1use glib::error::ErrorDomain;
6use glib::translate::*;
7use glib::value::FromValue;
8use glib::value::FromValueOptional;
9use glib::value::SetValue;
10use glib::value::Value;
11use glib::Quark;
12use glib::StaticType;
13use glib::Type;
14use gobject_sys;
15use gtk_sys;
16use std::fmt;
17
18#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
19pub enum Align {
20 Fill,
21 Start,
22 End,
23 Center,
24 Baseline,
25 #[doc(hidden)]
26 __Unknown(i32),
27}
28
29impl fmt::Display for Align {
30 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
31 write!(
32 f,
33 "Align::{}",
34 match *self {
35 Align::Fill => "Fill",
36 Align::Start => "Start",
37 Align::End => "End",
38 Align::Center => "Center",
39 Align::Baseline => "Baseline",
40 _ => "Unknown",
41 }
42 )
43 }
44}
45
46#[doc(hidden)]
47impl ToGlib for Align {
48 type GlibType = gtk_sys::GtkAlign;
49
50 fn to_glib(&self) -> gtk_sys::GtkAlign {
51 match *self {
52 Align::Fill => gtk_sys::GTK_ALIGN_FILL,
53 Align::Start => gtk_sys::GTK_ALIGN_START,
54 Align::End => gtk_sys::GTK_ALIGN_END,
55 Align::Center => gtk_sys::GTK_ALIGN_CENTER,
56 Align::Baseline => gtk_sys::GTK_ALIGN_BASELINE,
57 Align::__Unknown(value) => value,
58 }
59 }
60}
61
62#[doc(hidden)]
63impl FromGlib<gtk_sys::GtkAlign> for Align {
64 fn from_glib(value: gtk_sys::GtkAlign) -> Self {
65 skip_assert_initialized!();
66 match value {
67 0 => Align::Fill,
68 1 => Align::Start,
69 2 => Align::End,
70 3 => Align::Center,
71 4 => Align::Baseline,
72 value => Align::__Unknown(value),
73 }
74 }
75}
76
77impl StaticType for Align {
78 fn static_type() -> Type {
79 unsafe { from_glib(gtk_sys::gtk_align_get_type()) }
80 }
81}
82
83impl<'a> FromValueOptional<'a> for Align {
84 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
85 Some(FromValue::from_value(value))
86 }
87}
88
89impl<'a> FromValue<'a> for Align {
90 unsafe fn from_value(value: &Value) -> Self {
91 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
92 }
93}
94
95impl SetValue for Align {
96 unsafe fn set_value(value: &mut Value, this: &Self) {
97 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
98 }
99}
100
101#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
102pub enum ArrowType {
103 Up,
104 Down,
105 Left,
106 Right,
107 None,
108 #[doc(hidden)]
109 __Unknown(i32),
110}
111
112impl fmt::Display for ArrowType {
113 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
114 write!(
115 f,
116 "ArrowType::{}",
117 match *self {
118 ArrowType::Up => "Up",
119 ArrowType::Down => "Down",
120 ArrowType::Left => "Left",
121 ArrowType::Right => "Right",
122 ArrowType::None => "None",
123 _ => "Unknown",
124 }
125 )
126 }
127}
128
129#[doc(hidden)]
130impl ToGlib for ArrowType {
131 type GlibType = gtk_sys::GtkArrowType;
132
133 fn to_glib(&self) -> gtk_sys::GtkArrowType {
134 match *self {
135 ArrowType::Up => gtk_sys::GTK_ARROW_UP,
136 ArrowType::Down => gtk_sys::GTK_ARROW_DOWN,
137 ArrowType::Left => gtk_sys::GTK_ARROW_LEFT,
138 ArrowType::Right => gtk_sys::GTK_ARROW_RIGHT,
139 ArrowType::None => gtk_sys::GTK_ARROW_NONE,
140 ArrowType::__Unknown(value) => value,
141 }
142 }
143}
144
145#[doc(hidden)]
146impl FromGlib<gtk_sys::GtkArrowType> for ArrowType {
147 fn from_glib(value: gtk_sys::GtkArrowType) -> Self {
148 skip_assert_initialized!();
149 match value {
150 0 => ArrowType::Up,
151 1 => ArrowType::Down,
152 2 => ArrowType::Left,
153 3 => ArrowType::Right,
154 4 => ArrowType::None,
155 value => ArrowType::__Unknown(value),
156 }
157 }
158}
159
160impl StaticType for ArrowType {
161 fn static_type() -> Type {
162 unsafe { from_glib(gtk_sys::gtk_arrow_type_get_type()) }
163 }
164}
165
166impl<'a> FromValueOptional<'a> for ArrowType {
167 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
168 Some(FromValue::from_value(value))
169 }
170}
171
172impl<'a> FromValue<'a> for ArrowType {
173 unsafe fn from_value(value: &Value) -> Self {
174 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
175 }
176}
177
178impl SetValue for ArrowType {
179 unsafe fn set_value(value: &mut Value, this: &Self) {
180 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
181 }
182}
183
184#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
185pub enum AssistantPageType {
186 Content,
187 Intro,
188 Confirm,
189 Summary,
190 Progress,
191 Custom,
192 #[doc(hidden)]
193 __Unknown(i32),
194}
195
196impl fmt::Display for AssistantPageType {
197 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
198 write!(
199 f,
200 "AssistantPageType::{}",
201 match *self {
202 AssistantPageType::Content => "Content",
203 AssistantPageType::Intro => "Intro",
204 AssistantPageType::Confirm => "Confirm",
205 AssistantPageType::Summary => "Summary",
206 AssistantPageType::Progress => "Progress",
207 AssistantPageType::Custom => "Custom",
208 _ => "Unknown",
209 }
210 )
211 }
212}
213
214#[doc(hidden)]
215impl ToGlib for AssistantPageType {
216 type GlibType = gtk_sys::GtkAssistantPageType;
217
218 fn to_glib(&self) -> gtk_sys::GtkAssistantPageType {
219 match *self {
220 AssistantPageType::Content => gtk_sys::GTK_ASSISTANT_PAGE_CONTENT,
221 AssistantPageType::Intro => gtk_sys::GTK_ASSISTANT_PAGE_INTRO,
222 AssistantPageType::Confirm => gtk_sys::GTK_ASSISTANT_PAGE_CONFIRM,
223 AssistantPageType::Summary => gtk_sys::GTK_ASSISTANT_PAGE_SUMMARY,
224 AssistantPageType::Progress => gtk_sys::GTK_ASSISTANT_PAGE_PROGRESS,
225 AssistantPageType::Custom => gtk_sys::GTK_ASSISTANT_PAGE_CUSTOM,
226 AssistantPageType::__Unknown(value) => value,
227 }
228 }
229}
230
231#[doc(hidden)]
232impl FromGlib<gtk_sys::GtkAssistantPageType> for AssistantPageType {
233 fn from_glib(value: gtk_sys::GtkAssistantPageType) -> Self {
234 skip_assert_initialized!();
235 match value {
236 0 => AssistantPageType::Content,
237 1 => AssistantPageType::Intro,
238 2 => AssistantPageType::Confirm,
239 3 => AssistantPageType::Summary,
240 4 => AssistantPageType::Progress,
241 5 => AssistantPageType::Custom,
242 value => AssistantPageType::__Unknown(value),
243 }
244 }
245}
246
247impl StaticType for AssistantPageType {
248 fn static_type() -> Type {
249 unsafe { from_glib(gtk_sys::gtk_assistant_page_type_get_type()) }
250 }
251}
252
253impl<'a> FromValueOptional<'a> for AssistantPageType {
254 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
255 Some(FromValue::from_value(value))
256 }
257}
258
259impl<'a> FromValue<'a> for AssistantPageType {
260 unsafe fn from_value(value: &Value) -> Self {
261 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
262 }
263}
264
265impl SetValue for AssistantPageType {
266 unsafe fn set_value(value: &mut Value, this: &Self) {
267 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
268 }
269}
270
271#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
272pub enum BaselinePosition {
273 Top,
274 Center,
275 Bottom,
276 #[doc(hidden)]
277 __Unknown(i32),
278}
279
280impl fmt::Display for BaselinePosition {
281 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
282 write!(
283 f,
284 "BaselinePosition::{}",
285 match *self {
286 BaselinePosition::Top => "Top",
287 BaselinePosition::Center => "Center",
288 BaselinePosition::Bottom => "Bottom",
289 _ => "Unknown",
290 }
291 )
292 }
293}
294
295#[doc(hidden)]
296impl ToGlib for BaselinePosition {
297 type GlibType = gtk_sys::GtkBaselinePosition;
298
299 fn to_glib(&self) -> gtk_sys::GtkBaselinePosition {
300 match *self {
301 BaselinePosition::Top => gtk_sys::GTK_BASELINE_POSITION_TOP,
302 BaselinePosition::Center => gtk_sys::GTK_BASELINE_POSITION_CENTER,
303 BaselinePosition::Bottom => gtk_sys::GTK_BASELINE_POSITION_BOTTOM,
304 BaselinePosition::__Unknown(value) => value,
305 }
306 }
307}
308
309#[doc(hidden)]
310impl FromGlib<gtk_sys::GtkBaselinePosition> for BaselinePosition {
311 fn from_glib(value: gtk_sys::GtkBaselinePosition) -> Self {
312 skip_assert_initialized!();
313 match value {
314 0 => BaselinePosition::Top,
315 1 => BaselinePosition::Center,
316 2 => BaselinePosition::Bottom,
317 value => BaselinePosition::__Unknown(value),
318 }
319 }
320}
321
322impl StaticType for BaselinePosition {
323 fn static_type() -> Type {
324 unsafe { from_glib(gtk_sys::gtk_baseline_position_get_type()) }
325 }
326}
327
328impl<'a> FromValueOptional<'a> for BaselinePosition {
329 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
330 Some(FromValue::from_value(value))
331 }
332}
333
334impl<'a> FromValue<'a> for BaselinePosition {
335 unsafe fn from_value(value: &Value) -> Self {
336 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
337 }
338}
339
340impl SetValue for BaselinePosition {
341 unsafe fn set_value(value: &mut Value, this: &Self) {
342 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
343 }
344}
345
346#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
347pub enum BorderStyle {
348 None,
349 Solid,
350 Inset,
351 Outset,
352 Hidden,
353 Dotted,
354 Dashed,
355 Double,
356 Groove,
357 Ridge,
358 #[doc(hidden)]
359 __Unknown(i32),
360}
361
362impl fmt::Display for BorderStyle {
363 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
364 write!(
365 f,
366 "BorderStyle::{}",
367 match *self {
368 BorderStyle::None => "None",
369 BorderStyle::Solid => "Solid",
370 BorderStyle::Inset => "Inset",
371 BorderStyle::Outset => "Outset",
372 BorderStyle::Hidden => "Hidden",
373 BorderStyle::Dotted => "Dotted",
374 BorderStyle::Dashed => "Dashed",
375 BorderStyle::Double => "Double",
376 BorderStyle::Groove => "Groove",
377 BorderStyle::Ridge => "Ridge",
378 _ => "Unknown",
379 }
380 )
381 }
382}
383
384#[doc(hidden)]
385impl ToGlib for BorderStyle {
386 type GlibType = gtk_sys::GtkBorderStyle;
387
388 fn to_glib(&self) -> gtk_sys::GtkBorderStyle {
389 match *self {
390 BorderStyle::None => gtk_sys::GTK_BORDER_STYLE_NONE,
391 BorderStyle::Solid => gtk_sys::GTK_BORDER_STYLE_SOLID,
392 BorderStyle::Inset => gtk_sys::GTK_BORDER_STYLE_INSET,
393 BorderStyle::Outset => gtk_sys::GTK_BORDER_STYLE_OUTSET,
394 BorderStyle::Hidden => gtk_sys::GTK_BORDER_STYLE_HIDDEN,
395 BorderStyle::Dotted => gtk_sys::GTK_BORDER_STYLE_DOTTED,
396 BorderStyle::Dashed => gtk_sys::GTK_BORDER_STYLE_DASHED,
397 BorderStyle::Double => gtk_sys::GTK_BORDER_STYLE_DOUBLE,
398 BorderStyle::Groove => gtk_sys::GTK_BORDER_STYLE_GROOVE,
399 BorderStyle::Ridge => gtk_sys::GTK_BORDER_STYLE_RIDGE,
400 BorderStyle::__Unknown(value) => value,
401 }
402 }
403}
404
405#[doc(hidden)]
406impl FromGlib<gtk_sys::GtkBorderStyle> for BorderStyle {
407 fn from_glib(value: gtk_sys::GtkBorderStyle) -> Self {
408 skip_assert_initialized!();
409 match value {
410 0 => BorderStyle::None,
411 1 => BorderStyle::Solid,
412 2 => BorderStyle::Inset,
413 3 => BorderStyle::Outset,
414 4 => BorderStyle::Hidden,
415 5 => BorderStyle::Dotted,
416 6 => BorderStyle::Dashed,
417 7 => BorderStyle::Double,
418 8 => BorderStyle::Groove,
419 9 => BorderStyle::Ridge,
420 value => BorderStyle::__Unknown(value),
421 }
422 }
423}
424
425impl StaticType for BorderStyle {
426 fn static_type() -> Type {
427 unsafe { from_glib(gtk_sys::gtk_border_style_get_type()) }
428 }
429}
430
431impl<'a> FromValueOptional<'a> for BorderStyle {
432 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
433 Some(FromValue::from_value(value))
434 }
435}
436
437impl<'a> FromValue<'a> for BorderStyle {
438 unsafe fn from_value(value: &Value) -> Self {
439 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
440 }
441}
442
443impl SetValue for BorderStyle {
444 unsafe fn set_value(value: &mut Value, this: &Self) {
445 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
446 }
447}
448
449#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
450pub enum BuilderError {
451 InvalidTypeFunction,
452 UnhandledTag,
453 MissingAttribute,
454 InvalidAttribute,
455 InvalidTag,
456 MissingPropertyValue,
457 InvalidValue,
458 VersionMismatch,
459 DuplicateId,
460 ObjectTypeRefused,
461 TemplateMismatch,
462 InvalidProperty,
463 InvalidSignal,
464 InvalidId,
465 #[doc(hidden)]
466 __Unknown(i32),
467}
468
469impl fmt::Display for BuilderError {
470 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
471 write!(
472 f,
473 "BuilderError::{}",
474 match *self {
475 BuilderError::InvalidTypeFunction => "InvalidTypeFunction",
476 BuilderError::UnhandledTag => "UnhandledTag",
477 BuilderError::MissingAttribute => "MissingAttribute",
478 BuilderError::InvalidAttribute => "InvalidAttribute",
479 BuilderError::InvalidTag => "InvalidTag",
480 BuilderError::MissingPropertyValue => "MissingPropertyValue",
481 BuilderError::InvalidValue => "InvalidValue",
482 BuilderError::VersionMismatch => "VersionMismatch",
483 BuilderError::DuplicateId => "DuplicateId",
484 BuilderError::ObjectTypeRefused => "ObjectTypeRefused",
485 BuilderError::TemplateMismatch => "TemplateMismatch",
486 BuilderError::InvalidProperty => "InvalidProperty",
487 BuilderError::InvalidSignal => "InvalidSignal",
488 BuilderError::InvalidId => "InvalidId",
489 _ => "Unknown",
490 }
491 )
492 }
493}
494
495#[doc(hidden)]
496impl ToGlib for BuilderError {
497 type GlibType = gtk_sys::GtkBuilderError;
498
499 fn to_glib(&self) -> gtk_sys::GtkBuilderError {
500 match *self {
501 BuilderError::InvalidTypeFunction => gtk_sys::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
502 BuilderError::UnhandledTag => gtk_sys::GTK_BUILDER_ERROR_UNHANDLED_TAG,
503 BuilderError::MissingAttribute => gtk_sys::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
504 BuilderError::InvalidAttribute => gtk_sys::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
505 BuilderError::InvalidTag => gtk_sys::GTK_BUILDER_ERROR_INVALID_TAG,
506 BuilderError::MissingPropertyValue => gtk_sys::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
507 BuilderError::InvalidValue => gtk_sys::GTK_BUILDER_ERROR_INVALID_VALUE,
508 BuilderError::VersionMismatch => gtk_sys::GTK_BUILDER_ERROR_VERSION_MISMATCH,
509 BuilderError::DuplicateId => gtk_sys::GTK_BUILDER_ERROR_DUPLICATE_ID,
510 BuilderError::ObjectTypeRefused => gtk_sys::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
511 BuilderError::TemplateMismatch => gtk_sys::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
512 BuilderError::InvalidProperty => gtk_sys::GTK_BUILDER_ERROR_INVALID_PROPERTY,
513 BuilderError::InvalidSignal => gtk_sys::GTK_BUILDER_ERROR_INVALID_SIGNAL,
514 BuilderError::InvalidId => gtk_sys::GTK_BUILDER_ERROR_INVALID_ID,
515 BuilderError::__Unknown(value) => value,
516 }
517 }
518}
519
520#[doc(hidden)]
521impl FromGlib<gtk_sys::GtkBuilderError> for BuilderError {
522 fn from_glib(value: gtk_sys::GtkBuilderError) -> Self {
523 skip_assert_initialized!();
524 match value {
525 0 => BuilderError::InvalidTypeFunction,
526 1 => BuilderError::UnhandledTag,
527 2 => BuilderError::MissingAttribute,
528 3 => BuilderError::InvalidAttribute,
529 4 => BuilderError::InvalidTag,
530 5 => BuilderError::MissingPropertyValue,
531 6 => BuilderError::InvalidValue,
532 7 => BuilderError::VersionMismatch,
533 8 => BuilderError::DuplicateId,
534 9 => BuilderError::ObjectTypeRefused,
535 10 => BuilderError::TemplateMismatch,
536 11 => BuilderError::InvalidProperty,
537 12 => BuilderError::InvalidSignal,
538 13 => BuilderError::InvalidId,
539 value => BuilderError::__Unknown(value),
540 }
541 }
542}
543
544impl ErrorDomain for BuilderError {
545 fn domain() -> Quark {
546 skip_assert_initialized!();
547 unsafe { from_glib(gtk_sys::gtk_builder_error_quark()) }
548 }
549
550 fn code(self) -> i32 {
551 self.to_glib()
552 }
553
554 fn from(code: i32) -> Option<Self> {
555 skip_assert_initialized!();
556 match code {
557 0 => Some(BuilderError::InvalidTypeFunction),
558 1 => Some(BuilderError::UnhandledTag),
559 2 => Some(BuilderError::MissingAttribute),
560 3 => Some(BuilderError::InvalidAttribute),
561 4 => Some(BuilderError::InvalidTag),
562 5 => Some(BuilderError::MissingPropertyValue),
563 6 => Some(BuilderError::InvalidValue),
564 7 => Some(BuilderError::VersionMismatch),
565 8 => Some(BuilderError::DuplicateId),
566 9 => Some(BuilderError::ObjectTypeRefused),
567 10 => Some(BuilderError::TemplateMismatch),
568 11 => Some(BuilderError::InvalidProperty),
569 12 => Some(BuilderError::InvalidSignal),
570 13 => Some(BuilderError::InvalidId),
571 value => Some(BuilderError::__Unknown(value)),
572 }
573 }
574}
575
576impl StaticType for BuilderError {
577 fn static_type() -> Type {
578 unsafe { from_glib(gtk_sys::gtk_builder_error_get_type()) }
579 }
580}
581
582impl<'a> FromValueOptional<'a> for BuilderError {
583 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
584 Some(FromValue::from_value(value))
585 }
586}
587
588impl<'a> FromValue<'a> for BuilderError {
589 unsafe fn from_value(value: &Value) -> Self {
590 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
591 }
592}
593
594impl SetValue for BuilderError {
595 unsafe fn set_value(value: &mut Value, this: &Self) {
596 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
597 }
598}
599
600#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
601pub enum ButtonBoxStyle {
602 Spread,
603 Edge,
604 Start,
605 End,
606 Center,
607 Expand,
608 #[doc(hidden)]
609 __Unknown(i32),
610}
611
612impl fmt::Display for ButtonBoxStyle {
613 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
614 write!(
615 f,
616 "ButtonBoxStyle::{}",
617 match *self {
618 ButtonBoxStyle::Spread => "Spread",
619 ButtonBoxStyle::Edge => "Edge",
620 ButtonBoxStyle::Start => "Start",
621 ButtonBoxStyle::End => "End",
622 ButtonBoxStyle::Center => "Center",
623 ButtonBoxStyle::Expand => "Expand",
624 _ => "Unknown",
625 }
626 )
627 }
628}
629
630#[doc(hidden)]
631impl ToGlib for ButtonBoxStyle {
632 type GlibType = gtk_sys::GtkButtonBoxStyle;
633
634 fn to_glib(&self) -> gtk_sys::GtkButtonBoxStyle {
635 match *self {
636 ButtonBoxStyle::Spread => gtk_sys::GTK_BUTTONBOX_SPREAD,
637 ButtonBoxStyle::Edge => gtk_sys::GTK_BUTTONBOX_EDGE,
638 ButtonBoxStyle::Start => gtk_sys::GTK_BUTTONBOX_START,
639 ButtonBoxStyle::End => gtk_sys::GTK_BUTTONBOX_END,
640 ButtonBoxStyle::Center => gtk_sys::GTK_BUTTONBOX_CENTER,
641 ButtonBoxStyle::Expand => gtk_sys::GTK_BUTTONBOX_EXPAND,
642 ButtonBoxStyle::__Unknown(value) => value,
643 }
644 }
645}
646
647#[doc(hidden)]
648impl FromGlib<gtk_sys::GtkButtonBoxStyle> for ButtonBoxStyle {
649 fn from_glib(value: gtk_sys::GtkButtonBoxStyle) -> Self {
650 skip_assert_initialized!();
651 match value {
652 1 => ButtonBoxStyle::Spread,
653 2 => ButtonBoxStyle::Edge,
654 3 => ButtonBoxStyle::Start,
655 4 => ButtonBoxStyle::End,
656 5 => ButtonBoxStyle::Center,
657 6 => ButtonBoxStyle::Expand,
658 value => ButtonBoxStyle::__Unknown(value),
659 }
660 }
661}
662
663impl StaticType for ButtonBoxStyle {
664 fn static_type() -> Type {
665 unsafe { from_glib(gtk_sys::gtk_button_box_style_get_type()) }
666 }
667}
668
669impl<'a> FromValueOptional<'a> for ButtonBoxStyle {
670 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
671 Some(FromValue::from_value(value))
672 }
673}
674
675impl<'a> FromValue<'a> for ButtonBoxStyle {
676 unsafe fn from_value(value: &Value) -> Self {
677 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
678 }
679}
680
681impl SetValue for ButtonBoxStyle {
682 unsafe fn set_value(value: &mut Value, this: &Self) {
683 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
684 }
685}
686
687#[cfg(any(feature = "v3_16", feature = "dox"))]
688#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
689pub enum ButtonRole {
690 Normal,
691 Check,
692 Radio,
693 #[doc(hidden)]
694 __Unknown(i32),
695}
696
697#[cfg(any(feature = "v3_16", feature = "dox"))]
698impl fmt::Display for ButtonRole {
699 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
700 write!(
701 f,
702 "ButtonRole::{}",
703 match *self {
704 ButtonRole::Normal => "Normal",
705 ButtonRole::Check => "Check",
706 ButtonRole::Radio => "Radio",
707 _ => "Unknown",
708 }
709 )
710 }
711}
712
713#[cfg(any(feature = "v3_16", feature = "dox"))]
714#[doc(hidden)]
715impl ToGlib for ButtonRole {
716 type GlibType = gtk_sys::GtkButtonRole;
717
718 fn to_glib(&self) -> gtk_sys::GtkButtonRole {
719 match *self {
720 ButtonRole::Normal => gtk_sys::GTK_BUTTON_ROLE_NORMAL,
721 ButtonRole::Check => gtk_sys::GTK_BUTTON_ROLE_CHECK,
722 ButtonRole::Radio => gtk_sys::GTK_BUTTON_ROLE_RADIO,
723 ButtonRole::__Unknown(value) => value,
724 }
725 }
726}
727
728#[cfg(any(feature = "v3_16", feature = "dox"))]
729#[doc(hidden)]
730impl FromGlib<gtk_sys::GtkButtonRole> for ButtonRole {
731 fn from_glib(value: gtk_sys::GtkButtonRole) -> Self {
732 skip_assert_initialized!();
733 match value {
734 0 => ButtonRole::Normal,
735 1 => ButtonRole::Check,
736 2 => ButtonRole::Radio,
737 value => ButtonRole::__Unknown(value),
738 }
739 }
740}
741
742#[cfg(any(feature = "v3_16", feature = "dox"))]
743impl StaticType for ButtonRole {
744 fn static_type() -> Type {
745 unsafe { from_glib(gtk_sys::gtk_button_role_get_type()) }
746 }
747}
748
749#[cfg(any(feature = "v3_16", feature = "dox"))]
750impl<'a> FromValueOptional<'a> for ButtonRole {
751 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
752 Some(FromValue::from_value(value))
753 }
754}
755
756#[cfg(any(feature = "v3_16", feature = "dox"))]
757impl<'a> FromValue<'a> for ButtonRole {
758 unsafe fn from_value(value: &Value) -> Self {
759 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
760 }
761}
762
763#[cfg(any(feature = "v3_16", feature = "dox"))]
764impl SetValue for ButtonRole {
765 unsafe fn set_value(value: &mut Value, this: &Self) {
766 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
767 }
768}
769
770#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
771pub enum ButtonsType {
772 None,
773 Ok,
774 Close,
775 Cancel,
776 YesNo,
777 OkCancel,
778 #[doc(hidden)]
779 __Unknown(i32),
780}
781
782impl fmt::Display for ButtonsType {
783 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
784 write!(
785 f,
786 "ButtonsType::{}",
787 match *self {
788 ButtonsType::None => "None",
789 ButtonsType::Ok => "Ok",
790 ButtonsType::Close => "Close",
791 ButtonsType::Cancel => "Cancel",
792 ButtonsType::YesNo => "YesNo",
793 ButtonsType::OkCancel => "OkCancel",
794 _ => "Unknown",
795 }
796 )
797 }
798}
799
800#[doc(hidden)]
801impl ToGlib for ButtonsType {
802 type GlibType = gtk_sys::GtkButtonsType;
803
804 fn to_glib(&self) -> gtk_sys::GtkButtonsType {
805 match *self {
806 ButtonsType::None => gtk_sys::GTK_BUTTONS_NONE,
807 ButtonsType::Ok => gtk_sys::GTK_BUTTONS_OK,
808 ButtonsType::Close => gtk_sys::GTK_BUTTONS_CLOSE,
809 ButtonsType::Cancel => gtk_sys::GTK_BUTTONS_CANCEL,
810 ButtonsType::YesNo => gtk_sys::GTK_BUTTONS_YES_NO,
811 ButtonsType::OkCancel => gtk_sys::GTK_BUTTONS_OK_CANCEL,
812 ButtonsType::__Unknown(value) => value,
813 }
814 }
815}
816
817#[doc(hidden)]
818impl FromGlib<gtk_sys::GtkButtonsType> for ButtonsType {
819 fn from_glib(value: gtk_sys::GtkButtonsType) -> Self {
820 skip_assert_initialized!();
821 match value {
822 0 => ButtonsType::None,
823 1 => ButtonsType::Ok,
824 2 => ButtonsType::Close,
825 3 => ButtonsType::Cancel,
826 4 => ButtonsType::YesNo,
827 5 => ButtonsType::OkCancel,
828 value => ButtonsType::__Unknown(value),
829 }
830 }
831}
832
833impl StaticType for ButtonsType {
834 fn static_type() -> Type {
835 unsafe { from_glib(gtk_sys::gtk_buttons_type_get_type()) }
836 }
837}
838
839impl<'a> FromValueOptional<'a> for ButtonsType {
840 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
841 Some(FromValue::from_value(value))
842 }
843}
844
845impl<'a> FromValue<'a> for ButtonsType {
846 unsafe fn from_value(value: &Value) -> Self {
847 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
848 }
849}
850
851impl SetValue for ButtonsType {
852 unsafe fn set_value(value: &mut Value, this: &Self) {
853 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
854 }
855}
856
857#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
858pub enum CellRendererAccelMode {
859 Gtk,
860 Other,
861 ModifierTap,
862 #[doc(hidden)]
863 __Unknown(i32),
864}
865
866impl fmt::Display for CellRendererAccelMode {
867 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
868 write!(
869 f,
870 "CellRendererAccelMode::{}",
871 match *self {
872 CellRendererAccelMode::Gtk => "Gtk",
873 CellRendererAccelMode::Other => "Other",
874 CellRendererAccelMode::ModifierTap => "ModifierTap",
875 _ => "Unknown",
876 }
877 )
878 }
879}
880
881#[doc(hidden)]
882impl ToGlib for CellRendererAccelMode {
883 type GlibType = gtk_sys::GtkCellRendererAccelMode;
884
885 fn to_glib(&self) -> gtk_sys::GtkCellRendererAccelMode {
886 match *self {
887 CellRendererAccelMode::Gtk => gtk_sys::GTK_CELL_RENDERER_ACCEL_MODE_GTK,
888 CellRendererAccelMode::Other => gtk_sys::GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
889 CellRendererAccelMode::ModifierTap => {
890 gtk_sys::GTK_CELL_RENDERER_ACCEL_MODE_MODIFIER_TAP
891 }
892 CellRendererAccelMode::__Unknown(value) => value,
893 }
894 }
895}
896
897#[doc(hidden)]
898impl FromGlib<gtk_sys::GtkCellRendererAccelMode> for CellRendererAccelMode {
899 fn from_glib(value: gtk_sys::GtkCellRendererAccelMode) -> Self {
900 skip_assert_initialized!();
901 match value {
902 0 => CellRendererAccelMode::Gtk,
903 1 => CellRendererAccelMode::Other,
904 2 => CellRendererAccelMode::ModifierTap,
905 value => CellRendererAccelMode::__Unknown(value),
906 }
907 }
908}
909
910impl StaticType for CellRendererAccelMode {
911 fn static_type() -> Type {
912 unsafe { from_glib(gtk_sys::gtk_cell_renderer_accel_mode_get_type()) }
913 }
914}
915
916impl<'a> FromValueOptional<'a> for CellRendererAccelMode {
917 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
918 Some(FromValue::from_value(value))
919 }
920}
921
922impl<'a> FromValue<'a> for CellRendererAccelMode {
923 unsafe fn from_value(value: &Value) -> Self {
924 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
925 }
926}
927
928impl SetValue for CellRendererAccelMode {
929 unsafe fn set_value(value: &mut Value, this: &Self) {
930 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
931 }
932}
933
934#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
935pub enum CellRendererMode {
936 Inert,
937 Activatable,
938 Editable,
939 #[doc(hidden)]
940 __Unknown(i32),
941}
942
943impl fmt::Display for CellRendererMode {
944 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
945 write!(
946 f,
947 "CellRendererMode::{}",
948 match *self {
949 CellRendererMode::Inert => "Inert",
950 CellRendererMode::Activatable => "Activatable",
951 CellRendererMode::Editable => "Editable",
952 _ => "Unknown",
953 }
954 )
955 }
956}
957
958#[doc(hidden)]
959impl ToGlib for CellRendererMode {
960 type GlibType = gtk_sys::GtkCellRendererMode;
961
962 fn to_glib(&self) -> gtk_sys::GtkCellRendererMode {
963 match *self {
964 CellRendererMode::Inert => gtk_sys::GTK_CELL_RENDERER_MODE_INERT,
965 CellRendererMode::Activatable => gtk_sys::GTK_CELL_RENDERER_MODE_ACTIVATABLE,
966 CellRendererMode::Editable => gtk_sys::GTK_CELL_RENDERER_MODE_EDITABLE,
967 CellRendererMode::__Unknown(value) => value,
968 }
969 }
970}
971
972#[doc(hidden)]
973impl FromGlib<gtk_sys::GtkCellRendererMode> for CellRendererMode {
974 fn from_glib(value: gtk_sys::GtkCellRendererMode) -> Self {
975 skip_assert_initialized!();
976 match value {
977 0 => CellRendererMode::Inert,
978 1 => CellRendererMode::Activatable,
979 2 => CellRendererMode::Editable,
980 value => CellRendererMode::__Unknown(value),
981 }
982 }
983}
984
985impl StaticType for CellRendererMode {
986 fn static_type() -> Type {
987 unsafe { from_glib(gtk_sys::gtk_cell_renderer_mode_get_type()) }
988 }
989}
990
991impl<'a> FromValueOptional<'a> for CellRendererMode {
992 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
993 Some(FromValue::from_value(value))
994 }
995}
996
997impl<'a> FromValue<'a> for CellRendererMode {
998 unsafe fn from_value(value: &Value) -> Self {
999 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1000 }
1001}
1002
1003impl SetValue for CellRendererMode {
1004 unsafe fn set_value(value: &mut Value, this: &Self) {
1005 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1006 }
1007}
1008
1009#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1010pub enum CornerType {
1011 TopLeft,
1012 BottomLeft,
1013 TopRight,
1014 BottomRight,
1015 #[doc(hidden)]
1016 __Unknown(i32),
1017}
1018
1019impl fmt::Display for CornerType {
1020 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1021 write!(
1022 f,
1023 "CornerType::{}",
1024 match *self {
1025 CornerType::TopLeft => "TopLeft",
1026 CornerType::BottomLeft => "BottomLeft",
1027 CornerType::TopRight => "TopRight",
1028 CornerType::BottomRight => "BottomRight",
1029 _ => "Unknown",
1030 }
1031 )
1032 }
1033}
1034
1035#[doc(hidden)]
1036impl ToGlib for CornerType {
1037 type GlibType = gtk_sys::GtkCornerType;
1038
1039 fn to_glib(&self) -> gtk_sys::GtkCornerType {
1040 match *self {
1041 CornerType::TopLeft => gtk_sys::GTK_CORNER_TOP_LEFT,
1042 CornerType::BottomLeft => gtk_sys::GTK_CORNER_BOTTOM_LEFT,
1043 CornerType::TopRight => gtk_sys::GTK_CORNER_TOP_RIGHT,
1044 CornerType::BottomRight => gtk_sys::GTK_CORNER_BOTTOM_RIGHT,
1045 CornerType::__Unknown(value) => value,
1046 }
1047 }
1048}
1049
1050#[doc(hidden)]
1051impl FromGlib<gtk_sys::GtkCornerType> for CornerType {
1052 fn from_glib(value: gtk_sys::GtkCornerType) -> Self {
1053 skip_assert_initialized!();
1054 match value {
1055 0 => CornerType::TopLeft,
1056 1 => CornerType::BottomLeft,
1057 2 => CornerType::TopRight,
1058 3 => CornerType::BottomRight,
1059 value => CornerType::__Unknown(value),
1060 }
1061 }
1062}
1063
1064impl StaticType for CornerType {
1065 fn static_type() -> Type {
1066 unsafe { from_glib(gtk_sys::gtk_corner_type_get_type()) }
1067 }
1068}
1069
1070impl<'a> FromValueOptional<'a> for CornerType {
1071 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1072 Some(FromValue::from_value(value))
1073 }
1074}
1075
1076impl<'a> FromValue<'a> for CornerType {
1077 unsafe fn from_value(value: &Value) -> Self {
1078 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1079 }
1080}
1081
1082impl SetValue for CornerType {
1083 unsafe fn set_value(value: &mut Value, this: &Self) {
1084 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1085 }
1086}
1087
1088#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1089pub enum CssProviderError {
1090 Failed,
1091 Syntax,
1092 Import,
1093 Name,
1094 Deprecated,
1095 UnknownValue,
1096 #[doc(hidden)]
1097 __Unknown(i32),
1098}
1099
1100impl fmt::Display for CssProviderError {
1101 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1102 write!(
1103 f,
1104 "CssProviderError::{}",
1105 match *self {
1106 CssProviderError::Failed => "Failed",
1107 CssProviderError::Syntax => "Syntax",
1108 CssProviderError::Import => "Import",
1109 CssProviderError::Name => "Name",
1110 CssProviderError::Deprecated => "Deprecated",
1111 CssProviderError::UnknownValue => "UnknownValue",
1112 _ => "Unknown",
1113 }
1114 )
1115 }
1116}
1117
1118#[doc(hidden)]
1119impl ToGlib for CssProviderError {
1120 type GlibType = gtk_sys::GtkCssProviderError;
1121
1122 fn to_glib(&self) -> gtk_sys::GtkCssProviderError {
1123 match *self {
1124 CssProviderError::Failed => gtk_sys::GTK_CSS_PROVIDER_ERROR_FAILED,
1125 CssProviderError::Syntax => gtk_sys::GTK_CSS_PROVIDER_ERROR_SYNTAX,
1126 CssProviderError::Import => gtk_sys::GTK_CSS_PROVIDER_ERROR_IMPORT,
1127 CssProviderError::Name => gtk_sys::GTK_CSS_PROVIDER_ERROR_NAME,
1128 CssProviderError::Deprecated => gtk_sys::GTK_CSS_PROVIDER_ERROR_DEPRECATED,
1129 CssProviderError::UnknownValue => gtk_sys::GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE,
1130 CssProviderError::__Unknown(value) => value,
1131 }
1132 }
1133}
1134
1135#[doc(hidden)]
1136impl FromGlib<gtk_sys::GtkCssProviderError> for CssProviderError {
1137 fn from_glib(value: gtk_sys::GtkCssProviderError) -> Self {
1138 skip_assert_initialized!();
1139 match value {
1140 0 => CssProviderError::Failed,
1141 1 => CssProviderError::Syntax,
1142 2 => CssProviderError::Import,
1143 3 => CssProviderError::Name,
1144 4 => CssProviderError::Deprecated,
1145 5 => CssProviderError::UnknownValue,
1146 value => CssProviderError::__Unknown(value),
1147 }
1148 }
1149}
1150
1151impl ErrorDomain for CssProviderError {
1152 fn domain() -> Quark {
1153 skip_assert_initialized!();
1154 unsafe { from_glib(gtk_sys::gtk_css_provider_error_quark()) }
1155 }
1156
1157 fn code(self) -> i32 {
1158 self.to_glib()
1159 }
1160
1161 fn from(code: i32) -> Option<Self> {
1162 skip_assert_initialized!();
1163 match code {
1164 0 => Some(CssProviderError::Failed),
1165 1 => Some(CssProviderError::Syntax),
1166 2 => Some(CssProviderError::Import),
1167 3 => Some(CssProviderError::Name),
1168 4 => Some(CssProviderError::Deprecated),
1169 5 => Some(CssProviderError::UnknownValue),
1170 _ => Some(CssProviderError::Failed),
1171 }
1172 }
1173}
1174
1175impl StaticType for CssProviderError {
1176 fn static_type() -> Type {
1177 unsafe { from_glib(gtk_sys::gtk_css_provider_error_get_type()) }
1178 }
1179}
1180
1181impl<'a> FromValueOptional<'a> for CssProviderError {
1182 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1183 Some(FromValue::from_value(value))
1184 }
1185}
1186
1187impl<'a> FromValue<'a> for CssProviderError {
1188 unsafe fn from_value(value: &Value) -> Self {
1189 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1190 }
1191}
1192
1193impl SetValue for CssProviderError {
1194 unsafe fn set_value(value: &mut Value, this: &Self) {
1195 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1196 }
1197}
1198
1199#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1200pub enum CssSectionType {
1201 Document,
1202 Import,
1203 ColorDefinition,
1204 BindingSet,
1205 Ruleset,
1206 Selector,
1207 Declaration,
1208 Value,
1209 Keyframes,
1210 #[doc(hidden)]
1211 __Unknown(i32),
1212}
1213
1214impl fmt::Display for CssSectionType {
1215 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1216 write!(
1217 f,
1218 "CssSectionType::{}",
1219 match *self {
1220 CssSectionType::Document => "Document",
1221 CssSectionType::Import => "Import",
1222 CssSectionType::ColorDefinition => "ColorDefinition",
1223 CssSectionType::BindingSet => "BindingSet",
1224 CssSectionType::Ruleset => "Ruleset",
1225 CssSectionType::Selector => "Selector",
1226 CssSectionType::Declaration => "Declaration",
1227 CssSectionType::Value => "Value",
1228 CssSectionType::Keyframes => "Keyframes",
1229 _ => "Unknown",
1230 }
1231 )
1232 }
1233}
1234
1235#[doc(hidden)]
1236impl ToGlib for CssSectionType {
1237 type GlibType = gtk_sys::GtkCssSectionType;
1238
1239 fn to_glib(&self) -> gtk_sys::GtkCssSectionType {
1240 match *self {
1241 CssSectionType::Document => gtk_sys::GTK_CSS_SECTION_DOCUMENT,
1242 CssSectionType::Import => gtk_sys::GTK_CSS_SECTION_IMPORT,
1243 CssSectionType::ColorDefinition => gtk_sys::GTK_CSS_SECTION_COLOR_DEFINITION,
1244 CssSectionType::BindingSet => gtk_sys::GTK_CSS_SECTION_BINDING_SET,
1245 CssSectionType::Ruleset => gtk_sys::GTK_CSS_SECTION_RULESET,
1246 CssSectionType::Selector => gtk_sys::GTK_CSS_SECTION_SELECTOR,
1247 CssSectionType::Declaration => gtk_sys::GTK_CSS_SECTION_DECLARATION,
1248 CssSectionType::Value => gtk_sys::GTK_CSS_SECTION_VALUE,
1249 CssSectionType::Keyframes => gtk_sys::GTK_CSS_SECTION_KEYFRAMES,
1250 CssSectionType::__Unknown(value) => value,
1251 }
1252 }
1253}
1254
1255#[doc(hidden)]
1256impl FromGlib<gtk_sys::GtkCssSectionType> for CssSectionType {
1257 fn from_glib(value: gtk_sys::GtkCssSectionType) -> Self {
1258 skip_assert_initialized!();
1259 match value {
1260 0 => CssSectionType::Document,
1261 1 => CssSectionType::Import,
1262 2 => CssSectionType::ColorDefinition,
1263 3 => CssSectionType::BindingSet,
1264 4 => CssSectionType::Ruleset,
1265 5 => CssSectionType::Selector,
1266 6 => CssSectionType::Declaration,
1267 7 => CssSectionType::Value,
1268 8 => CssSectionType::Keyframes,
1269 value => CssSectionType::__Unknown(value),
1270 }
1271 }
1272}
1273
1274impl StaticType for CssSectionType {
1275 fn static_type() -> Type {
1276 unsafe { from_glib(gtk_sys::gtk_css_section_type_get_type()) }
1277 }
1278}
1279
1280impl<'a> FromValueOptional<'a> for CssSectionType {
1281 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1282 Some(FromValue::from_value(value))
1283 }
1284}
1285
1286impl<'a> FromValue<'a> for CssSectionType {
1287 unsafe fn from_value(value: &Value) -> Self {
1288 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1289 }
1290}
1291
1292impl SetValue for CssSectionType {
1293 unsafe fn set_value(value: &mut Value, this: &Self) {
1294 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1295 }
1296}
1297
1298#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1299pub enum DeleteType {
1300 Chars,
1301 WordEnds,
1302 Words,
1303 DisplayLines,
1304 DisplayLineEnds,
1305 ParagraphEnds,
1306 Paragraphs,
1307 Whitespace,
1308 #[doc(hidden)]
1309 __Unknown(i32),
1310}
1311
1312impl fmt::Display for DeleteType {
1313 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1314 write!(
1315 f,
1316 "DeleteType::{}",
1317 match *self {
1318 DeleteType::Chars => "Chars",
1319 DeleteType::WordEnds => "WordEnds",
1320 DeleteType::Words => "Words",
1321 DeleteType::DisplayLines => "DisplayLines",
1322 DeleteType::DisplayLineEnds => "DisplayLineEnds",
1323 DeleteType::ParagraphEnds => "ParagraphEnds",
1324 DeleteType::Paragraphs => "Paragraphs",
1325 DeleteType::Whitespace => "Whitespace",
1326 _ => "Unknown",
1327 }
1328 )
1329 }
1330}
1331
1332#[doc(hidden)]
1333impl ToGlib for DeleteType {
1334 type GlibType = gtk_sys::GtkDeleteType;
1335
1336 fn to_glib(&self) -> gtk_sys::GtkDeleteType {
1337 match *self {
1338 DeleteType::Chars => gtk_sys::GTK_DELETE_CHARS,
1339 DeleteType::WordEnds => gtk_sys::GTK_DELETE_WORD_ENDS,
1340 DeleteType::Words => gtk_sys::GTK_DELETE_WORDS,
1341 DeleteType::DisplayLines => gtk_sys::GTK_DELETE_DISPLAY_LINES,
1342 DeleteType::DisplayLineEnds => gtk_sys::GTK_DELETE_DISPLAY_LINE_ENDS,
1343 DeleteType::ParagraphEnds => gtk_sys::GTK_DELETE_PARAGRAPH_ENDS,
1344 DeleteType::Paragraphs => gtk_sys::GTK_DELETE_PARAGRAPHS,
1345 DeleteType::Whitespace => gtk_sys::GTK_DELETE_WHITESPACE,
1346 DeleteType::__Unknown(value) => value,
1347 }
1348 }
1349}
1350
1351#[doc(hidden)]
1352impl FromGlib<gtk_sys::GtkDeleteType> for DeleteType {
1353 fn from_glib(value: gtk_sys::GtkDeleteType) -> Self {
1354 skip_assert_initialized!();
1355 match value {
1356 0 => DeleteType::Chars,
1357 1 => DeleteType::WordEnds,
1358 2 => DeleteType::Words,
1359 3 => DeleteType::DisplayLines,
1360 4 => DeleteType::DisplayLineEnds,
1361 5 => DeleteType::ParagraphEnds,
1362 6 => DeleteType::Paragraphs,
1363 7 => DeleteType::Whitespace,
1364 value => DeleteType::__Unknown(value),
1365 }
1366 }
1367}
1368
1369impl StaticType for DeleteType {
1370 fn static_type() -> Type {
1371 unsafe { from_glib(gtk_sys::gtk_delete_type_get_type()) }
1372 }
1373}
1374
1375impl<'a> FromValueOptional<'a> for DeleteType {
1376 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1377 Some(FromValue::from_value(value))
1378 }
1379}
1380
1381impl<'a> FromValue<'a> for DeleteType {
1382 unsafe fn from_value(value: &Value) -> Self {
1383 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1384 }
1385}
1386
1387impl SetValue for DeleteType {
1388 unsafe fn set_value(value: &mut Value, this: &Self) {
1389 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1390 }
1391}
1392
1393#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1394pub enum DirectionType {
1395 TabForward,
1396 TabBackward,
1397 Up,
1398 Down,
1399 Left,
1400 Right,
1401 #[doc(hidden)]
1402 __Unknown(i32),
1403}
1404
1405impl fmt::Display for DirectionType {
1406 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1407 write!(
1408 f,
1409 "DirectionType::{}",
1410 match *self {
1411 DirectionType::TabForward => "TabForward",
1412 DirectionType::TabBackward => "TabBackward",
1413 DirectionType::Up => "Up",
1414 DirectionType::Down => "Down",
1415 DirectionType::Left => "Left",
1416 DirectionType::Right => "Right",
1417 _ => "Unknown",
1418 }
1419 )
1420 }
1421}
1422
1423#[doc(hidden)]
1424impl ToGlib for DirectionType {
1425 type GlibType = gtk_sys::GtkDirectionType;
1426
1427 fn to_glib(&self) -> gtk_sys::GtkDirectionType {
1428 match *self {
1429 DirectionType::TabForward => gtk_sys::GTK_DIR_TAB_FORWARD,
1430 DirectionType::TabBackward => gtk_sys::GTK_DIR_TAB_BACKWARD,
1431 DirectionType::Up => gtk_sys::GTK_DIR_UP,
1432 DirectionType::Down => gtk_sys::GTK_DIR_DOWN,
1433 DirectionType::Left => gtk_sys::GTK_DIR_LEFT,
1434 DirectionType::Right => gtk_sys::GTK_DIR_RIGHT,
1435 DirectionType::__Unknown(value) => value,
1436 }
1437 }
1438}
1439
1440#[doc(hidden)]
1441impl FromGlib<gtk_sys::GtkDirectionType> for DirectionType {
1442 fn from_glib(value: gtk_sys::GtkDirectionType) -> Self {
1443 skip_assert_initialized!();
1444 match value {
1445 0 => DirectionType::TabForward,
1446 1 => DirectionType::TabBackward,
1447 2 => DirectionType::Up,
1448 3 => DirectionType::Down,
1449 4 => DirectionType::Left,
1450 5 => DirectionType::Right,
1451 value => DirectionType::__Unknown(value),
1452 }
1453 }
1454}
1455
1456impl StaticType for DirectionType {
1457 fn static_type() -> Type {
1458 unsafe { from_glib(gtk_sys::gtk_direction_type_get_type()) }
1459 }
1460}
1461
1462impl<'a> FromValueOptional<'a> for DirectionType {
1463 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1464 Some(FromValue::from_value(value))
1465 }
1466}
1467
1468impl<'a> FromValue<'a> for DirectionType {
1469 unsafe fn from_value(value: &Value) -> Self {
1470 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1471 }
1472}
1473
1474impl SetValue for DirectionType {
1475 unsafe fn set_value(value: &mut Value, this: &Self) {
1476 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1477 }
1478}
1479
1480#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1481pub enum DragResult {
1482 Success,
1483 NoTarget,
1484 UserCancelled,
1485 TimeoutExpired,
1486 GrabBroken,
1487 Error,
1488 #[doc(hidden)]
1489 __Unknown(i32),
1490}
1491
1492impl fmt::Display for DragResult {
1493 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1494 write!(
1495 f,
1496 "DragResult::{}",
1497 match *self {
1498 DragResult::Success => "Success",
1499 DragResult::NoTarget => "NoTarget",
1500 DragResult::UserCancelled => "UserCancelled",
1501 DragResult::TimeoutExpired => "TimeoutExpired",
1502 DragResult::GrabBroken => "GrabBroken",
1503 DragResult::Error => "Error",
1504 _ => "Unknown",
1505 }
1506 )
1507 }
1508}
1509
1510#[doc(hidden)]
1511impl ToGlib for DragResult {
1512 type GlibType = gtk_sys::GtkDragResult;
1513
1514 fn to_glib(&self) -> gtk_sys::GtkDragResult {
1515 match *self {
1516 DragResult::Success => gtk_sys::GTK_DRAG_RESULT_SUCCESS,
1517 DragResult::NoTarget => gtk_sys::GTK_DRAG_RESULT_NO_TARGET,
1518 DragResult::UserCancelled => gtk_sys::GTK_DRAG_RESULT_USER_CANCELLED,
1519 DragResult::TimeoutExpired => gtk_sys::GTK_DRAG_RESULT_TIMEOUT_EXPIRED,
1520 DragResult::GrabBroken => gtk_sys::GTK_DRAG_RESULT_GRAB_BROKEN,
1521 DragResult::Error => gtk_sys::GTK_DRAG_RESULT_ERROR,
1522 DragResult::__Unknown(value) => value,
1523 }
1524 }
1525}
1526
1527#[doc(hidden)]
1528impl FromGlib<gtk_sys::GtkDragResult> for DragResult {
1529 fn from_glib(value: gtk_sys::GtkDragResult) -> Self {
1530 skip_assert_initialized!();
1531 match value {
1532 0 => DragResult::Success,
1533 1 => DragResult::NoTarget,
1534 2 => DragResult::UserCancelled,
1535 3 => DragResult::TimeoutExpired,
1536 4 => DragResult::GrabBroken,
1537 5 => DragResult::Error,
1538 value => DragResult::__Unknown(value),
1539 }
1540 }
1541}
1542
1543impl StaticType for DragResult {
1544 fn static_type() -> Type {
1545 unsafe { from_glib(gtk_sys::gtk_drag_result_get_type()) }
1546 }
1547}
1548
1549impl<'a> FromValueOptional<'a> for DragResult {
1550 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1551 Some(FromValue::from_value(value))
1552 }
1553}
1554
1555impl<'a> FromValue<'a> for DragResult {
1556 unsafe fn from_value(value: &Value) -> Self {
1557 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1558 }
1559}
1560
1561impl SetValue for DragResult {
1562 unsafe fn set_value(value: &mut Value, this: &Self) {
1563 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1564 }
1565}
1566
1567#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1568pub enum EntryIconPosition {
1569 Primary,
1570 Secondary,
1571 #[doc(hidden)]
1572 __Unknown(i32),
1573}
1574
1575impl fmt::Display for EntryIconPosition {
1576 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1577 write!(
1578 f,
1579 "EntryIconPosition::{}",
1580 match *self {
1581 EntryIconPosition::Primary => "Primary",
1582 EntryIconPosition::Secondary => "Secondary",
1583 _ => "Unknown",
1584 }
1585 )
1586 }
1587}
1588
1589#[doc(hidden)]
1590impl ToGlib for EntryIconPosition {
1591 type GlibType = gtk_sys::GtkEntryIconPosition;
1592
1593 fn to_glib(&self) -> gtk_sys::GtkEntryIconPosition {
1594 match *self {
1595 EntryIconPosition::Primary => gtk_sys::GTK_ENTRY_ICON_PRIMARY,
1596 EntryIconPosition::Secondary => gtk_sys::GTK_ENTRY_ICON_SECONDARY,
1597 EntryIconPosition::__Unknown(value) => value,
1598 }
1599 }
1600}
1601
1602#[doc(hidden)]
1603impl FromGlib<gtk_sys::GtkEntryIconPosition> for EntryIconPosition {
1604 fn from_glib(value: gtk_sys::GtkEntryIconPosition) -> Self {
1605 skip_assert_initialized!();
1606 match value {
1607 0 => EntryIconPosition::Primary,
1608 1 => EntryIconPosition::Secondary,
1609 value => EntryIconPosition::__Unknown(value),
1610 }
1611 }
1612}
1613
1614impl StaticType for EntryIconPosition {
1615 fn static_type() -> Type {
1616 unsafe { from_glib(gtk_sys::gtk_entry_icon_position_get_type()) }
1617 }
1618}
1619
1620impl<'a> FromValueOptional<'a> for EntryIconPosition {
1621 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1622 Some(FromValue::from_value(value))
1623 }
1624}
1625
1626impl<'a> FromValue<'a> for EntryIconPosition {
1627 unsafe fn from_value(value: &Value) -> Self {
1628 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1629 }
1630}
1631
1632impl SetValue for EntryIconPosition {
1633 unsafe fn set_value(value: &mut Value, this: &Self) {
1634 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1635 }
1636}
1637
1638#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1639pub enum EventSequenceState {
1640 None,
1641 Claimed,
1642 Denied,
1643 #[doc(hidden)]
1644 __Unknown(i32),
1645}
1646
1647impl fmt::Display for EventSequenceState {
1648 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1649 write!(
1650 f,
1651 "EventSequenceState::{}",
1652 match *self {
1653 EventSequenceState::None => "None",
1654 EventSequenceState::Claimed => "Claimed",
1655 EventSequenceState::Denied => "Denied",
1656 _ => "Unknown",
1657 }
1658 )
1659 }
1660}
1661
1662#[doc(hidden)]
1663impl ToGlib for EventSequenceState {
1664 type GlibType = gtk_sys::GtkEventSequenceState;
1665
1666 fn to_glib(&self) -> gtk_sys::GtkEventSequenceState {
1667 match *self {
1668 EventSequenceState::None => gtk_sys::GTK_EVENT_SEQUENCE_NONE,
1669 EventSequenceState::Claimed => gtk_sys::GTK_EVENT_SEQUENCE_CLAIMED,
1670 EventSequenceState::Denied => gtk_sys::GTK_EVENT_SEQUENCE_DENIED,
1671 EventSequenceState::__Unknown(value) => value,
1672 }
1673 }
1674}
1675
1676#[doc(hidden)]
1677impl FromGlib<gtk_sys::GtkEventSequenceState> for EventSequenceState {
1678 fn from_glib(value: gtk_sys::GtkEventSequenceState) -> Self {
1679 skip_assert_initialized!();
1680 match value {
1681 0 => EventSequenceState::None,
1682 1 => EventSequenceState::Claimed,
1683 2 => EventSequenceState::Denied,
1684 value => EventSequenceState::__Unknown(value),
1685 }
1686 }
1687}
1688
1689impl StaticType for EventSequenceState {
1690 fn static_type() -> Type {
1691 unsafe { from_glib(gtk_sys::gtk_event_sequence_state_get_type()) }
1692 }
1693}
1694
1695impl<'a> FromValueOptional<'a> for EventSequenceState {
1696 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1697 Some(FromValue::from_value(value))
1698 }
1699}
1700
1701impl<'a> FromValue<'a> for EventSequenceState {
1702 unsafe fn from_value(value: &Value) -> Self {
1703 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1704 }
1705}
1706
1707impl SetValue for EventSequenceState {
1708 unsafe fn set_value(value: &mut Value, this: &Self) {
1709 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1710 }
1711}
1712
1713#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1714pub enum FileChooserAction {
1715 Open,
1716 Save,
1717 SelectFolder,
1718 CreateFolder,
1719 #[doc(hidden)]
1720 __Unknown(i32),
1721}
1722
1723impl fmt::Display for FileChooserAction {
1724 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1725 write!(
1726 f,
1727 "FileChooserAction::{}",
1728 match *self {
1729 FileChooserAction::Open => "Open",
1730 FileChooserAction::Save => "Save",
1731 FileChooserAction::SelectFolder => "SelectFolder",
1732 FileChooserAction::CreateFolder => "CreateFolder",
1733 _ => "Unknown",
1734 }
1735 )
1736 }
1737}
1738
1739#[doc(hidden)]
1740impl ToGlib for FileChooserAction {
1741 type GlibType = gtk_sys::GtkFileChooserAction;
1742
1743 fn to_glib(&self) -> gtk_sys::GtkFileChooserAction {
1744 match *self {
1745 FileChooserAction::Open => gtk_sys::GTK_FILE_CHOOSER_ACTION_OPEN,
1746 FileChooserAction::Save => gtk_sys::GTK_FILE_CHOOSER_ACTION_SAVE,
1747 FileChooserAction::SelectFolder => gtk_sys::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
1748 FileChooserAction::CreateFolder => gtk_sys::GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
1749 FileChooserAction::__Unknown(value) => value,
1750 }
1751 }
1752}
1753
1754#[doc(hidden)]
1755impl FromGlib<gtk_sys::GtkFileChooserAction> for FileChooserAction {
1756 fn from_glib(value: gtk_sys::GtkFileChooserAction) -> Self {
1757 skip_assert_initialized!();
1758 match value {
1759 0 => FileChooserAction::Open,
1760 1 => FileChooserAction::Save,
1761 2 => FileChooserAction::SelectFolder,
1762 3 => FileChooserAction::CreateFolder,
1763 value => FileChooserAction::__Unknown(value),
1764 }
1765 }
1766}
1767
1768impl StaticType for FileChooserAction {
1769 fn static_type() -> Type {
1770 unsafe { from_glib(gtk_sys::gtk_file_chooser_action_get_type()) }
1771 }
1772}
1773
1774impl<'a> FromValueOptional<'a> for FileChooserAction {
1775 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1776 Some(FromValue::from_value(value))
1777 }
1778}
1779
1780impl<'a> FromValue<'a> for FileChooserAction {
1781 unsafe fn from_value(value: &Value) -> Self {
1782 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1783 }
1784}
1785
1786impl SetValue for FileChooserAction {
1787 unsafe fn set_value(value: &mut Value, this: &Self) {
1788 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1789 }
1790}
1791
1792#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1793pub enum FileChooserConfirmation {
1794 Confirm,
1795 AcceptFilename,
1796 SelectAgain,
1797 #[doc(hidden)]
1798 __Unknown(i32),
1799}
1800
1801impl fmt::Display for FileChooserConfirmation {
1802 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1803 write!(
1804 f,
1805 "FileChooserConfirmation::{}",
1806 match *self {
1807 FileChooserConfirmation::Confirm => "Confirm",
1808 FileChooserConfirmation::AcceptFilename => "AcceptFilename",
1809 FileChooserConfirmation::SelectAgain => "SelectAgain",
1810 _ => "Unknown",
1811 }
1812 )
1813 }
1814}
1815
1816#[doc(hidden)]
1817impl ToGlib for FileChooserConfirmation {
1818 type GlibType = gtk_sys::GtkFileChooserConfirmation;
1819
1820 fn to_glib(&self) -> gtk_sys::GtkFileChooserConfirmation {
1821 match *self {
1822 FileChooserConfirmation::Confirm => gtk_sys::GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM,
1823 FileChooserConfirmation::AcceptFilename => {
1824 gtk_sys::GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME
1825 }
1826 FileChooserConfirmation::SelectAgain => {
1827 gtk_sys::GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN
1828 }
1829 FileChooserConfirmation::__Unknown(value) => value,
1830 }
1831 }
1832}
1833
1834#[doc(hidden)]
1835impl FromGlib<gtk_sys::GtkFileChooserConfirmation> for FileChooserConfirmation {
1836 fn from_glib(value: gtk_sys::GtkFileChooserConfirmation) -> Self {
1837 skip_assert_initialized!();
1838 match value {
1839 0 => FileChooserConfirmation::Confirm,
1840 1 => FileChooserConfirmation::AcceptFilename,
1841 2 => FileChooserConfirmation::SelectAgain,
1842 value => FileChooserConfirmation::__Unknown(value),
1843 }
1844 }
1845}
1846
1847impl StaticType for FileChooserConfirmation {
1848 fn static_type() -> Type {
1849 unsafe { from_glib(gtk_sys::gtk_file_chooser_confirmation_get_type()) }
1850 }
1851}
1852
1853impl<'a> FromValueOptional<'a> for FileChooserConfirmation {
1854 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1855 Some(FromValue::from_value(value))
1856 }
1857}
1858
1859impl<'a> FromValue<'a> for FileChooserConfirmation {
1860 unsafe fn from_value(value: &Value) -> Self {
1861 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1862 }
1863}
1864
1865impl SetValue for FileChooserConfirmation {
1866 unsafe fn set_value(value: &mut Value, this: &Self) {
1867 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1868 }
1869}
1870
1871#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1872pub enum FileChooserError {
1873 Nonexistent,
1874 BadFilename,
1875 AlreadyExists,
1876 IncompleteHostname,
1877 #[doc(hidden)]
1878 __Unknown(i32),
1879}
1880
1881impl fmt::Display for FileChooserError {
1882 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1883 write!(
1884 f,
1885 "FileChooserError::{}",
1886 match *self {
1887 FileChooserError::Nonexistent => "Nonexistent",
1888 FileChooserError::BadFilename => "BadFilename",
1889 FileChooserError::AlreadyExists => "AlreadyExists",
1890 FileChooserError::IncompleteHostname => "IncompleteHostname",
1891 _ => "Unknown",
1892 }
1893 )
1894 }
1895}
1896
1897#[doc(hidden)]
1898impl ToGlib for FileChooserError {
1899 type GlibType = gtk_sys::GtkFileChooserError;
1900
1901 fn to_glib(&self) -> gtk_sys::GtkFileChooserError {
1902 match *self {
1903 FileChooserError::Nonexistent => gtk_sys::GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
1904 FileChooserError::BadFilename => gtk_sys::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
1905 FileChooserError::AlreadyExists => gtk_sys::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
1906 FileChooserError::IncompleteHostname => {
1907 gtk_sys::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME
1908 }
1909 FileChooserError::__Unknown(value) => value,
1910 }
1911 }
1912}
1913
1914#[doc(hidden)]
1915impl FromGlib<gtk_sys::GtkFileChooserError> for FileChooserError {
1916 fn from_glib(value: gtk_sys::GtkFileChooserError) -> Self {
1917 skip_assert_initialized!();
1918 match value {
1919 0 => FileChooserError::Nonexistent,
1920 1 => FileChooserError::BadFilename,
1921 2 => FileChooserError::AlreadyExists,
1922 3 => FileChooserError::IncompleteHostname,
1923 value => FileChooserError::__Unknown(value),
1924 }
1925 }
1926}
1927
1928impl ErrorDomain for FileChooserError {
1929 fn domain() -> Quark {
1930 skip_assert_initialized!();
1931 unsafe { from_glib(gtk_sys::gtk_file_chooser_error_quark()) }
1932 }
1933
1934 fn code(self) -> i32 {
1935 self.to_glib()
1936 }
1937
1938 fn from(code: i32) -> Option<Self> {
1939 skip_assert_initialized!();
1940 match code {
1941 0 => Some(FileChooserError::Nonexistent),
1942 1 => Some(FileChooserError::BadFilename),
1943 2 => Some(FileChooserError::AlreadyExists),
1944 3 => Some(FileChooserError::IncompleteHostname),
1945 value => Some(FileChooserError::__Unknown(value)),
1946 }
1947 }
1948}
1949
1950impl StaticType for FileChooserError {
1951 fn static_type() -> Type {
1952 unsafe { from_glib(gtk_sys::gtk_file_chooser_error_get_type()) }
1953 }
1954}
1955
1956impl<'a> FromValueOptional<'a> for FileChooserError {
1957 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1958 Some(FromValue::from_value(value))
1959 }
1960}
1961
1962impl<'a> FromValue<'a> for FileChooserError {
1963 unsafe fn from_value(value: &Value) -> Self {
1964 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1965 }
1966}
1967
1968impl SetValue for FileChooserError {
1969 unsafe fn set_value(value: &mut Value, this: &Self) {
1970 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1971 }
1972}
1973
1974#[deprecated]
1975#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1976pub enum IMPreeditStyle {
1977 Nothing,
1978 Callback,
1979 None,
1980 #[doc(hidden)]
1981 __Unknown(i32),
1982}
1983
1984#[deprecated]
1985impl fmt::Display for IMPreeditStyle {
1986 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1987 write!(
1988 f,
1989 "IMPreeditStyle::{}",
1990 match *self {
1991 IMPreeditStyle::Nothing => "Nothing",
1992 IMPreeditStyle::Callback => "Callback",
1993 IMPreeditStyle::None => "None",
1994 _ => "Unknown",
1995 }
1996 )
1997 }
1998}
1999
2000#[deprecated]
2001#[doc(hidden)]
2002impl ToGlib for IMPreeditStyle {
2003 type GlibType = gtk_sys::GtkIMPreeditStyle;
2004
2005 fn to_glib(&self) -> gtk_sys::GtkIMPreeditStyle {
2006 match *self {
2007 IMPreeditStyle::Nothing => gtk_sys::GTK_IM_PREEDIT_NOTHING,
2008 IMPreeditStyle::Callback => gtk_sys::GTK_IM_PREEDIT_CALLBACK,
2009 IMPreeditStyle::None => gtk_sys::GTK_IM_PREEDIT_NONE,
2010 IMPreeditStyle::__Unknown(value) => value,
2011 }
2012 }
2013}
2014
2015#[deprecated]
2016#[doc(hidden)]
2017impl FromGlib<gtk_sys::GtkIMPreeditStyle> for IMPreeditStyle {
2018 fn from_glib(value: gtk_sys::GtkIMPreeditStyle) -> Self {
2019 skip_assert_initialized!();
2020 match value {
2021 0 => IMPreeditStyle::Nothing,
2022 1 => IMPreeditStyle::Callback,
2023 2 => IMPreeditStyle::None,
2024 value => IMPreeditStyle::__Unknown(value),
2025 }
2026 }
2027}
2028
2029#[deprecated]
2030impl StaticType for IMPreeditStyle {
2031 fn static_type() -> Type {
2032 unsafe { from_glib(gtk_sys::gtk_im_preedit_style_get_type()) }
2033 }
2034}
2035
2036#[deprecated]
2037impl<'a> FromValueOptional<'a> for IMPreeditStyle {
2038 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2039 Some(FromValue::from_value(value))
2040 }
2041}
2042
2043#[deprecated]
2044impl<'a> FromValue<'a> for IMPreeditStyle {
2045 unsafe fn from_value(value: &Value) -> Self {
2046 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2047 }
2048}
2049
2050#[deprecated]
2051impl SetValue for IMPreeditStyle {
2052 unsafe fn set_value(value: &mut Value, this: &Self) {
2053 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2054 }
2055}
2056
2057#[deprecated]
2058#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2059pub enum IMStatusStyle {
2060 Nothing,
2061 Callback,
2062 None,
2063 #[doc(hidden)]
2064 __Unknown(i32),
2065}
2066
2067#[deprecated]
2068impl fmt::Display for IMStatusStyle {
2069 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2070 write!(
2071 f,
2072 "IMStatusStyle::{}",
2073 match *self {
2074 IMStatusStyle::Nothing => "Nothing",
2075 IMStatusStyle::Callback => "Callback",
2076 IMStatusStyle::None => "None",
2077 _ => "Unknown",
2078 }
2079 )
2080 }
2081}
2082
2083#[deprecated]
2084#[doc(hidden)]
2085impl ToGlib for IMStatusStyle {
2086 type GlibType = gtk_sys::GtkIMStatusStyle;
2087
2088 fn to_glib(&self) -> gtk_sys::GtkIMStatusStyle {
2089 match *self {
2090 IMStatusStyle::Nothing => gtk_sys::GTK_IM_STATUS_NOTHING,
2091 IMStatusStyle::Callback => gtk_sys::GTK_IM_STATUS_CALLBACK,
2092 IMStatusStyle::None => gtk_sys::GTK_IM_STATUS_NONE,
2093 IMStatusStyle::__Unknown(value) => value,
2094 }
2095 }
2096}
2097
2098#[deprecated]
2099#[doc(hidden)]
2100impl FromGlib<gtk_sys::GtkIMStatusStyle> for IMStatusStyle {
2101 fn from_glib(value: gtk_sys::GtkIMStatusStyle) -> Self {
2102 skip_assert_initialized!();
2103 match value {
2104 0 => IMStatusStyle::Nothing,
2105 1 => IMStatusStyle::Callback,
2106 2 => IMStatusStyle::None,
2107 value => IMStatusStyle::__Unknown(value),
2108 }
2109 }
2110}
2111
2112#[deprecated]
2113impl StaticType for IMStatusStyle {
2114 fn static_type() -> Type {
2115 unsafe { from_glib(gtk_sys::gtk_im_status_style_get_type()) }
2116 }
2117}
2118
2119#[deprecated]
2120impl<'a> FromValueOptional<'a> for IMStatusStyle {
2121 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2122 Some(FromValue::from_value(value))
2123 }
2124}
2125
2126#[deprecated]
2127impl<'a> FromValue<'a> for IMStatusStyle {
2128 unsafe fn from_value(value: &Value) -> Self {
2129 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2130 }
2131}
2132
2133#[deprecated]
2134impl SetValue for IMStatusStyle {
2135 unsafe fn set_value(value: &mut Value, this: &Self) {
2136 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2137 }
2138}
2139
2140#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2141pub enum IconSize {
2142 Invalid,
2143 Menu,
2144 SmallToolbar,
2145 LargeToolbar,
2146 Button,
2147 Dnd,
2148 Dialog,
2149 #[doc(hidden)]
2150 __Unknown(i32),
2151}
2152
2153impl fmt::Display for IconSize {
2154 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2155 write!(
2156 f,
2157 "IconSize::{}",
2158 match *self {
2159 IconSize::Invalid => "Invalid",
2160 IconSize::Menu => "Menu",
2161 IconSize::SmallToolbar => "SmallToolbar",
2162 IconSize::LargeToolbar => "LargeToolbar",
2163 IconSize::Button => "Button",
2164 IconSize::Dnd => "Dnd",
2165 IconSize::Dialog => "Dialog",
2166 _ => "Unknown",
2167 }
2168 )
2169 }
2170}
2171
2172#[doc(hidden)]
2173impl ToGlib for IconSize {
2174 type GlibType = gtk_sys::GtkIconSize;
2175
2176 fn to_glib(&self) -> gtk_sys::GtkIconSize {
2177 match *self {
2178 IconSize::Invalid => gtk_sys::GTK_ICON_SIZE_INVALID,
2179 IconSize::Menu => gtk_sys::GTK_ICON_SIZE_MENU,
2180 IconSize::SmallToolbar => gtk_sys::GTK_ICON_SIZE_SMALL_TOOLBAR,
2181 IconSize::LargeToolbar => gtk_sys::GTK_ICON_SIZE_LARGE_TOOLBAR,
2182 IconSize::Button => gtk_sys::GTK_ICON_SIZE_BUTTON,
2183 IconSize::Dnd => gtk_sys::GTK_ICON_SIZE_DND,
2184 IconSize::Dialog => gtk_sys::GTK_ICON_SIZE_DIALOG,
2185 IconSize::__Unknown(value) => value,
2186 }
2187 }
2188}
2189
2190#[doc(hidden)]
2191impl FromGlib<gtk_sys::GtkIconSize> for IconSize {
2192 fn from_glib(value: gtk_sys::GtkIconSize) -> Self {
2193 skip_assert_initialized!();
2194 match value {
2195 0 => IconSize::Invalid,
2196 1 => IconSize::Menu,
2197 2 => IconSize::SmallToolbar,
2198 3 => IconSize::LargeToolbar,
2199 4 => IconSize::Button,
2200 5 => IconSize::Dnd,
2201 6 => IconSize::Dialog,
2202 value => IconSize::__Unknown(value),
2203 }
2204 }
2205}
2206
2207impl StaticType for IconSize {
2208 fn static_type() -> Type {
2209 unsafe { from_glib(gtk_sys::gtk_icon_size_get_type()) }
2210 }
2211}
2212
2213impl<'a> FromValueOptional<'a> for IconSize {
2214 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2215 Some(FromValue::from_value(value))
2216 }
2217}
2218
2219impl<'a> FromValue<'a> for IconSize {
2220 unsafe fn from_value(value: &Value) -> Self {
2221 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2222 }
2223}
2224
2225impl SetValue for IconSize {
2226 unsafe fn set_value(value: &mut Value, this: &Self) {
2227 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2228 }
2229}
2230
2231#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2232pub enum IconThemeError {
2233 NotFound,
2234 Failed,
2235 #[doc(hidden)]
2236 __Unknown(i32),
2237}
2238
2239impl fmt::Display for IconThemeError {
2240 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2241 write!(
2242 f,
2243 "IconThemeError::{}",
2244 match *self {
2245 IconThemeError::NotFound => "NotFound",
2246 IconThemeError::Failed => "Failed",
2247 _ => "Unknown",
2248 }
2249 )
2250 }
2251}
2252
2253#[doc(hidden)]
2254impl ToGlib for IconThemeError {
2255 type GlibType = gtk_sys::GtkIconThemeError;
2256
2257 fn to_glib(&self) -> gtk_sys::GtkIconThemeError {
2258 match *self {
2259 IconThemeError::NotFound => gtk_sys::GTK_ICON_THEME_NOT_FOUND,
2260 IconThemeError::Failed => gtk_sys::GTK_ICON_THEME_FAILED,
2261 IconThemeError::__Unknown(value) => value,
2262 }
2263 }
2264}
2265
2266#[doc(hidden)]
2267impl FromGlib<gtk_sys::GtkIconThemeError> for IconThemeError {
2268 fn from_glib(value: gtk_sys::GtkIconThemeError) -> Self {
2269 skip_assert_initialized!();
2270 match value {
2271 0 => IconThemeError::NotFound,
2272 1 => IconThemeError::Failed,
2273 value => IconThemeError::__Unknown(value),
2274 }
2275 }
2276}
2277
2278impl ErrorDomain for IconThemeError {
2279 fn domain() -> Quark {
2280 skip_assert_initialized!();
2281 unsafe { from_glib(gtk_sys::gtk_icon_theme_error_quark()) }
2282 }
2283
2284 fn code(self) -> i32 {
2285 self.to_glib()
2286 }
2287
2288 fn from(code: i32) -> Option<Self> {
2289 skip_assert_initialized!();
2290 match code {
2291 0 => Some(IconThemeError::NotFound),
2292 1 => Some(IconThemeError::Failed),
2293 _ => Some(IconThemeError::Failed),
2294 }
2295 }
2296}
2297
2298impl StaticType for IconThemeError {
2299 fn static_type() -> Type {
2300 unsafe { from_glib(gtk_sys::gtk_icon_theme_error_get_type()) }
2301 }
2302}
2303
2304impl<'a> FromValueOptional<'a> for IconThemeError {
2305 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2306 Some(FromValue::from_value(value))
2307 }
2308}
2309
2310impl<'a> FromValue<'a> for IconThemeError {
2311 unsafe fn from_value(value: &Value) -> Self {
2312 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2313 }
2314}
2315
2316impl SetValue for IconThemeError {
2317 unsafe fn set_value(value: &mut Value, this: &Self) {
2318 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2319 }
2320}
2321
2322#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2323pub enum IconViewDropPosition {
2324 NoDrop,
2325 DropInto,
2326 DropLeft,
2327 DropRight,
2328 DropAbove,
2329 DropBelow,
2330 #[doc(hidden)]
2331 __Unknown(i32),
2332}
2333
2334impl fmt::Display for IconViewDropPosition {
2335 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2336 write!(
2337 f,
2338 "IconViewDropPosition::{}",
2339 match *self {
2340 IconViewDropPosition::NoDrop => "NoDrop",
2341 IconViewDropPosition::DropInto => "DropInto",
2342 IconViewDropPosition::DropLeft => "DropLeft",
2343 IconViewDropPosition::DropRight => "DropRight",
2344 IconViewDropPosition::DropAbove => "DropAbove",
2345 IconViewDropPosition::DropBelow => "DropBelow",
2346 _ => "Unknown",
2347 }
2348 )
2349 }
2350}
2351
2352#[doc(hidden)]
2353impl ToGlib for IconViewDropPosition {
2354 type GlibType = gtk_sys::GtkIconViewDropPosition;
2355
2356 fn to_glib(&self) -> gtk_sys::GtkIconViewDropPosition {
2357 match *self {
2358 IconViewDropPosition::NoDrop => gtk_sys::GTK_ICON_VIEW_NO_DROP,
2359 IconViewDropPosition::DropInto => gtk_sys::GTK_ICON_VIEW_DROP_INTO,
2360 IconViewDropPosition::DropLeft => gtk_sys::GTK_ICON_VIEW_DROP_LEFT,
2361 IconViewDropPosition::DropRight => gtk_sys::GTK_ICON_VIEW_DROP_RIGHT,
2362 IconViewDropPosition::DropAbove => gtk_sys::GTK_ICON_VIEW_DROP_ABOVE,
2363 IconViewDropPosition::DropBelow => gtk_sys::GTK_ICON_VIEW_DROP_BELOW,
2364 IconViewDropPosition::__Unknown(value) => value,
2365 }
2366 }
2367}
2368
2369#[doc(hidden)]
2370impl FromGlib<gtk_sys::GtkIconViewDropPosition> for IconViewDropPosition {
2371 fn from_glib(value: gtk_sys::GtkIconViewDropPosition) -> Self {
2372 skip_assert_initialized!();
2373 match value {
2374 0 => IconViewDropPosition::NoDrop,
2375 1 => IconViewDropPosition::DropInto,
2376 2 => IconViewDropPosition::DropLeft,
2377 3 => IconViewDropPosition::DropRight,
2378 4 => IconViewDropPosition::DropAbove,
2379 5 => IconViewDropPosition::DropBelow,
2380 value => IconViewDropPosition::__Unknown(value),
2381 }
2382 }
2383}
2384
2385impl StaticType for IconViewDropPosition {
2386 fn static_type() -> Type {
2387 unsafe { from_glib(gtk_sys::gtk_icon_view_drop_position_get_type()) }
2388 }
2389}
2390
2391impl<'a> FromValueOptional<'a> for IconViewDropPosition {
2392 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2393 Some(FromValue::from_value(value))
2394 }
2395}
2396
2397impl<'a> FromValue<'a> for IconViewDropPosition {
2398 unsafe fn from_value(value: &Value) -> Self {
2399 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2400 }
2401}
2402
2403impl SetValue for IconViewDropPosition {
2404 unsafe fn set_value(value: &mut Value, this: &Self) {
2405 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2406 }
2407}
2408
2409#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2410pub enum ImageType {
2411 Empty,
2412 Pixbuf,
2413 Stock,
2414 IconSet,
2415 Animation,
2416 IconName,
2417 Gicon,
2418 Surface,
2419 #[doc(hidden)]
2420 __Unknown(i32),
2421}
2422
2423impl fmt::Display for ImageType {
2424 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2425 write!(
2426 f,
2427 "ImageType::{}",
2428 match *self {
2429 ImageType::Empty => "Empty",
2430 ImageType::Pixbuf => "Pixbuf",
2431 ImageType::Stock => "Stock",
2432 ImageType::IconSet => "IconSet",
2433 ImageType::Animation => "Animation",
2434 ImageType::IconName => "IconName",
2435 ImageType::Gicon => "Gicon",
2436 ImageType::Surface => "Surface",
2437 _ => "Unknown",
2438 }
2439 )
2440 }
2441}
2442
2443#[doc(hidden)]
2444impl ToGlib for ImageType {
2445 type GlibType = gtk_sys::GtkImageType;
2446
2447 fn to_glib(&self) -> gtk_sys::GtkImageType {
2448 match *self {
2449 ImageType::Empty => gtk_sys::GTK_IMAGE_EMPTY,
2450 ImageType::Pixbuf => gtk_sys::GTK_IMAGE_PIXBUF,
2451 ImageType::Stock => gtk_sys::GTK_IMAGE_STOCK,
2452 ImageType::IconSet => gtk_sys::GTK_IMAGE_ICON_SET,
2453 ImageType::Animation => gtk_sys::GTK_IMAGE_ANIMATION,
2454 ImageType::IconName => gtk_sys::GTK_IMAGE_ICON_NAME,
2455 ImageType::Gicon => gtk_sys::GTK_IMAGE_GICON,
2456 ImageType::Surface => gtk_sys::GTK_IMAGE_SURFACE,
2457 ImageType::__Unknown(value) => value,
2458 }
2459 }
2460}
2461
2462#[doc(hidden)]
2463impl FromGlib<gtk_sys::GtkImageType> for ImageType {
2464 fn from_glib(value: gtk_sys::GtkImageType) -> Self {
2465 skip_assert_initialized!();
2466 match value {
2467 0 => ImageType::Empty,
2468 1 => ImageType::Pixbuf,
2469 2 => ImageType::Stock,
2470 3 => ImageType::IconSet,
2471 4 => ImageType::Animation,
2472 5 => ImageType::IconName,
2473 6 => ImageType::Gicon,
2474 7 => ImageType::Surface,
2475 value => ImageType::__Unknown(value),
2476 }
2477 }
2478}
2479
2480impl StaticType for ImageType {
2481 fn static_type() -> Type {
2482 unsafe { from_glib(gtk_sys::gtk_image_type_get_type()) }
2483 }
2484}
2485
2486impl<'a> FromValueOptional<'a> for ImageType {
2487 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2488 Some(FromValue::from_value(value))
2489 }
2490}
2491
2492impl<'a> FromValue<'a> for ImageType {
2493 unsafe fn from_value(value: &Value) -> Self {
2494 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2495 }
2496}
2497
2498impl SetValue for ImageType {
2499 unsafe fn set_value(value: &mut Value, this: &Self) {
2500 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2501 }
2502}
2503
2504#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2505pub enum InputPurpose {
2506 FreeForm,
2507 Alpha,
2508 Digits,
2509 Number,
2510 Phone,
2511 Url,
2512 Email,
2513 Name,
2514 Password,
2515 Pin,
2516 #[doc(hidden)]
2517 __Unknown(i32),
2518}
2519
2520impl fmt::Display for InputPurpose {
2521 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2522 write!(
2523 f,
2524 "InputPurpose::{}",
2525 match *self {
2526 InputPurpose::FreeForm => "FreeForm",
2527 InputPurpose::Alpha => "Alpha",
2528 InputPurpose::Digits => "Digits",
2529 InputPurpose::Number => "Number",
2530 InputPurpose::Phone => "Phone",
2531 InputPurpose::Url => "Url",
2532 InputPurpose::Email => "Email",
2533 InputPurpose::Name => "Name",
2534 InputPurpose::Password => "Password",
2535 InputPurpose::Pin => "Pin",
2536 _ => "Unknown",
2537 }
2538 )
2539 }
2540}
2541
2542#[doc(hidden)]
2543impl ToGlib for InputPurpose {
2544 type GlibType = gtk_sys::GtkInputPurpose;
2545
2546 fn to_glib(&self) -> gtk_sys::GtkInputPurpose {
2547 match *self {
2548 InputPurpose::FreeForm => gtk_sys::GTK_INPUT_PURPOSE_FREE_FORM,
2549 InputPurpose::Alpha => gtk_sys::GTK_INPUT_PURPOSE_ALPHA,
2550 InputPurpose::Digits => gtk_sys::GTK_INPUT_PURPOSE_DIGITS,
2551 InputPurpose::Number => gtk_sys::GTK_INPUT_PURPOSE_NUMBER,
2552 InputPurpose::Phone => gtk_sys::GTK_INPUT_PURPOSE_PHONE,
2553 InputPurpose::Url => gtk_sys::GTK_INPUT_PURPOSE_URL,
2554 InputPurpose::Email => gtk_sys::GTK_INPUT_PURPOSE_EMAIL,
2555 InputPurpose::Name => gtk_sys::GTK_INPUT_PURPOSE_NAME,
2556 InputPurpose::Password => gtk_sys::GTK_INPUT_PURPOSE_PASSWORD,
2557 InputPurpose::Pin => gtk_sys::GTK_INPUT_PURPOSE_PIN,
2558 InputPurpose::__Unknown(value) => value,
2559 }
2560 }
2561}
2562
2563#[doc(hidden)]
2564impl FromGlib<gtk_sys::GtkInputPurpose> for InputPurpose {
2565 fn from_glib(value: gtk_sys::GtkInputPurpose) -> Self {
2566 skip_assert_initialized!();
2567 match value {
2568 0 => InputPurpose::FreeForm,
2569 1 => InputPurpose::Alpha,
2570 2 => InputPurpose::Digits,
2571 3 => InputPurpose::Number,
2572 4 => InputPurpose::Phone,
2573 5 => InputPurpose::Url,
2574 6 => InputPurpose::Email,
2575 7 => InputPurpose::Name,
2576 8 => InputPurpose::Password,
2577 9 => InputPurpose::Pin,
2578 value => InputPurpose::__Unknown(value),
2579 }
2580 }
2581}
2582
2583impl StaticType for InputPurpose {
2584 fn static_type() -> Type {
2585 unsafe { from_glib(gtk_sys::gtk_input_purpose_get_type()) }
2586 }
2587}
2588
2589impl<'a> FromValueOptional<'a> for InputPurpose {
2590 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2591 Some(FromValue::from_value(value))
2592 }
2593}
2594
2595impl<'a> FromValue<'a> for InputPurpose {
2596 unsafe fn from_value(value: &Value) -> Self {
2597 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2598 }
2599}
2600
2601impl SetValue for InputPurpose {
2602 unsafe fn set_value(value: &mut Value, this: &Self) {
2603 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2604 }
2605}
2606
2607#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2608pub enum Justification {
2609 Left,
2610 Right,
2611 Center,
2612 Fill,
2613 #[doc(hidden)]
2614 __Unknown(i32),
2615}
2616
2617impl fmt::Display for Justification {
2618 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2619 write!(
2620 f,
2621 "Justification::{}",
2622 match *self {
2623 Justification::Left => "Left",
2624 Justification::Right => "Right",
2625 Justification::Center => "Center",
2626 Justification::Fill => "Fill",
2627 _ => "Unknown",
2628 }
2629 )
2630 }
2631}
2632
2633#[doc(hidden)]
2634impl ToGlib for Justification {
2635 type GlibType = gtk_sys::GtkJustification;
2636
2637 fn to_glib(&self) -> gtk_sys::GtkJustification {
2638 match *self {
2639 Justification::Left => gtk_sys::GTK_JUSTIFY_LEFT,
2640 Justification::Right => gtk_sys::GTK_JUSTIFY_RIGHT,
2641 Justification::Center => gtk_sys::GTK_JUSTIFY_CENTER,
2642 Justification::Fill => gtk_sys::GTK_JUSTIFY_FILL,
2643 Justification::__Unknown(value) => value,
2644 }
2645 }
2646}
2647
2648#[doc(hidden)]
2649impl FromGlib<gtk_sys::GtkJustification> for Justification {
2650 fn from_glib(value: gtk_sys::GtkJustification) -> Self {
2651 skip_assert_initialized!();
2652 match value {
2653 0 => Justification::Left,
2654 1 => Justification::Right,
2655 2 => Justification::Center,
2656 3 => Justification::Fill,
2657 value => Justification::__Unknown(value),
2658 }
2659 }
2660}
2661
2662impl StaticType for Justification {
2663 fn static_type() -> Type {
2664 unsafe { from_glib(gtk_sys::gtk_justification_get_type()) }
2665 }
2666}
2667
2668impl<'a> FromValueOptional<'a> for Justification {
2669 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2670 Some(FromValue::from_value(value))
2671 }
2672}
2673
2674impl<'a> FromValue<'a> for Justification {
2675 unsafe fn from_value(value: &Value) -> Self {
2676 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2677 }
2678}
2679
2680impl SetValue for Justification {
2681 unsafe fn set_value(value: &mut Value, this: &Self) {
2682 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2683 }
2684}
2685
2686#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2687pub enum LevelBarMode {
2688 Continuous,
2689 Discrete,
2690 #[doc(hidden)]
2691 __Unknown(i32),
2692}
2693
2694impl fmt::Display for LevelBarMode {
2695 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2696 write!(
2697 f,
2698 "LevelBarMode::{}",
2699 match *self {
2700 LevelBarMode::Continuous => "Continuous",
2701 LevelBarMode::Discrete => "Discrete",
2702 _ => "Unknown",
2703 }
2704 )
2705 }
2706}
2707
2708#[doc(hidden)]
2709impl ToGlib for LevelBarMode {
2710 type GlibType = gtk_sys::GtkLevelBarMode;
2711
2712 fn to_glib(&self) -> gtk_sys::GtkLevelBarMode {
2713 match *self {
2714 LevelBarMode::Continuous => gtk_sys::GTK_LEVEL_BAR_MODE_CONTINUOUS,
2715 LevelBarMode::Discrete => gtk_sys::GTK_LEVEL_BAR_MODE_DISCRETE,
2716 LevelBarMode::__Unknown(value) => value,
2717 }
2718 }
2719}
2720
2721#[doc(hidden)]
2722impl FromGlib<gtk_sys::GtkLevelBarMode> for LevelBarMode {
2723 fn from_glib(value: gtk_sys::GtkLevelBarMode) -> Self {
2724 skip_assert_initialized!();
2725 match value {
2726 0 => LevelBarMode::Continuous,
2727 1 => LevelBarMode::Discrete,
2728 value => LevelBarMode::__Unknown(value),
2729 }
2730 }
2731}
2732
2733impl StaticType for LevelBarMode {
2734 fn static_type() -> Type {
2735 unsafe { from_glib(gtk_sys::gtk_level_bar_mode_get_type()) }
2736 }
2737}
2738
2739impl<'a> FromValueOptional<'a> for LevelBarMode {
2740 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2741 Some(FromValue::from_value(value))
2742 }
2743}
2744
2745impl<'a> FromValue<'a> for LevelBarMode {
2746 unsafe fn from_value(value: &Value) -> Self {
2747 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2748 }
2749}
2750
2751impl SetValue for LevelBarMode {
2752 unsafe fn set_value(value: &mut Value, this: &Self) {
2753 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2754 }
2755}
2756
2757#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2758pub enum License {
2759 Unknown,
2760 Custom,
2761 Gpl20,
2762 Gpl30,
2763 Lgpl21,
2764 Lgpl30,
2765 Bsd,
2766 MitX11,
2767 Artistic,
2768 Gpl20Only,
2769 Gpl30Only,
2770 Lgpl21Only,
2771 Lgpl30Only,
2772 Agpl30,
2773 Agpl30Only,
2774 #[doc(hidden)]
2775 __Unknown(i32),
2776}
2777
2778impl fmt::Display for License {
2779 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2780 write!(
2781 f,
2782 "License::{}",
2783 match *self {
2784 License::Unknown => "Unknown",
2785 License::Custom => "Custom",
2786 License::Gpl20 => "Gpl20",
2787 License::Gpl30 => "Gpl30",
2788 License::Lgpl21 => "Lgpl21",
2789 License::Lgpl30 => "Lgpl30",
2790 License::Bsd => "Bsd",
2791 License::MitX11 => "MitX11",
2792 License::Artistic => "Artistic",
2793 License::Gpl20Only => "Gpl20Only",
2794 License::Gpl30Only => "Gpl30Only",
2795 License::Lgpl21Only => "Lgpl21Only",
2796 License::Lgpl30Only => "Lgpl30Only",
2797 License::Agpl30 => "Agpl30",
2798 License::Agpl30Only => "Agpl30Only",
2799 _ => "Unknown",
2800 }
2801 )
2802 }
2803}
2804
2805#[doc(hidden)]
2806impl ToGlib for License {
2807 type GlibType = gtk_sys::GtkLicense;
2808
2809 fn to_glib(&self) -> gtk_sys::GtkLicense {
2810 match *self {
2811 License::Unknown => gtk_sys::GTK_LICENSE_UNKNOWN,
2812 License::Custom => gtk_sys::GTK_LICENSE_CUSTOM,
2813 License::Gpl20 => gtk_sys::GTK_LICENSE_GPL_2_0,
2814 License::Gpl30 => gtk_sys::GTK_LICENSE_GPL_3_0,
2815 License::Lgpl21 => gtk_sys::GTK_LICENSE_LGPL_2_1,
2816 License::Lgpl30 => gtk_sys::GTK_LICENSE_LGPL_3_0,
2817 License::Bsd => gtk_sys::GTK_LICENSE_BSD,
2818 License::MitX11 => gtk_sys::GTK_LICENSE_MIT_X11,
2819 License::Artistic => gtk_sys::GTK_LICENSE_ARTISTIC,
2820 License::Gpl20Only => gtk_sys::GTK_LICENSE_GPL_2_0_ONLY,
2821 License::Gpl30Only => gtk_sys::GTK_LICENSE_GPL_3_0_ONLY,
2822 License::Lgpl21Only => gtk_sys::GTK_LICENSE_LGPL_2_1_ONLY,
2823 License::Lgpl30Only => gtk_sys::GTK_LICENSE_LGPL_3_0_ONLY,
2824 License::Agpl30 => gtk_sys::GTK_LICENSE_AGPL_3_0,
2825 License::Agpl30Only => gtk_sys::GTK_LICENSE_AGPL_3_0_ONLY,
2826 License::__Unknown(value) => value,
2827 }
2828 }
2829}
2830
2831#[doc(hidden)]
2832impl FromGlib<gtk_sys::GtkLicense> for License {
2833 fn from_glib(value: gtk_sys::GtkLicense) -> Self {
2834 skip_assert_initialized!();
2835 match value {
2836 0 => License::Unknown,
2837 1 => License::Custom,
2838 2 => License::Gpl20,
2839 3 => License::Gpl30,
2840 4 => License::Lgpl21,
2841 5 => License::Lgpl30,
2842 6 => License::Bsd,
2843 7 => License::MitX11,
2844 8 => License::Artistic,
2845 9 => License::Gpl20Only,
2846 10 => License::Gpl30Only,
2847 11 => License::Lgpl21Only,
2848 12 => License::Lgpl30Only,
2849 13 => License::Agpl30,
2850 14 => License::Agpl30Only,
2851 value => License::__Unknown(value),
2852 }
2853 }
2854}
2855
2856impl StaticType for License {
2857 fn static_type() -> Type {
2858 unsafe { from_glib(gtk_sys::gtk_license_get_type()) }
2859 }
2860}
2861
2862impl<'a> FromValueOptional<'a> for License {
2863 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2864 Some(FromValue::from_value(value))
2865 }
2866}
2867
2868impl<'a> FromValue<'a> for License {
2869 unsafe fn from_value(value: &Value) -> Self {
2870 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2871 }
2872}
2873
2874impl SetValue for License {
2875 unsafe fn set_value(value: &mut Value, this: &Self) {
2876 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2877 }
2878}
2879
2880#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2881pub enum MenuDirectionType {
2882 Parent,
2883 Child,
2884 Next,
2885 Prev,
2886 #[doc(hidden)]
2887 __Unknown(i32),
2888}
2889
2890impl fmt::Display for MenuDirectionType {
2891 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2892 write!(
2893 f,
2894 "MenuDirectionType::{}",
2895 match *self {
2896 MenuDirectionType::Parent => "Parent",
2897 MenuDirectionType::Child => "Child",
2898 MenuDirectionType::Next => "Next",
2899 MenuDirectionType::Prev => "Prev",
2900 _ => "Unknown",
2901 }
2902 )
2903 }
2904}
2905
2906#[doc(hidden)]
2907impl ToGlib for MenuDirectionType {
2908 type GlibType = gtk_sys::GtkMenuDirectionType;
2909
2910 fn to_glib(&self) -> gtk_sys::GtkMenuDirectionType {
2911 match *self {
2912 MenuDirectionType::Parent => gtk_sys::GTK_MENU_DIR_PARENT,
2913 MenuDirectionType::Child => gtk_sys::GTK_MENU_DIR_CHILD,
2914 MenuDirectionType::Next => gtk_sys::GTK_MENU_DIR_NEXT,
2915 MenuDirectionType::Prev => gtk_sys::GTK_MENU_DIR_PREV,
2916 MenuDirectionType::__Unknown(value) => value,
2917 }
2918 }
2919}
2920
2921#[doc(hidden)]
2922impl FromGlib<gtk_sys::GtkMenuDirectionType> for MenuDirectionType {
2923 fn from_glib(value: gtk_sys::GtkMenuDirectionType) -> Self {
2924 skip_assert_initialized!();
2925 match value {
2926 0 => MenuDirectionType::Parent,
2927 1 => MenuDirectionType::Child,
2928 2 => MenuDirectionType::Next,
2929 3 => MenuDirectionType::Prev,
2930 value => MenuDirectionType::__Unknown(value),
2931 }
2932 }
2933}
2934
2935impl StaticType for MenuDirectionType {
2936 fn static_type() -> Type {
2937 unsafe { from_glib(gtk_sys::gtk_menu_direction_type_get_type()) }
2938 }
2939}
2940
2941impl<'a> FromValueOptional<'a> for MenuDirectionType {
2942 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2943 Some(FromValue::from_value(value))
2944 }
2945}
2946
2947impl<'a> FromValue<'a> for MenuDirectionType {
2948 unsafe fn from_value(value: &Value) -> Self {
2949 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2950 }
2951}
2952
2953impl SetValue for MenuDirectionType {
2954 unsafe fn set_value(value: &mut Value, this: &Self) {
2955 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2956 }
2957}
2958
2959#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2960pub enum MessageType {
2961 Info,
2962 Warning,
2963 Question,
2964 Error,
2965 Other,
2966 #[doc(hidden)]
2967 __Unknown(i32),
2968}
2969
2970impl fmt::Display for MessageType {
2971 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2972 write!(
2973 f,
2974 "MessageType::{}",
2975 match *self {
2976 MessageType::Info => "Info",
2977 MessageType::Warning => "Warning",
2978 MessageType::Question => "Question",
2979 MessageType::Error => "Error",
2980 MessageType::Other => "Other",
2981 _ => "Unknown",
2982 }
2983 )
2984 }
2985}
2986
2987#[doc(hidden)]
2988impl ToGlib for MessageType {
2989 type GlibType = gtk_sys::GtkMessageType;
2990
2991 fn to_glib(&self) -> gtk_sys::GtkMessageType {
2992 match *self {
2993 MessageType::Info => gtk_sys::GTK_MESSAGE_INFO,
2994 MessageType::Warning => gtk_sys::GTK_MESSAGE_WARNING,
2995 MessageType::Question => gtk_sys::GTK_MESSAGE_QUESTION,
2996 MessageType::Error => gtk_sys::GTK_MESSAGE_ERROR,
2997 MessageType::Other => gtk_sys::GTK_MESSAGE_OTHER,
2998 MessageType::__Unknown(value) => value,
2999 }
3000 }
3001}
3002
3003#[doc(hidden)]
3004impl FromGlib<gtk_sys::GtkMessageType> for MessageType {
3005 fn from_glib(value: gtk_sys::GtkMessageType) -> Self {
3006 skip_assert_initialized!();
3007 match value {
3008 0 => MessageType::Info,
3009 1 => MessageType::Warning,
3010 2 => MessageType::Question,
3011 3 => MessageType::Error,
3012 4 => MessageType::Other,
3013 value => MessageType::__Unknown(value),
3014 }
3015 }
3016}
3017
3018impl StaticType for MessageType {
3019 fn static_type() -> Type {
3020 unsafe { from_glib(gtk_sys::gtk_message_type_get_type()) }
3021 }
3022}
3023
3024impl<'a> FromValueOptional<'a> for MessageType {
3025 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3026 Some(FromValue::from_value(value))
3027 }
3028}
3029
3030impl<'a> FromValue<'a> for MessageType {
3031 unsafe fn from_value(value: &Value) -> Self {
3032 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3033 }
3034}
3035
3036impl SetValue for MessageType {
3037 unsafe fn set_value(value: &mut Value, this: &Self) {
3038 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3039 }
3040}
3041
3042#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3043pub enum MovementStep {
3044 LogicalPositions,
3045 VisualPositions,
3046 Words,
3047 DisplayLines,
3048 DisplayLineEnds,
3049 Paragraphs,
3050 ParagraphEnds,
3051 Pages,
3052 BufferEnds,
3053 HorizontalPages,
3054 #[doc(hidden)]
3055 __Unknown(i32),
3056}
3057
3058impl fmt::Display for MovementStep {
3059 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3060 write!(
3061 f,
3062 "MovementStep::{}",
3063 match *self {
3064 MovementStep::LogicalPositions => "LogicalPositions",
3065 MovementStep::VisualPositions => "VisualPositions",
3066 MovementStep::Words => "Words",
3067 MovementStep::DisplayLines => "DisplayLines",
3068 MovementStep::DisplayLineEnds => "DisplayLineEnds",
3069 MovementStep::Paragraphs => "Paragraphs",
3070 MovementStep::ParagraphEnds => "ParagraphEnds",
3071 MovementStep::Pages => "Pages",
3072 MovementStep::BufferEnds => "BufferEnds",
3073 MovementStep::HorizontalPages => "HorizontalPages",
3074 _ => "Unknown",
3075 }
3076 )
3077 }
3078}
3079
3080#[doc(hidden)]
3081impl ToGlib for MovementStep {
3082 type GlibType = gtk_sys::GtkMovementStep;
3083
3084 fn to_glib(&self) -> gtk_sys::GtkMovementStep {
3085 match *self {
3086 MovementStep::LogicalPositions => gtk_sys::GTK_MOVEMENT_LOGICAL_POSITIONS,
3087 MovementStep::VisualPositions => gtk_sys::GTK_MOVEMENT_VISUAL_POSITIONS,
3088 MovementStep::Words => gtk_sys::GTK_MOVEMENT_WORDS,
3089 MovementStep::DisplayLines => gtk_sys::GTK_MOVEMENT_DISPLAY_LINES,
3090 MovementStep::DisplayLineEnds => gtk_sys::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
3091 MovementStep::Paragraphs => gtk_sys::GTK_MOVEMENT_PARAGRAPHS,
3092 MovementStep::ParagraphEnds => gtk_sys::GTK_MOVEMENT_PARAGRAPH_ENDS,
3093 MovementStep::Pages => gtk_sys::GTK_MOVEMENT_PAGES,
3094 MovementStep::BufferEnds => gtk_sys::GTK_MOVEMENT_BUFFER_ENDS,
3095 MovementStep::HorizontalPages => gtk_sys::GTK_MOVEMENT_HORIZONTAL_PAGES,
3096 MovementStep::__Unknown(value) => value,
3097 }
3098 }
3099}
3100
3101#[doc(hidden)]
3102impl FromGlib<gtk_sys::GtkMovementStep> for MovementStep {
3103 fn from_glib(value: gtk_sys::GtkMovementStep) -> Self {
3104 skip_assert_initialized!();
3105 match value {
3106 0 => MovementStep::LogicalPositions,
3107 1 => MovementStep::VisualPositions,
3108 2 => MovementStep::Words,
3109 3 => MovementStep::DisplayLines,
3110 4 => MovementStep::DisplayLineEnds,
3111 5 => MovementStep::Paragraphs,
3112 6 => MovementStep::ParagraphEnds,
3113 7 => MovementStep::Pages,
3114 8 => MovementStep::BufferEnds,
3115 9 => MovementStep::HorizontalPages,
3116 value => MovementStep::__Unknown(value),
3117 }
3118 }
3119}
3120
3121impl StaticType for MovementStep {
3122 fn static_type() -> Type {
3123 unsafe { from_glib(gtk_sys::gtk_movement_step_get_type()) }
3124 }
3125}
3126
3127impl<'a> FromValueOptional<'a> for MovementStep {
3128 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3129 Some(FromValue::from_value(value))
3130 }
3131}
3132
3133impl<'a> FromValue<'a> for MovementStep {
3134 unsafe fn from_value(value: &Value) -> Self {
3135 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3136 }
3137}
3138
3139impl SetValue for MovementStep {
3140 unsafe fn set_value(value: &mut Value, this: &Self) {
3141 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3142 }
3143}
3144
3145#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3146pub enum NotebookTab {
3147 First,
3148 Last,
3149 #[doc(hidden)]
3150 __Unknown(i32),
3151}
3152
3153impl fmt::Display for NotebookTab {
3154 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3155 write!(
3156 f,
3157 "NotebookTab::{}",
3158 match *self {
3159 NotebookTab::First => "First",
3160 NotebookTab::Last => "Last",
3161 _ => "Unknown",
3162 }
3163 )
3164 }
3165}
3166
3167#[doc(hidden)]
3168impl ToGlib for NotebookTab {
3169 type GlibType = gtk_sys::GtkNotebookTab;
3170
3171 fn to_glib(&self) -> gtk_sys::GtkNotebookTab {
3172 match *self {
3173 NotebookTab::First => gtk_sys::GTK_NOTEBOOK_TAB_FIRST,
3174 NotebookTab::Last => gtk_sys::GTK_NOTEBOOK_TAB_LAST,
3175 NotebookTab::__Unknown(value) => value,
3176 }
3177 }
3178}
3179
3180#[doc(hidden)]
3181impl FromGlib<gtk_sys::GtkNotebookTab> for NotebookTab {
3182 fn from_glib(value: gtk_sys::GtkNotebookTab) -> Self {
3183 skip_assert_initialized!();
3184 match value {
3185 0 => NotebookTab::First,
3186 1 => NotebookTab::Last,
3187 value => NotebookTab::__Unknown(value),
3188 }
3189 }
3190}
3191
3192impl StaticType for NotebookTab {
3193 fn static_type() -> Type {
3194 unsafe { from_glib(gtk_sys::gtk_notebook_tab_get_type()) }
3195 }
3196}
3197
3198impl<'a> FromValueOptional<'a> for NotebookTab {
3199 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3200 Some(FromValue::from_value(value))
3201 }
3202}
3203
3204impl<'a> FromValue<'a> for NotebookTab {
3205 unsafe fn from_value(value: &Value) -> Self {
3206 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3207 }
3208}
3209
3210impl SetValue for NotebookTab {
3211 unsafe fn set_value(value: &mut Value, this: &Self) {
3212 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3213 }
3214}
3215
3216#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3217pub enum NumberUpLayout {
3218 Lrtb,
3219 Lrbt,
3220 Rltb,
3221 Rlbt,
3222 Tblr,
3223 Tbrl,
3224 Btlr,
3225 Btrl,
3226 #[doc(hidden)]
3227 __Unknown(i32),
3228}
3229
3230impl fmt::Display for NumberUpLayout {
3231 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3232 write!(
3233 f,
3234 "NumberUpLayout::{}",
3235 match *self {
3236 NumberUpLayout::Lrtb => "Lrtb",
3237 NumberUpLayout::Lrbt => "Lrbt",
3238 NumberUpLayout::Rltb => "Rltb",
3239 NumberUpLayout::Rlbt => "Rlbt",
3240 NumberUpLayout::Tblr => "Tblr",
3241 NumberUpLayout::Tbrl => "Tbrl",
3242 NumberUpLayout::Btlr => "Btlr",
3243 NumberUpLayout::Btrl => "Btrl",
3244 _ => "Unknown",
3245 }
3246 )
3247 }
3248}
3249
3250#[doc(hidden)]
3251impl ToGlib for NumberUpLayout {
3252 type GlibType = gtk_sys::GtkNumberUpLayout;
3253
3254 fn to_glib(&self) -> gtk_sys::GtkNumberUpLayout {
3255 match *self {
3256 NumberUpLayout::Lrtb => gtk_sys::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
3257 NumberUpLayout::Lrbt => gtk_sys::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
3258 NumberUpLayout::Rltb => gtk_sys::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
3259 NumberUpLayout::Rlbt => gtk_sys::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
3260 NumberUpLayout::Tblr => gtk_sys::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
3261 NumberUpLayout::Tbrl => gtk_sys::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
3262 NumberUpLayout::Btlr => gtk_sys::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
3263 NumberUpLayout::Btrl => gtk_sys::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
3264 NumberUpLayout::__Unknown(value) => value,
3265 }
3266 }
3267}
3268
3269#[doc(hidden)]
3270impl FromGlib<gtk_sys::GtkNumberUpLayout> for NumberUpLayout {
3271 fn from_glib(value: gtk_sys::GtkNumberUpLayout) -> Self {
3272 skip_assert_initialized!();
3273 match value {
3274 0 => NumberUpLayout::Lrtb,
3275 1 => NumberUpLayout::Lrbt,
3276 2 => NumberUpLayout::Rltb,
3277 3 => NumberUpLayout::Rlbt,
3278 4 => NumberUpLayout::Tblr,
3279 5 => NumberUpLayout::Tbrl,
3280 6 => NumberUpLayout::Btlr,
3281 7 => NumberUpLayout::Btrl,
3282 value => NumberUpLayout::__Unknown(value),
3283 }
3284 }
3285}
3286
3287impl StaticType for NumberUpLayout {
3288 fn static_type() -> Type {
3289 unsafe { from_glib(gtk_sys::gtk_number_up_layout_get_type()) }
3290 }
3291}
3292
3293impl<'a> FromValueOptional<'a> for NumberUpLayout {
3294 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3295 Some(FromValue::from_value(value))
3296 }
3297}
3298
3299impl<'a> FromValue<'a> for NumberUpLayout {
3300 unsafe fn from_value(value: &Value) -> Self {
3301 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3302 }
3303}
3304
3305impl SetValue for NumberUpLayout {
3306 unsafe fn set_value(value: &mut Value, this: &Self) {
3307 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3308 }
3309}
3310
3311#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3312pub enum Orientation {
3313 Horizontal,
3314 Vertical,
3315 #[doc(hidden)]
3316 __Unknown(i32),
3317}
3318
3319impl fmt::Display for Orientation {
3320 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3321 write!(
3322 f,
3323 "Orientation::{}",
3324 match *self {
3325 Orientation::Horizontal => "Horizontal",
3326 Orientation::Vertical => "Vertical",
3327 _ => "Unknown",
3328 }
3329 )
3330 }
3331}
3332
3333#[doc(hidden)]
3334impl ToGlib for Orientation {
3335 type GlibType = gtk_sys::GtkOrientation;
3336
3337 fn to_glib(&self) -> gtk_sys::GtkOrientation {
3338 match *self {
3339 Orientation::Horizontal => gtk_sys::GTK_ORIENTATION_HORIZONTAL,
3340 Orientation::Vertical => gtk_sys::GTK_ORIENTATION_VERTICAL,
3341 Orientation::__Unknown(value) => value,
3342 }
3343 }
3344}
3345
3346#[doc(hidden)]
3347impl FromGlib<gtk_sys::GtkOrientation> for Orientation {
3348 fn from_glib(value: gtk_sys::GtkOrientation) -> Self {
3349 skip_assert_initialized!();
3350 match value {
3351 0 => Orientation::Horizontal,
3352 1 => Orientation::Vertical,
3353 value => Orientation::__Unknown(value),
3354 }
3355 }
3356}
3357
3358impl StaticType for Orientation {
3359 fn static_type() -> Type {
3360 unsafe { from_glib(gtk_sys::gtk_orientation_get_type()) }
3361 }
3362}
3363
3364impl<'a> FromValueOptional<'a> for Orientation {
3365 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3366 Some(FromValue::from_value(value))
3367 }
3368}
3369
3370impl<'a> FromValue<'a> for Orientation {
3371 unsafe fn from_value(value: &Value) -> Self {
3372 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3373 }
3374}
3375
3376impl SetValue for Orientation {
3377 unsafe fn set_value(value: &mut Value, this: &Self) {
3378 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3379 }
3380}
3381
3382#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3383pub enum PackDirection {
3384 Ltr,
3385 Rtl,
3386 Ttb,
3387 Btt,
3388 #[doc(hidden)]
3389 __Unknown(i32),
3390}
3391
3392impl fmt::Display for PackDirection {
3393 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3394 write!(
3395 f,
3396 "PackDirection::{}",
3397 match *self {
3398 PackDirection::Ltr => "Ltr",
3399 PackDirection::Rtl => "Rtl",
3400 PackDirection::Ttb => "Ttb",
3401 PackDirection::Btt => "Btt",
3402 _ => "Unknown",
3403 }
3404 )
3405 }
3406}
3407
3408#[doc(hidden)]
3409impl ToGlib for PackDirection {
3410 type GlibType = gtk_sys::GtkPackDirection;
3411
3412 fn to_glib(&self) -> gtk_sys::GtkPackDirection {
3413 match *self {
3414 PackDirection::Ltr => gtk_sys::GTK_PACK_DIRECTION_LTR,
3415 PackDirection::Rtl => gtk_sys::GTK_PACK_DIRECTION_RTL,
3416 PackDirection::Ttb => gtk_sys::GTK_PACK_DIRECTION_TTB,
3417 PackDirection::Btt => gtk_sys::GTK_PACK_DIRECTION_BTT,
3418 PackDirection::__Unknown(value) => value,
3419 }
3420 }
3421}
3422
3423#[doc(hidden)]
3424impl FromGlib<gtk_sys::GtkPackDirection> for PackDirection {
3425 fn from_glib(value: gtk_sys::GtkPackDirection) -> Self {
3426 skip_assert_initialized!();
3427 match value {
3428 0 => PackDirection::Ltr,
3429 1 => PackDirection::Rtl,
3430 2 => PackDirection::Ttb,
3431 3 => PackDirection::Btt,
3432 value => PackDirection::__Unknown(value),
3433 }
3434 }
3435}
3436
3437impl StaticType for PackDirection {
3438 fn static_type() -> Type {
3439 unsafe { from_glib(gtk_sys::gtk_pack_direction_get_type()) }
3440 }
3441}
3442
3443impl<'a> FromValueOptional<'a> for PackDirection {
3444 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3445 Some(FromValue::from_value(value))
3446 }
3447}
3448
3449impl<'a> FromValue<'a> for PackDirection {
3450 unsafe fn from_value(value: &Value) -> Self {
3451 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3452 }
3453}
3454
3455impl SetValue for PackDirection {
3456 unsafe fn set_value(value: &mut Value, this: &Self) {
3457 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3458 }
3459}
3460
3461#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3462pub enum PackType {
3463 Start,
3464 End,
3465 #[doc(hidden)]
3466 __Unknown(i32),
3467}
3468
3469impl fmt::Display for PackType {
3470 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3471 write!(
3472 f,
3473 "PackType::{}",
3474 match *self {
3475 PackType::Start => "Start",
3476 PackType::End => "End",
3477 _ => "Unknown",
3478 }
3479 )
3480 }
3481}
3482
3483#[doc(hidden)]
3484impl ToGlib for PackType {
3485 type GlibType = gtk_sys::GtkPackType;
3486
3487 fn to_glib(&self) -> gtk_sys::GtkPackType {
3488 match *self {
3489 PackType::Start => gtk_sys::GTK_PACK_START,
3490 PackType::End => gtk_sys::GTK_PACK_END,
3491 PackType::__Unknown(value) => value,
3492 }
3493 }
3494}
3495
3496#[doc(hidden)]
3497impl FromGlib<gtk_sys::GtkPackType> for PackType {
3498 fn from_glib(value: gtk_sys::GtkPackType) -> Self {
3499 skip_assert_initialized!();
3500 match value {
3501 0 => PackType::Start,
3502 1 => PackType::End,
3503 value => PackType::__Unknown(value),
3504 }
3505 }
3506}
3507
3508impl StaticType for PackType {
3509 fn static_type() -> Type {
3510 unsafe { from_glib(gtk_sys::gtk_pack_type_get_type()) }
3511 }
3512}
3513
3514impl<'a> FromValueOptional<'a> for PackType {
3515 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3516 Some(FromValue::from_value(value))
3517 }
3518}
3519
3520impl<'a> FromValue<'a> for PackType {
3521 unsafe fn from_value(value: &Value) -> Self {
3522 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3523 }
3524}
3525
3526impl SetValue for PackType {
3527 unsafe fn set_value(value: &mut Value, this: &Self) {
3528 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3529 }
3530}
3531
3532#[cfg(any(feature = "v3_22", feature = "dox"))]
3533#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3534pub enum PadActionType {
3535 Button,
3536 Ring,
3537 Strip,
3538 #[doc(hidden)]
3539 __Unknown(i32),
3540}
3541
3542#[cfg(any(feature = "v3_22", feature = "dox"))]
3543impl fmt::Display for PadActionType {
3544 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3545 write!(
3546 f,
3547 "PadActionType::{}",
3548 match *self {
3549 PadActionType::Button => "Button",
3550 PadActionType::Ring => "Ring",
3551 PadActionType::Strip => "Strip",
3552 _ => "Unknown",
3553 }
3554 )
3555 }
3556}
3557
3558#[cfg(any(feature = "v3_22", feature = "dox"))]
3559#[doc(hidden)]
3560impl ToGlib for PadActionType {
3561 type GlibType = gtk_sys::GtkPadActionType;
3562
3563 fn to_glib(&self) -> gtk_sys::GtkPadActionType {
3564 match *self {
3565 PadActionType::Button => gtk_sys::GTK_PAD_ACTION_BUTTON,
3566 PadActionType::Ring => gtk_sys::GTK_PAD_ACTION_RING,
3567 PadActionType::Strip => gtk_sys::GTK_PAD_ACTION_STRIP,
3568 PadActionType::__Unknown(value) => value,
3569 }
3570 }
3571}
3572
3573#[cfg(any(feature = "v3_22", feature = "dox"))]
3574#[doc(hidden)]
3575impl FromGlib<gtk_sys::GtkPadActionType> for PadActionType {
3576 fn from_glib(value: gtk_sys::GtkPadActionType) -> Self {
3577 skip_assert_initialized!();
3578 match value {
3579 0 => PadActionType::Button,
3580 1 => PadActionType::Ring,
3581 2 => PadActionType::Strip,
3582 value => PadActionType::__Unknown(value),
3583 }
3584 }
3585}
3586
3587#[cfg(any(feature = "v3_22", feature = "dox"))]
3588impl StaticType for PadActionType {
3589 fn static_type() -> Type {
3590 unsafe { from_glib(gtk_sys::gtk_pad_action_type_get_type()) }
3591 }
3592}
3593
3594#[cfg(any(feature = "v3_22", feature = "dox"))]
3595impl<'a> FromValueOptional<'a> for PadActionType {
3596 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3597 Some(FromValue::from_value(value))
3598 }
3599}
3600
3601#[cfg(any(feature = "v3_22", feature = "dox"))]
3602impl<'a> FromValue<'a> for PadActionType {
3603 unsafe fn from_value(value: &Value) -> Self {
3604 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3605 }
3606}
3607
3608#[cfg(any(feature = "v3_22", feature = "dox"))]
3609impl SetValue for PadActionType {
3610 unsafe fn set_value(value: &mut Value, this: &Self) {
3611 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3612 }
3613}
3614
3615#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3616pub enum PageOrientation {
3617 Portrait,
3618 Landscape,
3619 ReversePortrait,
3620 ReverseLandscape,
3621 #[doc(hidden)]
3622 __Unknown(i32),
3623}
3624
3625impl fmt::Display for PageOrientation {
3626 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3627 write!(
3628 f,
3629 "PageOrientation::{}",
3630 match *self {
3631 PageOrientation::Portrait => "Portrait",
3632 PageOrientation::Landscape => "Landscape",
3633 PageOrientation::ReversePortrait => "ReversePortrait",
3634 PageOrientation::ReverseLandscape => "ReverseLandscape",
3635 _ => "Unknown",
3636 }
3637 )
3638 }
3639}
3640
3641#[doc(hidden)]
3642impl ToGlib for PageOrientation {
3643 type GlibType = gtk_sys::GtkPageOrientation;
3644
3645 fn to_glib(&self) -> gtk_sys::GtkPageOrientation {
3646 match *self {
3647 PageOrientation::Portrait => gtk_sys::GTK_PAGE_ORIENTATION_PORTRAIT,
3648 PageOrientation::Landscape => gtk_sys::GTK_PAGE_ORIENTATION_LANDSCAPE,
3649 PageOrientation::ReversePortrait => gtk_sys::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
3650 PageOrientation::ReverseLandscape => gtk_sys::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
3651 PageOrientation::__Unknown(value) => value,
3652 }
3653 }
3654}
3655
3656#[doc(hidden)]
3657impl FromGlib<gtk_sys::GtkPageOrientation> for PageOrientation {
3658 fn from_glib(value: gtk_sys::GtkPageOrientation) -> Self {
3659 skip_assert_initialized!();
3660 match value {
3661 0 => PageOrientation::Portrait,
3662 1 => PageOrientation::Landscape,
3663 2 => PageOrientation::ReversePortrait,
3664 3 => PageOrientation::ReverseLandscape,
3665 value => PageOrientation::__Unknown(value),
3666 }
3667 }
3668}
3669
3670impl StaticType for PageOrientation {
3671 fn static_type() -> Type {
3672 unsafe { from_glib(gtk_sys::gtk_page_orientation_get_type()) }
3673 }
3674}
3675
3676impl<'a> FromValueOptional<'a> for PageOrientation {
3677 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3678 Some(FromValue::from_value(value))
3679 }
3680}
3681
3682impl<'a> FromValue<'a> for PageOrientation {
3683 unsafe fn from_value(value: &Value) -> Self {
3684 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3685 }
3686}
3687
3688impl SetValue for PageOrientation {
3689 unsafe fn set_value(value: &mut Value, this: &Self) {
3690 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3691 }
3692}
3693
3694#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3695pub enum PageSet {
3696 All,
3697 Even,
3698 Odd,
3699 #[doc(hidden)]
3700 __Unknown(i32),
3701}
3702
3703impl fmt::Display for PageSet {
3704 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3705 write!(
3706 f,
3707 "PageSet::{}",
3708 match *self {
3709 PageSet::All => "All",
3710 PageSet::Even => "Even",
3711 PageSet::Odd => "Odd",
3712 _ => "Unknown",
3713 }
3714 )
3715 }
3716}
3717
3718#[doc(hidden)]
3719impl ToGlib for PageSet {
3720 type GlibType = gtk_sys::GtkPageSet;
3721
3722 fn to_glib(&self) -> gtk_sys::GtkPageSet {
3723 match *self {
3724 PageSet::All => gtk_sys::GTK_PAGE_SET_ALL,
3725 PageSet::Even => gtk_sys::GTK_PAGE_SET_EVEN,
3726 PageSet::Odd => gtk_sys::GTK_PAGE_SET_ODD,
3727 PageSet::__Unknown(value) => value,
3728 }
3729 }
3730}
3731
3732#[doc(hidden)]
3733impl FromGlib<gtk_sys::GtkPageSet> for PageSet {
3734 fn from_glib(value: gtk_sys::GtkPageSet) -> Self {
3735 skip_assert_initialized!();
3736 match value {
3737 0 => PageSet::All,
3738 1 => PageSet::Even,
3739 2 => PageSet::Odd,
3740 value => PageSet::__Unknown(value),
3741 }
3742 }
3743}
3744
3745impl StaticType for PageSet {
3746 fn static_type() -> Type {
3747 unsafe { from_glib(gtk_sys::gtk_page_set_get_type()) }
3748 }
3749}
3750
3751impl<'a> FromValueOptional<'a> for PageSet {
3752 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3753 Some(FromValue::from_value(value))
3754 }
3755}
3756
3757impl<'a> FromValue<'a> for PageSet {
3758 unsafe fn from_value(value: &Value) -> Self {
3759 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3760 }
3761}
3762
3763impl SetValue for PageSet {
3764 unsafe fn set_value(value: &mut Value, this: &Self) {
3765 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3766 }
3767}
3768
3769#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3770pub enum PanDirection {
3771 Left,
3772 Right,
3773 Up,
3774 Down,
3775 #[doc(hidden)]
3776 __Unknown(i32),
3777}
3778
3779impl fmt::Display for PanDirection {
3780 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3781 write!(
3782 f,
3783 "PanDirection::{}",
3784 match *self {
3785 PanDirection::Left => "Left",
3786 PanDirection::Right => "Right",
3787 PanDirection::Up => "Up",
3788 PanDirection::Down => "Down",
3789 _ => "Unknown",
3790 }
3791 )
3792 }
3793}
3794
3795#[doc(hidden)]
3796impl ToGlib for PanDirection {
3797 type GlibType = gtk_sys::GtkPanDirection;
3798
3799 fn to_glib(&self) -> gtk_sys::GtkPanDirection {
3800 match *self {
3801 PanDirection::Left => gtk_sys::GTK_PAN_DIRECTION_LEFT,
3802 PanDirection::Right => gtk_sys::GTK_PAN_DIRECTION_RIGHT,
3803 PanDirection::Up => gtk_sys::GTK_PAN_DIRECTION_UP,
3804 PanDirection::Down => gtk_sys::GTK_PAN_DIRECTION_DOWN,
3805 PanDirection::__Unknown(value) => value,
3806 }
3807 }
3808}
3809
3810#[doc(hidden)]
3811impl FromGlib<gtk_sys::GtkPanDirection> for PanDirection {
3812 fn from_glib(value: gtk_sys::GtkPanDirection) -> Self {
3813 skip_assert_initialized!();
3814 match value {
3815 0 => PanDirection::Left,
3816 1 => PanDirection::Right,
3817 2 => PanDirection::Up,
3818 3 => PanDirection::Down,
3819 value => PanDirection::__Unknown(value),
3820 }
3821 }
3822}
3823
3824impl StaticType for PanDirection {
3825 fn static_type() -> Type {
3826 unsafe { from_glib(gtk_sys::gtk_pan_direction_get_type()) }
3827 }
3828}
3829
3830impl<'a> FromValueOptional<'a> for PanDirection {
3831 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3832 Some(FromValue::from_value(value))
3833 }
3834}
3835
3836impl<'a> FromValue<'a> for PanDirection {
3837 unsafe fn from_value(value: &Value) -> Self {
3838 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3839 }
3840}
3841
3842impl SetValue for PanDirection {
3843 unsafe fn set_value(value: &mut Value, this: &Self) {
3844 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3845 }
3846}
3847
3848#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3849pub enum PolicyType {
3850 Always,
3851 Automatic,
3852 Never,
3853 External,
3854 #[doc(hidden)]
3855 __Unknown(i32),
3856}
3857
3858impl fmt::Display for PolicyType {
3859 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3860 write!(
3861 f,
3862 "PolicyType::{}",
3863 match *self {
3864 PolicyType::Always => "Always",
3865 PolicyType::Automatic => "Automatic",
3866 PolicyType::Never => "Never",
3867 PolicyType::External => "External",
3868 _ => "Unknown",
3869 }
3870 )
3871 }
3872}
3873
3874#[doc(hidden)]
3875impl ToGlib for PolicyType {
3876 type GlibType = gtk_sys::GtkPolicyType;
3877
3878 fn to_glib(&self) -> gtk_sys::GtkPolicyType {
3879 match *self {
3880 PolicyType::Always => gtk_sys::GTK_POLICY_ALWAYS,
3881 PolicyType::Automatic => gtk_sys::GTK_POLICY_AUTOMATIC,
3882 PolicyType::Never => gtk_sys::GTK_POLICY_NEVER,
3883 PolicyType::External => gtk_sys::GTK_POLICY_EXTERNAL,
3884 PolicyType::__Unknown(value) => value,
3885 }
3886 }
3887}
3888
3889#[doc(hidden)]
3890impl FromGlib<gtk_sys::GtkPolicyType> for PolicyType {
3891 fn from_glib(value: gtk_sys::GtkPolicyType) -> Self {
3892 skip_assert_initialized!();
3893 match value {
3894 0 => PolicyType::Always,
3895 1 => PolicyType::Automatic,
3896 2 => PolicyType::Never,
3897 3 => PolicyType::External,
3898 value => PolicyType::__Unknown(value),
3899 }
3900 }
3901}
3902
3903impl StaticType for PolicyType {
3904 fn static_type() -> Type {
3905 unsafe { from_glib(gtk_sys::gtk_policy_type_get_type()) }
3906 }
3907}
3908
3909impl<'a> FromValueOptional<'a> for PolicyType {
3910 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3911 Some(FromValue::from_value(value))
3912 }
3913}
3914
3915impl<'a> FromValue<'a> for PolicyType {
3916 unsafe fn from_value(value: &Value) -> Self {
3917 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3918 }
3919}
3920
3921impl SetValue for PolicyType {
3922 unsafe fn set_value(value: &mut Value, this: &Self) {
3923 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3924 }
3925}
3926
3927#[cfg(any(feature = "v3_20", feature = "dox"))]
3928#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3929pub enum PopoverConstraint {
3930 None,
3931 Window,
3932 #[doc(hidden)]
3933 __Unknown(i32),
3934}
3935
3936#[cfg(any(feature = "v3_20", feature = "dox"))]
3937impl fmt::Display for PopoverConstraint {
3938 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3939 write!(
3940 f,
3941 "PopoverConstraint::{}",
3942 match *self {
3943 PopoverConstraint::None => "None",
3944 PopoverConstraint::Window => "Window",
3945 _ => "Unknown",
3946 }
3947 )
3948 }
3949}
3950
3951#[cfg(any(feature = "v3_20", feature = "dox"))]
3952#[doc(hidden)]
3953impl ToGlib for PopoverConstraint {
3954 type GlibType = gtk_sys::GtkPopoverConstraint;
3955
3956 fn to_glib(&self) -> gtk_sys::GtkPopoverConstraint {
3957 match *self {
3958 PopoverConstraint::None => gtk_sys::GTK_POPOVER_CONSTRAINT_NONE,
3959 PopoverConstraint::Window => gtk_sys::GTK_POPOVER_CONSTRAINT_WINDOW,
3960 PopoverConstraint::__Unknown(value) => value,
3961 }
3962 }
3963}
3964
3965#[cfg(any(feature = "v3_20", feature = "dox"))]
3966#[doc(hidden)]
3967impl FromGlib<gtk_sys::GtkPopoverConstraint> for PopoverConstraint {
3968 fn from_glib(value: gtk_sys::GtkPopoverConstraint) -> Self {
3969 skip_assert_initialized!();
3970 match value {
3971 0 => PopoverConstraint::None,
3972 1 => PopoverConstraint::Window,
3973 value => PopoverConstraint::__Unknown(value),
3974 }
3975 }
3976}
3977
3978#[cfg(any(feature = "v3_20", feature = "dox"))]
3979impl StaticType for PopoverConstraint {
3980 fn static_type() -> Type {
3981 unsafe { from_glib(gtk_sys::gtk_popover_constraint_get_type()) }
3982 }
3983}
3984
3985#[cfg(any(feature = "v3_20", feature = "dox"))]
3986impl<'a> FromValueOptional<'a> for PopoverConstraint {
3987 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3988 Some(FromValue::from_value(value))
3989 }
3990}
3991
3992#[cfg(any(feature = "v3_20", feature = "dox"))]
3993impl<'a> FromValue<'a> for PopoverConstraint {
3994 unsafe fn from_value(value: &Value) -> Self {
3995 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3996 }
3997}
3998
3999#[cfg(any(feature = "v3_20", feature = "dox"))]
4000impl SetValue for PopoverConstraint {
4001 unsafe fn set_value(value: &mut Value, this: &Self) {
4002 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4003 }
4004}
4005
4006#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4007pub enum PositionType {
4008 Left,
4009 Right,
4010 Top,
4011 Bottom,
4012 #[doc(hidden)]
4013 __Unknown(i32),
4014}
4015
4016impl fmt::Display for PositionType {
4017 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4018 write!(
4019 f,
4020 "PositionType::{}",
4021 match *self {
4022 PositionType::Left => "Left",
4023 PositionType::Right => "Right",
4024 PositionType::Top => "Top",
4025 PositionType::Bottom => "Bottom",
4026 _ => "Unknown",
4027 }
4028 )
4029 }
4030}
4031
4032#[doc(hidden)]
4033impl ToGlib for PositionType {
4034 type GlibType = gtk_sys::GtkPositionType;
4035
4036 fn to_glib(&self) -> gtk_sys::GtkPositionType {
4037 match *self {
4038 PositionType::Left => gtk_sys::GTK_POS_LEFT,
4039 PositionType::Right => gtk_sys::GTK_POS_RIGHT,
4040 PositionType::Top => gtk_sys::GTK_POS_TOP,
4041 PositionType::Bottom => gtk_sys::GTK_POS_BOTTOM,
4042 PositionType::__Unknown(value) => value,
4043 }
4044 }
4045}
4046
4047#[doc(hidden)]
4048impl FromGlib<gtk_sys::GtkPositionType> for PositionType {
4049 fn from_glib(value: gtk_sys::GtkPositionType) -> Self {
4050 skip_assert_initialized!();
4051 match value {
4052 0 => PositionType::Left,
4053 1 => PositionType::Right,
4054 2 => PositionType::Top,
4055 3 => PositionType::Bottom,
4056 value => PositionType::__Unknown(value),
4057 }
4058 }
4059}
4060
4061impl StaticType for PositionType {
4062 fn static_type() -> Type {
4063 unsafe { from_glib(gtk_sys::gtk_position_type_get_type()) }
4064 }
4065}
4066
4067impl<'a> FromValueOptional<'a> for PositionType {
4068 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4069 Some(FromValue::from_value(value))
4070 }
4071}
4072
4073impl<'a> FromValue<'a> for PositionType {
4074 unsafe fn from_value(value: &Value) -> Self {
4075 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4076 }
4077}
4078
4079impl SetValue for PositionType {
4080 unsafe fn set_value(value: &mut Value, this: &Self) {
4081 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4082 }
4083}
4084
4085#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4086pub enum PrintDuplex {
4087 Simplex,
4088 Horizontal,
4089 Vertical,
4090 #[doc(hidden)]
4091 __Unknown(i32),
4092}
4093
4094impl fmt::Display for PrintDuplex {
4095 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4096 write!(
4097 f,
4098 "PrintDuplex::{}",
4099 match *self {
4100 PrintDuplex::Simplex => "Simplex",
4101 PrintDuplex::Horizontal => "Horizontal",
4102 PrintDuplex::Vertical => "Vertical",
4103 _ => "Unknown",
4104 }
4105 )
4106 }
4107}
4108
4109#[doc(hidden)]
4110impl ToGlib for PrintDuplex {
4111 type GlibType = gtk_sys::GtkPrintDuplex;
4112
4113 fn to_glib(&self) -> gtk_sys::GtkPrintDuplex {
4114 match *self {
4115 PrintDuplex::Simplex => gtk_sys::GTK_PRINT_DUPLEX_SIMPLEX,
4116 PrintDuplex::Horizontal => gtk_sys::GTK_PRINT_DUPLEX_HORIZONTAL,
4117 PrintDuplex::Vertical => gtk_sys::GTK_PRINT_DUPLEX_VERTICAL,
4118 PrintDuplex::__Unknown(value) => value,
4119 }
4120 }
4121}
4122
4123#[doc(hidden)]
4124impl FromGlib<gtk_sys::GtkPrintDuplex> for PrintDuplex {
4125 fn from_glib(value: gtk_sys::GtkPrintDuplex) -> Self {
4126 skip_assert_initialized!();
4127 match value {
4128 0 => PrintDuplex::Simplex,
4129 1 => PrintDuplex::Horizontal,
4130 2 => PrintDuplex::Vertical,
4131 value => PrintDuplex::__Unknown(value),
4132 }
4133 }
4134}
4135
4136impl StaticType for PrintDuplex {
4137 fn static_type() -> Type {
4138 unsafe { from_glib(gtk_sys::gtk_print_duplex_get_type()) }
4139 }
4140}
4141
4142impl<'a> FromValueOptional<'a> for PrintDuplex {
4143 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4144 Some(FromValue::from_value(value))
4145 }
4146}
4147
4148impl<'a> FromValue<'a> for PrintDuplex {
4149 unsafe fn from_value(value: &Value) -> Self {
4150 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4151 }
4152}
4153
4154impl SetValue for PrintDuplex {
4155 unsafe fn set_value(value: &mut Value, this: &Self) {
4156 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4157 }
4158}
4159
4160#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4161pub enum PrintError {
4162 General,
4163 InternalError,
4164 Nomem,
4165 InvalidFile,
4166 #[doc(hidden)]
4167 __Unknown(i32),
4168}
4169
4170impl fmt::Display for PrintError {
4171 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4172 write!(
4173 f,
4174 "PrintError::{}",
4175 match *self {
4176 PrintError::General => "General",
4177 PrintError::InternalError => "InternalError",
4178 PrintError::Nomem => "Nomem",
4179 PrintError::InvalidFile => "InvalidFile",
4180 _ => "Unknown",
4181 }
4182 )
4183 }
4184}
4185
4186#[doc(hidden)]
4187impl ToGlib for PrintError {
4188 type GlibType = gtk_sys::GtkPrintError;
4189
4190 fn to_glib(&self) -> gtk_sys::GtkPrintError {
4191 match *self {
4192 PrintError::General => gtk_sys::GTK_PRINT_ERROR_GENERAL,
4193 PrintError::InternalError => gtk_sys::GTK_PRINT_ERROR_INTERNAL_ERROR,
4194 PrintError::Nomem => gtk_sys::GTK_PRINT_ERROR_NOMEM,
4195 PrintError::InvalidFile => gtk_sys::GTK_PRINT_ERROR_INVALID_FILE,
4196 PrintError::__Unknown(value) => value,
4197 }
4198 }
4199}
4200
4201#[doc(hidden)]
4202impl FromGlib<gtk_sys::GtkPrintError> for PrintError {
4203 fn from_glib(value: gtk_sys::GtkPrintError) -> Self {
4204 skip_assert_initialized!();
4205 match value {
4206 0 => PrintError::General,
4207 1 => PrintError::InternalError,
4208 2 => PrintError::Nomem,
4209 3 => PrintError::InvalidFile,
4210 value => PrintError::__Unknown(value),
4211 }
4212 }
4213}
4214
4215impl ErrorDomain for PrintError {
4216 fn domain() -> Quark {
4217 skip_assert_initialized!();
4218 unsafe { from_glib(gtk_sys::gtk_print_error_quark()) }
4219 }
4220
4221 fn code(self) -> i32 {
4222 self.to_glib()
4223 }
4224
4225 fn from(code: i32) -> Option<Self> {
4226 skip_assert_initialized!();
4227 match code {
4228 0 => Some(PrintError::General),
4229 1 => Some(PrintError::InternalError),
4230 2 => Some(PrintError::Nomem),
4231 3 => Some(PrintError::InvalidFile),
4232 value => Some(PrintError::__Unknown(value)),
4233 }
4234 }
4235}
4236
4237impl StaticType for PrintError {
4238 fn static_type() -> Type {
4239 unsafe { from_glib(gtk_sys::gtk_print_error_get_type()) }
4240 }
4241}
4242
4243impl<'a> FromValueOptional<'a> for PrintError {
4244 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4245 Some(FromValue::from_value(value))
4246 }
4247}
4248
4249impl<'a> FromValue<'a> for PrintError {
4250 unsafe fn from_value(value: &Value) -> Self {
4251 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4252 }
4253}
4254
4255impl SetValue for PrintError {
4256 unsafe fn set_value(value: &mut Value, this: &Self) {
4257 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4258 }
4259}
4260
4261#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4262pub enum PrintOperationAction {
4263 PrintDialog,
4264 Print,
4265 Preview,
4266 Export,
4267 #[doc(hidden)]
4268 __Unknown(i32),
4269}
4270
4271impl fmt::Display for PrintOperationAction {
4272 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4273 write!(
4274 f,
4275 "PrintOperationAction::{}",
4276 match *self {
4277 PrintOperationAction::PrintDialog => "PrintDialog",
4278 PrintOperationAction::Print => "Print",
4279 PrintOperationAction::Preview => "Preview",
4280 PrintOperationAction::Export => "Export",
4281 _ => "Unknown",
4282 }
4283 )
4284 }
4285}
4286
4287#[doc(hidden)]
4288impl ToGlib for PrintOperationAction {
4289 type GlibType = gtk_sys::GtkPrintOperationAction;
4290
4291 fn to_glib(&self) -> gtk_sys::GtkPrintOperationAction {
4292 match *self {
4293 PrintOperationAction::PrintDialog => gtk_sys::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
4294 PrintOperationAction::Print => gtk_sys::GTK_PRINT_OPERATION_ACTION_PRINT,
4295 PrintOperationAction::Preview => gtk_sys::GTK_PRINT_OPERATION_ACTION_PREVIEW,
4296 PrintOperationAction::Export => gtk_sys::GTK_PRINT_OPERATION_ACTION_EXPORT,
4297 PrintOperationAction::__Unknown(value) => value,
4298 }
4299 }
4300}
4301
4302#[doc(hidden)]
4303impl FromGlib<gtk_sys::GtkPrintOperationAction> for PrintOperationAction {
4304 fn from_glib(value: gtk_sys::GtkPrintOperationAction) -> Self {
4305 skip_assert_initialized!();
4306 match value {
4307 0 => PrintOperationAction::PrintDialog,
4308 1 => PrintOperationAction::Print,
4309 2 => PrintOperationAction::Preview,
4310 3 => PrintOperationAction::Export,
4311 value => PrintOperationAction::__Unknown(value),
4312 }
4313 }
4314}
4315
4316impl StaticType for PrintOperationAction {
4317 fn static_type() -> Type {
4318 unsafe { from_glib(gtk_sys::gtk_print_operation_action_get_type()) }
4319 }
4320}
4321
4322impl<'a> FromValueOptional<'a> for PrintOperationAction {
4323 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4324 Some(FromValue::from_value(value))
4325 }
4326}
4327
4328impl<'a> FromValue<'a> for PrintOperationAction {
4329 unsafe fn from_value(value: &Value) -> Self {
4330 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4331 }
4332}
4333
4334impl SetValue for PrintOperationAction {
4335 unsafe fn set_value(value: &mut Value, this: &Self) {
4336 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4337 }
4338}
4339
4340#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4341pub enum PrintOperationResult {
4342 Error,
4343 Apply,
4344 Cancel,
4345 InProgress,
4346 #[doc(hidden)]
4347 __Unknown(i32),
4348}
4349
4350impl fmt::Display for PrintOperationResult {
4351 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4352 write!(
4353 f,
4354 "PrintOperationResult::{}",
4355 match *self {
4356 PrintOperationResult::Error => "Error",
4357 PrintOperationResult::Apply => "Apply",
4358 PrintOperationResult::Cancel => "Cancel",
4359 PrintOperationResult::InProgress => "InProgress",
4360 _ => "Unknown",
4361 }
4362 )
4363 }
4364}
4365
4366#[doc(hidden)]
4367impl ToGlib for PrintOperationResult {
4368 type GlibType = gtk_sys::GtkPrintOperationResult;
4369
4370 fn to_glib(&self) -> gtk_sys::GtkPrintOperationResult {
4371 match *self {
4372 PrintOperationResult::Error => gtk_sys::GTK_PRINT_OPERATION_RESULT_ERROR,
4373 PrintOperationResult::Apply => gtk_sys::GTK_PRINT_OPERATION_RESULT_APPLY,
4374 PrintOperationResult::Cancel => gtk_sys::GTK_PRINT_OPERATION_RESULT_CANCEL,
4375 PrintOperationResult::InProgress => gtk_sys::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS,
4376 PrintOperationResult::__Unknown(value) => value,
4377 }
4378 }
4379}
4380
4381#[doc(hidden)]
4382impl FromGlib<gtk_sys::GtkPrintOperationResult> for PrintOperationResult {
4383 fn from_glib(value: gtk_sys::GtkPrintOperationResult) -> Self {
4384 skip_assert_initialized!();
4385 match value {
4386 0 => PrintOperationResult::Error,
4387 1 => PrintOperationResult::Apply,
4388 2 => PrintOperationResult::Cancel,
4389 3 => PrintOperationResult::InProgress,
4390 value => PrintOperationResult::__Unknown(value),
4391 }
4392 }
4393}
4394
4395impl StaticType for PrintOperationResult {
4396 fn static_type() -> Type {
4397 unsafe { from_glib(gtk_sys::gtk_print_operation_result_get_type()) }
4398 }
4399}
4400
4401impl<'a> FromValueOptional<'a> for PrintOperationResult {
4402 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4403 Some(FromValue::from_value(value))
4404 }
4405}
4406
4407impl<'a> FromValue<'a> for PrintOperationResult {
4408 unsafe fn from_value(value: &Value) -> Self {
4409 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4410 }
4411}
4412
4413impl SetValue for PrintOperationResult {
4414 unsafe fn set_value(value: &mut Value, this: &Self) {
4415 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4416 }
4417}
4418
4419#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4420pub enum PrintPages {
4421 All,
4422 Current,
4423 Ranges,
4424 Selection,
4425 #[doc(hidden)]
4426 __Unknown(i32),
4427}
4428
4429impl fmt::Display for PrintPages {
4430 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4431 write!(
4432 f,
4433 "PrintPages::{}",
4434 match *self {
4435 PrintPages::All => "All",
4436 PrintPages::Current => "Current",
4437 PrintPages::Ranges => "Ranges",
4438 PrintPages::Selection => "Selection",
4439 _ => "Unknown",
4440 }
4441 )
4442 }
4443}
4444
4445#[doc(hidden)]
4446impl ToGlib for PrintPages {
4447 type GlibType = gtk_sys::GtkPrintPages;
4448
4449 fn to_glib(&self) -> gtk_sys::GtkPrintPages {
4450 match *self {
4451 PrintPages::All => gtk_sys::GTK_PRINT_PAGES_ALL,
4452 PrintPages::Current => gtk_sys::GTK_PRINT_PAGES_CURRENT,
4453 PrintPages::Ranges => gtk_sys::GTK_PRINT_PAGES_RANGES,
4454 PrintPages::Selection => gtk_sys::GTK_PRINT_PAGES_SELECTION,
4455 PrintPages::__Unknown(value) => value,
4456 }
4457 }
4458}
4459
4460#[doc(hidden)]
4461impl FromGlib<gtk_sys::GtkPrintPages> for PrintPages {
4462 fn from_glib(value: gtk_sys::GtkPrintPages) -> Self {
4463 skip_assert_initialized!();
4464 match value {
4465 0 => PrintPages::All,
4466 1 => PrintPages::Current,
4467 2 => PrintPages::Ranges,
4468 3 => PrintPages::Selection,
4469 value => PrintPages::__Unknown(value),
4470 }
4471 }
4472}
4473
4474impl StaticType for PrintPages {
4475 fn static_type() -> Type {
4476 unsafe { from_glib(gtk_sys::gtk_print_pages_get_type()) }
4477 }
4478}
4479
4480impl<'a> FromValueOptional<'a> for PrintPages {
4481 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4482 Some(FromValue::from_value(value))
4483 }
4484}
4485
4486impl<'a> FromValue<'a> for PrintPages {
4487 unsafe fn from_value(value: &Value) -> Self {
4488 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4489 }
4490}
4491
4492impl SetValue for PrintPages {
4493 unsafe fn set_value(value: &mut Value, this: &Self) {
4494 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4495 }
4496}
4497
4498#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4499pub enum PrintQuality {
4500 Low,
4501 Normal,
4502 High,
4503 Draft,
4504 #[doc(hidden)]
4505 __Unknown(i32),
4506}
4507
4508impl fmt::Display for PrintQuality {
4509 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4510 write!(
4511 f,
4512 "PrintQuality::{}",
4513 match *self {
4514 PrintQuality::Low => "Low",
4515 PrintQuality::Normal => "Normal",
4516 PrintQuality::High => "High",
4517 PrintQuality::Draft => "Draft",
4518 _ => "Unknown",
4519 }
4520 )
4521 }
4522}
4523
4524#[doc(hidden)]
4525impl ToGlib for PrintQuality {
4526 type GlibType = gtk_sys::GtkPrintQuality;
4527
4528 fn to_glib(&self) -> gtk_sys::GtkPrintQuality {
4529 match *self {
4530 PrintQuality::Low => gtk_sys::GTK_PRINT_QUALITY_LOW,
4531 PrintQuality::Normal => gtk_sys::GTK_PRINT_QUALITY_NORMAL,
4532 PrintQuality::High => gtk_sys::GTK_PRINT_QUALITY_HIGH,
4533 PrintQuality::Draft => gtk_sys::GTK_PRINT_QUALITY_DRAFT,
4534 PrintQuality::__Unknown(value) => value,
4535 }
4536 }
4537}
4538
4539#[doc(hidden)]
4540impl FromGlib<gtk_sys::GtkPrintQuality> for PrintQuality {
4541 fn from_glib(value: gtk_sys::GtkPrintQuality) -> Self {
4542 skip_assert_initialized!();
4543 match value {
4544 0 => PrintQuality::Low,
4545 1 => PrintQuality::Normal,
4546 2 => PrintQuality::High,
4547 3 => PrintQuality::Draft,
4548 value => PrintQuality::__Unknown(value),
4549 }
4550 }
4551}
4552
4553impl StaticType for PrintQuality {
4554 fn static_type() -> Type {
4555 unsafe { from_glib(gtk_sys::gtk_print_quality_get_type()) }
4556 }
4557}
4558
4559impl<'a> FromValueOptional<'a> for PrintQuality {
4560 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4561 Some(FromValue::from_value(value))
4562 }
4563}
4564
4565impl<'a> FromValue<'a> for PrintQuality {
4566 unsafe fn from_value(value: &Value) -> Self {
4567 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4568 }
4569}
4570
4571impl SetValue for PrintQuality {
4572 unsafe fn set_value(value: &mut Value, this: &Self) {
4573 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4574 }
4575}
4576
4577#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4578pub enum PrintStatus {
4579 Initial,
4580 Preparing,
4581 GeneratingData,
4582 SendingData,
4583 Pending,
4584 PendingIssue,
4585 Printing,
4586 Finished,
4587 FinishedAborted,
4588 #[doc(hidden)]
4589 __Unknown(i32),
4590}
4591
4592impl fmt::Display for PrintStatus {
4593 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4594 write!(
4595 f,
4596 "PrintStatus::{}",
4597 match *self {
4598 PrintStatus::Initial => "Initial",
4599 PrintStatus::Preparing => "Preparing",
4600 PrintStatus::GeneratingData => "GeneratingData",
4601 PrintStatus::SendingData => "SendingData",
4602 PrintStatus::Pending => "Pending",
4603 PrintStatus::PendingIssue => "PendingIssue",
4604 PrintStatus::Printing => "Printing",
4605 PrintStatus::Finished => "Finished",
4606 PrintStatus::FinishedAborted => "FinishedAborted",
4607 _ => "Unknown",
4608 }
4609 )
4610 }
4611}
4612
4613#[doc(hidden)]
4614impl ToGlib for PrintStatus {
4615 type GlibType = gtk_sys::GtkPrintStatus;
4616
4617 fn to_glib(&self) -> gtk_sys::GtkPrintStatus {
4618 match *self {
4619 PrintStatus::Initial => gtk_sys::GTK_PRINT_STATUS_INITIAL,
4620 PrintStatus::Preparing => gtk_sys::GTK_PRINT_STATUS_PREPARING,
4621 PrintStatus::GeneratingData => gtk_sys::GTK_PRINT_STATUS_GENERATING_DATA,
4622 PrintStatus::SendingData => gtk_sys::GTK_PRINT_STATUS_SENDING_DATA,
4623 PrintStatus::Pending => gtk_sys::GTK_PRINT_STATUS_PENDING,
4624 PrintStatus::PendingIssue => gtk_sys::GTK_PRINT_STATUS_PENDING_ISSUE,
4625 PrintStatus::Printing => gtk_sys::GTK_PRINT_STATUS_PRINTING,
4626 PrintStatus::Finished => gtk_sys::GTK_PRINT_STATUS_FINISHED,
4627 PrintStatus::FinishedAborted => gtk_sys::GTK_PRINT_STATUS_FINISHED_ABORTED,
4628 PrintStatus::__Unknown(value) => value,
4629 }
4630 }
4631}
4632
4633#[doc(hidden)]
4634impl FromGlib<gtk_sys::GtkPrintStatus> for PrintStatus {
4635 fn from_glib(value: gtk_sys::GtkPrintStatus) -> Self {
4636 skip_assert_initialized!();
4637 match value {
4638 0 => PrintStatus::Initial,
4639 1 => PrintStatus::Preparing,
4640 2 => PrintStatus::GeneratingData,
4641 3 => PrintStatus::SendingData,
4642 4 => PrintStatus::Pending,
4643 5 => PrintStatus::PendingIssue,
4644 6 => PrintStatus::Printing,
4645 7 => PrintStatus::Finished,
4646 8 => PrintStatus::FinishedAborted,
4647 value => PrintStatus::__Unknown(value),
4648 }
4649 }
4650}
4651
4652impl StaticType for PrintStatus {
4653 fn static_type() -> Type {
4654 unsafe { from_glib(gtk_sys::gtk_print_status_get_type()) }
4655 }
4656}
4657
4658impl<'a> FromValueOptional<'a> for PrintStatus {
4659 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4660 Some(FromValue::from_value(value))
4661 }
4662}
4663
4664impl<'a> FromValue<'a> for PrintStatus {
4665 unsafe fn from_value(value: &Value) -> Self {
4666 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4667 }
4668}
4669
4670impl SetValue for PrintStatus {
4671 unsafe fn set_value(value: &mut Value, this: &Self) {
4672 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4673 }
4674}
4675
4676#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4677pub enum PropagationPhase {
4678 None,
4679 Capture,
4680 Bubble,
4681 Target,
4682 #[doc(hidden)]
4683 __Unknown(i32),
4684}
4685
4686impl fmt::Display for PropagationPhase {
4687 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4688 write!(
4689 f,
4690 "PropagationPhase::{}",
4691 match *self {
4692 PropagationPhase::None => "None",
4693 PropagationPhase::Capture => "Capture",
4694 PropagationPhase::Bubble => "Bubble",
4695 PropagationPhase::Target => "Target",
4696 _ => "Unknown",
4697 }
4698 )
4699 }
4700}
4701
4702#[doc(hidden)]
4703impl ToGlib for PropagationPhase {
4704 type GlibType = gtk_sys::GtkPropagationPhase;
4705
4706 fn to_glib(&self) -> gtk_sys::GtkPropagationPhase {
4707 match *self {
4708 PropagationPhase::None => gtk_sys::GTK_PHASE_NONE,
4709 PropagationPhase::Capture => gtk_sys::GTK_PHASE_CAPTURE,
4710 PropagationPhase::Bubble => gtk_sys::GTK_PHASE_BUBBLE,
4711 PropagationPhase::Target => gtk_sys::GTK_PHASE_TARGET,
4712 PropagationPhase::__Unknown(value) => value,
4713 }
4714 }
4715}
4716
4717#[doc(hidden)]
4718impl FromGlib<gtk_sys::GtkPropagationPhase> for PropagationPhase {
4719 fn from_glib(value: gtk_sys::GtkPropagationPhase) -> Self {
4720 skip_assert_initialized!();
4721 match value {
4722 0 => PropagationPhase::None,
4723 1 => PropagationPhase::Capture,
4724 2 => PropagationPhase::Bubble,
4725 3 => PropagationPhase::Target,
4726 value => PropagationPhase::__Unknown(value),
4727 }
4728 }
4729}
4730
4731impl StaticType for PropagationPhase {
4732 fn static_type() -> Type {
4733 unsafe { from_glib(gtk_sys::gtk_propagation_phase_get_type()) }
4734 }
4735}
4736
4737impl<'a> FromValueOptional<'a> for PropagationPhase {
4738 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4739 Some(FromValue::from_value(value))
4740 }
4741}
4742
4743impl<'a> FromValue<'a> for PropagationPhase {
4744 unsafe fn from_value(value: &Value) -> Self {
4745 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4746 }
4747}
4748
4749impl SetValue for PropagationPhase {
4750 unsafe fn set_value(value: &mut Value, this: &Self) {
4751 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4752 }
4753}
4754
4755#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4756pub enum RecentChooserError {
4757 NotFound,
4758 InvalidUri,
4759 #[doc(hidden)]
4760 __Unknown(i32),
4761}
4762
4763impl fmt::Display for RecentChooserError {
4764 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4765 write!(
4766 f,
4767 "RecentChooserError::{}",
4768 match *self {
4769 RecentChooserError::NotFound => "NotFound",
4770 RecentChooserError::InvalidUri => "InvalidUri",
4771 _ => "Unknown",
4772 }
4773 )
4774 }
4775}
4776
4777#[doc(hidden)]
4778impl ToGlib for RecentChooserError {
4779 type GlibType = gtk_sys::GtkRecentChooserError;
4780
4781 fn to_glib(&self) -> gtk_sys::GtkRecentChooserError {
4782 match *self {
4783 RecentChooserError::NotFound => gtk_sys::GTK_RECENT_CHOOSER_ERROR_NOT_FOUND,
4784 RecentChooserError::InvalidUri => gtk_sys::GTK_RECENT_CHOOSER_ERROR_INVALID_URI,
4785 RecentChooserError::__Unknown(value) => value,
4786 }
4787 }
4788}
4789
4790#[doc(hidden)]
4791impl FromGlib<gtk_sys::GtkRecentChooserError> for RecentChooserError {
4792 fn from_glib(value: gtk_sys::GtkRecentChooserError) -> Self {
4793 skip_assert_initialized!();
4794 match value {
4795 0 => RecentChooserError::NotFound,
4796 1 => RecentChooserError::InvalidUri,
4797 value => RecentChooserError::__Unknown(value),
4798 }
4799 }
4800}
4801
4802impl ErrorDomain for RecentChooserError {
4803 fn domain() -> Quark {
4804 skip_assert_initialized!();
4805 unsafe { from_glib(gtk_sys::gtk_recent_chooser_error_quark()) }
4806 }
4807
4808 fn code(self) -> i32 {
4809 self.to_glib()
4810 }
4811
4812 fn from(code: i32) -> Option<Self> {
4813 skip_assert_initialized!();
4814 match code {
4815 0 => Some(RecentChooserError::NotFound),
4816 1 => Some(RecentChooserError::InvalidUri),
4817 value => Some(RecentChooserError::__Unknown(value)),
4818 }
4819 }
4820}
4821
4822impl StaticType for RecentChooserError {
4823 fn static_type() -> Type {
4824 unsafe { from_glib(gtk_sys::gtk_recent_chooser_error_get_type()) }
4825 }
4826}
4827
4828impl<'a> FromValueOptional<'a> for RecentChooserError {
4829 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4830 Some(FromValue::from_value(value))
4831 }
4832}
4833
4834impl<'a> FromValue<'a> for RecentChooserError {
4835 unsafe fn from_value(value: &Value) -> Self {
4836 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4837 }
4838}
4839
4840impl SetValue for RecentChooserError {
4841 unsafe fn set_value(value: &mut Value, this: &Self) {
4842 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4843 }
4844}
4845
4846#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4847pub enum RecentManagerError {
4848 NotFound,
4849 InvalidUri,
4850 InvalidEncoding,
4851 NotRegistered,
4852 Read,
4853 Write,
4854 Unknown,
4855 #[doc(hidden)]
4856 __Unknown(i32),
4857}
4858
4859impl fmt::Display for RecentManagerError {
4860 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4861 write!(
4862 f,
4863 "RecentManagerError::{}",
4864 match *self {
4865 RecentManagerError::NotFound => "NotFound",
4866 RecentManagerError::InvalidUri => "InvalidUri",
4867 RecentManagerError::InvalidEncoding => "InvalidEncoding",
4868 RecentManagerError::NotRegistered => "NotRegistered",
4869 RecentManagerError::Read => "Read",
4870 RecentManagerError::Write => "Write",
4871 RecentManagerError::Unknown => "Unknown",
4872 _ => "Unknown",
4873 }
4874 )
4875 }
4876}
4877
4878#[doc(hidden)]
4879impl ToGlib for RecentManagerError {
4880 type GlibType = gtk_sys::GtkRecentManagerError;
4881
4882 fn to_glib(&self) -> gtk_sys::GtkRecentManagerError {
4883 match *self {
4884 RecentManagerError::NotFound => gtk_sys::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
4885 RecentManagerError::InvalidUri => gtk_sys::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
4886 RecentManagerError::InvalidEncoding => {
4887 gtk_sys::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING
4888 }
4889 RecentManagerError::NotRegistered => gtk_sys::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
4890 RecentManagerError::Read => gtk_sys::GTK_RECENT_MANAGER_ERROR_READ,
4891 RecentManagerError::Write => gtk_sys::GTK_RECENT_MANAGER_ERROR_WRITE,
4892 RecentManagerError::Unknown => gtk_sys::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
4893 RecentManagerError::__Unknown(value) => value,
4894 }
4895 }
4896}
4897
4898#[doc(hidden)]
4899impl FromGlib<gtk_sys::GtkRecentManagerError> for RecentManagerError {
4900 fn from_glib(value: gtk_sys::GtkRecentManagerError) -> Self {
4901 skip_assert_initialized!();
4902 match value {
4903 0 => RecentManagerError::NotFound,
4904 1 => RecentManagerError::InvalidUri,
4905 2 => RecentManagerError::InvalidEncoding,
4906 3 => RecentManagerError::NotRegistered,
4907 4 => RecentManagerError::Read,
4908 5 => RecentManagerError::Write,
4909 6 => RecentManagerError::Unknown,
4910 value => RecentManagerError::__Unknown(value),
4911 }
4912 }
4913}
4914
4915impl ErrorDomain for RecentManagerError {
4916 fn domain() -> Quark {
4917 skip_assert_initialized!();
4918 unsafe { from_glib(gtk_sys::gtk_recent_manager_error_quark()) }
4919 }
4920
4921 fn code(self) -> i32 {
4922 self.to_glib()
4923 }
4924
4925 fn from(code: i32) -> Option<Self> {
4926 skip_assert_initialized!();
4927 match code {
4928 0 => Some(RecentManagerError::NotFound),
4929 1 => Some(RecentManagerError::InvalidUri),
4930 2 => Some(RecentManagerError::InvalidEncoding),
4931 3 => Some(RecentManagerError::NotRegistered),
4932 4 => Some(RecentManagerError::Read),
4933 5 => Some(RecentManagerError::Write),
4934 6 => Some(RecentManagerError::Unknown),
4935 value => Some(RecentManagerError::__Unknown(value)),
4936 }
4937 }
4938}
4939
4940impl StaticType for RecentManagerError {
4941 fn static_type() -> Type {
4942 unsafe { from_glib(gtk_sys::gtk_recent_manager_error_get_type()) }
4943 }
4944}
4945
4946impl<'a> FromValueOptional<'a> for RecentManagerError {
4947 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4948 Some(FromValue::from_value(value))
4949 }
4950}
4951
4952impl<'a> FromValue<'a> for RecentManagerError {
4953 unsafe fn from_value(value: &Value) -> Self {
4954 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4955 }
4956}
4957
4958impl SetValue for RecentManagerError {
4959 unsafe fn set_value(value: &mut Value, this: &Self) {
4960 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4961 }
4962}
4963
4964#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4965pub enum RecentSortType {
4966 None,
4967 Mru,
4968 Lru,
4969 Custom,
4970 #[doc(hidden)]
4971 __Unknown(i32),
4972}
4973
4974impl fmt::Display for RecentSortType {
4975 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4976 write!(
4977 f,
4978 "RecentSortType::{}",
4979 match *self {
4980 RecentSortType::None => "None",
4981 RecentSortType::Mru => "Mru",
4982 RecentSortType::Lru => "Lru",
4983 RecentSortType::Custom => "Custom",
4984 _ => "Unknown",
4985 }
4986 )
4987 }
4988}
4989
4990#[doc(hidden)]
4991impl ToGlib for RecentSortType {
4992 type GlibType = gtk_sys::GtkRecentSortType;
4993
4994 fn to_glib(&self) -> gtk_sys::GtkRecentSortType {
4995 match *self {
4996 RecentSortType::None => gtk_sys::GTK_RECENT_SORT_NONE,
4997 RecentSortType::Mru => gtk_sys::GTK_RECENT_SORT_MRU,
4998 RecentSortType::Lru => gtk_sys::GTK_RECENT_SORT_LRU,
4999 RecentSortType::Custom => gtk_sys::GTK_RECENT_SORT_CUSTOM,
5000 RecentSortType::__Unknown(value) => value,
5001 }
5002 }
5003}
5004
5005#[doc(hidden)]
5006impl FromGlib<gtk_sys::GtkRecentSortType> for RecentSortType {
5007 fn from_glib(value: gtk_sys::GtkRecentSortType) -> Self {
5008 skip_assert_initialized!();
5009 match value {
5010 0 => RecentSortType::None,
5011 1 => RecentSortType::Mru,
5012 2 => RecentSortType::Lru,
5013 3 => RecentSortType::Custom,
5014 value => RecentSortType::__Unknown(value),
5015 }
5016 }
5017}
5018
5019impl StaticType for RecentSortType {
5020 fn static_type() -> Type {
5021 unsafe { from_glib(gtk_sys::gtk_recent_sort_type_get_type()) }
5022 }
5023}
5024
5025impl<'a> FromValueOptional<'a> for RecentSortType {
5026 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5027 Some(FromValue::from_value(value))
5028 }
5029}
5030
5031impl<'a> FromValue<'a> for RecentSortType {
5032 unsafe fn from_value(value: &Value) -> Self {
5033 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5034 }
5035}
5036
5037impl SetValue for RecentSortType {
5038 unsafe fn set_value(value: &mut Value, this: &Self) {
5039 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5040 }
5041}
5042
5043#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5044pub enum ReliefStyle {
5045 Normal,
5046 Half,
5047 None,
5048 #[doc(hidden)]
5049 __Unknown(i32),
5050}
5051
5052impl fmt::Display for ReliefStyle {
5053 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5054 write!(
5055 f,
5056 "ReliefStyle::{}",
5057 match *self {
5058 ReliefStyle::Normal => "Normal",
5059 ReliefStyle::Half => "Half",
5060 ReliefStyle::None => "None",
5061 _ => "Unknown",
5062 }
5063 )
5064 }
5065}
5066
5067#[doc(hidden)]
5068impl ToGlib for ReliefStyle {
5069 type GlibType = gtk_sys::GtkReliefStyle;
5070
5071 fn to_glib(&self) -> gtk_sys::GtkReliefStyle {
5072 match *self {
5073 ReliefStyle::Normal => gtk_sys::GTK_RELIEF_NORMAL,
5074 ReliefStyle::Half => gtk_sys::GTK_RELIEF_HALF,
5075 ReliefStyle::None => gtk_sys::GTK_RELIEF_NONE,
5076 ReliefStyle::__Unknown(value) => value,
5077 }
5078 }
5079}
5080
5081#[doc(hidden)]
5082impl FromGlib<gtk_sys::GtkReliefStyle> for ReliefStyle {
5083 fn from_glib(value: gtk_sys::GtkReliefStyle) -> Self {
5084 skip_assert_initialized!();
5085 match value {
5086 0 => ReliefStyle::Normal,
5087 1 => ReliefStyle::Half,
5088 2 => ReliefStyle::None,
5089 value => ReliefStyle::__Unknown(value),
5090 }
5091 }
5092}
5093
5094impl StaticType for ReliefStyle {
5095 fn static_type() -> Type {
5096 unsafe { from_glib(gtk_sys::gtk_relief_style_get_type()) }
5097 }
5098}
5099
5100impl<'a> FromValueOptional<'a> for ReliefStyle {
5101 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5102 Some(FromValue::from_value(value))
5103 }
5104}
5105
5106impl<'a> FromValue<'a> for ReliefStyle {
5107 unsafe fn from_value(value: &Value) -> Self {
5108 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5109 }
5110}
5111
5112impl SetValue for ReliefStyle {
5113 unsafe fn set_value(value: &mut Value, this: &Self) {
5114 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5115 }
5116}
5117
5118#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5119pub enum ResizeMode {
5120 Parent,
5121 Queue,
5122 Immediate,
5123 #[doc(hidden)]
5124 __Unknown(i32),
5125}
5126
5127impl fmt::Display for ResizeMode {
5128 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5129 write!(
5130 f,
5131 "ResizeMode::{}",
5132 match *self {
5133 ResizeMode::Parent => "Parent",
5134 ResizeMode::Queue => "Queue",
5135 ResizeMode::Immediate => "Immediate",
5136 _ => "Unknown",
5137 }
5138 )
5139 }
5140}
5141
5142#[doc(hidden)]
5143impl ToGlib for ResizeMode {
5144 type GlibType = gtk_sys::GtkResizeMode;
5145
5146 fn to_glib(&self) -> gtk_sys::GtkResizeMode {
5147 match *self {
5148 ResizeMode::Parent => gtk_sys::GTK_RESIZE_PARENT,
5149 ResizeMode::Queue => gtk_sys::GTK_RESIZE_QUEUE,
5150 ResizeMode::Immediate => gtk_sys::GTK_RESIZE_IMMEDIATE,
5151 ResizeMode::__Unknown(value) => value,
5152 }
5153 }
5154}
5155
5156#[doc(hidden)]
5157impl FromGlib<gtk_sys::GtkResizeMode> for ResizeMode {
5158 fn from_glib(value: gtk_sys::GtkResizeMode) -> Self {
5159 skip_assert_initialized!();
5160 match value {
5161 0 => ResizeMode::Parent,
5162 1 => ResizeMode::Queue,
5163 2 => ResizeMode::Immediate,
5164 value => ResizeMode::__Unknown(value),
5165 }
5166 }
5167}
5168
5169impl StaticType for ResizeMode {
5170 fn static_type() -> Type {
5171 unsafe { from_glib(gtk_sys::gtk_resize_mode_get_type()) }
5172 }
5173}
5174
5175impl<'a> FromValueOptional<'a> for ResizeMode {
5176 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5177 Some(FromValue::from_value(value))
5178 }
5179}
5180
5181impl<'a> FromValue<'a> for ResizeMode {
5182 unsafe fn from_value(value: &Value) -> Self {
5183 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5184 }
5185}
5186
5187impl SetValue for ResizeMode {
5188 unsafe fn set_value(value: &mut Value, this: &Self) {
5189 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5190 }
5191}
5192
5193#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5194pub enum RevealerTransitionType {
5195 None,
5196 Crossfade,
5197 SlideRight,
5198 SlideLeft,
5199 SlideUp,
5200 SlideDown,
5201 #[doc(hidden)]
5202 __Unknown(i32),
5203}
5204
5205impl fmt::Display for RevealerTransitionType {
5206 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5207 write!(
5208 f,
5209 "RevealerTransitionType::{}",
5210 match *self {
5211 RevealerTransitionType::None => "None",
5212 RevealerTransitionType::Crossfade => "Crossfade",
5213 RevealerTransitionType::SlideRight => "SlideRight",
5214 RevealerTransitionType::SlideLeft => "SlideLeft",
5215 RevealerTransitionType::SlideUp => "SlideUp",
5216 RevealerTransitionType::SlideDown => "SlideDown",
5217 _ => "Unknown",
5218 }
5219 )
5220 }
5221}
5222
5223#[doc(hidden)]
5224impl ToGlib for RevealerTransitionType {
5225 type GlibType = gtk_sys::GtkRevealerTransitionType;
5226
5227 fn to_glib(&self) -> gtk_sys::GtkRevealerTransitionType {
5228 match *self {
5229 RevealerTransitionType::None => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_NONE,
5230 RevealerTransitionType::Crossfade => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
5231 RevealerTransitionType::SlideRight => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
5232 RevealerTransitionType::SlideLeft => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
5233 RevealerTransitionType::SlideUp => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
5234 RevealerTransitionType::SlideDown => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
5235 RevealerTransitionType::__Unknown(value) => value,
5236 }
5237 }
5238}
5239
5240#[doc(hidden)]
5241impl FromGlib<gtk_sys::GtkRevealerTransitionType> for RevealerTransitionType {
5242 fn from_glib(value: gtk_sys::GtkRevealerTransitionType) -> Self {
5243 skip_assert_initialized!();
5244 match value {
5245 0 => RevealerTransitionType::None,
5246 1 => RevealerTransitionType::Crossfade,
5247 2 => RevealerTransitionType::SlideRight,
5248 3 => RevealerTransitionType::SlideLeft,
5249 4 => RevealerTransitionType::SlideUp,
5250 5 => RevealerTransitionType::SlideDown,
5251 value => RevealerTransitionType::__Unknown(value),
5252 }
5253 }
5254}
5255
5256impl StaticType for RevealerTransitionType {
5257 fn static_type() -> Type {
5258 unsafe { from_glib(gtk_sys::gtk_revealer_transition_type_get_type()) }
5259 }
5260}
5261
5262impl<'a> FromValueOptional<'a> for RevealerTransitionType {
5263 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5264 Some(FromValue::from_value(value))
5265 }
5266}
5267
5268impl<'a> FromValue<'a> for RevealerTransitionType {
5269 unsafe fn from_value(value: &Value) -> Self {
5270 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5271 }
5272}
5273
5274impl SetValue for RevealerTransitionType {
5275 unsafe fn set_value(value: &mut Value, this: &Self) {
5276 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5277 }
5278}
5279
5280#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5281pub enum ScrollStep {
5282 Steps,
5283 Pages,
5284 Ends,
5285 HorizontalSteps,
5286 HorizontalPages,
5287 HorizontalEnds,
5288 #[doc(hidden)]
5289 __Unknown(i32),
5290}
5291
5292impl fmt::Display for ScrollStep {
5293 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5294 write!(
5295 f,
5296 "ScrollStep::{}",
5297 match *self {
5298 ScrollStep::Steps => "Steps",
5299 ScrollStep::Pages => "Pages",
5300 ScrollStep::Ends => "Ends",
5301 ScrollStep::HorizontalSteps => "HorizontalSteps",
5302 ScrollStep::HorizontalPages => "HorizontalPages",
5303 ScrollStep::HorizontalEnds => "HorizontalEnds",
5304 _ => "Unknown",
5305 }
5306 )
5307 }
5308}
5309
5310#[doc(hidden)]
5311impl ToGlib for ScrollStep {
5312 type GlibType = gtk_sys::GtkScrollStep;
5313
5314 fn to_glib(&self) -> gtk_sys::GtkScrollStep {
5315 match *self {
5316 ScrollStep::Steps => gtk_sys::GTK_SCROLL_STEPS,
5317 ScrollStep::Pages => gtk_sys::GTK_SCROLL_PAGES,
5318 ScrollStep::Ends => gtk_sys::GTK_SCROLL_ENDS,
5319 ScrollStep::HorizontalSteps => gtk_sys::GTK_SCROLL_HORIZONTAL_STEPS,
5320 ScrollStep::HorizontalPages => gtk_sys::GTK_SCROLL_HORIZONTAL_PAGES,
5321 ScrollStep::HorizontalEnds => gtk_sys::GTK_SCROLL_HORIZONTAL_ENDS,
5322 ScrollStep::__Unknown(value) => value,
5323 }
5324 }
5325}
5326
5327#[doc(hidden)]
5328impl FromGlib<gtk_sys::GtkScrollStep> for ScrollStep {
5329 fn from_glib(value: gtk_sys::GtkScrollStep) -> Self {
5330 skip_assert_initialized!();
5331 match value {
5332 0 => ScrollStep::Steps,
5333 1 => ScrollStep::Pages,
5334 2 => ScrollStep::Ends,
5335 3 => ScrollStep::HorizontalSteps,
5336 4 => ScrollStep::HorizontalPages,
5337 5 => ScrollStep::HorizontalEnds,
5338 value => ScrollStep::__Unknown(value),
5339 }
5340 }
5341}
5342
5343impl StaticType for ScrollStep {
5344 fn static_type() -> Type {
5345 unsafe { from_glib(gtk_sys::gtk_scroll_step_get_type()) }
5346 }
5347}
5348
5349impl<'a> FromValueOptional<'a> for ScrollStep {
5350 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5351 Some(FromValue::from_value(value))
5352 }
5353}
5354
5355impl<'a> FromValue<'a> for ScrollStep {
5356 unsafe fn from_value(value: &Value) -> Self {
5357 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5358 }
5359}
5360
5361impl SetValue for ScrollStep {
5362 unsafe fn set_value(value: &mut Value, this: &Self) {
5363 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5364 }
5365}
5366
5367#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5368pub enum ScrollType {
5369 None,
5370 Jump,
5371 StepBackward,
5372 StepForward,
5373 PageBackward,
5374 PageForward,
5375 StepUp,
5376 StepDown,
5377 PageUp,
5378 PageDown,
5379 StepLeft,
5380 StepRight,
5381 PageLeft,
5382 PageRight,
5383 Start,
5384 End,
5385 #[doc(hidden)]
5386 __Unknown(i32),
5387}
5388
5389impl fmt::Display for ScrollType {
5390 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5391 write!(
5392 f,
5393 "ScrollType::{}",
5394 match *self {
5395 ScrollType::None => "None",
5396 ScrollType::Jump => "Jump",
5397 ScrollType::StepBackward => "StepBackward",
5398 ScrollType::StepForward => "StepForward",
5399 ScrollType::PageBackward => "PageBackward",
5400 ScrollType::PageForward => "PageForward",
5401 ScrollType::StepUp => "StepUp",
5402 ScrollType::StepDown => "StepDown",
5403 ScrollType::PageUp => "PageUp",
5404 ScrollType::PageDown => "PageDown",
5405 ScrollType::StepLeft => "StepLeft",
5406 ScrollType::StepRight => "StepRight",
5407 ScrollType::PageLeft => "PageLeft",
5408 ScrollType::PageRight => "PageRight",
5409 ScrollType::Start => "Start",
5410 ScrollType::End => "End",
5411 _ => "Unknown",
5412 }
5413 )
5414 }
5415}
5416
5417#[doc(hidden)]
5418impl ToGlib for ScrollType {
5419 type GlibType = gtk_sys::GtkScrollType;
5420
5421 fn to_glib(&self) -> gtk_sys::GtkScrollType {
5422 match *self {
5423 ScrollType::None => gtk_sys::GTK_SCROLL_NONE,
5424 ScrollType::Jump => gtk_sys::GTK_SCROLL_JUMP,
5425 ScrollType::StepBackward => gtk_sys::GTK_SCROLL_STEP_BACKWARD,
5426 ScrollType::StepForward => gtk_sys::GTK_SCROLL_STEP_FORWARD,
5427 ScrollType::PageBackward => gtk_sys::GTK_SCROLL_PAGE_BACKWARD,
5428 ScrollType::PageForward => gtk_sys::GTK_SCROLL_PAGE_FORWARD,
5429 ScrollType::StepUp => gtk_sys::GTK_SCROLL_STEP_UP,
5430 ScrollType::StepDown => gtk_sys::GTK_SCROLL_STEP_DOWN,
5431 ScrollType::PageUp => gtk_sys::GTK_SCROLL_PAGE_UP,
5432 ScrollType::PageDown => gtk_sys::GTK_SCROLL_PAGE_DOWN,
5433 ScrollType::StepLeft => gtk_sys::GTK_SCROLL_STEP_LEFT,
5434 ScrollType::StepRight => gtk_sys::GTK_SCROLL_STEP_RIGHT,
5435 ScrollType::PageLeft => gtk_sys::GTK_SCROLL_PAGE_LEFT,
5436 ScrollType::PageRight => gtk_sys::GTK_SCROLL_PAGE_RIGHT,
5437 ScrollType::Start => gtk_sys::GTK_SCROLL_START,
5438 ScrollType::End => gtk_sys::GTK_SCROLL_END,
5439 ScrollType::__Unknown(value) => value,
5440 }
5441 }
5442}
5443
5444#[doc(hidden)]
5445impl FromGlib<gtk_sys::GtkScrollType> for ScrollType {
5446 fn from_glib(value: gtk_sys::GtkScrollType) -> Self {
5447 skip_assert_initialized!();
5448 match value {
5449 0 => ScrollType::None,
5450 1 => ScrollType::Jump,
5451 2 => ScrollType::StepBackward,
5452 3 => ScrollType::StepForward,
5453 4 => ScrollType::PageBackward,
5454 5 => ScrollType::PageForward,
5455 6 => ScrollType::StepUp,
5456 7 => ScrollType::StepDown,
5457 8 => ScrollType::PageUp,
5458 9 => ScrollType::PageDown,
5459 10 => ScrollType::StepLeft,
5460 11 => ScrollType::StepRight,
5461 12 => ScrollType::PageLeft,
5462 13 => ScrollType::PageRight,
5463 14 => ScrollType::Start,
5464 15 => ScrollType::End,
5465 value => ScrollType::__Unknown(value),
5466 }
5467 }
5468}
5469
5470impl StaticType for ScrollType {
5471 fn static_type() -> Type {
5472 unsafe { from_glib(gtk_sys::gtk_scroll_type_get_type()) }
5473 }
5474}
5475
5476impl<'a> FromValueOptional<'a> for ScrollType {
5477 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5478 Some(FromValue::from_value(value))
5479 }
5480}
5481
5482impl<'a> FromValue<'a> for ScrollType {
5483 unsafe fn from_value(value: &Value) -> Self {
5484 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5485 }
5486}
5487
5488impl SetValue for ScrollType {
5489 unsafe fn set_value(value: &mut Value, this: &Self) {
5490 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5491 }
5492}
5493
5494#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5495pub enum ScrollablePolicy {
5496 Minimum,
5497 Natural,
5498 #[doc(hidden)]
5499 __Unknown(i32),
5500}
5501
5502impl fmt::Display for ScrollablePolicy {
5503 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5504 write!(
5505 f,
5506 "ScrollablePolicy::{}",
5507 match *self {
5508 ScrollablePolicy::Minimum => "Minimum",
5509 ScrollablePolicy::Natural => "Natural",
5510 _ => "Unknown",
5511 }
5512 )
5513 }
5514}
5515
5516#[doc(hidden)]
5517impl ToGlib for ScrollablePolicy {
5518 type GlibType = gtk_sys::GtkScrollablePolicy;
5519
5520 fn to_glib(&self) -> gtk_sys::GtkScrollablePolicy {
5521 match *self {
5522 ScrollablePolicy::Minimum => gtk_sys::GTK_SCROLL_MINIMUM,
5523 ScrollablePolicy::Natural => gtk_sys::GTK_SCROLL_NATURAL,
5524 ScrollablePolicy::__Unknown(value) => value,
5525 }
5526 }
5527}
5528
5529#[doc(hidden)]
5530impl FromGlib<gtk_sys::GtkScrollablePolicy> for ScrollablePolicy {
5531 fn from_glib(value: gtk_sys::GtkScrollablePolicy) -> Self {
5532 skip_assert_initialized!();
5533 match value {
5534 0 => ScrollablePolicy::Minimum,
5535 1 => ScrollablePolicy::Natural,
5536 value => ScrollablePolicy::__Unknown(value),
5537 }
5538 }
5539}
5540
5541impl StaticType for ScrollablePolicy {
5542 fn static_type() -> Type {
5543 unsafe { from_glib(gtk_sys::gtk_scrollable_policy_get_type()) }
5544 }
5545}
5546
5547impl<'a> FromValueOptional<'a> for ScrollablePolicy {
5548 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5549 Some(FromValue::from_value(value))
5550 }
5551}
5552
5553impl<'a> FromValue<'a> for ScrollablePolicy {
5554 unsafe fn from_value(value: &Value) -> Self {
5555 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5556 }
5557}
5558
5559impl SetValue for ScrollablePolicy {
5560 unsafe fn set_value(value: &mut Value, this: &Self) {
5561 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5562 }
5563}
5564
5565#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5566pub enum SelectionMode {
5567 None,
5568 Single,
5569 Browse,
5570 Multiple,
5571 #[doc(hidden)]
5572 __Unknown(i32),
5573}
5574
5575impl fmt::Display for SelectionMode {
5576 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5577 write!(
5578 f,
5579 "SelectionMode::{}",
5580 match *self {
5581 SelectionMode::None => "None",
5582 SelectionMode::Single => "Single",
5583 SelectionMode::Browse => "Browse",
5584 SelectionMode::Multiple => "Multiple",
5585 _ => "Unknown",
5586 }
5587 )
5588 }
5589}
5590
5591#[doc(hidden)]
5592impl ToGlib for SelectionMode {
5593 type GlibType = gtk_sys::GtkSelectionMode;
5594
5595 fn to_glib(&self) -> gtk_sys::GtkSelectionMode {
5596 match *self {
5597 SelectionMode::None => gtk_sys::GTK_SELECTION_NONE,
5598 SelectionMode::Single => gtk_sys::GTK_SELECTION_SINGLE,
5599 SelectionMode::Browse => gtk_sys::GTK_SELECTION_BROWSE,
5600 SelectionMode::Multiple => gtk_sys::GTK_SELECTION_MULTIPLE,
5601 SelectionMode::__Unknown(value) => value,
5602 }
5603 }
5604}
5605
5606#[doc(hidden)]
5607impl FromGlib<gtk_sys::GtkSelectionMode> for SelectionMode {
5608 fn from_glib(value: gtk_sys::GtkSelectionMode) -> Self {
5609 skip_assert_initialized!();
5610 match value {
5611 0 => SelectionMode::None,
5612 1 => SelectionMode::Single,
5613 2 => SelectionMode::Browse,
5614 3 => SelectionMode::Multiple,
5615 value => SelectionMode::__Unknown(value),
5616 }
5617 }
5618}
5619
5620impl StaticType for SelectionMode {
5621 fn static_type() -> Type {
5622 unsafe { from_glib(gtk_sys::gtk_selection_mode_get_type()) }
5623 }
5624}
5625
5626impl<'a> FromValueOptional<'a> for SelectionMode {
5627 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5628 Some(FromValue::from_value(value))
5629 }
5630}
5631
5632impl<'a> FromValue<'a> for SelectionMode {
5633 unsafe fn from_value(value: &Value) -> Self {
5634 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5635 }
5636}
5637
5638impl SetValue for SelectionMode {
5639 unsafe fn set_value(value: &mut Value, this: &Self) {
5640 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5641 }
5642}
5643
5644#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5645pub enum SensitivityType {
5646 Auto,
5647 On,
5648 Off,
5649 #[doc(hidden)]
5650 __Unknown(i32),
5651}
5652
5653impl fmt::Display for SensitivityType {
5654 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5655 write!(
5656 f,
5657 "SensitivityType::{}",
5658 match *self {
5659 SensitivityType::Auto => "Auto",
5660 SensitivityType::On => "On",
5661 SensitivityType::Off => "Off",
5662 _ => "Unknown",
5663 }
5664 )
5665 }
5666}
5667
5668#[doc(hidden)]
5669impl ToGlib for SensitivityType {
5670 type GlibType = gtk_sys::GtkSensitivityType;
5671
5672 fn to_glib(&self) -> gtk_sys::GtkSensitivityType {
5673 match *self {
5674 SensitivityType::Auto => gtk_sys::GTK_SENSITIVITY_AUTO,
5675 SensitivityType::On => gtk_sys::GTK_SENSITIVITY_ON,
5676 SensitivityType::Off => gtk_sys::GTK_SENSITIVITY_OFF,
5677 SensitivityType::__Unknown(value) => value,
5678 }
5679 }
5680}
5681
5682#[doc(hidden)]
5683impl FromGlib<gtk_sys::GtkSensitivityType> for SensitivityType {
5684 fn from_glib(value: gtk_sys::GtkSensitivityType) -> Self {
5685 skip_assert_initialized!();
5686 match value {
5687 0 => SensitivityType::Auto,
5688 1 => SensitivityType::On,
5689 2 => SensitivityType::Off,
5690 value => SensitivityType::__Unknown(value),
5691 }
5692 }
5693}
5694
5695impl StaticType for SensitivityType {
5696 fn static_type() -> Type {
5697 unsafe { from_glib(gtk_sys::gtk_sensitivity_type_get_type()) }
5698 }
5699}
5700
5701impl<'a> FromValueOptional<'a> for SensitivityType {
5702 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5703 Some(FromValue::from_value(value))
5704 }
5705}
5706
5707impl<'a> FromValue<'a> for SensitivityType {
5708 unsafe fn from_value(value: &Value) -> Self {
5709 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5710 }
5711}
5712
5713impl SetValue for SensitivityType {
5714 unsafe fn set_value(value: &mut Value, this: &Self) {
5715 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5716 }
5717}
5718
5719#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5720pub enum ShadowType {
5721 None,
5722 In,
5723 Out,
5724 EtchedIn,
5725 EtchedOut,
5726 #[doc(hidden)]
5727 __Unknown(i32),
5728}
5729
5730impl fmt::Display for ShadowType {
5731 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5732 write!(
5733 f,
5734 "ShadowType::{}",
5735 match *self {
5736 ShadowType::None => "None",
5737 ShadowType::In => "In",
5738 ShadowType::Out => "Out",
5739 ShadowType::EtchedIn => "EtchedIn",
5740 ShadowType::EtchedOut => "EtchedOut",
5741 _ => "Unknown",
5742 }
5743 )
5744 }
5745}
5746
5747#[doc(hidden)]
5748impl ToGlib for ShadowType {
5749 type GlibType = gtk_sys::GtkShadowType;
5750
5751 fn to_glib(&self) -> gtk_sys::GtkShadowType {
5752 match *self {
5753 ShadowType::None => gtk_sys::GTK_SHADOW_NONE,
5754 ShadowType::In => gtk_sys::GTK_SHADOW_IN,
5755 ShadowType::Out => gtk_sys::GTK_SHADOW_OUT,
5756 ShadowType::EtchedIn => gtk_sys::GTK_SHADOW_ETCHED_IN,
5757 ShadowType::EtchedOut => gtk_sys::GTK_SHADOW_ETCHED_OUT,
5758 ShadowType::__Unknown(value) => value,
5759 }
5760 }
5761}
5762
5763#[doc(hidden)]
5764impl FromGlib<gtk_sys::GtkShadowType> for ShadowType {
5765 fn from_glib(value: gtk_sys::GtkShadowType) -> Self {
5766 skip_assert_initialized!();
5767 match value {
5768 0 => ShadowType::None,
5769 1 => ShadowType::In,
5770 2 => ShadowType::Out,
5771 3 => ShadowType::EtchedIn,
5772 4 => ShadowType::EtchedOut,
5773 value => ShadowType::__Unknown(value),
5774 }
5775 }
5776}
5777
5778impl StaticType for ShadowType {
5779 fn static_type() -> Type {
5780 unsafe { from_glib(gtk_sys::gtk_shadow_type_get_type()) }
5781 }
5782}
5783
5784impl<'a> FromValueOptional<'a> for ShadowType {
5785 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5786 Some(FromValue::from_value(value))
5787 }
5788}
5789
5790impl<'a> FromValue<'a> for ShadowType {
5791 unsafe fn from_value(value: &Value) -> Self {
5792 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5793 }
5794}
5795
5796impl SetValue for ShadowType {
5797 unsafe fn set_value(value: &mut Value, this: &Self) {
5798 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5799 }
5800}
5801
5802#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5803pub enum SizeGroupMode {
5804 None,
5805 Horizontal,
5806 Vertical,
5807 Both,
5808 #[doc(hidden)]
5809 __Unknown(i32),
5810}
5811
5812impl fmt::Display for SizeGroupMode {
5813 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5814 write!(
5815 f,
5816 "SizeGroupMode::{}",
5817 match *self {
5818 SizeGroupMode::None => "None",
5819 SizeGroupMode::Horizontal => "Horizontal",
5820 SizeGroupMode::Vertical => "Vertical",
5821 SizeGroupMode::Both => "Both",
5822 _ => "Unknown",
5823 }
5824 )
5825 }
5826}
5827
5828#[doc(hidden)]
5829impl ToGlib for SizeGroupMode {
5830 type GlibType = gtk_sys::GtkSizeGroupMode;
5831
5832 fn to_glib(&self) -> gtk_sys::GtkSizeGroupMode {
5833 match *self {
5834 SizeGroupMode::None => gtk_sys::GTK_SIZE_GROUP_NONE,
5835 SizeGroupMode::Horizontal => gtk_sys::GTK_SIZE_GROUP_HORIZONTAL,
5836 SizeGroupMode::Vertical => gtk_sys::GTK_SIZE_GROUP_VERTICAL,
5837 SizeGroupMode::Both => gtk_sys::GTK_SIZE_GROUP_BOTH,
5838 SizeGroupMode::__Unknown(value) => value,
5839 }
5840 }
5841}
5842
5843#[doc(hidden)]
5844impl FromGlib<gtk_sys::GtkSizeGroupMode> for SizeGroupMode {
5845 fn from_glib(value: gtk_sys::GtkSizeGroupMode) -> Self {
5846 skip_assert_initialized!();
5847 match value {
5848 0 => SizeGroupMode::None,
5849 1 => SizeGroupMode::Horizontal,
5850 2 => SizeGroupMode::Vertical,
5851 3 => SizeGroupMode::Both,
5852 value => SizeGroupMode::__Unknown(value),
5853 }
5854 }
5855}
5856
5857impl StaticType for SizeGroupMode {
5858 fn static_type() -> Type {
5859 unsafe { from_glib(gtk_sys::gtk_size_group_mode_get_type()) }
5860 }
5861}
5862
5863impl<'a> FromValueOptional<'a> for SizeGroupMode {
5864 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5865 Some(FromValue::from_value(value))
5866 }
5867}
5868
5869impl<'a> FromValue<'a> for SizeGroupMode {
5870 unsafe fn from_value(value: &Value) -> Self {
5871 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5872 }
5873}
5874
5875impl SetValue for SizeGroupMode {
5876 unsafe fn set_value(value: &mut Value, this: &Self) {
5877 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5878 }
5879}
5880
5881#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5882pub enum SizeRequestMode {
5883 HeightForWidth,
5884 WidthForHeight,
5885 ConstantSize,
5886 #[doc(hidden)]
5887 __Unknown(i32),
5888}
5889
5890impl fmt::Display for SizeRequestMode {
5891 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5892 write!(
5893 f,
5894 "SizeRequestMode::{}",
5895 match *self {
5896 SizeRequestMode::HeightForWidth => "HeightForWidth",
5897 SizeRequestMode::WidthForHeight => "WidthForHeight",
5898 SizeRequestMode::ConstantSize => "ConstantSize",
5899 _ => "Unknown",
5900 }
5901 )
5902 }
5903}
5904
5905#[doc(hidden)]
5906impl ToGlib for SizeRequestMode {
5907 type GlibType = gtk_sys::GtkSizeRequestMode;
5908
5909 fn to_glib(&self) -> gtk_sys::GtkSizeRequestMode {
5910 match *self {
5911 SizeRequestMode::HeightForWidth => gtk_sys::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
5912 SizeRequestMode::WidthForHeight => gtk_sys::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
5913 SizeRequestMode::ConstantSize => gtk_sys::GTK_SIZE_REQUEST_CONSTANT_SIZE,
5914 SizeRequestMode::__Unknown(value) => value,
5915 }
5916 }
5917}
5918
5919#[doc(hidden)]
5920impl FromGlib<gtk_sys::GtkSizeRequestMode> for SizeRequestMode {
5921 fn from_glib(value: gtk_sys::GtkSizeRequestMode) -> Self {
5922 skip_assert_initialized!();
5923 match value {
5924 0 => SizeRequestMode::HeightForWidth,
5925 1 => SizeRequestMode::WidthForHeight,
5926 2 => SizeRequestMode::ConstantSize,
5927 value => SizeRequestMode::__Unknown(value),
5928 }
5929 }
5930}
5931
5932impl StaticType for SizeRequestMode {
5933 fn static_type() -> Type {
5934 unsafe { from_glib(gtk_sys::gtk_size_request_mode_get_type()) }
5935 }
5936}
5937
5938impl<'a> FromValueOptional<'a> for SizeRequestMode {
5939 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5940 Some(FromValue::from_value(value))
5941 }
5942}
5943
5944impl<'a> FromValue<'a> for SizeRequestMode {
5945 unsafe fn from_value(value: &Value) -> Self {
5946 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5947 }
5948}
5949
5950impl SetValue for SizeRequestMode {
5951 unsafe fn set_value(value: &mut Value, this: &Self) {
5952 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5953 }
5954}
5955
5956#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5957pub enum SortType {
5958 Ascending,
5959 Descending,
5960 #[doc(hidden)]
5961 __Unknown(i32),
5962}
5963
5964impl fmt::Display for SortType {
5965 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5966 write!(
5967 f,
5968 "SortType::{}",
5969 match *self {
5970 SortType::Ascending => "Ascending",
5971 SortType::Descending => "Descending",
5972 _ => "Unknown",
5973 }
5974 )
5975 }
5976}
5977
5978#[doc(hidden)]
5979impl ToGlib for SortType {
5980 type GlibType = gtk_sys::GtkSortType;
5981
5982 fn to_glib(&self) -> gtk_sys::GtkSortType {
5983 match *self {
5984 SortType::Ascending => gtk_sys::GTK_SORT_ASCENDING,
5985 SortType::Descending => gtk_sys::GTK_SORT_DESCENDING,
5986 SortType::__Unknown(value) => value,
5987 }
5988 }
5989}
5990
5991#[doc(hidden)]
5992impl FromGlib<gtk_sys::GtkSortType> for SortType {
5993 fn from_glib(value: gtk_sys::GtkSortType) -> Self {
5994 skip_assert_initialized!();
5995 match value {
5996 0 => SortType::Ascending,
5997 1 => SortType::Descending,
5998 value => SortType::__Unknown(value),
5999 }
6000 }
6001}
6002
6003impl StaticType for SortType {
6004 fn static_type() -> Type {
6005 unsafe { from_glib(gtk_sys::gtk_sort_type_get_type()) }
6006 }
6007}
6008
6009impl<'a> FromValueOptional<'a> for SortType {
6010 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6011 Some(FromValue::from_value(value))
6012 }
6013}
6014
6015impl<'a> FromValue<'a> for SortType {
6016 unsafe fn from_value(value: &Value) -> Self {
6017 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6018 }
6019}
6020
6021impl SetValue for SortType {
6022 unsafe fn set_value(value: &mut Value, this: &Self) {
6023 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6024 }
6025}
6026
6027#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6028pub enum SpinButtonUpdatePolicy {
6029 Always,
6030 IfValid,
6031 #[doc(hidden)]
6032 __Unknown(i32),
6033}
6034
6035impl fmt::Display for SpinButtonUpdatePolicy {
6036 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6037 write!(
6038 f,
6039 "SpinButtonUpdatePolicy::{}",
6040 match *self {
6041 SpinButtonUpdatePolicy::Always => "Always",
6042 SpinButtonUpdatePolicy::IfValid => "IfValid",
6043 _ => "Unknown",
6044 }
6045 )
6046 }
6047}
6048
6049#[doc(hidden)]
6050impl ToGlib for SpinButtonUpdatePolicy {
6051 type GlibType = gtk_sys::GtkSpinButtonUpdatePolicy;
6052
6053 fn to_glib(&self) -> gtk_sys::GtkSpinButtonUpdatePolicy {
6054 match *self {
6055 SpinButtonUpdatePolicy::Always => gtk_sys::GTK_UPDATE_ALWAYS,
6056 SpinButtonUpdatePolicy::IfValid => gtk_sys::GTK_UPDATE_IF_VALID,
6057 SpinButtonUpdatePolicy::__Unknown(value) => value,
6058 }
6059 }
6060}
6061
6062#[doc(hidden)]
6063impl FromGlib<gtk_sys::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
6064 fn from_glib(value: gtk_sys::GtkSpinButtonUpdatePolicy) -> Self {
6065 skip_assert_initialized!();
6066 match value {
6067 0 => SpinButtonUpdatePolicy::Always,
6068 1 => SpinButtonUpdatePolicy::IfValid,
6069 value => SpinButtonUpdatePolicy::__Unknown(value),
6070 }
6071 }
6072}
6073
6074impl StaticType for SpinButtonUpdatePolicy {
6075 fn static_type() -> Type {
6076 unsafe { from_glib(gtk_sys::gtk_spin_button_update_policy_get_type()) }
6077 }
6078}
6079
6080impl<'a> FromValueOptional<'a> for SpinButtonUpdatePolicy {
6081 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6082 Some(FromValue::from_value(value))
6083 }
6084}
6085
6086impl<'a> FromValue<'a> for SpinButtonUpdatePolicy {
6087 unsafe fn from_value(value: &Value) -> Self {
6088 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6089 }
6090}
6091
6092impl SetValue for SpinButtonUpdatePolicy {
6093 unsafe fn set_value(value: &mut Value, this: &Self) {
6094 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6095 }
6096}
6097
6098#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6099pub enum SpinType {
6100 StepForward,
6101 StepBackward,
6102 PageForward,
6103 PageBackward,
6104 Home,
6105 End,
6106 UserDefined,
6107 #[doc(hidden)]
6108 __Unknown(i32),
6109}
6110
6111impl fmt::Display for SpinType {
6112 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6113 write!(
6114 f,
6115 "SpinType::{}",
6116 match *self {
6117 SpinType::StepForward => "StepForward",
6118 SpinType::StepBackward => "StepBackward",
6119 SpinType::PageForward => "PageForward",
6120 SpinType::PageBackward => "PageBackward",
6121 SpinType::Home => "Home",
6122 SpinType::End => "End",
6123 SpinType::UserDefined => "UserDefined",
6124 _ => "Unknown",
6125 }
6126 )
6127 }
6128}
6129
6130#[doc(hidden)]
6131impl ToGlib for SpinType {
6132 type GlibType = gtk_sys::GtkSpinType;
6133
6134 fn to_glib(&self) -> gtk_sys::GtkSpinType {
6135 match *self {
6136 SpinType::StepForward => gtk_sys::GTK_SPIN_STEP_FORWARD,
6137 SpinType::StepBackward => gtk_sys::GTK_SPIN_STEP_BACKWARD,
6138 SpinType::PageForward => gtk_sys::GTK_SPIN_PAGE_FORWARD,
6139 SpinType::PageBackward => gtk_sys::GTK_SPIN_PAGE_BACKWARD,
6140 SpinType::Home => gtk_sys::GTK_SPIN_HOME,
6141 SpinType::End => gtk_sys::GTK_SPIN_END,
6142 SpinType::UserDefined => gtk_sys::GTK_SPIN_USER_DEFINED,
6143 SpinType::__Unknown(value) => value,
6144 }
6145 }
6146}
6147
6148#[doc(hidden)]
6149impl FromGlib<gtk_sys::GtkSpinType> for SpinType {
6150 fn from_glib(value: gtk_sys::GtkSpinType) -> Self {
6151 skip_assert_initialized!();
6152 match value {
6153 0 => SpinType::StepForward,
6154 1 => SpinType::StepBackward,
6155 2 => SpinType::PageForward,
6156 3 => SpinType::PageBackward,
6157 4 => SpinType::Home,
6158 5 => SpinType::End,
6159 6 => SpinType::UserDefined,
6160 value => SpinType::__Unknown(value),
6161 }
6162 }
6163}
6164
6165impl StaticType for SpinType {
6166 fn static_type() -> Type {
6167 unsafe { from_glib(gtk_sys::gtk_spin_type_get_type()) }
6168 }
6169}
6170
6171impl<'a> FromValueOptional<'a> for SpinType {
6172 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6173 Some(FromValue::from_value(value))
6174 }
6175}
6176
6177impl<'a> FromValue<'a> for SpinType {
6178 unsafe fn from_value(value: &Value) -> Self {
6179 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6180 }
6181}
6182
6183impl SetValue for SpinType {
6184 unsafe fn set_value(value: &mut Value, this: &Self) {
6185 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6186 }
6187}
6188
6189#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6190pub enum StackTransitionType {
6191 None,
6192 Crossfade,
6193 SlideRight,
6194 SlideLeft,
6195 SlideUp,
6196 SlideDown,
6197 SlideLeftRight,
6198 SlideUpDown,
6199 OverUp,
6200 OverDown,
6201 OverLeft,
6202 OverRight,
6203 UnderUp,
6204 UnderDown,
6205 UnderLeft,
6206 UnderRight,
6207 OverUpDown,
6208 OverDownUp,
6209 OverLeftRight,
6210 OverRightLeft,
6211 #[doc(hidden)]
6212 __Unknown(i32),
6213}
6214
6215impl fmt::Display for StackTransitionType {
6216 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6217 write!(
6218 f,
6219 "StackTransitionType::{}",
6220 match *self {
6221 StackTransitionType::None => "None",
6222 StackTransitionType::Crossfade => "Crossfade",
6223 StackTransitionType::SlideRight => "SlideRight",
6224 StackTransitionType::SlideLeft => "SlideLeft",
6225 StackTransitionType::SlideUp => "SlideUp",
6226 StackTransitionType::SlideDown => "SlideDown",
6227 StackTransitionType::SlideLeftRight => "SlideLeftRight",
6228 StackTransitionType::SlideUpDown => "SlideUpDown",
6229 StackTransitionType::OverUp => "OverUp",
6230 StackTransitionType::OverDown => "OverDown",
6231 StackTransitionType::OverLeft => "OverLeft",
6232 StackTransitionType::OverRight => "OverRight",
6233 StackTransitionType::UnderUp => "UnderUp",
6234 StackTransitionType::UnderDown => "UnderDown",
6235 StackTransitionType::UnderLeft => "UnderLeft",
6236 StackTransitionType::UnderRight => "UnderRight",
6237 StackTransitionType::OverUpDown => "OverUpDown",
6238 StackTransitionType::OverDownUp => "OverDownUp",
6239 StackTransitionType::OverLeftRight => "OverLeftRight",
6240 StackTransitionType::OverRightLeft => "OverRightLeft",
6241 _ => "Unknown",
6242 }
6243 )
6244 }
6245}
6246
6247#[doc(hidden)]
6248impl ToGlib for StackTransitionType {
6249 type GlibType = gtk_sys::GtkStackTransitionType;
6250
6251 fn to_glib(&self) -> gtk_sys::GtkStackTransitionType {
6252 match *self {
6253 StackTransitionType::None => gtk_sys::GTK_STACK_TRANSITION_TYPE_NONE,
6254 StackTransitionType::Crossfade => gtk_sys::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
6255 StackTransitionType::SlideRight => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
6256 StackTransitionType::SlideLeft => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
6257 StackTransitionType::SlideUp => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
6258 StackTransitionType::SlideDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
6259 StackTransitionType::SlideLeftRight => {
6260 gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT
6261 }
6262 StackTransitionType::SlideUpDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
6263 StackTransitionType::OverUp => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_UP,
6264 StackTransitionType::OverDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
6265 StackTransitionType::OverLeft => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
6266 StackTransitionType::OverRight => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
6267 StackTransitionType::UnderUp => gtk_sys::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
6268 StackTransitionType::UnderDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
6269 StackTransitionType::UnderLeft => gtk_sys::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
6270 StackTransitionType::UnderRight => gtk_sys::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
6271 StackTransitionType::OverUpDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
6272 StackTransitionType::OverDownUp => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
6273 StackTransitionType::OverLeftRight => {
6274 gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT
6275 }
6276 StackTransitionType::OverRightLeft => {
6277 gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT
6278 }
6279 StackTransitionType::__Unknown(value) => value,
6280 }
6281 }
6282}
6283
6284#[doc(hidden)]
6285impl FromGlib<gtk_sys::GtkStackTransitionType> for StackTransitionType {
6286 fn from_glib(value: gtk_sys::GtkStackTransitionType) -> Self {
6287 skip_assert_initialized!();
6288 match value {
6289 0 => StackTransitionType::None,
6290 1 => StackTransitionType::Crossfade,
6291 2 => StackTransitionType::SlideRight,
6292 3 => StackTransitionType::SlideLeft,
6293 4 => StackTransitionType::SlideUp,
6294 5 => StackTransitionType::SlideDown,
6295 6 => StackTransitionType::SlideLeftRight,
6296 7 => StackTransitionType::SlideUpDown,
6297 8 => StackTransitionType::OverUp,
6298 9 => StackTransitionType::OverDown,
6299 10 => StackTransitionType::OverLeft,
6300 11 => StackTransitionType::OverRight,
6301 12 => StackTransitionType::UnderUp,
6302 13 => StackTransitionType::UnderDown,
6303 14 => StackTransitionType::UnderLeft,
6304 15 => StackTransitionType::UnderRight,
6305 16 => StackTransitionType::OverUpDown,
6306 17 => StackTransitionType::OverDownUp,
6307 18 => StackTransitionType::OverLeftRight,
6308 19 => StackTransitionType::OverRightLeft,
6309 value => StackTransitionType::__Unknown(value),
6310 }
6311 }
6312}
6313
6314impl StaticType for StackTransitionType {
6315 fn static_type() -> Type {
6316 unsafe { from_glib(gtk_sys::gtk_stack_transition_type_get_type()) }
6317 }
6318}
6319
6320impl<'a> FromValueOptional<'a> for StackTransitionType {
6321 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6322 Some(FromValue::from_value(value))
6323 }
6324}
6325
6326impl<'a> FromValue<'a> for StackTransitionType {
6327 unsafe fn from_value(value: &Value) -> Self {
6328 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6329 }
6330}
6331
6332impl SetValue for StackTransitionType {
6333 unsafe fn set_value(value: &mut Value, this: &Self) {
6334 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6335 }
6336}
6337
6338#[deprecated]
6339#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6340pub enum StateType {
6341 Normal,
6342 Active,
6343 Prelight,
6344 Selected,
6345 Insensitive,
6346 Inconsistent,
6347 Focused,
6348 #[doc(hidden)]
6349 __Unknown(i32),
6350}
6351
6352#[deprecated]
6353impl fmt::Display for StateType {
6354 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6355 write!(
6356 f,
6357 "StateType::{}",
6358 match *self {
6359 StateType::Normal => "Normal",
6360 StateType::Active => "Active",
6361 StateType::Prelight => "Prelight",
6362 StateType::Selected => "Selected",
6363 StateType::Insensitive => "Insensitive",
6364 StateType::Inconsistent => "Inconsistent",
6365 StateType::Focused => "Focused",
6366 _ => "Unknown",
6367 }
6368 )
6369 }
6370}
6371
6372#[deprecated]
6373#[doc(hidden)]
6374impl ToGlib for StateType {
6375 type GlibType = gtk_sys::GtkStateType;
6376
6377 fn to_glib(&self) -> gtk_sys::GtkStateType {
6378 match *self {
6379 StateType::Normal => gtk_sys::GTK_STATE_NORMAL,
6380 StateType::Active => gtk_sys::GTK_STATE_ACTIVE,
6381 StateType::Prelight => gtk_sys::GTK_STATE_PRELIGHT,
6382 StateType::Selected => gtk_sys::GTK_STATE_SELECTED,
6383 StateType::Insensitive => gtk_sys::GTK_STATE_INSENSITIVE,
6384 StateType::Inconsistent => gtk_sys::GTK_STATE_INCONSISTENT,
6385 StateType::Focused => gtk_sys::GTK_STATE_FOCUSED,
6386 StateType::__Unknown(value) => value,
6387 }
6388 }
6389}
6390
6391#[deprecated]
6392#[doc(hidden)]
6393impl FromGlib<gtk_sys::GtkStateType> for StateType {
6394 fn from_glib(value: gtk_sys::GtkStateType) -> Self {
6395 skip_assert_initialized!();
6396 match value {
6397 0 => StateType::Normal,
6398 1 => StateType::Active,
6399 2 => StateType::Prelight,
6400 3 => StateType::Selected,
6401 4 => StateType::Insensitive,
6402 5 => StateType::Inconsistent,
6403 6 => StateType::Focused,
6404 value => StateType::__Unknown(value),
6405 }
6406 }
6407}
6408
6409#[deprecated]
6410impl StaticType for StateType {
6411 fn static_type() -> Type {
6412 unsafe { from_glib(gtk_sys::gtk_state_type_get_type()) }
6413 }
6414}
6415
6416#[deprecated]
6417impl<'a> FromValueOptional<'a> for StateType {
6418 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6419 Some(FromValue::from_value(value))
6420 }
6421}
6422
6423#[deprecated]
6424impl<'a> FromValue<'a> for StateType {
6425 unsafe fn from_value(value: &Value) -> Self {
6426 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6427 }
6428}
6429
6430#[deprecated]
6431impl SetValue for StateType {
6432 unsafe fn set_value(value: &mut Value, this: &Self) {
6433 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6434 }
6435}
6436
6437#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6438pub enum TextDirection {
6439 None,
6440 Ltr,
6441 Rtl,
6442 #[doc(hidden)]
6443 __Unknown(i32),
6444}
6445
6446impl fmt::Display for TextDirection {
6447 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6448 write!(
6449 f,
6450 "TextDirection::{}",
6451 match *self {
6452 TextDirection::None => "None",
6453 TextDirection::Ltr => "Ltr",
6454 TextDirection::Rtl => "Rtl",
6455 _ => "Unknown",
6456 }
6457 )
6458 }
6459}
6460
6461#[doc(hidden)]
6462impl ToGlib for TextDirection {
6463 type GlibType = gtk_sys::GtkTextDirection;
6464
6465 fn to_glib(&self) -> gtk_sys::GtkTextDirection {
6466 match *self {
6467 TextDirection::None => gtk_sys::GTK_TEXT_DIR_NONE,
6468 TextDirection::Ltr => gtk_sys::GTK_TEXT_DIR_LTR,
6469 TextDirection::Rtl => gtk_sys::GTK_TEXT_DIR_RTL,
6470 TextDirection::__Unknown(value) => value,
6471 }
6472 }
6473}
6474
6475#[doc(hidden)]
6476impl FromGlib<gtk_sys::GtkTextDirection> for TextDirection {
6477 fn from_glib(value: gtk_sys::GtkTextDirection) -> Self {
6478 skip_assert_initialized!();
6479 match value {
6480 0 => TextDirection::None,
6481 1 => TextDirection::Ltr,
6482 2 => TextDirection::Rtl,
6483 value => TextDirection::__Unknown(value),
6484 }
6485 }
6486}
6487
6488impl StaticType for TextDirection {
6489 fn static_type() -> Type {
6490 unsafe { from_glib(gtk_sys::gtk_text_direction_get_type()) }
6491 }
6492}
6493
6494impl<'a> FromValueOptional<'a> for TextDirection {
6495 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6496 Some(FromValue::from_value(value))
6497 }
6498}
6499
6500impl<'a> FromValue<'a> for TextDirection {
6501 unsafe fn from_value(value: &Value) -> Self {
6502 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6503 }
6504}
6505
6506impl SetValue for TextDirection {
6507 unsafe fn set_value(value: &mut Value, this: &Self) {
6508 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6509 }
6510}
6511
6512#[cfg(any(feature = "v3_16", feature = "dox"))]
6513#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6514pub enum TextExtendSelection {
6515 Word,
6516 Line,
6517 #[doc(hidden)]
6518 __Unknown(i32),
6519}
6520
6521#[cfg(any(feature = "v3_16", feature = "dox"))]
6522impl fmt::Display for TextExtendSelection {
6523 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6524 write!(
6525 f,
6526 "TextExtendSelection::{}",
6527 match *self {
6528 TextExtendSelection::Word => "Word",
6529 TextExtendSelection::Line => "Line",
6530 _ => "Unknown",
6531 }
6532 )
6533 }
6534}
6535
6536#[cfg(any(feature = "v3_16", feature = "dox"))]
6537#[doc(hidden)]
6538impl ToGlib for TextExtendSelection {
6539 type GlibType = gtk_sys::GtkTextExtendSelection;
6540
6541 fn to_glib(&self) -> gtk_sys::GtkTextExtendSelection {
6542 match *self {
6543 TextExtendSelection::Word => gtk_sys::GTK_TEXT_EXTEND_SELECTION_WORD,
6544 TextExtendSelection::Line => gtk_sys::GTK_TEXT_EXTEND_SELECTION_LINE,
6545 TextExtendSelection::__Unknown(value) => value,
6546 }
6547 }
6548}
6549
6550#[cfg(any(feature = "v3_16", feature = "dox"))]
6551#[doc(hidden)]
6552impl FromGlib<gtk_sys::GtkTextExtendSelection> for TextExtendSelection {
6553 fn from_glib(value: gtk_sys::GtkTextExtendSelection) -> Self {
6554 skip_assert_initialized!();
6555 match value {
6556 0 => TextExtendSelection::Word,
6557 1 => TextExtendSelection::Line,
6558 value => TextExtendSelection::__Unknown(value),
6559 }
6560 }
6561}
6562
6563#[cfg(any(feature = "v3_16", feature = "dox"))]
6564impl StaticType for TextExtendSelection {
6565 fn static_type() -> Type {
6566 unsafe { from_glib(gtk_sys::gtk_text_extend_selection_get_type()) }
6567 }
6568}
6569
6570#[cfg(any(feature = "v3_16", feature = "dox"))]
6571impl<'a> FromValueOptional<'a> for TextExtendSelection {
6572 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6573 Some(FromValue::from_value(value))
6574 }
6575}
6576
6577#[cfg(any(feature = "v3_16", feature = "dox"))]
6578impl<'a> FromValue<'a> for TextExtendSelection {
6579 unsafe fn from_value(value: &Value) -> Self {
6580 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6581 }
6582}
6583
6584#[cfg(any(feature = "v3_16", feature = "dox"))]
6585impl SetValue for TextExtendSelection {
6586 unsafe fn set_value(value: &mut Value, this: &Self) {
6587 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6588 }
6589}
6590
6591#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6592pub enum TextViewLayer {
6593 Below,
6594 Above,
6595 BelowText,
6596 AboveText,
6597 #[doc(hidden)]
6598 __Unknown(i32),
6599}
6600
6601impl fmt::Display for TextViewLayer {
6602 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6603 write!(
6604 f,
6605 "TextViewLayer::{}",
6606 match *self {
6607 TextViewLayer::Below => "Below",
6608 TextViewLayer::Above => "Above",
6609 TextViewLayer::BelowText => "BelowText",
6610 TextViewLayer::AboveText => "AboveText",
6611 _ => "Unknown",
6612 }
6613 )
6614 }
6615}
6616
6617#[doc(hidden)]
6618impl ToGlib for TextViewLayer {
6619 type GlibType = gtk_sys::GtkTextViewLayer;
6620
6621 fn to_glib(&self) -> gtk_sys::GtkTextViewLayer {
6622 match *self {
6623 TextViewLayer::Below => gtk_sys::GTK_TEXT_VIEW_LAYER_BELOW,
6624 TextViewLayer::Above => gtk_sys::GTK_TEXT_VIEW_LAYER_ABOVE,
6625 TextViewLayer::BelowText => gtk_sys::GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
6626 TextViewLayer::AboveText => gtk_sys::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT,
6627 TextViewLayer::__Unknown(value) => value,
6628 }
6629 }
6630}
6631
6632#[doc(hidden)]
6633impl FromGlib<gtk_sys::GtkTextViewLayer> for TextViewLayer {
6634 fn from_glib(value: gtk_sys::GtkTextViewLayer) -> Self {
6635 skip_assert_initialized!();
6636 match value {
6637 0 => TextViewLayer::Below,
6638 1 => TextViewLayer::Above,
6639 2 => TextViewLayer::BelowText,
6640 3 => TextViewLayer::AboveText,
6641 value => TextViewLayer::__Unknown(value),
6642 }
6643 }
6644}
6645
6646impl StaticType for TextViewLayer {
6647 fn static_type() -> Type {
6648 unsafe { from_glib(gtk_sys::gtk_text_view_layer_get_type()) }
6649 }
6650}
6651
6652impl<'a> FromValueOptional<'a> for TextViewLayer {
6653 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6654 Some(FromValue::from_value(value))
6655 }
6656}
6657
6658impl<'a> FromValue<'a> for TextViewLayer {
6659 unsafe fn from_value(value: &Value) -> Self {
6660 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6661 }
6662}
6663
6664impl SetValue for TextViewLayer {
6665 unsafe fn set_value(value: &mut Value, this: &Self) {
6666 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6667 }
6668}
6669
6670#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6671pub enum TextWindowType {
6672 Private,
6673 Widget,
6674 Text,
6675 Left,
6676 Right,
6677 Top,
6678 Bottom,
6679 #[doc(hidden)]
6680 __Unknown(i32),
6681}
6682
6683impl fmt::Display for TextWindowType {
6684 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6685 write!(
6686 f,
6687 "TextWindowType::{}",
6688 match *self {
6689 TextWindowType::Private => "Private",
6690 TextWindowType::Widget => "Widget",
6691 TextWindowType::Text => "Text",
6692 TextWindowType::Left => "Left",
6693 TextWindowType::Right => "Right",
6694 TextWindowType::Top => "Top",
6695 TextWindowType::Bottom => "Bottom",
6696 _ => "Unknown",
6697 }
6698 )
6699 }
6700}
6701
6702#[doc(hidden)]
6703impl ToGlib for TextWindowType {
6704 type GlibType = gtk_sys::GtkTextWindowType;
6705
6706 fn to_glib(&self) -> gtk_sys::GtkTextWindowType {
6707 match *self {
6708 TextWindowType::Private => gtk_sys::GTK_TEXT_WINDOW_PRIVATE,
6709 TextWindowType::Widget => gtk_sys::GTK_TEXT_WINDOW_WIDGET,
6710 TextWindowType::Text => gtk_sys::GTK_TEXT_WINDOW_TEXT,
6711 TextWindowType::Left => gtk_sys::GTK_TEXT_WINDOW_LEFT,
6712 TextWindowType::Right => gtk_sys::GTK_TEXT_WINDOW_RIGHT,
6713 TextWindowType::Top => gtk_sys::GTK_TEXT_WINDOW_TOP,
6714 TextWindowType::Bottom => gtk_sys::GTK_TEXT_WINDOW_BOTTOM,
6715 TextWindowType::__Unknown(value) => value,
6716 }
6717 }
6718}
6719
6720#[doc(hidden)]
6721impl FromGlib<gtk_sys::GtkTextWindowType> for TextWindowType {
6722 fn from_glib(value: gtk_sys::GtkTextWindowType) -> Self {
6723 skip_assert_initialized!();
6724 match value {
6725 0 => TextWindowType::Private,
6726 1 => TextWindowType::Widget,
6727 2 => TextWindowType::Text,
6728 3 => TextWindowType::Left,
6729 4 => TextWindowType::Right,
6730 5 => TextWindowType::Top,
6731 6 => TextWindowType::Bottom,
6732 value => TextWindowType::__Unknown(value),
6733 }
6734 }
6735}
6736
6737impl StaticType for TextWindowType {
6738 fn static_type() -> Type {
6739 unsafe { from_glib(gtk_sys::gtk_text_window_type_get_type()) }
6740 }
6741}
6742
6743impl<'a> FromValueOptional<'a> for TextWindowType {
6744 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6745 Some(FromValue::from_value(value))
6746 }
6747}
6748
6749impl<'a> FromValue<'a> for TextWindowType {
6750 unsafe fn from_value(value: &Value) -> Self {
6751 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6752 }
6753}
6754
6755impl SetValue for TextWindowType {
6756 unsafe fn set_value(value: &mut Value, this: &Self) {
6757 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6758 }
6759}
6760
6761#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6762pub enum ToolbarStyle {
6763 Icons,
6764 Text,
6765 Both,
6766 BothHoriz,
6767 #[doc(hidden)]
6768 __Unknown(i32),
6769}
6770
6771impl fmt::Display for ToolbarStyle {
6772 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6773 write!(
6774 f,
6775 "ToolbarStyle::{}",
6776 match *self {
6777 ToolbarStyle::Icons => "Icons",
6778 ToolbarStyle::Text => "Text",
6779 ToolbarStyle::Both => "Both",
6780 ToolbarStyle::BothHoriz => "BothHoriz",
6781 _ => "Unknown",
6782 }
6783 )
6784 }
6785}
6786
6787#[doc(hidden)]
6788impl ToGlib for ToolbarStyle {
6789 type GlibType = gtk_sys::GtkToolbarStyle;
6790
6791 fn to_glib(&self) -> gtk_sys::GtkToolbarStyle {
6792 match *self {
6793 ToolbarStyle::Icons => gtk_sys::GTK_TOOLBAR_ICONS,
6794 ToolbarStyle::Text => gtk_sys::GTK_TOOLBAR_TEXT,
6795 ToolbarStyle::Both => gtk_sys::GTK_TOOLBAR_BOTH,
6796 ToolbarStyle::BothHoriz => gtk_sys::GTK_TOOLBAR_BOTH_HORIZ,
6797 ToolbarStyle::__Unknown(value) => value,
6798 }
6799 }
6800}
6801
6802#[doc(hidden)]
6803impl FromGlib<gtk_sys::GtkToolbarStyle> for ToolbarStyle {
6804 fn from_glib(value: gtk_sys::GtkToolbarStyle) -> Self {
6805 skip_assert_initialized!();
6806 match value {
6807 0 => ToolbarStyle::Icons,
6808 1 => ToolbarStyle::Text,
6809 2 => ToolbarStyle::Both,
6810 3 => ToolbarStyle::BothHoriz,
6811 value => ToolbarStyle::__Unknown(value),
6812 }
6813 }
6814}
6815
6816impl StaticType for ToolbarStyle {
6817 fn static_type() -> Type {
6818 unsafe { from_glib(gtk_sys::gtk_toolbar_style_get_type()) }
6819 }
6820}
6821
6822impl<'a> FromValueOptional<'a> for ToolbarStyle {
6823 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6824 Some(FromValue::from_value(value))
6825 }
6826}
6827
6828impl<'a> FromValue<'a> for ToolbarStyle {
6829 unsafe fn from_value(value: &Value) -> Self {
6830 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6831 }
6832}
6833
6834impl SetValue for ToolbarStyle {
6835 unsafe fn set_value(value: &mut Value, this: &Self) {
6836 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6837 }
6838}
6839
6840#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6841pub enum TreeViewColumnSizing {
6842 GrowOnly,
6843 Autosize,
6844 Fixed,
6845 #[doc(hidden)]
6846 __Unknown(i32),
6847}
6848
6849impl fmt::Display for TreeViewColumnSizing {
6850 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6851 write!(
6852 f,
6853 "TreeViewColumnSizing::{}",
6854 match *self {
6855 TreeViewColumnSizing::GrowOnly => "GrowOnly",
6856 TreeViewColumnSizing::Autosize => "Autosize",
6857 TreeViewColumnSizing::Fixed => "Fixed",
6858 _ => "Unknown",
6859 }
6860 )
6861 }
6862}
6863
6864#[doc(hidden)]
6865impl ToGlib for TreeViewColumnSizing {
6866 type GlibType = gtk_sys::GtkTreeViewColumnSizing;
6867
6868 fn to_glib(&self) -> gtk_sys::GtkTreeViewColumnSizing {
6869 match *self {
6870 TreeViewColumnSizing::GrowOnly => gtk_sys::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
6871 TreeViewColumnSizing::Autosize => gtk_sys::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
6872 TreeViewColumnSizing::Fixed => gtk_sys::GTK_TREE_VIEW_COLUMN_FIXED,
6873 TreeViewColumnSizing::__Unknown(value) => value,
6874 }
6875 }
6876}
6877
6878#[doc(hidden)]
6879impl FromGlib<gtk_sys::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
6880 fn from_glib(value: gtk_sys::GtkTreeViewColumnSizing) -> Self {
6881 skip_assert_initialized!();
6882 match value {
6883 0 => TreeViewColumnSizing::GrowOnly,
6884 1 => TreeViewColumnSizing::Autosize,
6885 2 => TreeViewColumnSizing::Fixed,
6886 value => TreeViewColumnSizing::__Unknown(value),
6887 }
6888 }
6889}
6890
6891impl StaticType for TreeViewColumnSizing {
6892 fn static_type() -> Type {
6893 unsafe { from_glib(gtk_sys::gtk_tree_view_column_sizing_get_type()) }
6894 }
6895}
6896
6897impl<'a> FromValueOptional<'a> for TreeViewColumnSizing {
6898 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6899 Some(FromValue::from_value(value))
6900 }
6901}
6902
6903impl<'a> FromValue<'a> for TreeViewColumnSizing {
6904 unsafe fn from_value(value: &Value) -> Self {
6905 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6906 }
6907}
6908
6909impl SetValue for TreeViewColumnSizing {
6910 unsafe fn set_value(value: &mut Value, this: &Self) {
6911 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6912 }
6913}
6914
6915#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6916pub enum TreeViewDropPosition {
6917 Before,
6918 After,
6919 IntoOrBefore,
6920 IntoOrAfter,
6921 #[doc(hidden)]
6922 __Unknown(i32),
6923}
6924
6925impl fmt::Display for TreeViewDropPosition {
6926 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6927 write!(
6928 f,
6929 "TreeViewDropPosition::{}",
6930 match *self {
6931 TreeViewDropPosition::Before => "Before",
6932 TreeViewDropPosition::After => "After",
6933 TreeViewDropPosition::IntoOrBefore => "IntoOrBefore",
6934 TreeViewDropPosition::IntoOrAfter => "IntoOrAfter",
6935 _ => "Unknown",
6936 }
6937 )
6938 }
6939}
6940
6941#[doc(hidden)]
6942impl ToGlib for TreeViewDropPosition {
6943 type GlibType = gtk_sys::GtkTreeViewDropPosition;
6944
6945 fn to_glib(&self) -> gtk_sys::GtkTreeViewDropPosition {
6946 match *self {
6947 TreeViewDropPosition::Before => gtk_sys::GTK_TREE_VIEW_DROP_BEFORE,
6948 TreeViewDropPosition::After => gtk_sys::GTK_TREE_VIEW_DROP_AFTER,
6949 TreeViewDropPosition::IntoOrBefore => gtk_sys::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
6950 TreeViewDropPosition::IntoOrAfter => gtk_sys::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
6951 TreeViewDropPosition::__Unknown(value) => value,
6952 }
6953 }
6954}
6955
6956#[doc(hidden)]
6957impl FromGlib<gtk_sys::GtkTreeViewDropPosition> for TreeViewDropPosition {
6958 fn from_glib(value: gtk_sys::GtkTreeViewDropPosition) -> Self {
6959 skip_assert_initialized!();
6960 match value {
6961 0 => TreeViewDropPosition::Before,
6962 1 => TreeViewDropPosition::After,
6963 2 => TreeViewDropPosition::IntoOrBefore,
6964 3 => TreeViewDropPosition::IntoOrAfter,
6965 value => TreeViewDropPosition::__Unknown(value),
6966 }
6967 }
6968}
6969
6970impl StaticType for TreeViewDropPosition {
6971 fn static_type() -> Type {
6972 unsafe { from_glib(gtk_sys::gtk_tree_view_drop_position_get_type()) }
6973 }
6974}
6975
6976impl<'a> FromValueOptional<'a> for TreeViewDropPosition {
6977 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6978 Some(FromValue::from_value(value))
6979 }
6980}
6981
6982impl<'a> FromValue<'a> for TreeViewDropPosition {
6983 unsafe fn from_value(value: &Value) -> Self {
6984 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6985 }
6986}
6987
6988impl SetValue for TreeViewDropPosition {
6989 unsafe fn set_value(value: &mut Value, this: &Self) {
6990 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6991 }
6992}
6993
6994#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6995pub enum TreeViewGridLines {
6996 None,
6997 Horizontal,
6998 Vertical,
6999 Both,
7000 #[doc(hidden)]
7001 __Unknown(i32),
7002}
7003
7004impl fmt::Display for TreeViewGridLines {
7005 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7006 write!(
7007 f,
7008 "TreeViewGridLines::{}",
7009 match *self {
7010 TreeViewGridLines::None => "None",
7011 TreeViewGridLines::Horizontal => "Horizontal",
7012 TreeViewGridLines::Vertical => "Vertical",
7013 TreeViewGridLines::Both => "Both",
7014 _ => "Unknown",
7015 }
7016 )
7017 }
7018}
7019
7020#[doc(hidden)]
7021impl ToGlib for TreeViewGridLines {
7022 type GlibType = gtk_sys::GtkTreeViewGridLines;
7023
7024 fn to_glib(&self) -> gtk_sys::GtkTreeViewGridLines {
7025 match *self {
7026 TreeViewGridLines::None => gtk_sys::GTK_TREE_VIEW_GRID_LINES_NONE,
7027 TreeViewGridLines::Horizontal => gtk_sys::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
7028 TreeViewGridLines::Vertical => gtk_sys::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
7029 TreeViewGridLines::Both => gtk_sys::GTK_TREE_VIEW_GRID_LINES_BOTH,
7030 TreeViewGridLines::__Unknown(value) => value,
7031 }
7032 }
7033}
7034
7035#[doc(hidden)]
7036impl FromGlib<gtk_sys::GtkTreeViewGridLines> for TreeViewGridLines {
7037 fn from_glib(value: gtk_sys::GtkTreeViewGridLines) -> Self {
7038 skip_assert_initialized!();
7039 match value {
7040 0 => TreeViewGridLines::None,
7041 1 => TreeViewGridLines::Horizontal,
7042 2 => TreeViewGridLines::Vertical,
7043 3 => TreeViewGridLines::Both,
7044 value => TreeViewGridLines::__Unknown(value),
7045 }
7046 }
7047}
7048
7049impl StaticType for TreeViewGridLines {
7050 fn static_type() -> Type {
7051 unsafe { from_glib(gtk_sys::gtk_tree_view_grid_lines_get_type()) }
7052 }
7053}
7054
7055impl<'a> FromValueOptional<'a> for TreeViewGridLines {
7056 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7057 Some(FromValue::from_value(value))
7058 }
7059}
7060
7061impl<'a> FromValue<'a> for TreeViewGridLines {
7062 unsafe fn from_value(value: &Value) -> Self {
7063 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7064 }
7065}
7066
7067impl SetValue for TreeViewGridLines {
7068 unsafe fn set_value(value: &mut Value, this: &Self) {
7069 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7070 }
7071}
7072
7073#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7074pub enum Unit {
7075 None,
7076 Points,
7077 Inch,
7078 Mm,
7079 #[doc(hidden)]
7080 __Unknown(i32),
7081}
7082
7083impl fmt::Display for Unit {
7084 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7085 write!(
7086 f,
7087 "Unit::{}",
7088 match *self {
7089 Unit::None => "None",
7090 Unit::Points => "Points",
7091 Unit::Inch => "Inch",
7092 Unit::Mm => "Mm",
7093 _ => "Unknown",
7094 }
7095 )
7096 }
7097}
7098
7099#[doc(hidden)]
7100impl ToGlib for Unit {
7101 type GlibType = gtk_sys::GtkUnit;
7102
7103 fn to_glib(&self) -> gtk_sys::GtkUnit {
7104 match *self {
7105 Unit::None => gtk_sys::GTK_UNIT_NONE,
7106 Unit::Points => gtk_sys::GTK_UNIT_POINTS,
7107 Unit::Inch => gtk_sys::GTK_UNIT_INCH,
7108 Unit::Mm => gtk_sys::GTK_UNIT_MM,
7109 Unit::__Unknown(value) => value,
7110 }
7111 }
7112}
7113
7114#[doc(hidden)]
7115impl FromGlib<gtk_sys::GtkUnit> for Unit {
7116 fn from_glib(value: gtk_sys::GtkUnit) -> Self {
7117 skip_assert_initialized!();
7118 match value {
7119 0 => Unit::None,
7120 1 => Unit::Points,
7121 2 => Unit::Inch,
7122 3 => Unit::Mm,
7123 value => Unit::__Unknown(value),
7124 }
7125 }
7126}
7127
7128impl StaticType for Unit {
7129 fn static_type() -> Type {
7130 unsafe { from_glib(gtk_sys::gtk_unit_get_type()) }
7131 }
7132}
7133
7134impl<'a> FromValueOptional<'a> for Unit {
7135 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7136 Some(FromValue::from_value(value))
7137 }
7138}
7139
7140impl<'a> FromValue<'a> for Unit {
7141 unsafe fn from_value(value: &Value) -> Self {
7142 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7143 }
7144}
7145
7146impl SetValue for Unit {
7147 unsafe fn set_value(value: &mut Value, this: &Self) {
7148 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7149 }
7150}
7151
7152#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7153pub enum WidgetHelpType {
7154 Tooltip,
7155 WhatsThis,
7156 #[doc(hidden)]
7157 __Unknown(i32),
7158}
7159
7160impl fmt::Display for WidgetHelpType {
7161 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7162 write!(
7163 f,
7164 "WidgetHelpType::{}",
7165 match *self {
7166 WidgetHelpType::Tooltip => "Tooltip",
7167 WidgetHelpType::WhatsThis => "WhatsThis",
7168 _ => "Unknown",
7169 }
7170 )
7171 }
7172}
7173
7174#[doc(hidden)]
7175impl ToGlib for WidgetHelpType {
7176 type GlibType = gtk_sys::GtkWidgetHelpType;
7177
7178 fn to_glib(&self) -> gtk_sys::GtkWidgetHelpType {
7179 match *self {
7180 WidgetHelpType::Tooltip => gtk_sys::GTK_WIDGET_HELP_TOOLTIP,
7181 WidgetHelpType::WhatsThis => gtk_sys::GTK_WIDGET_HELP_WHATS_THIS,
7182 WidgetHelpType::__Unknown(value) => value,
7183 }
7184 }
7185}
7186
7187#[doc(hidden)]
7188impl FromGlib<gtk_sys::GtkWidgetHelpType> for WidgetHelpType {
7189 fn from_glib(value: gtk_sys::GtkWidgetHelpType) -> Self {
7190 skip_assert_initialized!();
7191 match value {
7192 0 => WidgetHelpType::Tooltip,
7193 1 => WidgetHelpType::WhatsThis,
7194 value => WidgetHelpType::__Unknown(value),
7195 }
7196 }
7197}
7198
7199impl StaticType for WidgetHelpType {
7200 fn static_type() -> Type {
7201 unsafe { from_glib(gtk_sys::gtk_widget_help_type_get_type()) }
7202 }
7203}
7204
7205impl<'a> FromValueOptional<'a> for WidgetHelpType {
7206 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7207 Some(FromValue::from_value(value))
7208 }
7209}
7210
7211impl<'a> FromValue<'a> for WidgetHelpType {
7212 unsafe fn from_value(value: &Value) -> Self {
7213 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7214 }
7215}
7216
7217impl SetValue for WidgetHelpType {
7218 unsafe fn set_value(value: &mut Value, this: &Self) {
7219 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7220 }
7221}
7222
7223#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7224pub enum WindowPosition {
7225 None,
7226 Center,
7227 Mouse,
7228 CenterAlways,
7229 CenterOnParent,
7230 #[doc(hidden)]
7231 __Unknown(i32),
7232}
7233
7234impl fmt::Display for WindowPosition {
7235 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7236 write!(
7237 f,
7238 "WindowPosition::{}",
7239 match *self {
7240 WindowPosition::None => "None",
7241 WindowPosition::Center => "Center",
7242 WindowPosition::Mouse => "Mouse",
7243 WindowPosition::CenterAlways => "CenterAlways",
7244 WindowPosition::CenterOnParent => "CenterOnParent",
7245 _ => "Unknown",
7246 }
7247 )
7248 }
7249}
7250
7251#[doc(hidden)]
7252impl ToGlib for WindowPosition {
7253 type GlibType = gtk_sys::GtkWindowPosition;
7254
7255 fn to_glib(&self) -> gtk_sys::GtkWindowPosition {
7256 match *self {
7257 WindowPosition::None => gtk_sys::GTK_WIN_POS_NONE,
7258 WindowPosition::Center => gtk_sys::GTK_WIN_POS_CENTER,
7259 WindowPosition::Mouse => gtk_sys::GTK_WIN_POS_MOUSE,
7260 WindowPosition::CenterAlways => gtk_sys::GTK_WIN_POS_CENTER_ALWAYS,
7261 WindowPosition::CenterOnParent => gtk_sys::GTK_WIN_POS_CENTER_ON_PARENT,
7262 WindowPosition::__Unknown(value) => value,
7263 }
7264 }
7265}
7266
7267#[doc(hidden)]
7268impl FromGlib<gtk_sys::GtkWindowPosition> for WindowPosition {
7269 fn from_glib(value: gtk_sys::GtkWindowPosition) -> Self {
7270 skip_assert_initialized!();
7271 match value {
7272 0 => WindowPosition::None,
7273 1 => WindowPosition::Center,
7274 2 => WindowPosition::Mouse,
7275 3 => WindowPosition::CenterAlways,
7276 4 => WindowPosition::CenterOnParent,
7277 value => WindowPosition::__Unknown(value),
7278 }
7279 }
7280}
7281
7282impl StaticType for WindowPosition {
7283 fn static_type() -> Type {
7284 unsafe { from_glib(gtk_sys::gtk_window_position_get_type()) }
7285 }
7286}
7287
7288impl<'a> FromValueOptional<'a> for WindowPosition {
7289 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7290 Some(FromValue::from_value(value))
7291 }
7292}
7293
7294impl<'a> FromValue<'a> for WindowPosition {
7295 unsafe fn from_value(value: &Value) -> Self {
7296 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7297 }
7298}
7299
7300impl SetValue for WindowPosition {
7301 unsafe fn set_value(value: &mut Value, this: &Self) {
7302 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7303 }
7304}
7305
7306#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7307pub enum WindowType {
7308 Toplevel,
7309 Popup,
7310 #[doc(hidden)]
7311 __Unknown(i32),
7312}
7313
7314impl fmt::Display for WindowType {
7315 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7316 write!(
7317 f,
7318 "WindowType::{}",
7319 match *self {
7320 WindowType::Toplevel => "Toplevel",
7321 WindowType::Popup => "Popup",
7322 _ => "Unknown",
7323 }
7324 )
7325 }
7326}
7327
7328#[doc(hidden)]
7329impl ToGlib for WindowType {
7330 type GlibType = gtk_sys::GtkWindowType;
7331
7332 fn to_glib(&self) -> gtk_sys::GtkWindowType {
7333 match *self {
7334 WindowType::Toplevel => gtk_sys::GTK_WINDOW_TOPLEVEL,
7335 WindowType::Popup => gtk_sys::GTK_WINDOW_POPUP,
7336 WindowType::__Unknown(value) => value,
7337 }
7338 }
7339}
7340
7341#[doc(hidden)]
7342impl FromGlib<gtk_sys::GtkWindowType> for WindowType {
7343 fn from_glib(value: gtk_sys::GtkWindowType) -> Self {
7344 skip_assert_initialized!();
7345 match value {
7346 0 => WindowType::Toplevel,
7347 1 => WindowType::Popup,
7348 value => WindowType::__Unknown(value),
7349 }
7350 }
7351}
7352
7353impl StaticType for WindowType {
7354 fn static_type() -> Type {
7355 unsafe { from_glib(gtk_sys::gtk_window_type_get_type()) }
7356 }
7357}
7358
7359impl<'a> FromValueOptional<'a> for WindowType {
7360 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7361 Some(FromValue::from_value(value))
7362 }
7363}
7364
7365impl<'a> FromValue<'a> for WindowType {
7366 unsafe fn from_value(value: &Value) -> Self {
7367 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7368 }
7369}
7370
7371impl SetValue for WindowType {
7372 unsafe fn set_value(value: &mut Value, this: &Self) {
7373 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7374 }
7375}
7376
7377#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7378pub enum WrapMode {
7379 None,
7380 Char,
7381 Word,
7382 WordChar,
7383 #[doc(hidden)]
7384 __Unknown(i32),
7385}
7386
7387impl fmt::Display for WrapMode {
7388 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7389 write!(
7390 f,
7391 "WrapMode::{}",
7392 match *self {
7393 WrapMode::None => "None",
7394 WrapMode::Char => "Char",
7395 WrapMode::Word => "Word",
7396 WrapMode::WordChar => "WordChar",
7397 _ => "Unknown",
7398 }
7399 )
7400 }
7401}
7402
7403#[doc(hidden)]
7404impl ToGlib for WrapMode {
7405 type GlibType = gtk_sys::GtkWrapMode;
7406
7407 fn to_glib(&self) -> gtk_sys::GtkWrapMode {
7408 match *self {
7409 WrapMode::None => gtk_sys::GTK_WRAP_NONE,
7410 WrapMode::Char => gtk_sys::GTK_WRAP_CHAR,
7411 WrapMode::Word => gtk_sys::GTK_WRAP_WORD,
7412 WrapMode::WordChar => gtk_sys::GTK_WRAP_WORD_CHAR,
7413 WrapMode::__Unknown(value) => value,
7414 }
7415 }
7416}
7417
7418#[doc(hidden)]
7419impl FromGlib<gtk_sys::GtkWrapMode> for WrapMode {
7420 fn from_glib(value: gtk_sys::GtkWrapMode) -> Self {
7421 skip_assert_initialized!();
7422 match value {
7423 0 => WrapMode::None,
7424 1 => WrapMode::Char,
7425 2 => WrapMode::Word,
7426 3 => WrapMode::WordChar,
7427 value => WrapMode::__Unknown(value),
7428 }
7429 }
7430}
7431
7432impl StaticType for WrapMode {
7433 fn static_type() -> Type {
7434 unsafe { from_glib(gtk_sys::gtk_wrap_mode_get_type()) }
7435 }
7436}
7437
7438impl<'a> FromValueOptional<'a> for WrapMode {
7439 unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7440 Some(FromValue::from_value(value))
7441 }
7442}
7443
7444impl<'a> FromValue<'a> for WrapMode {
7445 unsafe fn from_value(value: &Value) -> Self {
7446 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7447 }
7448}
7449
7450impl SetValue for WrapMode {
7451 unsafe fn set_value(value: &mut Value, this: &Self) {
7452 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7453 }
7454}