1 // This file was generated by gir (https://github.com/gtk-rs/gir) 2 // from gir-files (https://github.com/gtk-rs/gir-files) 3 // DO NOT EDIT 4 5 use glib::error::ErrorDomain; 6 use glib::translate::*; 7 use glib::value::FromValue; 8 use glib::value::ToValue; 9 use glib::Quark; 10 use glib::StaticType; 11 use glib::Type; 12 use std::fmt; 13 use std::mem; 14 15 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 16 #[non_exhaustive] 17 #[doc(alias = "GtkAlign")] 18 pub enum Align { 19 #[doc(alias = "GTK_ALIGN_FILL")] 20 Fill, 21 #[doc(alias = "GTK_ALIGN_START")] 22 Start, 23 #[doc(alias = "GTK_ALIGN_END")] 24 End, 25 #[doc(alias = "GTK_ALIGN_CENTER")] 26 Center, 27 #[doc(alias = "GTK_ALIGN_BASELINE")] 28 Baseline, 29 #[doc(hidden)] 30 __Unknown(i32), 31 } 32 33 impl fmt::Display for Align { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result34 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 35 write!( 36 f, 37 "Align::{}", 38 match *self { 39 Self::Fill => "Fill", 40 Self::Start => "Start", 41 Self::End => "End", 42 Self::Center => "Center", 43 Self::Baseline => "Baseline", 44 _ => "Unknown", 45 } 46 ) 47 } 48 } 49 50 #[doc(hidden)] 51 impl IntoGlib for Align { 52 type GlibType = ffi::GtkAlign; 53 into_glib(self) -> ffi::GtkAlign54 fn into_glib(self) -> ffi::GtkAlign { 55 match self { 56 Self::Fill => ffi::GTK_ALIGN_FILL, 57 Self::Start => ffi::GTK_ALIGN_START, 58 Self::End => ffi::GTK_ALIGN_END, 59 Self::Center => ffi::GTK_ALIGN_CENTER, 60 Self::Baseline => ffi::GTK_ALIGN_BASELINE, 61 Self::__Unknown(value) => value, 62 } 63 } 64 } 65 66 #[doc(hidden)] 67 impl FromGlib<ffi::GtkAlign> for Align { from_glib(value: ffi::GtkAlign) -> Self68 unsafe fn from_glib(value: ffi::GtkAlign) -> Self { 69 skip_assert_initialized!(); 70 match value { 71 ffi::GTK_ALIGN_FILL => Self::Fill, 72 ffi::GTK_ALIGN_START => Self::Start, 73 ffi::GTK_ALIGN_END => Self::End, 74 ffi::GTK_ALIGN_CENTER => Self::Center, 75 ffi::GTK_ALIGN_BASELINE => Self::Baseline, 76 value => Self::__Unknown(value), 77 } 78 } 79 } 80 81 impl StaticType for Align { static_type() -> Type82 fn static_type() -> Type { 83 unsafe { from_glib(ffi::gtk_align_get_type()) } 84 } 85 } 86 87 impl glib::value::ValueType for Align { 88 type Type = Self; 89 } 90 91 unsafe impl<'a> FromValue<'a> for Align { 92 type Checker = glib::value::GenericValueTypeChecker<Self>; 93 from_value(value: &'a glib::Value) -> Self94 unsafe fn from_value(value: &'a glib::Value) -> Self { 95 skip_assert_initialized!(); 96 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 97 } 98 } 99 100 impl ToValue for Align { to_value(&self) -> glib::Value101 fn to_value(&self) -> glib::Value { 102 let mut value = glib::Value::for_value_type::<Self>(); 103 unsafe { 104 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 105 } 106 value 107 } 108 value_type(&self) -> glib::Type109 fn value_type(&self) -> glib::Type { 110 Self::static_type() 111 } 112 } 113 114 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 115 #[non_exhaustive] 116 #[doc(alias = "GtkArrowType")] 117 pub enum ArrowType { 118 #[doc(alias = "GTK_ARROW_UP")] 119 Up, 120 #[doc(alias = "GTK_ARROW_DOWN")] 121 Down, 122 #[doc(alias = "GTK_ARROW_LEFT")] 123 Left, 124 #[doc(alias = "GTK_ARROW_RIGHT")] 125 Right, 126 #[doc(alias = "GTK_ARROW_NONE")] 127 None, 128 #[doc(hidden)] 129 __Unknown(i32), 130 } 131 132 impl fmt::Display for ArrowType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result133 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 134 write!( 135 f, 136 "ArrowType::{}", 137 match *self { 138 Self::Up => "Up", 139 Self::Down => "Down", 140 Self::Left => "Left", 141 Self::Right => "Right", 142 Self::None => "None", 143 _ => "Unknown", 144 } 145 ) 146 } 147 } 148 149 #[doc(hidden)] 150 impl IntoGlib for ArrowType { 151 type GlibType = ffi::GtkArrowType; 152 into_glib(self) -> ffi::GtkArrowType153 fn into_glib(self) -> ffi::GtkArrowType { 154 match self { 155 Self::Up => ffi::GTK_ARROW_UP, 156 Self::Down => ffi::GTK_ARROW_DOWN, 157 Self::Left => ffi::GTK_ARROW_LEFT, 158 Self::Right => ffi::GTK_ARROW_RIGHT, 159 Self::None => ffi::GTK_ARROW_NONE, 160 Self::__Unknown(value) => value, 161 } 162 } 163 } 164 165 #[doc(hidden)] 166 impl FromGlib<ffi::GtkArrowType> for ArrowType { from_glib(value: ffi::GtkArrowType) -> Self167 unsafe fn from_glib(value: ffi::GtkArrowType) -> Self { 168 skip_assert_initialized!(); 169 match value { 170 ffi::GTK_ARROW_UP => Self::Up, 171 ffi::GTK_ARROW_DOWN => Self::Down, 172 ffi::GTK_ARROW_LEFT => Self::Left, 173 ffi::GTK_ARROW_RIGHT => Self::Right, 174 ffi::GTK_ARROW_NONE => Self::None, 175 value => Self::__Unknown(value), 176 } 177 } 178 } 179 180 impl StaticType for ArrowType { static_type() -> Type181 fn static_type() -> Type { 182 unsafe { from_glib(ffi::gtk_arrow_type_get_type()) } 183 } 184 } 185 186 impl glib::value::ValueType for ArrowType { 187 type Type = Self; 188 } 189 190 unsafe impl<'a> FromValue<'a> for ArrowType { 191 type Checker = glib::value::GenericValueTypeChecker<Self>; 192 from_value(value: &'a glib::Value) -> Self193 unsafe fn from_value(value: &'a glib::Value) -> Self { 194 skip_assert_initialized!(); 195 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 196 } 197 } 198 199 impl ToValue for ArrowType { to_value(&self) -> glib::Value200 fn to_value(&self) -> glib::Value { 201 let mut value = glib::Value::for_value_type::<Self>(); 202 unsafe { 203 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 204 } 205 value 206 } 207 value_type(&self) -> glib::Type208 fn value_type(&self) -> glib::Type { 209 Self::static_type() 210 } 211 } 212 213 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 214 #[non_exhaustive] 215 #[doc(alias = "GtkAssistantPageType")] 216 pub enum AssistantPageType { 217 #[doc(alias = "GTK_ASSISTANT_PAGE_CONTENT")] 218 Content, 219 #[doc(alias = "GTK_ASSISTANT_PAGE_INTRO")] 220 Intro, 221 #[doc(alias = "GTK_ASSISTANT_PAGE_CONFIRM")] 222 Confirm, 223 #[doc(alias = "GTK_ASSISTANT_PAGE_SUMMARY")] 224 Summary, 225 #[doc(alias = "GTK_ASSISTANT_PAGE_PROGRESS")] 226 Progress, 227 #[doc(alias = "GTK_ASSISTANT_PAGE_CUSTOM")] 228 Custom, 229 #[doc(hidden)] 230 __Unknown(i32), 231 } 232 233 impl fmt::Display for AssistantPageType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result234 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 235 write!( 236 f, 237 "AssistantPageType::{}", 238 match *self { 239 Self::Content => "Content", 240 Self::Intro => "Intro", 241 Self::Confirm => "Confirm", 242 Self::Summary => "Summary", 243 Self::Progress => "Progress", 244 Self::Custom => "Custom", 245 _ => "Unknown", 246 } 247 ) 248 } 249 } 250 251 #[doc(hidden)] 252 impl IntoGlib for AssistantPageType { 253 type GlibType = ffi::GtkAssistantPageType; 254 into_glib(self) -> ffi::GtkAssistantPageType255 fn into_glib(self) -> ffi::GtkAssistantPageType { 256 match self { 257 Self::Content => ffi::GTK_ASSISTANT_PAGE_CONTENT, 258 Self::Intro => ffi::GTK_ASSISTANT_PAGE_INTRO, 259 Self::Confirm => ffi::GTK_ASSISTANT_PAGE_CONFIRM, 260 Self::Summary => ffi::GTK_ASSISTANT_PAGE_SUMMARY, 261 Self::Progress => ffi::GTK_ASSISTANT_PAGE_PROGRESS, 262 Self::Custom => ffi::GTK_ASSISTANT_PAGE_CUSTOM, 263 Self::__Unknown(value) => value, 264 } 265 } 266 } 267 268 #[doc(hidden)] 269 impl FromGlib<ffi::GtkAssistantPageType> for AssistantPageType { from_glib(value: ffi::GtkAssistantPageType) -> Self270 unsafe fn from_glib(value: ffi::GtkAssistantPageType) -> Self { 271 skip_assert_initialized!(); 272 match value { 273 ffi::GTK_ASSISTANT_PAGE_CONTENT => Self::Content, 274 ffi::GTK_ASSISTANT_PAGE_INTRO => Self::Intro, 275 ffi::GTK_ASSISTANT_PAGE_CONFIRM => Self::Confirm, 276 ffi::GTK_ASSISTANT_PAGE_SUMMARY => Self::Summary, 277 ffi::GTK_ASSISTANT_PAGE_PROGRESS => Self::Progress, 278 ffi::GTK_ASSISTANT_PAGE_CUSTOM => Self::Custom, 279 value => Self::__Unknown(value), 280 } 281 } 282 } 283 284 impl StaticType for AssistantPageType { static_type() -> Type285 fn static_type() -> Type { 286 unsafe { from_glib(ffi::gtk_assistant_page_type_get_type()) } 287 } 288 } 289 290 impl glib::value::ValueType for AssistantPageType { 291 type Type = Self; 292 } 293 294 unsafe impl<'a> FromValue<'a> for AssistantPageType { 295 type Checker = glib::value::GenericValueTypeChecker<Self>; 296 from_value(value: &'a glib::Value) -> Self297 unsafe fn from_value(value: &'a glib::Value) -> Self { 298 skip_assert_initialized!(); 299 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 300 } 301 } 302 303 impl ToValue for AssistantPageType { to_value(&self) -> glib::Value304 fn to_value(&self) -> glib::Value { 305 let mut value = glib::Value::for_value_type::<Self>(); 306 unsafe { 307 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 308 } 309 value 310 } 311 value_type(&self) -> glib::Type312 fn value_type(&self) -> glib::Type { 313 Self::static_type() 314 } 315 } 316 317 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 318 #[non_exhaustive] 319 #[doc(alias = "GtkBaselinePosition")] 320 pub enum BaselinePosition { 321 #[doc(alias = "GTK_BASELINE_POSITION_TOP")] 322 Top, 323 #[doc(alias = "GTK_BASELINE_POSITION_CENTER")] 324 Center, 325 #[doc(alias = "GTK_BASELINE_POSITION_BOTTOM")] 326 Bottom, 327 #[doc(hidden)] 328 __Unknown(i32), 329 } 330 331 impl fmt::Display for BaselinePosition { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result332 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 333 write!( 334 f, 335 "BaselinePosition::{}", 336 match *self { 337 Self::Top => "Top", 338 Self::Center => "Center", 339 Self::Bottom => "Bottom", 340 _ => "Unknown", 341 } 342 ) 343 } 344 } 345 346 #[doc(hidden)] 347 impl IntoGlib for BaselinePosition { 348 type GlibType = ffi::GtkBaselinePosition; 349 into_glib(self) -> ffi::GtkBaselinePosition350 fn into_glib(self) -> ffi::GtkBaselinePosition { 351 match self { 352 Self::Top => ffi::GTK_BASELINE_POSITION_TOP, 353 Self::Center => ffi::GTK_BASELINE_POSITION_CENTER, 354 Self::Bottom => ffi::GTK_BASELINE_POSITION_BOTTOM, 355 Self::__Unknown(value) => value, 356 } 357 } 358 } 359 360 #[doc(hidden)] 361 impl FromGlib<ffi::GtkBaselinePosition> for BaselinePosition { from_glib(value: ffi::GtkBaselinePosition) -> Self362 unsafe fn from_glib(value: ffi::GtkBaselinePosition) -> Self { 363 skip_assert_initialized!(); 364 match value { 365 ffi::GTK_BASELINE_POSITION_TOP => Self::Top, 366 ffi::GTK_BASELINE_POSITION_CENTER => Self::Center, 367 ffi::GTK_BASELINE_POSITION_BOTTOM => Self::Bottom, 368 value => Self::__Unknown(value), 369 } 370 } 371 } 372 373 impl StaticType for BaselinePosition { static_type() -> Type374 fn static_type() -> Type { 375 unsafe { from_glib(ffi::gtk_baseline_position_get_type()) } 376 } 377 } 378 379 impl glib::value::ValueType for BaselinePosition { 380 type Type = Self; 381 } 382 383 unsafe impl<'a> FromValue<'a> for BaselinePosition { 384 type Checker = glib::value::GenericValueTypeChecker<Self>; 385 from_value(value: &'a glib::Value) -> Self386 unsafe fn from_value(value: &'a glib::Value) -> Self { 387 skip_assert_initialized!(); 388 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 389 } 390 } 391 392 impl ToValue for BaselinePosition { to_value(&self) -> glib::Value393 fn to_value(&self) -> glib::Value { 394 let mut value = glib::Value::for_value_type::<Self>(); 395 unsafe { 396 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 397 } 398 value 399 } 400 value_type(&self) -> glib::Type401 fn value_type(&self) -> glib::Type { 402 Self::static_type() 403 } 404 } 405 406 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 407 #[non_exhaustive] 408 #[doc(alias = "GtkBorderStyle")] 409 pub enum BorderStyle { 410 #[doc(alias = "GTK_BORDER_STYLE_NONE")] 411 None, 412 #[doc(alias = "GTK_BORDER_STYLE_SOLID")] 413 Solid, 414 #[doc(alias = "GTK_BORDER_STYLE_INSET")] 415 Inset, 416 #[doc(alias = "GTK_BORDER_STYLE_OUTSET")] 417 Outset, 418 #[doc(alias = "GTK_BORDER_STYLE_HIDDEN")] 419 Hidden, 420 #[doc(alias = "GTK_BORDER_STYLE_DOTTED")] 421 Dotted, 422 #[doc(alias = "GTK_BORDER_STYLE_DASHED")] 423 Dashed, 424 #[doc(alias = "GTK_BORDER_STYLE_DOUBLE")] 425 Double, 426 #[doc(alias = "GTK_BORDER_STYLE_GROOVE")] 427 Groove, 428 #[doc(alias = "GTK_BORDER_STYLE_RIDGE")] 429 Ridge, 430 #[doc(hidden)] 431 __Unknown(i32), 432 } 433 434 impl fmt::Display for BorderStyle { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result435 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 436 write!( 437 f, 438 "BorderStyle::{}", 439 match *self { 440 Self::None => "None", 441 Self::Solid => "Solid", 442 Self::Inset => "Inset", 443 Self::Outset => "Outset", 444 Self::Hidden => "Hidden", 445 Self::Dotted => "Dotted", 446 Self::Dashed => "Dashed", 447 Self::Double => "Double", 448 Self::Groove => "Groove", 449 Self::Ridge => "Ridge", 450 _ => "Unknown", 451 } 452 ) 453 } 454 } 455 456 #[doc(hidden)] 457 impl IntoGlib for BorderStyle { 458 type GlibType = ffi::GtkBorderStyle; 459 into_glib(self) -> ffi::GtkBorderStyle460 fn into_glib(self) -> ffi::GtkBorderStyle { 461 match self { 462 Self::None => ffi::GTK_BORDER_STYLE_NONE, 463 Self::Solid => ffi::GTK_BORDER_STYLE_SOLID, 464 Self::Inset => ffi::GTK_BORDER_STYLE_INSET, 465 Self::Outset => ffi::GTK_BORDER_STYLE_OUTSET, 466 Self::Hidden => ffi::GTK_BORDER_STYLE_HIDDEN, 467 Self::Dotted => ffi::GTK_BORDER_STYLE_DOTTED, 468 Self::Dashed => ffi::GTK_BORDER_STYLE_DASHED, 469 Self::Double => ffi::GTK_BORDER_STYLE_DOUBLE, 470 Self::Groove => ffi::GTK_BORDER_STYLE_GROOVE, 471 Self::Ridge => ffi::GTK_BORDER_STYLE_RIDGE, 472 Self::__Unknown(value) => value, 473 } 474 } 475 } 476 477 #[doc(hidden)] 478 impl FromGlib<ffi::GtkBorderStyle> for BorderStyle { from_glib(value: ffi::GtkBorderStyle) -> Self479 unsafe fn from_glib(value: ffi::GtkBorderStyle) -> Self { 480 skip_assert_initialized!(); 481 match value { 482 ffi::GTK_BORDER_STYLE_NONE => Self::None, 483 ffi::GTK_BORDER_STYLE_SOLID => Self::Solid, 484 ffi::GTK_BORDER_STYLE_INSET => Self::Inset, 485 ffi::GTK_BORDER_STYLE_OUTSET => Self::Outset, 486 ffi::GTK_BORDER_STYLE_HIDDEN => Self::Hidden, 487 ffi::GTK_BORDER_STYLE_DOTTED => Self::Dotted, 488 ffi::GTK_BORDER_STYLE_DASHED => Self::Dashed, 489 ffi::GTK_BORDER_STYLE_DOUBLE => Self::Double, 490 ffi::GTK_BORDER_STYLE_GROOVE => Self::Groove, 491 ffi::GTK_BORDER_STYLE_RIDGE => Self::Ridge, 492 value => Self::__Unknown(value), 493 } 494 } 495 } 496 497 impl StaticType for BorderStyle { static_type() -> Type498 fn static_type() -> Type { 499 unsafe { from_glib(ffi::gtk_border_style_get_type()) } 500 } 501 } 502 503 impl glib::value::ValueType for BorderStyle { 504 type Type = Self; 505 } 506 507 unsafe impl<'a> FromValue<'a> for BorderStyle { 508 type Checker = glib::value::GenericValueTypeChecker<Self>; 509 from_value(value: &'a glib::Value) -> Self510 unsafe fn from_value(value: &'a glib::Value) -> Self { 511 skip_assert_initialized!(); 512 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 513 } 514 } 515 516 impl ToValue for BorderStyle { to_value(&self) -> glib::Value517 fn to_value(&self) -> glib::Value { 518 let mut value = glib::Value::for_value_type::<Self>(); 519 unsafe { 520 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 521 } 522 value 523 } 524 value_type(&self) -> glib::Type525 fn value_type(&self) -> glib::Type { 526 Self::static_type() 527 } 528 } 529 530 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 531 #[non_exhaustive] 532 #[doc(alias = "GtkBuilderError")] 533 pub enum BuilderError { 534 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION")] 535 InvalidTypeFunction, 536 #[doc(alias = "GTK_BUILDER_ERROR_UNHANDLED_TAG")] 537 UnhandledTag, 538 #[doc(alias = "GTK_BUILDER_ERROR_MISSING_ATTRIBUTE")] 539 MissingAttribute, 540 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ATTRIBUTE")] 541 InvalidAttribute, 542 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TAG")] 543 InvalidTag, 544 #[doc(alias = "GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE")] 545 MissingPropertyValue, 546 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_VALUE")] 547 InvalidValue, 548 #[doc(alias = "GTK_BUILDER_ERROR_VERSION_MISMATCH")] 549 VersionMismatch, 550 #[doc(alias = "GTK_BUILDER_ERROR_DUPLICATE_ID")] 551 DuplicateId, 552 #[doc(alias = "GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED")] 553 ObjectTypeRefused, 554 #[doc(alias = "GTK_BUILDER_ERROR_TEMPLATE_MISMATCH")] 555 TemplateMismatch, 556 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_PROPERTY")] 557 InvalidProperty, 558 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_SIGNAL")] 559 InvalidSignal, 560 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ID")] 561 InvalidId, 562 #[doc(hidden)] 563 __Unknown(i32), 564 } 565 566 impl fmt::Display for BuilderError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result567 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 568 write!( 569 f, 570 "BuilderError::{}", 571 match *self { 572 Self::InvalidTypeFunction => "InvalidTypeFunction", 573 Self::UnhandledTag => "UnhandledTag", 574 Self::MissingAttribute => "MissingAttribute", 575 Self::InvalidAttribute => "InvalidAttribute", 576 Self::InvalidTag => "InvalidTag", 577 Self::MissingPropertyValue => "MissingPropertyValue", 578 Self::InvalidValue => "InvalidValue", 579 Self::VersionMismatch => "VersionMismatch", 580 Self::DuplicateId => "DuplicateId", 581 Self::ObjectTypeRefused => "ObjectTypeRefused", 582 Self::TemplateMismatch => "TemplateMismatch", 583 Self::InvalidProperty => "InvalidProperty", 584 Self::InvalidSignal => "InvalidSignal", 585 Self::InvalidId => "InvalidId", 586 _ => "Unknown", 587 } 588 ) 589 } 590 } 591 592 #[doc(hidden)] 593 impl IntoGlib for BuilderError { 594 type GlibType = ffi::GtkBuilderError; 595 into_glib(self) -> ffi::GtkBuilderError596 fn into_glib(self) -> ffi::GtkBuilderError { 597 match self { 598 Self::InvalidTypeFunction => ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION, 599 Self::UnhandledTag => ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG, 600 Self::MissingAttribute => ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE, 601 Self::InvalidAttribute => ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE, 602 Self::InvalidTag => ffi::GTK_BUILDER_ERROR_INVALID_TAG, 603 Self::MissingPropertyValue => ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE, 604 Self::InvalidValue => ffi::GTK_BUILDER_ERROR_INVALID_VALUE, 605 Self::VersionMismatch => ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH, 606 Self::DuplicateId => ffi::GTK_BUILDER_ERROR_DUPLICATE_ID, 607 Self::ObjectTypeRefused => ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED, 608 Self::TemplateMismatch => ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH, 609 Self::InvalidProperty => ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY, 610 Self::InvalidSignal => ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL, 611 Self::InvalidId => ffi::GTK_BUILDER_ERROR_INVALID_ID, 612 Self::__Unknown(value) => value, 613 } 614 } 615 } 616 617 #[doc(hidden)] 618 impl FromGlib<ffi::GtkBuilderError> for BuilderError { from_glib(value: ffi::GtkBuilderError) -> Self619 unsafe fn from_glib(value: ffi::GtkBuilderError) -> Self { 620 skip_assert_initialized!(); 621 match value { 622 ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION => Self::InvalidTypeFunction, 623 ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG => Self::UnhandledTag, 624 ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE => Self::MissingAttribute, 625 ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute, 626 ffi::GTK_BUILDER_ERROR_INVALID_TAG => Self::InvalidTag, 627 ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE => Self::MissingPropertyValue, 628 ffi::GTK_BUILDER_ERROR_INVALID_VALUE => Self::InvalidValue, 629 ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH => Self::VersionMismatch, 630 ffi::GTK_BUILDER_ERROR_DUPLICATE_ID => Self::DuplicateId, 631 ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED => Self::ObjectTypeRefused, 632 ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH => Self::TemplateMismatch, 633 ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY => Self::InvalidProperty, 634 ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL => Self::InvalidSignal, 635 ffi::GTK_BUILDER_ERROR_INVALID_ID => Self::InvalidId, 636 value => Self::__Unknown(value), 637 } 638 } 639 } 640 641 impl ErrorDomain for BuilderError { domain() -> Quark642 fn domain() -> Quark { 643 skip_assert_initialized!(); 644 645 unsafe { from_glib(ffi::gtk_builder_error_quark()) } 646 } 647 code(self) -> i32648 fn code(self) -> i32 { 649 self.into_glib() 650 } 651 from(code: i32) -> Option<Self>652 fn from(code: i32) -> Option<Self> { 653 skip_assert_initialized!(); 654 match code { 655 ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION => Some(Self::InvalidTypeFunction), 656 ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG => Some(Self::UnhandledTag), 657 ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE => Some(Self::MissingAttribute), 658 ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE => Some(Self::InvalidAttribute), 659 ffi::GTK_BUILDER_ERROR_INVALID_TAG => Some(Self::InvalidTag), 660 ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE => Some(Self::MissingPropertyValue), 661 ffi::GTK_BUILDER_ERROR_INVALID_VALUE => Some(Self::InvalidValue), 662 ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH => Some(Self::VersionMismatch), 663 ffi::GTK_BUILDER_ERROR_DUPLICATE_ID => Some(Self::DuplicateId), 664 ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED => Some(Self::ObjectTypeRefused), 665 ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH => Some(Self::TemplateMismatch), 666 ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY => Some(Self::InvalidProperty), 667 ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL => Some(Self::InvalidSignal), 668 ffi::GTK_BUILDER_ERROR_INVALID_ID => Some(Self::InvalidId), 669 value => Some(Self::__Unknown(value)), 670 } 671 } 672 } 673 674 impl StaticType for BuilderError { static_type() -> Type675 fn static_type() -> Type { 676 unsafe { from_glib(ffi::gtk_builder_error_get_type()) } 677 } 678 } 679 680 impl glib::value::ValueType for BuilderError { 681 type Type = Self; 682 } 683 684 unsafe impl<'a> FromValue<'a> for BuilderError { 685 type Checker = glib::value::GenericValueTypeChecker<Self>; 686 from_value(value: &'a glib::Value) -> Self687 unsafe fn from_value(value: &'a glib::Value) -> Self { 688 skip_assert_initialized!(); 689 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 690 } 691 } 692 693 impl ToValue for BuilderError { to_value(&self) -> glib::Value694 fn to_value(&self) -> glib::Value { 695 let mut value = glib::Value::for_value_type::<Self>(); 696 unsafe { 697 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 698 } 699 value 700 } 701 value_type(&self) -> glib::Type702 fn value_type(&self) -> glib::Type { 703 Self::static_type() 704 } 705 } 706 707 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 708 #[non_exhaustive] 709 #[doc(alias = "GtkButtonBoxStyle")] 710 pub enum ButtonBoxStyle { 711 #[doc(alias = "GTK_BUTTONBOX_SPREAD")] 712 Spread, 713 #[doc(alias = "GTK_BUTTONBOX_EDGE")] 714 Edge, 715 #[doc(alias = "GTK_BUTTONBOX_START")] 716 Start, 717 #[doc(alias = "GTK_BUTTONBOX_END")] 718 End, 719 #[doc(alias = "GTK_BUTTONBOX_CENTER")] 720 Center, 721 #[doc(alias = "GTK_BUTTONBOX_EXPAND")] 722 Expand, 723 #[doc(hidden)] 724 __Unknown(i32), 725 } 726 727 impl fmt::Display for ButtonBoxStyle { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result728 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 729 write!( 730 f, 731 "ButtonBoxStyle::{}", 732 match *self { 733 Self::Spread => "Spread", 734 Self::Edge => "Edge", 735 Self::Start => "Start", 736 Self::End => "End", 737 Self::Center => "Center", 738 Self::Expand => "Expand", 739 _ => "Unknown", 740 } 741 ) 742 } 743 } 744 745 #[doc(hidden)] 746 impl IntoGlib for ButtonBoxStyle { 747 type GlibType = ffi::GtkButtonBoxStyle; 748 into_glib(self) -> ffi::GtkButtonBoxStyle749 fn into_glib(self) -> ffi::GtkButtonBoxStyle { 750 match self { 751 Self::Spread => ffi::GTK_BUTTONBOX_SPREAD, 752 Self::Edge => ffi::GTK_BUTTONBOX_EDGE, 753 Self::Start => ffi::GTK_BUTTONBOX_START, 754 Self::End => ffi::GTK_BUTTONBOX_END, 755 Self::Center => ffi::GTK_BUTTONBOX_CENTER, 756 Self::Expand => ffi::GTK_BUTTONBOX_EXPAND, 757 Self::__Unknown(value) => value, 758 } 759 } 760 } 761 762 #[doc(hidden)] 763 impl FromGlib<ffi::GtkButtonBoxStyle> for ButtonBoxStyle { from_glib(value: ffi::GtkButtonBoxStyle) -> Self764 unsafe fn from_glib(value: ffi::GtkButtonBoxStyle) -> Self { 765 skip_assert_initialized!(); 766 match value { 767 ffi::GTK_BUTTONBOX_SPREAD => Self::Spread, 768 ffi::GTK_BUTTONBOX_EDGE => Self::Edge, 769 ffi::GTK_BUTTONBOX_START => Self::Start, 770 ffi::GTK_BUTTONBOX_END => Self::End, 771 ffi::GTK_BUTTONBOX_CENTER => Self::Center, 772 ffi::GTK_BUTTONBOX_EXPAND => Self::Expand, 773 value => Self::__Unknown(value), 774 } 775 } 776 } 777 778 impl StaticType for ButtonBoxStyle { static_type() -> Type779 fn static_type() -> Type { 780 unsafe { from_glib(ffi::gtk_button_box_style_get_type()) } 781 } 782 } 783 784 impl glib::value::ValueType for ButtonBoxStyle { 785 type Type = Self; 786 } 787 788 unsafe impl<'a> FromValue<'a> for ButtonBoxStyle { 789 type Checker = glib::value::GenericValueTypeChecker<Self>; 790 from_value(value: &'a glib::Value) -> Self791 unsafe fn from_value(value: &'a glib::Value) -> Self { 792 skip_assert_initialized!(); 793 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 794 } 795 } 796 797 impl ToValue for ButtonBoxStyle { to_value(&self) -> glib::Value798 fn to_value(&self) -> glib::Value { 799 let mut value = glib::Value::for_value_type::<Self>(); 800 unsafe { 801 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 802 } 803 value 804 } 805 value_type(&self) -> glib::Type806 fn value_type(&self) -> glib::Type { 807 Self::static_type() 808 } 809 } 810 811 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 812 #[non_exhaustive] 813 #[doc(alias = "GtkButtonRole")] 814 pub enum ButtonRole { 815 #[doc(alias = "GTK_BUTTON_ROLE_NORMAL")] 816 Normal, 817 #[doc(alias = "GTK_BUTTON_ROLE_CHECK")] 818 Check, 819 #[doc(alias = "GTK_BUTTON_ROLE_RADIO")] 820 Radio, 821 #[doc(hidden)] 822 __Unknown(i32), 823 } 824 825 impl fmt::Display for ButtonRole { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result826 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 827 write!( 828 f, 829 "ButtonRole::{}", 830 match *self { 831 Self::Normal => "Normal", 832 Self::Check => "Check", 833 Self::Radio => "Radio", 834 _ => "Unknown", 835 } 836 ) 837 } 838 } 839 840 #[doc(hidden)] 841 impl IntoGlib for ButtonRole { 842 type GlibType = ffi::GtkButtonRole; 843 into_glib(self) -> ffi::GtkButtonRole844 fn into_glib(self) -> ffi::GtkButtonRole { 845 match self { 846 Self::Normal => ffi::GTK_BUTTON_ROLE_NORMAL, 847 Self::Check => ffi::GTK_BUTTON_ROLE_CHECK, 848 Self::Radio => ffi::GTK_BUTTON_ROLE_RADIO, 849 Self::__Unknown(value) => value, 850 } 851 } 852 } 853 854 #[doc(hidden)] 855 impl FromGlib<ffi::GtkButtonRole> for ButtonRole { from_glib(value: ffi::GtkButtonRole) -> Self856 unsafe fn from_glib(value: ffi::GtkButtonRole) -> Self { 857 skip_assert_initialized!(); 858 match value { 859 ffi::GTK_BUTTON_ROLE_NORMAL => Self::Normal, 860 ffi::GTK_BUTTON_ROLE_CHECK => Self::Check, 861 ffi::GTK_BUTTON_ROLE_RADIO => Self::Radio, 862 value => Self::__Unknown(value), 863 } 864 } 865 } 866 867 impl StaticType for ButtonRole { static_type() -> Type868 fn static_type() -> Type { 869 unsafe { from_glib(ffi::gtk_button_role_get_type()) } 870 } 871 } 872 873 impl glib::value::ValueType for ButtonRole { 874 type Type = Self; 875 } 876 877 unsafe impl<'a> FromValue<'a> for ButtonRole { 878 type Checker = glib::value::GenericValueTypeChecker<Self>; 879 from_value(value: &'a glib::Value) -> Self880 unsafe fn from_value(value: &'a glib::Value) -> Self { 881 skip_assert_initialized!(); 882 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 883 } 884 } 885 886 impl ToValue for ButtonRole { to_value(&self) -> glib::Value887 fn to_value(&self) -> glib::Value { 888 let mut value = glib::Value::for_value_type::<Self>(); 889 unsafe { 890 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 891 } 892 value 893 } 894 value_type(&self) -> glib::Type895 fn value_type(&self) -> glib::Type { 896 Self::static_type() 897 } 898 } 899 900 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 901 #[non_exhaustive] 902 #[doc(alias = "GtkButtonsType")] 903 pub enum ButtonsType { 904 #[doc(alias = "GTK_BUTTONS_NONE")] 905 None, 906 #[doc(alias = "GTK_BUTTONS_OK")] 907 Ok, 908 #[doc(alias = "GTK_BUTTONS_CLOSE")] 909 Close, 910 #[doc(alias = "GTK_BUTTONS_CANCEL")] 911 Cancel, 912 #[doc(alias = "GTK_BUTTONS_YES_NO")] 913 YesNo, 914 #[doc(alias = "GTK_BUTTONS_OK_CANCEL")] 915 OkCancel, 916 #[doc(hidden)] 917 __Unknown(i32), 918 } 919 920 impl fmt::Display for ButtonsType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result921 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 922 write!( 923 f, 924 "ButtonsType::{}", 925 match *self { 926 Self::None => "None", 927 Self::Ok => "Ok", 928 Self::Close => "Close", 929 Self::Cancel => "Cancel", 930 Self::YesNo => "YesNo", 931 Self::OkCancel => "OkCancel", 932 _ => "Unknown", 933 } 934 ) 935 } 936 } 937 938 #[doc(hidden)] 939 impl IntoGlib for ButtonsType { 940 type GlibType = ffi::GtkButtonsType; 941 into_glib(self) -> ffi::GtkButtonsType942 fn into_glib(self) -> ffi::GtkButtonsType { 943 match self { 944 Self::None => ffi::GTK_BUTTONS_NONE, 945 Self::Ok => ffi::GTK_BUTTONS_OK, 946 Self::Close => ffi::GTK_BUTTONS_CLOSE, 947 Self::Cancel => ffi::GTK_BUTTONS_CANCEL, 948 Self::YesNo => ffi::GTK_BUTTONS_YES_NO, 949 Self::OkCancel => ffi::GTK_BUTTONS_OK_CANCEL, 950 Self::__Unknown(value) => value, 951 } 952 } 953 } 954 955 #[doc(hidden)] 956 impl FromGlib<ffi::GtkButtonsType> for ButtonsType { from_glib(value: ffi::GtkButtonsType) -> Self957 unsafe fn from_glib(value: ffi::GtkButtonsType) -> Self { 958 skip_assert_initialized!(); 959 match value { 960 ffi::GTK_BUTTONS_NONE => Self::None, 961 ffi::GTK_BUTTONS_OK => Self::Ok, 962 ffi::GTK_BUTTONS_CLOSE => Self::Close, 963 ffi::GTK_BUTTONS_CANCEL => Self::Cancel, 964 ffi::GTK_BUTTONS_YES_NO => Self::YesNo, 965 ffi::GTK_BUTTONS_OK_CANCEL => Self::OkCancel, 966 value => Self::__Unknown(value), 967 } 968 } 969 } 970 971 impl StaticType for ButtonsType { static_type() -> Type972 fn static_type() -> Type { 973 unsafe { from_glib(ffi::gtk_buttons_type_get_type()) } 974 } 975 } 976 977 impl glib::value::ValueType for ButtonsType { 978 type Type = Self; 979 } 980 981 unsafe impl<'a> FromValue<'a> for ButtonsType { 982 type Checker = glib::value::GenericValueTypeChecker<Self>; 983 from_value(value: &'a glib::Value) -> Self984 unsafe fn from_value(value: &'a glib::Value) -> Self { 985 skip_assert_initialized!(); 986 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 987 } 988 } 989 990 impl ToValue for ButtonsType { to_value(&self) -> glib::Value991 fn to_value(&self) -> glib::Value { 992 let mut value = glib::Value::for_value_type::<Self>(); 993 unsafe { 994 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 995 } 996 value 997 } 998 value_type(&self) -> glib::Type999 fn value_type(&self) -> glib::Type { 1000 Self::static_type() 1001 } 1002 } 1003 1004 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1005 #[non_exhaustive] 1006 #[doc(alias = "GtkCellRendererAccelMode")] 1007 pub enum CellRendererAccelMode { 1008 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_GTK")] 1009 Gtk, 1010 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_OTHER")] 1011 Other, 1012 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_MODIFIER_TAP")] 1013 ModifierTap, 1014 #[doc(hidden)] 1015 __Unknown(i32), 1016 } 1017 1018 impl fmt::Display for CellRendererAccelMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1019 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1020 write!( 1021 f, 1022 "CellRendererAccelMode::{}", 1023 match *self { 1024 Self::Gtk => "Gtk", 1025 Self::Other => "Other", 1026 Self::ModifierTap => "ModifierTap", 1027 _ => "Unknown", 1028 } 1029 ) 1030 } 1031 } 1032 1033 #[doc(hidden)] 1034 impl IntoGlib for CellRendererAccelMode { 1035 type GlibType = ffi::GtkCellRendererAccelMode; 1036 into_glib(self) -> ffi::GtkCellRendererAccelMode1037 fn into_glib(self) -> ffi::GtkCellRendererAccelMode { 1038 match self { 1039 Self::Gtk => ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK, 1040 Self::Other => ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER, 1041 Self::ModifierTap => ffi::GTK_CELL_RENDERER_ACCEL_MODE_MODIFIER_TAP, 1042 Self::__Unknown(value) => value, 1043 } 1044 } 1045 } 1046 1047 #[doc(hidden)] 1048 impl FromGlib<ffi::GtkCellRendererAccelMode> for CellRendererAccelMode { from_glib(value: ffi::GtkCellRendererAccelMode) -> Self1049 unsafe fn from_glib(value: ffi::GtkCellRendererAccelMode) -> Self { 1050 skip_assert_initialized!(); 1051 match value { 1052 ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK => Self::Gtk, 1053 ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER => Self::Other, 1054 ffi::GTK_CELL_RENDERER_ACCEL_MODE_MODIFIER_TAP => Self::ModifierTap, 1055 value => Self::__Unknown(value), 1056 } 1057 } 1058 } 1059 1060 impl StaticType for CellRendererAccelMode { static_type() -> Type1061 fn static_type() -> Type { 1062 unsafe { from_glib(ffi::gtk_cell_renderer_accel_mode_get_type()) } 1063 } 1064 } 1065 1066 impl glib::value::ValueType for CellRendererAccelMode { 1067 type Type = Self; 1068 } 1069 1070 unsafe impl<'a> FromValue<'a> for CellRendererAccelMode { 1071 type Checker = glib::value::GenericValueTypeChecker<Self>; 1072 from_value(value: &'a glib::Value) -> Self1073 unsafe fn from_value(value: &'a glib::Value) -> Self { 1074 skip_assert_initialized!(); 1075 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1076 } 1077 } 1078 1079 impl ToValue for CellRendererAccelMode { to_value(&self) -> glib::Value1080 fn to_value(&self) -> glib::Value { 1081 let mut value = glib::Value::for_value_type::<Self>(); 1082 unsafe { 1083 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1084 } 1085 value 1086 } 1087 value_type(&self) -> glib::Type1088 fn value_type(&self) -> glib::Type { 1089 Self::static_type() 1090 } 1091 } 1092 1093 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1094 #[non_exhaustive] 1095 #[doc(alias = "GtkCellRendererMode")] 1096 pub enum CellRendererMode { 1097 #[doc(alias = "GTK_CELL_RENDERER_MODE_INERT")] 1098 Inert, 1099 #[doc(alias = "GTK_CELL_RENDERER_MODE_ACTIVATABLE")] 1100 Activatable, 1101 #[doc(alias = "GTK_CELL_RENDERER_MODE_EDITABLE")] 1102 Editable, 1103 #[doc(hidden)] 1104 __Unknown(i32), 1105 } 1106 1107 impl fmt::Display for CellRendererMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1108 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1109 write!( 1110 f, 1111 "CellRendererMode::{}", 1112 match *self { 1113 Self::Inert => "Inert", 1114 Self::Activatable => "Activatable", 1115 Self::Editable => "Editable", 1116 _ => "Unknown", 1117 } 1118 ) 1119 } 1120 } 1121 1122 #[doc(hidden)] 1123 impl IntoGlib for CellRendererMode { 1124 type GlibType = ffi::GtkCellRendererMode; 1125 into_glib(self) -> ffi::GtkCellRendererMode1126 fn into_glib(self) -> ffi::GtkCellRendererMode { 1127 match self { 1128 Self::Inert => ffi::GTK_CELL_RENDERER_MODE_INERT, 1129 Self::Activatable => ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE, 1130 Self::Editable => ffi::GTK_CELL_RENDERER_MODE_EDITABLE, 1131 Self::__Unknown(value) => value, 1132 } 1133 } 1134 } 1135 1136 #[doc(hidden)] 1137 impl FromGlib<ffi::GtkCellRendererMode> for CellRendererMode { from_glib(value: ffi::GtkCellRendererMode) -> Self1138 unsafe fn from_glib(value: ffi::GtkCellRendererMode) -> Self { 1139 skip_assert_initialized!(); 1140 match value { 1141 ffi::GTK_CELL_RENDERER_MODE_INERT => Self::Inert, 1142 ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE => Self::Activatable, 1143 ffi::GTK_CELL_RENDERER_MODE_EDITABLE => Self::Editable, 1144 value => Self::__Unknown(value), 1145 } 1146 } 1147 } 1148 1149 impl StaticType for CellRendererMode { static_type() -> Type1150 fn static_type() -> Type { 1151 unsafe { from_glib(ffi::gtk_cell_renderer_mode_get_type()) } 1152 } 1153 } 1154 1155 impl glib::value::ValueType for CellRendererMode { 1156 type Type = Self; 1157 } 1158 1159 unsafe impl<'a> FromValue<'a> for CellRendererMode { 1160 type Checker = glib::value::GenericValueTypeChecker<Self>; 1161 from_value(value: &'a glib::Value) -> Self1162 unsafe fn from_value(value: &'a glib::Value) -> Self { 1163 skip_assert_initialized!(); 1164 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1165 } 1166 } 1167 1168 impl ToValue for CellRendererMode { to_value(&self) -> glib::Value1169 fn to_value(&self) -> glib::Value { 1170 let mut value = glib::Value::for_value_type::<Self>(); 1171 unsafe { 1172 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1173 } 1174 value 1175 } 1176 value_type(&self) -> glib::Type1177 fn value_type(&self) -> glib::Type { 1178 Self::static_type() 1179 } 1180 } 1181 1182 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1183 #[non_exhaustive] 1184 #[doc(alias = "GtkCornerType")] 1185 pub enum CornerType { 1186 #[doc(alias = "GTK_CORNER_TOP_LEFT")] 1187 TopLeft, 1188 #[doc(alias = "GTK_CORNER_BOTTOM_LEFT")] 1189 BottomLeft, 1190 #[doc(alias = "GTK_CORNER_TOP_RIGHT")] 1191 TopRight, 1192 #[doc(alias = "GTK_CORNER_BOTTOM_RIGHT")] 1193 BottomRight, 1194 #[doc(hidden)] 1195 __Unknown(i32), 1196 } 1197 1198 impl fmt::Display for CornerType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1199 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1200 write!( 1201 f, 1202 "CornerType::{}", 1203 match *self { 1204 Self::TopLeft => "TopLeft", 1205 Self::BottomLeft => "BottomLeft", 1206 Self::TopRight => "TopRight", 1207 Self::BottomRight => "BottomRight", 1208 _ => "Unknown", 1209 } 1210 ) 1211 } 1212 } 1213 1214 #[doc(hidden)] 1215 impl IntoGlib for CornerType { 1216 type GlibType = ffi::GtkCornerType; 1217 into_glib(self) -> ffi::GtkCornerType1218 fn into_glib(self) -> ffi::GtkCornerType { 1219 match self { 1220 Self::TopLeft => ffi::GTK_CORNER_TOP_LEFT, 1221 Self::BottomLeft => ffi::GTK_CORNER_BOTTOM_LEFT, 1222 Self::TopRight => ffi::GTK_CORNER_TOP_RIGHT, 1223 Self::BottomRight => ffi::GTK_CORNER_BOTTOM_RIGHT, 1224 Self::__Unknown(value) => value, 1225 } 1226 } 1227 } 1228 1229 #[doc(hidden)] 1230 impl FromGlib<ffi::GtkCornerType> for CornerType { from_glib(value: ffi::GtkCornerType) -> Self1231 unsafe fn from_glib(value: ffi::GtkCornerType) -> Self { 1232 skip_assert_initialized!(); 1233 match value { 1234 ffi::GTK_CORNER_TOP_LEFT => Self::TopLeft, 1235 ffi::GTK_CORNER_BOTTOM_LEFT => Self::BottomLeft, 1236 ffi::GTK_CORNER_TOP_RIGHT => Self::TopRight, 1237 ffi::GTK_CORNER_BOTTOM_RIGHT => Self::BottomRight, 1238 value => Self::__Unknown(value), 1239 } 1240 } 1241 } 1242 1243 impl StaticType for CornerType { static_type() -> Type1244 fn static_type() -> Type { 1245 unsafe { from_glib(ffi::gtk_corner_type_get_type()) } 1246 } 1247 } 1248 1249 impl glib::value::ValueType for CornerType { 1250 type Type = Self; 1251 } 1252 1253 unsafe impl<'a> FromValue<'a> for CornerType { 1254 type Checker = glib::value::GenericValueTypeChecker<Self>; 1255 from_value(value: &'a glib::Value) -> Self1256 unsafe fn from_value(value: &'a glib::Value) -> Self { 1257 skip_assert_initialized!(); 1258 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1259 } 1260 } 1261 1262 impl ToValue for CornerType { to_value(&self) -> glib::Value1263 fn to_value(&self) -> glib::Value { 1264 let mut value = glib::Value::for_value_type::<Self>(); 1265 unsafe { 1266 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1267 } 1268 value 1269 } 1270 value_type(&self) -> glib::Type1271 fn value_type(&self) -> glib::Type { 1272 Self::static_type() 1273 } 1274 } 1275 1276 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1277 #[non_exhaustive] 1278 #[doc(alias = "GtkCssProviderError")] 1279 pub enum CssProviderError { 1280 #[doc(alias = "GTK_CSS_PROVIDER_ERROR_FAILED")] 1281 Failed, 1282 #[doc(alias = "GTK_CSS_PROVIDER_ERROR_SYNTAX")] 1283 Syntax, 1284 #[doc(alias = "GTK_CSS_PROVIDER_ERROR_IMPORT")] 1285 Import, 1286 #[doc(alias = "GTK_CSS_PROVIDER_ERROR_NAME")] 1287 Name, 1288 #[doc(alias = "GTK_CSS_PROVIDER_ERROR_DEPRECATED")] 1289 Deprecated, 1290 #[doc(alias = "GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE")] 1291 UnknownValue, 1292 #[doc(hidden)] 1293 __Unknown(i32), 1294 } 1295 1296 impl fmt::Display for CssProviderError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1297 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1298 write!( 1299 f, 1300 "CssProviderError::{}", 1301 match *self { 1302 Self::Failed => "Failed", 1303 Self::Syntax => "Syntax", 1304 Self::Import => "Import", 1305 Self::Name => "Name", 1306 Self::Deprecated => "Deprecated", 1307 Self::UnknownValue => "UnknownValue", 1308 _ => "Unknown", 1309 } 1310 ) 1311 } 1312 } 1313 1314 #[doc(hidden)] 1315 impl IntoGlib for CssProviderError { 1316 type GlibType = ffi::GtkCssProviderError; 1317 into_glib(self) -> ffi::GtkCssProviderError1318 fn into_glib(self) -> ffi::GtkCssProviderError { 1319 match self { 1320 Self::Failed => ffi::GTK_CSS_PROVIDER_ERROR_FAILED, 1321 Self::Syntax => ffi::GTK_CSS_PROVIDER_ERROR_SYNTAX, 1322 Self::Import => ffi::GTK_CSS_PROVIDER_ERROR_IMPORT, 1323 Self::Name => ffi::GTK_CSS_PROVIDER_ERROR_NAME, 1324 Self::Deprecated => ffi::GTK_CSS_PROVIDER_ERROR_DEPRECATED, 1325 Self::UnknownValue => ffi::GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE, 1326 Self::__Unknown(value) => value, 1327 } 1328 } 1329 } 1330 1331 #[doc(hidden)] 1332 impl FromGlib<ffi::GtkCssProviderError> for CssProviderError { from_glib(value: ffi::GtkCssProviderError) -> Self1333 unsafe fn from_glib(value: ffi::GtkCssProviderError) -> Self { 1334 skip_assert_initialized!(); 1335 match value { 1336 ffi::GTK_CSS_PROVIDER_ERROR_FAILED => Self::Failed, 1337 ffi::GTK_CSS_PROVIDER_ERROR_SYNTAX => Self::Syntax, 1338 ffi::GTK_CSS_PROVIDER_ERROR_IMPORT => Self::Import, 1339 ffi::GTK_CSS_PROVIDER_ERROR_NAME => Self::Name, 1340 ffi::GTK_CSS_PROVIDER_ERROR_DEPRECATED => Self::Deprecated, 1341 ffi::GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE => Self::UnknownValue, 1342 value => Self::__Unknown(value), 1343 } 1344 } 1345 } 1346 1347 impl ErrorDomain for CssProviderError { domain() -> Quark1348 fn domain() -> Quark { 1349 skip_assert_initialized!(); 1350 1351 unsafe { from_glib(ffi::gtk_css_provider_error_quark()) } 1352 } 1353 code(self) -> i321354 fn code(self) -> i32 { 1355 self.into_glib() 1356 } 1357 from(code: i32) -> Option<Self>1358 fn from(code: i32) -> Option<Self> { 1359 skip_assert_initialized!(); 1360 match code { 1361 ffi::GTK_CSS_PROVIDER_ERROR_FAILED => Some(Self::Failed), 1362 ffi::GTK_CSS_PROVIDER_ERROR_SYNTAX => Some(Self::Syntax), 1363 ffi::GTK_CSS_PROVIDER_ERROR_IMPORT => Some(Self::Import), 1364 ffi::GTK_CSS_PROVIDER_ERROR_NAME => Some(Self::Name), 1365 ffi::GTK_CSS_PROVIDER_ERROR_DEPRECATED => Some(Self::Deprecated), 1366 ffi::GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE => Some(Self::UnknownValue), 1367 _ => Some(Self::Failed), 1368 } 1369 } 1370 } 1371 1372 impl StaticType for CssProviderError { static_type() -> Type1373 fn static_type() -> Type { 1374 unsafe { from_glib(ffi::gtk_css_provider_error_get_type()) } 1375 } 1376 } 1377 1378 impl glib::value::ValueType for CssProviderError { 1379 type Type = Self; 1380 } 1381 1382 unsafe impl<'a> FromValue<'a> for CssProviderError { 1383 type Checker = glib::value::GenericValueTypeChecker<Self>; 1384 from_value(value: &'a glib::Value) -> Self1385 unsafe fn from_value(value: &'a glib::Value) -> Self { 1386 skip_assert_initialized!(); 1387 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1388 } 1389 } 1390 1391 impl ToValue for CssProviderError { to_value(&self) -> glib::Value1392 fn to_value(&self) -> glib::Value { 1393 let mut value = glib::Value::for_value_type::<Self>(); 1394 unsafe { 1395 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1396 } 1397 value 1398 } 1399 value_type(&self) -> glib::Type1400 fn value_type(&self) -> glib::Type { 1401 Self::static_type() 1402 } 1403 } 1404 1405 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1406 #[non_exhaustive] 1407 #[doc(alias = "GtkCssSectionType")] 1408 pub enum CssSectionType { 1409 #[doc(alias = "GTK_CSS_SECTION_DOCUMENT")] 1410 Document, 1411 #[doc(alias = "GTK_CSS_SECTION_IMPORT")] 1412 Import, 1413 #[doc(alias = "GTK_CSS_SECTION_COLOR_DEFINITION")] 1414 ColorDefinition, 1415 #[doc(alias = "GTK_CSS_SECTION_BINDING_SET")] 1416 BindingSet, 1417 #[doc(alias = "GTK_CSS_SECTION_RULESET")] 1418 Ruleset, 1419 #[doc(alias = "GTK_CSS_SECTION_SELECTOR")] 1420 Selector, 1421 #[doc(alias = "GTK_CSS_SECTION_DECLARATION")] 1422 Declaration, 1423 #[doc(alias = "GTK_CSS_SECTION_VALUE")] 1424 Value, 1425 #[doc(alias = "GTK_CSS_SECTION_KEYFRAMES")] 1426 Keyframes, 1427 #[doc(hidden)] 1428 __Unknown(i32), 1429 } 1430 1431 impl fmt::Display for CssSectionType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1432 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1433 write!( 1434 f, 1435 "CssSectionType::{}", 1436 match *self { 1437 Self::Document => "Document", 1438 Self::Import => "Import", 1439 Self::ColorDefinition => "ColorDefinition", 1440 Self::BindingSet => "BindingSet", 1441 Self::Ruleset => "Ruleset", 1442 Self::Selector => "Selector", 1443 Self::Declaration => "Declaration", 1444 Self::Value => "Value", 1445 Self::Keyframes => "Keyframes", 1446 _ => "Unknown", 1447 } 1448 ) 1449 } 1450 } 1451 1452 #[doc(hidden)] 1453 impl IntoGlib for CssSectionType { 1454 type GlibType = ffi::GtkCssSectionType; 1455 into_glib(self) -> ffi::GtkCssSectionType1456 fn into_glib(self) -> ffi::GtkCssSectionType { 1457 match self { 1458 Self::Document => ffi::GTK_CSS_SECTION_DOCUMENT, 1459 Self::Import => ffi::GTK_CSS_SECTION_IMPORT, 1460 Self::ColorDefinition => ffi::GTK_CSS_SECTION_COLOR_DEFINITION, 1461 Self::BindingSet => ffi::GTK_CSS_SECTION_BINDING_SET, 1462 Self::Ruleset => ffi::GTK_CSS_SECTION_RULESET, 1463 Self::Selector => ffi::GTK_CSS_SECTION_SELECTOR, 1464 Self::Declaration => ffi::GTK_CSS_SECTION_DECLARATION, 1465 Self::Value => ffi::GTK_CSS_SECTION_VALUE, 1466 Self::Keyframes => ffi::GTK_CSS_SECTION_KEYFRAMES, 1467 Self::__Unknown(value) => value, 1468 } 1469 } 1470 } 1471 1472 #[doc(hidden)] 1473 impl FromGlib<ffi::GtkCssSectionType> for CssSectionType { from_glib(value: ffi::GtkCssSectionType) -> Self1474 unsafe fn from_glib(value: ffi::GtkCssSectionType) -> Self { 1475 skip_assert_initialized!(); 1476 match value { 1477 ffi::GTK_CSS_SECTION_DOCUMENT => Self::Document, 1478 ffi::GTK_CSS_SECTION_IMPORT => Self::Import, 1479 ffi::GTK_CSS_SECTION_COLOR_DEFINITION => Self::ColorDefinition, 1480 ffi::GTK_CSS_SECTION_BINDING_SET => Self::BindingSet, 1481 ffi::GTK_CSS_SECTION_RULESET => Self::Ruleset, 1482 ffi::GTK_CSS_SECTION_SELECTOR => Self::Selector, 1483 ffi::GTK_CSS_SECTION_DECLARATION => Self::Declaration, 1484 ffi::GTK_CSS_SECTION_VALUE => Self::Value, 1485 ffi::GTK_CSS_SECTION_KEYFRAMES => Self::Keyframes, 1486 value => Self::__Unknown(value), 1487 } 1488 } 1489 } 1490 1491 impl StaticType for CssSectionType { static_type() -> Type1492 fn static_type() -> Type { 1493 unsafe { from_glib(ffi::gtk_css_section_type_get_type()) } 1494 } 1495 } 1496 1497 impl glib::value::ValueType for CssSectionType { 1498 type Type = Self; 1499 } 1500 1501 unsafe impl<'a> FromValue<'a> for CssSectionType { 1502 type Checker = glib::value::GenericValueTypeChecker<Self>; 1503 from_value(value: &'a glib::Value) -> Self1504 unsafe fn from_value(value: &'a glib::Value) -> Self { 1505 skip_assert_initialized!(); 1506 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1507 } 1508 } 1509 1510 impl ToValue for CssSectionType { to_value(&self) -> glib::Value1511 fn to_value(&self) -> glib::Value { 1512 let mut value = glib::Value::for_value_type::<Self>(); 1513 unsafe { 1514 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1515 } 1516 value 1517 } 1518 value_type(&self) -> glib::Type1519 fn value_type(&self) -> glib::Type { 1520 Self::static_type() 1521 } 1522 } 1523 1524 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1525 #[non_exhaustive] 1526 #[doc(alias = "GtkDeleteType")] 1527 pub enum DeleteType { 1528 #[doc(alias = "GTK_DELETE_CHARS")] 1529 Chars, 1530 #[doc(alias = "GTK_DELETE_WORD_ENDS")] 1531 WordEnds, 1532 #[doc(alias = "GTK_DELETE_WORDS")] 1533 Words, 1534 #[doc(alias = "GTK_DELETE_DISPLAY_LINES")] 1535 DisplayLines, 1536 #[doc(alias = "GTK_DELETE_DISPLAY_LINE_ENDS")] 1537 DisplayLineEnds, 1538 #[doc(alias = "GTK_DELETE_PARAGRAPH_ENDS")] 1539 ParagraphEnds, 1540 #[doc(alias = "GTK_DELETE_PARAGRAPHS")] 1541 Paragraphs, 1542 #[doc(alias = "GTK_DELETE_WHITESPACE")] 1543 Whitespace, 1544 #[doc(hidden)] 1545 __Unknown(i32), 1546 } 1547 1548 impl fmt::Display for DeleteType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1549 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1550 write!( 1551 f, 1552 "DeleteType::{}", 1553 match *self { 1554 Self::Chars => "Chars", 1555 Self::WordEnds => "WordEnds", 1556 Self::Words => "Words", 1557 Self::DisplayLines => "DisplayLines", 1558 Self::DisplayLineEnds => "DisplayLineEnds", 1559 Self::ParagraphEnds => "ParagraphEnds", 1560 Self::Paragraphs => "Paragraphs", 1561 Self::Whitespace => "Whitespace", 1562 _ => "Unknown", 1563 } 1564 ) 1565 } 1566 } 1567 1568 #[doc(hidden)] 1569 impl IntoGlib for DeleteType { 1570 type GlibType = ffi::GtkDeleteType; 1571 into_glib(self) -> ffi::GtkDeleteType1572 fn into_glib(self) -> ffi::GtkDeleteType { 1573 match self { 1574 Self::Chars => ffi::GTK_DELETE_CHARS, 1575 Self::WordEnds => ffi::GTK_DELETE_WORD_ENDS, 1576 Self::Words => ffi::GTK_DELETE_WORDS, 1577 Self::DisplayLines => ffi::GTK_DELETE_DISPLAY_LINES, 1578 Self::DisplayLineEnds => ffi::GTK_DELETE_DISPLAY_LINE_ENDS, 1579 Self::ParagraphEnds => ffi::GTK_DELETE_PARAGRAPH_ENDS, 1580 Self::Paragraphs => ffi::GTK_DELETE_PARAGRAPHS, 1581 Self::Whitespace => ffi::GTK_DELETE_WHITESPACE, 1582 Self::__Unknown(value) => value, 1583 } 1584 } 1585 } 1586 1587 #[doc(hidden)] 1588 impl FromGlib<ffi::GtkDeleteType> for DeleteType { from_glib(value: ffi::GtkDeleteType) -> Self1589 unsafe fn from_glib(value: ffi::GtkDeleteType) -> Self { 1590 skip_assert_initialized!(); 1591 match value { 1592 ffi::GTK_DELETE_CHARS => Self::Chars, 1593 ffi::GTK_DELETE_WORD_ENDS => Self::WordEnds, 1594 ffi::GTK_DELETE_WORDS => Self::Words, 1595 ffi::GTK_DELETE_DISPLAY_LINES => Self::DisplayLines, 1596 ffi::GTK_DELETE_DISPLAY_LINE_ENDS => Self::DisplayLineEnds, 1597 ffi::GTK_DELETE_PARAGRAPH_ENDS => Self::ParagraphEnds, 1598 ffi::GTK_DELETE_PARAGRAPHS => Self::Paragraphs, 1599 ffi::GTK_DELETE_WHITESPACE => Self::Whitespace, 1600 value => Self::__Unknown(value), 1601 } 1602 } 1603 } 1604 1605 impl StaticType for DeleteType { static_type() -> Type1606 fn static_type() -> Type { 1607 unsafe { from_glib(ffi::gtk_delete_type_get_type()) } 1608 } 1609 } 1610 1611 impl glib::value::ValueType for DeleteType { 1612 type Type = Self; 1613 } 1614 1615 unsafe impl<'a> FromValue<'a> for DeleteType { 1616 type Checker = glib::value::GenericValueTypeChecker<Self>; 1617 from_value(value: &'a glib::Value) -> Self1618 unsafe fn from_value(value: &'a glib::Value) -> Self { 1619 skip_assert_initialized!(); 1620 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1621 } 1622 } 1623 1624 impl ToValue for DeleteType { to_value(&self) -> glib::Value1625 fn to_value(&self) -> glib::Value { 1626 let mut value = glib::Value::for_value_type::<Self>(); 1627 unsafe { 1628 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1629 } 1630 value 1631 } 1632 value_type(&self) -> glib::Type1633 fn value_type(&self) -> glib::Type { 1634 Self::static_type() 1635 } 1636 } 1637 1638 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1639 #[non_exhaustive] 1640 #[doc(alias = "GtkDirectionType")] 1641 pub enum DirectionType { 1642 #[doc(alias = "GTK_DIR_TAB_FORWARD")] 1643 TabForward, 1644 #[doc(alias = "GTK_DIR_TAB_BACKWARD")] 1645 TabBackward, 1646 #[doc(alias = "GTK_DIR_UP")] 1647 Up, 1648 #[doc(alias = "GTK_DIR_DOWN")] 1649 Down, 1650 #[doc(alias = "GTK_DIR_LEFT")] 1651 Left, 1652 #[doc(alias = "GTK_DIR_RIGHT")] 1653 Right, 1654 #[doc(hidden)] 1655 __Unknown(i32), 1656 } 1657 1658 impl fmt::Display for DirectionType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1659 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1660 write!( 1661 f, 1662 "DirectionType::{}", 1663 match *self { 1664 Self::TabForward => "TabForward", 1665 Self::TabBackward => "TabBackward", 1666 Self::Up => "Up", 1667 Self::Down => "Down", 1668 Self::Left => "Left", 1669 Self::Right => "Right", 1670 _ => "Unknown", 1671 } 1672 ) 1673 } 1674 } 1675 1676 #[doc(hidden)] 1677 impl IntoGlib for DirectionType { 1678 type GlibType = ffi::GtkDirectionType; 1679 into_glib(self) -> ffi::GtkDirectionType1680 fn into_glib(self) -> ffi::GtkDirectionType { 1681 match self { 1682 Self::TabForward => ffi::GTK_DIR_TAB_FORWARD, 1683 Self::TabBackward => ffi::GTK_DIR_TAB_BACKWARD, 1684 Self::Up => ffi::GTK_DIR_UP, 1685 Self::Down => ffi::GTK_DIR_DOWN, 1686 Self::Left => ffi::GTK_DIR_LEFT, 1687 Self::Right => ffi::GTK_DIR_RIGHT, 1688 Self::__Unknown(value) => value, 1689 } 1690 } 1691 } 1692 1693 #[doc(hidden)] 1694 impl FromGlib<ffi::GtkDirectionType> for DirectionType { from_glib(value: ffi::GtkDirectionType) -> Self1695 unsafe fn from_glib(value: ffi::GtkDirectionType) -> Self { 1696 skip_assert_initialized!(); 1697 match value { 1698 ffi::GTK_DIR_TAB_FORWARD => Self::TabForward, 1699 ffi::GTK_DIR_TAB_BACKWARD => Self::TabBackward, 1700 ffi::GTK_DIR_UP => Self::Up, 1701 ffi::GTK_DIR_DOWN => Self::Down, 1702 ffi::GTK_DIR_LEFT => Self::Left, 1703 ffi::GTK_DIR_RIGHT => Self::Right, 1704 value => Self::__Unknown(value), 1705 } 1706 } 1707 } 1708 1709 impl StaticType for DirectionType { static_type() -> Type1710 fn static_type() -> Type { 1711 unsafe { from_glib(ffi::gtk_direction_type_get_type()) } 1712 } 1713 } 1714 1715 impl glib::value::ValueType for DirectionType { 1716 type Type = Self; 1717 } 1718 1719 unsafe impl<'a> FromValue<'a> for DirectionType { 1720 type Checker = glib::value::GenericValueTypeChecker<Self>; 1721 from_value(value: &'a glib::Value) -> Self1722 unsafe fn from_value(value: &'a glib::Value) -> Self { 1723 skip_assert_initialized!(); 1724 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1725 } 1726 } 1727 1728 impl ToValue for DirectionType { to_value(&self) -> glib::Value1729 fn to_value(&self) -> glib::Value { 1730 let mut value = glib::Value::for_value_type::<Self>(); 1731 unsafe { 1732 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1733 } 1734 value 1735 } 1736 value_type(&self) -> glib::Type1737 fn value_type(&self) -> glib::Type { 1738 Self::static_type() 1739 } 1740 } 1741 1742 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1743 #[non_exhaustive] 1744 #[doc(alias = "GtkDragResult")] 1745 pub enum DragResult { 1746 #[doc(alias = "GTK_DRAG_RESULT_SUCCESS")] 1747 Success, 1748 #[doc(alias = "GTK_DRAG_RESULT_NO_TARGET")] 1749 NoTarget, 1750 #[doc(alias = "GTK_DRAG_RESULT_USER_CANCELLED")] 1751 UserCancelled, 1752 #[doc(alias = "GTK_DRAG_RESULT_TIMEOUT_EXPIRED")] 1753 TimeoutExpired, 1754 #[doc(alias = "GTK_DRAG_RESULT_GRAB_BROKEN")] 1755 GrabBroken, 1756 #[doc(alias = "GTK_DRAG_RESULT_ERROR")] 1757 Error, 1758 #[doc(hidden)] 1759 __Unknown(i32), 1760 } 1761 1762 impl fmt::Display for DragResult { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1763 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1764 write!( 1765 f, 1766 "DragResult::{}", 1767 match *self { 1768 Self::Success => "Success", 1769 Self::NoTarget => "NoTarget", 1770 Self::UserCancelled => "UserCancelled", 1771 Self::TimeoutExpired => "TimeoutExpired", 1772 Self::GrabBroken => "GrabBroken", 1773 Self::Error => "Error", 1774 _ => "Unknown", 1775 } 1776 ) 1777 } 1778 } 1779 1780 #[doc(hidden)] 1781 impl IntoGlib for DragResult { 1782 type GlibType = ffi::GtkDragResult; 1783 into_glib(self) -> ffi::GtkDragResult1784 fn into_glib(self) -> ffi::GtkDragResult { 1785 match self { 1786 Self::Success => ffi::GTK_DRAG_RESULT_SUCCESS, 1787 Self::NoTarget => ffi::GTK_DRAG_RESULT_NO_TARGET, 1788 Self::UserCancelled => ffi::GTK_DRAG_RESULT_USER_CANCELLED, 1789 Self::TimeoutExpired => ffi::GTK_DRAG_RESULT_TIMEOUT_EXPIRED, 1790 Self::GrabBroken => ffi::GTK_DRAG_RESULT_GRAB_BROKEN, 1791 Self::Error => ffi::GTK_DRAG_RESULT_ERROR, 1792 Self::__Unknown(value) => value, 1793 } 1794 } 1795 } 1796 1797 #[doc(hidden)] 1798 impl FromGlib<ffi::GtkDragResult> for DragResult { from_glib(value: ffi::GtkDragResult) -> Self1799 unsafe fn from_glib(value: ffi::GtkDragResult) -> Self { 1800 skip_assert_initialized!(); 1801 match value { 1802 ffi::GTK_DRAG_RESULT_SUCCESS => Self::Success, 1803 ffi::GTK_DRAG_RESULT_NO_TARGET => Self::NoTarget, 1804 ffi::GTK_DRAG_RESULT_USER_CANCELLED => Self::UserCancelled, 1805 ffi::GTK_DRAG_RESULT_TIMEOUT_EXPIRED => Self::TimeoutExpired, 1806 ffi::GTK_DRAG_RESULT_GRAB_BROKEN => Self::GrabBroken, 1807 ffi::GTK_DRAG_RESULT_ERROR => Self::Error, 1808 value => Self::__Unknown(value), 1809 } 1810 } 1811 } 1812 1813 impl StaticType for DragResult { static_type() -> Type1814 fn static_type() -> Type { 1815 unsafe { from_glib(ffi::gtk_drag_result_get_type()) } 1816 } 1817 } 1818 1819 impl glib::value::ValueType for DragResult { 1820 type Type = Self; 1821 } 1822 1823 unsafe impl<'a> FromValue<'a> for DragResult { 1824 type Checker = glib::value::GenericValueTypeChecker<Self>; 1825 from_value(value: &'a glib::Value) -> Self1826 unsafe fn from_value(value: &'a glib::Value) -> Self { 1827 skip_assert_initialized!(); 1828 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1829 } 1830 } 1831 1832 impl ToValue for DragResult { to_value(&self) -> glib::Value1833 fn to_value(&self) -> glib::Value { 1834 let mut value = glib::Value::for_value_type::<Self>(); 1835 unsafe { 1836 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1837 } 1838 value 1839 } 1840 value_type(&self) -> glib::Type1841 fn value_type(&self) -> glib::Type { 1842 Self::static_type() 1843 } 1844 } 1845 1846 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1847 #[non_exhaustive] 1848 #[doc(alias = "GtkEntryIconPosition")] 1849 pub enum EntryIconPosition { 1850 #[doc(alias = "GTK_ENTRY_ICON_PRIMARY")] 1851 Primary, 1852 #[doc(alias = "GTK_ENTRY_ICON_SECONDARY")] 1853 Secondary, 1854 #[doc(hidden)] 1855 __Unknown(i32), 1856 } 1857 1858 impl fmt::Display for EntryIconPosition { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1859 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1860 write!( 1861 f, 1862 "EntryIconPosition::{}", 1863 match *self { 1864 Self::Primary => "Primary", 1865 Self::Secondary => "Secondary", 1866 _ => "Unknown", 1867 } 1868 ) 1869 } 1870 } 1871 1872 #[doc(hidden)] 1873 impl IntoGlib for EntryIconPosition { 1874 type GlibType = ffi::GtkEntryIconPosition; 1875 into_glib(self) -> ffi::GtkEntryIconPosition1876 fn into_glib(self) -> ffi::GtkEntryIconPosition { 1877 match self { 1878 Self::Primary => ffi::GTK_ENTRY_ICON_PRIMARY, 1879 Self::Secondary => ffi::GTK_ENTRY_ICON_SECONDARY, 1880 Self::__Unknown(value) => value, 1881 } 1882 } 1883 } 1884 1885 #[doc(hidden)] 1886 impl FromGlib<ffi::GtkEntryIconPosition> for EntryIconPosition { from_glib(value: ffi::GtkEntryIconPosition) -> Self1887 unsafe fn from_glib(value: ffi::GtkEntryIconPosition) -> Self { 1888 skip_assert_initialized!(); 1889 match value { 1890 ffi::GTK_ENTRY_ICON_PRIMARY => Self::Primary, 1891 ffi::GTK_ENTRY_ICON_SECONDARY => Self::Secondary, 1892 value => Self::__Unknown(value), 1893 } 1894 } 1895 } 1896 1897 impl StaticType for EntryIconPosition { static_type() -> Type1898 fn static_type() -> Type { 1899 unsafe { from_glib(ffi::gtk_entry_icon_position_get_type()) } 1900 } 1901 } 1902 1903 impl glib::value::ValueType for EntryIconPosition { 1904 type Type = Self; 1905 } 1906 1907 unsafe impl<'a> FromValue<'a> for EntryIconPosition { 1908 type Checker = glib::value::GenericValueTypeChecker<Self>; 1909 from_value(value: &'a glib::Value) -> Self1910 unsafe fn from_value(value: &'a glib::Value) -> Self { 1911 skip_assert_initialized!(); 1912 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1913 } 1914 } 1915 1916 impl ToValue for EntryIconPosition { to_value(&self) -> glib::Value1917 fn to_value(&self) -> glib::Value { 1918 let mut value = glib::Value::for_value_type::<Self>(); 1919 unsafe { 1920 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1921 } 1922 value 1923 } 1924 value_type(&self) -> glib::Type1925 fn value_type(&self) -> glib::Type { 1926 Self::static_type() 1927 } 1928 } 1929 1930 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1931 #[non_exhaustive] 1932 #[doc(alias = "GtkEventSequenceState")] 1933 pub enum EventSequenceState { 1934 #[doc(alias = "GTK_EVENT_SEQUENCE_NONE")] 1935 None, 1936 #[doc(alias = "GTK_EVENT_SEQUENCE_CLAIMED")] 1937 Claimed, 1938 #[doc(alias = "GTK_EVENT_SEQUENCE_DENIED")] 1939 Denied, 1940 #[doc(hidden)] 1941 __Unknown(i32), 1942 } 1943 1944 impl fmt::Display for EventSequenceState { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1945 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1946 write!( 1947 f, 1948 "EventSequenceState::{}", 1949 match *self { 1950 Self::None => "None", 1951 Self::Claimed => "Claimed", 1952 Self::Denied => "Denied", 1953 _ => "Unknown", 1954 } 1955 ) 1956 } 1957 } 1958 1959 #[doc(hidden)] 1960 impl IntoGlib for EventSequenceState { 1961 type GlibType = ffi::GtkEventSequenceState; 1962 into_glib(self) -> ffi::GtkEventSequenceState1963 fn into_glib(self) -> ffi::GtkEventSequenceState { 1964 match self { 1965 Self::None => ffi::GTK_EVENT_SEQUENCE_NONE, 1966 Self::Claimed => ffi::GTK_EVENT_SEQUENCE_CLAIMED, 1967 Self::Denied => ffi::GTK_EVENT_SEQUENCE_DENIED, 1968 Self::__Unknown(value) => value, 1969 } 1970 } 1971 } 1972 1973 #[doc(hidden)] 1974 impl FromGlib<ffi::GtkEventSequenceState> for EventSequenceState { from_glib(value: ffi::GtkEventSequenceState) -> Self1975 unsafe fn from_glib(value: ffi::GtkEventSequenceState) -> Self { 1976 skip_assert_initialized!(); 1977 match value { 1978 ffi::GTK_EVENT_SEQUENCE_NONE => Self::None, 1979 ffi::GTK_EVENT_SEQUENCE_CLAIMED => Self::Claimed, 1980 ffi::GTK_EVENT_SEQUENCE_DENIED => Self::Denied, 1981 value => Self::__Unknown(value), 1982 } 1983 } 1984 } 1985 1986 impl StaticType for EventSequenceState { static_type() -> Type1987 fn static_type() -> Type { 1988 unsafe { from_glib(ffi::gtk_event_sequence_state_get_type()) } 1989 } 1990 } 1991 1992 impl glib::value::ValueType for EventSequenceState { 1993 type Type = Self; 1994 } 1995 1996 unsafe impl<'a> FromValue<'a> for EventSequenceState { 1997 type Checker = glib::value::GenericValueTypeChecker<Self>; 1998 from_value(value: &'a glib::Value) -> Self1999 unsafe fn from_value(value: &'a glib::Value) -> Self { 2000 skip_assert_initialized!(); 2001 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2002 } 2003 } 2004 2005 impl ToValue for EventSequenceState { to_value(&self) -> glib::Value2006 fn to_value(&self) -> glib::Value { 2007 let mut value = glib::Value::for_value_type::<Self>(); 2008 unsafe { 2009 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2010 } 2011 value 2012 } 2013 value_type(&self) -> glib::Type2014 fn value_type(&self) -> glib::Type { 2015 Self::static_type() 2016 } 2017 } 2018 2019 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2020 #[non_exhaustive] 2021 #[doc(alias = "GtkFileChooserAction")] 2022 pub enum FileChooserAction { 2023 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_OPEN")] 2024 Open, 2025 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SAVE")] 2026 Save, 2027 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER")] 2028 SelectFolder, 2029 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER")] 2030 CreateFolder, 2031 #[doc(hidden)] 2032 __Unknown(i32), 2033 } 2034 2035 impl fmt::Display for FileChooserAction { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2036 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2037 write!( 2038 f, 2039 "FileChooserAction::{}", 2040 match *self { 2041 Self::Open => "Open", 2042 Self::Save => "Save", 2043 Self::SelectFolder => "SelectFolder", 2044 Self::CreateFolder => "CreateFolder", 2045 _ => "Unknown", 2046 } 2047 ) 2048 } 2049 } 2050 2051 #[doc(hidden)] 2052 impl IntoGlib for FileChooserAction { 2053 type GlibType = ffi::GtkFileChooserAction; 2054 into_glib(self) -> ffi::GtkFileChooserAction2055 fn into_glib(self) -> ffi::GtkFileChooserAction { 2056 match self { 2057 Self::Open => ffi::GTK_FILE_CHOOSER_ACTION_OPEN, 2058 Self::Save => ffi::GTK_FILE_CHOOSER_ACTION_SAVE, 2059 Self::SelectFolder => ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, 2060 Self::CreateFolder => ffi::GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, 2061 Self::__Unknown(value) => value, 2062 } 2063 } 2064 } 2065 2066 #[doc(hidden)] 2067 impl FromGlib<ffi::GtkFileChooserAction> for FileChooserAction { from_glib(value: ffi::GtkFileChooserAction) -> Self2068 unsafe fn from_glib(value: ffi::GtkFileChooserAction) -> Self { 2069 skip_assert_initialized!(); 2070 match value { 2071 ffi::GTK_FILE_CHOOSER_ACTION_OPEN => Self::Open, 2072 ffi::GTK_FILE_CHOOSER_ACTION_SAVE => Self::Save, 2073 ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER => Self::SelectFolder, 2074 ffi::GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER => Self::CreateFolder, 2075 value => Self::__Unknown(value), 2076 } 2077 } 2078 } 2079 2080 impl StaticType for FileChooserAction { static_type() -> Type2081 fn static_type() -> Type { 2082 unsafe { from_glib(ffi::gtk_file_chooser_action_get_type()) } 2083 } 2084 } 2085 2086 impl glib::value::ValueType for FileChooserAction { 2087 type Type = Self; 2088 } 2089 2090 unsafe impl<'a> FromValue<'a> for FileChooserAction { 2091 type Checker = glib::value::GenericValueTypeChecker<Self>; 2092 from_value(value: &'a glib::Value) -> Self2093 unsafe fn from_value(value: &'a glib::Value) -> Self { 2094 skip_assert_initialized!(); 2095 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2096 } 2097 } 2098 2099 impl ToValue for FileChooserAction { to_value(&self) -> glib::Value2100 fn to_value(&self) -> glib::Value { 2101 let mut value = glib::Value::for_value_type::<Self>(); 2102 unsafe { 2103 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2104 } 2105 value 2106 } 2107 value_type(&self) -> glib::Type2108 fn value_type(&self) -> glib::Type { 2109 Self::static_type() 2110 } 2111 } 2112 2113 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2114 #[non_exhaustive] 2115 #[doc(alias = "GtkFileChooserConfirmation")] 2116 pub enum FileChooserConfirmation { 2117 #[doc(alias = "GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM")] 2118 Confirm, 2119 #[doc(alias = "GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME")] 2120 AcceptFilename, 2121 #[doc(alias = "GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN")] 2122 SelectAgain, 2123 #[doc(hidden)] 2124 __Unknown(i32), 2125 } 2126 2127 impl fmt::Display for FileChooserConfirmation { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2128 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2129 write!( 2130 f, 2131 "FileChooserConfirmation::{}", 2132 match *self { 2133 Self::Confirm => "Confirm", 2134 Self::AcceptFilename => "AcceptFilename", 2135 Self::SelectAgain => "SelectAgain", 2136 _ => "Unknown", 2137 } 2138 ) 2139 } 2140 } 2141 2142 #[doc(hidden)] 2143 impl IntoGlib for FileChooserConfirmation { 2144 type GlibType = ffi::GtkFileChooserConfirmation; 2145 into_glib(self) -> ffi::GtkFileChooserConfirmation2146 fn into_glib(self) -> ffi::GtkFileChooserConfirmation { 2147 match self { 2148 Self::Confirm => ffi::GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM, 2149 Self::AcceptFilename => ffi::GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME, 2150 Self::SelectAgain => ffi::GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN, 2151 Self::__Unknown(value) => value, 2152 } 2153 } 2154 } 2155 2156 #[doc(hidden)] 2157 impl FromGlib<ffi::GtkFileChooserConfirmation> for FileChooserConfirmation { from_glib(value: ffi::GtkFileChooserConfirmation) -> Self2158 unsafe fn from_glib(value: ffi::GtkFileChooserConfirmation) -> Self { 2159 skip_assert_initialized!(); 2160 match value { 2161 ffi::GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM => Self::Confirm, 2162 ffi::GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME => Self::AcceptFilename, 2163 ffi::GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN => Self::SelectAgain, 2164 value => Self::__Unknown(value), 2165 } 2166 } 2167 } 2168 2169 impl StaticType for FileChooserConfirmation { static_type() -> Type2170 fn static_type() -> Type { 2171 unsafe { from_glib(ffi::gtk_file_chooser_confirmation_get_type()) } 2172 } 2173 } 2174 2175 impl glib::value::ValueType for FileChooserConfirmation { 2176 type Type = Self; 2177 } 2178 2179 unsafe impl<'a> FromValue<'a> for FileChooserConfirmation { 2180 type Checker = glib::value::GenericValueTypeChecker<Self>; 2181 from_value(value: &'a glib::Value) -> Self2182 unsafe fn from_value(value: &'a glib::Value) -> Self { 2183 skip_assert_initialized!(); 2184 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2185 } 2186 } 2187 2188 impl ToValue for FileChooserConfirmation { to_value(&self) -> glib::Value2189 fn to_value(&self) -> glib::Value { 2190 let mut value = glib::Value::for_value_type::<Self>(); 2191 unsafe { 2192 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2193 } 2194 value 2195 } 2196 value_type(&self) -> glib::Type2197 fn value_type(&self) -> glib::Type { 2198 Self::static_type() 2199 } 2200 } 2201 2202 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2203 #[non_exhaustive] 2204 #[doc(alias = "GtkFileChooserError")] 2205 pub enum FileChooserError { 2206 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_NONEXISTENT")] 2207 Nonexistent, 2208 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME")] 2209 BadFilename, 2210 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS")] 2211 AlreadyExists, 2212 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME")] 2213 IncompleteHostname, 2214 #[doc(hidden)] 2215 __Unknown(i32), 2216 } 2217 2218 impl fmt::Display for FileChooserError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2219 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2220 write!( 2221 f, 2222 "FileChooserError::{}", 2223 match *self { 2224 Self::Nonexistent => "Nonexistent", 2225 Self::BadFilename => "BadFilename", 2226 Self::AlreadyExists => "AlreadyExists", 2227 Self::IncompleteHostname => "IncompleteHostname", 2228 _ => "Unknown", 2229 } 2230 ) 2231 } 2232 } 2233 2234 #[doc(hidden)] 2235 impl IntoGlib for FileChooserError { 2236 type GlibType = ffi::GtkFileChooserError; 2237 into_glib(self) -> ffi::GtkFileChooserError2238 fn into_glib(self) -> ffi::GtkFileChooserError { 2239 match self { 2240 Self::Nonexistent => ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT, 2241 Self::BadFilename => ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME, 2242 Self::AlreadyExists => ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS, 2243 Self::IncompleteHostname => ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME, 2244 Self::__Unknown(value) => value, 2245 } 2246 } 2247 } 2248 2249 #[doc(hidden)] 2250 impl FromGlib<ffi::GtkFileChooserError> for FileChooserError { from_glib(value: ffi::GtkFileChooserError) -> Self2251 unsafe fn from_glib(value: ffi::GtkFileChooserError) -> Self { 2252 skip_assert_initialized!(); 2253 match value { 2254 ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT => Self::Nonexistent, 2255 ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => Self::BadFilename, 2256 ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS => Self::AlreadyExists, 2257 ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME => Self::IncompleteHostname, 2258 value => Self::__Unknown(value), 2259 } 2260 } 2261 } 2262 2263 impl ErrorDomain for FileChooserError { domain() -> Quark2264 fn domain() -> Quark { 2265 skip_assert_initialized!(); 2266 2267 unsafe { from_glib(ffi::gtk_file_chooser_error_quark()) } 2268 } 2269 code(self) -> i322270 fn code(self) -> i32 { 2271 self.into_glib() 2272 } 2273 from(code: i32) -> Option<Self>2274 fn from(code: i32) -> Option<Self> { 2275 skip_assert_initialized!(); 2276 match code { 2277 ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT => Some(Self::Nonexistent), 2278 ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => Some(Self::BadFilename), 2279 ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS => Some(Self::AlreadyExists), 2280 ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME => Some(Self::IncompleteHostname), 2281 value => Some(Self::__Unknown(value)), 2282 } 2283 } 2284 } 2285 2286 impl StaticType for FileChooserError { static_type() -> Type2287 fn static_type() -> Type { 2288 unsafe { from_glib(ffi::gtk_file_chooser_error_get_type()) } 2289 } 2290 } 2291 2292 impl glib::value::ValueType for FileChooserError { 2293 type Type = Self; 2294 } 2295 2296 unsafe impl<'a> FromValue<'a> for FileChooserError { 2297 type Checker = glib::value::GenericValueTypeChecker<Self>; 2298 from_value(value: &'a glib::Value) -> Self2299 unsafe fn from_value(value: &'a glib::Value) -> Self { 2300 skip_assert_initialized!(); 2301 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2302 } 2303 } 2304 2305 impl ToValue for FileChooserError { to_value(&self) -> glib::Value2306 fn to_value(&self) -> glib::Value { 2307 let mut value = glib::Value::for_value_type::<Self>(); 2308 unsafe { 2309 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2310 } 2311 value 2312 } 2313 value_type(&self) -> glib::Type2314 fn value_type(&self) -> glib::Type { 2315 Self::static_type() 2316 } 2317 } 2318 2319 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2320 #[non_exhaustive] 2321 #[doc(alias = "GtkIconSize")] 2322 pub enum IconSize { 2323 #[doc(alias = "GTK_ICON_SIZE_INVALID")] 2324 Invalid, 2325 #[doc(alias = "GTK_ICON_SIZE_MENU")] 2326 Menu, 2327 #[doc(alias = "GTK_ICON_SIZE_SMALL_TOOLBAR")] 2328 SmallToolbar, 2329 #[doc(alias = "GTK_ICON_SIZE_LARGE_TOOLBAR")] 2330 LargeToolbar, 2331 #[doc(alias = "GTK_ICON_SIZE_BUTTON")] 2332 Button, 2333 #[doc(alias = "GTK_ICON_SIZE_DND")] 2334 Dnd, 2335 #[doc(alias = "GTK_ICON_SIZE_DIALOG")] 2336 Dialog, 2337 #[doc(hidden)] 2338 __Unknown(i32), 2339 } 2340 2341 impl IconSize { 2342 #[doc(alias = "gtk_icon_size_lookup")] lookup(self) -> Option<(i32, i32)>2343 pub fn lookup(self) -> Option<(i32, i32)> { 2344 assert_initialized_main_thread!(); 2345 unsafe { 2346 let mut width = mem::MaybeUninit::uninit(); 2347 let mut height = mem::MaybeUninit::uninit(); 2348 let ret = from_glib(ffi::gtk_icon_size_lookup( 2349 self.into_glib(), 2350 width.as_mut_ptr(), 2351 height.as_mut_ptr(), 2352 )); 2353 let width = width.assume_init(); 2354 let height = height.assume_init(); 2355 if ret { 2356 Some((width, height)) 2357 } else { 2358 None 2359 } 2360 } 2361 } 2362 } 2363 2364 impl fmt::Display for IconSize { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2365 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2366 write!( 2367 f, 2368 "IconSize::{}", 2369 match *self { 2370 Self::Invalid => "Invalid", 2371 Self::Menu => "Menu", 2372 Self::SmallToolbar => "SmallToolbar", 2373 Self::LargeToolbar => "LargeToolbar", 2374 Self::Button => "Button", 2375 Self::Dnd => "Dnd", 2376 Self::Dialog => "Dialog", 2377 _ => "Unknown", 2378 } 2379 ) 2380 } 2381 } 2382 2383 #[doc(hidden)] 2384 impl IntoGlib for IconSize { 2385 type GlibType = ffi::GtkIconSize; 2386 into_glib(self) -> ffi::GtkIconSize2387 fn into_glib(self) -> ffi::GtkIconSize { 2388 match self { 2389 Self::Invalid => ffi::GTK_ICON_SIZE_INVALID, 2390 Self::Menu => ffi::GTK_ICON_SIZE_MENU, 2391 Self::SmallToolbar => ffi::GTK_ICON_SIZE_SMALL_TOOLBAR, 2392 Self::LargeToolbar => ffi::GTK_ICON_SIZE_LARGE_TOOLBAR, 2393 Self::Button => ffi::GTK_ICON_SIZE_BUTTON, 2394 Self::Dnd => ffi::GTK_ICON_SIZE_DND, 2395 Self::Dialog => ffi::GTK_ICON_SIZE_DIALOG, 2396 Self::__Unknown(value) => value, 2397 } 2398 } 2399 } 2400 2401 #[doc(hidden)] 2402 impl FromGlib<ffi::GtkIconSize> for IconSize { from_glib(value: ffi::GtkIconSize) -> Self2403 unsafe fn from_glib(value: ffi::GtkIconSize) -> Self { 2404 skip_assert_initialized!(); 2405 match value { 2406 ffi::GTK_ICON_SIZE_INVALID => Self::Invalid, 2407 ffi::GTK_ICON_SIZE_MENU => Self::Menu, 2408 ffi::GTK_ICON_SIZE_SMALL_TOOLBAR => Self::SmallToolbar, 2409 ffi::GTK_ICON_SIZE_LARGE_TOOLBAR => Self::LargeToolbar, 2410 ffi::GTK_ICON_SIZE_BUTTON => Self::Button, 2411 ffi::GTK_ICON_SIZE_DND => Self::Dnd, 2412 ffi::GTK_ICON_SIZE_DIALOG => Self::Dialog, 2413 value => Self::__Unknown(value), 2414 } 2415 } 2416 } 2417 2418 impl StaticType for IconSize { static_type() -> Type2419 fn static_type() -> Type { 2420 unsafe { from_glib(ffi::gtk_icon_size_get_type()) } 2421 } 2422 } 2423 2424 impl glib::value::ValueType for IconSize { 2425 type Type = Self; 2426 } 2427 2428 unsafe impl<'a> FromValue<'a> for IconSize { 2429 type Checker = glib::value::GenericValueTypeChecker<Self>; 2430 from_value(value: &'a glib::Value) -> Self2431 unsafe fn from_value(value: &'a glib::Value) -> Self { 2432 skip_assert_initialized!(); 2433 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2434 } 2435 } 2436 2437 impl ToValue for IconSize { to_value(&self) -> glib::Value2438 fn to_value(&self) -> glib::Value { 2439 let mut value = glib::Value::for_value_type::<Self>(); 2440 unsafe { 2441 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2442 } 2443 value 2444 } 2445 value_type(&self) -> glib::Type2446 fn value_type(&self) -> glib::Type { 2447 Self::static_type() 2448 } 2449 } 2450 2451 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2452 #[non_exhaustive] 2453 #[doc(alias = "GtkIconThemeError")] 2454 pub enum IconThemeError { 2455 #[doc(alias = "GTK_ICON_THEME_NOT_FOUND")] 2456 NotFound, 2457 #[doc(alias = "GTK_ICON_THEME_FAILED")] 2458 Failed, 2459 #[doc(hidden)] 2460 __Unknown(i32), 2461 } 2462 2463 impl fmt::Display for IconThemeError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2464 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2465 write!( 2466 f, 2467 "IconThemeError::{}", 2468 match *self { 2469 Self::NotFound => "NotFound", 2470 Self::Failed => "Failed", 2471 _ => "Unknown", 2472 } 2473 ) 2474 } 2475 } 2476 2477 #[doc(hidden)] 2478 impl IntoGlib for IconThemeError { 2479 type GlibType = ffi::GtkIconThemeError; 2480 into_glib(self) -> ffi::GtkIconThemeError2481 fn into_glib(self) -> ffi::GtkIconThemeError { 2482 match self { 2483 Self::NotFound => ffi::GTK_ICON_THEME_NOT_FOUND, 2484 Self::Failed => ffi::GTK_ICON_THEME_FAILED, 2485 Self::__Unknown(value) => value, 2486 } 2487 } 2488 } 2489 2490 #[doc(hidden)] 2491 impl FromGlib<ffi::GtkIconThemeError> for IconThemeError { from_glib(value: ffi::GtkIconThemeError) -> Self2492 unsafe fn from_glib(value: ffi::GtkIconThemeError) -> Self { 2493 skip_assert_initialized!(); 2494 match value { 2495 ffi::GTK_ICON_THEME_NOT_FOUND => Self::NotFound, 2496 ffi::GTK_ICON_THEME_FAILED => Self::Failed, 2497 value => Self::__Unknown(value), 2498 } 2499 } 2500 } 2501 2502 impl ErrorDomain for IconThemeError { domain() -> Quark2503 fn domain() -> Quark { 2504 skip_assert_initialized!(); 2505 2506 unsafe { from_glib(ffi::gtk_icon_theme_error_quark()) } 2507 } 2508 code(self) -> i322509 fn code(self) -> i32 { 2510 self.into_glib() 2511 } 2512 from(code: i32) -> Option<Self>2513 fn from(code: i32) -> Option<Self> { 2514 skip_assert_initialized!(); 2515 match code { 2516 ffi::GTK_ICON_THEME_NOT_FOUND => Some(Self::NotFound), 2517 ffi::GTK_ICON_THEME_FAILED => Some(Self::Failed), 2518 _ => Some(Self::Failed), 2519 } 2520 } 2521 } 2522 2523 impl StaticType for IconThemeError { static_type() -> Type2524 fn static_type() -> Type { 2525 unsafe { from_glib(ffi::gtk_icon_theme_error_get_type()) } 2526 } 2527 } 2528 2529 impl glib::value::ValueType for IconThemeError { 2530 type Type = Self; 2531 } 2532 2533 unsafe impl<'a> FromValue<'a> for IconThemeError { 2534 type Checker = glib::value::GenericValueTypeChecker<Self>; 2535 from_value(value: &'a glib::Value) -> Self2536 unsafe fn from_value(value: &'a glib::Value) -> Self { 2537 skip_assert_initialized!(); 2538 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2539 } 2540 } 2541 2542 impl ToValue for IconThemeError { to_value(&self) -> glib::Value2543 fn to_value(&self) -> glib::Value { 2544 let mut value = glib::Value::for_value_type::<Self>(); 2545 unsafe { 2546 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2547 } 2548 value 2549 } 2550 value_type(&self) -> glib::Type2551 fn value_type(&self) -> glib::Type { 2552 Self::static_type() 2553 } 2554 } 2555 2556 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2557 #[non_exhaustive] 2558 #[doc(alias = "GtkIconViewDropPosition")] 2559 pub enum IconViewDropPosition { 2560 #[doc(alias = "GTK_ICON_VIEW_NO_DROP")] 2561 NoDrop, 2562 #[doc(alias = "GTK_ICON_VIEW_DROP_INTO")] 2563 DropInto, 2564 #[doc(alias = "GTK_ICON_VIEW_DROP_LEFT")] 2565 DropLeft, 2566 #[doc(alias = "GTK_ICON_VIEW_DROP_RIGHT")] 2567 DropRight, 2568 #[doc(alias = "GTK_ICON_VIEW_DROP_ABOVE")] 2569 DropAbove, 2570 #[doc(alias = "GTK_ICON_VIEW_DROP_BELOW")] 2571 DropBelow, 2572 #[doc(hidden)] 2573 __Unknown(i32), 2574 } 2575 2576 impl fmt::Display for IconViewDropPosition { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2577 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2578 write!( 2579 f, 2580 "IconViewDropPosition::{}", 2581 match *self { 2582 Self::NoDrop => "NoDrop", 2583 Self::DropInto => "DropInto", 2584 Self::DropLeft => "DropLeft", 2585 Self::DropRight => "DropRight", 2586 Self::DropAbove => "DropAbove", 2587 Self::DropBelow => "DropBelow", 2588 _ => "Unknown", 2589 } 2590 ) 2591 } 2592 } 2593 2594 #[doc(hidden)] 2595 impl IntoGlib for IconViewDropPosition { 2596 type GlibType = ffi::GtkIconViewDropPosition; 2597 into_glib(self) -> ffi::GtkIconViewDropPosition2598 fn into_glib(self) -> ffi::GtkIconViewDropPosition { 2599 match self { 2600 Self::NoDrop => ffi::GTK_ICON_VIEW_NO_DROP, 2601 Self::DropInto => ffi::GTK_ICON_VIEW_DROP_INTO, 2602 Self::DropLeft => ffi::GTK_ICON_VIEW_DROP_LEFT, 2603 Self::DropRight => ffi::GTK_ICON_VIEW_DROP_RIGHT, 2604 Self::DropAbove => ffi::GTK_ICON_VIEW_DROP_ABOVE, 2605 Self::DropBelow => ffi::GTK_ICON_VIEW_DROP_BELOW, 2606 Self::__Unknown(value) => value, 2607 } 2608 } 2609 } 2610 2611 #[doc(hidden)] 2612 impl FromGlib<ffi::GtkIconViewDropPosition> for IconViewDropPosition { from_glib(value: ffi::GtkIconViewDropPosition) -> Self2613 unsafe fn from_glib(value: ffi::GtkIconViewDropPosition) -> Self { 2614 skip_assert_initialized!(); 2615 match value { 2616 ffi::GTK_ICON_VIEW_NO_DROP => Self::NoDrop, 2617 ffi::GTK_ICON_VIEW_DROP_INTO => Self::DropInto, 2618 ffi::GTK_ICON_VIEW_DROP_LEFT => Self::DropLeft, 2619 ffi::GTK_ICON_VIEW_DROP_RIGHT => Self::DropRight, 2620 ffi::GTK_ICON_VIEW_DROP_ABOVE => Self::DropAbove, 2621 ffi::GTK_ICON_VIEW_DROP_BELOW => Self::DropBelow, 2622 value => Self::__Unknown(value), 2623 } 2624 } 2625 } 2626 2627 impl StaticType for IconViewDropPosition { static_type() -> Type2628 fn static_type() -> Type { 2629 unsafe { from_glib(ffi::gtk_icon_view_drop_position_get_type()) } 2630 } 2631 } 2632 2633 impl glib::value::ValueType for IconViewDropPosition { 2634 type Type = Self; 2635 } 2636 2637 unsafe impl<'a> FromValue<'a> for IconViewDropPosition { 2638 type Checker = glib::value::GenericValueTypeChecker<Self>; 2639 from_value(value: &'a glib::Value) -> Self2640 unsafe fn from_value(value: &'a glib::Value) -> Self { 2641 skip_assert_initialized!(); 2642 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2643 } 2644 } 2645 2646 impl ToValue for IconViewDropPosition { to_value(&self) -> glib::Value2647 fn to_value(&self) -> glib::Value { 2648 let mut value = glib::Value::for_value_type::<Self>(); 2649 unsafe { 2650 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2651 } 2652 value 2653 } 2654 value_type(&self) -> glib::Type2655 fn value_type(&self) -> glib::Type { 2656 Self::static_type() 2657 } 2658 } 2659 2660 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2661 #[non_exhaustive] 2662 #[doc(alias = "GtkImageType")] 2663 pub enum ImageType { 2664 #[doc(alias = "GTK_IMAGE_EMPTY")] 2665 Empty, 2666 #[doc(alias = "GTK_IMAGE_PIXBUF")] 2667 Pixbuf, 2668 #[doc(alias = "GTK_IMAGE_STOCK")] 2669 Stock, 2670 #[doc(alias = "GTK_IMAGE_ICON_SET")] 2671 IconSet, 2672 #[doc(alias = "GTK_IMAGE_ANIMATION")] 2673 Animation, 2674 #[doc(alias = "GTK_IMAGE_ICON_NAME")] 2675 IconName, 2676 #[doc(alias = "GTK_IMAGE_GICON")] 2677 Gicon, 2678 #[doc(alias = "GTK_IMAGE_SURFACE")] 2679 Surface, 2680 #[doc(hidden)] 2681 __Unknown(i32), 2682 } 2683 2684 impl fmt::Display for ImageType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2685 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2686 write!( 2687 f, 2688 "ImageType::{}", 2689 match *self { 2690 Self::Empty => "Empty", 2691 Self::Pixbuf => "Pixbuf", 2692 Self::Stock => "Stock", 2693 Self::IconSet => "IconSet", 2694 Self::Animation => "Animation", 2695 Self::IconName => "IconName", 2696 Self::Gicon => "Gicon", 2697 Self::Surface => "Surface", 2698 _ => "Unknown", 2699 } 2700 ) 2701 } 2702 } 2703 2704 #[doc(hidden)] 2705 impl IntoGlib for ImageType { 2706 type GlibType = ffi::GtkImageType; 2707 into_glib(self) -> ffi::GtkImageType2708 fn into_glib(self) -> ffi::GtkImageType { 2709 match self { 2710 Self::Empty => ffi::GTK_IMAGE_EMPTY, 2711 Self::Pixbuf => ffi::GTK_IMAGE_PIXBUF, 2712 Self::Stock => ffi::GTK_IMAGE_STOCK, 2713 Self::IconSet => ffi::GTK_IMAGE_ICON_SET, 2714 Self::Animation => ffi::GTK_IMAGE_ANIMATION, 2715 Self::IconName => ffi::GTK_IMAGE_ICON_NAME, 2716 Self::Gicon => ffi::GTK_IMAGE_GICON, 2717 Self::Surface => ffi::GTK_IMAGE_SURFACE, 2718 Self::__Unknown(value) => value, 2719 } 2720 } 2721 } 2722 2723 #[doc(hidden)] 2724 impl FromGlib<ffi::GtkImageType> for ImageType { from_glib(value: ffi::GtkImageType) -> Self2725 unsafe fn from_glib(value: ffi::GtkImageType) -> Self { 2726 skip_assert_initialized!(); 2727 match value { 2728 ffi::GTK_IMAGE_EMPTY => Self::Empty, 2729 ffi::GTK_IMAGE_PIXBUF => Self::Pixbuf, 2730 ffi::GTK_IMAGE_STOCK => Self::Stock, 2731 ffi::GTK_IMAGE_ICON_SET => Self::IconSet, 2732 ffi::GTK_IMAGE_ANIMATION => Self::Animation, 2733 ffi::GTK_IMAGE_ICON_NAME => Self::IconName, 2734 ffi::GTK_IMAGE_GICON => Self::Gicon, 2735 ffi::GTK_IMAGE_SURFACE => Self::Surface, 2736 value => Self::__Unknown(value), 2737 } 2738 } 2739 } 2740 2741 impl StaticType for ImageType { static_type() -> Type2742 fn static_type() -> Type { 2743 unsafe { from_glib(ffi::gtk_image_type_get_type()) } 2744 } 2745 } 2746 2747 impl glib::value::ValueType for ImageType { 2748 type Type = Self; 2749 } 2750 2751 unsafe impl<'a> FromValue<'a> for ImageType { 2752 type Checker = glib::value::GenericValueTypeChecker<Self>; 2753 from_value(value: &'a glib::Value) -> Self2754 unsafe fn from_value(value: &'a glib::Value) -> Self { 2755 skip_assert_initialized!(); 2756 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2757 } 2758 } 2759 2760 impl ToValue for ImageType { to_value(&self) -> glib::Value2761 fn to_value(&self) -> glib::Value { 2762 let mut value = glib::Value::for_value_type::<Self>(); 2763 unsafe { 2764 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2765 } 2766 value 2767 } 2768 value_type(&self) -> glib::Type2769 fn value_type(&self) -> glib::Type { 2770 Self::static_type() 2771 } 2772 } 2773 2774 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2775 #[non_exhaustive] 2776 #[doc(alias = "GtkInputPurpose")] 2777 pub enum InputPurpose { 2778 #[doc(alias = "GTK_INPUT_PURPOSE_FREE_FORM")] 2779 FreeForm, 2780 #[doc(alias = "GTK_INPUT_PURPOSE_ALPHA")] 2781 Alpha, 2782 #[doc(alias = "GTK_INPUT_PURPOSE_DIGITS")] 2783 Digits, 2784 #[doc(alias = "GTK_INPUT_PURPOSE_NUMBER")] 2785 Number, 2786 #[doc(alias = "GTK_INPUT_PURPOSE_PHONE")] 2787 Phone, 2788 #[doc(alias = "GTK_INPUT_PURPOSE_URL")] 2789 Url, 2790 #[doc(alias = "GTK_INPUT_PURPOSE_EMAIL")] 2791 Email, 2792 #[doc(alias = "GTK_INPUT_PURPOSE_NAME")] 2793 Name, 2794 #[doc(alias = "GTK_INPUT_PURPOSE_PASSWORD")] 2795 Password, 2796 #[doc(alias = "GTK_INPUT_PURPOSE_PIN")] 2797 Pin, 2798 #[doc(alias = "GTK_INPUT_PURPOSE_TERMINAL")] 2799 Terminal, 2800 #[doc(hidden)] 2801 __Unknown(i32), 2802 } 2803 2804 impl fmt::Display for InputPurpose { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2805 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2806 write!( 2807 f, 2808 "InputPurpose::{}", 2809 match *self { 2810 Self::FreeForm => "FreeForm", 2811 Self::Alpha => "Alpha", 2812 Self::Digits => "Digits", 2813 Self::Number => "Number", 2814 Self::Phone => "Phone", 2815 Self::Url => "Url", 2816 Self::Email => "Email", 2817 Self::Name => "Name", 2818 Self::Password => "Password", 2819 Self::Pin => "Pin", 2820 Self::Terminal => "Terminal", 2821 _ => "Unknown", 2822 } 2823 ) 2824 } 2825 } 2826 2827 #[doc(hidden)] 2828 impl IntoGlib for InputPurpose { 2829 type GlibType = ffi::GtkInputPurpose; 2830 into_glib(self) -> ffi::GtkInputPurpose2831 fn into_glib(self) -> ffi::GtkInputPurpose { 2832 match self { 2833 Self::FreeForm => ffi::GTK_INPUT_PURPOSE_FREE_FORM, 2834 Self::Alpha => ffi::GTK_INPUT_PURPOSE_ALPHA, 2835 Self::Digits => ffi::GTK_INPUT_PURPOSE_DIGITS, 2836 Self::Number => ffi::GTK_INPUT_PURPOSE_NUMBER, 2837 Self::Phone => ffi::GTK_INPUT_PURPOSE_PHONE, 2838 Self::Url => ffi::GTK_INPUT_PURPOSE_URL, 2839 Self::Email => ffi::GTK_INPUT_PURPOSE_EMAIL, 2840 Self::Name => ffi::GTK_INPUT_PURPOSE_NAME, 2841 Self::Password => ffi::GTK_INPUT_PURPOSE_PASSWORD, 2842 Self::Pin => ffi::GTK_INPUT_PURPOSE_PIN, 2843 Self::Terminal => ffi::GTK_INPUT_PURPOSE_TERMINAL, 2844 Self::__Unknown(value) => value, 2845 } 2846 } 2847 } 2848 2849 #[doc(hidden)] 2850 impl FromGlib<ffi::GtkInputPurpose> for InputPurpose { from_glib(value: ffi::GtkInputPurpose) -> Self2851 unsafe fn from_glib(value: ffi::GtkInputPurpose) -> Self { 2852 skip_assert_initialized!(); 2853 match value { 2854 ffi::GTK_INPUT_PURPOSE_FREE_FORM => Self::FreeForm, 2855 ffi::GTK_INPUT_PURPOSE_ALPHA => Self::Alpha, 2856 ffi::GTK_INPUT_PURPOSE_DIGITS => Self::Digits, 2857 ffi::GTK_INPUT_PURPOSE_NUMBER => Self::Number, 2858 ffi::GTK_INPUT_PURPOSE_PHONE => Self::Phone, 2859 ffi::GTK_INPUT_PURPOSE_URL => Self::Url, 2860 ffi::GTK_INPUT_PURPOSE_EMAIL => Self::Email, 2861 ffi::GTK_INPUT_PURPOSE_NAME => Self::Name, 2862 ffi::GTK_INPUT_PURPOSE_PASSWORD => Self::Password, 2863 ffi::GTK_INPUT_PURPOSE_PIN => Self::Pin, 2864 ffi::GTK_INPUT_PURPOSE_TERMINAL => Self::Terminal, 2865 value => Self::__Unknown(value), 2866 } 2867 } 2868 } 2869 2870 impl StaticType for InputPurpose { static_type() -> Type2871 fn static_type() -> Type { 2872 unsafe { from_glib(ffi::gtk_input_purpose_get_type()) } 2873 } 2874 } 2875 2876 impl glib::value::ValueType for InputPurpose { 2877 type Type = Self; 2878 } 2879 2880 unsafe impl<'a> FromValue<'a> for InputPurpose { 2881 type Checker = glib::value::GenericValueTypeChecker<Self>; 2882 from_value(value: &'a glib::Value) -> Self2883 unsafe fn from_value(value: &'a glib::Value) -> Self { 2884 skip_assert_initialized!(); 2885 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2886 } 2887 } 2888 2889 impl ToValue for InputPurpose { to_value(&self) -> glib::Value2890 fn to_value(&self) -> glib::Value { 2891 let mut value = glib::Value::for_value_type::<Self>(); 2892 unsafe { 2893 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2894 } 2895 value 2896 } 2897 value_type(&self) -> glib::Type2898 fn value_type(&self) -> glib::Type { 2899 Self::static_type() 2900 } 2901 } 2902 2903 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2904 #[non_exhaustive] 2905 #[doc(alias = "GtkJustification")] 2906 pub enum Justification { 2907 #[doc(alias = "GTK_JUSTIFY_LEFT")] 2908 Left, 2909 #[doc(alias = "GTK_JUSTIFY_RIGHT")] 2910 Right, 2911 #[doc(alias = "GTK_JUSTIFY_CENTER")] 2912 Center, 2913 #[doc(alias = "GTK_JUSTIFY_FILL")] 2914 Fill, 2915 #[doc(hidden)] 2916 __Unknown(i32), 2917 } 2918 2919 impl fmt::Display for Justification { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2920 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2921 write!( 2922 f, 2923 "Justification::{}", 2924 match *self { 2925 Self::Left => "Left", 2926 Self::Right => "Right", 2927 Self::Center => "Center", 2928 Self::Fill => "Fill", 2929 _ => "Unknown", 2930 } 2931 ) 2932 } 2933 } 2934 2935 #[doc(hidden)] 2936 impl IntoGlib for Justification { 2937 type GlibType = ffi::GtkJustification; 2938 into_glib(self) -> ffi::GtkJustification2939 fn into_glib(self) -> ffi::GtkJustification { 2940 match self { 2941 Self::Left => ffi::GTK_JUSTIFY_LEFT, 2942 Self::Right => ffi::GTK_JUSTIFY_RIGHT, 2943 Self::Center => ffi::GTK_JUSTIFY_CENTER, 2944 Self::Fill => ffi::GTK_JUSTIFY_FILL, 2945 Self::__Unknown(value) => value, 2946 } 2947 } 2948 } 2949 2950 #[doc(hidden)] 2951 impl FromGlib<ffi::GtkJustification> for Justification { from_glib(value: ffi::GtkJustification) -> Self2952 unsafe fn from_glib(value: ffi::GtkJustification) -> Self { 2953 skip_assert_initialized!(); 2954 match value { 2955 ffi::GTK_JUSTIFY_LEFT => Self::Left, 2956 ffi::GTK_JUSTIFY_RIGHT => Self::Right, 2957 ffi::GTK_JUSTIFY_CENTER => Self::Center, 2958 ffi::GTK_JUSTIFY_FILL => Self::Fill, 2959 value => Self::__Unknown(value), 2960 } 2961 } 2962 } 2963 2964 impl StaticType for Justification { static_type() -> Type2965 fn static_type() -> Type { 2966 unsafe { from_glib(ffi::gtk_justification_get_type()) } 2967 } 2968 } 2969 2970 impl glib::value::ValueType for Justification { 2971 type Type = Self; 2972 } 2973 2974 unsafe impl<'a> FromValue<'a> for Justification { 2975 type Checker = glib::value::GenericValueTypeChecker<Self>; 2976 from_value(value: &'a glib::Value) -> Self2977 unsafe fn from_value(value: &'a glib::Value) -> Self { 2978 skip_assert_initialized!(); 2979 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2980 } 2981 } 2982 2983 impl ToValue for Justification { to_value(&self) -> glib::Value2984 fn to_value(&self) -> glib::Value { 2985 let mut value = glib::Value::for_value_type::<Self>(); 2986 unsafe { 2987 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2988 } 2989 value 2990 } 2991 value_type(&self) -> glib::Type2992 fn value_type(&self) -> glib::Type { 2993 Self::static_type() 2994 } 2995 } 2996 2997 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2998 #[non_exhaustive] 2999 #[doc(alias = "GtkLevelBarMode")] 3000 pub enum LevelBarMode { 3001 #[doc(alias = "GTK_LEVEL_BAR_MODE_CONTINUOUS")] 3002 Continuous, 3003 #[doc(alias = "GTK_LEVEL_BAR_MODE_DISCRETE")] 3004 Discrete, 3005 #[doc(hidden)] 3006 __Unknown(i32), 3007 } 3008 3009 impl fmt::Display for LevelBarMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3010 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3011 write!( 3012 f, 3013 "LevelBarMode::{}", 3014 match *self { 3015 Self::Continuous => "Continuous", 3016 Self::Discrete => "Discrete", 3017 _ => "Unknown", 3018 } 3019 ) 3020 } 3021 } 3022 3023 #[doc(hidden)] 3024 impl IntoGlib for LevelBarMode { 3025 type GlibType = ffi::GtkLevelBarMode; 3026 into_glib(self) -> ffi::GtkLevelBarMode3027 fn into_glib(self) -> ffi::GtkLevelBarMode { 3028 match self { 3029 Self::Continuous => ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS, 3030 Self::Discrete => ffi::GTK_LEVEL_BAR_MODE_DISCRETE, 3031 Self::__Unknown(value) => value, 3032 } 3033 } 3034 } 3035 3036 #[doc(hidden)] 3037 impl FromGlib<ffi::GtkLevelBarMode> for LevelBarMode { from_glib(value: ffi::GtkLevelBarMode) -> Self3038 unsafe fn from_glib(value: ffi::GtkLevelBarMode) -> Self { 3039 skip_assert_initialized!(); 3040 match value { 3041 ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS => Self::Continuous, 3042 ffi::GTK_LEVEL_BAR_MODE_DISCRETE => Self::Discrete, 3043 value => Self::__Unknown(value), 3044 } 3045 } 3046 } 3047 3048 impl StaticType for LevelBarMode { static_type() -> Type3049 fn static_type() -> Type { 3050 unsafe { from_glib(ffi::gtk_level_bar_mode_get_type()) } 3051 } 3052 } 3053 3054 impl glib::value::ValueType for LevelBarMode { 3055 type Type = Self; 3056 } 3057 3058 unsafe impl<'a> FromValue<'a> for LevelBarMode { 3059 type Checker = glib::value::GenericValueTypeChecker<Self>; 3060 from_value(value: &'a glib::Value) -> Self3061 unsafe fn from_value(value: &'a glib::Value) -> Self { 3062 skip_assert_initialized!(); 3063 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3064 } 3065 } 3066 3067 impl ToValue for LevelBarMode { to_value(&self) -> glib::Value3068 fn to_value(&self) -> glib::Value { 3069 let mut value = glib::Value::for_value_type::<Self>(); 3070 unsafe { 3071 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3072 } 3073 value 3074 } 3075 value_type(&self) -> glib::Type3076 fn value_type(&self) -> glib::Type { 3077 Self::static_type() 3078 } 3079 } 3080 3081 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3082 #[non_exhaustive] 3083 #[doc(alias = "GtkLicense")] 3084 pub enum License { 3085 #[doc(alias = "GTK_LICENSE_UNKNOWN")] 3086 Unknown, 3087 #[doc(alias = "GTK_LICENSE_CUSTOM")] 3088 Custom, 3089 #[doc(alias = "GTK_LICENSE_GPL_2_0")] 3090 Gpl20, 3091 #[doc(alias = "GTK_LICENSE_GPL_3_0")] 3092 Gpl30, 3093 #[doc(alias = "GTK_LICENSE_LGPL_2_1")] 3094 Lgpl21, 3095 #[doc(alias = "GTK_LICENSE_LGPL_3_0")] 3096 Lgpl30, 3097 #[doc(alias = "GTK_LICENSE_BSD")] 3098 Bsd, 3099 #[doc(alias = "GTK_LICENSE_MIT_X11")] 3100 MitX11, 3101 #[doc(alias = "GTK_LICENSE_ARTISTIC")] 3102 Artistic, 3103 #[doc(alias = "GTK_LICENSE_GPL_2_0_ONLY")] 3104 Gpl20Only, 3105 #[doc(alias = "GTK_LICENSE_GPL_3_0_ONLY")] 3106 Gpl30Only, 3107 #[doc(alias = "GTK_LICENSE_LGPL_2_1_ONLY")] 3108 Lgpl21Only, 3109 #[doc(alias = "GTK_LICENSE_LGPL_3_0_ONLY")] 3110 Lgpl30Only, 3111 #[doc(alias = "GTK_LICENSE_AGPL_3_0")] 3112 Agpl30, 3113 #[doc(alias = "GTK_LICENSE_AGPL_3_0_ONLY")] 3114 Agpl30Only, 3115 #[doc(alias = "GTK_LICENSE_BSD_3")] 3116 Bsd3, 3117 #[doc(alias = "GTK_LICENSE_APACHE_2_0")] 3118 Apache20, 3119 #[doc(alias = "GTK_LICENSE_MPL_2_0")] 3120 Mpl20, 3121 #[doc(hidden)] 3122 __Unknown(i32), 3123 } 3124 3125 impl fmt::Display for License { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3126 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3127 write!( 3128 f, 3129 "License::{}", 3130 match *self { 3131 Self::Unknown => "Unknown", 3132 Self::Custom => "Custom", 3133 Self::Gpl20 => "Gpl20", 3134 Self::Gpl30 => "Gpl30", 3135 Self::Lgpl21 => "Lgpl21", 3136 Self::Lgpl30 => "Lgpl30", 3137 Self::Bsd => "Bsd", 3138 Self::MitX11 => "MitX11", 3139 Self::Artistic => "Artistic", 3140 Self::Gpl20Only => "Gpl20Only", 3141 Self::Gpl30Only => "Gpl30Only", 3142 Self::Lgpl21Only => "Lgpl21Only", 3143 Self::Lgpl30Only => "Lgpl30Only", 3144 Self::Agpl30 => "Agpl30", 3145 Self::Agpl30Only => "Agpl30Only", 3146 Self::Bsd3 => "Bsd3", 3147 Self::Apache20 => "Apache20", 3148 Self::Mpl20 => "Mpl20", 3149 _ => "Unknown", 3150 } 3151 ) 3152 } 3153 } 3154 3155 #[doc(hidden)] 3156 impl IntoGlib for License { 3157 type GlibType = ffi::GtkLicense; 3158 into_glib(self) -> ffi::GtkLicense3159 fn into_glib(self) -> ffi::GtkLicense { 3160 match self { 3161 Self::Unknown => ffi::GTK_LICENSE_UNKNOWN, 3162 Self::Custom => ffi::GTK_LICENSE_CUSTOM, 3163 Self::Gpl20 => ffi::GTK_LICENSE_GPL_2_0, 3164 Self::Gpl30 => ffi::GTK_LICENSE_GPL_3_0, 3165 Self::Lgpl21 => ffi::GTK_LICENSE_LGPL_2_1, 3166 Self::Lgpl30 => ffi::GTK_LICENSE_LGPL_3_0, 3167 Self::Bsd => ffi::GTK_LICENSE_BSD, 3168 Self::MitX11 => ffi::GTK_LICENSE_MIT_X11, 3169 Self::Artistic => ffi::GTK_LICENSE_ARTISTIC, 3170 Self::Gpl20Only => ffi::GTK_LICENSE_GPL_2_0_ONLY, 3171 Self::Gpl30Only => ffi::GTK_LICENSE_GPL_3_0_ONLY, 3172 Self::Lgpl21Only => ffi::GTK_LICENSE_LGPL_2_1_ONLY, 3173 Self::Lgpl30Only => ffi::GTK_LICENSE_LGPL_3_0_ONLY, 3174 Self::Agpl30 => ffi::GTK_LICENSE_AGPL_3_0, 3175 Self::Agpl30Only => ffi::GTK_LICENSE_AGPL_3_0_ONLY, 3176 Self::Bsd3 => ffi::GTK_LICENSE_BSD_3, 3177 Self::Apache20 => ffi::GTK_LICENSE_APACHE_2_0, 3178 Self::Mpl20 => ffi::GTK_LICENSE_MPL_2_0, 3179 Self::__Unknown(value) => value, 3180 } 3181 } 3182 } 3183 3184 #[doc(hidden)] 3185 impl FromGlib<ffi::GtkLicense> for License { from_glib(value: ffi::GtkLicense) -> Self3186 unsafe fn from_glib(value: ffi::GtkLicense) -> Self { 3187 skip_assert_initialized!(); 3188 match value { 3189 ffi::GTK_LICENSE_UNKNOWN => Self::Unknown, 3190 ffi::GTK_LICENSE_CUSTOM => Self::Custom, 3191 ffi::GTK_LICENSE_GPL_2_0 => Self::Gpl20, 3192 ffi::GTK_LICENSE_GPL_3_0 => Self::Gpl30, 3193 ffi::GTK_LICENSE_LGPL_2_1 => Self::Lgpl21, 3194 ffi::GTK_LICENSE_LGPL_3_0 => Self::Lgpl30, 3195 ffi::GTK_LICENSE_BSD => Self::Bsd, 3196 ffi::GTK_LICENSE_MIT_X11 => Self::MitX11, 3197 ffi::GTK_LICENSE_ARTISTIC => Self::Artistic, 3198 ffi::GTK_LICENSE_GPL_2_0_ONLY => Self::Gpl20Only, 3199 ffi::GTK_LICENSE_GPL_3_0_ONLY => Self::Gpl30Only, 3200 ffi::GTK_LICENSE_LGPL_2_1_ONLY => Self::Lgpl21Only, 3201 ffi::GTK_LICENSE_LGPL_3_0_ONLY => Self::Lgpl30Only, 3202 ffi::GTK_LICENSE_AGPL_3_0 => Self::Agpl30, 3203 ffi::GTK_LICENSE_AGPL_3_0_ONLY => Self::Agpl30Only, 3204 ffi::GTK_LICENSE_BSD_3 => Self::Bsd3, 3205 ffi::GTK_LICENSE_APACHE_2_0 => Self::Apache20, 3206 ffi::GTK_LICENSE_MPL_2_0 => Self::Mpl20, 3207 value => Self::__Unknown(value), 3208 } 3209 } 3210 } 3211 3212 impl StaticType for License { static_type() -> Type3213 fn static_type() -> Type { 3214 unsafe { from_glib(ffi::gtk_license_get_type()) } 3215 } 3216 } 3217 3218 impl glib::value::ValueType for License { 3219 type Type = Self; 3220 } 3221 3222 unsafe impl<'a> FromValue<'a> for License { 3223 type Checker = glib::value::GenericValueTypeChecker<Self>; 3224 from_value(value: &'a glib::Value) -> Self3225 unsafe fn from_value(value: &'a glib::Value) -> Self { 3226 skip_assert_initialized!(); 3227 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3228 } 3229 } 3230 3231 impl ToValue for License { to_value(&self) -> glib::Value3232 fn to_value(&self) -> glib::Value { 3233 let mut value = glib::Value::for_value_type::<Self>(); 3234 unsafe { 3235 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3236 } 3237 value 3238 } 3239 value_type(&self) -> glib::Type3240 fn value_type(&self) -> glib::Type { 3241 Self::static_type() 3242 } 3243 } 3244 3245 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3246 #[non_exhaustive] 3247 #[doc(alias = "GtkMenuDirectionType")] 3248 pub enum MenuDirectionType { 3249 #[doc(alias = "GTK_MENU_DIR_PARENT")] 3250 Parent, 3251 #[doc(alias = "GTK_MENU_DIR_CHILD")] 3252 Child, 3253 #[doc(alias = "GTK_MENU_DIR_NEXT")] 3254 Next, 3255 #[doc(alias = "GTK_MENU_DIR_PREV")] 3256 Prev, 3257 #[doc(hidden)] 3258 __Unknown(i32), 3259 } 3260 3261 impl fmt::Display for MenuDirectionType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3262 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3263 write!( 3264 f, 3265 "MenuDirectionType::{}", 3266 match *self { 3267 Self::Parent => "Parent", 3268 Self::Child => "Child", 3269 Self::Next => "Next", 3270 Self::Prev => "Prev", 3271 _ => "Unknown", 3272 } 3273 ) 3274 } 3275 } 3276 3277 #[doc(hidden)] 3278 impl IntoGlib for MenuDirectionType { 3279 type GlibType = ffi::GtkMenuDirectionType; 3280 into_glib(self) -> ffi::GtkMenuDirectionType3281 fn into_glib(self) -> ffi::GtkMenuDirectionType { 3282 match self { 3283 Self::Parent => ffi::GTK_MENU_DIR_PARENT, 3284 Self::Child => ffi::GTK_MENU_DIR_CHILD, 3285 Self::Next => ffi::GTK_MENU_DIR_NEXT, 3286 Self::Prev => ffi::GTK_MENU_DIR_PREV, 3287 Self::__Unknown(value) => value, 3288 } 3289 } 3290 } 3291 3292 #[doc(hidden)] 3293 impl FromGlib<ffi::GtkMenuDirectionType> for MenuDirectionType { from_glib(value: ffi::GtkMenuDirectionType) -> Self3294 unsafe fn from_glib(value: ffi::GtkMenuDirectionType) -> Self { 3295 skip_assert_initialized!(); 3296 match value { 3297 ffi::GTK_MENU_DIR_PARENT => Self::Parent, 3298 ffi::GTK_MENU_DIR_CHILD => Self::Child, 3299 ffi::GTK_MENU_DIR_NEXT => Self::Next, 3300 ffi::GTK_MENU_DIR_PREV => Self::Prev, 3301 value => Self::__Unknown(value), 3302 } 3303 } 3304 } 3305 3306 impl StaticType for MenuDirectionType { static_type() -> Type3307 fn static_type() -> Type { 3308 unsafe { from_glib(ffi::gtk_menu_direction_type_get_type()) } 3309 } 3310 } 3311 3312 impl glib::value::ValueType for MenuDirectionType { 3313 type Type = Self; 3314 } 3315 3316 unsafe impl<'a> FromValue<'a> for MenuDirectionType { 3317 type Checker = glib::value::GenericValueTypeChecker<Self>; 3318 from_value(value: &'a glib::Value) -> Self3319 unsafe fn from_value(value: &'a glib::Value) -> Self { 3320 skip_assert_initialized!(); 3321 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3322 } 3323 } 3324 3325 impl ToValue for MenuDirectionType { to_value(&self) -> glib::Value3326 fn to_value(&self) -> glib::Value { 3327 let mut value = glib::Value::for_value_type::<Self>(); 3328 unsafe { 3329 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3330 } 3331 value 3332 } 3333 value_type(&self) -> glib::Type3334 fn value_type(&self) -> glib::Type { 3335 Self::static_type() 3336 } 3337 } 3338 3339 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3340 #[non_exhaustive] 3341 #[doc(alias = "GtkMessageType")] 3342 pub enum MessageType { 3343 #[doc(alias = "GTK_MESSAGE_INFO")] 3344 Info, 3345 #[doc(alias = "GTK_MESSAGE_WARNING")] 3346 Warning, 3347 #[doc(alias = "GTK_MESSAGE_QUESTION")] 3348 Question, 3349 #[doc(alias = "GTK_MESSAGE_ERROR")] 3350 Error, 3351 #[doc(alias = "GTK_MESSAGE_OTHER")] 3352 Other, 3353 #[doc(hidden)] 3354 __Unknown(i32), 3355 } 3356 3357 impl fmt::Display for MessageType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3358 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3359 write!( 3360 f, 3361 "MessageType::{}", 3362 match *self { 3363 Self::Info => "Info", 3364 Self::Warning => "Warning", 3365 Self::Question => "Question", 3366 Self::Error => "Error", 3367 Self::Other => "Other", 3368 _ => "Unknown", 3369 } 3370 ) 3371 } 3372 } 3373 3374 #[doc(hidden)] 3375 impl IntoGlib for MessageType { 3376 type GlibType = ffi::GtkMessageType; 3377 into_glib(self) -> ffi::GtkMessageType3378 fn into_glib(self) -> ffi::GtkMessageType { 3379 match self { 3380 Self::Info => ffi::GTK_MESSAGE_INFO, 3381 Self::Warning => ffi::GTK_MESSAGE_WARNING, 3382 Self::Question => ffi::GTK_MESSAGE_QUESTION, 3383 Self::Error => ffi::GTK_MESSAGE_ERROR, 3384 Self::Other => ffi::GTK_MESSAGE_OTHER, 3385 Self::__Unknown(value) => value, 3386 } 3387 } 3388 } 3389 3390 #[doc(hidden)] 3391 impl FromGlib<ffi::GtkMessageType> for MessageType { from_glib(value: ffi::GtkMessageType) -> Self3392 unsafe fn from_glib(value: ffi::GtkMessageType) -> Self { 3393 skip_assert_initialized!(); 3394 match value { 3395 ffi::GTK_MESSAGE_INFO => Self::Info, 3396 ffi::GTK_MESSAGE_WARNING => Self::Warning, 3397 ffi::GTK_MESSAGE_QUESTION => Self::Question, 3398 ffi::GTK_MESSAGE_ERROR => Self::Error, 3399 ffi::GTK_MESSAGE_OTHER => Self::Other, 3400 value => Self::__Unknown(value), 3401 } 3402 } 3403 } 3404 3405 impl StaticType for MessageType { static_type() -> Type3406 fn static_type() -> Type { 3407 unsafe { from_glib(ffi::gtk_message_type_get_type()) } 3408 } 3409 } 3410 3411 impl glib::value::ValueType for MessageType { 3412 type Type = Self; 3413 } 3414 3415 unsafe impl<'a> FromValue<'a> for MessageType { 3416 type Checker = glib::value::GenericValueTypeChecker<Self>; 3417 from_value(value: &'a glib::Value) -> Self3418 unsafe fn from_value(value: &'a glib::Value) -> Self { 3419 skip_assert_initialized!(); 3420 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3421 } 3422 } 3423 3424 impl ToValue for MessageType { to_value(&self) -> glib::Value3425 fn to_value(&self) -> glib::Value { 3426 let mut value = glib::Value::for_value_type::<Self>(); 3427 unsafe { 3428 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3429 } 3430 value 3431 } 3432 value_type(&self) -> glib::Type3433 fn value_type(&self) -> glib::Type { 3434 Self::static_type() 3435 } 3436 } 3437 3438 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3439 #[non_exhaustive] 3440 #[doc(alias = "GtkMovementStep")] 3441 pub enum MovementStep { 3442 #[doc(alias = "GTK_MOVEMENT_LOGICAL_POSITIONS")] 3443 LogicalPositions, 3444 #[doc(alias = "GTK_MOVEMENT_VISUAL_POSITIONS")] 3445 VisualPositions, 3446 #[doc(alias = "GTK_MOVEMENT_WORDS")] 3447 Words, 3448 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINES")] 3449 DisplayLines, 3450 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINE_ENDS")] 3451 DisplayLineEnds, 3452 #[doc(alias = "GTK_MOVEMENT_PARAGRAPHS")] 3453 Paragraphs, 3454 #[doc(alias = "GTK_MOVEMENT_PARAGRAPH_ENDS")] 3455 ParagraphEnds, 3456 #[doc(alias = "GTK_MOVEMENT_PAGES")] 3457 Pages, 3458 #[doc(alias = "GTK_MOVEMENT_BUFFER_ENDS")] 3459 BufferEnds, 3460 #[doc(alias = "GTK_MOVEMENT_HORIZONTAL_PAGES")] 3461 HorizontalPages, 3462 #[doc(hidden)] 3463 __Unknown(i32), 3464 } 3465 3466 impl fmt::Display for MovementStep { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3467 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3468 write!( 3469 f, 3470 "MovementStep::{}", 3471 match *self { 3472 Self::LogicalPositions => "LogicalPositions", 3473 Self::VisualPositions => "VisualPositions", 3474 Self::Words => "Words", 3475 Self::DisplayLines => "DisplayLines", 3476 Self::DisplayLineEnds => "DisplayLineEnds", 3477 Self::Paragraphs => "Paragraphs", 3478 Self::ParagraphEnds => "ParagraphEnds", 3479 Self::Pages => "Pages", 3480 Self::BufferEnds => "BufferEnds", 3481 Self::HorizontalPages => "HorizontalPages", 3482 _ => "Unknown", 3483 } 3484 ) 3485 } 3486 } 3487 3488 #[doc(hidden)] 3489 impl IntoGlib for MovementStep { 3490 type GlibType = ffi::GtkMovementStep; 3491 into_glib(self) -> ffi::GtkMovementStep3492 fn into_glib(self) -> ffi::GtkMovementStep { 3493 match self { 3494 Self::LogicalPositions => ffi::GTK_MOVEMENT_LOGICAL_POSITIONS, 3495 Self::VisualPositions => ffi::GTK_MOVEMENT_VISUAL_POSITIONS, 3496 Self::Words => ffi::GTK_MOVEMENT_WORDS, 3497 Self::DisplayLines => ffi::GTK_MOVEMENT_DISPLAY_LINES, 3498 Self::DisplayLineEnds => ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS, 3499 Self::Paragraphs => ffi::GTK_MOVEMENT_PARAGRAPHS, 3500 Self::ParagraphEnds => ffi::GTK_MOVEMENT_PARAGRAPH_ENDS, 3501 Self::Pages => ffi::GTK_MOVEMENT_PAGES, 3502 Self::BufferEnds => ffi::GTK_MOVEMENT_BUFFER_ENDS, 3503 Self::HorizontalPages => ffi::GTK_MOVEMENT_HORIZONTAL_PAGES, 3504 Self::__Unknown(value) => value, 3505 } 3506 } 3507 } 3508 3509 #[doc(hidden)] 3510 impl FromGlib<ffi::GtkMovementStep> for MovementStep { from_glib(value: ffi::GtkMovementStep) -> Self3511 unsafe fn from_glib(value: ffi::GtkMovementStep) -> Self { 3512 skip_assert_initialized!(); 3513 match value { 3514 ffi::GTK_MOVEMENT_LOGICAL_POSITIONS => Self::LogicalPositions, 3515 ffi::GTK_MOVEMENT_VISUAL_POSITIONS => Self::VisualPositions, 3516 ffi::GTK_MOVEMENT_WORDS => Self::Words, 3517 ffi::GTK_MOVEMENT_DISPLAY_LINES => Self::DisplayLines, 3518 ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS => Self::DisplayLineEnds, 3519 ffi::GTK_MOVEMENT_PARAGRAPHS => Self::Paragraphs, 3520 ffi::GTK_MOVEMENT_PARAGRAPH_ENDS => Self::ParagraphEnds, 3521 ffi::GTK_MOVEMENT_PAGES => Self::Pages, 3522 ffi::GTK_MOVEMENT_BUFFER_ENDS => Self::BufferEnds, 3523 ffi::GTK_MOVEMENT_HORIZONTAL_PAGES => Self::HorizontalPages, 3524 value => Self::__Unknown(value), 3525 } 3526 } 3527 } 3528 3529 impl StaticType for MovementStep { static_type() -> Type3530 fn static_type() -> Type { 3531 unsafe { from_glib(ffi::gtk_movement_step_get_type()) } 3532 } 3533 } 3534 3535 impl glib::value::ValueType for MovementStep { 3536 type Type = Self; 3537 } 3538 3539 unsafe impl<'a> FromValue<'a> for MovementStep { 3540 type Checker = glib::value::GenericValueTypeChecker<Self>; 3541 from_value(value: &'a glib::Value) -> Self3542 unsafe fn from_value(value: &'a glib::Value) -> Self { 3543 skip_assert_initialized!(); 3544 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3545 } 3546 } 3547 3548 impl ToValue for MovementStep { to_value(&self) -> glib::Value3549 fn to_value(&self) -> glib::Value { 3550 let mut value = glib::Value::for_value_type::<Self>(); 3551 unsafe { 3552 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3553 } 3554 value 3555 } 3556 value_type(&self) -> glib::Type3557 fn value_type(&self) -> glib::Type { 3558 Self::static_type() 3559 } 3560 } 3561 3562 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3563 #[non_exhaustive] 3564 #[doc(alias = "GtkNotebookTab")] 3565 pub enum NotebookTab { 3566 #[doc(alias = "GTK_NOTEBOOK_TAB_FIRST")] 3567 First, 3568 #[doc(alias = "GTK_NOTEBOOK_TAB_LAST")] 3569 Last, 3570 #[doc(hidden)] 3571 __Unknown(i32), 3572 } 3573 3574 impl fmt::Display for NotebookTab { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3575 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3576 write!( 3577 f, 3578 "NotebookTab::{}", 3579 match *self { 3580 Self::First => "First", 3581 Self::Last => "Last", 3582 _ => "Unknown", 3583 } 3584 ) 3585 } 3586 } 3587 3588 #[doc(hidden)] 3589 impl IntoGlib for NotebookTab { 3590 type GlibType = ffi::GtkNotebookTab; 3591 into_glib(self) -> ffi::GtkNotebookTab3592 fn into_glib(self) -> ffi::GtkNotebookTab { 3593 match self { 3594 Self::First => ffi::GTK_NOTEBOOK_TAB_FIRST, 3595 Self::Last => ffi::GTK_NOTEBOOK_TAB_LAST, 3596 Self::__Unknown(value) => value, 3597 } 3598 } 3599 } 3600 3601 #[doc(hidden)] 3602 impl FromGlib<ffi::GtkNotebookTab> for NotebookTab { from_glib(value: ffi::GtkNotebookTab) -> Self3603 unsafe fn from_glib(value: ffi::GtkNotebookTab) -> Self { 3604 skip_assert_initialized!(); 3605 match value { 3606 ffi::GTK_NOTEBOOK_TAB_FIRST => Self::First, 3607 ffi::GTK_NOTEBOOK_TAB_LAST => Self::Last, 3608 value => Self::__Unknown(value), 3609 } 3610 } 3611 } 3612 3613 impl StaticType for NotebookTab { static_type() -> Type3614 fn static_type() -> Type { 3615 unsafe { from_glib(ffi::gtk_notebook_tab_get_type()) } 3616 } 3617 } 3618 3619 impl glib::value::ValueType for NotebookTab { 3620 type Type = Self; 3621 } 3622 3623 unsafe impl<'a> FromValue<'a> for NotebookTab { 3624 type Checker = glib::value::GenericValueTypeChecker<Self>; 3625 from_value(value: &'a glib::Value) -> Self3626 unsafe fn from_value(value: &'a glib::Value) -> Self { 3627 skip_assert_initialized!(); 3628 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3629 } 3630 } 3631 3632 impl ToValue for NotebookTab { to_value(&self) -> glib::Value3633 fn to_value(&self) -> glib::Value { 3634 let mut value = glib::Value::for_value_type::<Self>(); 3635 unsafe { 3636 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3637 } 3638 value 3639 } 3640 value_type(&self) -> glib::Type3641 fn value_type(&self) -> glib::Type { 3642 Self::static_type() 3643 } 3644 } 3645 3646 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3647 #[non_exhaustive] 3648 #[doc(alias = "GtkNumberUpLayout")] 3649 pub enum NumberUpLayout { 3650 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM")] 3651 Lrtb, 3652 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP")] 3653 Lrbt, 3654 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM")] 3655 Rltb, 3656 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP")] 3657 Rlbt, 3658 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT")] 3659 Tblr, 3660 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT")] 3661 Tbrl, 3662 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT")] 3663 Btlr, 3664 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT")] 3665 Btrl, 3666 #[doc(hidden)] 3667 __Unknown(i32), 3668 } 3669 3670 impl fmt::Display for NumberUpLayout { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3671 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3672 write!( 3673 f, 3674 "NumberUpLayout::{}", 3675 match *self { 3676 Self::Lrtb => "Lrtb", 3677 Self::Lrbt => "Lrbt", 3678 Self::Rltb => "Rltb", 3679 Self::Rlbt => "Rlbt", 3680 Self::Tblr => "Tblr", 3681 Self::Tbrl => "Tbrl", 3682 Self::Btlr => "Btlr", 3683 Self::Btrl => "Btrl", 3684 _ => "Unknown", 3685 } 3686 ) 3687 } 3688 } 3689 3690 #[doc(hidden)] 3691 impl IntoGlib for NumberUpLayout { 3692 type GlibType = ffi::GtkNumberUpLayout; 3693 into_glib(self) -> ffi::GtkNumberUpLayout3694 fn into_glib(self) -> ffi::GtkNumberUpLayout { 3695 match self { 3696 Self::Lrtb => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM, 3697 Self::Lrbt => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP, 3698 Self::Rltb => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM, 3699 Self::Rlbt => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP, 3700 Self::Tblr => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT, 3701 Self::Tbrl => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT, 3702 Self::Btlr => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT, 3703 Self::Btrl => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT, 3704 Self::__Unknown(value) => value, 3705 } 3706 } 3707 } 3708 3709 #[doc(hidden)] 3710 impl FromGlib<ffi::GtkNumberUpLayout> for NumberUpLayout { from_glib(value: ffi::GtkNumberUpLayout) -> Self3711 unsafe fn from_glib(value: ffi::GtkNumberUpLayout) -> Self { 3712 skip_assert_initialized!(); 3713 match value { 3714 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM => Self::Lrtb, 3715 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP => Self::Lrbt, 3716 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM => Self::Rltb, 3717 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP => Self::Rlbt, 3718 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT => Self::Tblr, 3719 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT => Self::Tbrl, 3720 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT => Self::Btlr, 3721 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT => Self::Btrl, 3722 value => Self::__Unknown(value), 3723 } 3724 } 3725 } 3726 3727 impl StaticType for NumberUpLayout { static_type() -> Type3728 fn static_type() -> Type { 3729 unsafe { from_glib(ffi::gtk_number_up_layout_get_type()) } 3730 } 3731 } 3732 3733 impl glib::value::ValueType for NumberUpLayout { 3734 type Type = Self; 3735 } 3736 3737 unsafe impl<'a> FromValue<'a> for NumberUpLayout { 3738 type Checker = glib::value::GenericValueTypeChecker<Self>; 3739 from_value(value: &'a glib::Value) -> Self3740 unsafe fn from_value(value: &'a glib::Value) -> Self { 3741 skip_assert_initialized!(); 3742 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3743 } 3744 } 3745 3746 impl ToValue for NumberUpLayout { to_value(&self) -> glib::Value3747 fn to_value(&self) -> glib::Value { 3748 let mut value = glib::Value::for_value_type::<Self>(); 3749 unsafe { 3750 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3751 } 3752 value 3753 } 3754 value_type(&self) -> glib::Type3755 fn value_type(&self) -> glib::Type { 3756 Self::static_type() 3757 } 3758 } 3759 3760 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3761 #[non_exhaustive] 3762 #[doc(alias = "GtkOrientation")] 3763 pub enum Orientation { 3764 #[doc(alias = "GTK_ORIENTATION_HORIZONTAL")] 3765 Horizontal, 3766 #[doc(alias = "GTK_ORIENTATION_VERTICAL")] 3767 Vertical, 3768 #[doc(hidden)] 3769 __Unknown(i32), 3770 } 3771 3772 impl fmt::Display for Orientation { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3773 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3774 write!( 3775 f, 3776 "Orientation::{}", 3777 match *self { 3778 Self::Horizontal => "Horizontal", 3779 Self::Vertical => "Vertical", 3780 _ => "Unknown", 3781 } 3782 ) 3783 } 3784 } 3785 3786 #[doc(hidden)] 3787 impl IntoGlib for Orientation { 3788 type GlibType = ffi::GtkOrientation; 3789 into_glib(self) -> ffi::GtkOrientation3790 fn into_glib(self) -> ffi::GtkOrientation { 3791 match self { 3792 Self::Horizontal => ffi::GTK_ORIENTATION_HORIZONTAL, 3793 Self::Vertical => ffi::GTK_ORIENTATION_VERTICAL, 3794 Self::__Unknown(value) => value, 3795 } 3796 } 3797 } 3798 3799 #[doc(hidden)] 3800 impl FromGlib<ffi::GtkOrientation> for Orientation { from_glib(value: ffi::GtkOrientation) -> Self3801 unsafe fn from_glib(value: ffi::GtkOrientation) -> Self { 3802 skip_assert_initialized!(); 3803 match value { 3804 ffi::GTK_ORIENTATION_HORIZONTAL => Self::Horizontal, 3805 ffi::GTK_ORIENTATION_VERTICAL => Self::Vertical, 3806 value => Self::__Unknown(value), 3807 } 3808 } 3809 } 3810 3811 impl StaticType for Orientation { static_type() -> Type3812 fn static_type() -> Type { 3813 unsafe { from_glib(ffi::gtk_orientation_get_type()) } 3814 } 3815 } 3816 3817 impl glib::value::ValueType for Orientation { 3818 type Type = Self; 3819 } 3820 3821 unsafe impl<'a> FromValue<'a> for Orientation { 3822 type Checker = glib::value::GenericValueTypeChecker<Self>; 3823 from_value(value: &'a glib::Value) -> Self3824 unsafe fn from_value(value: &'a glib::Value) -> Self { 3825 skip_assert_initialized!(); 3826 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3827 } 3828 } 3829 3830 impl ToValue for Orientation { to_value(&self) -> glib::Value3831 fn to_value(&self) -> glib::Value { 3832 let mut value = glib::Value::for_value_type::<Self>(); 3833 unsafe { 3834 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3835 } 3836 value 3837 } 3838 value_type(&self) -> glib::Type3839 fn value_type(&self) -> glib::Type { 3840 Self::static_type() 3841 } 3842 } 3843 3844 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3845 #[non_exhaustive] 3846 #[doc(alias = "GtkPackDirection")] 3847 pub enum PackDirection { 3848 #[doc(alias = "GTK_PACK_DIRECTION_LTR")] 3849 Ltr, 3850 #[doc(alias = "GTK_PACK_DIRECTION_RTL")] 3851 Rtl, 3852 #[doc(alias = "GTK_PACK_DIRECTION_TTB")] 3853 Ttb, 3854 #[doc(alias = "GTK_PACK_DIRECTION_BTT")] 3855 Btt, 3856 #[doc(hidden)] 3857 __Unknown(i32), 3858 } 3859 3860 impl fmt::Display for PackDirection { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3861 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3862 write!( 3863 f, 3864 "PackDirection::{}", 3865 match *self { 3866 Self::Ltr => "Ltr", 3867 Self::Rtl => "Rtl", 3868 Self::Ttb => "Ttb", 3869 Self::Btt => "Btt", 3870 _ => "Unknown", 3871 } 3872 ) 3873 } 3874 } 3875 3876 #[doc(hidden)] 3877 impl IntoGlib for PackDirection { 3878 type GlibType = ffi::GtkPackDirection; 3879 into_glib(self) -> ffi::GtkPackDirection3880 fn into_glib(self) -> ffi::GtkPackDirection { 3881 match self { 3882 Self::Ltr => ffi::GTK_PACK_DIRECTION_LTR, 3883 Self::Rtl => ffi::GTK_PACK_DIRECTION_RTL, 3884 Self::Ttb => ffi::GTK_PACK_DIRECTION_TTB, 3885 Self::Btt => ffi::GTK_PACK_DIRECTION_BTT, 3886 Self::__Unknown(value) => value, 3887 } 3888 } 3889 } 3890 3891 #[doc(hidden)] 3892 impl FromGlib<ffi::GtkPackDirection> for PackDirection { from_glib(value: ffi::GtkPackDirection) -> Self3893 unsafe fn from_glib(value: ffi::GtkPackDirection) -> Self { 3894 skip_assert_initialized!(); 3895 match value { 3896 ffi::GTK_PACK_DIRECTION_LTR => Self::Ltr, 3897 ffi::GTK_PACK_DIRECTION_RTL => Self::Rtl, 3898 ffi::GTK_PACK_DIRECTION_TTB => Self::Ttb, 3899 ffi::GTK_PACK_DIRECTION_BTT => Self::Btt, 3900 value => Self::__Unknown(value), 3901 } 3902 } 3903 } 3904 3905 impl StaticType for PackDirection { static_type() -> Type3906 fn static_type() -> Type { 3907 unsafe { from_glib(ffi::gtk_pack_direction_get_type()) } 3908 } 3909 } 3910 3911 impl glib::value::ValueType for PackDirection { 3912 type Type = Self; 3913 } 3914 3915 unsafe impl<'a> FromValue<'a> for PackDirection { 3916 type Checker = glib::value::GenericValueTypeChecker<Self>; 3917 from_value(value: &'a glib::Value) -> Self3918 unsafe fn from_value(value: &'a glib::Value) -> Self { 3919 skip_assert_initialized!(); 3920 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3921 } 3922 } 3923 3924 impl ToValue for PackDirection { to_value(&self) -> glib::Value3925 fn to_value(&self) -> glib::Value { 3926 let mut value = glib::Value::for_value_type::<Self>(); 3927 unsafe { 3928 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3929 } 3930 value 3931 } 3932 value_type(&self) -> glib::Type3933 fn value_type(&self) -> glib::Type { 3934 Self::static_type() 3935 } 3936 } 3937 3938 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3939 #[non_exhaustive] 3940 #[doc(alias = "GtkPackType")] 3941 pub enum PackType { 3942 #[doc(alias = "GTK_PACK_START")] 3943 Start, 3944 #[doc(alias = "GTK_PACK_END")] 3945 End, 3946 #[doc(hidden)] 3947 __Unknown(i32), 3948 } 3949 3950 impl fmt::Display for PackType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3951 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3952 write!( 3953 f, 3954 "PackType::{}", 3955 match *self { 3956 Self::Start => "Start", 3957 Self::End => "End", 3958 _ => "Unknown", 3959 } 3960 ) 3961 } 3962 } 3963 3964 #[doc(hidden)] 3965 impl IntoGlib for PackType { 3966 type GlibType = ffi::GtkPackType; 3967 into_glib(self) -> ffi::GtkPackType3968 fn into_glib(self) -> ffi::GtkPackType { 3969 match self { 3970 Self::Start => ffi::GTK_PACK_START, 3971 Self::End => ffi::GTK_PACK_END, 3972 Self::__Unknown(value) => value, 3973 } 3974 } 3975 } 3976 3977 #[doc(hidden)] 3978 impl FromGlib<ffi::GtkPackType> for PackType { from_glib(value: ffi::GtkPackType) -> Self3979 unsafe fn from_glib(value: ffi::GtkPackType) -> Self { 3980 skip_assert_initialized!(); 3981 match value { 3982 ffi::GTK_PACK_START => Self::Start, 3983 ffi::GTK_PACK_END => Self::End, 3984 value => Self::__Unknown(value), 3985 } 3986 } 3987 } 3988 3989 impl StaticType for PackType { static_type() -> Type3990 fn static_type() -> Type { 3991 unsafe { from_glib(ffi::gtk_pack_type_get_type()) } 3992 } 3993 } 3994 3995 impl glib::value::ValueType for PackType { 3996 type Type = Self; 3997 } 3998 3999 unsafe impl<'a> FromValue<'a> for PackType { 4000 type Checker = glib::value::GenericValueTypeChecker<Self>; 4001 from_value(value: &'a glib::Value) -> Self4002 unsafe fn from_value(value: &'a glib::Value) -> Self { 4003 skip_assert_initialized!(); 4004 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4005 } 4006 } 4007 4008 impl ToValue for PackType { to_value(&self) -> glib::Value4009 fn to_value(&self) -> glib::Value { 4010 let mut value = glib::Value::for_value_type::<Self>(); 4011 unsafe { 4012 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4013 } 4014 value 4015 } 4016 value_type(&self) -> glib::Type4017 fn value_type(&self) -> glib::Type { 4018 Self::static_type() 4019 } 4020 } 4021 4022 #[cfg(any(feature = "v3_22", feature = "dox"))] 4023 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 4024 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4025 #[non_exhaustive] 4026 #[doc(alias = "GtkPadActionType")] 4027 pub enum PadActionType { 4028 #[doc(alias = "GTK_PAD_ACTION_BUTTON")] 4029 Button, 4030 #[doc(alias = "GTK_PAD_ACTION_RING")] 4031 Ring, 4032 #[doc(alias = "GTK_PAD_ACTION_STRIP")] 4033 Strip, 4034 #[doc(hidden)] 4035 __Unknown(i32), 4036 } 4037 4038 #[cfg(any(feature = "v3_22", feature = "dox"))] 4039 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 4040 impl fmt::Display for PadActionType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4041 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4042 write!( 4043 f, 4044 "PadActionType::{}", 4045 match *self { 4046 Self::Button => "Button", 4047 Self::Ring => "Ring", 4048 Self::Strip => "Strip", 4049 _ => "Unknown", 4050 } 4051 ) 4052 } 4053 } 4054 4055 #[cfg(any(feature = "v3_22", feature = "dox"))] 4056 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 4057 #[doc(hidden)] 4058 impl IntoGlib for PadActionType { 4059 type GlibType = ffi::GtkPadActionType; 4060 into_glib(self) -> ffi::GtkPadActionType4061 fn into_glib(self) -> ffi::GtkPadActionType { 4062 match self { 4063 Self::Button => ffi::GTK_PAD_ACTION_BUTTON, 4064 Self::Ring => ffi::GTK_PAD_ACTION_RING, 4065 Self::Strip => ffi::GTK_PAD_ACTION_STRIP, 4066 Self::__Unknown(value) => value, 4067 } 4068 } 4069 } 4070 4071 #[cfg(any(feature = "v3_22", feature = "dox"))] 4072 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 4073 #[doc(hidden)] 4074 impl FromGlib<ffi::GtkPadActionType> for PadActionType { from_glib(value: ffi::GtkPadActionType) -> Self4075 unsafe fn from_glib(value: ffi::GtkPadActionType) -> Self { 4076 skip_assert_initialized!(); 4077 match value { 4078 ffi::GTK_PAD_ACTION_BUTTON => Self::Button, 4079 ffi::GTK_PAD_ACTION_RING => Self::Ring, 4080 ffi::GTK_PAD_ACTION_STRIP => Self::Strip, 4081 value => Self::__Unknown(value), 4082 } 4083 } 4084 } 4085 4086 #[cfg(any(feature = "v3_22", feature = "dox"))] 4087 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 4088 impl StaticType for PadActionType { static_type() -> Type4089 fn static_type() -> Type { 4090 unsafe { from_glib(ffi::gtk_pad_action_type_get_type()) } 4091 } 4092 } 4093 4094 #[cfg(any(feature = "v3_22", feature = "dox"))] 4095 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 4096 impl glib::value::ValueType for PadActionType { 4097 type Type = Self; 4098 } 4099 4100 #[cfg(any(feature = "v3_22", feature = "dox"))] 4101 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 4102 unsafe impl<'a> FromValue<'a> for PadActionType { 4103 type Checker = glib::value::GenericValueTypeChecker<Self>; 4104 from_value(value: &'a glib::Value) -> Self4105 unsafe fn from_value(value: &'a glib::Value) -> Self { 4106 skip_assert_initialized!(); 4107 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4108 } 4109 } 4110 4111 #[cfg(any(feature = "v3_22", feature = "dox"))] 4112 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 4113 impl ToValue for PadActionType { to_value(&self) -> glib::Value4114 fn to_value(&self) -> glib::Value { 4115 let mut value = glib::Value::for_value_type::<Self>(); 4116 unsafe { 4117 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4118 } 4119 value 4120 } 4121 value_type(&self) -> glib::Type4122 fn value_type(&self) -> glib::Type { 4123 Self::static_type() 4124 } 4125 } 4126 4127 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4128 #[non_exhaustive] 4129 #[doc(alias = "GtkPageOrientation")] 4130 pub enum PageOrientation { 4131 #[doc(alias = "GTK_PAGE_ORIENTATION_PORTRAIT")] 4132 Portrait, 4133 #[doc(alias = "GTK_PAGE_ORIENTATION_LANDSCAPE")] 4134 Landscape, 4135 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT")] 4136 ReversePortrait, 4137 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE")] 4138 ReverseLandscape, 4139 #[doc(hidden)] 4140 __Unknown(i32), 4141 } 4142 4143 impl fmt::Display for PageOrientation { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4144 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4145 write!( 4146 f, 4147 "PageOrientation::{}", 4148 match *self { 4149 Self::Portrait => "Portrait", 4150 Self::Landscape => "Landscape", 4151 Self::ReversePortrait => "ReversePortrait", 4152 Self::ReverseLandscape => "ReverseLandscape", 4153 _ => "Unknown", 4154 } 4155 ) 4156 } 4157 } 4158 4159 #[doc(hidden)] 4160 impl IntoGlib for PageOrientation { 4161 type GlibType = ffi::GtkPageOrientation; 4162 into_glib(self) -> ffi::GtkPageOrientation4163 fn into_glib(self) -> ffi::GtkPageOrientation { 4164 match self { 4165 Self::Portrait => ffi::GTK_PAGE_ORIENTATION_PORTRAIT, 4166 Self::Landscape => ffi::GTK_PAGE_ORIENTATION_LANDSCAPE, 4167 Self::ReversePortrait => ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT, 4168 Self::ReverseLandscape => ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE, 4169 Self::__Unknown(value) => value, 4170 } 4171 } 4172 } 4173 4174 #[doc(hidden)] 4175 impl FromGlib<ffi::GtkPageOrientation> for PageOrientation { from_glib(value: ffi::GtkPageOrientation) -> Self4176 unsafe fn from_glib(value: ffi::GtkPageOrientation) -> Self { 4177 skip_assert_initialized!(); 4178 match value { 4179 ffi::GTK_PAGE_ORIENTATION_PORTRAIT => Self::Portrait, 4180 ffi::GTK_PAGE_ORIENTATION_LANDSCAPE => Self::Landscape, 4181 ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT => Self::ReversePortrait, 4182 ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE => Self::ReverseLandscape, 4183 value => Self::__Unknown(value), 4184 } 4185 } 4186 } 4187 4188 impl StaticType for PageOrientation { static_type() -> Type4189 fn static_type() -> Type { 4190 unsafe { from_glib(ffi::gtk_page_orientation_get_type()) } 4191 } 4192 } 4193 4194 impl glib::value::ValueType for PageOrientation { 4195 type Type = Self; 4196 } 4197 4198 unsafe impl<'a> FromValue<'a> for PageOrientation { 4199 type Checker = glib::value::GenericValueTypeChecker<Self>; 4200 from_value(value: &'a glib::Value) -> Self4201 unsafe fn from_value(value: &'a glib::Value) -> Self { 4202 skip_assert_initialized!(); 4203 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4204 } 4205 } 4206 4207 impl ToValue for PageOrientation { to_value(&self) -> glib::Value4208 fn to_value(&self) -> glib::Value { 4209 let mut value = glib::Value::for_value_type::<Self>(); 4210 unsafe { 4211 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4212 } 4213 value 4214 } 4215 value_type(&self) -> glib::Type4216 fn value_type(&self) -> glib::Type { 4217 Self::static_type() 4218 } 4219 } 4220 4221 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4222 #[non_exhaustive] 4223 #[doc(alias = "GtkPageSet")] 4224 pub enum PageSet { 4225 #[doc(alias = "GTK_PAGE_SET_ALL")] 4226 All, 4227 #[doc(alias = "GTK_PAGE_SET_EVEN")] 4228 Even, 4229 #[doc(alias = "GTK_PAGE_SET_ODD")] 4230 Odd, 4231 #[doc(hidden)] 4232 __Unknown(i32), 4233 } 4234 4235 impl fmt::Display for PageSet { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4236 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4237 write!( 4238 f, 4239 "PageSet::{}", 4240 match *self { 4241 Self::All => "All", 4242 Self::Even => "Even", 4243 Self::Odd => "Odd", 4244 _ => "Unknown", 4245 } 4246 ) 4247 } 4248 } 4249 4250 #[doc(hidden)] 4251 impl IntoGlib for PageSet { 4252 type GlibType = ffi::GtkPageSet; 4253 into_glib(self) -> ffi::GtkPageSet4254 fn into_glib(self) -> ffi::GtkPageSet { 4255 match self { 4256 Self::All => ffi::GTK_PAGE_SET_ALL, 4257 Self::Even => ffi::GTK_PAGE_SET_EVEN, 4258 Self::Odd => ffi::GTK_PAGE_SET_ODD, 4259 Self::__Unknown(value) => value, 4260 } 4261 } 4262 } 4263 4264 #[doc(hidden)] 4265 impl FromGlib<ffi::GtkPageSet> for PageSet { from_glib(value: ffi::GtkPageSet) -> Self4266 unsafe fn from_glib(value: ffi::GtkPageSet) -> Self { 4267 skip_assert_initialized!(); 4268 match value { 4269 ffi::GTK_PAGE_SET_ALL => Self::All, 4270 ffi::GTK_PAGE_SET_EVEN => Self::Even, 4271 ffi::GTK_PAGE_SET_ODD => Self::Odd, 4272 value => Self::__Unknown(value), 4273 } 4274 } 4275 } 4276 4277 impl StaticType for PageSet { static_type() -> Type4278 fn static_type() -> Type { 4279 unsafe { from_glib(ffi::gtk_page_set_get_type()) } 4280 } 4281 } 4282 4283 impl glib::value::ValueType for PageSet { 4284 type Type = Self; 4285 } 4286 4287 unsafe impl<'a> FromValue<'a> for PageSet { 4288 type Checker = glib::value::GenericValueTypeChecker<Self>; 4289 from_value(value: &'a glib::Value) -> Self4290 unsafe fn from_value(value: &'a glib::Value) -> Self { 4291 skip_assert_initialized!(); 4292 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4293 } 4294 } 4295 4296 impl ToValue for PageSet { to_value(&self) -> glib::Value4297 fn to_value(&self) -> glib::Value { 4298 let mut value = glib::Value::for_value_type::<Self>(); 4299 unsafe { 4300 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4301 } 4302 value 4303 } 4304 value_type(&self) -> glib::Type4305 fn value_type(&self) -> glib::Type { 4306 Self::static_type() 4307 } 4308 } 4309 4310 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4311 #[non_exhaustive] 4312 #[doc(alias = "GtkPanDirection")] 4313 pub enum PanDirection { 4314 #[doc(alias = "GTK_PAN_DIRECTION_LEFT")] 4315 Left, 4316 #[doc(alias = "GTK_PAN_DIRECTION_RIGHT")] 4317 Right, 4318 #[doc(alias = "GTK_PAN_DIRECTION_UP")] 4319 Up, 4320 #[doc(alias = "GTK_PAN_DIRECTION_DOWN")] 4321 Down, 4322 #[doc(hidden)] 4323 __Unknown(i32), 4324 } 4325 4326 impl fmt::Display for PanDirection { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4327 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4328 write!( 4329 f, 4330 "PanDirection::{}", 4331 match *self { 4332 Self::Left => "Left", 4333 Self::Right => "Right", 4334 Self::Up => "Up", 4335 Self::Down => "Down", 4336 _ => "Unknown", 4337 } 4338 ) 4339 } 4340 } 4341 4342 #[doc(hidden)] 4343 impl IntoGlib for PanDirection { 4344 type GlibType = ffi::GtkPanDirection; 4345 into_glib(self) -> ffi::GtkPanDirection4346 fn into_glib(self) -> ffi::GtkPanDirection { 4347 match self { 4348 Self::Left => ffi::GTK_PAN_DIRECTION_LEFT, 4349 Self::Right => ffi::GTK_PAN_DIRECTION_RIGHT, 4350 Self::Up => ffi::GTK_PAN_DIRECTION_UP, 4351 Self::Down => ffi::GTK_PAN_DIRECTION_DOWN, 4352 Self::__Unknown(value) => value, 4353 } 4354 } 4355 } 4356 4357 #[doc(hidden)] 4358 impl FromGlib<ffi::GtkPanDirection> for PanDirection { from_glib(value: ffi::GtkPanDirection) -> Self4359 unsafe fn from_glib(value: ffi::GtkPanDirection) -> Self { 4360 skip_assert_initialized!(); 4361 match value { 4362 ffi::GTK_PAN_DIRECTION_LEFT => Self::Left, 4363 ffi::GTK_PAN_DIRECTION_RIGHT => Self::Right, 4364 ffi::GTK_PAN_DIRECTION_UP => Self::Up, 4365 ffi::GTK_PAN_DIRECTION_DOWN => Self::Down, 4366 value => Self::__Unknown(value), 4367 } 4368 } 4369 } 4370 4371 impl StaticType for PanDirection { static_type() -> Type4372 fn static_type() -> Type { 4373 unsafe { from_glib(ffi::gtk_pan_direction_get_type()) } 4374 } 4375 } 4376 4377 impl glib::value::ValueType for PanDirection { 4378 type Type = Self; 4379 } 4380 4381 unsafe impl<'a> FromValue<'a> for PanDirection { 4382 type Checker = glib::value::GenericValueTypeChecker<Self>; 4383 from_value(value: &'a glib::Value) -> Self4384 unsafe fn from_value(value: &'a glib::Value) -> Self { 4385 skip_assert_initialized!(); 4386 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4387 } 4388 } 4389 4390 impl ToValue for PanDirection { to_value(&self) -> glib::Value4391 fn to_value(&self) -> glib::Value { 4392 let mut value = glib::Value::for_value_type::<Self>(); 4393 unsafe { 4394 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4395 } 4396 value 4397 } 4398 value_type(&self) -> glib::Type4399 fn value_type(&self) -> glib::Type { 4400 Self::static_type() 4401 } 4402 } 4403 4404 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4405 #[non_exhaustive] 4406 #[doc(alias = "GtkPolicyType")] 4407 pub enum PolicyType { 4408 #[doc(alias = "GTK_POLICY_ALWAYS")] 4409 Always, 4410 #[doc(alias = "GTK_POLICY_AUTOMATIC")] 4411 Automatic, 4412 #[doc(alias = "GTK_POLICY_NEVER")] 4413 Never, 4414 #[doc(alias = "GTK_POLICY_EXTERNAL")] 4415 External, 4416 #[doc(hidden)] 4417 __Unknown(i32), 4418 } 4419 4420 impl fmt::Display for PolicyType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4421 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4422 write!( 4423 f, 4424 "PolicyType::{}", 4425 match *self { 4426 Self::Always => "Always", 4427 Self::Automatic => "Automatic", 4428 Self::Never => "Never", 4429 Self::External => "External", 4430 _ => "Unknown", 4431 } 4432 ) 4433 } 4434 } 4435 4436 #[doc(hidden)] 4437 impl IntoGlib for PolicyType { 4438 type GlibType = ffi::GtkPolicyType; 4439 into_glib(self) -> ffi::GtkPolicyType4440 fn into_glib(self) -> ffi::GtkPolicyType { 4441 match self { 4442 Self::Always => ffi::GTK_POLICY_ALWAYS, 4443 Self::Automatic => ffi::GTK_POLICY_AUTOMATIC, 4444 Self::Never => ffi::GTK_POLICY_NEVER, 4445 Self::External => ffi::GTK_POLICY_EXTERNAL, 4446 Self::__Unknown(value) => value, 4447 } 4448 } 4449 } 4450 4451 #[doc(hidden)] 4452 impl FromGlib<ffi::GtkPolicyType> for PolicyType { from_glib(value: ffi::GtkPolicyType) -> Self4453 unsafe fn from_glib(value: ffi::GtkPolicyType) -> Self { 4454 skip_assert_initialized!(); 4455 match value { 4456 ffi::GTK_POLICY_ALWAYS => Self::Always, 4457 ffi::GTK_POLICY_AUTOMATIC => Self::Automatic, 4458 ffi::GTK_POLICY_NEVER => Self::Never, 4459 ffi::GTK_POLICY_EXTERNAL => Self::External, 4460 value => Self::__Unknown(value), 4461 } 4462 } 4463 } 4464 4465 impl StaticType for PolicyType { static_type() -> Type4466 fn static_type() -> Type { 4467 unsafe { from_glib(ffi::gtk_policy_type_get_type()) } 4468 } 4469 } 4470 4471 impl glib::value::ValueType for PolicyType { 4472 type Type = Self; 4473 } 4474 4475 unsafe impl<'a> FromValue<'a> for PolicyType { 4476 type Checker = glib::value::GenericValueTypeChecker<Self>; 4477 from_value(value: &'a glib::Value) -> Self4478 unsafe fn from_value(value: &'a glib::Value) -> Self { 4479 skip_assert_initialized!(); 4480 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4481 } 4482 } 4483 4484 impl ToValue for PolicyType { to_value(&self) -> glib::Value4485 fn to_value(&self) -> glib::Value { 4486 let mut value = glib::Value::for_value_type::<Self>(); 4487 unsafe { 4488 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4489 } 4490 value 4491 } 4492 value_type(&self) -> glib::Type4493 fn value_type(&self) -> glib::Type { 4494 Self::static_type() 4495 } 4496 } 4497 4498 #[cfg(any(feature = "v3_20", feature = "dox"))] 4499 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 4500 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4501 #[non_exhaustive] 4502 #[doc(alias = "GtkPopoverConstraint")] 4503 pub enum PopoverConstraint { 4504 #[doc(alias = "GTK_POPOVER_CONSTRAINT_NONE")] 4505 None, 4506 #[doc(alias = "GTK_POPOVER_CONSTRAINT_WINDOW")] 4507 Window, 4508 #[doc(hidden)] 4509 __Unknown(i32), 4510 } 4511 4512 #[cfg(any(feature = "v3_20", feature = "dox"))] 4513 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 4514 impl fmt::Display for PopoverConstraint { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4515 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4516 write!( 4517 f, 4518 "PopoverConstraint::{}", 4519 match *self { 4520 Self::None => "None", 4521 Self::Window => "Window", 4522 _ => "Unknown", 4523 } 4524 ) 4525 } 4526 } 4527 4528 #[cfg(any(feature = "v3_20", feature = "dox"))] 4529 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 4530 #[doc(hidden)] 4531 impl IntoGlib for PopoverConstraint { 4532 type GlibType = ffi::GtkPopoverConstraint; 4533 into_glib(self) -> ffi::GtkPopoverConstraint4534 fn into_glib(self) -> ffi::GtkPopoverConstraint { 4535 match self { 4536 Self::None => ffi::GTK_POPOVER_CONSTRAINT_NONE, 4537 Self::Window => ffi::GTK_POPOVER_CONSTRAINT_WINDOW, 4538 Self::__Unknown(value) => value, 4539 } 4540 } 4541 } 4542 4543 #[cfg(any(feature = "v3_20", feature = "dox"))] 4544 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 4545 #[doc(hidden)] 4546 impl FromGlib<ffi::GtkPopoverConstraint> for PopoverConstraint { from_glib(value: ffi::GtkPopoverConstraint) -> Self4547 unsafe fn from_glib(value: ffi::GtkPopoverConstraint) -> Self { 4548 skip_assert_initialized!(); 4549 match value { 4550 ffi::GTK_POPOVER_CONSTRAINT_NONE => Self::None, 4551 ffi::GTK_POPOVER_CONSTRAINT_WINDOW => Self::Window, 4552 value => Self::__Unknown(value), 4553 } 4554 } 4555 } 4556 4557 #[cfg(any(feature = "v3_20", feature = "dox"))] 4558 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 4559 impl StaticType for PopoverConstraint { static_type() -> Type4560 fn static_type() -> Type { 4561 unsafe { from_glib(ffi::gtk_popover_constraint_get_type()) } 4562 } 4563 } 4564 4565 #[cfg(any(feature = "v3_20", feature = "dox"))] 4566 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 4567 impl glib::value::ValueType for PopoverConstraint { 4568 type Type = Self; 4569 } 4570 4571 #[cfg(any(feature = "v3_20", feature = "dox"))] 4572 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 4573 unsafe impl<'a> FromValue<'a> for PopoverConstraint { 4574 type Checker = glib::value::GenericValueTypeChecker<Self>; 4575 from_value(value: &'a glib::Value) -> Self4576 unsafe fn from_value(value: &'a glib::Value) -> Self { 4577 skip_assert_initialized!(); 4578 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4579 } 4580 } 4581 4582 #[cfg(any(feature = "v3_20", feature = "dox"))] 4583 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 4584 impl ToValue for PopoverConstraint { to_value(&self) -> glib::Value4585 fn to_value(&self) -> glib::Value { 4586 let mut value = glib::Value::for_value_type::<Self>(); 4587 unsafe { 4588 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4589 } 4590 value 4591 } 4592 value_type(&self) -> glib::Type4593 fn value_type(&self) -> glib::Type { 4594 Self::static_type() 4595 } 4596 } 4597 4598 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4599 #[non_exhaustive] 4600 #[doc(alias = "GtkPositionType")] 4601 pub enum PositionType { 4602 #[doc(alias = "GTK_POS_LEFT")] 4603 Left, 4604 #[doc(alias = "GTK_POS_RIGHT")] 4605 Right, 4606 #[doc(alias = "GTK_POS_TOP")] 4607 Top, 4608 #[doc(alias = "GTK_POS_BOTTOM")] 4609 Bottom, 4610 #[doc(hidden)] 4611 __Unknown(i32), 4612 } 4613 4614 impl fmt::Display for PositionType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4615 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4616 write!( 4617 f, 4618 "PositionType::{}", 4619 match *self { 4620 Self::Left => "Left", 4621 Self::Right => "Right", 4622 Self::Top => "Top", 4623 Self::Bottom => "Bottom", 4624 _ => "Unknown", 4625 } 4626 ) 4627 } 4628 } 4629 4630 #[doc(hidden)] 4631 impl IntoGlib for PositionType { 4632 type GlibType = ffi::GtkPositionType; 4633 into_glib(self) -> ffi::GtkPositionType4634 fn into_glib(self) -> ffi::GtkPositionType { 4635 match self { 4636 Self::Left => ffi::GTK_POS_LEFT, 4637 Self::Right => ffi::GTK_POS_RIGHT, 4638 Self::Top => ffi::GTK_POS_TOP, 4639 Self::Bottom => ffi::GTK_POS_BOTTOM, 4640 Self::__Unknown(value) => value, 4641 } 4642 } 4643 } 4644 4645 #[doc(hidden)] 4646 impl FromGlib<ffi::GtkPositionType> for PositionType { from_glib(value: ffi::GtkPositionType) -> Self4647 unsafe fn from_glib(value: ffi::GtkPositionType) -> Self { 4648 skip_assert_initialized!(); 4649 match value { 4650 ffi::GTK_POS_LEFT => Self::Left, 4651 ffi::GTK_POS_RIGHT => Self::Right, 4652 ffi::GTK_POS_TOP => Self::Top, 4653 ffi::GTK_POS_BOTTOM => Self::Bottom, 4654 value => Self::__Unknown(value), 4655 } 4656 } 4657 } 4658 4659 impl StaticType for PositionType { static_type() -> Type4660 fn static_type() -> Type { 4661 unsafe { from_glib(ffi::gtk_position_type_get_type()) } 4662 } 4663 } 4664 4665 impl glib::value::ValueType for PositionType { 4666 type Type = Self; 4667 } 4668 4669 unsafe impl<'a> FromValue<'a> for PositionType { 4670 type Checker = glib::value::GenericValueTypeChecker<Self>; 4671 from_value(value: &'a glib::Value) -> Self4672 unsafe fn from_value(value: &'a glib::Value) -> Self { 4673 skip_assert_initialized!(); 4674 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4675 } 4676 } 4677 4678 impl ToValue for PositionType { to_value(&self) -> glib::Value4679 fn to_value(&self) -> glib::Value { 4680 let mut value = glib::Value::for_value_type::<Self>(); 4681 unsafe { 4682 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4683 } 4684 value 4685 } 4686 value_type(&self) -> glib::Type4687 fn value_type(&self) -> glib::Type { 4688 Self::static_type() 4689 } 4690 } 4691 4692 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4693 #[non_exhaustive] 4694 #[doc(alias = "GtkPrintDuplex")] 4695 pub enum PrintDuplex { 4696 #[doc(alias = "GTK_PRINT_DUPLEX_SIMPLEX")] 4697 Simplex, 4698 #[doc(alias = "GTK_PRINT_DUPLEX_HORIZONTAL")] 4699 Horizontal, 4700 #[doc(alias = "GTK_PRINT_DUPLEX_VERTICAL")] 4701 Vertical, 4702 #[doc(hidden)] 4703 __Unknown(i32), 4704 } 4705 4706 impl fmt::Display for PrintDuplex { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4707 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4708 write!( 4709 f, 4710 "PrintDuplex::{}", 4711 match *self { 4712 Self::Simplex => "Simplex", 4713 Self::Horizontal => "Horizontal", 4714 Self::Vertical => "Vertical", 4715 _ => "Unknown", 4716 } 4717 ) 4718 } 4719 } 4720 4721 #[doc(hidden)] 4722 impl IntoGlib for PrintDuplex { 4723 type GlibType = ffi::GtkPrintDuplex; 4724 into_glib(self) -> ffi::GtkPrintDuplex4725 fn into_glib(self) -> ffi::GtkPrintDuplex { 4726 match self { 4727 Self::Simplex => ffi::GTK_PRINT_DUPLEX_SIMPLEX, 4728 Self::Horizontal => ffi::GTK_PRINT_DUPLEX_HORIZONTAL, 4729 Self::Vertical => ffi::GTK_PRINT_DUPLEX_VERTICAL, 4730 Self::__Unknown(value) => value, 4731 } 4732 } 4733 } 4734 4735 #[doc(hidden)] 4736 impl FromGlib<ffi::GtkPrintDuplex> for PrintDuplex { from_glib(value: ffi::GtkPrintDuplex) -> Self4737 unsafe fn from_glib(value: ffi::GtkPrintDuplex) -> Self { 4738 skip_assert_initialized!(); 4739 match value { 4740 ffi::GTK_PRINT_DUPLEX_SIMPLEX => Self::Simplex, 4741 ffi::GTK_PRINT_DUPLEX_HORIZONTAL => Self::Horizontal, 4742 ffi::GTK_PRINT_DUPLEX_VERTICAL => Self::Vertical, 4743 value => Self::__Unknown(value), 4744 } 4745 } 4746 } 4747 4748 impl StaticType for PrintDuplex { static_type() -> Type4749 fn static_type() -> Type { 4750 unsafe { from_glib(ffi::gtk_print_duplex_get_type()) } 4751 } 4752 } 4753 4754 impl glib::value::ValueType for PrintDuplex { 4755 type Type = Self; 4756 } 4757 4758 unsafe impl<'a> FromValue<'a> for PrintDuplex { 4759 type Checker = glib::value::GenericValueTypeChecker<Self>; 4760 from_value(value: &'a glib::Value) -> Self4761 unsafe fn from_value(value: &'a glib::Value) -> Self { 4762 skip_assert_initialized!(); 4763 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4764 } 4765 } 4766 4767 impl ToValue for PrintDuplex { to_value(&self) -> glib::Value4768 fn to_value(&self) -> glib::Value { 4769 let mut value = glib::Value::for_value_type::<Self>(); 4770 unsafe { 4771 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4772 } 4773 value 4774 } 4775 value_type(&self) -> glib::Type4776 fn value_type(&self) -> glib::Type { 4777 Self::static_type() 4778 } 4779 } 4780 4781 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4782 #[non_exhaustive] 4783 #[doc(alias = "GtkPrintError")] 4784 pub enum PrintError { 4785 #[doc(alias = "GTK_PRINT_ERROR_GENERAL")] 4786 General, 4787 #[doc(alias = "GTK_PRINT_ERROR_INTERNAL_ERROR")] 4788 InternalError, 4789 #[doc(alias = "GTK_PRINT_ERROR_NOMEM")] 4790 Nomem, 4791 #[doc(alias = "GTK_PRINT_ERROR_INVALID_FILE")] 4792 InvalidFile, 4793 #[doc(hidden)] 4794 __Unknown(i32), 4795 } 4796 4797 impl fmt::Display for PrintError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4798 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4799 write!( 4800 f, 4801 "PrintError::{}", 4802 match *self { 4803 Self::General => "General", 4804 Self::InternalError => "InternalError", 4805 Self::Nomem => "Nomem", 4806 Self::InvalidFile => "InvalidFile", 4807 _ => "Unknown", 4808 } 4809 ) 4810 } 4811 } 4812 4813 #[doc(hidden)] 4814 impl IntoGlib for PrintError { 4815 type GlibType = ffi::GtkPrintError; 4816 into_glib(self) -> ffi::GtkPrintError4817 fn into_glib(self) -> ffi::GtkPrintError { 4818 match self { 4819 Self::General => ffi::GTK_PRINT_ERROR_GENERAL, 4820 Self::InternalError => ffi::GTK_PRINT_ERROR_INTERNAL_ERROR, 4821 Self::Nomem => ffi::GTK_PRINT_ERROR_NOMEM, 4822 Self::InvalidFile => ffi::GTK_PRINT_ERROR_INVALID_FILE, 4823 Self::__Unknown(value) => value, 4824 } 4825 } 4826 } 4827 4828 #[doc(hidden)] 4829 impl FromGlib<ffi::GtkPrintError> for PrintError { from_glib(value: ffi::GtkPrintError) -> Self4830 unsafe fn from_glib(value: ffi::GtkPrintError) -> Self { 4831 skip_assert_initialized!(); 4832 match value { 4833 ffi::GTK_PRINT_ERROR_GENERAL => Self::General, 4834 ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => Self::InternalError, 4835 ffi::GTK_PRINT_ERROR_NOMEM => Self::Nomem, 4836 ffi::GTK_PRINT_ERROR_INVALID_FILE => Self::InvalidFile, 4837 value => Self::__Unknown(value), 4838 } 4839 } 4840 } 4841 4842 impl ErrorDomain for PrintError { domain() -> Quark4843 fn domain() -> Quark { 4844 skip_assert_initialized!(); 4845 4846 unsafe { from_glib(ffi::gtk_print_error_quark()) } 4847 } 4848 code(self) -> i324849 fn code(self) -> i32 { 4850 self.into_glib() 4851 } 4852 from(code: i32) -> Option<Self>4853 fn from(code: i32) -> Option<Self> { 4854 skip_assert_initialized!(); 4855 match code { 4856 ffi::GTK_PRINT_ERROR_GENERAL => Some(Self::General), 4857 ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => Some(Self::InternalError), 4858 ffi::GTK_PRINT_ERROR_NOMEM => Some(Self::Nomem), 4859 ffi::GTK_PRINT_ERROR_INVALID_FILE => Some(Self::InvalidFile), 4860 value => Some(Self::__Unknown(value)), 4861 } 4862 } 4863 } 4864 4865 impl StaticType for PrintError { static_type() -> Type4866 fn static_type() -> Type { 4867 unsafe { from_glib(ffi::gtk_print_error_get_type()) } 4868 } 4869 } 4870 4871 impl glib::value::ValueType for PrintError { 4872 type Type = Self; 4873 } 4874 4875 unsafe impl<'a> FromValue<'a> for PrintError { 4876 type Checker = glib::value::GenericValueTypeChecker<Self>; 4877 from_value(value: &'a glib::Value) -> Self4878 unsafe fn from_value(value: &'a glib::Value) -> Self { 4879 skip_assert_initialized!(); 4880 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4881 } 4882 } 4883 4884 impl ToValue for PrintError { to_value(&self) -> glib::Value4885 fn to_value(&self) -> glib::Value { 4886 let mut value = glib::Value::for_value_type::<Self>(); 4887 unsafe { 4888 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4889 } 4890 value 4891 } 4892 value_type(&self) -> glib::Type4893 fn value_type(&self) -> glib::Type { 4894 Self::static_type() 4895 } 4896 } 4897 4898 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4899 #[non_exhaustive] 4900 #[doc(alias = "GtkPrintOperationAction")] 4901 pub enum PrintOperationAction { 4902 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG")] 4903 PrintDialog, 4904 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT")] 4905 Print, 4906 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PREVIEW")] 4907 Preview, 4908 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_EXPORT")] 4909 Export, 4910 #[doc(hidden)] 4911 __Unknown(i32), 4912 } 4913 4914 impl fmt::Display for PrintOperationAction { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result4915 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 4916 write!( 4917 f, 4918 "PrintOperationAction::{}", 4919 match *self { 4920 Self::PrintDialog => "PrintDialog", 4921 Self::Print => "Print", 4922 Self::Preview => "Preview", 4923 Self::Export => "Export", 4924 _ => "Unknown", 4925 } 4926 ) 4927 } 4928 } 4929 4930 #[doc(hidden)] 4931 impl IntoGlib for PrintOperationAction { 4932 type GlibType = ffi::GtkPrintOperationAction; 4933 into_glib(self) -> ffi::GtkPrintOperationAction4934 fn into_glib(self) -> ffi::GtkPrintOperationAction { 4935 match self { 4936 Self::PrintDialog => ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, 4937 Self::Print => ffi::GTK_PRINT_OPERATION_ACTION_PRINT, 4938 Self::Preview => ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW, 4939 Self::Export => ffi::GTK_PRINT_OPERATION_ACTION_EXPORT, 4940 Self::__Unknown(value) => value, 4941 } 4942 } 4943 } 4944 4945 #[doc(hidden)] 4946 impl FromGlib<ffi::GtkPrintOperationAction> for PrintOperationAction { from_glib(value: ffi::GtkPrintOperationAction) -> Self4947 unsafe fn from_glib(value: ffi::GtkPrintOperationAction) -> Self { 4948 skip_assert_initialized!(); 4949 match value { 4950 ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG => Self::PrintDialog, 4951 ffi::GTK_PRINT_OPERATION_ACTION_PRINT => Self::Print, 4952 ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW => Self::Preview, 4953 ffi::GTK_PRINT_OPERATION_ACTION_EXPORT => Self::Export, 4954 value => Self::__Unknown(value), 4955 } 4956 } 4957 } 4958 4959 impl StaticType for PrintOperationAction { static_type() -> Type4960 fn static_type() -> Type { 4961 unsafe { from_glib(ffi::gtk_print_operation_action_get_type()) } 4962 } 4963 } 4964 4965 impl glib::value::ValueType for PrintOperationAction { 4966 type Type = Self; 4967 } 4968 4969 unsafe impl<'a> FromValue<'a> for PrintOperationAction { 4970 type Checker = glib::value::GenericValueTypeChecker<Self>; 4971 from_value(value: &'a glib::Value) -> Self4972 unsafe fn from_value(value: &'a glib::Value) -> Self { 4973 skip_assert_initialized!(); 4974 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 4975 } 4976 } 4977 4978 impl ToValue for PrintOperationAction { to_value(&self) -> glib::Value4979 fn to_value(&self) -> glib::Value { 4980 let mut value = glib::Value::for_value_type::<Self>(); 4981 unsafe { 4982 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 4983 } 4984 value 4985 } 4986 value_type(&self) -> glib::Type4987 fn value_type(&self) -> glib::Type { 4988 Self::static_type() 4989 } 4990 } 4991 4992 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 4993 #[non_exhaustive] 4994 #[doc(alias = "GtkPrintOperationResult")] 4995 pub enum PrintOperationResult { 4996 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_ERROR")] 4997 Error, 4998 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_APPLY")] 4999 Apply, 5000 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_CANCEL")] 5001 Cancel, 5002 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS")] 5003 InProgress, 5004 #[doc(hidden)] 5005 __Unknown(i32), 5006 } 5007 5008 impl fmt::Display for PrintOperationResult { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5009 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5010 write!( 5011 f, 5012 "PrintOperationResult::{}", 5013 match *self { 5014 Self::Error => "Error", 5015 Self::Apply => "Apply", 5016 Self::Cancel => "Cancel", 5017 Self::InProgress => "InProgress", 5018 _ => "Unknown", 5019 } 5020 ) 5021 } 5022 } 5023 5024 #[doc(hidden)] 5025 impl IntoGlib for PrintOperationResult { 5026 type GlibType = ffi::GtkPrintOperationResult; 5027 into_glib(self) -> ffi::GtkPrintOperationResult5028 fn into_glib(self) -> ffi::GtkPrintOperationResult { 5029 match self { 5030 Self::Error => ffi::GTK_PRINT_OPERATION_RESULT_ERROR, 5031 Self::Apply => ffi::GTK_PRINT_OPERATION_RESULT_APPLY, 5032 Self::Cancel => ffi::GTK_PRINT_OPERATION_RESULT_CANCEL, 5033 Self::InProgress => ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS, 5034 Self::__Unknown(value) => value, 5035 } 5036 } 5037 } 5038 5039 #[doc(hidden)] 5040 impl FromGlib<ffi::GtkPrintOperationResult> for PrintOperationResult { from_glib(value: ffi::GtkPrintOperationResult) -> Self5041 unsafe fn from_glib(value: ffi::GtkPrintOperationResult) -> Self { 5042 skip_assert_initialized!(); 5043 match value { 5044 ffi::GTK_PRINT_OPERATION_RESULT_ERROR => Self::Error, 5045 ffi::GTK_PRINT_OPERATION_RESULT_APPLY => Self::Apply, 5046 ffi::GTK_PRINT_OPERATION_RESULT_CANCEL => Self::Cancel, 5047 ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS => Self::InProgress, 5048 value => Self::__Unknown(value), 5049 } 5050 } 5051 } 5052 5053 impl StaticType for PrintOperationResult { static_type() -> Type5054 fn static_type() -> Type { 5055 unsafe { from_glib(ffi::gtk_print_operation_result_get_type()) } 5056 } 5057 } 5058 5059 impl glib::value::ValueType for PrintOperationResult { 5060 type Type = Self; 5061 } 5062 5063 unsafe impl<'a> FromValue<'a> for PrintOperationResult { 5064 type Checker = glib::value::GenericValueTypeChecker<Self>; 5065 from_value(value: &'a glib::Value) -> Self5066 unsafe fn from_value(value: &'a glib::Value) -> Self { 5067 skip_assert_initialized!(); 5068 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5069 } 5070 } 5071 5072 impl ToValue for PrintOperationResult { to_value(&self) -> glib::Value5073 fn to_value(&self) -> glib::Value { 5074 let mut value = glib::Value::for_value_type::<Self>(); 5075 unsafe { 5076 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5077 } 5078 value 5079 } 5080 value_type(&self) -> glib::Type5081 fn value_type(&self) -> glib::Type { 5082 Self::static_type() 5083 } 5084 } 5085 5086 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5087 #[non_exhaustive] 5088 #[doc(alias = "GtkPrintPages")] 5089 pub enum PrintPages { 5090 #[doc(alias = "GTK_PRINT_PAGES_ALL")] 5091 All, 5092 #[doc(alias = "GTK_PRINT_PAGES_CURRENT")] 5093 Current, 5094 #[doc(alias = "GTK_PRINT_PAGES_RANGES")] 5095 Ranges, 5096 #[doc(alias = "GTK_PRINT_PAGES_SELECTION")] 5097 Selection, 5098 #[doc(hidden)] 5099 __Unknown(i32), 5100 } 5101 5102 impl fmt::Display for PrintPages { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5103 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5104 write!( 5105 f, 5106 "PrintPages::{}", 5107 match *self { 5108 Self::All => "All", 5109 Self::Current => "Current", 5110 Self::Ranges => "Ranges", 5111 Self::Selection => "Selection", 5112 _ => "Unknown", 5113 } 5114 ) 5115 } 5116 } 5117 5118 #[doc(hidden)] 5119 impl IntoGlib for PrintPages { 5120 type GlibType = ffi::GtkPrintPages; 5121 into_glib(self) -> ffi::GtkPrintPages5122 fn into_glib(self) -> ffi::GtkPrintPages { 5123 match self { 5124 Self::All => ffi::GTK_PRINT_PAGES_ALL, 5125 Self::Current => ffi::GTK_PRINT_PAGES_CURRENT, 5126 Self::Ranges => ffi::GTK_PRINT_PAGES_RANGES, 5127 Self::Selection => ffi::GTK_PRINT_PAGES_SELECTION, 5128 Self::__Unknown(value) => value, 5129 } 5130 } 5131 } 5132 5133 #[doc(hidden)] 5134 impl FromGlib<ffi::GtkPrintPages> for PrintPages { from_glib(value: ffi::GtkPrintPages) -> Self5135 unsafe fn from_glib(value: ffi::GtkPrintPages) -> Self { 5136 skip_assert_initialized!(); 5137 match value { 5138 ffi::GTK_PRINT_PAGES_ALL => Self::All, 5139 ffi::GTK_PRINT_PAGES_CURRENT => Self::Current, 5140 ffi::GTK_PRINT_PAGES_RANGES => Self::Ranges, 5141 ffi::GTK_PRINT_PAGES_SELECTION => Self::Selection, 5142 value => Self::__Unknown(value), 5143 } 5144 } 5145 } 5146 5147 impl StaticType for PrintPages { static_type() -> Type5148 fn static_type() -> Type { 5149 unsafe { from_glib(ffi::gtk_print_pages_get_type()) } 5150 } 5151 } 5152 5153 impl glib::value::ValueType for PrintPages { 5154 type Type = Self; 5155 } 5156 5157 unsafe impl<'a> FromValue<'a> for PrintPages { 5158 type Checker = glib::value::GenericValueTypeChecker<Self>; 5159 from_value(value: &'a glib::Value) -> Self5160 unsafe fn from_value(value: &'a glib::Value) -> Self { 5161 skip_assert_initialized!(); 5162 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5163 } 5164 } 5165 5166 impl ToValue for PrintPages { to_value(&self) -> glib::Value5167 fn to_value(&self) -> glib::Value { 5168 let mut value = glib::Value::for_value_type::<Self>(); 5169 unsafe { 5170 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5171 } 5172 value 5173 } 5174 value_type(&self) -> glib::Type5175 fn value_type(&self) -> glib::Type { 5176 Self::static_type() 5177 } 5178 } 5179 5180 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5181 #[non_exhaustive] 5182 #[doc(alias = "GtkPrintQuality")] 5183 pub enum PrintQuality { 5184 #[doc(alias = "GTK_PRINT_QUALITY_LOW")] 5185 Low, 5186 #[doc(alias = "GTK_PRINT_QUALITY_NORMAL")] 5187 Normal, 5188 #[doc(alias = "GTK_PRINT_QUALITY_HIGH")] 5189 High, 5190 #[doc(alias = "GTK_PRINT_QUALITY_DRAFT")] 5191 Draft, 5192 #[doc(hidden)] 5193 __Unknown(i32), 5194 } 5195 5196 impl fmt::Display for PrintQuality { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5197 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5198 write!( 5199 f, 5200 "PrintQuality::{}", 5201 match *self { 5202 Self::Low => "Low", 5203 Self::Normal => "Normal", 5204 Self::High => "High", 5205 Self::Draft => "Draft", 5206 _ => "Unknown", 5207 } 5208 ) 5209 } 5210 } 5211 5212 #[doc(hidden)] 5213 impl IntoGlib for PrintQuality { 5214 type GlibType = ffi::GtkPrintQuality; 5215 into_glib(self) -> ffi::GtkPrintQuality5216 fn into_glib(self) -> ffi::GtkPrintQuality { 5217 match self { 5218 Self::Low => ffi::GTK_PRINT_QUALITY_LOW, 5219 Self::Normal => ffi::GTK_PRINT_QUALITY_NORMAL, 5220 Self::High => ffi::GTK_PRINT_QUALITY_HIGH, 5221 Self::Draft => ffi::GTK_PRINT_QUALITY_DRAFT, 5222 Self::__Unknown(value) => value, 5223 } 5224 } 5225 } 5226 5227 #[doc(hidden)] 5228 impl FromGlib<ffi::GtkPrintQuality> for PrintQuality { from_glib(value: ffi::GtkPrintQuality) -> Self5229 unsafe fn from_glib(value: ffi::GtkPrintQuality) -> Self { 5230 skip_assert_initialized!(); 5231 match value { 5232 ffi::GTK_PRINT_QUALITY_LOW => Self::Low, 5233 ffi::GTK_PRINT_QUALITY_NORMAL => Self::Normal, 5234 ffi::GTK_PRINT_QUALITY_HIGH => Self::High, 5235 ffi::GTK_PRINT_QUALITY_DRAFT => Self::Draft, 5236 value => Self::__Unknown(value), 5237 } 5238 } 5239 } 5240 5241 impl StaticType for PrintQuality { static_type() -> Type5242 fn static_type() -> Type { 5243 unsafe { from_glib(ffi::gtk_print_quality_get_type()) } 5244 } 5245 } 5246 5247 impl glib::value::ValueType for PrintQuality { 5248 type Type = Self; 5249 } 5250 5251 unsafe impl<'a> FromValue<'a> for PrintQuality { 5252 type Checker = glib::value::GenericValueTypeChecker<Self>; 5253 from_value(value: &'a glib::Value) -> Self5254 unsafe fn from_value(value: &'a glib::Value) -> Self { 5255 skip_assert_initialized!(); 5256 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5257 } 5258 } 5259 5260 impl ToValue for PrintQuality { to_value(&self) -> glib::Value5261 fn to_value(&self) -> glib::Value { 5262 let mut value = glib::Value::for_value_type::<Self>(); 5263 unsafe { 5264 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5265 } 5266 value 5267 } 5268 value_type(&self) -> glib::Type5269 fn value_type(&self) -> glib::Type { 5270 Self::static_type() 5271 } 5272 } 5273 5274 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5275 #[non_exhaustive] 5276 #[doc(alias = "GtkPrintStatus")] 5277 pub enum PrintStatus { 5278 #[doc(alias = "GTK_PRINT_STATUS_INITIAL")] 5279 Initial, 5280 #[doc(alias = "GTK_PRINT_STATUS_PREPARING")] 5281 Preparing, 5282 #[doc(alias = "GTK_PRINT_STATUS_GENERATING_DATA")] 5283 GeneratingData, 5284 #[doc(alias = "GTK_PRINT_STATUS_SENDING_DATA")] 5285 SendingData, 5286 #[doc(alias = "GTK_PRINT_STATUS_PENDING")] 5287 Pending, 5288 #[doc(alias = "GTK_PRINT_STATUS_PENDING_ISSUE")] 5289 PendingIssue, 5290 #[doc(alias = "GTK_PRINT_STATUS_PRINTING")] 5291 Printing, 5292 #[doc(alias = "GTK_PRINT_STATUS_FINISHED")] 5293 Finished, 5294 #[doc(alias = "GTK_PRINT_STATUS_FINISHED_ABORTED")] 5295 FinishedAborted, 5296 #[doc(hidden)] 5297 __Unknown(i32), 5298 } 5299 5300 impl fmt::Display for PrintStatus { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5301 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5302 write!( 5303 f, 5304 "PrintStatus::{}", 5305 match *self { 5306 Self::Initial => "Initial", 5307 Self::Preparing => "Preparing", 5308 Self::GeneratingData => "GeneratingData", 5309 Self::SendingData => "SendingData", 5310 Self::Pending => "Pending", 5311 Self::PendingIssue => "PendingIssue", 5312 Self::Printing => "Printing", 5313 Self::Finished => "Finished", 5314 Self::FinishedAborted => "FinishedAborted", 5315 _ => "Unknown", 5316 } 5317 ) 5318 } 5319 } 5320 5321 #[doc(hidden)] 5322 impl IntoGlib for PrintStatus { 5323 type GlibType = ffi::GtkPrintStatus; 5324 into_glib(self) -> ffi::GtkPrintStatus5325 fn into_glib(self) -> ffi::GtkPrintStatus { 5326 match self { 5327 Self::Initial => ffi::GTK_PRINT_STATUS_INITIAL, 5328 Self::Preparing => ffi::GTK_PRINT_STATUS_PREPARING, 5329 Self::GeneratingData => ffi::GTK_PRINT_STATUS_GENERATING_DATA, 5330 Self::SendingData => ffi::GTK_PRINT_STATUS_SENDING_DATA, 5331 Self::Pending => ffi::GTK_PRINT_STATUS_PENDING, 5332 Self::PendingIssue => ffi::GTK_PRINT_STATUS_PENDING_ISSUE, 5333 Self::Printing => ffi::GTK_PRINT_STATUS_PRINTING, 5334 Self::Finished => ffi::GTK_PRINT_STATUS_FINISHED, 5335 Self::FinishedAborted => ffi::GTK_PRINT_STATUS_FINISHED_ABORTED, 5336 Self::__Unknown(value) => value, 5337 } 5338 } 5339 } 5340 5341 #[doc(hidden)] 5342 impl FromGlib<ffi::GtkPrintStatus> for PrintStatus { from_glib(value: ffi::GtkPrintStatus) -> Self5343 unsafe fn from_glib(value: ffi::GtkPrintStatus) -> Self { 5344 skip_assert_initialized!(); 5345 match value { 5346 ffi::GTK_PRINT_STATUS_INITIAL => Self::Initial, 5347 ffi::GTK_PRINT_STATUS_PREPARING => Self::Preparing, 5348 ffi::GTK_PRINT_STATUS_GENERATING_DATA => Self::GeneratingData, 5349 ffi::GTK_PRINT_STATUS_SENDING_DATA => Self::SendingData, 5350 ffi::GTK_PRINT_STATUS_PENDING => Self::Pending, 5351 ffi::GTK_PRINT_STATUS_PENDING_ISSUE => Self::PendingIssue, 5352 ffi::GTK_PRINT_STATUS_PRINTING => Self::Printing, 5353 ffi::GTK_PRINT_STATUS_FINISHED => Self::Finished, 5354 ffi::GTK_PRINT_STATUS_FINISHED_ABORTED => Self::FinishedAborted, 5355 value => Self::__Unknown(value), 5356 } 5357 } 5358 } 5359 5360 impl StaticType for PrintStatus { static_type() -> Type5361 fn static_type() -> Type { 5362 unsafe { from_glib(ffi::gtk_print_status_get_type()) } 5363 } 5364 } 5365 5366 impl glib::value::ValueType for PrintStatus { 5367 type Type = Self; 5368 } 5369 5370 unsafe impl<'a> FromValue<'a> for PrintStatus { 5371 type Checker = glib::value::GenericValueTypeChecker<Self>; 5372 from_value(value: &'a glib::Value) -> Self5373 unsafe fn from_value(value: &'a glib::Value) -> Self { 5374 skip_assert_initialized!(); 5375 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5376 } 5377 } 5378 5379 impl ToValue for PrintStatus { to_value(&self) -> glib::Value5380 fn to_value(&self) -> glib::Value { 5381 let mut value = glib::Value::for_value_type::<Self>(); 5382 unsafe { 5383 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5384 } 5385 value 5386 } 5387 value_type(&self) -> glib::Type5388 fn value_type(&self) -> glib::Type { 5389 Self::static_type() 5390 } 5391 } 5392 5393 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5394 #[non_exhaustive] 5395 #[doc(alias = "GtkPropagationPhase")] 5396 pub enum PropagationPhase { 5397 #[doc(alias = "GTK_PHASE_NONE")] 5398 None, 5399 #[doc(alias = "GTK_PHASE_CAPTURE")] 5400 Capture, 5401 #[doc(alias = "GTK_PHASE_BUBBLE")] 5402 Bubble, 5403 #[doc(alias = "GTK_PHASE_TARGET")] 5404 Target, 5405 #[doc(hidden)] 5406 __Unknown(i32), 5407 } 5408 5409 impl fmt::Display for PropagationPhase { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5410 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5411 write!( 5412 f, 5413 "PropagationPhase::{}", 5414 match *self { 5415 Self::None => "None", 5416 Self::Capture => "Capture", 5417 Self::Bubble => "Bubble", 5418 Self::Target => "Target", 5419 _ => "Unknown", 5420 } 5421 ) 5422 } 5423 } 5424 5425 #[doc(hidden)] 5426 impl IntoGlib for PropagationPhase { 5427 type GlibType = ffi::GtkPropagationPhase; 5428 into_glib(self) -> ffi::GtkPropagationPhase5429 fn into_glib(self) -> ffi::GtkPropagationPhase { 5430 match self { 5431 Self::None => ffi::GTK_PHASE_NONE, 5432 Self::Capture => ffi::GTK_PHASE_CAPTURE, 5433 Self::Bubble => ffi::GTK_PHASE_BUBBLE, 5434 Self::Target => ffi::GTK_PHASE_TARGET, 5435 Self::__Unknown(value) => value, 5436 } 5437 } 5438 } 5439 5440 #[doc(hidden)] 5441 impl FromGlib<ffi::GtkPropagationPhase> for PropagationPhase { from_glib(value: ffi::GtkPropagationPhase) -> Self5442 unsafe fn from_glib(value: ffi::GtkPropagationPhase) -> Self { 5443 skip_assert_initialized!(); 5444 match value { 5445 ffi::GTK_PHASE_NONE => Self::None, 5446 ffi::GTK_PHASE_CAPTURE => Self::Capture, 5447 ffi::GTK_PHASE_BUBBLE => Self::Bubble, 5448 ffi::GTK_PHASE_TARGET => Self::Target, 5449 value => Self::__Unknown(value), 5450 } 5451 } 5452 } 5453 5454 impl StaticType for PropagationPhase { static_type() -> Type5455 fn static_type() -> Type { 5456 unsafe { from_glib(ffi::gtk_propagation_phase_get_type()) } 5457 } 5458 } 5459 5460 impl glib::value::ValueType for PropagationPhase { 5461 type Type = Self; 5462 } 5463 5464 unsafe impl<'a> FromValue<'a> for PropagationPhase { 5465 type Checker = glib::value::GenericValueTypeChecker<Self>; 5466 from_value(value: &'a glib::Value) -> Self5467 unsafe fn from_value(value: &'a glib::Value) -> Self { 5468 skip_assert_initialized!(); 5469 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5470 } 5471 } 5472 5473 impl ToValue for PropagationPhase { to_value(&self) -> glib::Value5474 fn to_value(&self) -> glib::Value { 5475 let mut value = glib::Value::for_value_type::<Self>(); 5476 unsafe { 5477 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5478 } 5479 value 5480 } 5481 value_type(&self) -> glib::Type5482 fn value_type(&self) -> glib::Type { 5483 Self::static_type() 5484 } 5485 } 5486 5487 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5488 #[non_exhaustive] 5489 #[doc(alias = "GtkRecentChooserError")] 5490 pub enum RecentChooserError { 5491 #[doc(alias = "GTK_RECENT_CHOOSER_ERROR_NOT_FOUND")] 5492 NotFound, 5493 #[doc(alias = "GTK_RECENT_CHOOSER_ERROR_INVALID_URI")] 5494 InvalidUri, 5495 #[doc(hidden)] 5496 __Unknown(i32), 5497 } 5498 5499 impl fmt::Display for RecentChooserError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5500 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5501 write!( 5502 f, 5503 "RecentChooserError::{}", 5504 match *self { 5505 Self::NotFound => "NotFound", 5506 Self::InvalidUri => "InvalidUri", 5507 _ => "Unknown", 5508 } 5509 ) 5510 } 5511 } 5512 5513 #[doc(hidden)] 5514 impl IntoGlib for RecentChooserError { 5515 type GlibType = ffi::GtkRecentChooserError; 5516 into_glib(self) -> ffi::GtkRecentChooserError5517 fn into_glib(self) -> ffi::GtkRecentChooserError { 5518 match self { 5519 Self::NotFound => ffi::GTK_RECENT_CHOOSER_ERROR_NOT_FOUND, 5520 Self::InvalidUri => ffi::GTK_RECENT_CHOOSER_ERROR_INVALID_URI, 5521 Self::__Unknown(value) => value, 5522 } 5523 } 5524 } 5525 5526 #[doc(hidden)] 5527 impl FromGlib<ffi::GtkRecentChooserError> for RecentChooserError { from_glib(value: ffi::GtkRecentChooserError) -> Self5528 unsafe fn from_glib(value: ffi::GtkRecentChooserError) -> Self { 5529 skip_assert_initialized!(); 5530 match value { 5531 ffi::GTK_RECENT_CHOOSER_ERROR_NOT_FOUND => Self::NotFound, 5532 ffi::GTK_RECENT_CHOOSER_ERROR_INVALID_URI => Self::InvalidUri, 5533 value => Self::__Unknown(value), 5534 } 5535 } 5536 } 5537 5538 impl ErrorDomain for RecentChooserError { domain() -> Quark5539 fn domain() -> Quark { 5540 skip_assert_initialized!(); 5541 5542 unsafe { from_glib(ffi::gtk_recent_chooser_error_quark()) } 5543 } 5544 code(self) -> i325545 fn code(self) -> i32 { 5546 self.into_glib() 5547 } 5548 from(code: i32) -> Option<Self>5549 fn from(code: i32) -> Option<Self> { 5550 skip_assert_initialized!(); 5551 match code { 5552 ffi::GTK_RECENT_CHOOSER_ERROR_NOT_FOUND => Some(Self::NotFound), 5553 ffi::GTK_RECENT_CHOOSER_ERROR_INVALID_URI => Some(Self::InvalidUri), 5554 value => Some(Self::__Unknown(value)), 5555 } 5556 } 5557 } 5558 5559 impl StaticType for RecentChooserError { static_type() -> Type5560 fn static_type() -> Type { 5561 unsafe { from_glib(ffi::gtk_recent_chooser_error_get_type()) } 5562 } 5563 } 5564 5565 impl glib::value::ValueType for RecentChooserError { 5566 type Type = Self; 5567 } 5568 5569 unsafe impl<'a> FromValue<'a> for RecentChooserError { 5570 type Checker = glib::value::GenericValueTypeChecker<Self>; 5571 from_value(value: &'a glib::Value) -> Self5572 unsafe fn from_value(value: &'a glib::Value) -> Self { 5573 skip_assert_initialized!(); 5574 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5575 } 5576 } 5577 5578 impl ToValue for RecentChooserError { to_value(&self) -> glib::Value5579 fn to_value(&self) -> glib::Value { 5580 let mut value = glib::Value::for_value_type::<Self>(); 5581 unsafe { 5582 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5583 } 5584 value 5585 } 5586 value_type(&self) -> glib::Type5587 fn value_type(&self) -> glib::Type { 5588 Self::static_type() 5589 } 5590 } 5591 5592 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5593 #[non_exhaustive] 5594 #[doc(alias = "GtkRecentManagerError")] 5595 pub enum RecentManagerError { 5596 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_FOUND")] 5597 NotFound, 5598 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_URI")] 5599 InvalidUri, 5600 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING")] 5601 InvalidEncoding, 5602 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED")] 5603 NotRegistered, 5604 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_READ")] 5605 Read, 5606 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_WRITE")] 5607 Write, 5608 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_UNKNOWN")] 5609 Unknown, 5610 #[doc(hidden)] 5611 __Unknown(i32), 5612 } 5613 5614 impl fmt::Display for RecentManagerError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5615 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5616 write!( 5617 f, 5618 "RecentManagerError::{}", 5619 match *self { 5620 Self::NotFound => "NotFound", 5621 Self::InvalidUri => "InvalidUri", 5622 Self::InvalidEncoding => "InvalidEncoding", 5623 Self::NotRegistered => "NotRegistered", 5624 Self::Read => "Read", 5625 Self::Write => "Write", 5626 Self::Unknown => "Unknown", 5627 _ => "Unknown", 5628 } 5629 ) 5630 } 5631 } 5632 5633 #[doc(hidden)] 5634 impl IntoGlib for RecentManagerError { 5635 type GlibType = ffi::GtkRecentManagerError; 5636 into_glib(self) -> ffi::GtkRecentManagerError5637 fn into_glib(self) -> ffi::GtkRecentManagerError { 5638 match self { 5639 Self::NotFound => ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND, 5640 Self::InvalidUri => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI, 5641 Self::InvalidEncoding => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING, 5642 Self::NotRegistered => ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED, 5643 Self::Read => ffi::GTK_RECENT_MANAGER_ERROR_READ, 5644 Self::Write => ffi::GTK_RECENT_MANAGER_ERROR_WRITE, 5645 Self::Unknown => ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN, 5646 Self::__Unknown(value) => value, 5647 } 5648 } 5649 } 5650 5651 #[doc(hidden)] 5652 impl FromGlib<ffi::GtkRecentManagerError> for RecentManagerError { from_glib(value: ffi::GtkRecentManagerError) -> Self5653 unsafe fn from_glib(value: ffi::GtkRecentManagerError) -> Self { 5654 skip_assert_initialized!(); 5655 match value { 5656 ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => Self::NotFound, 5657 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => Self::InvalidUri, 5658 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => Self::InvalidEncoding, 5659 ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => Self::NotRegistered, 5660 ffi::GTK_RECENT_MANAGER_ERROR_READ => Self::Read, 5661 ffi::GTK_RECENT_MANAGER_ERROR_WRITE => Self::Write, 5662 ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => Self::Unknown, 5663 value => Self::__Unknown(value), 5664 } 5665 } 5666 } 5667 5668 impl ErrorDomain for RecentManagerError { domain() -> Quark5669 fn domain() -> Quark { 5670 skip_assert_initialized!(); 5671 5672 unsafe { from_glib(ffi::gtk_recent_manager_error_quark()) } 5673 } 5674 code(self) -> i325675 fn code(self) -> i32 { 5676 self.into_glib() 5677 } 5678 from(code: i32) -> Option<Self>5679 fn from(code: i32) -> Option<Self> { 5680 skip_assert_initialized!(); 5681 match code { 5682 ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => Some(Self::NotFound), 5683 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => Some(Self::InvalidUri), 5684 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => Some(Self::InvalidEncoding), 5685 ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => Some(Self::NotRegistered), 5686 ffi::GTK_RECENT_MANAGER_ERROR_READ => Some(Self::Read), 5687 ffi::GTK_RECENT_MANAGER_ERROR_WRITE => Some(Self::Write), 5688 ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => Some(Self::Unknown), 5689 value => Some(Self::__Unknown(value)), 5690 } 5691 } 5692 } 5693 5694 impl StaticType for RecentManagerError { static_type() -> Type5695 fn static_type() -> Type { 5696 unsafe { from_glib(ffi::gtk_recent_manager_error_get_type()) } 5697 } 5698 } 5699 5700 impl glib::value::ValueType for RecentManagerError { 5701 type Type = Self; 5702 } 5703 5704 unsafe impl<'a> FromValue<'a> for RecentManagerError { 5705 type Checker = glib::value::GenericValueTypeChecker<Self>; 5706 from_value(value: &'a glib::Value) -> Self5707 unsafe fn from_value(value: &'a glib::Value) -> Self { 5708 skip_assert_initialized!(); 5709 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5710 } 5711 } 5712 5713 impl ToValue for RecentManagerError { to_value(&self) -> glib::Value5714 fn to_value(&self) -> glib::Value { 5715 let mut value = glib::Value::for_value_type::<Self>(); 5716 unsafe { 5717 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5718 } 5719 value 5720 } 5721 value_type(&self) -> glib::Type5722 fn value_type(&self) -> glib::Type { 5723 Self::static_type() 5724 } 5725 } 5726 5727 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5728 #[non_exhaustive] 5729 #[doc(alias = "GtkRecentSortType")] 5730 pub enum RecentSortType { 5731 #[doc(alias = "GTK_RECENT_SORT_NONE")] 5732 None, 5733 #[doc(alias = "GTK_RECENT_SORT_MRU")] 5734 Mru, 5735 #[doc(alias = "GTK_RECENT_SORT_LRU")] 5736 Lru, 5737 #[doc(alias = "GTK_RECENT_SORT_CUSTOM")] 5738 Custom, 5739 #[doc(hidden)] 5740 __Unknown(i32), 5741 } 5742 5743 impl fmt::Display for RecentSortType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5744 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5745 write!( 5746 f, 5747 "RecentSortType::{}", 5748 match *self { 5749 Self::None => "None", 5750 Self::Mru => "Mru", 5751 Self::Lru => "Lru", 5752 Self::Custom => "Custom", 5753 _ => "Unknown", 5754 } 5755 ) 5756 } 5757 } 5758 5759 #[doc(hidden)] 5760 impl IntoGlib for RecentSortType { 5761 type GlibType = ffi::GtkRecentSortType; 5762 into_glib(self) -> ffi::GtkRecentSortType5763 fn into_glib(self) -> ffi::GtkRecentSortType { 5764 match self { 5765 Self::None => ffi::GTK_RECENT_SORT_NONE, 5766 Self::Mru => ffi::GTK_RECENT_SORT_MRU, 5767 Self::Lru => ffi::GTK_RECENT_SORT_LRU, 5768 Self::Custom => ffi::GTK_RECENT_SORT_CUSTOM, 5769 Self::__Unknown(value) => value, 5770 } 5771 } 5772 } 5773 5774 #[doc(hidden)] 5775 impl FromGlib<ffi::GtkRecentSortType> for RecentSortType { from_glib(value: ffi::GtkRecentSortType) -> Self5776 unsafe fn from_glib(value: ffi::GtkRecentSortType) -> Self { 5777 skip_assert_initialized!(); 5778 match value { 5779 ffi::GTK_RECENT_SORT_NONE => Self::None, 5780 ffi::GTK_RECENT_SORT_MRU => Self::Mru, 5781 ffi::GTK_RECENT_SORT_LRU => Self::Lru, 5782 ffi::GTK_RECENT_SORT_CUSTOM => Self::Custom, 5783 value => Self::__Unknown(value), 5784 } 5785 } 5786 } 5787 5788 impl StaticType for RecentSortType { static_type() -> Type5789 fn static_type() -> Type { 5790 unsafe { from_glib(ffi::gtk_recent_sort_type_get_type()) } 5791 } 5792 } 5793 5794 impl glib::value::ValueType for RecentSortType { 5795 type Type = Self; 5796 } 5797 5798 unsafe impl<'a> FromValue<'a> for RecentSortType { 5799 type Checker = glib::value::GenericValueTypeChecker<Self>; 5800 from_value(value: &'a glib::Value) -> Self5801 unsafe fn from_value(value: &'a glib::Value) -> Self { 5802 skip_assert_initialized!(); 5803 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5804 } 5805 } 5806 5807 impl ToValue for RecentSortType { to_value(&self) -> glib::Value5808 fn to_value(&self) -> glib::Value { 5809 let mut value = glib::Value::for_value_type::<Self>(); 5810 unsafe { 5811 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5812 } 5813 value 5814 } 5815 value_type(&self) -> glib::Type5816 fn value_type(&self) -> glib::Type { 5817 Self::static_type() 5818 } 5819 } 5820 5821 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5822 #[non_exhaustive] 5823 #[doc(alias = "GtkReliefStyle")] 5824 pub enum ReliefStyle { 5825 #[doc(alias = "GTK_RELIEF_NORMAL")] 5826 Normal, 5827 #[doc(alias = "GTK_RELIEF_HALF")] 5828 Half, 5829 #[doc(alias = "GTK_RELIEF_NONE")] 5830 None, 5831 #[doc(hidden)] 5832 __Unknown(i32), 5833 } 5834 5835 impl fmt::Display for ReliefStyle { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5836 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5837 write!( 5838 f, 5839 "ReliefStyle::{}", 5840 match *self { 5841 Self::Normal => "Normal", 5842 Self::Half => "Half", 5843 Self::None => "None", 5844 _ => "Unknown", 5845 } 5846 ) 5847 } 5848 } 5849 5850 #[doc(hidden)] 5851 impl IntoGlib for ReliefStyle { 5852 type GlibType = ffi::GtkReliefStyle; 5853 into_glib(self) -> ffi::GtkReliefStyle5854 fn into_glib(self) -> ffi::GtkReliefStyle { 5855 match self { 5856 Self::Normal => ffi::GTK_RELIEF_NORMAL, 5857 Self::Half => ffi::GTK_RELIEF_HALF, 5858 Self::None => ffi::GTK_RELIEF_NONE, 5859 Self::__Unknown(value) => value, 5860 } 5861 } 5862 } 5863 5864 #[doc(hidden)] 5865 impl FromGlib<ffi::GtkReliefStyle> for ReliefStyle { from_glib(value: ffi::GtkReliefStyle) -> Self5866 unsafe fn from_glib(value: ffi::GtkReliefStyle) -> Self { 5867 skip_assert_initialized!(); 5868 match value { 5869 ffi::GTK_RELIEF_NORMAL => Self::Normal, 5870 ffi::GTK_RELIEF_HALF => Self::Half, 5871 ffi::GTK_RELIEF_NONE => Self::None, 5872 value => Self::__Unknown(value), 5873 } 5874 } 5875 } 5876 5877 impl StaticType for ReliefStyle { static_type() -> Type5878 fn static_type() -> Type { 5879 unsafe { from_glib(ffi::gtk_relief_style_get_type()) } 5880 } 5881 } 5882 5883 impl glib::value::ValueType for ReliefStyle { 5884 type Type = Self; 5885 } 5886 5887 unsafe impl<'a> FromValue<'a> for ReliefStyle { 5888 type Checker = glib::value::GenericValueTypeChecker<Self>; 5889 from_value(value: &'a glib::Value) -> Self5890 unsafe fn from_value(value: &'a glib::Value) -> Self { 5891 skip_assert_initialized!(); 5892 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5893 } 5894 } 5895 5896 impl ToValue for ReliefStyle { to_value(&self) -> glib::Value5897 fn to_value(&self) -> glib::Value { 5898 let mut value = glib::Value::for_value_type::<Self>(); 5899 unsafe { 5900 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5901 } 5902 value 5903 } 5904 value_type(&self) -> glib::Type5905 fn value_type(&self) -> glib::Type { 5906 Self::static_type() 5907 } 5908 } 5909 5910 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 5911 #[non_exhaustive] 5912 #[doc(alias = "GtkResizeMode")] 5913 pub enum ResizeMode { 5914 #[doc(alias = "GTK_RESIZE_PARENT")] 5915 Parent, 5916 #[doc(alias = "GTK_RESIZE_QUEUE")] 5917 Queue, 5918 #[doc(alias = "GTK_RESIZE_IMMEDIATE")] 5919 Immediate, 5920 #[doc(hidden)] 5921 __Unknown(i32), 5922 } 5923 5924 impl fmt::Display for ResizeMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result5925 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 5926 write!( 5927 f, 5928 "ResizeMode::{}", 5929 match *self { 5930 Self::Parent => "Parent", 5931 Self::Queue => "Queue", 5932 Self::Immediate => "Immediate", 5933 _ => "Unknown", 5934 } 5935 ) 5936 } 5937 } 5938 5939 #[doc(hidden)] 5940 impl IntoGlib for ResizeMode { 5941 type GlibType = ffi::GtkResizeMode; 5942 into_glib(self) -> ffi::GtkResizeMode5943 fn into_glib(self) -> ffi::GtkResizeMode { 5944 match self { 5945 Self::Parent => ffi::GTK_RESIZE_PARENT, 5946 Self::Queue => ffi::GTK_RESIZE_QUEUE, 5947 Self::Immediate => ffi::GTK_RESIZE_IMMEDIATE, 5948 Self::__Unknown(value) => value, 5949 } 5950 } 5951 } 5952 5953 #[doc(hidden)] 5954 impl FromGlib<ffi::GtkResizeMode> for ResizeMode { from_glib(value: ffi::GtkResizeMode) -> Self5955 unsafe fn from_glib(value: ffi::GtkResizeMode) -> Self { 5956 skip_assert_initialized!(); 5957 match value { 5958 ffi::GTK_RESIZE_PARENT => Self::Parent, 5959 ffi::GTK_RESIZE_QUEUE => Self::Queue, 5960 ffi::GTK_RESIZE_IMMEDIATE => Self::Immediate, 5961 value => Self::__Unknown(value), 5962 } 5963 } 5964 } 5965 5966 impl StaticType for ResizeMode { static_type() -> Type5967 fn static_type() -> Type { 5968 unsafe { from_glib(ffi::gtk_resize_mode_get_type()) } 5969 } 5970 } 5971 5972 impl glib::value::ValueType for ResizeMode { 5973 type Type = Self; 5974 } 5975 5976 unsafe impl<'a> FromValue<'a> for ResizeMode { 5977 type Checker = glib::value::GenericValueTypeChecker<Self>; 5978 from_value(value: &'a glib::Value) -> Self5979 unsafe fn from_value(value: &'a glib::Value) -> Self { 5980 skip_assert_initialized!(); 5981 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 5982 } 5983 } 5984 5985 impl ToValue for ResizeMode { to_value(&self) -> glib::Value5986 fn to_value(&self) -> glib::Value { 5987 let mut value = glib::Value::for_value_type::<Self>(); 5988 unsafe { 5989 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 5990 } 5991 value 5992 } 5993 value_type(&self) -> glib::Type5994 fn value_type(&self) -> glib::Type { 5995 Self::static_type() 5996 } 5997 } 5998 5999 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6000 #[non_exhaustive] 6001 #[doc(alias = "GtkRevealerTransitionType")] 6002 pub enum RevealerTransitionType { 6003 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_NONE")] 6004 None, 6005 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE")] 6006 Crossfade, 6007 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT")] 6008 SlideRight, 6009 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT")] 6010 SlideLeft, 6011 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP")] 6012 SlideUp, 6013 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN")] 6014 SlideDown, 6015 #[doc(hidden)] 6016 __Unknown(i32), 6017 } 6018 6019 impl fmt::Display for RevealerTransitionType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6020 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6021 write!( 6022 f, 6023 "RevealerTransitionType::{}", 6024 match *self { 6025 Self::None => "None", 6026 Self::Crossfade => "Crossfade", 6027 Self::SlideRight => "SlideRight", 6028 Self::SlideLeft => "SlideLeft", 6029 Self::SlideUp => "SlideUp", 6030 Self::SlideDown => "SlideDown", 6031 _ => "Unknown", 6032 } 6033 ) 6034 } 6035 } 6036 6037 #[doc(hidden)] 6038 impl IntoGlib for RevealerTransitionType { 6039 type GlibType = ffi::GtkRevealerTransitionType; 6040 into_glib(self) -> ffi::GtkRevealerTransitionType6041 fn into_glib(self) -> ffi::GtkRevealerTransitionType { 6042 match self { 6043 Self::None => ffi::GTK_REVEALER_TRANSITION_TYPE_NONE, 6044 Self::Crossfade => ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE, 6045 Self::SlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT, 6046 Self::SlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT, 6047 Self::SlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP, 6048 Self::SlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN, 6049 Self::__Unknown(value) => value, 6050 } 6051 } 6052 } 6053 6054 #[doc(hidden)] 6055 impl FromGlib<ffi::GtkRevealerTransitionType> for RevealerTransitionType { from_glib(value: ffi::GtkRevealerTransitionType) -> Self6056 unsafe fn from_glib(value: ffi::GtkRevealerTransitionType) -> Self { 6057 skip_assert_initialized!(); 6058 match value { 6059 ffi::GTK_REVEALER_TRANSITION_TYPE_NONE => Self::None, 6060 ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade, 6061 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight, 6062 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft, 6063 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp, 6064 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown, 6065 value => Self::__Unknown(value), 6066 } 6067 } 6068 } 6069 6070 impl StaticType for RevealerTransitionType { static_type() -> Type6071 fn static_type() -> Type { 6072 unsafe { from_glib(ffi::gtk_revealer_transition_type_get_type()) } 6073 } 6074 } 6075 6076 impl glib::value::ValueType for RevealerTransitionType { 6077 type Type = Self; 6078 } 6079 6080 unsafe impl<'a> FromValue<'a> for RevealerTransitionType { 6081 type Checker = glib::value::GenericValueTypeChecker<Self>; 6082 from_value(value: &'a glib::Value) -> Self6083 unsafe fn from_value(value: &'a glib::Value) -> Self { 6084 skip_assert_initialized!(); 6085 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6086 } 6087 } 6088 6089 impl ToValue for RevealerTransitionType { to_value(&self) -> glib::Value6090 fn to_value(&self) -> glib::Value { 6091 let mut value = glib::Value::for_value_type::<Self>(); 6092 unsafe { 6093 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6094 } 6095 value 6096 } 6097 value_type(&self) -> glib::Type6098 fn value_type(&self) -> glib::Type { 6099 Self::static_type() 6100 } 6101 } 6102 6103 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6104 #[non_exhaustive] 6105 #[doc(alias = "GtkScrollStep")] 6106 pub enum ScrollStep { 6107 #[doc(alias = "GTK_SCROLL_STEPS")] 6108 Steps, 6109 #[doc(alias = "GTK_SCROLL_PAGES")] 6110 Pages, 6111 #[doc(alias = "GTK_SCROLL_ENDS")] 6112 Ends, 6113 #[doc(alias = "GTK_SCROLL_HORIZONTAL_STEPS")] 6114 HorizontalSteps, 6115 #[doc(alias = "GTK_SCROLL_HORIZONTAL_PAGES")] 6116 HorizontalPages, 6117 #[doc(alias = "GTK_SCROLL_HORIZONTAL_ENDS")] 6118 HorizontalEnds, 6119 #[doc(hidden)] 6120 __Unknown(i32), 6121 } 6122 6123 impl fmt::Display for ScrollStep { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6124 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6125 write!( 6126 f, 6127 "ScrollStep::{}", 6128 match *self { 6129 Self::Steps => "Steps", 6130 Self::Pages => "Pages", 6131 Self::Ends => "Ends", 6132 Self::HorizontalSteps => "HorizontalSteps", 6133 Self::HorizontalPages => "HorizontalPages", 6134 Self::HorizontalEnds => "HorizontalEnds", 6135 _ => "Unknown", 6136 } 6137 ) 6138 } 6139 } 6140 6141 #[doc(hidden)] 6142 impl IntoGlib for ScrollStep { 6143 type GlibType = ffi::GtkScrollStep; 6144 into_glib(self) -> ffi::GtkScrollStep6145 fn into_glib(self) -> ffi::GtkScrollStep { 6146 match self { 6147 Self::Steps => ffi::GTK_SCROLL_STEPS, 6148 Self::Pages => ffi::GTK_SCROLL_PAGES, 6149 Self::Ends => ffi::GTK_SCROLL_ENDS, 6150 Self::HorizontalSteps => ffi::GTK_SCROLL_HORIZONTAL_STEPS, 6151 Self::HorizontalPages => ffi::GTK_SCROLL_HORIZONTAL_PAGES, 6152 Self::HorizontalEnds => ffi::GTK_SCROLL_HORIZONTAL_ENDS, 6153 Self::__Unknown(value) => value, 6154 } 6155 } 6156 } 6157 6158 #[doc(hidden)] 6159 impl FromGlib<ffi::GtkScrollStep> for ScrollStep { from_glib(value: ffi::GtkScrollStep) -> Self6160 unsafe fn from_glib(value: ffi::GtkScrollStep) -> Self { 6161 skip_assert_initialized!(); 6162 match value { 6163 ffi::GTK_SCROLL_STEPS => Self::Steps, 6164 ffi::GTK_SCROLL_PAGES => Self::Pages, 6165 ffi::GTK_SCROLL_ENDS => Self::Ends, 6166 ffi::GTK_SCROLL_HORIZONTAL_STEPS => Self::HorizontalSteps, 6167 ffi::GTK_SCROLL_HORIZONTAL_PAGES => Self::HorizontalPages, 6168 ffi::GTK_SCROLL_HORIZONTAL_ENDS => Self::HorizontalEnds, 6169 value => Self::__Unknown(value), 6170 } 6171 } 6172 } 6173 6174 impl StaticType for ScrollStep { static_type() -> Type6175 fn static_type() -> Type { 6176 unsafe { from_glib(ffi::gtk_scroll_step_get_type()) } 6177 } 6178 } 6179 6180 impl glib::value::ValueType for ScrollStep { 6181 type Type = Self; 6182 } 6183 6184 unsafe impl<'a> FromValue<'a> for ScrollStep { 6185 type Checker = glib::value::GenericValueTypeChecker<Self>; 6186 from_value(value: &'a glib::Value) -> Self6187 unsafe fn from_value(value: &'a glib::Value) -> Self { 6188 skip_assert_initialized!(); 6189 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6190 } 6191 } 6192 6193 impl ToValue for ScrollStep { to_value(&self) -> glib::Value6194 fn to_value(&self) -> glib::Value { 6195 let mut value = glib::Value::for_value_type::<Self>(); 6196 unsafe { 6197 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6198 } 6199 value 6200 } 6201 value_type(&self) -> glib::Type6202 fn value_type(&self) -> glib::Type { 6203 Self::static_type() 6204 } 6205 } 6206 6207 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6208 #[non_exhaustive] 6209 #[doc(alias = "GtkScrollType")] 6210 pub enum ScrollType { 6211 #[doc(alias = "GTK_SCROLL_NONE")] 6212 None, 6213 #[doc(alias = "GTK_SCROLL_JUMP")] 6214 Jump, 6215 #[doc(alias = "GTK_SCROLL_STEP_BACKWARD")] 6216 StepBackward, 6217 #[doc(alias = "GTK_SCROLL_STEP_FORWARD")] 6218 StepForward, 6219 #[doc(alias = "GTK_SCROLL_PAGE_BACKWARD")] 6220 PageBackward, 6221 #[doc(alias = "GTK_SCROLL_PAGE_FORWARD")] 6222 PageForward, 6223 #[doc(alias = "GTK_SCROLL_STEP_UP")] 6224 StepUp, 6225 #[doc(alias = "GTK_SCROLL_STEP_DOWN")] 6226 StepDown, 6227 #[doc(alias = "GTK_SCROLL_PAGE_UP")] 6228 PageUp, 6229 #[doc(alias = "GTK_SCROLL_PAGE_DOWN")] 6230 PageDown, 6231 #[doc(alias = "GTK_SCROLL_STEP_LEFT")] 6232 StepLeft, 6233 #[doc(alias = "GTK_SCROLL_STEP_RIGHT")] 6234 StepRight, 6235 #[doc(alias = "GTK_SCROLL_PAGE_LEFT")] 6236 PageLeft, 6237 #[doc(alias = "GTK_SCROLL_PAGE_RIGHT")] 6238 PageRight, 6239 #[doc(alias = "GTK_SCROLL_START")] 6240 Start, 6241 #[doc(alias = "GTK_SCROLL_END")] 6242 End, 6243 #[doc(hidden)] 6244 __Unknown(i32), 6245 } 6246 6247 impl fmt::Display for ScrollType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6248 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6249 write!( 6250 f, 6251 "ScrollType::{}", 6252 match *self { 6253 Self::None => "None", 6254 Self::Jump => "Jump", 6255 Self::StepBackward => "StepBackward", 6256 Self::StepForward => "StepForward", 6257 Self::PageBackward => "PageBackward", 6258 Self::PageForward => "PageForward", 6259 Self::StepUp => "StepUp", 6260 Self::StepDown => "StepDown", 6261 Self::PageUp => "PageUp", 6262 Self::PageDown => "PageDown", 6263 Self::StepLeft => "StepLeft", 6264 Self::StepRight => "StepRight", 6265 Self::PageLeft => "PageLeft", 6266 Self::PageRight => "PageRight", 6267 Self::Start => "Start", 6268 Self::End => "End", 6269 _ => "Unknown", 6270 } 6271 ) 6272 } 6273 } 6274 6275 #[doc(hidden)] 6276 impl IntoGlib for ScrollType { 6277 type GlibType = ffi::GtkScrollType; 6278 into_glib(self) -> ffi::GtkScrollType6279 fn into_glib(self) -> ffi::GtkScrollType { 6280 match self { 6281 Self::None => ffi::GTK_SCROLL_NONE, 6282 Self::Jump => ffi::GTK_SCROLL_JUMP, 6283 Self::StepBackward => ffi::GTK_SCROLL_STEP_BACKWARD, 6284 Self::StepForward => ffi::GTK_SCROLL_STEP_FORWARD, 6285 Self::PageBackward => ffi::GTK_SCROLL_PAGE_BACKWARD, 6286 Self::PageForward => ffi::GTK_SCROLL_PAGE_FORWARD, 6287 Self::StepUp => ffi::GTK_SCROLL_STEP_UP, 6288 Self::StepDown => ffi::GTK_SCROLL_STEP_DOWN, 6289 Self::PageUp => ffi::GTK_SCROLL_PAGE_UP, 6290 Self::PageDown => ffi::GTK_SCROLL_PAGE_DOWN, 6291 Self::StepLeft => ffi::GTK_SCROLL_STEP_LEFT, 6292 Self::StepRight => ffi::GTK_SCROLL_STEP_RIGHT, 6293 Self::PageLeft => ffi::GTK_SCROLL_PAGE_LEFT, 6294 Self::PageRight => ffi::GTK_SCROLL_PAGE_RIGHT, 6295 Self::Start => ffi::GTK_SCROLL_START, 6296 Self::End => ffi::GTK_SCROLL_END, 6297 Self::__Unknown(value) => value, 6298 } 6299 } 6300 } 6301 6302 #[doc(hidden)] 6303 impl FromGlib<ffi::GtkScrollType> for ScrollType { from_glib(value: ffi::GtkScrollType) -> Self6304 unsafe fn from_glib(value: ffi::GtkScrollType) -> Self { 6305 skip_assert_initialized!(); 6306 match value { 6307 ffi::GTK_SCROLL_NONE => Self::None, 6308 ffi::GTK_SCROLL_JUMP => Self::Jump, 6309 ffi::GTK_SCROLL_STEP_BACKWARD => Self::StepBackward, 6310 ffi::GTK_SCROLL_STEP_FORWARD => Self::StepForward, 6311 ffi::GTK_SCROLL_PAGE_BACKWARD => Self::PageBackward, 6312 ffi::GTK_SCROLL_PAGE_FORWARD => Self::PageForward, 6313 ffi::GTK_SCROLL_STEP_UP => Self::StepUp, 6314 ffi::GTK_SCROLL_STEP_DOWN => Self::StepDown, 6315 ffi::GTK_SCROLL_PAGE_UP => Self::PageUp, 6316 ffi::GTK_SCROLL_PAGE_DOWN => Self::PageDown, 6317 ffi::GTK_SCROLL_STEP_LEFT => Self::StepLeft, 6318 ffi::GTK_SCROLL_STEP_RIGHT => Self::StepRight, 6319 ffi::GTK_SCROLL_PAGE_LEFT => Self::PageLeft, 6320 ffi::GTK_SCROLL_PAGE_RIGHT => Self::PageRight, 6321 ffi::GTK_SCROLL_START => Self::Start, 6322 ffi::GTK_SCROLL_END => Self::End, 6323 value => Self::__Unknown(value), 6324 } 6325 } 6326 } 6327 6328 impl StaticType for ScrollType { static_type() -> Type6329 fn static_type() -> Type { 6330 unsafe { from_glib(ffi::gtk_scroll_type_get_type()) } 6331 } 6332 } 6333 6334 impl glib::value::ValueType for ScrollType { 6335 type Type = Self; 6336 } 6337 6338 unsafe impl<'a> FromValue<'a> for ScrollType { 6339 type Checker = glib::value::GenericValueTypeChecker<Self>; 6340 from_value(value: &'a glib::Value) -> Self6341 unsafe fn from_value(value: &'a glib::Value) -> Self { 6342 skip_assert_initialized!(); 6343 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6344 } 6345 } 6346 6347 impl ToValue for ScrollType { to_value(&self) -> glib::Value6348 fn to_value(&self) -> glib::Value { 6349 let mut value = glib::Value::for_value_type::<Self>(); 6350 unsafe { 6351 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6352 } 6353 value 6354 } 6355 value_type(&self) -> glib::Type6356 fn value_type(&self) -> glib::Type { 6357 Self::static_type() 6358 } 6359 } 6360 6361 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6362 #[non_exhaustive] 6363 #[doc(alias = "GtkScrollablePolicy")] 6364 pub enum ScrollablePolicy { 6365 #[doc(alias = "GTK_SCROLL_MINIMUM")] 6366 Minimum, 6367 #[doc(alias = "GTK_SCROLL_NATURAL")] 6368 Natural, 6369 #[doc(hidden)] 6370 __Unknown(i32), 6371 } 6372 6373 impl fmt::Display for ScrollablePolicy { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6374 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6375 write!( 6376 f, 6377 "ScrollablePolicy::{}", 6378 match *self { 6379 Self::Minimum => "Minimum", 6380 Self::Natural => "Natural", 6381 _ => "Unknown", 6382 } 6383 ) 6384 } 6385 } 6386 6387 #[doc(hidden)] 6388 impl IntoGlib for ScrollablePolicy { 6389 type GlibType = ffi::GtkScrollablePolicy; 6390 into_glib(self) -> ffi::GtkScrollablePolicy6391 fn into_glib(self) -> ffi::GtkScrollablePolicy { 6392 match self { 6393 Self::Minimum => ffi::GTK_SCROLL_MINIMUM, 6394 Self::Natural => ffi::GTK_SCROLL_NATURAL, 6395 Self::__Unknown(value) => value, 6396 } 6397 } 6398 } 6399 6400 #[doc(hidden)] 6401 impl FromGlib<ffi::GtkScrollablePolicy> for ScrollablePolicy { from_glib(value: ffi::GtkScrollablePolicy) -> Self6402 unsafe fn from_glib(value: ffi::GtkScrollablePolicy) -> Self { 6403 skip_assert_initialized!(); 6404 match value { 6405 ffi::GTK_SCROLL_MINIMUM => Self::Minimum, 6406 ffi::GTK_SCROLL_NATURAL => Self::Natural, 6407 value => Self::__Unknown(value), 6408 } 6409 } 6410 } 6411 6412 impl StaticType for ScrollablePolicy { static_type() -> Type6413 fn static_type() -> Type { 6414 unsafe { from_glib(ffi::gtk_scrollable_policy_get_type()) } 6415 } 6416 } 6417 6418 impl glib::value::ValueType for ScrollablePolicy { 6419 type Type = Self; 6420 } 6421 6422 unsafe impl<'a> FromValue<'a> for ScrollablePolicy { 6423 type Checker = glib::value::GenericValueTypeChecker<Self>; 6424 from_value(value: &'a glib::Value) -> Self6425 unsafe fn from_value(value: &'a glib::Value) -> Self { 6426 skip_assert_initialized!(); 6427 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6428 } 6429 } 6430 6431 impl ToValue for ScrollablePolicy { to_value(&self) -> glib::Value6432 fn to_value(&self) -> glib::Value { 6433 let mut value = glib::Value::for_value_type::<Self>(); 6434 unsafe { 6435 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6436 } 6437 value 6438 } 6439 value_type(&self) -> glib::Type6440 fn value_type(&self) -> glib::Type { 6441 Self::static_type() 6442 } 6443 } 6444 6445 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6446 #[non_exhaustive] 6447 #[doc(alias = "GtkSelectionMode")] 6448 pub enum SelectionMode { 6449 #[doc(alias = "GTK_SELECTION_NONE")] 6450 None, 6451 #[doc(alias = "GTK_SELECTION_SINGLE")] 6452 Single, 6453 #[doc(alias = "GTK_SELECTION_BROWSE")] 6454 Browse, 6455 #[doc(alias = "GTK_SELECTION_MULTIPLE")] 6456 Multiple, 6457 #[doc(hidden)] 6458 __Unknown(i32), 6459 } 6460 6461 impl fmt::Display for SelectionMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6462 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6463 write!( 6464 f, 6465 "SelectionMode::{}", 6466 match *self { 6467 Self::None => "None", 6468 Self::Single => "Single", 6469 Self::Browse => "Browse", 6470 Self::Multiple => "Multiple", 6471 _ => "Unknown", 6472 } 6473 ) 6474 } 6475 } 6476 6477 #[doc(hidden)] 6478 impl IntoGlib for SelectionMode { 6479 type GlibType = ffi::GtkSelectionMode; 6480 into_glib(self) -> ffi::GtkSelectionMode6481 fn into_glib(self) -> ffi::GtkSelectionMode { 6482 match self { 6483 Self::None => ffi::GTK_SELECTION_NONE, 6484 Self::Single => ffi::GTK_SELECTION_SINGLE, 6485 Self::Browse => ffi::GTK_SELECTION_BROWSE, 6486 Self::Multiple => ffi::GTK_SELECTION_MULTIPLE, 6487 Self::__Unknown(value) => value, 6488 } 6489 } 6490 } 6491 6492 #[doc(hidden)] 6493 impl FromGlib<ffi::GtkSelectionMode> for SelectionMode { from_glib(value: ffi::GtkSelectionMode) -> Self6494 unsafe fn from_glib(value: ffi::GtkSelectionMode) -> Self { 6495 skip_assert_initialized!(); 6496 match value { 6497 ffi::GTK_SELECTION_NONE => Self::None, 6498 ffi::GTK_SELECTION_SINGLE => Self::Single, 6499 ffi::GTK_SELECTION_BROWSE => Self::Browse, 6500 ffi::GTK_SELECTION_MULTIPLE => Self::Multiple, 6501 value => Self::__Unknown(value), 6502 } 6503 } 6504 } 6505 6506 impl StaticType for SelectionMode { static_type() -> Type6507 fn static_type() -> Type { 6508 unsafe { from_glib(ffi::gtk_selection_mode_get_type()) } 6509 } 6510 } 6511 6512 impl glib::value::ValueType for SelectionMode { 6513 type Type = Self; 6514 } 6515 6516 unsafe impl<'a> FromValue<'a> for SelectionMode { 6517 type Checker = glib::value::GenericValueTypeChecker<Self>; 6518 from_value(value: &'a glib::Value) -> Self6519 unsafe fn from_value(value: &'a glib::Value) -> Self { 6520 skip_assert_initialized!(); 6521 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6522 } 6523 } 6524 6525 impl ToValue for SelectionMode { to_value(&self) -> glib::Value6526 fn to_value(&self) -> glib::Value { 6527 let mut value = glib::Value::for_value_type::<Self>(); 6528 unsafe { 6529 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6530 } 6531 value 6532 } 6533 value_type(&self) -> glib::Type6534 fn value_type(&self) -> glib::Type { 6535 Self::static_type() 6536 } 6537 } 6538 6539 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6540 #[non_exhaustive] 6541 #[doc(alias = "GtkSensitivityType")] 6542 pub enum SensitivityType { 6543 #[doc(alias = "GTK_SENSITIVITY_AUTO")] 6544 Auto, 6545 #[doc(alias = "GTK_SENSITIVITY_ON")] 6546 On, 6547 #[doc(alias = "GTK_SENSITIVITY_OFF")] 6548 Off, 6549 #[doc(hidden)] 6550 __Unknown(i32), 6551 } 6552 6553 impl fmt::Display for SensitivityType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6554 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6555 write!( 6556 f, 6557 "SensitivityType::{}", 6558 match *self { 6559 Self::Auto => "Auto", 6560 Self::On => "On", 6561 Self::Off => "Off", 6562 _ => "Unknown", 6563 } 6564 ) 6565 } 6566 } 6567 6568 #[doc(hidden)] 6569 impl IntoGlib for SensitivityType { 6570 type GlibType = ffi::GtkSensitivityType; 6571 into_glib(self) -> ffi::GtkSensitivityType6572 fn into_glib(self) -> ffi::GtkSensitivityType { 6573 match self { 6574 Self::Auto => ffi::GTK_SENSITIVITY_AUTO, 6575 Self::On => ffi::GTK_SENSITIVITY_ON, 6576 Self::Off => ffi::GTK_SENSITIVITY_OFF, 6577 Self::__Unknown(value) => value, 6578 } 6579 } 6580 } 6581 6582 #[doc(hidden)] 6583 impl FromGlib<ffi::GtkSensitivityType> for SensitivityType { from_glib(value: ffi::GtkSensitivityType) -> Self6584 unsafe fn from_glib(value: ffi::GtkSensitivityType) -> Self { 6585 skip_assert_initialized!(); 6586 match value { 6587 ffi::GTK_SENSITIVITY_AUTO => Self::Auto, 6588 ffi::GTK_SENSITIVITY_ON => Self::On, 6589 ffi::GTK_SENSITIVITY_OFF => Self::Off, 6590 value => Self::__Unknown(value), 6591 } 6592 } 6593 } 6594 6595 impl StaticType for SensitivityType { static_type() -> Type6596 fn static_type() -> Type { 6597 unsafe { from_glib(ffi::gtk_sensitivity_type_get_type()) } 6598 } 6599 } 6600 6601 impl glib::value::ValueType for SensitivityType { 6602 type Type = Self; 6603 } 6604 6605 unsafe impl<'a> FromValue<'a> for SensitivityType { 6606 type Checker = glib::value::GenericValueTypeChecker<Self>; 6607 from_value(value: &'a glib::Value) -> Self6608 unsafe fn from_value(value: &'a glib::Value) -> Self { 6609 skip_assert_initialized!(); 6610 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6611 } 6612 } 6613 6614 impl ToValue for SensitivityType { to_value(&self) -> glib::Value6615 fn to_value(&self) -> glib::Value { 6616 let mut value = glib::Value::for_value_type::<Self>(); 6617 unsafe { 6618 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6619 } 6620 value 6621 } 6622 value_type(&self) -> glib::Type6623 fn value_type(&self) -> glib::Type { 6624 Self::static_type() 6625 } 6626 } 6627 6628 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6629 #[non_exhaustive] 6630 #[doc(alias = "GtkShadowType")] 6631 pub enum ShadowType { 6632 #[doc(alias = "GTK_SHADOW_NONE")] 6633 None, 6634 #[doc(alias = "GTK_SHADOW_IN")] 6635 In, 6636 #[doc(alias = "GTK_SHADOW_OUT")] 6637 Out, 6638 #[doc(alias = "GTK_SHADOW_ETCHED_IN")] 6639 EtchedIn, 6640 #[doc(alias = "GTK_SHADOW_ETCHED_OUT")] 6641 EtchedOut, 6642 #[doc(hidden)] 6643 __Unknown(i32), 6644 } 6645 6646 impl fmt::Display for ShadowType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6647 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6648 write!( 6649 f, 6650 "ShadowType::{}", 6651 match *self { 6652 Self::None => "None", 6653 Self::In => "In", 6654 Self::Out => "Out", 6655 Self::EtchedIn => "EtchedIn", 6656 Self::EtchedOut => "EtchedOut", 6657 _ => "Unknown", 6658 } 6659 ) 6660 } 6661 } 6662 6663 #[doc(hidden)] 6664 impl IntoGlib for ShadowType { 6665 type GlibType = ffi::GtkShadowType; 6666 into_glib(self) -> ffi::GtkShadowType6667 fn into_glib(self) -> ffi::GtkShadowType { 6668 match self { 6669 Self::None => ffi::GTK_SHADOW_NONE, 6670 Self::In => ffi::GTK_SHADOW_IN, 6671 Self::Out => ffi::GTK_SHADOW_OUT, 6672 Self::EtchedIn => ffi::GTK_SHADOW_ETCHED_IN, 6673 Self::EtchedOut => ffi::GTK_SHADOW_ETCHED_OUT, 6674 Self::__Unknown(value) => value, 6675 } 6676 } 6677 } 6678 6679 #[doc(hidden)] 6680 impl FromGlib<ffi::GtkShadowType> for ShadowType { from_glib(value: ffi::GtkShadowType) -> Self6681 unsafe fn from_glib(value: ffi::GtkShadowType) -> Self { 6682 skip_assert_initialized!(); 6683 match value { 6684 ffi::GTK_SHADOW_NONE => Self::None, 6685 ffi::GTK_SHADOW_IN => Self::In, 6686 ffi::GTK_SHADOW_OUT => Self::Out, 6687 ffi::GTK_SHADOW_ETCHED_IN => Self::EtchedIn, 6688 ffi::GTK_SHADOW_ETCHED_OUT => Self::EtchedOut, 6689 value => Self::__Unknown(value), 6690 } 6691 } 6692 } 6693 6694 impl StaticType for ShadowType { static_type() -> Type6695 fn static_type() -> Type { 6696 unsafe { from_glib(ffi::gtk_shadow_type_get_type()) } 6697 } 6698 } 6699 6700 impl glib::value::ValueType for ShadowType { 6701 type Type = Self; 6702 } 6703 6704 unsafe impl<'a> FromValue<'a> for ShadowType { 6705 type Checker = glib::value::GenericValueTypeChecker<Self>; 6706 from_value(value: &'a glib::Value) -> Self6707 unsafe fn from_value(value: &'a glib::Value) -> Self { 6708 skip_assert_initialized!(); 6709 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6710 } 6711 } 6712 6713 impl ToValue for ShadowType { to_value(&self) -> glib::Value6714 fn to_value(&self) -> glib::Value { 6715 let mut value = glib::Value::for_value_type::<Self>(); 6716 unsafe { 6717 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6718 } 6719 value 6720 } 6721 value_type(&self) -> glib::Type6722 fn value_type(&self) -> glib::Type { 6723 Self::static_type() 6724 } 6725 } 6726 6727 #[cfg(any(feature = "v3_20", feature = "dox"))] 6728 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 6729 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6730 #[non_exhaustive] 6731 #[doc(alias = "GtkShortcutType")] 6732 pub enum ShortcutType { 6733 #[doc(alias = "GTK_SHORTCUT_ACCELERATOR")] 6734 Accelerator, 6735 #[doc(alias = "GTK_SHORTCUT_GESTURE_PINCH")] 6736 GesturePinch, 6737 #[doc(alias = "GTK_SHORTCUT_GESTURE_STRETCH")] 6738 GestureStretch, 6739 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE")] 6740 GestureRotateClockwise, 6741 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE")] 6742 GestureRotateCounterclockwise, 6743 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT")] 6744 GestureTwoFingerSwipeLeft, 6745 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT")] 6746 GestureTwoFingerSwipeRight, 6747 #[doc(alias = "GTK_SHORTCUT_GESTURE")] 6748 Gesture, 6749 #[doc(hidden)] 6750 __Unknown(i32), 6751 } 6752 6753 #[cfg(any(feature = "v3_20", feature = "dox"))] 6754 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 6755 impl fmt::Display for ShortcutType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6756 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6757 write!( 6758 f, 6759 "ShortcutType::{}", 6760 match *self { 6761 Self::Accelerator => "Accelerator", 6762 Self::GesturePinch => "GesturePinch", 6763 Self::GestureStretch => "GestureStretch", 6764 Self::GestureRotateClockwise => "GestureRotateClockwise", 6765 Self::GestureRotateCounterclockwise => "GestureRotateCounterclockwise", 6766 Self::GestureTwoFingerSwipeLeft => "GestureTwoFingerSwipeLeft", 6767 Self::GestureTwoFingerSwipeRight => "GestureTwoFingerSwipeRight", 6768 Self::Gesture => "Gesture", 6769 _ => "Unknown", 6770 } 6771 ) 6772 } 6773 } 6774 6775 #[cfg(any(feature = "v3_20", feature = "dox"))] 6776 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 6777 #[doc(hidden)] 6778 impl IntoGlib for ShortcutType { 6779 type GlibType = ffi::GtkShortcutType; 6780 into_glib(self) -> ffi::GtkShortcutType6781 fn into_glib(self) -> ffi::GtkShortcutType { 6782 match self { 6783 Self::Accelerator => ffi::GTK_SHORTCUT_ACCELERATOR, 6784 Self::GesturePinch => ffi::GTK_SHORTCUT_GESTURE_PINCH, 6785 Self::GestureStretch => ffi::GTK_SHORTCUT_GESTURE_STRETCH, 6786 Self::GestureRotateClockwise => ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE, 6787 Self::GestureRotateCounterclockwise => { 6788 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE 6789 } 6790 Self::GestureTwoFingerSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT, 6791 Self::GestureTwoFingerSwipeRight => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT, 6792 Self::Gesture => ffi::GTK_SHORTCUT_GESTURE, 6793 Self::__Unknown(value) => value, 6794 } 6795 } 6796 } 6797 6798 #[cfg(any(feature = "v3_20", feature = "dox"))] 6799 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 6800 #[doc(hidden)] 6801 impl FromGlib<ffi::GtkShortcutType> for ShortcutType { from_glib(value: ffi::GtkShortcutType) -> Self6802 unsafe fn from_glib(value: ffi::GtkShortcutType) -> Self { 6803 skip_assert_initialized!(); 6804 match value { 6805 ffi::GTK_SHORTCUT_ACCELERATOR => Self::Accelerator, 6806 ffi::GTK_SHORTCUT_GESTURE_PINCH => Self::GesturePinch, 6807 ffi::GTK_SHORTCUT_GESTURE_STRETCH => Self::GestureStretch, 6808 ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE => Self::GestureRotateClockwise, 6809 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE => { 6810 Self::GestureRotateCounterclockwise 6811 } 6812 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT => Self::GestureTwoFingerSwipeLeft, 6813 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT => Self::GestureTwoFingerSwipeRight, 6814 ffi::GTK_SHORTCUT_GESTURE => Self::Gesture, 6815 value => Self::__Unknown(value), 6816 } 6817 } 6818 } 6819 6820 #[cfg(any(feature = "v3_20", feature = "dox"))] 6821 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 6822 impl StaticType for ShortcutType { static_type() -> Type6823 fn static_type() -> Type { 6824 unsafe { from_glib(ffi::gtk_shortcut_type_get_type()) } 6825 } 6826 } 6827 6828 #[cfg(any(feature = "v3_20", feature = "dox"))] 6829 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 6830 impl glib::value::ValueType for ShortcutType { 6831 type Type = Self; 6832 } 6833 6834 #[cfg(any(feature = "v3_20", feature = "dox"))] 6835 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 6836 unsafe impl<'a> FromValue<'a> for ShortcutType { 6837 type Checker = glib::value::GenericValueTypeChecker<Self>; 6838 from_value(value: &'a glib::Value) -> Self6839 unsafe fn from_value(value: &'a glib::Value) -> Self { 6840 skip_assert_initialized!(); 6841 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6842 } 6843 } 6844 6845 #[cfg(any(feature = "v3_20", feature = "dox"))] 6846 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 6847 impl ToValue for ShortcutType { to_value(&self) -> glib::Value6848 fn to_value(&self) -> glib::Value { 6849 let mut value = glib::Value::for_value_type::<Self>(); 6850 unsafe { 6851 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6852 } 6853 value 6854 } 6855 value_type(&self) -> glib::Type6856 fn value_type(&self) -> glib::Type { 6857 Self::static_type() 6858 } 6859 } 6860 6861 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6862 #[non_exhaustive] 6863 #[doc(alias = "GtkSizeGroupMode")] 6864 pub enum SizeGroupMode { 6865 #[doc(alias = "GTK_SIZE_GROUP_NONE")] 6866 None, 6867 #[doc(alias = "GTK_SIZE_GROUP_HORIZONTAL")] 6868 Horizontal, 6869 #[doc(alias = "GTK_SIZE_GROUP_VERTICAL")] 6870 Vertical, 6871 #[doc(alias = "GTK_SIZE_GROUP_BOTH")] 6872 Both, 6873 #[doc(hidden)] 6874 __Unknown(i32), 6875 } 6876 6877 impl fmt::Display for SizeGroupMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6878 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6879 write!( 6880 f, 6881 "SizeGroupMode::{}", 6882 match *self { 6883 Self::None => "None", 6884 Self::Horizontal => "Horizontal", 6885 Self::Vertical => "Vertical", 6886 Self::Both => "Both", 6887 _ => "Unknown", 6888 } 6889 ) 6890 } 6891 } 6892 6893 #[doc(hidden)] 6894 impl IntoGlib for SizeGroupMode { 6895 type GlibType = ffi::GtkSizeGroupMode; 6896 into_glib(self) -> ffi::GtkSizeGroupMode6897 fn into_glib(self) -> ffi::GtkSizeGroupMode { 6898 match self { 6899 Self::None => ffi::GTK_SIZE_GROUP_NONE, 6900 Self::Horizontal => ffi::GTK_SIZE_GROUP_HORIZONTAL, 6901 Self::Vertical => ffi::GTK_SIZE_GROUP_VERTICAL, 6902 Self::Both => ffi::GTK_SIZE_GROUP_BOTH, 6903 Self::__Unknown(value) => value, 6904 } 6905 } 6906 } 6907 6908 #[doc(hidden)] 6909 impl FromGlib<ffi::GtkSizeGroupMode> for SizeGroupMode { from_glib(value: ffi::GtkSizeGroupMode) -> Self6910 unsafe fn from_glib(value: ffi::GtkSizeGroupMode) -> Self { 6911 skip_assert_initialized!(); 6912 match value { 6913 ffi::GTK_SIZE_GROUP_NONE => Self::None, 6914 ffi::GTK_SIZE_GROUP_HORIZONTAL => Self::Horizontal, 6915 ffi::GTK_SIZE_GROUP_VERTICAL => Self::Vertical, 6916 ffi::GTK_SIZE_GROUP_BOTH => Self::Both, 6917 value => Self::__Unknown(value), 6918 } 6919 } 6920 } 6921 6922 impl StaticType for SizeGroupMode { static_type() -> Type6923 fn static_type() -> Type { 6924 unsafe { from_glib(ffi::gtk_size_group_mode_get_type()) } 6925 } 6926 } 6927 6928 impl glib::value::ValueType for SizeGroupMode { 6929 type Type = Self; 6930 } 6931 6932 unsafe impl<'a> FromValue<'a> for SizeGroupMode { 6933 type Checker = glib::value::GenericValueTypeChecker<Self>; 6934 from_value(value: &'a glib::Value) -> Self6935 unsafe fn from_value(value: &'a glib::Value) -> Self { 6936 skip_assert_initialized!(); 6937 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 6938 } 6939 } 6940 6941 impl ToValue for SizeGroupMode { to_value(&self) -> glib::Value6942 fn to_value(&self) -> glib::Value { 6943 let mut value = glib::Value::for_value_type::<Self>(); 6944 unsafe { 6945 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 6946 } 6947 value 6948 } 6949 value_type(&self) -> glib::Type6950 fn value_type(&self) -> glib::Type { 6951 Self::static_type() 6952 } 6953 } 6954 6955 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 6956 #[non_exhaustive] 6957 #[doc(alias = "GtkSizeRequestMode")] 6958 pub enum SizeRequestMode { 6959 #[doc(alias = "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH")] 6960 HeightForWidth, 6961 #[doc(alias = "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT")] 6962 WidthForHeight, 6963 #[doc(alias = "GTK_SIZE_REQUEST_CONSTANT_SIZE")] 6964 ConstantSize, 6965 #[doc(hidden)] 6966 __Unknown(i32), 6967 } 6968 6969 impl fmt::Display for SizeRequestMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result6970 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 6971 write!( 6972 f, 6973 "SizeRequestMode::{}", 6974 match *self { 6975 Self::HeightForWidth => "HeightForWidth", 6976 Self::WidthForHeight => "WidthForHeight", 6977 Self::ConstantSize => "ConstantSize", 6978 _ => "Unknown", 6979 } 6980 ) 6981 } 6982 } 6983 6984 #[doc(hidden)] 6985 impl IntoGlib for SizeRequestMode { 6986 type GlibType = ffi::GtkSizeRequestMode; 6987 into_glib(self) -> ffi::GtkSizeRequestMode6988 fn into_glib(self) -> ffi::GtkSizeRequestMode { 6989 match self { 6990 Self::HeightForWidth => ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH, 6991 Self::WidthForHeight => ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT, 6992 Self::ConstantSize => ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE, 6993 Self::__Unknown(value) => value, 6994 } 6995 } 6996 } 6997 6998 #[doc(hidden)] 6999 impl FromGlib<ffi::GtkSizeRequestMode> for SizeRequestMode { from_glib(value: ffi::GtkSizeRequestMode) -> Self7000 unsafe fn from_glib(value: ffi::GtkSizeRequestMode) -> Self { 7001 skip_assert_initialized!(); 7002 match value { 7003 ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH => Self::HeightForWidth, 7004 ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT => Self::WidthForHeight, 7005 ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE => Self::ConstantSize, 7006 value => Self::__Unknown(value), 7007 } 7008 } 7009 } 7010 7011 impl StaticType for SizeRequestMode { static_type() -> Type7012 fn static_type() -> Type { 7013 unsafe { from_glib(ffi::gtk_size_request_mode_get_type()) } 7014 } 7015 } 7016 7017 impl glib::value::ValueType for SizeRequestMode { 7018 type Type = Self; 7019 } 7020 7021 unsafe impl<'a> FromValue<'a> for SizeRequestMode { 7022 type Checker = glib::value::GenericValueTypeChecker<Self>; 7023 from_value(value: &'a glib::Value) -> Self7024 unsafe fn from_value(value: &'a glib::Value) -> Self { 7025 skip_assert_initialized!(); 7026 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7027 } 7028 } 7029 7030 impl ToValue for SizeRequestMode { to_value(&self) -> glib::Value7031 fn to_value(&self) -> glib::Value { 7032 let mut value = glib::Value::for_value_type::<Self>(); 7033 unsafe { 7034 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7035 } 7036 value 7037 } 7038 value_type(&self) -> glib::Type7039 fn value_type(&self) -> glib::Type { 7040 Self::static_type() 7041 } 7042 } 7043 7044 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7045 #[non_exhaustive] 7046 #[doc(alias = "GtkSortType")] 7047 pub enum SortType { 7048 #[doc(alias = "GTK_SORT_ASCENDING")] 7049 Ascending, 7050 #[doc(alias = "GTK_SORT_DESCENDING")] 7051 Descending, 7052 #[doc(hidden)] 7053 __Unknown(i32), 7054 } 7055 7056 impl fmt::Display for SortType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7057 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7058 write!( 7059 f, 7060 "SortType::{}", 7061 match *self { 7062 Self::Ascending => "Ascending", 7063 Self::Descending => "Descending", 7064 _ => "Unknown", 7065 } 7066 ) 7067 } 7068 } 7069 7070 #[doc(hidden)] 7071 impl IntoGlib for SortType { 7072 type GlibType = ffi::GtkSortType; 7073 into_glib(self) -> ffi::GtkSortType7074 fn into_glib(self) -> ffi::GtkSortType { 7075 match self { 7076 Self::Ascending => ffi::GTK_SORT_ASCENDING, 7077 Self::Descending => ffi::GTK_SORT_DESCENDING, 7078 Self::__Unknown(value) => value, 7079 } 7080 } 7081 } 7082 7083 #[doc(hidden)] 7084 impl FromGlib<ffi::GtkSortType> for SortType { from_glib(value: ffi::GtkSortType) -> Self7085 unsafe fn from_glib(value: ffi::GtkSortType) -> Self { 7086 skip_assert_initialized!(); 7087 match value { 7088 ffi::GTK_SORT_ASCENDING => Self::Ascending, 7089 ffi::GTK_SORT_DESCENDING => Self::Descending, 7090 value => Self::__Unknown(value), 7091 } 7092 } 7093 } 7094 7095 impl StaticType for SortType { static_type() -> Type7096 fn static_type() -> Type { 7097 unsafe { from_glib(ffi::gtk_sort_type_get_type()) } 7098 } 7099 } 7100 7101 impl glib::value::ValueType for SortType { 7102 type Type = Self; 7103 } 7104 7105 unsafe impl<'a> FromValue<'a> for SortType { 7106 type Checker = glib::value::GenericValueTypeChecker<Self>; 7107 from_value(value: &'a glib::Value) -> Self7108 unsafe fn from_value(value: &'a glib::Value) -> Self { 7109 skip_assert_initialized!(); 7110 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7111 } 7112 } 7113 7114 impl ToValue for SortType { to_value(&self) -> glib::Value7115 fn to_value(&self) -> glib::Value { 7116 let mut value = glib::Value::for_value_type::<Self>(); 7117 unsafe { 7118 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7119 } 7120 value 7121 } 7122 value_type(&self) -> glib::Type7123 fn value_type(&self) -> glib::Type { 7124 Self::static_type() 7125 } 7126 } 7127 7128 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7129 #[non_exhaustive] 7130 #[doc(alias = "GtkSpinButtonUpdatePolicy")] 7131 pub enum SpinButtonUpdatePolicy { 7132 #[doc(alias = "GTK_UPDATE_ALWAYS")] 7133 Always, 7134 #[doc(alias = "GTK_UPDATE_IF_VALID")] 7135 IfValid, 7136 #[doc(hidden)] 7137 __Unknown(i32), 7138 } 7139 7140 impl fmt::Display for SpinButtonUpdatePolicy { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7141 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7142 write!( 7143 f, 7144 "SpinButtonUpdatePolicy::{}", 7145 match *self { 7146 Self::Always => "Always", 7147 Self::IfValid => "IfValid", 7148 _ => "Unknown", 7149 } 7150 ) 7151 } 7152 } 7153 7154 #[doc(hidden)] 7155 impl IntoGlib for SpinButtonUpdatePolicy { 7156 type GlibType = ffi::GtkSpinButtonUpdatePolicy; 7157 into_glib(self) -> ffi::GtkSpinButtonUpdatePolicy7158 fn into_glib(self) -> ffi::GtkSpinButtonUpdatePolicy { 7159 match self { 7160 Self::Always => ffi::GTK_UPDATE_ALWAYS, 7161 Self::IfValid => ffi::GTK_UPDATE_IF_VALID, 7162 Self::__Unknown(value) => value, 7163 } 7164 } 7165 } 7166 7167 #[doc(hidden)] 7168 impl FromGlib<ffi::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy { from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self7169 unsafe fn from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self { 7170 skip_assert_initialized!(); 7171 match value { 7172 ffi::GTK_UPDATE_ALWAYS => Self::Always, 7173 ffi::GTK_UPDATE_IF_VALID => Self::IfValid, 7174 value => Self::__Unknown(value), 7175 } 7176 } 7177 } 7178 7179 impl StaticType for SpinButtonUpdatePolicy { static_type() -> Type7180 fn static_type() -> Type { 7181 unsafe { from_glib(ffi::gtk_spin_button_update_policy_get_type()) } 7182 } 7183 } 7184 7185 impl glib::value::ValueType for SpinButtonUpdatePolicy { 7186 type Type = Self; 7187 } 7188 7189 unsafe impl<'a> FromValue<'a> for SpinButtonUpdatePolicy { 7190 type Checker = glib::value::GenericValueTypeChecker<Self>; 7191 from_value(value: &'a glib::Value) -> Self7192 unsafe fn from_value(value: &'a glib::Value) -> Self { 7193 skip_assert_initialized!(); 7194 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7195 } 7196 } 7197 7198 impl ToValue for SpinButtonUpdatePolicy { to_value(&self) -> glib::Value7199 fn to_value(&self) -> glib::Value { 7200 let mut value = glib::Value::for_value_type::<Self>(); 7201 unsafe { 7202 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7203 } 7204 value 7205 } 7206 value_type(&self) -> glib::Type7207 fn value_type(&self) -> glib::Type { 7208 Self::static_type() 7209 } 7210 } 7211 7212 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7213 #[non_exhaustive] 7214 #[doc(alias = "GtkSpinType")] 7215 pub enum SpinType { 7216 #[doc(alias = "GTK_SPIN_STEP_FORWARD")] 7217 StepForward, 7218 #[doc(alias = "GTK_SPIN_STEP_BACKWARD")] 7219 StepBackward, 7220 #[doc(alias = "GTK_SPIN_PAGE_FORWARD")] 7221 PageForward, 7222 #[doc(alias = "GTK_SPIN_PAGE_BACKWARD")] 7223 PageBackward, 7224 #[doc(alias = "GTK_SPIN_HOME")] 7225 Home, 7226 #[doc(alias = "GTK_SPIN_END")] 7227 End, 7228 #[doc(alias = "GTK_SPIN_USER_DEFINED")] 7229 UserDefined, 7230 #[doc(hidden)] 7231 __Unknown(i32), 7232 } 7233 7234 impl fmt::Display for SpinType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7235 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7236 write!( 7237 f, 7238 "SpinType::{}", 7239 match *self { 7240 Self::StepForward => "StepForward", 7241 Self::StepBackward => "StepBackward", 7242 Self::PageForward => "PageForward", 7243 Self::PageBackward => "PageBackward", 7244 Self::Home => "Home", 7245 Self::End => "End", 7246 Self::UserDefined => "UserDefined", 7247 _ => "Unknown", 7248 } 7249 ) 7250 } 7251 } 7252 7253 #[doc(hidden)] 7254 impl IntoGlib for SpinType { 7255 type GlibType = ffi::GtkSpinType; 7256 into_glib(self) -> ffi::GtkSpinType7257 fn into_glib(self) -> ffi::GtkSpinType { 7258 match self { 7259 Self::StepForward => ffi::GTK_SPIN_STEP_FORWARD, 7260 Self::StepBackward => ffi::GTK_SPIN_STEP_BACKWARD, 7261 Self::PageForward => ffi::GTK_SPIN_PAGE_FORWARD, 7262 Self::PageBackward => ffi::GTK_SPIN_PAGE_BACKWARD, 7263 Self::Home => ffi::GTK_SPIN_HOME, 7264 Self::End => ffi::GTK_SPIN_END, 7265 Self::UserDefined => ffi::GTK_SPIN_USER_DEFINED, 7266 Self::__Unknown(value) => value, 7267 } 7268 } 7269 } 7270 7271 #[doc(hidden)] 7272 impl FromGlib<ffi::GtkSpinType> for SpinType { from_glib(value: ffi::GtkSpinType) -> Self7273 unsafe fn from_glib(value: ffi::GtkSpinType) -> Self { 7274 skip_assert_initialized!(); 7275 match value { 7276 ffi::GTK_SPIN_STEP_FORWARD => Self::StepForward, 7277 ffi::GTK_SPIN_STEP_BACKWARD => Self::StepBackward, 7278 ffi::GTK_SPIN_PAGE_FORWARD => Self::PageForward, 7279 ffi::GTK_SPIN_PAGE_BACKWARD => Self::PageBackward, 7280 ffi::GTK_SPIN_HOME => Self::Home, 7281 ffi::GTK_SPIN_END => Self::End, 7282 ffi::GTK_SPIN_USER_DEFINED => Self::UserDefined, 7283 value => Self::__Unknown(value), 7284 } 7285 } 7286 } 7287 7288 impl StaticType for SpinType { static_type() -> Type7289 fn static_type() -> Type { 7290 unsafe { from_glib(ffi::gtk_spin_type_get_type()) } 7291 } 7292 } 7293 7294 impl glib::value::ValueType for SpinType { 7295 type Type = Self; 7296 } 7297 7298 unsafe impl<'a> FromValue<'a> for SpinType { 7299 type Checker = glib::value::GenericValueTypeChecker<Self>; 7300 from_value(value: &'a glib::Value) -> Self7301 unsafe fn from_value(value: &'a glib::Value) -> Self { 7302 skip_assert_initialized!(); 7303 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7304 } 7305 } 7306 7307 impl ToValue for SpinType { to_value(&self) -> glib::Value7308 fn to_value(&self) -> glib::Value { 7309 let mut value = glib::Value::for_value_type::<Self>(); 7310 unsafe { 7311 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7312 } 7313 value 7314 } 7315 value_type(&self) -> glib::Type7316 fn value_type(&self) -> glib::Type { 7317 Self::static_type() 7318 } 7319 } 7320 7321 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7322 #[non_exhaustive] 7323 #[doc(alias = "GtkStackTransitionType")] 7324 pub enum StackTransitionType { 7325 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_NONE")] 7326 None, 7327 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_CROSSFADE")] 7328 Crossfade, 7329 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT")] 7330 SlideRight, 7331 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT")] 7332 SlideLeft, 7333 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP")] 7334 SlideUp, 7335 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN")] 7336 SlideDown, 7337 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT")] 7338 SlideLeftRight, 7339 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN")] 7340 SlideUpDown, 7341 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP")] 7342 OverUp, 7343 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN")] 7344 OverDown, 7345 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT")] 7346 OverLeft, 7347 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT")] 7348 OverRight, 7349 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_UP")] 7350 UnderUp, 7351 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN")] 7352 UnderDown, 7353 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT")] 7354 UnderLeft, 7355 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT")] 7356 UnderRight, 7357 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN")] 7358 OverUpDown, 7359 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP")] 7360 OverDownUp, 7361 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT")] 7362 OverLeftRight, 7363 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT")] 7364 OverRightLeft, 7365 #[doc(hidden)] 7366 __Unknown(i32), 7367 } 7368 7369 impl fmt::Display for StackTransitionType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7370 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7371 write!( 7372 f, 7373 "StackTransitionType::{}", 7374 match *self { 7375 Self::None => "None", 7376 Self::Crossfade => "Crossfade", 7377 Self::SlideRight => "SlideRight", 7378 Self::SlideLeft => "SlideLeft", 7379 Self::SlideUp => "SlideUp", 7380 Self::SlideDown => "SlideDown", 7381 Self::SlideLeftRight => "SlideLeftRight", 7382 Self::SlideUpDown => "SlideUpDown", 7383 Self::OverUp => "OverUp", 7384 Self::OverDown => "OverDown", 7385 Self::OverLeft => "OverLeft", 7386 Self::OverRight => "OverRight", 7387 Self::UnderUp => "UnderUp", 7388 Self::UnderDown => "UnderDown", 7389 Self::UnderLeft => "UnderLeft", 7390 Self::UnderRight => "UnderRight", 7391 Self::OverUpDown => "OverUpDown", 7392 Self::OverDownUp => "OverDownUp", 7393 Self::OverLeftRight => "OverLeftRight", 7394 Self::OverRightLeft => "OverRightLeft", 7395 _ => "Unknown", 7396 } 7397 ) 7398 } 7399 } 7400 7401 #[doc(hidden)] 7402 impl IntoGlib for StackTransitionType { 7403 type GlibType = ffi::GtkStackTransitionType; 7404 into_glib(self) -> ffi::GtkStackTransitionType7405 fn into_glib(self) -> ffi::GtkStackTransitionType { 7406 match self { 7407 Self::None => ffi::GTK_STACK_TRANSITION_TYPE_NONE, 7408 Self::Crossfade => ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE, 7409 Self::SlideRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT, 7410 Self::SlideLeft => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT, 7411 Self::SlideUp => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP, 7412 Self::SlideDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN, 7413 Self::SlideLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT, 7414 Self::SlideUpDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN, 7415 Self::OverUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP, 7416 Self::OverDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN, 7417 Self::OverLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT, 7418 Self::OverRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT, 7419 Self::UnderUp => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP, 7420 Self::UnderDown => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN, 7421 Self::UnderLeft => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT, 7422 Self::UnderRight => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT, 7423 Self::OverUpDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN, 7424 Self::OverDownUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP, 7425 Self::OverLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT, 7426 Self::OverRightLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT, 7427 Self::__Unknown(value) => value, 7428 } 7429 } 7430 } 7431 7432 #[doc(hidden)] 7433 impl FromGlib<ffi::GtkStackTransitionType> for StackTransitionType { from_glib(value: ffi::GtkStackTransitionType) -> Self7434 unsafe fn from_glib(value: ffi::GtkStackTransitionType) -> Self { 7435 skip_assert_initialized!(); 7436 match value { 7437 ffi::GTK_STACK_TRANSITION_TYPE_NONE => Self::None, 7438 ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE => Self::Crossfade, 7439 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight, 7440 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft, 7441 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp, 7442 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown, 7443 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT => Self::SlideLeftRight, 7444 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN => Self::SlideUpDown, 7445 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP => Self::OverUp, 7446 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN => Self::OverDown, 7447 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT => Self::OverLeft, 7448 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT => Self::OverRight, 7449 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP => Self::UnderUp, 7450 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN => Self::UnderDown, 7451 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT => Self::UnderLeft, 7452 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT => Self::UnderRight, 7453 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN => Self::OverUpDown, 7454 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP => Self::OverDownUp, 7455 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT => Self::OverLeftRight, 7456 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT => Self::OverRightLeft, 7457 value => Self::__Unknown(value), 7458 } 7459 } 7460 } 7461 7462 impl StaticType for StackTransitionType { static_type() -> Type7463 fn static_type() -> Type { 7464 unsafe { from_glib(ffi::gtk_stack_transition_type_get_type()) } 7465 } 7466 } 7467 7468 impl glib::value::ValueType for StackTransitionType { 7469 type Type = Self; 7470 } 7471 7472 unsafe impl<'a> FromValue<'a> for StackTransitionType { 7473 type Checker = glib::value::GenericValueTypeChecker<Self>; 7474 from_value(value: &'a glib::Value) -> Self7475 unsafe fn from_value(value: &'a glib::Value) -> Self { 7476 skip_assert_initialized!(); 7477 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7478 } 7479 } 7480 7481 impl ToValue for StackTransitionType { to_value(&self) -> glib::Value7482 fn to_value(&self) -> glib::Value { 7483 let mut value = glib::Value::for_value_type::<Self>(); 7484 unsafe { 7485 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7486 } 7487 value 7488 } 7489 value_type(&self) -> glib::Type7490 fn value_type(&self) -> glib::Type { 7491 Self::static_type() 7492 } 7493 } 7494 7495 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7496 #[non_exhaustive] 7497 #[doc(alias = "GtkTextDirection")] 7498 pub enum TextDirection { 7499 #[doc(alias = "GTK_TEXT_DIR_NONE")] 7500 None, 7501 #[doc(alias = "GTK_TEXT_DIR_LTR")] 7502 Ltr, 7503 #[doc(alias = "GTK_TEXT_DIR_RTL")] 7504 Rtl, 7505 #[doc(hidden)] 7506 __Unknown(i32), 7507 } 7508 7509 impl fmt::Display for TextDirection { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7510 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7511 write!( 7512 f, 7513 "TextDirection::{}", 7514 match *self { 7515 Self::None => "None", 7516 Self::Ltr => "Ltr", 7517 Self::Rtl => "Rtl", 7518 _ => "Unknown", 7519 } 7520 ) 7521 } 7522 } 7523 7524 #[doc(hidden)] 7525 impl IntoGlib for TextDirection { 7526 type GlibType = ffi::GtkTextDirection; 7527 into_glib(self) -> ffi::GtkTextDirection7528 fn into_glib(self) -> ffi::GtkTextDirection { 7529 match self { 7530 Self::None => ffi::GTK_TEXT_DIR_NONE, 7531 Self::Ltr => ffi::GTK_TEXT_DIR_LTR, 7532 Self::Rtl => ffi::GTK_TEXT_DIR_RTL, 7533 Self::__Unknown(value) => value, 7534 } 7535 } 7536 } 7537 7538 #[doc(hidden)] 7539 impl FromGlib<ffi::GtkTextDirection> for TextDirection { from_glib(value: ffi::GtkTextDirection) -> Self7540 unsafe fn from_glib(value: ffi::GtkTextDirection) -> Self { 7541 skip_assert_initialized!(); 7542 match value { 7543 ffi::GTK_TEXT_DIR_NONE => Self::None, 7544 ffi::GTK_TEXT_DIR_LTR => Self::Ltr, 7545 ffi::GTK_TEXT_DIR_RTL => Self::Rtl, 7546 value => Self::__Unknown(value), 7547 } 7548 } 7549 } 7550 7551 impl StaticType for TextDirection { static_type() -> Type7552 fn static_type() -> Type { 7553 unsafe { from_glib(ffi::gtk_text_direction_get_type()) } 7554 } 7555 } 7556 7557 impl glib::value::ValueType for TextDirection { 7558 type Type = Self; 7559 } 7560 7561 unsafe impl<'a> FromValue<'a> for TextDirection { 7562 type Checker = glib::value::GenericValueTypeChecker<Self>; 7563 from_value(value: &'a glib::Value) -> Self7564 unsafe fn from_value(value: &'a glib::Value) -> Self { 7565 skip_assert_initialized!(); 7566 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7567 } 7568 } 7569 7570 impl ToValue for TextDirection { to_value(&self) -> glib::Value7571 fn to_value(&self) -> glib::Value { 7572 let mut value = glib::Value::for_value_type::<Self>(); 7573 unsafe { 7574 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7575 } 7576 value 7577 } 7578 value_type(&self) -> glib::Type7579 fn value_type(&self) -> glib::Type { 7580 Self::static_type() 7581 } 7582 } 7583 7584 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7585 #[non_exhaustive] 7586 #[doc(alias = "GtkTextExtendSelection")] 7587 pub enum TextExtendSelection { 7588 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_WORD")] 7589 Word, 7590 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_LINE")] 7591 Line, 7592 #[doc(hidden)] 7593 __Unknown(i32), 7594 } 7595 7596 impl fmt::Display for TextExtendSelection { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7597 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7598 write!( 7599 f, 7600 "TextExtendSelection::{}", 7601 match *self { 7602 Self::Word => "Word", 7603 Self::Line => "Line", 7604 _ => "Unknown", 7605 } 7606 ) 7607 } 7608 } 7609 7610 #[doc(hidden)] 7611 impl IntoGlib for TextExtendSelection { 7612 type GlibType = ffi::GtkTextExtendSelection; 7613 into_glib(self) -> ffi::GtkTextExtendSelection7614 fn into_glib(self) -> ffi::GtkTextExtendSelection { 7615 match self { 7616 Self::Word => ffi::GTK_TEXT_EXTEND_SELECTION_WORD, 7617 Self::Line => ffi::GTK_TEXT_EXTEND_SELECTION_LINE, 7618 Self::__Unknown(value) => value, 7619 } 7620 } 7621 } 7622 7623 #[doc(hidden)] 7624 impl FromGlib<ffi::GtkTextExtendSelection> for TextExtendSelection { from_glib(value: ffi::GtkTextExtendSelection) -> Self7625 unsafe fn from_glib(value: ffi::GtkTextExtendSelection) -> Self { 7626 skip_assert_initialized!(); 7627 match value { 7628 ffi::GTK_TEXT_EXTEND_SELECTION_WORD => Self::Word, 7629 ffi::GTK_TEXT_EXTEND_SELECTION_LINE => Self::Line, 7630 value => Self::__Unknown(value), 7631 } 7632 } 7633 } 7634 7635 impl StaticType for TextExtendSelection { static_type() -> Type7636 fn static_type() -> Type { 7637 unsafe { from_glib(ffi::gtk_text_extend_selection_get_type()) } 7638 } 7639 } 7640 7641 impl glib::value::ValueType for TextExtendSelection { 7642 type Type = Self; 7643 } 7644 7645 unsafe impl<'a> FromValue<'a> for TextExtendSelection { 7646 type Checker = glib::value::GenericValueTypeChecker<Self>; 7647 from_value(value: &'a glib::Value) -> Self7648 unsafe fn from_value(value: &'a glib::Value) -> Self { 7649 skip_assert_initialized!(); 7650 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7651 } 7652 } 7653 7654 impl ToValue for TextExtendSelection { to_value(&self) -> glib::Value7655 fn to_value(&self) -> glib::Value { 7656 let mut value = glib::Value::for_value_type::<Self>(); 7657 unsafe { 7658 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7659 } 7660 value 7661 } 7662 value_type(&self) -> glib::Type7663 fn value_type(&self) -> glib::Type { 7664 Self::static_type() 7665 } 7666 } 7667 7668 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7669 #[non_exhaustive] 7670 #[doc(alias = "GtkTextViewLayer")] 7671 pub enum TextViewLayer { 7672 #[doc(alias = "GTK_TEXT_VIEW_LAYER_BELOW")] 7673 Below, 7674 #[doc(alias = "GTK_TEXT_VIEW_LAYER_ABOVE")] 7675 Above, 7676 #[doc(alias = "GTK_TEXT_VIEW_LAYER_BELOW_TEXT")] 7677 BelowText, 7678 #[doc(alias = "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT")] 7679 AboveText, 7680 #[doc(hidden)] 7681 __Unknown(i32), 7682 } 7683 7684 impl fmt::Display for TextViewLayer { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7685 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7686 write!( 7687 f, 7688 "TextViewLayer::{}", 7689 match *self { 7690 Self::Below => "Below", 7691 Self::Above => "Above", 7692 Self::BelowText => "BelowText", 7693 Self::AboveText => "AboveText", 7694 _ => "Unknown", 7695 } 7696 ) 7697 } 7698 } 7699 7700 #[doc(hidden)] 7701 impl IntoGlib for TextViewLayer { 7702 type GlibType = ffi::GtkTextViewLayer; 7703 into_glib(self) -> ffi::GtkTextViewLayer7704 fn into_glib(self) -> ffi::GtkTextViewLayer { 7705 match self { 7706 Self::Below => ffi::GTK_TEXT_VIEW_LAYER_BELOW, 7707 Self::Above => ffi::GTK_TEXT_VIEW_LAYER_ABOVE, 7708 Self::BelowText => ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT, 7709 Self::AboveText => ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT, 7710 Self::__Unknown(value) => value, 7711 } 7712 } 7713 } 7714 7715 #[doc(hidden)] 7716 impl FromGlib<ffi::GtkTextViewLayer> for TextViewLayer { from_glib(value: ffi::GtkTextViewLayer) -> Self7717 unsafe fn from_glib(value: ffi::GtkTextViewLayer) -> Self { 7718 skip_assert_initialized!(); 7719 match value { 7720 ffi::GTK_TEXT_VIEW_LAYER_BELOW => Self::Below, 7721 ffi::GTK_TEXT_VIEW_LAYER_ABOVE => Self::Above, 7722 ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT => Self::BelowText, 7723 ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT => Self::AboveText, 7724 value => Self::__Unknown(value), 7725 } 7726 } 7727 } 7728 7729 impl StaticType for TextViewLayer { static_type() -> Type7730 fn static_type() -> Type { 7731 unsafe { from_glib(ffi::gtk_text_view_layer_get_type()) } 7732 } 7733 } 7734 7735 impl glib::value::ValueType for TextViewLayer { 7736 type Type = Self; 7737 } 7738 7739 unsafe impl<'a> FromValue<'a> for TextViewLayer { 7740 type Checker = glib::value::GenericValueTypeChecker<Self>; 7741 from_value(value: &'a glib::Value) -> Self7742 unsafe fn from_value(value: &'a glib::Value) -> Self { 7743 skip_assert_initialized!(); 7744 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7745 } 7746 } 7747 7748 impl ToValue for TextViewLayer { to_value(&self) -> glib::Value7749 fn to_value(&self) -> glib::Value { 7750 let mut value = glib::Value::for_value_type::<Self>(); 7751 unsafe { 7752 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7753 } 7754 value 7755 } 7756 value_type(&self) -> glib::Type7757 fn value_type(&self) -> glib::Type { 7758 Self::static_type() 7759 } 7760 } 7761 7762 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7763 #[non_exhaustive] 7764 #[doc(alias = "GtkTextWindowType")] 7765 pub enum TextWindowType { 7766 #[doc(alias = "GTK_TEXT_WINDOW_PRIVATE")] 7767 Private, 7768 #[doc(alias = "GTK_TEXT_WINDOW_WIDGET")] 7769 Widget, 7770 #[doc(alias = "GTK_TEXT_WINDOW_TEXT")] 7771 Text, 7772 #[doc(alias = "GTK_TEXT_WINDOW_LEFT")] 7773 Left, 7774 #[doc(alias = "GTK_TEXT_WINDOW_RIGHT")] 7775 Right, 7776 #[doc(alias = "GTK_TEXT_WINDOW_TOP")] 7777 Top, 7778 #[doc(alias = "GTK_TEXT_WINDOW_BOTTOM")] 7779 Bottom, 7780 #[doc(hidden)] 7781 __Unknown(i32), 7782 } 7783 7784 impl fmt::Display for TextWindowType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7785 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7786 write!( 7787 f, 7788 "TextWindowType::{}", 7789 match *self { 7790 Self::Private => "Private", 7791 Self::Widget => "Widget", 7792 Self::Text => "Text", 7793 Self::Left => "Left", 7794 Self::Right => "Right", 7795 Self::Top => "Top", 7796 Self::Bottom => "Bottom", 7797 _ => "Unknown", 7798 } 7799 ) 7800 } 7801 } 7802 7803 #[doc(hidden)] 7804 impl IntoGlib for TextWindowType { 7805 type GlibType = ffi::GtkTextWindowType; 7806 into_glib(self) -> ffi::GtkTextWindowType7807 fn into_glib(self) -> ffi::GtkTextWindowType { 7808 match self { 7809 Self::Private => ffi::GTK_TEXT_WINDOW_PRIVATE, 7810 Self::Widget => ffi::GTK_TEXT_WINDOW_WIDGET, 7811 Self::Text => ffi::GTK_TEXT_WINDOW_TEXT, 7812 Self::Left => ffi::GTK_TEXT_WINDOW_LEFT, 7813 Self::Right => ffi::GTK_TEXT_WINDOW_RIGHT, 7814 Self::Top => ffi::GTK_TEXT_WINDOW_TOP, 7815 Self::Bottom => ffi::GTK_TEXT_WINDOW_BOTTOM, 7816 Self::__Unknown(value) => value, 7817 } 7818 } 7819 } 7820 7821 #[doc(hidden)] 7822 impl FromGlib<ffi::GtkTextWindowType> for TextWindowType { from_glib(value: ffi::GtkTextWindowType) -> Self7823 unsafe fn from_glib(value: ffi::GtkTextWindowType) -> Self { 7824 skip_assert_initialized!(); 7825 match value { 7826 ffi::GTK_TEXT_WINDOW_PRIVATE => Self::Private, 7827 ffi::GTK_TEXT_WINDOW_WIDGET => Self::Widget, 7828 ffi::GTK_TEXT_WINDOW_TEXT => Self::Text, 7829 ffi::GTK_TEXT_WINDOW_LEFT => Self::Left, 7830 ffi::GTK_TEXT_WINDOW_RIGHT => Self::Right, 7831 ffi::GTK_TEXT_WINDOW_TOP => Self::Top, 7832 ffi::GTK_TEXT_WINDOW_BOTTOM => Self::Bottom, 7833 value => Self::__Unknown(value), 7834 } 7835 } 7836 } 7837 7838 impl StaticType for TextWindowType { static_type() -> Type7839 fn static_type() -> Type { 7840 unsafe { from_glib(ffi::gtk_text_window_type_get_type()) } 7841 } 7842 } 7843 7844 impl glib::value::ValueType for TextWindowType { 7845 type Type = Self; 7846 } 7847 7848 unsafe impl<'a> FromValue<'a> for TextWindowType { 7849 type Checker = glib::value::GenericValueTypeChecker<Self>; 7850 from_value(value: &'a glib::Value) -> Self7851 unsafe fn from_value(value: &'a glib::Value) -> Self { 7852 skip_assert_initialized!(); 7853 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7854 } 7855 } 7856 7857 impl ToValue for TextWindowType { to_value(&self) -> glib::Value7858 fn to_value(&self) -> glib::Value { 7859 let mut value = glib::Value::for_value_type::<Self>(); 7860 unsafe { 7861 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7862 } 7863 value 7864 } 7865 value_type(&self) -> glib::Type7866 fn value_type(&self) -> glib::Type { 7867 Self::static_type() 7868 } 7869 } 7870 7871 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7872 #[non_exhaustive] 7873 #[doc(alias = "GtkToolbarStyle")] 7874 pub enum ToolbarStyle { 7875 #[doc(alias = "GTK_TOOLBAR_ICONS")] 7876 Icons, 7877 #[doc(alias = "GTK_TOOLBAR_TEXT")] 7878 Text, 7879 #[doc(alias = "GTK_TOOLBAR_BOTH")] 7880 Both, 7881 #[doc(alias = "GTK_TOOLBAR_BOTH_HORIZ")] 7882 BothHoriz, 7883 #[doc(hidden)] 7884 __Unknown(i32), 7885 } 7886 7887 impl fmt::Display for ToolbarStyle { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7888 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7889 write!( 7890 f, 7891 "ToolbarStyle::{}", 7892 match *self { 7893 Self::Icons => "Icons", 7894 Self::Text => "Text", 7895 Self::Both => "Both", 7896 Self::BothHoriz => "BothHoriz", 7897 _ => "Unknown", 7898 } 7899 ) 7900 } 7901 } 7902 7903 #[doc(hidden)] 7904 impl IntoGlib for ToolbarStyle { 7905 type GlibType = ffi::GtkToolbarStyle; 7906 into_glib(self) -> ffi::GtkToolbarStyle7907 fn into_glib(self) -> ffi::GtkToolbarStyle { 7908 match self { 7909 Self::Icons => ffi::GTK_TOOLBAR_ICONS, 7910 Self::Text => ffi::GTK_TOOLBAR_TEXT, 7911 Self::Both => ffi::GTK_TOOLBAR_BOTH, 7912 Self::BothHoriz => ffi::GTK_TOOLBAR_BOTH_HORIZ, 7913 Self::__Unknown(value) => value, 7914 } 7915 } 7916 } 7917 7918 #[doc(hidden)] 7919 impl FromGlib<ffi::GtkToolbarStyle> for ToolbarStyle { from_glib(value: ffi::GtkToolbarStyle) -> Self7920 unsafe fn from_glib(value: ffi::GtkToolbarStyle) -> Self { 7921 skip_assert_initialized!(); 7922 match value { 7923 ffi::GTK_TOOLBAR_ICONS => Self::Icons, 7924 ffi::GTK_TOOLBAR_TEXT => Self::Text, 7925 ffi::GTK_TOOLBAR_BOTH => Self::Both, 7926 ffi::GTK_TOOLBAR_BOTH_HORIZ => Self::BothHoriz, 7927 value => Self::__Unknown(value), 7928 } 7929 } 7930 } 7931 7932 impl StaticType for ToolbarStyle { static_type() -> Type7933 fn static_type() -> Type { 7934 unsafe { from_glib(ffi::gtk_toolbar_style_get_type()) } 7935 } 7936 } 7937 7938 impl glib::value::ValueType for ToolbarStyle { 7939 type Type = Self; 7940 } 7941 7942 unsafe impl<'a> FromValue<'a> for ToolbarStyle { 7943 type Checker = glib::value::GenericValueTypeChecker<Self>; 7944 from_value(value: &'a glib::Value) -> Self7945 unsafe fn from_value(value: &'a glib::Value) -> Self { 7946 skip_assert_initialized!(); 7947 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 7948 } 7949 } 7950 7951 impl ToValue for ToolbarStyle { to_value(&self) -> glib::Value7952 fn to_value(&self) -> glib::Value { 7953 let mut value = glib::Value::for_value_type::<Self>(); 7954 unsafe { 7955 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 7956 } 7957 value 7958 } 7959 value_type(&self) -> glib::Type7960 fn value_type(&self) -> glib::Type { 7961 Self::static_type() 7962 } 7963 } 7964 7965 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 7966 #[non_exhaustive] 7967 #[doc(alias = "GtkTreeViewColumnSizing")] 7968 pub enum TreeViewColumnSizing { 7969 #[doc(alias = "GTK_TREE_VIEW_COLUMN_GROW_ONLY")] 7970 GrowOnly, 7971 #[doc(alias = "GTK_TREE_VIEW_COLUMN_AUTOSIZE")] 7972 Autosize, 7973 #[doc(alias = "GTK_TREE_VIEW_COLUMN_FIXED")] 7974 Fixed, 7975 #[doc(hidden)] 7976 __Unknown(i32), 7977 } 7978 7979 impl fmt::Display for TreeViewColumnSizing { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result7980 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 7981 write!( 7982 f, 7983 "TreeViewColumnSizing::{}", 7984 match *self { 7985 Self::GrowOnly => "GrowOnly", 7986 Self::Autosize => "Autosize", 7987 Self::Fixed => "Fixed", 7988 _ => "Unknown", 7989 } 7990 ) 7991 } 7992 } 7993 7994 #[doc(hidden)] 7995 impl IntoGlib for TreeViewColumnSizing { 7996 type GlibType = ffi::GtkTreeViewColumnSizing; 7997 into_glib(self) -> ffi::GtkTreeViewColumnSizing7998 fn into_glib(self) -> ffi::GtkTreeViewColumnSizing { 7999 match self { 8000 Self::GrowOnly => ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY, 8001 Self::Autosize => ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE, 8002 Self::Fixed => ffi::GTK_TREE_VIEW_COLUMN_FIXED, 8003 Self::__Unknown(value) => value, 8004 } 8005 } 8006 } 8007 8008 #[doc(hidden)] 8009 impl FromGlib<ffi::GtkTreeViewColumnSizing> for TreeViewColumnSizing { from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self8010 unsafe fn from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self { 8011 skip_assert_initialized!(); 8012 match value { 8013 ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY => Self::GrowOnly, 8014 ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE => Self::Autosize, 8015 ffi::GTK_TREE_VIEW_COLUMN_FIXED => Self::Fixed, 8016 value => Self::__Unknown(value), 8017 } 8018 } 8019 } 8020 8021 impl StaticType for TreeViewColumnSizing { static_type() -> Type8022 fn static_type() -> Type { 8023 unsafe { from_glib(ffi::gtk_tree_view_column_sizing_get_type()) } 8024 } 8025 } 8026 8027 impl glib::value::ValueType for TreeViewColumnSizing { 8028 type Type = Self; 8029 } 8030 8031 unsafe impl<'a> FromValue<'a> for TreeViewColumnSizing { 8032 type Checker = glib::value::GenericValueTypeChecker<Self>; 8033 from_value(value: &'a glib::Value) -> Self8034 unsafe fn from_value(value: &'a glib::Value) -> Self { 8035 skip_assert_initialized!(); 8036 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 8037 } 8038 } 8039 8040 impl ToValue for TreeViewColumnSizing { to_value(&self) -> glib::Value8041 fn to_value(&self) -> glib::Value { 8042 let mut value = glib::Value::for_value_type::<Self>(); 8043 unsafe { 8044 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 8045 } 8046 value 8047 } 8048 value_type(&self) -> glib::Type8049 fn value_type(&self) -> glib::Type { 8050 Self::static_type() 8051 } 8052 } 8053 8054 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 8055 #[non_exhaustive] 8056 #[doc(alias = "GtkTreeViewDropPosition")] 8057 pub enum TreeViewDropPosition { 8058 #[doc(alias = "GTK_TREE_VIEW_DROP_BEFORE")] 8059 Before, 8060 #[doc(alias = "GTK_TREE_VIEW_DROP_AFTER")] 8061 After, 8062 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE")] 8063 IntoOrBefore, 8064 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_AFTER")] 8065 IntoOrAfter, 8066 #[doc(hidden)] 8067 __Unknown(i32), 8068 } 8069 8070 impl fmt::Display for TreeViewDropPosition { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result8071 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 8072 write!( 8073 f, 8074 "TreeViewDropPosition::{}", 8075 match *self { 8076 Self::Before => "Before", 8077 Self::After => "After", 8078 Self::IntoOrBefore => "IntoOrBefore", 8079 Self::IntoOrAfter => "IntoOrAfter", 8080 _ => "Unknown", 8081 } 8082 ) 8083 } 8084 } 8085 8086 #[doc(hidden)] 8087 impl IntoGlib for TreeViewDropPosition { 8088 type GlibType = ffi::GtkTreeViewDropPosition; 8089 into_glib(self) -> ffi::GtkTreeViewDropPosition8090 fn into_glib(self) -> ffi::GtkTreeViewDropPosition { 8091 match self { 8092 Self::Before => ffi::GTK_TREE_VIEW_DROP_BEFORE, 8093 Self::After => ffi::GTK_TREE_VIEW_DROP_AFTER, 8094 Self::IntoOrBefore => ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE, 8095 Self::IntoOrAfter => ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER, 8096 Self::__Unknown(value) => value, 8097 } 8098 } 8099 } 8100 8101 #[doc(hidden)] 8102 impl FromGlib<ffi::GtkTreeViewDropPosition> for TreeViewDropPosition { from_glib(value: ffi::GtkTreeViewDropPosition) -> Self8103 unsafe fn from_glib(value: ffi::GtkTreeViewDropPosition) -> Self { 8104 skip_assert_initialized!(); 8105 match value { 8106 ffi::GTK_TREE_VIEW_DROP_BEFORE => Self::Before, 8107 ffi::GTK_TREE_VIEW_DROP_AFTER => Self::After, 8108 ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => Self::IntoOrBefore, 8109 ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER => Self::IntoOrAfter, 8110 value => Self::__Unknown(value), 8111 } 8112 } 8113 } 8114 8115 impl StaticType for TreeViewDropPosition { static_type() -> Type8116 fn static_type() -> Type { 8117 unsafe { from_glib(ffi::gtk_tree_view_drop_position_get_type()) } 8118 } 8119 } 8120 8121 impl glib::value::ValueType for TreeViewDropPosition { 8122 type Type = Self; 8123 } 8124 8125 unsafe impl<'a> FromValue<'a> for TreeViewDropPosition { 8126 type Checker = glib::value::GenericValueTypeChecker<Self>; 8127 from_value(value: &'a glib::Value) -> Self8128 unsafe fn from_value(value: &'a glib::Value) -> Self { 8129 skip_assert_initialized!(); 8130 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 8131 } 8132 } 8133 8134 impl ToValue for TreeViewDropPosition { to_value(&self) -> glib::Value8135 fn to_value(&self) -> glib::Value { 8136 let mut value = glib::Value::for_value_type::<Self>(); 8137 unsafe { 8138 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 8139 } 8140 value 8141 } 8142 value_type(&self) -> glib::Type8143 fn value_type(&self) -> glib::Type { 8144 Self::static_type() 8145 } 8146 } 8147 8148 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 8149 #[non_exhaustive] 8150 #[doc(alias = "GtkTreeViewGridLines")] 8151 pub enum TreeViewGridLines { 8152 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_NONE")] 8153 None, 8154 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL")] 8155 Horizontal, 8156 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_VERTICAL")] 8157 Vertical, 8158 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_BOTH")] 8159 Both, 8160 #[doc(hidden)] 8161 __Unknown(i32), 8162 } 8163 8164 impl fmt::Display for TreeViewGridLines { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result8165 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 8166 write!( 8167 f, 8168 "TreeViewGridLines::{}", 8169 match *self { 8170 Self::None => "None", 8171 Self::Horizontal => "Horizontal", 8172 Self::Vertical => "Vertical", 8173 Self::Both => "Both", 8174 _ => "Unknown", 8175 } 8176 ) 8177 } 8178 } 8179 8180 #[doc(hidden)] 8181 impl IntoGlib for TreeViewGridLines { 8182 type GlibType = ffi::GtkTreeViewGridLines; 8183 into_glib(self) -> ffi::GtkTreeViewGridLines8184 fn into_glib(self) -> ffi::GtkTreeViewGridLines { 8185 match self { 8186 Self::None => ffi::GTK_TREE_VIEW_GRID_LINES_NONE, 8187 Self::Horizontal => ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL, 8188 Self::Vertical => ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL, 8189 Self::Both => ffi::GTK_TREE_VIEW_GRID_LINES_BOTH, 8190 Self::__Unknown(value) => value, 8191 } 8192 } 8193 } 8194 8195 #[doc(hidden)] 8196 impl FromGlib<ffi::GtkTreeViewGridLines> for TreeViewGridLines { from_glib(value: ffi::GtkTreeViewGridLines) -> Self8197 unsafe fn from_glib(value: ffi::GtkTreeViewGridLines) -> Self { 8198 skip_assert_initialized!(); 8199 match value { 8200 ffi::GTK_TREE_VIEW_GRID_LINES_NONE => Self::None, 8201 ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL => Self::Horizontal, 8202 ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL => Self::Vertical, 8203 ffi::GTK_TREE_VIEW_GRID_LINES_BOTH => Self::Both, 8204 value => Self::__Unknown(value), 8205 } 8206 } 8207 } 8208 8209 impl StaticType for TreeViewGridLines { static_type() -> Type8210 fn static_type() -> Type { 8211 unsafe { from_glib(ffi::gtk_tree_view_grid_lines_get_type()) } 8212 } 8213 } 8214 8215 impl glib::value::ValueType for TreeViewGridLines { 8216 type Type = Self; 8217 } 8218 8219 unsafe impl<'a> FromValue<'a> for TreeViewGridLines { 8220 type Checker = glib::value::GenericValueTypeChecker<Self>; 8221 from_value(value: &'a glib::Value) -> Self8222 unsafe fn from_value(value: &'a glib::Value) -> Self { 8223 skip_assert_initialized!(); 8224 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 8225 } 8226 } 8227 8228 impl ToValue for TreeViewGridLines { to_value(&self) -> glib::Value8229 fn to_value(&self) -> glib::Value { 8230 let mut value = glib::Value::for_value_type::<Self>(); 8231 unsafe { 8232 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 8233 } 8234 value 8235 } 8236 value_type(&self) -> glib::Type8237 fn value_type(&self) -> glib::Type { 8238 Self::static_type() 8239 } 8240 } 8241 8242 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 8243 #[non_exhaustive] 8244 #[doc(alias = "GtkUnit")] 8245 pub enum Unit { 8246 #[doc(alias = "GTK_UNIT_NONE")] 8247 None, 8248 #[doc(alias = "GTK_UNIT_POINTS")] 8249 Points, 8250 #[doc(alias = "GTK_UNIT_INCH")] 8251 Inch, 8252 #[doc(alias = "GTK_UNIT_MM")] 8253 Mm, 8254 #[doc(hidden)] 8255 __Unknown(i32), 8256 } 8257 8258 impl fmt::Display for Unit { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result8259 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 8260 write!( 8261 f, 8262 "Unit::{}", 8263 match *self { 8264 Self::None => "None", 8265 Self::Points => "Points", 8266 Self::Inch => "Inch", 8267 Self::Mm => "Mm", 8268 _ => "Unknown", 8269 } 8270 ) 8271 } 8272 } 8273 8274 #[doc(hidden)] 8275 impl IntoGlib for Unit { 8276 type GlibType = ffi::GtkUnit; 8277 into_glib(self) -> ffi::GtkUnit8278 fn into_glib(self) -> ffi::GtkUnit { 8279 match self { 8280 Self::None => ffi::GTK_UNIT_NONE, 8281 Self::Points => ffi::GTK_UNIT_POINTS, 8282 Self::Inch => ffi::GTK_UNIT_INCH, 8283 Self::Mm => ffi::GTK_UNIT_MM, 8284 Self::__Unknown(value) => value, 8285 } 8286 } 8287 } 8288 8289 #[doc(hidden)] 8290 impl FromGlib<ffi::GtkUnit> for Unit { from_glib(value: ffi::GtkUnit) -> Self8291 unsafe fn from_glib(value: ffi::GtkUnit) -> Self { 8292 skip_assert_initialized!(); 8293 match value { 8294 ffi::GTK_UNIT_NONE => Self::None, 8295 ffi::GTK_UNIT_POINTS => Self::Points, 8296 ffi::GTK_UNIT_INCH => Self::Inch, 8297 ffi::GTK_UNIT_MM => Self::Mm, 8298 value => Self::__Unknown(value), 8299 } 8300 } 8301 } 8302 8303 impl StaticType for Unit { static_type() -> Type8304 fn static_type() -> Type { 8305 unsafe { from_glib(ffi::gtk_unit_get_type()) } 8306 } 8307 } 8308 8309 impl glib::value::ValueType for Unit { 8310 type Type = Self; 8311 } 8312 8313 unsafe impl<'a> FromValue<'a> for Unit { 8314 type Checker = glib::value::GenericValueTypeChecker<Self>; 8315 from_value(value: &'a glib::Value) -> Self8316 unsafe fn from_value(value: &'a glib::Value) -> Self { 8317 skip_assert_initialized!(); 8318 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 8319 } 8320 } 8321 8322 impl ToValue for Unit { to_value(&self) -> glib::Value8323 fn to_value(&self) -> glib::Value { 8324 let mut value = glib::Value::for_value_type::<Self>(); 8325 unsafe { 8326 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 8327 } 8328 value 8329 } 8330 value_type(&self) -> glib::Type8331 fn value_type(&self) -> glib::Type { 8332 Self::static_type() 8333 } 8334 } 8335 8336 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 8337 #[non_exhaustive] 8338 #[doc(alias = "GtkWidgetHelpType")] 8339 pub enum WidgetHelpType { 8340 #[doc(alias = "GTK_WIDGET_HELP_TOOLTIP")] 8341 Tooltip, 8342 #[doc(alias = "GTK_WIDGET_HELP_WHATS_THIS")] 8343 WhatsThis, 8344 #[doc(hidden)] 8345 __Unknown(i32), 8346 } 8347 8348 impl fmt::Display for WidgetHelpType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result8349 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 8350 write!( 8351 f, 8352 "WidgetHelpType::{}", 8353 match *self { 8354 Self::Tooltip => "Tooltip", 8355 Self::WhatsThis => "WhatsThis", 8356 _ => "Unknown", 8357 } 8358 ) 8359 } 8360 } 8361 8362 #[doc(hidden)] 8363 impl IntoGlib for WidgetHelpType { 8364 type GlibType = ffi::GtkWidgetHelpType; 8365 into_glib(self) -> ffi::GtkWidgetHelpType8366 fn into_glib(self) -> ffi::GtkWidgetHelpType { 8367 match self { 8368 Self::Tooltip => ffi::GTK_WIDGET_HELP_TOOLTIP, 8369 Self::WhatsThis => ffi::GTK_WIDGET_HELP_WHATS_THIS, 8370 Self::__Unknown(value) => value, 8371 } 8372 } 8373 } 8374 8375 #[doc(hidden)] 8376 impl FromGlib<ffi::GtkWidgetHelpType> for WidgetHelpType { from_glib(value: ffi::GtkWidgetHelpType) -> Self8377 unsafe fn from_glib(value: ffi::GtkWidgetHelpType) -> Self { 8378 skip_assert_initialized!(); 8379 match value { 8380 ffi::GTK_WIDGET_HELP_TOOLTIP => Self::Tooltip, 8381 ffi::GTK_WIDGET_HELP_WHATS_THIS => Self::WhatsThis, 8382 value => Self::__Unknown(value), 8383 } 8384 } 8385 } 8386 8387 impl StaticType for WidgetHelpType { static_type() -> Type8388 fn static_type() -> Type { 8389 unsafe { from_glib(ffi::gtk_widget_help_type_get_type()) } 8390 } 8391 } 8392 8393 impl glib::value::ValueType for WidgetHelpType { 8394 type Type = Self; 8395 } 8396 8397 unsafe impl<'a> FromValue<'a> for WidgetHelpType { 8398 type Checker = glib::value::GenericValueTypeChecker<Self>; 8399 from_value(value: &'a glib::Value) -> Self8400 unsafe fn from_value(value: &'a glib::Value) -> Self { 8401 skip_assert_initialized!(); 8402 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 8403 } 8404 } 8405 8406 impl ToValue for WidgetHelpType { to_value(&self) -> glib::Value8407 fn to_value(&self) -> glib::Value { 8408 let mut value = glib::Value::for_value_type::<Self>(); 8409 unsafe { 8410 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 8411 } 8412 value 8413 } 8414 value_type(&self) -> glib::Type8415 fn value_type(&self) -> glib::Type { 8416 Self::static_type() 8417 } 8418 } 8419 8420 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 8421 #[non_exhaustive] 8422 #[doc(alias = "GtkWindowPosition")] 8423 pub enum WindowPosition { 8424 #[doc(alias = "GTK_WIN_POS_NONE")] 8425 None, 8426 #[doc(alias = "GTK_WIN_POS_CENTER")] 8427 Center, 8428 #[doc(alias = "GTK_WIN_POS_MOUSE")] 8429 Mouse, 8430 #[doc(alias = "GTK_WIN_POS_CENTER_ALWAYS")] 8431 CenterAlways, 8432 #[doc(alias = "GTK_WIN_POS_CENTER_ON_PARENT")] 8433 CenterOnParent, 8434 #[doc(hidden)] 8435 __Unknown(i32), 8436 } 8437 8438 impl fmt::Display for WindowPosition { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result8439 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 8440 write!( 8441 f, 8442 "WindowPosition::{}", 8443 match *self { 8444 Self::None => "None", 8445 Self::Center => "Center", 8446 Self::Mouse => "Mouse", 8447 Self::CenterAlways => "CenterAlways", 8448 Self::CenterOnParent => "CenterOnParent", 8449 _ => "Unknown", 8450 } 8451 ) 8452 } 8453 } 8454 8455 #[doc(hidden)] 8456 impl IntoGlib for WindowPosition { 8457 type GlibType = ffi::GtkWindowPosition; 8458 into_glib(self) -> ffi::GtkWindowPosition8459 fn into_glib(self) -> ffi::GtkWindowPosition { 8460 match self { 8461 Self::None => ffi::GTK_WIN_POS_NONE, 8462 Self::Center => ffi::GTK_WIN_POS_CENTER, 8463 Self::Mouse => ffi::GTK_WIN_POS_MOUSE, 8464 Self::CenterAlways => ffi::GTK_WIN_POS_CENTER_ALWAYS, 8465 Self::CenterOnParent => ffi::GTK_WIN_POS_CENTER_ON_PARENT, 8466 Self::__Unknown(value) => value, 8467 } 8468 } 8469 } 8470 8471 #[doc(hidden)] 8472 impl FromGlib<ffi::GtkWindowPosition> for WindowPosition { from_glib(value: ffi::GtkWindowPosition) -> Self8473 unsafe fn from_glib(value: ffi::GtkWindowPosition) -> Self { 8474 skip_assert_initialized!(); 8475 match value { 8476 ffi::GTK_WIN_POS_NONE => Self::None, 8477 ffi::GTK_WIN_POS_CENTER => Self::Center, 8478 ffi::GTK_WIN_POS_MOUSE => Self::Mouse, 8479 ffi::GTK_WIN_POS_CENTER_ALWAYS => Self::CenterAlways, 8480 ffi::GTK_WIN_POS_CENTER_ON_PARENT => Self::CenterOnParent, 8481 value => Self::__Unknown(value), 8482 } 8483 } 8484 } 8485 8486 impl StaticType for WindowPosition { static_type() -> Type8487 fn static_type() -> Type { 8488 unsafe { from_glib(ffi::gtk_window_position_get_type()) } 8489 } 8490 } 8491 8492 impl glib::value::ValueType for WindowPosition { 8493 type Type = Self; 8494 } 8495 8496 unsafe impl<'a> FromValue<'a> for WindowPosition { 8497 type Checker = glib::value::GenericValueTypeChecker<Self>; 8498 from_value(value: &'a glib::Value) -> Self8499 unsafe fn from_value(value: &'a glib::Value) -> Self { 8500 skip_assert_initialized!(); 8501 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 8502 } 8503 } 8504 8505 impl ToValue for WindowPosition { to_value(&self) -> glib::Value8506 fn to_value(&self) -> glib::Value { 8507 let mut value = glib::Value::for_value_type::<Self>(); 8508 unsafe { 8509 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 8510 } 8511 value 8512 } 8513 value_type(&self) -> glib::Type8514 fn value_type(&self) -> glib::Type { 8515 Self::static_type() 8516 } 8517 } 8518 8519 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 8520 #[non_exhaustive] 8521 #[doc(alias = "GtkWindowType")] 8522 pub enum WindowType { 8523 #[doc(alias = "GTK_WINDOW_TOPLEVEL")] 8524 Toplevel, 8525 #[doc(alias = "GTK_WINDOW_POPUP")] 8526 Popup, 8527 #[doc(hidden)] 8528 __Unknown(i32), 8529 } 8530 8531 impl fmt::Display for WindowType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result8532 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 8533 write!( 8534 f, 8535 "WindowType::{}", 8536 match *self { 8537 Self::Toplevel => "Toplevel", 8538 Self::Popup => "Popup", 8539 _ => "Unknown", 8540 } 8541 ) 8542 } 8543 } 8544 8545 #[doc(hidden)] 8546 impl IntoGlib for WindowType { 8547 type GlibType = ffi::GtkWindowType; 8548 into_glib(self) -> ffi::GtkWindowType8549 fn into_glib(self) -> ffi::GtkWindowType { 8550 match self { 8551 Self::Toplevel => ffi::GTK_WINDOW_TOPLEVEL, 8552 Self::Popup => ffi::GTK_WINDOW_POPUP, 8553 Self::__Unknown(value) => value, 8554 } 8555 } 8556 } 8557 8558 #[doc(hidden)] 8559 impl FromGlib<ffi::GtkWindowType> for WindowType { from_glib(value: ffi::GtkWindowType) -> Self8560 unsafe fn from_glib(value: ffi::GtkWindowType) -> Self { 8561 skip_assert_initialized!(); 8562 match value { 8563 ffi::GTK_WINDOW_TOPLEVEL => Self::Toplevel, 8564 ffi::GTK_WINDOW_POPUP => Self::Popup, 8565 value => Self::__Unknown(value), 8566 } 8567 } 8568 } 8569 8570 impl StaticType for WindowType { static_type() -> Type8571 fn static_type() -> Type { 8572 unsafe { from_glib(ffi::gtk_window_type_get_type()) } 8573 } 8574 } 8575 8576 impl glib::value::ValueType for WindowType { 8577 type Type = Self; 8578 } 8579 8580 unsafe impl<'a> FromValue<'a> for WindowType { 8581 type Checker = glib::value::GenericValueTypeChecker<Self>; 8582 from_value(value: &'a glib::Value) -> Self8583 unsafe fn from_value(value: &'a glib::Value) -> Self { 8584 skip_assert_initialized!(); 8585 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 8586 } 8587 } 8588 8589 impl ToValue for WindowType { to_value(&self) -> glib::Value8590 fn to_value(&self) -> glib::Value { 8591 let mut value = glib::Value::for_value_type::<Self>(); 8592 unsafe { 8593 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 8594 } 8595 value 8596 } 8597 value_type(&self) -> glib::Type8598 fn value_type(&self) -> glib::Type { 8599 Self::static_type() 8600 } 8601 } 8602 8603 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 8604 #[non_exhaustive] 8605 #[doc(alias = "GtkWrapMode")] 8606 pub enum WrapMode { 8607 #[doc(alias = "GTK_WRAP_NONE")] 8608 None, 8609 #[doc(alias = "GTK_WRAP_CHAR")] 8610 Char, 8611 #[doc(alias = "GTK_WRAP_WORD")] 8612 Word, 8613 #[doc(alias = "GTK_WRAP_WORD_CHAR")] 8614 WordChar, 8615 #[doc(hidden)] 8616 __Unknown(i32), 8617 } 8618 8619 impl fmt::Display for WrapMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result8620 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 8621 write!( 8622 f, 8623 "WrapMode::{}", 8624 match *self { 8625 Self::None => "None", 8626 Self::Char => "Char", 8627 Self::Word => "Word", 8628 Self::WordChar => "WordChar", 8629 _ => "Unknown", 8630 } 8631 ) 8632 } 8633 } 8634 8635 #[doc(hidden)] 8636 impl IntoGlib for WrapMode { 8637 type GlibType = ffi::GtkWrapMode; 8638 into_glib(self) -> ffi::GtkWrapMode8639 fn into_glib(self) -> ffi::GtkWrapMode { 8640 match self { 8641 Self::None => ffi::GTK_WRAP_NONE, 8642 Self::Char => ffi::GTK_WRAP_CHAR, 8643 Self::Word => ffi::GTK_WRAP_WORD, 8644 Self::WordChar => ffi::GTK_WRAP_WORD_CHAR, 8645 Self::__Unknown(value) => value, 8646 } 8647 } 8648 } 8649 8650 #[doc(hidden)] 8651 impl FromGlib<ffi::GtkWrapMode> for WrapMode { from_glib(value: ffi::GtkWrapMode) -> Self8652 unsafe fn from_glib(value: ffi::GtkWrapMode) -> Self { 8653 skip_assert_initialized!(); 8654 match value { 8655 ffi::GTK_WRAP_NONE => Self::None, 8656 ffi::GTK_WRAP_CHAR => Self::Char, 8657 ffi::GTK_WRAP_WORD => Self::Word, 8658 ffi::GTK_WRAP_WORD_CHAR => Self::WordChar, 8659 value => Self::__Unknown(value), 8660 } 8661 } 8662 } 8663 8664 impl StaticType for WrapMode { static_type() -> Type8665 fn static_type() -> Type { 8666 unsafe { from_glib(ffi::gtk_wrap_mode_get_type()) } 8667 } 8668 } 8669 8670 impl glib::value::ValueType for WrapMode { 8671 type Type = Self; 8672 } 8673 8674 unsafe impl<'a> FromValue<'a> for WrapMode { 8675 type Checker = glib::value::GenericValueTypeChecker<Self>; 8676 from_value(value: &'a glib::Value) -> Self8677 unsafe fn from_value(value: &'a glib::Value) -> Self { 8678 skip_assert_initialized!(); 8679 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 8680 } 8681 } 8682 8683 impl ToValue for WrapMode { to_value(&self) -> glib::Value8684 fn to_value(&self) -> glib::Value { 8685 let mut value = glib::Value::for_value_type::<Self>(); 8686 unsafe { 8687 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 8688 } 8689 value 8690 } 8691 value_type(&self) -> glib::Type8692 fn value_type(&self) -> glib::Type { 8693 Self::static_type() 8694 } 8695 } 8696