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 14 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 15 #[non_exhaustive] 16 #[doc(alias = "GdkAxisUse")] 17 pub enum AxisUse { 18 #[doc(alias = "GDK_AXIS_IGNORE")] 19 Ignore, 20 #[doc(alias = "GDK_AXIS_X")] 21 X, 22 #[doc(alias = "GDK_AXIS_Y")] 23 Y, 24 #[doc(alias = "GDK_AXIS_PRESSURE")] 25 Pressure, 26 #[doc(alias = "GDK_AXIS_XTILT")] 27 Xtilt, 28 #[doc(alias = "GDK_AXIS_YTILT")] 29 Ytilt, 30 #[doc(alias = "GDK_AXIS_WHEEL")] 31 Wheel, 32 #[doc(alias = "GDK_AXIS_DISTANCE")] 33 Distance, 34 #[doc(alias = "GDK_AXIS_ROTATION")] 35 Rotation, 36 #[doc(alias = "GDK_AXIS_SLIDER")] 37 Slider, 38 #[doc(alias = "GDK_AXIS_LAST")] 39 Last, 40 #[doc(hidden)] 41 __Unknown(i32), 42 } 43 44 impl fmt::Display for AxisUse { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result45 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 46 write!( 47 f, 48 "AxisUse::{}", 49 match *self { 50 Self::Ignore => "Ignore", 51 Self::X => "X", 52 Self::Y => "Y", 53 Self::Pressure => "Pressure", 54 Self::Xtilt => "Xtilt", 55 Self::Ytilt => "Ytilt", 56 Self::Wheel => "Wheel", 57 Self::Distance => "Distance", 58 Self::Rotation => "Rotation", 59 Self::Slider => "Slider", 60 Self::Last => "Last", 61 _ => "Unknown", 62 } 63 ) 64 } 65 } 66 67 #[doc(hidden)] 68 impl IntoGlib for AxisUse { 69 type GlibType = ffi::GdkAxisUse; 70 into_glib(self) -> ffi::GdkAxisUse71 fn into_glib(self) -> ffi::GdkAxisUse { 72 match self { 73 Self::Ignore => ffi::GDK_AXIS_IGNORE, 74 Self::X => ffi::GDK_AXIS_X, 75 Self::Y => ffi::GDK_AXIS_Y, 76 Self::Pressure => ffi::GDK_AXIS_PRESSURE, 77 Self::Xtilt => ffi::GDK_AXIS_XTILT, 78 Self::Ytilt => ffi::GDK_AXIS_YTILT, 79 Self::Wheel => ffi::GDK_AXIS_WHEEL, 80 Self::Distance => ffi::GDK_AXIS_DISTANCE, 81 Self::Rotation => ffi::GDK_AXIS_ROTATION, 82 Self::Slider => ffi::GDK_AXIS_SLIDER, 83 Self::Last => ffi::GDK_AXIS_LAST, 84 Self::__Unknown(value) => value, 85 } 86 } 87 } 88 89 #[doc(hidden)] 90 impl FromGlib<ffi::GdkAxisUse> for AxisUse { from_glib(value: ffi::GdkAxisUse) -> Self91 unsafe fn from_glib(value: ffi::GdkAxisUse) -> Self { 92 skip_assert_initialized!(); 93 match value { 94 ffi::GDK_AXIS_IGNORE => Self::Ignore, 95 ffi::GDK_AXIS_X => Self::X, 96 ffi::GDK_AXIS_Y => Self::Y, 97 ffi::GDK_AXIS_PRESSURE => Self::Pressure, 98 ffi::GDK_AXIS_XTILT => Self::Xtilt, 99 ffi::GDK_AXIS_YTILT => Self::Ytilt, 100 ffi::GDK_AXIS_WHEEL => Self::Wheel, 101 ffi::GDK_AXIS_DISTANCE => Self::Distance, 102 ffi::GDK_AXIS_ROTATION => Self::Rotation, 103 ffi::GDK_AXIS_SLIDER => Self::Slider, 104 ffi::GDK_AXIS_LAST => Self::Last, 105 value => Self::__Unknown(value), 106 } 107 } 108 } 109 110 impl StaticType for AxisUse { static_type() -> Type111 fn static_type() -> Type { 112 unsafe { from_glib(ffi::gdk_axis_use_get_type()) } 113 } 114 } 115 116 impl glib::value::ValueType for AxisUse { 117 type Type = Self; 118 } 119 120 unsafe impl<'a> FromValue<'a> for AxisUse { 121 type Checker = glib::value::GenericValueTypeChecker<Self>; 122 from_value(value: &'a glib::Value) -> Self123 unsafe fn from_value(value: &'a glib::Value) -> Self { 124 skip_assert_initialized!(); 125 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 126 } 127 } 128 129 impl ToValue for AxisUse { to_value(&self) -> glib::Value130 fn to_value(&self) -> glib::Value { 131 let mut value = glib::Value::for_value_type::<Self>(); 132 unsafe { 133 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 134 } 135 value 136 } 137 value_type(&self) -> glib::Type138 fn value_type(&self) -> glib::Type { 139 Self::static_type() 140 } 141 } 142 143 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 144 #[non_exhaustive] 145 #[doc(alias = "GdkByteOrder")] 146 pub enum ByteOrder { 147 #[doc(alias = "GDK_LSB_FIRST")] 148 LsbFirst, 149 #[doc(alias = "GDK_MSB_FIRST")] 150 MsbFirst, 151 #[doc(hidden)] 152 __Unknown(i32), 153 } 154 155 impl fmt::Display for ByteOrder { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result156 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 157 write!( 158 f, 159 "ByteOrder::{}", 160 match *self { 161 Self::LsbFirst => "LsbFirst", 162 Self::MsbFirst => "MsbFirst", 163 _ => "Unknown", 164 } 165 ) 166 } 167 } 168 169 #[doc(hidden)] 170 impl IntoGlib for ByteOrder { 171 type GlibType = ffi::GdkByteOrder; 172 into_glib(self) -> ffi::GdkByteOrder173 fn into_glib(self) -> ffi::GdkByteOrder { 174 match self { 175 Self::LsbFirst => ffi::GDK_LSB_FIRST, 176 Self::MsbFirst => ffi::GDK_MSB_FIRST, 177 Self::__Unknown(value) => value, 178 } 179 } 180 } 181 182 #[doc(hidden)] 183 impl FromGlib<ffi::GdkByteOrder> for ByteOrder { from_glib(value: ffi::GdkByteOrder) -> Self184 unsafe fn from_glib(value: ffi::GdkByteOrder) -> Self { 185 skip_assert_initialized!(); 186 match value { 187 ffi::GDK_LSB_FIRST => Self::LsbFirst, 188 ffi::GDK_MSB_FIRST => Self::MsbFirst, 189 value => Self::__Unknown(value), 190 } 191 } 192 } 193 194 impl StaticType for ByteOrder { static_type() -> Type195 fn static_type() -> Type { 196 unsafe { from_glib(ffi::gdk_byte_order_get_type()) } 197 } 198 } 199 200 impl glib::value::ValueType for ByteOrder { 201 type Type = Self; 202 } 203 204 unsafe impl<'a> FromValue<'a> for ByteOrder { 205 type Checker = glib::value::GenericValueTypeChecker<Self>; 206 from_value(value: &'a glib::Value) -> Self207 unsafe fn from_value(value: &'a glib::Value) -> Self { 208 skip_assert_initialized!(); 209 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 210 } 211 } 212 213 impl ToValue for ByteOrder { to_value(&self) -> glib::Value214 fn to_value(&self) -> glib::Value { 215 let mut value = glib::Value::for_value_type::<Self>(); 216 unsafe { 217 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 218 } 219 value 220 } 221 value_type(&self) -> glib::Type222 fn value_type(&self) -> glib::Type { 223 Self::static_type() 224 } 225 } 226 227 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 228 #[non_exhaustive] 229 #[doc(alias = "GdkCrossingMode")] 230 pub enum CrossingMode { 231 #[doc(alias = "GDK_CROSSING_NORMAL")] 232 Normal, 233 #[doc(alias = "GDK_CROSSING_GRAB")] 234 Grab, 235 #[doc(alias = "GDK_CROSSING_UNGRAB")] 236 Ungrab, 237 #[doc(alias = "GDK_CROSSING_GTK_GRAB")] 238 GtkGrab, 239 #[doc(alias = "GDK_CROSSING_GTK_UNGRAB")] 240 GtkUngrab, 241 #[doc(alias = "GDK_CROSSING_STATE_CHANGED")] 242 StateChanged, 243 #[doc(alias = "GDK_CROSSING_TOUCH_BEGIN")] 244 TouchBegin, 245 #[doc(alias = "GDK_CROSSING_TOUCH_END")] 246 TouchEnd, 247 #[doc(alias = "GDK_CROSSING_DEVICE_SWITCH")] 248 DeviceSwitch, 249 #[doc(hidden)] 250 __Unknown(i32), 251 } 252 253 impl fmt::Display for CrossingMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result254 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 255 write!( 256 f, 257 "CrossingMode::{}", 258 match *self { 259 Self::Normal => "Normal", 260 Self::Grab => "Grab", 261 Self::Ungrab => "Ungrab", 262 Self::GtkGrab => "GtkGrab", 263 Self::GtkUngrab => "GtkUngrab", 264 Self::StateChanged => "StateChanged", 265 Self::TouchBegin => "TouchBegin", 266 Self::TouchEnd => "TouchEnd", 267 Self::DeviceSwitch => "DeviceSwitch", 268 _ => "Unknown", 269 } 270 ) 271 } 272 } 273 274 #[doc(hidden)] 275 impl IntoGlib for CrossingMode { 276 type GlibType = ffi::GdkCrossingMode; 277 into_glib(self) -> ffi::GdkCrossingMode278 fn into_glib(self) -> ffi::GdkCrossingMode { 279 match self { 280 Self::Normal => ffi::GDK_CROSSING_NORMAL, 281 Self::Grab => ffi::GDK_CROSSING_GRAB, 282 Self::Ungrab => ffi::GDK_CROSSING_UNGRAB, 283 Self::GtkGrab => ffi::GDK_CROSSING_GTK_GRAB, 284 Self::GtkUngrab => ffi::GDK_CROSSING_GTK_UNGRAB, 285 Self::StateChanged => ffi::GDK_CROSSING_STATE_CHANGED, 286 Self::TouchBegin => ffi::GDK_CROSSING_TOUCH_BEGIN, 287 Self::TouchEnd => ffi::GDK_CROSSING_TOUCH_END, 288 Self::DeviceSwitch => ffi::GDK_CROSSING_DEVICE_SWITCH, 289 Self::__Unknown(value) => value, 290 } 291 } 292 } 293 294 #[doc(hidden)] 295 impl FromGlib<ffi::GdkCrossingMode> for CrossingMode { from_glib(value: ffi::GdkCrossingMode) -> Self296 unsafe fn from_glib(value: ffi::GdkCrossingMode) -> Self { 297 skip_assert_initialized!(); 298 match value { 299 ffi::GDK_CROSSING_NORMAL => Self::Normal, 300 ffi::GDK_CROSSING_GRAB => Self::Grab, 301 ffi::GDK_CROSSING_UNGRAB => Self::Ungrab, 302 ffi::GDK_CROSSING_GTK_GRAB => Self::GtkGrab, 303 ffi::GDK_CROSSING_GTK_UNGRAB => Self::GtkUngrab, 304 ffi::GDK_CROSSING_STATE_CHANGED => Self::StateChanged, 305 ffi::GDK_CROSSING_TOUCH_BEGIN => Self::TouchBegin, 306 ffi::GDK_CROSSING_TOUCH_END => Self::TouchEnd, 307 ffi::GDK_CROSSING_DEVICE_SWITCH => Self::DeviceSwitch, 308 value => Self::__Unknown(value), 309 } 310 } 311 } 312 313 impl StaticType for CrossingMode { static_type() -> Type314 fn static_type() -> Type { 315 unsafe { from_glib(ffi::gdk_crossing_mode_get_type()) } 316 } 317 } 318 319 impl glib::value::ValueType for CrossingMode { 320 type Type = Self; 321 } 322 323 unsafe impl<'a> FromValue<'a> for CrossingMode { 324 type Checker = glib::value::GenericValueTypeChecker<Self>; 325 from_value(value: &'a glib::Value) -> Self326 unsafe fn from_value(value: &'a glib::Value) -> Self { 327 skip_assert_initialized!(); 328 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 329 } 330 } 331 332 impl ToValue for CrossingMode { to_value(&self) -> glib::Value333 fn to_value(&self) -> glib::Value { 334 let mut value = glib::Value::for_value_type::<Self>(); 335 unsafe { 336 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 337 } 338 value 339 } 340 value_type(&self) -> glib::Type341 fn value_type(&self) -> glib::Type { 342 Self::static_type() 343 } 344 } 345 346 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 347 #[non_exhaustive] 348 #[doc(alias = "GdkCursorType")] 349 pub enum CursorType { 350 #[doc(alias = "GDK_X_CURSOR")] 351 XCursor, 352 #[doc(alias = "GDK_ARROW")] 353 Arrow, 354 #[doc(alias = "GDK_BASED_ARROW_DOWN")] 355 BasedArrowDown, 356 #[doc(alias = "GDK_BASED_ARROW_UP")] 357 BasedArrowUp, 358 #[doc(alias = "GDK_BOAT")] 359 Boat, 360 #[doc(alias = "GDK_BOGOSITY")] 361 Bogosity, 362 #[doc(alias = "GDK_BOTTOM_LEFT_CORNER")] 363 BottomLeftCorner, 364 #[doc(alias = "GDK_BOTTOM_RIGHT_CORNER")] 365 BottomRightCorner, 366 #[doc(alias = "GDK_BOTTOM_SIDE")] 367 BottomSide, 368 #[doc(alias = "GDK_BOTTOM_TEE")] 369 BottomTee, 370 #[doc(alias = "GDK_BOX_SPIRAL")] 371 BoxSpiral, 372 #[doc(alias = "GDK_CENTER_PTR")] 373 CenterPtr, 374 #[doc(alias = "GDK_CIRCLE")] 375 Circle, 376 #[doc(alias = "GDK_CLOCK")] 377 Clock, 378 #[doc(alias = "GDK_COFFEE_MUG")] 379 CoffeeMug, 380 #[doc(alias = "GDK_CROSS")] 381 Cross, 382 #[doc(alias = "GDK_CROSS_REVERSE")] 383 CrossReverse, 384 #[doc(alias = "GDK_CROSSHAIR")] 385 Crosshair, 386 #[doc(alias = "GDK_DIAMOND_CROSS")] 387 DiamondCross, 388 #[doc(alias = "GDK_DOT")] 389 Dot, 390 #[doc(alias = "GDK_DOTBOX")] 391 Dotbox, 392 #[doc(alias = "GDK_DOUBLE_ARROW")] 393 DoubleArrow, 394 #[doc(alias = "GDK_DRAFT_LARGE")] 395 DraftLarge, 396 #[doc(alias = "GDK_DRAFT_SMALL")] 397 DraftSmall, 398 #[doc(alias = "GDK_DRAPED_BOX")] 399 DrapedBox, 400 #[doc(alias = "GDK_EXCHANGE")] 401 Exchange, 402 #[doc(alias = "GDK_FLEUR")] 403 Fleur, 404 #[doc(alias = "GDK_GOBBLER")] 405 Gobbler, 406 #[doc(alias = "GDK_GUMBY")] 407 Gumby, 408 #[doc(alias = "GDK_HAND1")] 409 Hand1, 410 #[doc(alias = "GDK_HAND2")] 411 Hand2, 412 #[doc(alias = "GDK_HEART")] 413 Heart, 414 #[doc(alias = "GDK_ICON")] 415 Icon, 416 #[doc(alias = "GDK_IRON_CROSS")] 417 IronCross, 418 #[doc(alias = "GDK_LEFT_PTR")] 419 LeftPtr, 420 #[doc(alias = "GDK_LEFT_SIDE")] 421 LeftSide, 422 #[doc(alias = "GDK_LEFT_TEE")] 423 LeftTee, 424 #[doc(alias = "GDK_LEFTBUTTON")] 425 Leftbutton, 426 #[doc(alias = "GDK_LL_ANGLE")] 427 LlAngle, 428 #[doc(alias = "GDK_LR_ANGLE")] 429 LrAngle, 430 #[doc(alias = "GDK_MAN")] 431 Man, 432 #[doc(alias = "GDK_MIDDLEBUTTON")] 433 Middlebutton, 434 #[doc(alias = "GDK_MOUSE")] 435 Mouse, 436 #[doc(alias = "GDK_PENCIL")] 437 Pencil, 438 #[doc(alias = "GDK_PIRATE")] 439 Pirate, 440 #[doc(alias = "GDK_PLUS")] 441 Plus, 442 #[doc(alias = "GDK_QUESTION_ARROW")] 443 QuestionArrow, 444 #[doc(alias = "GDK_RIGHT_PTR")] 445 RightPtr, 446 #[doc(alias = "GDK_RIGHT_SIDE")] 447 RightSide, 448 #[doc(alias = "GDK_RIGHT_TEE")] 449 RightTee, 450 #[doc(alias = "GDK_RIGHTBUTTON")] 451 Rightbutton, 452 #[doc(alias = "GDK_RTL_LOGO")] 453 RtlLogo, 454 #[doc(alias = "GDK_SAILBOAT")] 455 Sailboat, 456 #[doc(alias = "GDK_SB_DOWN_ARROW")] 457 SbDownArrow, 458 #[doc(alias = "GDK_SB_H_DOUBLE_ARROW")] 459 SbHDoubleArrow, 460 #[doc(alias = "GDK_SB_LEFT_ARROW")] 461 SbLeftArrow, 462 #[doc(alias = "GDK_SB_RIGHT_ARROW")] 463 SbRightArrow, 464 #[doc(alias = "GDK_SB_UP_ARROW")] 465 SbUpArrow, 466 #[doc(alias = "GDK_SB_V_DOUBLE_ARROW")] 467 SbVDoubleArrow, 468 #[doc(alias = "GDK_SHUTTLE")] 469 Shuttle, 470 #[doc(alias = "GDK_SIZING")] 471 Sizing, 472 #[doc(alias = "GDK_SPIDER")] 473 Spider, 474 #[doc(alias = "GDK_SPRAYCAN")] 475 Spraycan, 476 #[doc(alias = "GDK_STAR")] 477 Star, 478 #[doc(alias = "GDK_TARGET")] 479 Target, 480 #[doc(alias = "GDK_TCROSS")] 481 Tcross, 482 #[doc(alias = "GDK_TOP_LEFT_ARROW")] 483 TopLeftArrow, 484 #[doc(alias = "GDK_TOP_LEFT_CORNER")] 485 TopLeftCorner, 486 #[doc(alias = "GDK_TOP_RIGHT_CORNER")] 487 TopRightCorner, 488 #[doc(alias = "GDK_TOP_SIDE")] 489 TopSide, 490 #[doc(alias = "GDK_TOP_TEE")] 491 TopTee, 492 #[doc(alias = "GDK_TREK")] 493 Trek, 494 #[doc(alias = "GDK_UL_ANGLE")] 495 UlAngle, 496 #[doc(alias = "GDK_UMBRELLA")] 497 Umbrella, 498 #[doc(alias = "GDK_UR_ANGLE")] 499 UrAngle, 500 #[doc(alias = "GDK_WATCH")] 501 Watch, 502 #[doc(alias = "GDK_XTERM")] 503 Xterm, 504 #[doc(alias = "GDK_LAST_CURSOR")] 505 LastCursor, 506 #[doc(alias = "GDK_BLANK_CURSOR")] 507 BlankCursor, 508 #[doc(alias = "GDK_CURSOR_IS_PIXMAP")] 509 CursorIsPixmap, 510 #[doc(hidden)] 511 __Unknown(i32), 512 } 513 514 impl fmt::Display for CursorType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result515 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 516 write!( 517 f, 518 "CursorType::{}", 519 match *self { 520 Self::XCursor => "XCursor", 521 Self::Arrow => "Arrow", 522 Self::BasedArrowDown => "BasedArrowDown", 523 Self::BasedArrowUp => "BasedArrowUp", 524 Self::Boat => "Boat", 525 Self::Bogosity => "Bogosity", 526 Self::BottomLeftCorner => "BottomLeftCorner", 527 Self::BottomRightCorner => "BottomRightCorner", 528 Self::BottomSide => "BottomSide", 529 Self::BottomTee => "BottomTee", 530 Self::BoxSpiral => "BoxSpiral", 531 Self::CenterPtr => "CenterPtr", 532 Self::Circle => "Circle", 533 Self::Clock => "Clock", 534 Self::CoffeeMug => "CoffeeMug", 535 Self::Cross => "Cross", 536 Self::CrossReverse => "CrossReverse", 537 Self::Crosshair => "Crosshair", 538 Self::DiamondCross => "DiamondCross", 539 Self::Dot => "Dot", 540 Self::Dotbox => "Dotbox", 541 Self::DoubleArrow => "DoubleArrow", 542 Self::DraftLarge => "DraftLarge", 543 Self::DraftSmall => "DraftSmall", 544 Self::DrapedBox => "DrapedBox", 545 Self::Exchange => "Exchange", 546 Self::Fleur => "Fleur", 547 Self::Gobbler => "Gobbler", 548 Self::Gumby => "Gumby", 549 Self::Hand1 => "Hand1", 550 Self::Hand2 => "Hand2", 551 Self::Heart => "Heart", 552 Self::Icon => "Icon", 553 Self::IronCross => "IronCross", 554 Self::LeftPtr => "LeftPtr", 555 Self::LeftSide => "LeftSide", 556 Self::LeftTee => "LeftTee", 557 Self::Leftbutton => "Leftbutton", 558 Self::LlAngle => "LlAngle", 559 Self::LrAngle => "LrAngle", 560 Self::Man => "Man", 561 Self::Middlebutton => "Middlebutton", 562 Self::Mouse => "Mouse", 563 Self::Pencil => "Pencil", 564 Self::Pirate => "Pirate", 565 Self::Plus => "Plus", 566 Self::QuestionArrow => "QuestionArrow", 567 Self::RightPtr => "RightPtr", 568 Self::RightSide => "RightSide", 569 Self::RightTee => "RightTee", 570 Self::Rightbutton => "Rightbutton", 571 Self::RtlLogo => "RtlLogo", 572 Self::Sailboat => "Sailboat", 573 Self::SbDownArrow => "SbDownArrow", 574 Self::SbHDoubleArrow => "SbHDoubleArrow", 575 Self::SbLeftArrow => "SbLeftArrow", 576 Self::SbRightArrow => "SbRightArrow", 577 Self::SbUpArrow => "SbUpArrow", 578 Self::SbVDoubleArrow => "SbVDoubleArrow", 579 Self::Shuttle => "Shuttle", 580 Self::Sizing => "Sizing", 581 Self::Spider => "Spider", 582 Self::Spraycan => "Spraycan", 583 Self::Star => "Star", 584 Self::Target => "Target", 585 Self::Tcross => "Tcross", 586 Self::TopLeftArrow => "TopLeftArrow", 587 Self::TopLeftCorner => "TopLeftCorner", 588 Self::TopRightCorner => "TopRightCorner", 589 Self::TopSide => "TopSide", 590 Self::TopTee => "TopTee", 591 Self::Trek => "Trek", 592 Self::UlAngle => "UlAngle", 593 Self::Umbrella => "Umbrella", 594 Self::UrAngle => "UrAngle", 595 Self::Watch => "Watch", 596 Self::Xterm => "Xterm", 597 Self::LastCursor => "LastCursor", 598 Self::BlankCursor => "BlankCursor", 599 Self::CursorIsPixmap => "CursorIsPixmap", 600 _ => "Unknown", 601 } 602 ) 603 } 604 } 605 606 #[doc(hidden)] 607 impl IntoGlib for CursorType { 608 type GlibType = ffi::GdkCursorType; 609 into_glib(self) -> ffi::GdkCursorType610 fn into_glib(self) -> ffi::GdkCursorType { 611 match self { 612 Self::XCursor => ffi::GDK_X_CURSOR, 613 Self::Arrow => ffi::GDK_ARROW, 614 Self::BasedArrowDown => ffi::GDK_BASED_ARROW_DOWN, 615 Self::BasedArrowUp => ffi::GDK_BASED_ARROW_UP, 616 Self::Boat => ffi::GDK_BOAT, 617 Self::Bogosity => ffi::GDK_BOGOSITY, 618 Self::BottomLeftCorner => ffi::GDK_BOTTOM_LEFT_CORNER, 619 Self::BottomRightCorner => ffi::GDK_BOTTOM_RIGHT_CORNER, 620 Self::BottomSide => ffi::GDK_BOTTOM_SIDE, 621 Self::BottomTee => ffi::GDK_BOTTOM_TEE, 622 Self::BoxSpiral => ffi::GDK_BOX_SPIRAL, 623 Self::CenterPtr => ffi::GDK_CENTER_PTR, 624 Self::Circle => ffi::GDK_CIRCLE, 625 Self::Clock => ffi::GDK_CLOCK, 626 Self::CoffeeMug => ffi::GDK_COFFEE_MUG, 627 Self::Cross => ffi::GDK_CROSS, 628 Self::CrossReverse => ffi::GDK_CROSS_REVERSE, 629 Self::Crosshair => ffi::GDK_CROSSHAIR, 630 Self::DiamondCross => ffi::GDK_DIAMOND_CROSS, 631 Self::Dot => ffi::GDK_DOT, 632 Self::Dotbox => ffi::GDK_DOTBOX, 633 Self::DoubleArrow => ffi::GDK_DOUBLE_ARROW, 634 Self::DraftLarge => ffi::GDK_DRAFT_LARGE, 635 Self::DraftSmall => ffi::GDK_DRAFT_SMALL, 636 Self::DrapedBox => ffi::GDK_DRAPED_BOX, 637 Self::Exchange => ffi::GDK_EXCHANGE, 638 Self::Fleur => ffi::GDK_FLEUR, 639 Self::Gobbler => ffi::GDK_GOBBLER, 640 Self::Gumby => ffi::GDK_GUMBY, 641 Self::Hand1 => ffi::GDK_HAND1, 642 Self::Hand2 => ffi::GDK_HAND2, 643 Self::Heart => ffi::GDK_HEART, 644 Self::Icon => ffi::GDK_ICON, 645 Self::IronCross => ffi::GDK_IRON_CROSS, 646 Self::LeftPtr => ffi::GDK_LEFT_PTR, 647 Self::LeftSide => ffi::GDK_LEFT_SIDE, 648 Self::LeftTee => ffi::GDK_LEFT_TEE, 649 Self::Leftbutton => ffi::GDK_LEFTBUTTON, 650 Self::LlAngle => ffi::GDK_LL_ANGLE, 651 Self::LrAngle => ffi::GDK_LR_ANGLE, 652 Self::Man => ffi::GDK_MAN, 653 Self::Middlebutton => ffi::GDK_MIDDLEBUTTON, 654 Self::Mouse => ffi::GDK_MOUSE, 655 Self::Pencil => ffi::GDK_PENCIL, 656 Self::Pirate => ffi::GDK_PIRATE, 657 Self::Plus => ffi::GDK_PLUS, 658 Self::QuestionArrow => ffi::GDK_QUESTION_ARROW, 659 Self::RightPtr => ffi::GDK_RIGHT_PTR, 660 Self::RightSide => ffi::GDK_RIGHT_SIDE, 661 Self::RightTee => ffi::GDK_RIGHT_TEE, 662 Self::Rightbutton => ffi::GDK_RIGHTBUTTON, 663 Self::RtlLogo => ffi::GDK_RTL_LOGO, 664 Self::Sailboat => ffi::GDK_SAILBOAT, 665 Self::SbDownArrow => ffi::GDK_SB_DOWN_ARROW, 666 Self::SbHDoubleArrow => ffi::GDK_SB_H_DOUBLE_ARROW, 667 Self::SbLeftArrow => ffi::GDK_SB_LEFT_ARROW, 668 Self::SbRightArrow => ffi::GDK_SB_RIGHT_ARROW, 669 Self::SbUpArrow => ffi::GDK_SB_UP_ARROW, 670 Self::SbVDoubleArrow => ffi::GDK_SB_V_DOUBLE_ARROW, 671 Self::Shuttle => ffi::GDK_SHUTTLE, 672 Self::Sizing => ffi::GDK_SIZING, 673 Self::Spider => ffi::GDK_SPIDER, 674 Self::Spraycan => ffi::GDK_SPRAYCAN, 675 Self::Star => ffi::GDK_STAR, 676 Self::Target => ffi::GDK_TARGET, 677 Self::Tcross => ffi::GDK_TCROSS, 678 Self::TopLeftArrow => ffi::GDK_TOP_LEFT_ARROW, 679 Self::TopLeftCorner => ffi::GDK_TOP_LEFT_CORNER, 680 Self::TopRightCorner => ffi::GDK_TOP_RIGHT_CORNER, 681 Self::TopSide => ffi::GDK_TOP_SIDE, 682 Self::TopTee => ffi::GDK_TOP_TEE, 683 Self::Trek => ffi::GDK_TREK, 684 Self::UlAngle => ffi::GDK_UL_ANGLE, 685 Self::Umbrella => ffi::GDK_UMBRELLA, 686 Self::UrAngle => ffi::GDK_UR_ANGLE, 687 Self::Watch => ffi::GDK_WATCH, 688 Self::Xterm => ffi::GDK_XTERM, 689 Self::LastCursor => ffi::GDK_LAST_CURSOR, 690 Self::BlankCursor => ffi::GDK_BLANK_CURSOR, 691 Self::CursorIsPixmap => ffi::GDK_CURSOR_IS_PIXMAP, 692 Self::__Unknown(value) => value, 693 } 694 } 695 } 696 697 #[doc(hidden)] 698 impl FromGlib<ffi::GdkCursorType> for CursorType { from_glib(value: ffi::GdkCursorType) -> Self699 unsafe fn from_glib(value: ffi::GdkCursorType) -> Self { 700 skip_assert_initialized!(); 701 match value { 702 ffi::GDK_X_CURSOR => Self::XCursor, 703 ffi::GDK_ARROW => Self::Arrow, 704 ffi::GDK_BASED_ARROW_DOWN => Self::BasedArrowDown, 705 ffi::GDK_BASED_ARROW_UP => Self::BasedArrowUp, 706 ffi::GDK_BOAT => Self::Boat, 707 ffi::GDK_BOGOSITY => Self::Bogosity, 708 ffi::GDK_BOTTOM_LEFT_CORNER => Self::BottomLeftCorner, 709 ffi::GDK_BOTTOM_RIGHT_CORNER => Self::BottomRightCorner, 710 ffi::GDK_BOTTOM_SIDE => Self::BottomSide, 711 ffi::GDK_BOTTOM_TEE => Self::BottomTee, 712 ffi::GDK_BOX_SPIRAL => Self::BoxSpiral, 713 ffi::GDK_CENTER_PTR => Self::CenterPtr, 714 ffi::GDK_CIRCLE => Self::Circle, 715 ffi::GDK_CLOCK => Self::Clock, 716 ffi::GDK_COFFEE_MUG => Self::CoffeeMug, 717 ffi::GDK_CROSS => Self::Cross, 718 ffi::GDK_CROSS_REVERSE => Self::CrossReverse, 719 ffi::GDK_CROSSHAIR => Self::Crosshair, 720 ffi::GDK_DIAMOND_CROSS => Self::DiamondCross, 721 ffi::GDK_DOT => Self::Dot, 722 ffi::GDK_DOTBOX => Self::Dotbox, 723 ffi::GDK_DOUBLE_ARROW => Self::DoubleArrow, 724 ffi::GDK_DRAFT_LARGE => Self::DraftLarge, 725 ffi::GDK_DRAFT_SMALL => Self::DraftSmall, 726 ffi::GDK_DRAPED_BOX => Self::DrapedBox, 727 ffi::GDK_EXCHANGE => Self::Exchange, 728 ffi::GDK_FLEUR => Self::Fleur, 729 ffi::GDK_GOBBLER => Self::Gobbler, 730 ffi::GDK_GUMBY => Self::Gumby, 731 ffi::GDK_HAND1 => Self::Hand1, 732 ffi::GDK_HAND2 => Self::Hand2, 733 ffi::GDK_HEART => Self::Heart, 734 ffi::GDK_ICON => Self::Icon, 735 ffi::GDK_IRON_CROSS => Self::IronCross, 736 ffi::GDK_LEFT_PTR => Self::LeftPtr, 737 ffi::GDK_LEFT_SIDE => Self::LeftSide, 738 ffi::GDK_LEFT_TEE => Self::LeftTee, 739 ffi::GDK_LEFTBUTTON => Self::Leftbutton, 740 ffi::GDK_LL_ANGLE => Self::LlAngle, 741 ffi::GDK_LR_ANGLE => Self::LrAngle, 742 ffi::GDK_MAN => Self::Man, 743 ffi::GDK_MIDDLEBUTTON => Self::Middlebutton, 744 ffi::GDK_MOUSE => Self::Mouse, 745 ffi::GDK_PENCIL => Self::Pencil, 746 ffi::GDK_PIRATE => Self::Pirate, 747 ffi::GDK_PLUS => Self::Plus, 748 ffi::GDK_QUESTION_ARROW => Self::QuestionArrow, 749 ffi::GDK_RIGHT_PTR => Self::RightPtr, 750 ffi::GDK_RIGHT_SIDE => Self::RightSide, 751 ffi::GDK_RIGHT_TEE => Self::RightTee, 752 ffi::GDK_RIGHTBUTTON => Self::Rightbutton, 753 ffi::GDK_RTL_LOGO => Self::RtlLogo, 754 ffi::GDK_SAILBOAT => Self::Sailboat, 755 ffi::GDK_SB_DOWN_ARROW => Self::SbDownArrow, 756 ffi::GDK_SB_H_DOUBLE_ARROW => Self::SbHDoubleArrow, 757 ffi::GDK_SB_LEFT_ARROW => Self::SbLeftArrow, 758 ffi::GDK_SB_RIGHT_ARROW => Self::SbRightArrow, 759 ffi::GDK_SB_UP_ARROW => Self::SbUpArrow, 760 ffi::GDK_SB_V_DOUBLE_ARROW => Self::SbVDoubleArrow, 761 ffi::GDK_SHUTTLE => Self::Shuttle, 762 ffi::GDK_SIZING => Self::Sizing, 763 ffi::GDK_SPIDER => Self::Spider, 764 ffi::GDK_SPRAYCAN => Self::Spraycan, 765 ffi::GDK_STAR => Self::Star, 766 ffi::GDK_TARGET => Self::Target, 767 ffi::GDK_TCROSS => Self::Tcross, 768 ffi::GDK_TOP_LEFT_ARROW => Self::TopLeftArrow, 769 ffi::GDK_TOP_LEFT_CORNER => Self::TopLeftCorner, 770 ffi::GDK_TOP_RIGHT_CORNER => Self::TopRightCorner, 771 ffi::GDK_TOP_SIDE => Self::TopSide, 772 ffi::GDK_TOP_TEE => Self::TopTee, 773 ffi::GDK_TREK => Self::Trek, 774 ffi::GDK_UL_ANGLE => Self::UlAngle, 775 ffi::GDK_UMBRELLA => Self::Umbrella, 776 ffi::GDK_UR_ANGLE => Self::UrAngle, 777 ffi::GDK_WATCH => Self::Watch, 778 ffi::GDK_XTERM => Self::Xterm, 779 ffi::GDK_LAST_CURSOR => Self::LastCursor, 780 ffi::GDK_BLANK_CURSOR => Self::BlankCursor, 781 ffi::GDK_CURSOR_IS_PIXMAP => Self::CursorIsPixmap, 782 value => Self::__Unknown(value), 783 } 784 } 785 } 786 787 impl StaticType for CursorType { static_type() -> Type788 fn static_type() -> Type { 789 unsafe { from_glib(ffi::gdk_cursor_type_get_type()) } 790 } 791 } 792 793 impl glib::value::ValueType for CursorType { 794 type Type = Self; 795 } 796 797 unsafe impl<'a> FromValue<'a> for CursorType { 798 type Checker = glib::value::GenericValueTypeChecker<Self>; 799 from_value(value: &'a glib::Value) -> Self800 unsafe fn from_value(value: &'a glib::Value) -> Self { 801 skip_assert_initialized!(); 802 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 803 } 804 } 805 806 impl ToValue for CursorType { to_value(&self) -> glib::Value807 fn to_value(&self) -> glib::Value { 808 let mut value = glib::Value::for_value_type::<Self>(); 809 unsafe { 810 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 811 } 812 value 813 } 814 value_type(&self) -> glib::Type815 fn value_type(&self) -> glib::Type { 816 Self::static_type() 817 } 818 } 819 820 #[cfg(any(feature = "v3_22", feature = "dox"))] 821 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 822 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 823 #[non_exhaustive] 824 #[doc(alias = "GdkDevicePadFeature")] 825 pub enum DevicePadFeature { 826 #[doc(alias = "GDK_DEVICE_PAD_FEATURE_BUTTON")] 827 Button, 828 #[doc(alias = "GDK_DEVICE_PAD_FEATURE_RING")] 829 Ring, 830 #[doc(alias = "GDK_DEVICE_PAD_FEATURE_STRIP")] 831 Strip, 832 #[doc(hidden)] 833 __Unknown(i32), 834 } 835 836 #[cfg(any(feature = "v3_22", feature = "dox"))] 837 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 838 impl fmt::Display for DevicePadFeature { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result839 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 840 write!( 841 f, 842 "DevicePadFeature::{}", 843 match *self { 844 Self::Button => "Button", 845 Self::Ring => "Ring", 846 Self::Strip => "Strip", 847 _ => "Unknown", 848 } 849 ) 850 } 851 } 852 853 #[cfg(any(feature = "v3_22", feature = "dox"))] 854 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 855 #[doc(hidden)] 856 impl IntoGlib for DevicePadFeature { 857 type GlibType = ffi::GdkDevicePadFeature; 858 into_glib(self) -> ffi::GdkDevicePadFeature859 fn into_glib(self) -> ffi::GdkDevicePadFeature { 860 match self { 861 Self::Button => ffi::GDK_DEVICE_PAD_FEATURE_BUTTON, 862 Self::Ring => ffi::GDK_DEVICE_PAD_FEATURE_RING, 863 Self::Strip => ffi::GDK_DEVICE_PAD_FEATURE_STRIP, 864 Self::__Unknown(value) => value, 865 } 866 } 867 } 868 869 #[cfg(any(feature = "v3_22", feature = "dox"))] 870 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 871 #[doc(hidden)] 872 impl FromGlib<ffi::GdkDevicePadFeature> for DevicePadFeature { from_glib(value: ffi::GdkDevicePadFeature) -> Self873 unsafe fn from_glib(value: ffi::GdkDevicePadFeature) -> Self { 874 skip_assert_initialized!(); 875 match value { 876 ffi::GDK_DEVICE_PAD_FEATURE_BUTTON => Self::Button, 877 ffi::GDK_DEVICE_PAD_FEATURE_RING => Self::Ring, 878 ffi::GDK_DEVICE_PAD_FEATURE_STRIP => Self::Strip, 879 value => Self::__Unknown(value), 880 } 881 } 882 } 883 884 #[cfg(any(feature = "v3_22", feature = "dox"))] 885 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 886 impl StaticType for DevicePadFeature { static_type() -> Type887 fn static_type() -> Type { 888 unsafe { from_glib(ffi::gdk_device_pad_feature_get_type()) } 889 } 890 } 891 892 #[cfg(any(feature = "v3_22", feature = "dox"))] 893 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 894 impl glib::value::ValueType for DevicePadFeature { 895 type Type = Self; 896 } 897 898 #[cfg(any(feature = "v3_22", feature = "dox"))] 899 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 900 unsafe impl<'a> FromValue<'a> for DevicePadFeature { 901 type Checker = glib::value::GenericValueTypeChecker<Self>; 902 from_value(value: &'a glib::Value) -> Self903 unsafe fn from_value(value: &'a glib::Value) -> Self { 904 skip_assert_initialized!(); 905 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 906 } 907 } 908 909 #[cfg(any(feature = "v3_22", feature = "dox"))] 910 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 911 impl ToValue for DevicePadFeature { to_value(&self) -> glib::Value912 fn to_value(&self) -> glib::Value { 913 let mut value = glib::Value::for_value_type::<Self>(); 914 unsafe { 915 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 916 } 917 value 918 } 919 value_type(&self) -> glib::Type920 fn value_type(&self) -> glib::Type { 921 Self::static_type() 922 } 923 } 924 925 #[cfg(any(feature = "v3_22", feature = "dox"))] 926 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 927 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 928 #[non_exhaustive] 929 #[doc(alias = "GdkDeviceToolType")] 930 pub enum DeviceToolType { 931 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_UNKNOWN")] 932 Unknown, 933 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PEN")] 934 Pen, 935 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_ERASER")] 936 Eraser, 937 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_BRUSH")] 938 Brush, 939 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PENCIL")] 940 Pencil, 941 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_AIRBRUSH")] 942 Airbrush, 943 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_MOUSE")] 944 Mouse, 945 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_LENS")] 946 Lens, 947 #[doc(hidden)] 948 __Unknown(i32), 949 } 950 951 #[cfg(any(feature = "v3_22", feature = "dox"))] 952 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 953 impl fmt::Display for DeviceToolType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result954 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 955 write!( 956 f, 957 "DeviceToolType::{}", 958 match *self { 959 Self::Unknown => "Unknown", 960 Self::Pen => "Pen", 961 Self::Eraser => "Eraser", 962 Self::Brush => "Brush", 963 Self::Pencil => "Pencil", 964 Self::Airbrush => "Airbrush", 965 Self::Mouse => "Mouse", 966 Self::Lens => "Lens", 967 _ => "Unknown", 968 } 969 ) 970 } 971 } 972 973 #[cfg(any(feature = "v3_22", feature = "dox"))] 974 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 975 #[doc(hidden)] 976 impl IntoGlib for DeviceToolType { 977 type GlibType = ffi::GdkDeviceToolType; 978 into_glib(self) -> ffi::GdkDeviceToolType979 fn into_glib(self) -> ffi::GdkDeviceToolType { 980 match self { 981 Self::Unknown => ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN, 982 Self::Pen => ffi::GDK_DEVICE_TOOL_TYPE_PEN, 983 Self::Eraser => ffi::GDK_DEVICE_TOOL_TYPE_ERASER, 984 Self::Brush => ffi::GDK_DEVICE_TOOL_TYPE_BRUSH, 985 Self::Pencil => ffi::GDK_DEVICE_TOOL_TYPE_PENCIL, 986 Self::Airbrush => ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH, 987 Self::Mouse => ffi::GDK_DEVICE_TOOL_TYPE_MOUSE, 988 Self::Lens => ffi::GDK_DEVICE_TOOL_TYPE_LENS, 989 Self::__Unknown(value) => value, 990 } 991 } 992 } 993 994 #[cfg(any(feature = "v3_22", feature = "dox"))] 995 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 996 #[doc(hidden)] 997 impl FromGlib<ffi::GdkDeviceToolType> for DeviceToolType { from_glib(value: ffi::GdkDeviceToolType) -> Self998 unsafe fn from_glib(value: ffi::GdkDeviceToolType) -> Self { 999 skip_assert_initialized!(); 1000 match value { 1001 ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN => Self::Unknown, 1002 ffi::GDK_DEVICE_TOOL_TYPE_PEN => Self::Pen, 1003 ffi::GDK_DEVICE_TOOL_TYPE_ERASER => Self::Eraser, 1004 ffi::GDK_DEVICE_TOOL_TYPE_BRUSH => Self::Brush, 1005 ffi::GDK_DEVICE_TOOL_TYPE_PENCIL => Self::Pencil, 1006 ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH => Self::Airbrush, 1007 ffi::GDK_DEVICE_TOOL_TYPE_MOUSE => Self::Mouse, 1008 ffi::GDK_DEVICE_TOOL_TYPE_LENS => Self::Lens, 1009 value => Self::__Unknown(value), 1010 } 1011 } 1012 } 1013 1014 #[cfg(any(feature = "v3_22", feature = "dox"))] 1015 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 1016 impl StaticType for DeviceToolType { static_type() -> Type1017 fn static_type() -> Type { 1018 unsafe { from_glib(ffi::gdk_device_tool_type_get_type()) } 1019 } 1020 } 1021 1022 #[cfg(any(feature = "v3_22", feature = "dox"))] 1023 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 1024 impl glib::value::ValueType for DeviceToolType { 1025 type Type = Self; 1026 } 1027 1028 #[cfg(any(feature = "v3_22", feature = "dox"))] 1029 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 1030 unsafe impl<'a> FromValue<'a> for DeviceToolType { 1031 type Checker = glib::value::GenericValueTypeChecker<Self>; 1032 from_value(value: &'a glib::Value) -> Self1033 unsafe fn from_value(value: &'a glib::Value) -> Self { 1034 skip_assert_initialized!(); 1035 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1036 } 1037 } 1038 1039 #[cfg(any(feature = "v3_22", feature = "dox"))] 1040 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 1041 impl ToValue for DeviceToolType { to_value(&self) -> glib::Value1042 fn to_value(&self) -> glib::Value { 1043 let mut value = glib::Value::for_value_type::<Self>(); 1044 unsafe { 1045 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1046 } 1047 value 1048 } 1049 value_type(&self) -> glib::Type1050 fn value_type(&self) -> glib::Type { 1051 Self::static_type() 1052 } 1053 } 1054 1055 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1056 #[non_exhaustive] 1057 #[doc(alias = "GdkDeviceType")] 1058 pub enum DeviceType { 1059 #[doc(alias = "GDK_DEVICE_TYPE_MASTER")] 1060 Master, 1061 #[doc(alias = "GDK_DEVICE_TYPE_SLAVE")] 1062 Slave, 1063 #[doc(alias = "GDK_DEVICE_TYPE_FLOATING")] 1064 Floating, 1065 #[doc(hidden)] 1066 __Unknown(i32), 1067 } 1068 1069 impl fmt::Display for DeviceType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1070 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1071 write!( 1072 f, 1073 "DeviceType::{}", 1074 match *self { 1075 Self::Master => "Master", 1076 Self::Slave => "Slave", 1077 Self::Floating => "Floating", 1078 _ => "Unknown", 1079 } 1080 ) 1081 } 1082 } 1083 1084 #[doc(hidden)] 1085 impl IntoGlib for DeviceType { 1086 type GlibType = ffi::GdkDeviceType; 1087 into_glib(self) -> ffi::GdkDeviceType1088 fn into_glib(self) -> ffi::GdkDeviceType { 1089 match self { 1090 Self::Master => ffi::GDK_DEVICE_TYPE_MASTER, 1091 Self::Slave => ffi::GDK_DEVICE_TYPE_SLAVE, 1092 Self::Floating => ffi::GDK_DEVICE_TYPE_FLOATING, 1093 Self::__Unknown(value) => value, 1094 } 1095 } 1096 } 1097 1098 #[doc(hidden)] 1099 impl FromGlib<ffi::GdkDeviceType> for DeviceType { from_glib(value: ffi::GdkDeviceType) -> Self1100 unsafe fn from_glib(value: ffi::GdkDeviceType) -> Self { 1101 skip_assert_initialized!(); 1102 match value { 1103 ffi::GDK_DEVICE_TYPE_MASTER => Self::Master, 1104 ffi::GDK_DEVICE_TYPE_SLAVE => Self::Slave, 1105 ffi::GDK_DEVICE_TYPE_FLOATING => Self::Floating, 1106 value => Self::__Unknown(value), 1107 } 1108 } 1109 } 1110 1111 impl StaticType for DeviceType { static_type() -> Type1112 fn static_type() -> Type { 1113 unsafe { from_glib(ffi::gdk_device_type_get_type()) } 1114 } 1115 } 1116 1117 impl glib::value::ValueType for DeviceType { 1118 type Type = Self; 1119 } 1120 1121 unsafe impl<'a> FromValue<'a> for DeviceType { 1122 type Checker = glib::value::GenericValueTypeChecker<Self>; 1123 from_value(value: &'a glib::Value) -> Self1124 unsafe fn from_value(value: &'a glib::Value) -> Self { 1125 skip_assert_initialized!(); 1126 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1127 } 1128 } 1129 1130 impl ToValue for DeviceType { to_value(&self) -> glib::Value1131 fn to_value(&self) -> glib::Value { 1132 let mut value = glib::Value::for_value_type::<Self>(); 1133 unsafe { 1134 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1135 } 1136 value 1137 } 1138 value_type(&self) -> glib::Type1139 fn value_type(&self) -> glib::Type { 1140 Self::static_type() 1141 } 1142 } 1143 1144 #[cfg(any(feature = "v3_20", feature = "dox"))] 1145 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1146 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1147 #[non_exhaustive] 1148 #[doc(alias = "GdkDragCancelReason")] 1149 pub enum DragCancelReason { 1150 #[doc(alias = "GDK_DRAG_CANCEL_NO_TARGET")] 1151 NoTarget, 1152 #[doc(alias = "GDK_DRAG_CANCEL_USER_CANCELLED")] 1153 UserCancelled, 1154 #[doc(alias = "GDK_DRAG_CANCEL_ERROR")] 1155 Error, 1156 #[doc(hidden)] 1157 __Unknown(i32), 1158 } 1159 1160 #[cfg(any(feature = "v3_20", feature = "dox"))] 1161 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1162 impl fmt::Display for DragCancelReason { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1163 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1164 write!( 1165 f, 1166 "DragCancelReason::{}", 1167 match *self { 1168 Self::NoTarget => "NoTarget", 1169 Self::UserCancelled => "UserCancelled", 1170 Self::Error => "Error", 1171 _ => "Unknown", 1172 } 1173 ) 1174 } 1175 } 1176 1177 #[cfg(any(feature = "v3_20", feature = "dox"))] 1178 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1179 #[doc(hidden)] 1180 impl IntoGlib for DragCancelReason { 1181 type GlibType = ffi::GdkDragCancelReason; 1182 into_glib(self) -> ffi::GdkDragCancelReason1183 fn into_glib(self) -> ffi::GdkDragCancelReason { 1184 match self { 1185 Self::NoTarget => ffi::GDK_DRAG_CANCEL_NO_TARGET, 1186 Self::UserCancelled => ffi::GDK_DRAG_CANCEL_USER_CANCELLED, 1187 Self::Error => ffi::GDK_DRAG_CANCEL_ERROR, 1188 Self::__Unknown(value) => value, 1189 } 1190 } 1191 } 1192 1193 #[cfg(any(feature = "v3_20", feature = "dox"))] 1194 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1195 #[doc(hidden)] 1196 impl FromGlib<ffi::GdkDragCancelReason> for DragCancelReason { from_glib(value: ffi::GdkDragCancelReason) -> Self1197 unsafe fn from_glib(value: ffi::GdkDragCancelReason) -> Self { 1198 skip_assert_initialized!(); 1199 match value { 1200 ffi::GDK_DRAG_CANCEL_NO_TARGET => Self::NoTarget, 1201 ffi::GDK_DRAG_CANCEL_USER_CANCELLED => Self::UserCancelled, 1202 ffi::GDK_DRAG_CANCEL_ERROR => Self::Error, 1203 value => Self::__Unknown(value), 1204 } 1205 } 1206 } 1207 1208 #[cfg(any(feature = "v3_20", feature = "dox"))] 1209 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1210 impl StaticType for DragCancelReason { static_type() -> Type1211 fn static_type() -> Type { 1212 unsafe { from_glib(ffi::gdk_drag_cancel_reason_get_type()) } 1213 } 1214 } 1215 1216 #[cfg(any(feature = "v3_20", feature = "dox"))] 1217 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1218 impl glib::value::ValueType for DragCancelReason { 1219 type Type = Self; 1220 } 1221 1222 #[cfg(any(feature = "v3_20", feature = "dox"))] 1223 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1224 unsafe impl<'a> FromValue<'a> for DragCancelReason { 1225 type Checker = glib::value::GenericValueTypeChecker<Self>; 1226 from_value(value: &'a glib::Value) -> Self1227 unsafe fn from_value(value: &'a glib::Value) -> Self { 1228 skip_assert_initialized!(); 1229 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1230 } 1231 } 1232 1233 #[cfg(any(feature = "v3_20", feature = "dox"))] 1234 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1235 impl ToValue for DragCancelReason { to_value(&self) -> glib::Value1236 fn to_value(&self) -> glib::Value { 1237 let mut value = glib::Value::for_value_type::<Self>(); 1238 unsafe { 1239 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1240 } 1241 value 1242 } 1243 value_type(&self) -> glib::Type1244 fn value_type(&self) -> glib::Type { 1245 Self::static_type() 1246 } 1247 } 1248 1249 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1250 #[non_exhaustive] 1251 #[doc(alias = "GdkDragProtocol")] 1252 pub enum DragProtocol { 1253 #[doc(alias = "GDK_DRAG_PROTO_NONE")] 1254 None, 1255 #[doc(alias = "GDK_DRAG_PROTO_MOTIF")] 1256 Motif, 1257 #[doc(alias = "GDK_DRAG_PROTO_XDND")] 1258 Xdnd, 1259 #[doc(alias = "GDK_DRAG_PROTO_ROOTWIN")] 1260 Rootwin, 1261 #[doc(alias = "GDK_DRAG_PROTO_WIN32_DROPFILES")] 1262 Win32Dropfiles, 1263 #[doc(alias = "GDK_DRAG_PROTO_OLE2")] 1264 Ole2, 1265 #[doc(alias = "GDK_DRAG_PROTO_LOCAL")] 1266 Local, 1267 #[doc(alias = "GDK_DRAG_PROTO_WAYLAND")] 1268 Wayland, 1269 #[doc(hidden)] 1270 __Unknown(i32), 1271 } 1272 1273 impl fmt::Display for DragProtocol { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1274 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1275 write!( 1276 f, 1277 "DragProtocol::{}", 1278 match *self { 1279 Self::None => "None", 1280 Self::Motif => "Motif", 1281 Self::Xdnd => "Xdnd", 1282 Self::Rootwin => "Rootwin", 1283 Self::Win32Dropfiles => "Win32Dropfiles", 1284 Self::Ole2 => "Ole2", 1285 Self::Local => "Local", 1286 Self::Wayland => "Wayland", 1287 _ => "Unknown", 1288 } 1289 ) 1290 } 1291 } 1292 1293 #[doc(hidden)] 1294 impl IntoGlib for DragProtocol { 1295 type GlibType = ffi::GdkDragProtocol; 1296 into_glib(self) -> ffi::GdkDragProtocol1297 fn into_glib(self) -> ffi::GdkDragProtocol { 1298 match self { 1299 Self::None => ffi::GDK_DRAG_PROTO_NONE, 1300 Self::Motif => ffi::GDK_DRAG_PROTO_MOTIF, 1301 Self::Xdnd => ffi::GDK_DRAG_PROTO_XDND, 1302 Self::Rootwin => ffi::GDK_DRAG_PROTO_ROOTWIN, 1303 Self::Win32Dropfiles => ffi::GDK_DRAG_PROTO_WIN32_DROPFILES, 1304 Self::Ole2 => ffi::GDK_DRAG_PROTO_OLE2, 1305 Self::Local => ffi::GDK_DRAG_PROTO_LOCAL, 1306 Self::Wayland => ffi::GDK_DRAG_PROTO_WAYLAND, 1307 Self::__Unknown(value) => value, 1308 } 1309 } 1310 } 1311 1312 #[doc(hidden)] 1313 impl FromGlib<ffi::GdkDragProtocol> for DragProtocol { from_glib(value: ffi::GdkDragProtocol) -> Self1314 unsafe fn from_glib(value: ffi::GdkDragProtocol) -> Self { 1315 skip_assert_initialized!(); 1316 match value { 1317 ffi::GDK_DRAG_PROTO_NONE => Self::None, 1318 ffi::GDK_DRAG_PROTO_MOTIF => Self::Motif, 1319 ffi::GDK_DRAG_PROTO_XDND => Self::Xdnd, 1320 ffi::GDK_DRAG_PROTO_ROOTWIN => Self::Rootwin, 1321 ffi::GDK_DRAG_PROTO_WIN32_DROPFILES => Self::Win32Dropfiles, 1322 ffi::GDK_DRAG_PROTO_OLE2 => Self::Ole2, 1323 ffi::GDK_DRAG_PROTO_LOCAL => Self::Local, 1324 ffi::GDK_DRAG_PROTO_WAYLAND => Self::Wayland, 1325 value => Self::__Unknown(value), 1326 } 1327 } 1328 } 1329 1330 impl StaticType for DragProtocol { static_type() -> Type1331 fn static_type() -> Type { 1332 unsafe { from_glib(ffi::gdk_drag_protocol_get_type()) } 1333 } 1334 } 1335 1336 impl glib::value::ValueType for DragProtocol { 1337 type Type = Self; 1338 } 1339 1340 unsafe impl<'a> FromValue<'a> for DragProtocol { 1341 type Checker = glib::value::GenericValueTypeChecker<Self>; 1342 from_value(value: &'a glib::Value) -> Self1343 unsafe fn from_value(value: &'a glib::Value) -> Self { 1344 skip_assert_initialized!(); 1345 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1346 } 1347 } 1348 1349 impl ToValue for DragProtocol { to_value(&self) -> glib::Value1350 fn to_value(&self) -> glib::Value { 1351 let mut value = glib::Value::for_value_type::<Self>(); 1352 unsafe { 1353 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1354 } 1355 value 1356 } 1357 value_type(&self) -> glib::Type1358 fn value_type(&self) -> glib::Type { 1359 Self::static_type() 1360 } 1361 } 1362 1363 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1364 #[non_exhaustive] 1365 #[doc(alias = "GdkEventType")] 1366 pub enum EventType { 1367 #[doc(alias = "GDK_NOTHING")] 1368 Nothing, 1369 #[doc(alias = "GDK_DELETE")] 1370 Delete, 1371 #[doc(alias = "GDK_DESTROY")] 1372 Destroy, 1373 #[doc(alias = "GDK_EXPOSE")] 1374 Expose, 1375 #[doc(alias = "GDK_MOTION_NOTIFY")] 1376 MotionNotify, 1377 #[doc(alias = "GDK_BUTTON_PRESS")] 1378 ButtonPress, 1379 #[doc(alias = "GDK_DOUBLE_BUTTON_PRESS")] 1380 DoubleButtonPress, 1381 #[doc(alias = "GDK_TRIPLE_BUTTON_PRESS")] 1382 TripleButtonPress, 1383 #[doc(alias = "GDK_BUTTON_RELEASE")] 1384 ButtonRelease, 1385 #[doc(alias = "GDK_KEY_PRESS")] 1386 KeyPress, 1387 #[doc(alias = "GDK_KEY_RELEASE")] 1388 KeyRelease, 1389 #[doc(alias = "GDK_ENTER_NOTIFY")] 1390 EnterNotify, 1391 #[doc(alias = "GDK_LEAVE_NOTIFY")] 1392 LeaveNotify, 1393 #[doc(alias = "GDK_FOCUS_CHANGE")] 1394 FocusChange, 1395 #[doc(alias = "GDK_CONFIGURE")] 1396 Configure, 1397 #[doc(alias = "GDK_MAP")] 1398 Map, 1399 #[doc(alias = "GDK_UNMAP")] 1400 Unmap, 1401 #[doc(alias = "GDK_PROPERTY_NOTIFY")] 1402 PropertyNotify, 1403 #[doc(alias = "GDK_SELECTION_CLEAR")] 1404 SelectionClear, 1405 #[doc(alias = "GDK_SELECTION_REQUEST")] 1406 SelectionRequest, 1407 #[doc(alias = "GDK_SELECTION_NOTIFY")] 1408 SelectionNotify, 1409 #[doc(alias = "GDK_PROXIMITY_IN")] 1410 ProximityIn, 1411 #[doc(alias = "GDK_PROXIMITY_OUT")] 1412 ProximityOut, 1413 #[doc(alias = "GDK_DRAG_ENTER")] 1414 DragEnter, 1415 #[doc(alias = "GDK_DRAG_LEAVE")] 1416 DragLeave, 1417 #[doc(alias = "GDK_DRAG_MOTION")] 1418 DragMotion, 1419 #[doc(alias = "GDK_DRAG_STATUS")] 1420 DragStatus, 1421 #[doc(alias = "GDK_DROP_START")] 1422 DropStart, 1423 #[doc(alias = "GDK_DROP_FINISHED")] 1424 DropFinished, 1425 #[doc(alias = "GDK_CLIENT_EVENT")] 1426 ClientEvent, 1427 #[doc(alias = "GDK_VISIBILITY_NOTIFY")] 1428 VisibilityNotify, 1429 #[doc(alias = "GDK_SCROLL")] 1430 Scroll, 1431 #[doc(alias = "GDK_WINDOW_STATE")] 1432 WindowState, 1433 #[doc(alias = "GDK_SETTING")] 1434 Setting, 1435 #[doc(alias = "GDK_OWNER_CHANGE")] 1436 OwnerChange, 1437 #[doc(alias = "GDK_GRAB_BROKEN")] 1438 GrabBroken, 1439 #[doc(alias = "GDK_DAMAGE")] 1440 Damage, 1441 #[doc(alias = "GDK_TOUCH_BEGIN")] 1442 TouchBegin, 1443 #[doc(alias = "GDK_TOUCH_UPDATE")] 1444 TouchUpdate, 1445 #[doc(alias = "GDK_TOUCH_END")] 1446 TouchEnd, 1447 #[doc(alias = "GDK_TOUCH_CANCEL")] 1448 TouchCancel, 1449 #[doc(alias = "GDK_TOUCHPAD_SWIPE")] 1450 TouchpadSwipe, 1451 #[doc(alias = "GDK_TOUCHPAD_PINCH")] 1452 TouchpadPinch, 1453 #[doc(alias = "GDK_PAD_BUTTON_PRESS")] 1454 PadButtonPress, 1455 #[doc(alias = "GDK_PAD_BUTTON_RELEASE")] 1456 PadButtonRelease, 1457 #[doc(alias = "GDK_PAD_RING")] 1458 PadRing, 1459 #[doc(alias = "GDK_PAD_STRIP")] 1460 PadStrip, 1461 #[doc(alias = "GDK_PAD_GROUP_MODE")] 1462 PadGroupMode, 1463 #[doc(hidden)] 1464 __Unknown(i32), 1465 } 1466 1467 impl fmt::Display for EventType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1468 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1469 write!( 1470 f, 1471 "EventType::{}", 1472 match *self { 1473 Self::Nothing => "Nothing", 1474 Self::Delete => "Delete", 1475 Self::Destroy => "Destroy", 1476 Self::Expose => "Expose", 1477 Self::MotionNotify => "MotionNotify", 1478 Self::ButtonPress => "ButtonPress", 1479 Self::DoubleButtonPress => "DoubleButtonPress", 1480 Self::TripleButtonPress => "TripleButtonPress", 1481 Self::ButtonRelease => "ButtonRelease", 1482 Self::KeyPress => "KeyPress", 1483 Self::KeyRelease => "KeyRelease", 1484 Self::EnterNotify => "EnterNotify", 1485 Self::LeaveNotify => "LeaveNotify", 1486 Self::FocusChange => "FocusChange", 1487 Self::Configure => "Configure", 1488 Self::Map => "Map", 1489 Self::Unmap => "Unmap", 1490 Self::PropertyNotify => "PropertyNotify", 1491 Self::SelectionClear => "SelectionClear", 1492 Self::SelectionRequest => "SelectionRequest", 1493 Self::SelectionNotify => "SelectionNotify", 1494 Self::ProximityIn => "ProximityIn", 1495 Self::ProximityOut => "ProximityOut", 1496 Self::DragEnter => "DragEnter", 1497 Self::DragLeave => "DragLeave", 1498 Self::DragMotion => "DragMotion", 1499 Self::DragStatus => "DragStatus", 1500 Self::DropStart => "DropStart", 1501 Self::DropFinished => "DropFinished", 1502 Self::ClientEvent => "ClientEvent", 1503 Self::VisibilityNotify => "VisibilityNotify", 1504 Self::Scroll => "Scroll", 1505 Self::WindowState => "WindowState", 1506 Self::Setting => "Setting", 1507 Self::OwnerChange => "OwnerChange", 1508 Self::GrabBroken => "GrabBroken", 1509 Self::Damage => "Damage", 1510 Self::TouchBegin => "TouchBegin", 1511 Self::TouchUpdate => "TouchUpdate", 1512 Self::TouchEnd => "TouchEnd", 1513 Self::TouchCancel => "TouchCancel", 1514 Self::TouchpadSwipe => "TouchpadSwipe", 1515 Self::TouchpadPinch => "TouchpadPinch", 1516 Self::PadButtonPress => "PadButtonPress", 1517 Self::PadButtonRelease => "PadButtonRelease", 1518 Self::PadRing => "PadRing", 1519 Self::PadStrip => "PadStrip", 1520 Self::PadGroupMode => "PadGroupMode", 1521 _ => "Unknown", 1522 } 1523 ) 1524 } 1525 } 1526 1527 #[doc(hidden)] 1528 impl IntoGlib for EventType { 1529 type GlibType = ffi::GdkEventType; 1530 into_glib(self) -> ffi::GdkEventType1531 fn into_glib(self) -> ffi::GdkEventType { 1532 match self { 1533 Self::Nothing => ffi::GDK_NOTHING, 1534 Self::Delete => ffi::GDK_DELETE, 1535 Self::Destroy => ffi::GDK_DESTROY, 1536 Self::Expose => ffi::GDK_EXPOSE, 1537 Self::MotionNotify => ffi::GDK_MOTION_NOTIFY, 1538 Self::ButtonPress => ffi::GDK_BUTTON_PRESS, 1539 Self::DoubleButtonPress => ffi::GDK_DOUBLE_BUTTON_PRESS, 1540 Self::TripleButtonPress => ffi::GDK_TRIPLE_BUTTON_PRESS, 1541 Self::ButtonRelease => ffi::GDK_BUTTON_RELEASE, 1542 Self::KeyPress => ffi::GDK_KEY_PRESS, 1543 Self::KeyRelease => ffi::GDK_KEY_RELEASE, 1544 Self::EnterNotify => ffi::GDK_ENTER_NOTIFY, 1545 Self::LeaveNotify => ffi::GDK_LEAVE_NOTIFY, 1546 Self::FocusChange => ffi::GDK_FOCUS_CHANGE, 1547 Self::Configure => ffi::GDK_CONFIGURE, 1548 Self::Map => ffi::GDK_MAP, 1549 Self::Unmap => ffi::GDK_UNMAP, 1550 Self::PropertyNotify => ffi::GDK_PROPERTY_NOTIFY, 1551 Self::SelectionClear => ffi::GDK_SELECTION_CLEAR, 1552 Self::SelectionRequest => ffi::GDK_SELECTION_REQUEST, 1553 Self::SelectionNotify => ffi::GDK_SELECTION_NOTIFY, 1554 Self::ProximityIn => ffi::GDK_PROXIMITY_IN, 1555 Self::ProximityOut => ffi::GDK_PROXIMITY_OUT, 1556 Self::DragEnter => ffi::GDK_DRAG_ENTER, 1557 Self::DragLeave => ffi::GDK_DRAG_LEAVE, 1558 Self::DragMotion => ffi::GDK_DRAG_MOTION, 1559 Self::DragStatus => ffi::GDK_DRAG_STATUS, 1560 Self::DropStart => ffi::GDK_DROP_START, 1561 Self::DropFinished => ffi::GDK_DROP_FINISHED, 1562 Self::ClientEvent => ffi::GDK_CLIENT_EVENT, 1563 Self::VisibilityNotify => ffi::GDK_VISIBILITY_NOTIFY, 1564 Self::Scroll => ffi::GDK_SCROLL, 1565 Self::WindowState => ffi::GDK_WINDOW_STATE, 1566 Self::Setting => ffi::GDK_SETTING, 1567 Self::OwnerChange => ffi::GDK_OWNER_CHANGE, 1568 Self::GrabBroken => ffi::GDK_GRAB_BROKEN, 1569 Self::Damage => ffi::GDK_DAMAGE, 1570 Self::TouchBegin => ffi::GDK_TOUCH_BEGIN, 1571 Self::TouchUpdate => ffi::GDK_TOUCH_UPDATE, 1572 Self::TouchEnd => ffi::GDK_TOUCH_END, 1573 Self::TouchCancel => ffi::GDK_TOUCH_CANCEL, 1574 Self::TouchpadSwipe => ffi::GDK_TOUCHPAD_SWIPE, 1575 Self::TouchpadPinch => ffi::GDK_TOUCHPAD_PINCH, 1576 Self::PadButtonPress => ffi::GDK_PAD_BUTTON_PRESS, 1577 Self::PadButtonRelease => ffi::GDK_PAD_BUTTON_RELEASE, 1578 Self::PadRing => ffi::GDK_PAD_RING, 1579 Self::PadStrip => ffi::GDK_PAD_STRIP, 1580 Self::PadGroupMode => ffi::GDK_PAD_GROUP_MODE, 1581 Self::__Unknown(value) => value, 1582 } 1583 } 1584 } 1585 1586 #[doc(hidden)] 1587 impl FromGlib<ffi::GdkEventType> for EventType { from_glib(value: ffi::GdkEventType) -> Self1588 unsafe fn from_glib(value: ffi::GdkEventType) -> Self { 1589 skip_assert_initialized!(); 1590 match value { 1591 ffi::GDK_NOTHING => Self::Nothing, 1592 ffi::GDK_DELETE => Self::Delete, 1593 ffi::GDK_DESTROY => Self::Destroy, 1594 ffi::GDK_EXPOSE => Self::Expose, 1595 ffi::GDK_MOTION_NOTIFY => Self::MotionNotify, 1596 ffi::GDK_BUTTON_PRESS => Self::ButtonPress, 1597 ffi::GDK_DOUBLE_BUTTON_PRESS => Self::DoubleButtonPress, 1598 ffi::GDK_TRIPLE_BUTTON_PRESS => Self::TripleButtonPress, 1599 ffi::GDK_BUTTON_RELEASE => Self::ButtonRelease, 1600 ffi::GDK_KEY_PRESS => Self::KeyPress, 1601 ffi::GDK_KEY_RELEASE => Self::KeyRelease, 1602 ffi::GDK_ENTER_NOTIFY => Self::EnterNotify, 1603 ffi::GDK_LEAVE_NOTIFY => Self::LeaveNotify, 1604 ffi::GDK_FOCUS_CHANGE => Self::FocusChange, 1605 ffi::GDK_CONFIGURE => Self::Configure, 1606 ffi::GDK_MAP => Self::Map, 1607 ffi::GDK_UNMAP => Self::Unmap, 1608 ffi::GDK_PROPERTY_NOTIFY => Self::PropertyNotify, 1609 ffi::GDK_SELECTION_CLEAR => Self::SelectionClear, 1610 ffi::GDK_SELECTION_REQUEST => Self::SelectionRequest, 1611 ffi::GDK_SELECTION_NOTIFY => Self::SelectionNotify, 1612 ffi::GDK_PROXIMITY_IN => Self::ProximityIn, 1613 ffi::GDK_PROXIMITY_OUT => Self::ProximityOut, 1614 ffi::GDK_DRAG_ENTER => Self::DragEnter, 1615 ffi::GDK_DRAG_LEAVE => Self::DragLeave, 1616 ffi::GDK_DRAG_MOTION => Self::DragMotion, 1617 ffi::GDK_DRAG_STATUS => Self::DragStatus, 1618 ffi::GDK_DROP_START => Self::DropStart, 1619 ffi::GDK_DROP_FINISHED => Self::DropFinished, 1620 ffi::GDK_CLIENT_EVENT => Self::ClientEvent, 1621 ffi::GDK_VISIBILITY_NOTIFY => Self::VisibilityNotify, 1622 ffi::GDK_SCROLL => Self::Scroll, 1623 ffi::GDK_WINDOW_STATE => Self::WindowState, 1624 ffi::GDK_SETTING => Self::Setting, 1625 ffi::GDK_OWNER_CHANGE => Self::OwnerChange, 1626 ffi::GDK_GRAB_BROKEN => Self::GrabBroken, 1627 ffi::GDK_DAMAGE => Self::Damage, 1628 ffi::GDK_TOUCH_BEGIN => Self::TouchBegin, 1629 ffi::GDK_TOUCH_UPDATE => Self::TouchUpdate, 1630 ffi::GDK_TOUCH_END => Self::TouchEnd, 1631 ffi::GDK_TOUCH_CANCEL => Self::TouchCancel, 1632 ffi::GDK_TOUCHPAD_SWIPE => Self::TouchpadSwipe, 1633 ffi::GDK_TOUCHPAD_PINCH => Self::TouchpadPinch, 1634 ffi::GDK_PAD_BUTTON_PRESS => Self::PadButtonPress, 1635 ffi::GDK_PAD_BUTTON_RELEASE => Self::PadButtonRelease, 1636 ffi::GDK_PAD_RING => Self::PadRing, 1637 ffi::GDK_PAD_STRIP => Self::PadStrip, 1638 ffi::GDK_PAD_GROUP_MODE => Self::PadGroupMode, 1639 value => Self::__Unknown(value), 1640 } 1641 } 1642 } 1643 1644 impl StaticType for EventType { static_type() -> Type1645 fn static_type() -> Type { 1646 unsafe { from_glib(ffi::gdk_event_type_get_type()) } 1647 } 1648 } 1649 1650 impl glib::value::ValueType for EventType { 1651 type Type = Self; 1652 } 1653 1654 unsafe impl<'a> FromValue<'a> for EventType { 1655 type Checker = glib::value::GenericValueTypeChecker<Self>; 1656 from_value(value: &'a glib::Value) -> Self1657 unsafe fn from_value(value: &'a glib::Value) -> Self { 1658 skip_assert_initialized!(); 1659 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1660 } 1661 } 1662 1663 impl ToValue for EventType { to_value(&self) -> glib::Value1664 fn to_value(&self) -> glib::Value { 1665 let mut value = glib::Value::for_value_type::<Self>(); 1666 unsafe { 1667 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1668 } 1669 value 1670 } 1671 value_type(&self) -> glib::Type1672 fn value_type(&self) -> glib::Type { 1673 Self::static_type() 1674 } 1675 } 1676 1677 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1678 #[non_exhaustive] 1679 #[doc(alias = "GdkFullscreenMode")] 1680 pub enum FullscreenMode { 1681 #[doc(alias = "GDK_FULLSCREEN_ON_CURRENT_MONITOR")] 1682 CurrentMonitor, 1683 #[doc(alias = "GDK_FULLSCREEN_ON_ALL_MONITORS")] 1684 AllMonitors, 1685 #[doc(hidden)] 1686 __Unknown(i32), 1687 } 1688 1689 impl fmt::Display for FullscreenMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1690 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1691 write!( 1692 f, 1693 "FullscreenMode::{}", 1694 match *self { 1695 Self::CurrentMonitor => "CurrentMonitor", 1696 Self::AllMonitors => "AllMonitors", 1697 _ => "Unknown", 1698 } 1699 ) 1700 } 1701 } 1702 1703 #[doc(hidden)] 1704 impl IntoGlib for FullscreenMode { 1705 type GlibType = ffi::GdkFullscreenMode; 1706 into_glib(self) -> ffi::GdkFullscreenMode1707 fn into_glib(self) -> ffi::GdkFullscreenMode { 1708 match self { 1709 Self::CurrentMonitor => ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR, 1710 Self::AllMonitors => ffi::GDK_FULLSCREEN_ON_ALL_MONITORS, 1711 Self::__Unknown(value) => value, 1712 } 1713 } 1714 } 1715 1716 #[doc(hidden)] 1717 impl FromGlib<ffi::GdkFullscreenMode> for FullscreenMode { from_glib(value: ffi::GdkFullscreenMode) -> Self1718 unsafe fn from_glib(value: ffi::GdkFullscreenMode) -> Self { 1719 skip_assert_initialized!(); 1720 match value { 1721 ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR => Self::CurrentMonitor, 1722 ffi::GDK_FULLSCREEN_ON_ALL_MONITORS => Self::AllMonitors, 1723 value => Self::__Unknown(value), 1724 } 1725 } 1726 } 1727 1728 impl StaticType for FullscreenMode { static_type() -> Type1729 fn static_type() -> Type { 1730 unsafe { from_glib(ffi::gdk_fullscreen_mode_get_type()) } 1731 } 1732 } 1733 1734 impl glib::value::ValueType for FullscreenMode { 1735 type Type = Self; 1736 } 1737 1738 unsafe impl<'a> FromValue<'a> for FullscreenMode { 1739 type Checker = glib::value::GenericValueTypeChecker<Self>; 1740 from_value(value: &'a glib::Value) -> Self1741 unsafe fn from_value(value: &'a glib::Value) -> Self { 1742 skip_assert_initialized!(); 1743 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1744 } 1745 } 1746 1747 impl ToValue for FullscreenMode { to_value(&self) -> glib::Value1748 fn to_value(&self) -> glib::Value { 1749 let mut value = glib::Value::for_value_type::<Self>(); 1750 unsafe { 1751 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1752 } 1753 value 1754 } 1755 value_type(&self) -> glib::Type1756 fn value_type(&self) -> glib::Type { 1757 Self::static_type() 1758 } 1759 } 1760 1761 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1762 #[non_exhaustive] 1763 #[doc(alias = "GdkGLError")] 1764 pub enum GLError { 1765 #[doc(alias = "GDK_GL_ERROR_NOT_AVAILABLE")] 1766 NotAvailable, 1767 #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_FORMAT")] 1768 UnsupportedFormat, 1769 #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_PROFILE")] 1770 UnsupportedProfile, 1771 #[doc(hidden)] 1772 __Unknown(i32), 1773 } 1774 1775 impl fmt::Display for GLError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1776 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1777 write!( 1778 f, 1779 "GLError::{}", 1780 match *self { 1781 Self::NotAvailable => "NotAvailable", 1782 Self::UnsupportedFormat => "UnsupportedFormat", 1783 Self::UnsupportedProfile => "UnsupportedProfile", 1784 _ => "Unknown", 1785 } 1786 ) 1787 } 1788 } 1789 1790 #[doc(hidden)] 1791 impl IntoGlib for GLError { 1792 type GlibType = ffi::GdkGLError; 1793 into_glib(self) -> ffi::GdkGLError1794 fn into_glib(self) -> ffi::GdkGLError { 1795 match self { 1796 Self::NotAvailable => ffi::GDK_GL_ERROR_NOT_AVAILABLE, 1797 Self::UnsupportedFormat => ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT, 1798 Self::UnsupportedProfile => ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE, 1799 Self::__Unknown(value) => value, 1800 } 1801 } 1802 } 1803 1804 #[doc(hidden)] 1805 impl FromGlib<ffi::GdkGLError> for GLError { from_glib(value: ffi::GdkGLError) -> Self1806 unsafe fn from_glib(value: ffi::GdkGLError) -> Self { 1807 skip_assert_initialized!(); 1808 match value { 1809 ffi::GDK_GL_ERROR_NOT_AVAILABLE => Self::NotAvailable, 1810 ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT => Self::UnsupportedFormat, 1811 ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE => Self::UnsupportedProfile, 1812 value => Self::__Unknown(value), 1813 } 1814 } 1815 } 1816 1817 impl ErrorDomain for GLError { domain() -> Quark1818 fn domain() -> Quark { 1819 skip_assert_initialized!(); 1820 1821 unsafe { from_glib(ffi::gdk_gl_error_quark()) } 1822 } 1823 code(self) -> i321824 fn code(self) -> i32 { 1825 self.into_glib() 1826 } 1827 from(code: i32) -> Option<Self>1828 fn from(code: i32) -> Option<Self> { 1829 skip_assert_initialized!(); 1830 match code { 1831 ffi::GDK_GL_ERROR_NOT_AVAILABLE => Some(Self::NotAvailable), 1832 ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT => Some(Self::UnsupportedFormat), 1833 ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE => Some(Self::UnsupportedProfile), 1834 value => Some(Self::__Unknown(value)), 1835 } 1836 } 1837 } 1838 1839 impl StaticType for GLError { static_type() -> Type1840 fn static_type() -> Type { 1841 unsafe { from_glib(ffi::gdk_gl_error_get_type()) } 1842 } 1843 } 1844 1845 impl glib::value::ValueType for GLError { 1846 type Type = Self; 1847 } 1848 1849 unsafe impl<'a> FromValue<'a> for GLError { 1850 type Checker = glib::value::GenericValueTypeChecker<Self>; 1851 from_value(value: &'a glib::Value) -> Self1852 unsafe fn from_value(value: &'a glib::Value) -> Self { 1853 skip_assert_initialized!(); 1854 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1855 } 1856 } 1857 1858 impl ToValue for GLError { to_value(&self) -> glib::Value1859 fn to_value(&self) -> glib::Value { 1860 let mut value = glib::Value::for_value_type::<Self>(); 1861 unsafe { 1862 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1863 } 1864 value 1865 } 1866 value_type(&self) -> glib::Type1867 fn value_type(&self) -> glib::Type { 1868 Self::static_type() 1869 } 1870 } 1871 1872 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1873 #[non_exhaustive] 1874 #[doc(alias = "GdkGrabOwnership")] 1875 pub enum GrabOwnership { 1876 #[doc(alias = "GDK_OWNERSHIP_NONE")] 1877 None, 1878 #[doc(alias = "GDK_OWNERSHIP_WINDOW")] 1879 Window, 1880 #[doc(alias = "GDK_OWNERSHIP_APPLICATION")] 1881 Application, 1882 #[doc(hidden)] 1883 __Unknown(i32), 1884 } 1885 1886 impl fmt::Display for GrabOwnership { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1887 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1888 write!( 1889 f, 1890 "GrabOwnership::{}", 1891 match *self { 1892 Self::None => "None", 1893 Self::Window => "Window", 1894 Self::Application => "Application", 1895 _ => "Unknown", 1896 } 1897 ) 1898 } 1899 } 1900 1901 #[doc(hidden)] 1902 impl IntoGlib for GrabOwnership { 1903 type GlibType = ffi::GdkGrabOwnership; 1904 into_glib(self) -> ffi::GdkGrabOwnership1905 fn into_glib(self) -> ffi::GdkGrabOwnership { 1906 match self { 1907 Self::None => ffi::GDK_OWNERSHIP_NONE, 1908 Self::Window => ffi::GDK_OWNERSHIP_WINDOW, 1909 Self::Application => ffi::GDK_OWNERSHIP_APPLICATION, 1910 Self::__Unknown(value) => value, 1911 } 1912 } 1913 } 1914 1915 #[doc(hidden)] 1916 impl FromGlib<ffi::GdkGrabOwnership> for GrabOwnership { from_glib(value: ffi::GdkGrabOwnership) -> Self1917 unsafe fn from_glib(value: ffi::GdkGrabOwnership) -> Self { 1918 skip_assert_initialized!(); 1919 match value { 1920 ffi::GDK_OWNERSHIP_NONE => Self::None, 1921 ffi::GDK_OWNERSHIP_WINDOW => Self::Window, 1922 ffi::GDK_OWNERSHIP_APPLICATION => Self::Application, 1923 value => Self::__Unknown(value), 1924 } 1925 } 1926 } 1927 1928 impl StaticType for GrabOwnership { static_type() -> Type1929 fn static_type() -> Type { 1930 unsafe { from_glib(ffi::gdk_grab_ownership_get_type()) } 1931 } 1932 } 1933 1934 impl glib::value::ValueType for GrabOwnership { 1935 type Type = Self; 1936 } 1937 1938 unsafe impl<'a> FromValue<'a> for GrabOwnership { 1939 type Checker = glib::value::GenericValueTypeChecker<Self>; 1940 from_value(value: &'a glib::Value) -> Self1941 unsafe fn from_value(value: &'a glib::Value) -> Self { 1942 skip_assert_initialized!(); 1943 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 1944 } 1945 } 1946 1947 impl ToValue for GrabOwnership { to_value(&self) -> glib::Value1948 fn to_value(&self) -> glib::Value { 1949 let mut value = glib::Value::for_value_type::<Self>(); 1950 unsafe { 1951 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 1952 } 1953 value 1954 } 1955 value_type(&self) -> glib::Type1956 fn value_type(&self) -> glib::Type { 1957 Self::static_type() 1958 } 1959 } 1960 1961 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1962 #[non_exhaustive] 1963 #[doc(alias = "GdkGrabStatus")] 1964 pub enum GrabStatus { 1965 #[doc(alias = "GDK_GRAB_SUCCESS")] 1966 Success, 1967 #[doc(alias = "GDK_GRAB_ALREADY_GRABBED")] 1968 AlreadyGrabbed, 1969 #[doc(alias = "GDK_GRAB_INVALID_TIME")] 1970 InvalidTime, 1971 #[doc(alias = "GDK_GRAB_NOT_VIEWABLE")] 1972 NotViewable, 1973 #[doc(alias = "GDK_GRAB_FROZEN")] 1974 Frozen, 1975 #[doc(alias = "GDK_GRAB_FAILED")] 1976 Failed, 1977 #[doc(hidden)] 1978 __Unknown(i32), 1979 } 1980 1981 impl fmt::Display for GrabStatus { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1982 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1983 write!( 1984 f, 1985 "GrabStatus::{}", 1986 match *self { 1987 Self::Success => "Success", 1988 Self::AlreadyGrabbed => "AlreadyGrabbed", 1989 Self::InvalidTime => "InvalidTime", 1990 Self::NotViewable => "NotViewable", 1991 Self::Frozen => "Frozen", 1992 Self::Failed => "Failed", 1993 _ => "Unknown", 1994 } 1995 ) 1996 } 1997 } 1998 1999 #[doc(hidden)] 2000 impl IntoGlib for GrabStatus { 2001 type GlibType = ffi::GdkGrabStatus; 2002 into_glib(self) -> ffi::GdkGrabStatus2003 fn into_glib(self) -> ffi::GdkGrabStatus { 2004 match self { 2005 Self::Success => ffi::GDK_GRAB_SUCCESS, 2006 Self::AlreadyGrabbed => ffi::GDK_GRAB_ALREADY_GRABBED, 2007 Self::InvalidTime => ffi::GDK_GRAB_INVALID_TIME, 2008 Self::NotViewable => ffi::GDK_GRAB_NOT_VIEWABLE, 2009 Self::Frozen => ffi::GDK_GRAB_FROZEN, 2010 Self::Failed => ffi::GDK_GRAB_FAILED, 2011 Self::__Unknown(value) => value, 2012 } 2013 } 2014 } 2015 2016 #[doc(hidden)] 2017 impl FromGlib<ffi::GdkGrabStatus> for GrabStatus { from_glib(value: ffi::GdkGrabStatus) -> Self2018 unsafe fn from_glib(value: ffi::GdkGrabStatus) -> Self { 2019 skip_assert_initialized!(); 2020 match value { 2021 ffi::GDK_GRAB_SUCCESS => Self::Success, 2022 ffi::GDK_GRAB_ALREADY_GRABBED => Self::AlreadyGrabbed, 2023 ffi::GDK_GRAB_INVALID_TIME => Self::InvalidTime, 2024 ffi::GDK_GRAB_NOT_VIEWABLE => Self::NotViewable, 2025 ffi::GDK_GRAB_FROZEN => Self::Frozen, 2026 ffi::GDK_GRAB_FAILED => Self::Failed, 2027 value => Self::__Unknown(value), 2028 } 2029 } 2030 } 2031 2032 impl StaticType for GrabStatus { static_type() -> Type2033 fn static_type() -> Type { 2034 unsafe { from_glib(ffi::gdk_grab_status_get_type()) } 2035 } 2036 } 2037 2038 impl glib::value::ValueType for GrabStatus { 2039 type Type = Self; 2040 } 2041 2042 unsafe impl<'a> FromValue<'a> for GrabStatus { 2043 type Checker = glib::value::GenericValueTypeChecker<Self>; 2044 from_value(value: &'a glib::Value) -> Self2045 unsafe fn from_value(value: &'a glib::Value) -> Self { 2046 skip_assert_initialized!(); 2047 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2048 } 2049 } 2050 2051 impl ToValue for GrabStatus { to_value(&self) -> glib::Value2052 fn to_value(&self) -> glib::Value { 2053 let mut value = glib::Value::for_value_type::<Self>(); 2054 unsafe { 2055 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2056 } 2057 value 2058 } 2059 value_type(&self) -> glib::Type2060 fn value_type(&self) -> glib::Type { 2061 Self::static_type() 2062 } 2063 } 2064 2065 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2066 #[non_exhaustive] 2067 #[doc(alias = "GdkGravity")] 2068 pub enum Gravity { 2069 #[doc(alias = "GDK_GRAVITY_NORTH_WEST")] 2070 NorthWest, 2071 #[doc(alias = "GDK_GRAVITY_NORTH")] 2072 North, 2073 #[doc(alias = "GDK_GRAVITY_NORTH_EAST")] 2074 NorthEast, 2075 #[doc(alias = "GDK_GRAVITY_WEST")] 2076 West, 2077 #[doc(alias = "GDK_GRAVITY_CENTER")] 2078 Center, 2079 #[doc(alias = "GDK_GRAVITY_EAST")] 2080 East, 2081 #[doc(alias = "GDK_GRAVITY_SOUTH_WEST")] 2082 SouthWest, 2083 #[doc(alias = "GDK_GRAVITY_SOUTH")] 2084 South, 2085 #[doc(alias = "GDK_GRAVITY_SOUTH_EAST")] 2086 SouthEast, 2087 #[doc(alias = "GDK_GRAVITY_STATIC")] 2088 Static, 2089 #[doc(hidden)] 2090 __Unknown(i32), 2091 } 2092 2093 impl fmt::Display for Gravity { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2094 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2095 write!( 2096 f, 2097 "Gravity::{}", 2098 match *self { 2099 Self::NorthWest => "NorthWest", 2100 Self::North => "North", 2101 Self::NorthEast => "NorthEast", 2102 Self::West => "West", 2103 Self::Center => "Center", 2104 Self::East => "East", 2105 Self::SouthWest => "SouthWest", 2106 Self::South => "South", 2107 Self::SouthEast => "SouthEast", 2108 Self::Static => "Static", 2109 _ => "Unknown", 2110 } 2111 ) 2112 } 2113 } 2114 2115 #[doc(hidden)] 2116 impl IntoGlib for Gravity { 2117 type GlibType = ffi::GdkGravity; 2118 into_glib(self) -> ffi::GdkGravity2119 fn into_glib(self) -> ffi::GdkGravity { 2120 match self { 2121 Self::NorthWest => ffi::GDK_GRAVITY_NORTH_WEST, 2122 Self::North => ffi::GDK_GRAVITY_NORTH, 2123 Self::NorthEast => ffi::GDK_GRAVITY_NORTH_EAST, 2124 Self::West => ffi::GDK_GRAVITY_WEST, 2125 Self::Center => ffi::GDK_GRAVITY_CENTER, 2126 Self::East => ffi::GDK_GRAVITY_EAST, 2127 Self::SouthWest => ffi::GDK_GRAVITY_SOUTH_WEST, 2128 Self::South => ffi::GDK_GRAVITY_SOUTH, 2129 Self::SouthEast => ffi::GDK_GRAVITY_SOUTH_EAST, 2130 Self::Static => ffi::GDK_GRAVITY_STATIC, 2131 Self::__Unknown(value) => value, 2132 } 2133 } 2134 } 2135 2136 #[doc(hidden)] 2137 impl FromGlib<ffi::GdkGravity> for Gravity { from_glib(value: ffi::GdkGravity) -> Self2138 unsafe fn from_glib(value: ffi::GdkGravity) -> Self { 2139 skip_assert_initialized!(); 2140 match value { 2141 ffi::GDK_GRAVITY_NORTH_WEST => Self::NorthWest, 2142 ffi::GDK_GRAVITY_NORTH => Self::North, 2143 ffi::GDK_GRAVITY_NORTH_EAST => Self::NorthEast, 2144 ffi::GDK_GRAVITY_WEST => Self::West, 2145 ffi::GDK_GRAVITY_CENTER => Self::Center, 2146 ffi::GDK_GRAVITY_EAST => Self::East, 2147 ffi::GDK_GRAVITY_SOUTH_WEST => Self::SouthWest, 2148 ffi::GDK_GRAVITY_SOUTH => Self::South, 2149 ffi::GDK_GRAVITY_SOUTH_EAST => Self::SouthEast, 2150 ffi::GDK_GRAVITY_STATIC => Self::Static, 2151 value => Self::__Unknown(value), 2152 } 2153 } 2154 } 2155 2156 impl StaticType for Gravity { static_type() -> Type2157 fn static_type() -> Type { 2158 unsafe { from_glib(ffi::gdk_gravity_get_type()) } 2159 } 2160 } 2161 2162 impl glib::value::ValueType for Gravity { 2163 type Type = Self; 2164 } 2165 2166 unsafe impl<'a> FromValue<'a> for Gravity { 2167 type Checker = glib::value::GenericValueTypeChecker<Self>; 2168 from_value(value: &'a glib::Value) -> Self2169 unsafe fn from_value(value: &'a glib::Value) -> Self { 2170 skip_assert_initialized!(); 2171 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2172 } 2173 } 2174 2175 impl ToValue for Gravity { to_value(&self) -> glib::Value2176 fn to_value(&self) -> glib::Value { 2177 let mut value = glib::Value::for_value_type::<Self>(); 2178 unsafe { 2179 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2180 } 2181 value 2182 } 2183 value_type(&self) -> glib::Type2184 fn value_type(&self) -> glib::Type { 2185 Self::static_type() 2186 } 2187 } 2188 2189 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2190 #[non_exhaustive] 2191 #[doc(alias = "GdkInputMode")] 2192 pub enum InputMode { 2193 #[doc(alias = "GDK_MODE_DISABLED")] 2194 Disabled, 2195 #[doc(alias = "GDK_MODE_SCREEN")] 2196 Screen, 2197 #[doc(alias = "GDK_MODE_WINDOW")] 2198 Window, 2199 #[doc(hidden)] 2200 __Unknown(i32), 2201 } 2202 2203 impl fmt::Display for InputMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2204 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2205 write!( 2206 f, 2207 "InputMode::{}", 2208 match *self { 2209 Self::Disabled => "Disabled", 2210 Self::Screen => "Screen", 2211 Self::Window => "Window", 2212 _ => "Unknown", 2213 } 2214 ) 2215 } 2216 } 2217 2218 #[doc(hidden)] 2219 impl IntoGlib for InputMode { 2220 type GlibType = ffi::GdkInputMode; 2221 into_glib(self) -> ffi::GdkInputMode2222 fn into_glib(self) -> ffi::GdkInputMode { 2223 match self { 2224 Self::Disabled => ffi::GDK_MODE_DISABLED, 2225 Self::Screen => ffi::GDK_MODE_SCREEN, 2226 Self::Window => ffi::GDK_MODE_WINDOW, 2227 Self::__Unknown(value) => value, 2228 } 2229 } 2230 } 2231 2232 #[doc(hidden)] 2233 impl FromGlib<ffi::GdkInputMode> for InputMode { from_glib(value: ffi::GdkInputMode) -> Self2234 unsafe fn from_glib(value: ffi::GdkInputMode) -> Self { 2235 skip_assert_initialized!(); 2236 match value { 2237 ffi::GDK_MODE_DISABLED => Self::Disabled, 2238 ffi::GDK_MODE_SCREEN => Self::Screen, 2239 ffi::GDK_MODE_WINDOW => Self::Window, 2240 value => Self::__Unknown(value), 2241 } 2242 } 2243 } 2244 2245 impl StaticType for InputMode { static_type() -> Type2246 fn static_type() -> Type { 2247 unsafe { from_glib(ffi::gdk_input_mode_get_type()) } 2248 } 2249 } 2250 2251 impl glib::value::ValueType for InputMode { 2252 type Type = Self; 2253 } 2254 2255 unsafe impl<'a> FromValue<'a> for InputMode { 2256 type Checker = glib::value::GenericValueTypeChecker<Self>; 2257 from_value(value: &'a glib::Value) -> Self2258 unsafe fn from_value(value: &'a glib::Value) -> Self { 2259 skip_assert_initialized!(); 2260 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2261 } 2262 } 2263 2264 impl ToValue for InputMode { to_value(&self) -> glib::Value2265 fn to_value(&self) -> glib::Value { 2266 let mut value = glib::Value::for_value_type::<Self>(); 2267 unsafe { 2268 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2269 } 2270 value 2271 } 2272 value_type(&self) -> glib::Type2273 fn value_type(&self) -> glib::Type { 2274 Self::static_type() 2275 } 2276 } 2277 2278 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2279 #[non_exhaustive] 2280 #[doc(alias = "GdkInputSource")] 2281 pub enum InputSource { 2282 #[doc(alias = "GDK_SOURCE_MOUSE")] 2283 Mouse, 2284 #[doc(alias = "GDK_SOURCE_PEN")] 2285 Pen, 2286 #[doc(alias = "GDK_SOURCE_ERASER")] 2287 Eraser, 2288 #[doc(alias = "GDK_SOURCE_CURSOR")] 2289 Cursor, 2290 #[doc(alias = "GDK_SOURCE_KEYBOARD")] 2291 Keyboard, 2292 #[doc(alias = "GDK_SOURCE_TOUCHSCREEN")] 2293 Touchscreen, 2294 #[doc(alias = "GDK_SOURCE_TOUCHPAD")] 2295 Touchpad, 2296 #[doc(alias = "GDK_SOURCE_TRACKPOINT")] 2297 Trackpoint, 2298 #[doc(alias = "GDK_SOURCE_TABLET_PAD")] 2299 TabletPad, 2300 #[doc(hidden)] 2301 __Unknown(i32), 2302 } 2303 2304 impl fmt::Display for InputSource { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2305 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2306 write!( 2307 f, 2308 "InputSource::{}", 2309 match *self { 2310 Self::Mouse => "Mouse", 2311 Self::Pen => "Pen", 2312 Self::Eraser => "Eraser", 2313 Self::Cursor => "Cursor", 2314 Self::Keyboard => "Keyboard", 2315 Self::Touchscreen => "Touchscreen", 2316 Self::Touchpad => "Touchpad", 2317 Self::Trackpoint => "Trackpoint", 2318 Self::TabletPad => "TabletPad", 2319 _ => "Unknown", 2320 } 2321 ) 2322 } 2323 } 2324 2325 #[doc(hidden)] 2326 impl IntoGlib for InputSource { 2327 type GlibType = ffi::GdkInputSource; 2328 into_glib(self) -> ffi::GdkInputSource2329 fn into_glib(self) -> ffi::GdkInputSource { 2330 match self { 2331 Self::Mouse => ffi::GDK_SOURCE_MOUSE, 2332 Self::Pen => ffi::GDK_SOURCE_PEN, 2333 Self::Eraser => ffi::GDK_SOURCE_ERASER, 2334 Self::Cursor => ffi::GDK_SOURCE_CURSOR, 2335 Self::Keyboard => ffi::GDK_SOURCE_KEYBOARD, 2336 Self::Touchscreen => ffi::GDK_SOURCE_TOUCHSCREEN, 2337 Self::Touchpad => ffi::GDK_SOURCE_TOUCHPAD, 2338 Self::Trackpoint => ffi::GDK_SOURCE_TRACKPOINT, 2339 Self::TabletPad => ffi::GDK_SOURCE_TABLET_PAD, 2340 Self::__Unknown(value) => value, 2341 } 2342 } 2343 } 2344 2345 #[doc(hidden)] 2346 impl FromGlib<ffi::GdkInputSource> for InputSource { from_glib(value: ffi::GdkInputSource) -> Self2347 unsafe fn from_glib(value: ffi::GdkInputSource) -> Self { 2348 skip_assert_initialized!(); 2349 match value { 2350 ffi::GDK_SOURCE_MOUSE => Self::Mouse, 2351 ffi::GDK_SOURCE_PEN => Self::Pen, 2352 ffi::GDK_SOURCE_ERASER => Self::Eraser, 2353 ffi::GDK_SOURCE_CURSOR => Self::Cursor, 2354 ffi::GDK_SOURCE_KEYBOARD => Self::Keyboard, 2355 ffi::GDK_SOURCE_TOUCHSCREEN => Self::Touchscreen, 2356 ffi::GDK_SOURCE_TOUCHPAD => Self::Touchpad, 2357 ffi::GDK_SOURCE_TRACKPOINT => Self::Trackpoint, 2358 ffi::GDK_SOURCE_TABLET_PAD => Self::TabletPad, 2359 value => Self::__Unknown(value), 2360 } 2361 } 2362 } 2363 2364 impl StaticType for InputSource { static_type() -> Type2365 fn static_type() -> Type { 2366 unsafe { from_glib(ffi::gdk_input_source_get_type()) } 2367 } 2368 } 2369 2370 impl glib::value::ValueType for InputSource { 2371 type Type = Self; 2372 } 2373 2374 unsafe impl<'a> FromValue<'a> for InputSource { 2375 type Checker = glib::value::GenericValueTypeChecker<Self>; 2376 from_value(value: &'a glib::Value) -> Self2377 unsafe fn from_value(value: &'a glib::Value) -> Self { 2378 skip_assert_initialized!(); 2379 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2380 } 2381 } 2382 2383 impl ToValue for InputSource { to_value(&self) -> glib::Value2384 fn to_value(&self) -> glib::Value { 2385 let mut value = glib::Value::for_value_type::<Self>(); 2386 unsafe { 2387 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2388 } 2389 value 2390 } 2391 value_type(&self) -> glib::Type2392 fn value_type(&self) -> glib::Type { 2393 Self::static_type() 2394 } 2395 } 2396 2397 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2398 #[non_exhaustive] 2399 #[doc(alias = "GdkModifierIntent")] 2400 pub enum ModifierIntent { 2401 #[doc(alias = "GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR")] 2402 PrimaryAccelerator, 2403 #[doc(alias = "GDK_MODIFIER_INTENT_CONTEXT_MENU")] 2404 ContextMenu, 2405 #[doc(alias = "GDK_MODIFIER_INTENT_EXTEND_SELECTION")] 2406 ExtendSelection, 2407 #[doc(alias = "GDK_MODIFIER_INTENT_MODIFY_SELECTION")] 2408 ModifySelection, 2409 #[doc(alias = "GDK_MODIFIER_INTENT_NO_TEXT_INPUT")] 2410 NoTextInput, 2411 #[doc(alias = "GDK_MODIFIER_INTENT_SHIFT_GROUP")] 2412 ShiftGroup, 2413 #[doc(alias = "GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK")] 2414 DefaultModMask, 2415 #[doc(hidden)] 2416 __Unknown(i32), 2417 } 2418 2419 impl fmt::Display for ModifierIntent { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2420 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2421 write!( 2422 f, 2423 "ModifierIntent::{}", 2424 match *self { 2425 Self::PrimaryAccelerator => "PrimaryAccelerator", 2426 Self::ContextMenu => "ContextMenu", 2427 Self::ExtendSelection => "ExtendSelection", 2428 Self::ModifySelection => "ModifySelection", 2429 Self::NoTextInput => "NoTextInput", 2430 Self::ShiftGroup => "ShiftGroup", 2431 Self::DefaultModMask => "DefaultModMask", 2432 _ => "Unknown", 2433 } 2434 ) 2435 } 2436 } 2437 2438 #[doc(hidden)] 2439 impl IntoGlib for ModifierIntent { 2440 type GlibType = ffi::GdkModifierIntent; 2441 into_glib(self) -> ffi::GdkModifierIntent2442 fn into_glib(self) -> ffi::GdkModifierIntent { 2443 match self { 2444 Self::PrimaryAccelerator => ffi::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR, 2445 Self::ContextMenu => ffi::GDK_MODIFIER_INTENT_CONTEXT_MENU, 2446 Self::ExtendSelection => ffi::GDK_MODIFIER_INTENT_EXTEND_SELECTION, 2447 Self::ModifySelection => ffi::GDK_MODIFIER_INTENT_MODIFY_SELECTION, 2448 Self::NoTextInput => ffi::GDK_MODIFIER_INTENT_NO_TEXT_INPUT, 2449 Self::ShiftGroup => ffi::GDK_MODIFIER_INTENT_SHIFT_GROUP, 2450 Self::DefaultModMask => ffi::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK, 2451 Self::__Unknown(value) => value, 2452 } 2453 } 2454 } 2455 2456 #[doc(hidden)] 2457 impl FromGlib<ffi::GdkModifierIntent> for ModifierIntent { from_glib(value: ffi::GdkModifierIntent) -> Self2458 unsafe fn from_glib(value: ffi::GdkModifierIntent) -> Self { 2459 skip_assert_initialized!(); 2460 match value { 2461 ffi::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR => Self::PrimaryAccelerator, 2462 ffi::GDK_MODIFIER_INTENT_CONTEXT_MENU => Self::ContextMenu, 2463 ffi::GDK_MODIFIER_INTENT_EXTEND_SELECTION => Self::ExtendSelection, 2464 ffi::GDK_MODIFIER_INTENT_MODIFY_SELECTION => Self::ModifySelection, 2465 ffi::GDK_MODIFIER_INTENT_NO_TEXT_INPUT => Self::NoTextInput, 2466 ffi::GDK_MODIFIER_INTENT_SHIFT_GROUP => Self::ShiftGroup, 2467 ffi::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK => Self::DefaultModMask, 2468 value => Self::__Unknown(value), 2469 } 2470 } 2471 } 2472 2473 impl StaticType for ModifierIntent { static_type() -> Type2474 fn static_type() -> Type { 2475 unsafe { from_glib(ffi::gdk_modifier_intent_get_type()) } 2476 } 2477 } 2478 2479 impl glib::value::ValueType for ModifierIntent { 2480 type Type = Self; 2481 } 2482 2483 unsafe impl<'a> FromValue<'a> for ModifierIntent { 2484 type Checker = glib::value::GenericValueTypeChecker<Self>; 2485 from_value(value: &'a glib::Value) -> Self2486 unsafe fn from_value(value: &'a glib::Value) -> Self { 2487 skip_assert_initialized!(); 2488 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2489 } 2490 } 2491 2492 impl ToValue for ModifierIntent { to_value(&self) -> glib::Value2493 fn to_value(&self) -> glib::Value { 2494 let mut value = glib::Value::for_value_type::<Self>(); 2495 unsafe { 2496 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2497 } 2498 value 2499 } 2500 value_type(&self) -> glib::Type2501 fn value_type(&self) -> glib::Type { 2502 Self::static_type() 2503 } 2504 } 2505 2506 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2507 #[non_exhaustive] 2508 #[doc(alias = "GdkNotifyType")] 2509 pub enum NotifyType { 2510 #[doc(alias = "GDK_NOTIFY_ANCESTOR")] 2511 Ancestor, 2512 #[doc(alias = "GDK_NOTIFY_VIRTUAL")] 2513 Virtual, 2514 #[doc(alias = "GDK_NOTIFY_INFERIOR")] 2515 Inferior, 2516 #[doc(alias = "GDK_NOTIFY_NONLINEAR")] 2517 Nonlinear, 2518 #[doc(alias = "GDK_NOTIFY_NONLINEAR_VIRTUAL")] 2519 NonlinearVirtual, 2520 #[doc(alias = "GDK_NOTIFY_UNKNOWN")] 2521 Unknown, 2522 #[doc(hidden)] 2523 __Unknown(i32), 2524 } 2525 2526 impl fmt::Display for NotifyType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2527 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2528 write!( 2529 f, 2530 "NotifyType::{}", 2531 match *self { 2532 Self::Ancestor => "Ancestor", 2533 Self::Virtual => "Virtual", 2534 Self::Inferior => "Inferior", 2535 Self::Nonlinear => "Nonlinear", 2536 Self::NonlinearVirtual => "NonlinearVirtual", 2537 Self::Unknown => "Unknown", 2538 _ => "Unknown", 2539 } 2540 ) 2541 } 2542 } 2543 2544 #[doc(hidden)] 2545 impl IntoGlib for NotifyType { 2546 type GlibType = ffi::GdkNotifyType; 2547 into_glib(self) -> ffi::GdkNotifyType2548 fn into_glib(self) -> ffi::GdkNotifyType { 2549 match self { 2550 Self::Ancestor => ffi::GDK_NOTIFY_ANCESTOR, 2551 Self::Virtual => ffi::GDK_NOTIFY_VIRTUAL, 2552 Self::Inferior => ffi::GDK_NOTIFY_INFERIOR, 2553 Self::Nonlinear => ffi::GDK_NOTIFY_NONLINEAR, 2554 Self::NonlinearVirtual => ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL, 2555 Self::Unknown => ffi::GDK_NOTIFY_UNKNOWN, 2556 Self::__Unknown(value) => value, 2557 } 2558 } 2559 } 2560 2561 #[doc(hidden)] 2562 impl FromGlib<ffi::GdkNotifyType> for NotifyType { from_glib(value: ffi::GdkNotifyType) -> Self2563 unsafe fn from_glib(value: ffi::GdkNotifyType) -> Self { 2564 skip_assert_initialized!(); 2565 match value { 2566 ffi::GDK_NOTIFY_ANCESTOR => Self::Ancestor, 2567 ffi::GDK_NOTIFY_VIRTUAL => Self::Virtual, 2568 ffi::GDK_NOTIFY_INFERIOR => Self::Inferior, 2569 ffi::GDK_NOTIFY_NONLINEAR => Self::Nonlinear, 2570 ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL => Self::NonlinearVirtual, 2571 ffi::GDK_NOTIFY_UNKNOWN => Self::Unknown, 2572 value => Self::__Unknown(value), 2573 } 2574 } 2575 } 2576 2577 impl StaticType for NotifyType { static_type() -> Type2578 fn static_type() -> Type { 2579 unsafe { from_glib(ffi::gdk_notify_type_get_type()) } 2580 } 2581 } 2582 2583 impl glib::value::ValueType for NotifyType { 2584 type Type = Self; 2585 } 2586 2587 unsafe impl<'a> FromValue<'a> for NotifyType { 2588 type Checker = glib::value::GenericValueTypeChecker<Self>; 2589 from_value(value: &'a glib::Value) -> Self2590 unsafe fn from_value(value: &'a glib::Value) -> Self { 2591 skip_assert_initialized!(); 2592 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2593 } 2594 } 2595 2596 impl ToValue for NotifyType { to_value(&self) -> glib::Value2597 fn to_value(&self) -> glib::Value { 2598 let mut value = glib::Value::for_value_type::<Self>(); 2599 unsafe { 2600 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2601 } 2602 value 2603 } 2604 value_type(&self) -> glib::Type2605 fn value_type(&self) -> glib::Type { 2606 Self::static_type() 2607 } 2608 } 2609 2610 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2611 #[non_exhaustive] 2612 #[doc(alias = "GdkOwnerChange")] 2613 pub enum OwnerChange { 2614 #[doc(alias = "GDK_OWNER_CHANGE_NEW_OWNER")] 2615 NewOwner, 2616 #[doc(alias = "GDK_OWNER_CHANGE_DESTROY")] 2617 Destroy, 2618 #[doc(alias = "GDK_OWNER_CHANGE_CLOSE")] 2619 Close, 2620 #[doc(hidden)] 2621 __Unknown(i32), 2622 } 2623 2624 impl fmt::Display for OwnerChange { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2625 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2626 write!( 2627 f, 2628 "OwnerChange::{}", 2629 match *self { 2630 Self::NewOwner => "NewOwner", 2631 Self::Destroy => "Destroy", 2632 Self::Close => "Close", 2633 _ => "Unknown", 2634 } 2635 ) 2636 } 2637 } 2638 2639 #[doc(hidden)] 2640 impl IntoGlib for OwnerChange { 2641 type GlibType = ffi::GdkOwnerChange; 2642 into_glib(self) -> ffi::GdkOwnerChange2643 fn into_glib(self) -> ffi::GdkOwnerChange { 2644 match self { 2645 Self::NewOwner => ffi::GDK_OWNER_CHANGE_NEW_OWNER, 2646 Self::Destroy => ffi::GDK_OWNER_CHANGE_DESTROY, 2647 Self::Close => ffi::GDK_OWNER_CHANGE_CLOSE, 2648 Self::__Unknown(value) => value, 2649 } 2650 } 2651 } 2652 2653 #[doc(hidden)] 2654 impl FromGlib<ffi::GdkOwnerChange> for OwnerChange { from_glib(value: ffi::GdkOwnerChange) -> Self2655 unsafe fn from_glib(value: ffi::GdkOwnerChange) -> Self { 2656 skip_assert_initialized!(); 2657 match value { 2658 ffi::GDK_OWNER_CHANGE_NEW_OWNER => Self::NewOwner, 2659 ffi::GDK_OWNER_CHANGE_DESTROY => Self::Destroy, 2660 ffi::GDK_OWNER_CHANGE_CLOSE => Self::Close, 2661 value => Self::__Unknown(value), 2662 } 2663 } 2664 } 2665 2666 impl StaticType for OwnerChange { static_type() -> Type2667 fn static_type() -> Type { 2668 unsafe { from_glib(ffi::gdk_owner_change_get_type()) } 2669 } 2670 } 2671 2672 impl glib::value::ValueType for OwnerChange { 2673 type Type = Self; 2674 } 2675 2676 unsafe impl<'a> FromValue<'a> for OwnerChange { 2677 type Checker = glib::value::GenericValueTypeChecker<Self>; 2678 from_value(value: &'a glib::Value) -> Self2679 unsafe fn from_value(value: &'a glib::Value) -> Self { 2680 skip_assert_initialized!(); 2681 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2682 } 2683 } 2684 2685 impl ToValue for OwnerChange { to_value(&self) -> glib::Value2686 fn to_value(&self) -> glib::Value { 2687 let mut value = glib::Value::for_value_type::<Self>(); 2688 unsafe { 2689 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2690 } 2691 value 2692 } 2693 value_type(&self) -> glib::Type2694 fn value_type(&self) -> glib::Type { 2695 Self::static_type() 2696 } 2697 } 2698 2699 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2700 #[non_exhaustive] 2701 #[doc(alias = "GdkPropMode")] 2702 pub enum PropMode { 2703 #[doc(alias = "GDK_PROP_MODE_REPLACE")] 2704 Replace, 2705 #[doc(alias = "GDK_PROP_MODE_PREPEND")] 2706 Prepend, 2707 #[doc(alias = "GDK_PROP_MODE_APPEND")] 2708 Append, 2709 #[doc(hidden)] 2710 __Unknown(i32), 2711 } 2712 2713 impl fmt::Display for PropMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2714 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2715 write!( 2716 f, 2717 "PropMode::{}", 2718 match *self { 2719 Self::Replace => "Replace", 2720 Self::Prepend => "Prepend", 2721 Self::Append => "Append", 2722 _ => "Unknown", 2723 } 2724 ) 2725 } 2726 } 2727 2728 #[doc(hidden)] 2729 impl IntoGlib for PropMode { 2730 type GlibType = ffi::GdkPropMode; 2731 into_glib(self) -> ffi::GdkPropMode2732 fn into_glib(self) -> ffi::GdkPropMode { 2733 match self { 2734 Self::Replace => ffi::GDK_PROP_MODE_REPLACE, 2735 Self::Prepend => ffi::GDK_PROP_MODE_PREPEND, 2736 Self::Append => ffi::GDK_PROP_MODE_APPEND, 2737 Self::__Unknown(value) => value, 2738 } 2739 } 2740 } 2741 2742 #[doc(hidden)] 2743 impl FromGlib<ffi::GdkPropMode> for PropMode { from_glib(value: ffi::GdkPropMode) -> Self2744 unsafe fn from_glib(value: ffi::GdkPropMode) -> Self { 2745 skip_assert_initialized!(); 2746 match value { 2747 ffi::GDK_PROP_MODE_REPLACE => Self::Replace, 2748 ffi::GDK_PROP_MODE_PREPEND => Self::Prepend, 2749 ffi::GDK_PROP_MODE_APPEND => Self::Append, 2750 value => Self::__Unknown(value), 2751 } 2752 } 2753 } 2754 2755 impl StaticType for PropMode { static_type() -> Type2756 fn static_type() -> Type { 2757 unsafe { from_glib(ffi::gdk_prop_mode_get_type()) } 2758 } 2759 } 2760 2761 impl glib::value::ValueType for PropMode { 2762 type Type = Self; 2763 } 2764 2765 unsafe impl<'a> FromValue<'a> for PropMode { 2766 type Checker = glib::value::GenericValueTypeChecker<Self>; 2767 from_value(value: &'a glib::Value) -> Self2768 unsafe fn from_value(value: &'a glib::Value) -> Self { 2769 skip_assert_initialized!(); 2770 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2771 } 2772 } 2773 2774 impl ToValue for PropMode { to_value(&self) -> glib::Value2775 fn to_value(&self) -> glib::Value { 2776 let mut value = glib::Value::for_value_type::<Self>(); 2777 unsafe { 2778 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2779 } 2780 value 2781 } 2782 value_type(&self) -> glib::Type2783 fn value_type(&self) -> glib::Type { 2784 Self::static_type() 2785 } 2786 } 2787 2788 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2789 #[non_exhaustive] 2790 #[doc(alias = "GdkPropertyState")] 2791 pub enum PropertyState { 2792 #[doc(alias = "GDK_PROPERTY_NEW_VALUE")] 2793 NewValue, 2794 #[doc(alias = "GDK_PROPERTY_DELETE")] 2795 Delete, 2796 #[doc(hidden)] 2797 __Unknown(i32), 2798 } 2799 2800 impl fmt::Display for PropertyState { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2801 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2802 write!( 2803 f, 2804 "PropertyState::{}", 2805 match *self { 2806 Self::NewValue => "NewValue", 2807 Self::Delete => "Delete", 2808 _ => "Unknown", 2809 } 2810 ) 2811 } 2812 } 2813 2814 #[doc(hidden)] 2815 impl IntoGlib for PropertyState { 2816 type GlibType = ffi::GdkPropertyState; 2817 into_glib(self) -> ffi::GdkPropertyState2818 fn into_glib(self) -> ffi::GdkPropertyState { 2819 match self { 2820 Self::NewValue => ffi::GDK_PROPERTY_NEW_VALUE, 2821 Self::Delete => ffi::GDK_PROPERTY_DELETE, 2822 Self::__Unknown(value) => value, 2823 } 2824 } 2825 } 2826 2827 #[doc(hidden)] 2828 impl FromGlib<ffi::GdkPropertyState> for PropertyState { from_glib(value: ffi::GdkPropertyState) -> Self2829 unsafe fn from_glib(value: ffi::GdkPropertyState) -> Self { 2830 skip_assert_initialized!(); 2831 match value { 2832 ffi::GDK_PROPERTY_NEW_VALUE => Self::NewValue, 2833 ffi::GDK_PROPERTY_DELETE => Self::Delete, 2834 value => Self::__Unknown(value), 2835 } 2836 } 2837 } 2838 2839 impl StaticType for PropertyState { static_type() -> Type2840 fn static_type() -> Type { 2841 unsafe { from_glib(ffi::gdk_property_state_get_type()) } 2842 } 2843 } 2844 2845 impl glib::value::ValueType for PropertyState { 2846 type Type = Self; 2847 } 2848 2849 unsafe impl<'a> FromValue<'a> for PropertyState { 2850 type Checker = glib::value::GenericValueTypeChecker<Self>; 2851 from_value(value: &'a glib::Value) -> Self2852 unsafe fn from_value(value: &'a glib::Value) -> Self { 2853 skip_assert_initialized!(); 2854 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2855 } 2856 } 2857 2858 impl ToValue for PropertyState { to_value(&self) -> glib::Value2859 fn to_value(&self) -> glib::Value { 2860 let mut value = glib::Value::for_value_type::<Self>(); 2861 unsafe { 2862 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2863 } 2864 value 2865 } 2866 value_type(&self) -> glib::Type2867 fn value_type(&self) -> glib::Type { 2868 Self::static_type() 2869 } 2870 } 2871 2872 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2873 #[non_exhaustive] 2874 #[doc(alias = "GdkScrollDirection")] 2875 pub enum ScrollDirection { 2876 #[doc(alias = "GDK_SCROLL_UP")] 2877 Up, 2878 #[doc(alias = "GDK_SCROLL_DOWN")] 2879 Down, 2880 #[doc(alias = "GDK_SCROLL_LEFT")] 2881 Left, 2882 #[doc(alias = "GDK_SCROLL_RIGHT")] 2883 Right, 2884 #[doc(alias = "GDK_SCROLL_SMOOTH")] 2885 Smooth, 2886 #[doc(hidden)] 2887 __Unknown(i32), 2888 } 2889 2890 impl fmt::Display for ScrollDirection { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2891 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2892 write!( 2893 f, 2894 "ScrollDirection::{}", 2895 match *self { 2896 Self::Up => "Up", 2897 Self::Down => "Down", 2898 Self::Left => "Left", 2899 Self::Right => "Right", 2900 Self::Smooth => "Smooth", 2901 _ => "Unknown", 2902 } 2903 ) 2904 } 2905 } 2906 2907 #[doc(hidden)] 2908 impl IntoGlib for ScrollDirection { 2909 type GlibType = ffi::GdkScrollDirection; 2910 into_glib(self) -> ffi::GdkScrollDirection2911 fn into_glib(self) -> ffi::GdkScrollDirection { 2912 match self { 2913 Self::Up => ffi::GDK_SCROLL_UP, 2914 Self::Down => ffi::GDK_SCROLL_DOWN, 2915 Self::Left => ffi::GDK_SCROLL_LEFT, 2916 Self::Right => ffi::GDK_SCROLL_RIGHT, 2917 Self::Smooth => ffi::GDK_SCROLL_SMOOTH, 2918 Self::__Unknown(value) => value, 2919 } 2920 } 2921 } 2922 2923 #[doc(hidden)] 2924 impl FromGlib<ffi::GdkScrollDirection> for ScrollDirection { from_glib(value: ffi::GdkScrollDirection) -> Self2925 unsafe fn from_glib(value: ffi::GdkScrollDirection) -> Self { 2926 skip_assert_initialized!(); 2927 match value { 2928 ffi::GDK_SCROLL_UP => Self::Up, 2929 ffi::GDK_SCROLL_DOWN => Self::Down, 2930 ffi::GDK_SCROLL_LEFT => Self::Left, 2931 ffi::GDK_SCROLL_RIGHT => Self::Right, 2932 ffi::GDK_SCROLL_SMOOTH => Self::Smooth, 2933 value => Self::__Unknown(value), 2934 } 2935 } 2936 } 2937 2938 impl StaticType for ScrollDirection { static_type() -> Type2939 fn static_type() -> Type { 2940 unsafe { from_glib(ffi::gdk_scroll_direction_get_type()) } 2941 } 2942 } 2943 2944 impl glib::value::ValueType for ScrollDirection { 2945 type Type = Self; 2946 } 2947 2948 unsafe impl<'a> FromValue<'a> for ScrollDirection { 2949 type Checker = glib::value::GenericValueTypeChecker<Self>; 2950 from_value(value: &'a glib::Value) -> Self2951 unsafe fn from_value(value: &'a glib::Value) -> Self { 2952 skip_assert_initialized!(); 2953 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 2954 } 2955 } 2956 2957 impl ToValue for ScrollDirection { to_value(&self) -> glib::Value2958 fn to_value(&self) -> glib::Value { 2959 let mut value = glib::Value::for_value_type::<Self>(); 2960 unsafe { 2961 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 2962 } 2963 value 2964 } 2965 value_type(&self) -> glib::Type2966 fn value_type(&self) -> glib::Type { 2967 Self::static_type() 2968 } 2969 } 2970 2971 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2972 #[non_exhaustive] 2973 #[doc(alias = "GdkSettingAction")] 2974 pub enum SettingAction { 2975 #[doc(alias = "GDK_SETTING_ACTION_NEW")] 2976 New, 2977 #[doc(alias = "GDK_SETTING_ACTION_CHANGED")] 2978 Changed, 2979 #[doc(alias = "GDK_SETTING_ACTION_DELETED")] 2980 Deleted, 2981 #[doc(hidden)] 2982 __Unknown(i32), 2983 } 2984 2985 impl fmt::Display for SettingAction { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2986 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2987 write!( 2988 f, 2989 "SettingAction::{}", 2990 match *self { 2991 Self::New => "New", 2992 Self::Changed => "Changed", 2993 Self::Deleted => "Deleted", 2994 _ => "Unknown", 2995 } 2996 ) 2997 } 2998 } 2999 3000 #[doc(hidden)] 3001 impl IntoGlib for SettingAction { 3002 type GlibType = ffi::GdkSettingAction; 3003 into_glib(self) -> ffi::GdkSettingAction3004 fn into_glib(self) -> ffi::GdkSettingAction { 3005 match self { 3006 Self::New => ffi::GDK_SETTING_ACTION_NEW, 3007 Self::Changed => ffi::GDK_SETTING_ACTION_CHANGED, 3008 Self::Deleted => ffi::GDK_SETTING_ACTION_DELETED, 3009 Self::__Unknown(value) => value, 3010 } 3011 } 3012 } 3013 3014 #[doc(hidden)] 3015 impl FromGlib<ffi::GdkSettingAction> for SettingAction { from_glib(value: ffi::GdkSettingAction) -> Self3016 unsafe fn from_glib(value: ffi::GdkSettingAction) -> Self { 3017 skip_assert_initialized!(); 3018 match value { 3019 ffi::GDK_SETTING_ACTION_NEW => Self::New, 3020 ffi::GDK_SETTING_ACTION_CHANGED => Self::Changed, 3021 ffi::GDK_SETTING_ACTION_DELETED => Self::Deleted, 3022 value => Self::__Unknown(value), 3023 } 3024 } 3025 } 3026 3027 impl StaticType for SettingAction { static_type() -> Type3028 fn static_type() -> Type { 3029 unsafe { from_glib(ffi::gdk_setting_action_get_type()) } 3030 } 3031 } 3032 3033 impl glib::value::ValueType for SettingAction { 3034 type Type = Self; 3035 } 3036 3037 unsafe impl<'a> FromValue<'a> for SettingAction { 3038 type Checker = glib::value::GenericValueTypeChecker<Self>; 3039 from_value(value: &'a glib::Value) -> Self3040 unsafe fn from_value(value: &'a glib::Value) -> Self { 3041 skip_assert_initialized!(); 3042 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3043 } 3044 } 3045 3046 impl ToValue for SettingAction { to_value(&self) -> glib::Value3047 fn to_value(&self) -> glib::Value { 3048 let mut value = glib::Value::for_value_type::<Self>(); 3049 unsafe { 3050 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3051 } 3052 value 3053 } 3054 value_type(&self) -> glib::Type3055 fn value_type(&self) -> glib::Type { 3056 Self::static_type() 3057 } 3058 } 3059 3060 #[cfg(any(feature = "v3_22", feature = "dox"))] 3061 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 3062 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3063 #[non_exhaustive] 3064 #[doc(alias = "GdkSubpixelLayout")] 3065 pub enum SubpixelLayout { 3066 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_UNKNOWN")] 3067 Unknown, 3068 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_NONE")] 3069 None, 3070 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB")] 3071 HorizontalRgb, 3072 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR")] 3073 HorizontalBgr, 3074 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB")] 3075 VerticalRgb, 3076 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR")] 3077 VerticalBgr, 3078 #[doc(hidden)] 3079 __Unknown(i32), 3080 } 3081 3082 #[cfg(any(feature = "v3_22", feature = "dox"))] 3083 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 3084 impl fmt::Display for SubpixelLayout { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3085 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3086 write!( 3087 f, 3088 "SubpixelLayout::{}", 3089 match *self { 3090 Self::Unknown => "Unknown", 3091 Self::None => "None", 3092 Self::HorizontalRgb => "HorizontalRgb", 3093 Self::HorizontalBgr => "HorizontalBgr", 3094 Self::VerticalRgb => "VerticalRgb", 3095 Self::VerticalBgr => "VerticalBgr", 3096 _ => "Unknown", 3097 } 3098 ) 3099 } 3100 } 3101 3102 #[cfg(any(feature = "v3_22", feature = "dox"))] 3103 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 3104 #[doc(hidden)] 3105 impl IntoGlib for SubpixelLayout { 3106 type GlibType = ffi::GdkSubpixelLayout; 3107 into_glib(self) -> ffi::GdkSubpixelLayout3108 fn into_glib(self) -> ffi::GdkSubpixelLayout { 3109 match self { 3110 Self::Unknown => ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN, 3111 Self::None => ffi::GDK_SUBPIXEL_LAYOUT_NONE, 3112 Self::HorizontalRgb => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB, 3113 Self::HorizontalBgr => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR, 3114 Self::VerticalRgb => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB, 3115 Self::VerticalBgr => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR, 3116 Self::__Unknown(value) => value, 3117 } 3118 } 3119 } 3120 3121 #[cfg(any(feature = "v3_22", feature = "dox"))] 3122 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 3123 #[doc(hidden)] 3124 impl FromGlib<ffi::GdkSubpixelLayout> for SubpixelLayout { from_glib(value: ffi::GdkSubpixelLayout) -> Self3125 unsafe fn from_glib(value: ffi::GdkSubpixelLayout) -> Self { 3126 skip_assert_initialized!(); 3127 match value { 3128 ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN => Self::Unknown, 3129 ffi::GDK_SUBPIXEL_LAYOUT_NONE => Self::None, 3130 ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB => Self::HorizontalRgb, 3131 ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR => Self::HorizontalBgr, 3132 ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB => Self::VerticalRgb, 3133 ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR => Self::VerticalBgr, 3134 value => Self::__Unknown(value), 3135 } 3136 } 3137 } 3138 3139 #[cfg(any(feature = "v3_22", feature = "dox"))] 3140 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 3141 impl StaticType for SubpixelLayout { static_type() -> Type3142 fn static_type() -> Type { 3143 unsafe { from_glib(ffi::gdk_subpixel_layout_get_type()) } 3144 } 3145 } 3146 3147 #[cfg(any(feature = "v3_22", feature = "dox"))] 3148 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 3149 impl glib::value::ValueType for SubpixelLayout { 3150 type Type = Self; 3151 } 3152 3153 #[cfg(any(feature = "v3_22", feature = "dox"))] 3154 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 3155 unsafe impl<'a> FromValue<'a> for SubpixelLayout { 3156 type Checker = glib::value::GenericValueTypeChecker<Self>; 3157 from_value(value: &'a glib::Value) -> Self3158 unsafe fn from_value(value: &'a glib::Value) -> Self { 3159 skip_assert_initialized!(); 3160 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3161 } 3162 } 3163 3164 #[cfg(any(feature = "v3_22", feature = "dox"))] 3165 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))] 3166 impl ToValue for SubpixelLayout { to_value(&self) -> glib::Value3167 fn to_value(&self) -> glib::Value { 3168 let mut value = glib::Value::for_value_type::<Self>(); 3169 unsafe { 3170 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3171 } 3172 value 3173 } 3174 value_type(&self) -> glib::Type3175 fn value_type(&self) -> glib::Type { 3176 Self::static_type() 3177 } 3178 } 3179 3180 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3181 #[non_exhaustive] 3182 #[doc(alias = "GdkVisibilityState")] 3183 pub enum VisibilityState { 3184 #[doc(alias = "GDK_VISIBILITY_UNOBSCURED")] 3185 Unobscured, 3186 #[doc(alias = "GDK_VISIBILITY_PARTIAL")] 3187 Partial, 3188 #[doc(alias = "GDK_VISIBILITY_FULLY_OBSCURED")] 3189 FullyObscured, 3190 #[doc(hidden)] 3191 __Unknown(i32), 3192 } 3193 3194 impl fmt::Display for VisibilityState { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3195 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3196 write!( 3197 f, 3198 "VisibilityState::{}", 3199 match *self { 3200 Self::Unobscured => "Unobscured", 3201 Self::Partial => "Partial", 3202 Self::FullyObscured => "FullyObscured", 3203 _ => "Unknown", 3204 } 3205 ) 3206 } 3207 } 3208 3209 #[doc(hidden)] 3210 impl IntoGlib for VisibilityState { 3211 type GlibType = ffi::GdkVisibilityState; 3212 into_glib(self) -> ffi::GdkVisibilityState3213 fn into_glib(self) -> ffi::GdkVisibilityState { 3214 match self { 3215 Self::Unobscured => ffi::GDK_VISIBILITY_UNOBSCURED, 3216 Self::Partial => ffi::GDK_VISIBILITY_PARTIAL, 3217 Self::FullyObscured => ffi::GDK_VISIBILITY_FULLY_OBSCURED, 3218 Self::__Unknown(value) => value, 3219 } 3220 } 3221 } 3222 3223 #[doc(hidden)] 3224 impl FromGlib<ffi::GdkVisibilityState> for VisibilityState { from_glib(value: ffi::GdkVisibilityState) -> Self3225 unsafe fn from_glib(value: ffi::GdkVisibilityState) -> Self { 3226 skip_assert_initialized!(); 3227 match value { 3228 ffi::GDK_VISIBILITY_UNOBSCURED => Self::Unobscured, 3229 ffi::GDK_VISIBILITY_PARTIAL => Self::Partial, 3230 ffi::GDK_VISIBILITY_FULLY_OBSCURED => Self::FullyObscured, 3231 value => Self::__Unknown(value), 3232 } 3233 } 3234 } 3235 3236 impl StaticType for VisibilityState { static_type() -> Type3237 fn static_type() -> Type { 3238 unsafe { from_glib(ffi::gdk_visibility_state_get_type()) } 3239 } 3240 } 3241 3242 impl glib::value::ValueType for VisibilityState { 3243 type Type = Self; 3244 } 3245 3246 unsafe impl<'a> FromValue<'a> for VisibilityState { 3247 type Checker = glib::value::GenericValueTypeChecker<Self>; 3248 from_value(value: &'a glib::Value) -> Self3249 unsafe fn from_value(value: &'a glib::Value) -> Self { 3250 skip_assert_initialized!(); 3251 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3252 } 3253 } 3254 3255 impl ToValue for VisibilityState { to_value(&self) -> glib::Value3256 fn to_value(&self) -> glib::Value { 3257 let mut value = glib::Value::for_value_type::<Self>(); 3258 unsafe { 3259 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3260 } 3261 value 3262 } 3263 value_type(&self) -> glib::Type3264 fn value_type(&self) -> glib::Type { 3265 Self::static_type() 3266 } 3267 } 3268 3269 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3270 #[non_exhaustive] 3271 #[doc(alias = "GdkVisualType")] 3272 pub enum VisualType { 3273 #[doc(alias = "GDK_VISUAL_STATIC_GRAY")] 3274 StaticGray, 3275 #[doc(alias = "GDK_VISUAL_GRAYSCALE")] 3276 Grayscale, 3277 #[doc(alias = "GDK_VISUAL_STATIC_COLOR")] 3278 StaticColor, 3279 #[doc(alias = "GDK_VISUAL_PSEUDO_COLOR")] 3280 PseudoColor, 3281 #[doc(alias = "GDK_VISUAL_TRUE_COLOR")] 3282 TrueColor, 3283 #[doc(alias = "GDK_VISUAL_DIRECT_COLOR")] 3284 DirectColor, 3285 #[doc(hidden)] 3286 __Unknown(i32), 3287 } 3288 3289 impl fmt::Display for VisualType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3290 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3291 write!( 3292 f, 3293 "VisualType::{}", 3294 match *self { 3295 Self::StaticGray => "StaticGray", 3296 Self::Grayscale => "Grayscale", 3297 Self::StaticColor => "StaticColor", 3298 Self::PseudoColor => "PseudoColor", 3299 Self::TrueColor => "TrueColor", 3300 Self::DirectColor => "DirectColor", 3301 _ => "Unknown", 3302 } 3303 ) 3304 } 3305 } 3306 3307 #[doc(hidden)] 3308 impl IntoGlib for VisualType { 3309 type GlibType = ffi::GdkVisualType; 3310 into_glib(self) -> ffi::GdkVisualType3311 fn into_glib(self) -> ffi::GdkVisualType { 3312 match self { 3313 Self::StaticGray => ffi::GDK_VISUAL_STATIC_GRAY, 3314 Self::Grayscale => ffi::GDK_VISUAL_GRAYSCALE, 3315 Self::StaticColor => ffi::GDK_VISUAL_STATIC_COLOR, 3316 Self::PseudoColor => ffi::GDK_VISUAL_PSEUDO_COLOR, 3317 Self::TrueColor => ffi::GDK_VISUAL_TRUE_COLOR, 3318 Self::DirectColor => ffi::GDK_VISUAL_DIRECT_COLOR, 3319 Self::__Unknown(value) => value, 3320 } 3321 } 3322 } 3323 3324 #[doc(hidden)] 3325 impl FromGlib<ffi::GdkVisualType> for VisualType { from_glib(value: ffi::GdkVisualType) -> Self3326 unsafe fn from_glib(value: ffi::GdkVisualType) -> Self { 3327 skip_assert_initialized!(); 3328 match value { 3329 ffi::GDK_VISUAL_STATIC_GRAY => Self::StaticGray, 3330 ffi::GDK_VISUAL_GRAYSCALE => Self::Grayscale, 3331 ffi::GDK_VISUAL_STATIC_COLOR => Self::StaticColor, 3332 ffi::GDK_VISUAL_PSEUDO_COLOR => Self::PseudoColor, 3333 ffi::GDK_VISUAL_TRUE_COLOR => Self::TrueColor, 3334 ffi::GDK_VISUAL_DIRECT_COLOR => Self::DirectColor, 3335 value => Self::__Unknown(value), 3336 } 3337 } 3338 } 3339 3340 impl StaticType for VisualType { static_type() -> Type3341 fn static_type() -> Type { 3342 unsafe { from_glib(ffi::gdk_visual_type_get_type()) } 3343 } 3344 } 3345 3346 impl glib::value::ValueType for VisualType { 3347 type Type = Self; 3348 } 3349 3350 unsafe impl<'a> FromValue<'a> for VisualType { 3351 type Checker = glib::value::GenericValueTypeChecker<Self>; 3352 from_value(value: &'a glib::Value) -> Self3353 unsafe fn from_value(value: &'a glib::Value) -> Self { 3354 skip_assert_initialized!(); 3355 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3356 } 3357 } 3358 3359 impl ToValue for VisualType { to_value(&self) -> glib::Value3360 fn to_value(&self) -> glib::Value { 3361 let mut value = glib::Value::for_value_type::<Self>(); 3362 unsafe { 3363 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3364 } 3365 value 3366 } 3367 value_type(&self) -> glib::Type3368 fn value_type(&self) -> glib::Type { 3369 Self::static_type() 3370 } 3371 } 3372 3373 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3374 #[non_exhaustive] 3375 #[doc(alias = "GdkWindowEdge")] 3376 pub enum WindowEdge { 3377 #[doc(alias = "GDK_WINDOW_EDGE_NORTH_WEST")] 3378 NorthWest, 3379 #[doc(alias = "GDK_WINDOW_EDGE_NORTH")] 3380 North, 3381 #[doc(alias = "GDK_WINDOW_EDGE_NORTH_EAST")] 3382 NorthEast, 3383 #[doc(alias = "GDK_WINDOW_EDGE_WEST")] 3384 West, 3385 #[doc(alias = "GDK_WINDOW_EDGE_EAST")] 3386 East, 3387 #[doc(alias = "GDK_WINDOW_EDGE_SOUTH_WEST")] 3388 SouthWest, 3389 #[doc(alias = "GDK_WINDOW_EDGE_SOUTH")] 3390 South, 3391 #[doc(alias = "GDK_WINDOW_EDGE_SOUTH_EAST")] 3392 SouthEast, 3393 #[doc(hidden)] 3394 __Unknown(i32), 3395 } 3396 3397 impl fmt::Display for WindowEdge { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3398 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3399 write!( 3400 f, 3401 "WindowEdge::{}", 3402 match *self { 3403 Self::NorthWest => "NorthWest", 3404 Self::North => "North", 3405 Self::NorthEast => "NorthEast", 3406 Self::West => "West", 3407 Self::East => "East", 3408 Self::SouthWest => "SouthWest", 3409 Self::South => "South", 3410 Self::SouthEast => "SouthEast", 3411 _ => "Unknown", 3412 } 3413 ) 3414 } 3415 } 3416 3417 #[doc(hidden)] 3418 impl IntoGlib for WindowEdge { 3419 type GlibType = ffi::GdkWindowEdge; 3420 into_glib(self) -> ffi::GdkWindowEdge3421 fn into_glib(self) -> ffi::GdkWindowEdge { 3422 match self { 3423 Self::NorthWest => ffi::GDK_WINDOW_EDGE_NORTH_WEST, 3424 Self::North => ffi::GDK_WINDOW_EDGE_NORTH, 3425 Self::NorthEast => ffi::GDK_WINDOW_EDGE_NORTH_EAST, 3426 Self::West => ffi::GDK_WINDOW_EDGE_WEST, 3427 Self::East => ffi::GDK_WINDOW_EDGE_EAST, 3428 Self::SouthWest => ffi::GDK_WINDOW_EDGE_SOUTH_WEST, 3429 Self::South => ffi::GDK_WINDOW_EDGE_SOUTH, 3430 Self::SouthEast => ffi::GDK_WINDOW_EDGE_SOUTH_EAST, 3431 Self::__Unknown(value) => value, 3432 } 3433 } 3434 } 3435 3436 #[doc(hidden)] 3437 impl FromGlib<ffi::GdkWindowEdge> for WindowEdge { from_glib(value: ffi::GdkWindowEdge) -> Self3438 unsafe fn from_glib(value: ffi::GdkWindowEdge) -> Self { 3439 skip_assert_initialized!(); 3440 match value { 3441 ffi::GDK_WINDOW_EDGE_NORTH_WEST => Self::NorthWest, 3442 ffi::GDK_WINDOW_EDGE_NORTH => Self::North, 3443 ffi::GDK_WINDOW_EDGE_NORTH_EAST => Self::NorthEast, 3444 ffi::GDK_WINDOW_EDGE_WEST => Self::West, 3445 ffi::GDK_WINDOW_EDGE_EAST => Self::East, 3446 ffi::GDK_WINDOW_EDGE_SOUTH_WEST => Self::SouthWest, 3447 ffi::GDK_WINDOW_EDGE_SOUTH => Self::South, 3448 ffi::GDK_WINDOW_EDGE_SOUTH_EAST => Self::SouthEast, 3449 value => Self::__Unknown(value), 3450 } 3451 } 3452 } 3453 3454 impl StaticType for WindowEdge { static_type() -> Type3455 fn static_type() -> Type { 3456 unsafe { from_glib(ffi::gdk_window_edge_get_type()) } 3457 } 3458 } 3459 3460 impl glib::value::ValueType for WindowEdge { 3461 type Type = Self; 3462 } 3463 3464 unsafe impl<'a> FromValue<'a> for WindowEdge { 3465 type Checker = glib::value::GenericValueTypeChecker<Self>; 3466 from_value(value: &'a glib::Value) -> Self3467 unsafe fn from_value(value: &'a glib::Value) -> Self { 3468 skip_assert_initialized!(); 3469 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3470 } 3471 } 3472 3473 impl ToValue for WindowEdge { to_value(&self) -> glib::Value3474 fn to_value(&self) -> glib::Value { 3475 let mut value = glib::Value::for_value_type::<Self>(); 3476 unsafe { 3477 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3478 } 3479 value 3480 } 3481 value_type(&self) -> glib::Type3482 fn value_type(&self) -> glib::Type { 3483 Self::static_type() 3484 } 3485 } 3486 3487 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3488 #[non_exhaustive] 3489 #[doc(alias = "GdkWindowType")] 3490 pub enum WindowType { 3491 #[doc(alias = "GDK_WINDOW_ROOT")] 3492 Root, 3493 #[doc(alias = "GDK_WINDOW_TOPLEVEL")] 3494 Toplevel, 3495 #[doc(alias = "GDK_WINDOW_CHILD")] 3496 Child, 3497 #[doc(alias = "GDK_WINDOW_TEMP")] 3498 Temp, 3499 #[doc(alias = "GDK_WINDOW_FOREIGN")] 3500 Foreign, 3501 #[doc(alias = "GDK_WINDOW_OFFSCREEN")] 3502 Offscreen, 3503 #[doc(alias = "GDK_WINDOW_SUBSURFACE")] 3504 Subsurface, 3505 #[doc(hidden)] 3506 __Unknown(i32), 3507 } 3508 3509 impl fmt::Display for WindowType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3510 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3511 write!( 3512 f, 3513 "WindowType::{}", 3514 match *self { 3515 Self::Root => "Root", 3516 Self::Toplevel => "Toplevel", 3517 Self::Child => "Child", 3518 Self::Temp => "Temp", 3519 Self::Foreign => "Foreign", 3520 Self::Offscreen => "Offscreen", 3521 Self::Subsurface => "Subsurface", 3522 _ => "Unknown", 3523 } 3524 ) 3525 } 3526 } 3527 3528 #[doc(hidden)] 3529 impl IntoGlib for WindowType { 3530 type GlibType = ffi::GdkWindowType; 3531 into_glib(self) -> ffi::GdkWindowType3532 fn into_glib(self) -> ffi::GdkWindowType { 3533 match self { 3534 Self::Root => ffi::GDK_WINDOW_ROOT, 3535 Self::Toplevel => ffi::GDK_WINDOW_TOPLEVEL, 3536 Self::Child => ffi::GDK_WINDOW_CHILD, 3537 Self::Temp => ffi::GDK_WINDOW_TEMP, 3538 Self::Foreign => ffi::GDK_WINDOW_FOREIGN, 3539 Self::Offscreen => ffi::GDK_WINDOW_OFFSCREEN, 3540 Self::Subsurface => ffi::GDK_WINDOW_SUBSURFACE, 3541 Self::__Unknown(value) => value, 3542 } 3543 } 3544 } 3545 3546 #[doc(hidden)] 3547 impl FromGlib<ffi::GdkWindowType> for WindowType { from_glib(value: ffi::GdkWindowType) -> Self3548 unsafe fn from_glib(value: ffi::GdkWindowType) -> Self { 3549 skip_assert_initialized!(); 3550 match value { 3551 ffi::GDK_WINDOW_ROOT => Self::Root, 3552 ffi::GDK_WINDOW_TOPLEVEL => Self::Toplevel, 3553 ffi::GDK_WINDOW_CHILD => Self::Child, 3554 ffi::GDK_WINDOW_TEMP => Self::Temp, 3555 ffi::GDK_WINDOW_FOREIGN => Self::Foreign, 3556 ffi::GDK_WINDOW_OFFSCREEN => Self::Offscreen, 3557 ffi::GDK_WINDOW_SUBSURFACE => Self::Subsurface, 3558 value => Self::__Unknown(value), 3559 } 3560 } 3561 } 3562 3563 impl StaticType for WindowType { static_type() -> Type3564 fn static_type() -> Type { 3565 unsafe { from_glib(ffi::gdk_window_type_get_type()) } 3566 } 3567 } 3568 3569 impl glib::value::ValueType for WindowType { 3570 type Type = Self; 3571 } 3572 3573 unsafe impl<'a> FromValue<'a> for WindowType { 3574 type Checker = glib::value::GenericValueTypeChecker<Self>; 3575 from_value(value: &'a glib::Value) -> Self3576 unsafe fn from_value(value: &'a glib::Value) -> Self { 3577 skip_assert_initialized!(); 3578 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3579 } 3580 } 3581 3582 impl ToValue for WindowType { to_value(&self) -> glib::Value3583 fn to_value(&self) -> glib::Value { 3584 let mut value = glib::Value::for_value_type::<Self>(); 3585 unsafe { 3586 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3587 } 3588 value 3589 } 3590 value_type(&self) -> glib::Type3591 fn value_type(&self) -> glib::Type { 3592 Self::static_type() 3593 } 3594 } 3595 3596 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3597 #[non_exhaustive] 3598 #[doc(alias = "GdkWindowTypeHint")] 3599 pub enum WindowTypeHint { 3600 #[doc(alias = "GDK_WINDOW_TYPE_HINT_NORMAL")] 3601 Normal, 3602 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DIALOG")] 3603 Dialog, 3604 #[doc(alias = "GDK_WINDOW_TYPE_HINT_MENU")] 3605 Menu, 3606 #[doc(alias = "GDK_WINDOW_TYPE_HINT_TOOLBAR")] 3607 Toolbar, 3608 #[doc(alias = "GDK_WINDOW_TYPE_HINT_SPLASHSCREEN")] 3609 Splashscreen, 3610 #[doc(alias = "GDK_WINDOW_TYPE_HINT_UTILITY")] 3611 Utility, 3612 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DOCK")] 3613 Dock, 3614 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DESKTOP")] 3615 Desktop, 3616 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU")] 3617 DropdownMenu, 3618 #[doc(alias = "GDK_WINDOW_TYPE_HINT_POPUP_MENU")] 3619 PopupMenu, 3620 #[doc(alias = "GDK_WINDOW_TYPE_HINT_TOOLTIP")] 3621 Tooltip, 3622 #[doc(alias = "GDK_WINDOW_TYPE_HINT_NOTIFICATION")] 3623 Notification, 3624 #[doc(alias = "GDK_WINDOW_TYPE_HINT_COMBO")] 3625 Combo, 3626 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DND")] 3627 Dnd, 3628 #[doc(hidden)] 3629 __Unknown(i32), 3630 } 3631 3632 impl fmt::Display for WindowTypeHint { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3633 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3634 write!( 3635 f, 3636 "WindowTypeHint::{}", 3637 match *self { 3638 Self::Normal => "Normal", 3639 Self::Dialog => "Dialog", 3640 Self::Menu => "Menu", 3641 Self::Toolbar => "Toolbar", 3642 Self::Splashscreen => "Splashscreen", 3643 Self::Utility => "Utility", 3644 Self::Dock => "Dock", 3645 Self::Desktop => "Desktop", 3646 Self::DropdownMenu => "DropdownMenu", 3647 Self::PopupMenu => "PopupMenu", 3648 Self::Tooltip => "Tooltip", 3649 Self::Notification => "Notification", 3650 Self::Combo => "Combo", 3651 Self::Dnd => "Dnd", 3652 _ => "Unknown", 3653 } 3654 ) 3655 } 3656 } 3657 3658 #[doc(hidden)] 3659 impl IntoGlib for WindowTypeHint { 3660 type GlibType = ffi::GdkWindowTypeHint; 3661 into_glib(self) -> ffi::GdkWindowTypeHint3662 fn into_glib(self) -> ffi::GdkWindowTypeHint { 3663 match self { 3664 Self::Normal => ffi::GDK_WINDOW_TYPE_HINT_NORMAL, 3665 Self::Dialog => ffi::GDK_WINDOW_TYPE_HINT_DIALOG, 3666 Self::Menu => ffi::GDK_WINDOW_TYPE_HINT_MENU, 3667 Self::Toolbar => ffi::GDK_WINDOW_TYPE_HINT_TOOLBAR, 3668 Self::Splashscreen => ffi::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN, 3669 Self::Utility => ffi::GDK_WINDOW_TYPE_HINT_UTILITY, 3670 Self::Dock => ffi::GDK_WINDOW_TYPE_HINT_DOCK, 3671 Self::Desktop => ffi::GDK_WINDOW_TYPE_HINT_DESKTOP, 3672 Self::DropdownMenu => ffi::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU, 3673 Self::PopupMenu => ffi::GDK_WINDOW_TYPE_HINT_POPUP_MENU, 3674 Self::Tooltip => ffi::GDK_WINDOW_TYPE_HINT_TOOLTIP, 3675 Self::Notification => ffi::GDK_WINDOW_TYPE_HINT_NOTIFICATION, 3676 Self::Combo => ffi::GDK_WINDOW_TYPE_HINT_COMBO, 3677 Self::Dnd => ffi::GDK_WINDOW_TYPE_HINT_DND, 3678 Self::__Unknown(value) => value, 3679 } 3680 } 3681 } 3682 3683 #[doc(hidden)] 3684 impl FromGlib<ffi::GdkWindowTypeHint> for WindowTypeHint { from_glib(value: ffi::GdkWindowTypeHint) -> Self3685 unsafe fn from_glib(value: ffi::GdkWindowTypeHint) -> Self { 3686 skip_assert_initialized!(); 3687 match value { 3688 ffi::GDK_WINDOW_TYPE_HINT_NORMAL => Self::Normal, 3689 ffi::GDK_WINDOW_TYPE_HINT_DIALOG => Self::Dialog, 3690 ffi::GDK_WINDOW_TYPE_HINT_MENU => Self::Menu, 3691 ffi::GDK_WINDOW_TYPE_HINT_TOOLBAR => Self::Toolbar, 3692 ffi::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN => Self::Splashscreen, 3693 ffi::GDK_WINDOW_TYPE_HINT_UTILITY => Self::Utility, 3694 ffi::GDK_WINDOW_TYPE_HINT_DOCK => Self::Dock, 3695 ffi::GDK_WINDOW_TYPE_HINT_DESKTOP => Self::Desktop, 3696 ffi::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU => Self::DropdownMenu, 3697 ffi::GDK_WINDOW_TYPE_HINT_POPUP_MENU => Self::PopupMenu, 3698 ffi::GDK_WINDOW_TYPE_HINT_TOOLTIP => Self::Tooltip, 3699 ffi::GDK_WINDOW_TYPE_HINT_NOTIFICATION => Self::Notification, 3700 ffi::GDK_WINDOW_TYPE_HINT_COMBO => Self::Combo, 3701 ffi::GDK_WINDOW_TYPE_HINT_DND => Self::Dnd, 3702 value => Self::__Unknown(value), 3703 } 3704 } 3705 } 3706 3707 impl StaticType for WindowTypeHint { static_type() -> Type3708 fn static_type() -> Type { 3709 unsafe { from_glib(ffi::gdk_window_type_hint_get_type()) } 3710 } 3711 } 3712 3713 impl glib::value::ValueType for WindowTypeHint { 3714 type Type = Self; 3715 } 3716 3717 unsafe impl<'a> FromValue<'a> for WindowTypeHint { 3718 type Checker = glib::value::GenericValueTypeChecker<Self>; 3719 from_value(value: &'a glib::Value) -> Self3720 unsafe fn from_value(value: &'a glib::Value) -> Self { 3721 skip_assert_initialized!(); 3722 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3723 } 3724 } 3725 3726 impl ToValue for WindowTypeHint { to_value(&self) -> glib::Value3727 fn to_value(&self) -> glib::Value { 3728 let mut value = glib::Value::for_value_type::<Self>(); 3729 unsafe { 3730 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3731 } 3732 value 3733 } 3734 value_type(&self) -> glib::Type3735 fn value_type(&self) -> glib::Type { 3736 Self::static_type() 3737 } 3738 } 3739 3740 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3741 #[non_exhaustive] 3742 #[doc(alias = "GdkWindowWindowClass")] 3743 pub enum WindowWindowClass { 3744 #[doc(alias = "GDK_INPUT_OUTPUT")] 3745 InputOutput, 3746 #[doc(alias = "GDK_INPUT_ONLY")] 3747 InputOnly, 3748 #[doc(hidden)] 3749 __Unknown(i32), 3750 } 3751 3752 impl fmt::Display for WindowWindowClass { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3753 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3754 write!( 3755 f, 3756 "WindowWindowClass::{}", 3757 match *self { 3758 Self::InputOutput => "InputOutput", 3759 Self::InputOnly => "InputOnly", 3760 _ => "Unknown", 3761 } 3762 ) 3763 } 3764 } 3765 3766 #[doc(hidden)] 3767 impl IntoGlib for WindowWindowClass { 3768 type GlibType = ffi::GdkWindowWindowClass; 3769 into_glib(self) -> ffi::GdkWindowWindowClass3770 fn into_glib(self) -> ffi::GdkWindowWindowClass { 3771 match self { 3772 Self::InputOutput => ffi::GDK_INPUT_OUTPUT, 3773 Self::InputOnly => ffi::GDK_INPUT_ONLY, 3774 Self::__Unknown(value) => value, 3775 } 3776 } 3777 } 3778 3779 #[doc(hidden)] 3780 impl FromGlib<ffi::GdkWindowWindowClass> for WindowWindowClass { from_glib(value: ffi::GdkWindowWindowClass) -> Self3781 unsafe fn from_glib(value: ffi::GdkWindowWindowClass) -> Self { 3782 skip_assert_initialized!(); 3783 match value { 3784 ffi::GDK_INPUT_OUTPUT => Self::InputOutput, 3785 ffi::GDK_INPUT_ONLY => Self::InputOnly, 3786 value => Self::__Unknown(value), 3787 } 3788 } 3789 } 3790 3791 impl StaticType for WindowWindowClass { static_type() -> Type3792 fn static_type() -> Type { 3793 unsafe { from_glib(ffi::gdk_window_window_class_get_type()) } 3794 } 3795 } 3796 3797 impl glib::value::ValueType for WindowWindowClass { 3798 type Type = Self; 3799 } 3800 3801 unsafe impl<'a> FromValue<'a> for WindowWindowClass { 3802 type Checker = glib::value::GenericValueTypeChecker<Self>; 3803 from_value(value: &'a glib::Value) -> Self3804 unsafe fn from_value(value: &'a glib::Value) -> Self { 3805 skip_assert_initialized!(); 3806 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 3807 } 3808 } 3809 3810 impl ToValue for WindowWindowClass { to_value(&self) -> glib::Value3811 fn to_value(&self) -> glib::Value { 3812 let mut value = glib::Value::for_value_type::<Self>(); 3813 unsafe { 3814 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); 3815 } 3816 value 3817 } 3818 value_type(&self) -> glib::Type3819 fn value_type(&self) -> glib::Type { 3820 Self::static_type() 3821 } 3822 } 3823