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 gdk_sys; 6 use glib::error::ErrorDomain; 7 use glib::translate::*; 8 use glib::value::FromValue; 9 use glib::value::FromValueOptional; 10 use glib::value::SetValue; 11 use glib::value::Value; 12 use glib::Quark; 13 use glib::StaticType; 14 use glib::Type; 15 use gobject_sys; 16 use std::fmt; 17 18 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 19 pub enum AxisUse { 20 Ignore, 21 X, 22 Y, 23 Pressure, 24 Xtilt, 25 Ytilt, 26 Wheel, 27 Distance, 28 Rotation, 29 Slider, 30 Last, 31 #[doc(hidden)] 32 __Unknown(i32), 33 } 34 35 impl fmt::Display for AxisUse { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result36 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 37 write!( 38 f, 39 "AxisUse::{}", 40 match *self { 41 AxisUse::Ignore => "Ignore", 42 AxisUse::X => "X", 43 AxisUse::Y => "Y", 44 AxisUse::Pressure => "Pressure", 45 AxisUse::Xtilt => "Xtilt", 46 AxisUse::Ytilt => "Ytilt", 47 AxisUse::Wheel => "Wheel", 48 AxisUse::Distance => "Distance", 49 AxisUse::Rotation => "Rotation", 50 AxisUse::Slider => "Slider", 51 AxisUse::Last => "Last", 52 _ => "Unknown", 53 } 54 ) 55 } 56 } 57 58 #[doc(hidden)] 59 impl ToGlib for AxisUse { 60 type GlibType = gdk_sys::GdkAxisUse; 61 to_glib(&self) -> gdk_sys::GdkAxisUse62 fn to_glib(&self) -> gdk_sys::GdkAxisUse { 63 match *self { 64 AxisUse::Ignore => gdk_sys::GDK_AXIS_IGNORE, 65 AxisUse::X => gdk_sys::GDK_AXIS_X, 66 AxisUse::Y => gdk_sys::GDK_AXIS_Y, 67 AxisUse::Pressure => gdk_sys::GDK_AXIS_PRESSURE, 68 AxisUse::Xtilt => gdk_sys::GDK_AXIS_XTILT, 69 AxisUse::Ytilt => gdk_sys::GDK_AXIS_YTILT, 70 AxisUse::Wheel => gdk_sys::GDK_AXIS_WHEEL, 71 AxisUse::Distance => gdk_sys::GDK_AXIS_DISTANCE, 72 AxisUse::Rotation => gdk_sys::GDK_AXIS_ROTATION, 73 AxisUse::Slider => gdk_sys::GDK_AXIS_SLIDER, 74 AxisUse::Last => gdk_sys::GDK_AXIS_LAST, 75 AxisUse::__Unknown(value) => value, 76 } 77 } 78 } 79 80 #[doc(hidden)] 81 impl FromGlib<gdk_sys::GdkAxisUse> for AxisUse { from_glib(value: gdk_sys::GdkAxisUse) -> Self82 fn from_glib(value: gdk_sys::GdkAxisUse) -> Self { 83 skip_assert_initialized!(); 84 match value { 85 0 => AxisUse::Ignore, 86 1 => AxisUse::X, 87 2 => AxisUse::Y, 88 3 => AxisUse::Pressure, 89 4 => AxisUse::Xtilt, 90 5 => AxisUse::Ytilt, 91 6 => AxisUse::Wheel, 92 7 => AxisUse::Distance, 93 8 => AxisUse::Rotation, 94 9 => AxisUse::Slider, 95 10 => AxisUse::Last, 96 value => AxisUse::__Unknown(value), 97 } 98 } 99 } 100 101 impl StaticType for AxisUse { static_type() -> Type102 fn static_type() -> Type { 103 unsafe { from_glib(gdk_sys::gdk_axis_use_get_type()) } 104 } 105 } 106 107 impl<'a> FromValueOptional<'a> for AxisUse { from_value_optional(value: &Value) -> Option<Self>108 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 109 Some(FromValue::from_value(value)) 110 } 111 } 112 113 impl<'a> FromValue<'a> for AxisUse { from_value(value: &Value) -> Self114 unsafe fn from_value(value: &Value) -> Self { 115 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 116 } 117 } 118 119 impl SetValue for AxisUse { set_value(value: &mut Value, this: &Self)120 unsafe fn set_value(value: &mut Value, this: &Self) { 121 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 122 } 123 } 124 125 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 126 pub enum ByteOrder { 127 LsbFirst, 128 MsbFirst, 129 #[doc(hidden)] 130 __Unknown(i32), 131 } 132 133 impl fmt::Display for ByteOrder { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result134 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 135 write!( 136 f, 137 "ByteOrder::{}", 138 match *self { 139 ByteOrder::LsbFirst => "LsbFirst", 140 ByteOrder::MsbFirst => "MsbFirst", 141 _ => "Unknown", 142 } 143 ) 144 } 145 } 146 147 #[doc(hidden)] 148 impl ToGlib for ByteOrder { 149 type GlibType = gdk_sys::GdkByteOrder; 150 to_glib(&self) -> gdk_sys::GdkByteOrder151 fn to_glib(&self) -> gdk_sys::GdkByteOrder { 152 match *self { 153 ByteOrder::LsbFirst => gdk_sys::GDK_LSB_FIRST, 154 ByteOrder::MsbFirst => gdk_sys::GDK_MSB_FIRST, 155 ByteOrder::__Unknown(value) => value, 156 } 157 } 158 } 159 160 #[doc(hidden)] 161 impl FromGlib<gdk_sys::GdkByteOrder> for ByteOrder { from_glib(value: gdk_sys::GdkByteOrder) -> Self162 fn from_glib(value: gdk_sys::GdkByteOrder) -> Self { 163 skip_assert_initialized!(); 164 match value { 165 0 => ByteOrder::LsbFirst, 166 1 => ByteOrder::MsbFirst, 167 value => ByteOrder::__Unknown(value), 168 } 169 } 170 } 171 172 impl StaticType for ByteOrder { static_type() -> Type173 fn static_type() -> Type { 174 unsafe { from_glib(gdk_sys::gdk_byte_order_get_type()) } 175 } 176 } 177 178 impl<'a> FromValueOptional<'a> for ByteOrder { from_value_optional(value: &Value) -> Option<Self>179 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 180 Some(FromValue::from_value(value)) 181 } 182 } 183 184 impl<'a> FromValue<'a> for ByteOrder { from_value(value: &Value) -> Self185 unsafe fn from_value(value: &Value) -> Self { 186 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 187 } 188 } 189 190 impl SetValue for ByteOrder { set_value(value: &mut Value, this: &Self)191 unsafe fn set_value(value: &mut Value, this: &Self) { 192 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 193 } 194 } 195 196 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 197 pub enum CrossingMode { 198 Normal, 199 Grab, 200 Ungrab, 201 GtkGrab, 202 GtkUngrab, 203 StateChanged, 204 TouchBegin, 205 TouchEnd, 206 DeviceSwitch, 207 #[doc(hidden)] 208 __Unknown(i32), 209 } 210 211 impl fmt::Display for CrossingMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result212 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 213 write!( 214 f, 215 "CrossingMode::{}", 216 match *self { 217 CrossingMode::Normal => "Normal", 218 CrossingMode::Grab => "Grab", 219 CrossingMode::Ungrab => "Ungrab", 220 CrossingMode::GtkGrab => "GtkGrab", 221 CrossingMode::GtkUngrab => "GtkUngrab", 222 CrossingMode::StateChanged => "StateChanged", 223 CrossingMode::TouchBegin => "TouchBegin", 224 CrossingMode::TouchEnd => "TouchEnd", 225 CrossingMode::DeviceSwitch => "DeviceSwitch", 226 _ => "Unknown", 227 } 228 ) 229 } 230 } 231 232 #[doc(hidden)] 233 impl ToGlib for CrossingMode { 234 type GlibType = gdk_sys::GdkCrossingMode; 235 to_glib(&self) -> gdk_sys::GdkCrossingMode236 fn to_glib(&self) -> gdk_sys::GdkCrossingMode { 237 match *self { 238 CrossingMode::Normal => gdk_sys::GDK_CROSSING_NORMAL, 239 CrossingMode::Grab => gdk_sys::GDK_CROSSING_GRAB, 240 CrossingMode::Ungrab => gdk_sys::GDK_CROSSING_UNGRAB, 241 CrossingMode::GtkGrab => gdk_sys::GDK_CROSSING_GTK_GRAB, 242 CrossingMode::GtkUngrab => gdk_sys::GDK_CROSSING_GTK_UNGRAB, 243 CrossingMode::StateChanged => gdk_sys::GDK_CROSSING_STATE_CHANGED, 244 CrossingMode::TouchBegin => gdk_sys::GDK_CROSSING_TOUCH_BEGIN, 245 CrossingMode::TouchEnd => gdk_sys::GDK_CROSSING_TOUCH_END, 246 CrossingMode::DeviceSwitch => gdk_sys::GDK_CROSSING_DEVICE_SWITCH, 247 CrossingMode::__Unknown(value) => value, 248 } 249 } 250 } 251 252 #[doc(hidden)] 253 impl FromGlib<gdk_sys::GdkCrossingMode> for CrossingMode { from_glib(value: gdk_sys::GdkCrossingMode) -> Self254 fn from_glib(value: gdk_sys::GdkCrossingMode) -> Self { 255 skip_assert_initialized!(); 256 match value { 257 0 => CrossingMode::Normal, 258 1 => CrossingMode::Grab, 259 2 => CrossingMode::Ungrab, 260 3 => CrossingMode::GtkGrab, 261 4 => CrossingMode::GtkUngrab, 262 5 => CrossingMode::StateChanged, 263 6 => CrossingMode::TouchBegin, 264 7 => CrossingMode::TouchEnd, 265 8 => CrossingMode::DeviceSwitch, 266 value => CrossingMode::__Unknown(value), 267 } 268 } 269 } 270 271 impl StaticType for CrossingMode { static_type() -> Type272 fn static_type() -> Type { 273 unsafe { from_glib(gdk_sys::gdk_crossing_mode_get_type()) } 274 } 275 } 276 277 impl<'a> FromValueOptional<'a> for CrossingMode { from_value_optional(value: &Value) -> Option<Self>278 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 279 Some(FromValue::from_value(value)) 280 } 281 } 282 283 impl<'a> FromValue<'a> for CrossingMode { from_value(value: &Value) -> Self284 unsafe fn from_value(value: &Value) -> Self { 285 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 286 } 287 } 288 289 impl SetValue for CrossingMode { set_value(value: &mut Value, this: &Self)290 unsafe fn set_value(value: &mut Value, this: &Self) { 291 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 292 } 293 } 294 295 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 296 pub enum CursorType { 297 XCursor, 298 Arrow, 299 BasedArrowDown, 300 BasedArrowUp, 301 Boat, 302 Bogosity, 303 BottomLeftCorner, 304 BottomRightCorner, 305 BottomSide, 306 BottomTee, 307 BoxSpiral, 308 CenterPtr, 309 Circle, 310 Clock, 311 CoffeeMug, 312 Cross, 313 CrossReverse, 314 Crosshair, 315 DiamondCross, 316 Dot, 317 Dotbox, 318 DoubleArrow, 319 DraftLarge, 320 DraftSmall, 321 DrapedBox, 322 Exchange, 323 Fleur, 324 Gobbler, 325 Gumby, 326 Hand1, 327 Hand2, 328 Heart, 329 Icon, 330 IronCross, 331 LeftPtr, 332 LeftSide, 333 LeftTee, 334 Leftbutton, 335 LlAngle, 336 LrAngle, 337 Man, 338 Middlebutton, 339 Mouse, 340 Pencil, 341 Pirate, 342 Plus, 343 QuestionArrow, 344 RightPtr, 345 RightSide, 346 RightTee, 347 Rightbutton, 348 RtlLogo, 349 Sailboat, 350 SbDownArrow, 351 SbHDoubleArrow, 352 SbLeftArrow, 353 SbRightArrow, 354 SbUpArrow, 355 SbVDoubleArrow, 356 Shuttle, 357 Sizing, 358 Spider, 359 Spraycan, 360 Star, 361 Target, 362 Tcross, 363 TopLeftArrow, 364 TopLeftCorner, 365 TopRightCorner, 366 TopSide, 367 TopTee, 368 Trek, 369 UlAngle, 370 Umbrella, 371 UrAngle, 372 Watch, 373 Xterm, 374 LastCursor, 375 BlankCursor, 376 CursorIsPixmap, 377 #[doc(hidden)] 378 __Unknown(i32), 379 } 380 381 impl fmt::Display for CursorType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result382 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 383 write!( 384 f, 385 "CursorType::{}", 386 match *self { 387 CursorType::XCursor => "XCursor", 388 CursorType::Arrow => "Arrow", 389 CursorType::BasedArrowDown => "BasedArrowDown", 390 CursorType::BasedArrowUp => "BasedArrowUp", 391 CursorType::Boat => "Boat", 392 CursorType::Bogosity => "Bogosity", 393 CursorType::BottomLeftCorner => "BottomLeftCorner", 394 CursorType::BottomRightCorner => "BottomRightCorner", 395 CursorType::BottomSide => "BottomSide", 396 CursorType::BottomTee => "BottomTee", 397 CursorType::BoxSpiral => "BoxSpiral", 398 CursorType::CenterPtr => "CenterPtr", 399 CursorType::Circle => "Circle", 400 CursorType::Clock => "Clock", 401 CursorType::CoffeeMug => "CoffeeMug", 402 CursorType::Cross => "Cross", 403 CursorType::CrossReverse => "CrossReverse", 404 CursorType::Crosshair => "Crosshair", 405 CursorType::DiamondCross => "DiamondCross", 406 CursorType::Dot => "Dot", 407 CursorType::Dotbox => "Dotbox", 408 CursorType::DoubleArrow => "DoubleArrow", 409 CursorType::DraftLarge => "DraftLarge", 410 CursorType::DraftSmall => "DraftSmall", 411 CursorType::DrapedBox => "DrapedBox", 412 CursorType::Exchange => "Exchange", 413 CursorType::Fleur => "Fleur", 414 CursorType::Gobbler => "Gobbler", 415 CursorType::Gumby => "Gumby", 416 CursorType::Hand1 => "Hand1", 417 CursorType::Hand2 => "Hand2", 418 CursorType::Heart => "Heart", 419 CursorType::Icon => "Icon", 420 CursorType::IronCross => "IronCross", 421 CursorType::LeftPtr => "LeftPtr", 422 CursorType::LeftSide => "LeftSide", 423 CursorType::LeftTee => "LeftTee", 424 CursorType::Leftbutton => "Leftbutton", 425 CursorType::LlAngle => "LlAngle", 426 CursorType::LrAngle => "LrAngle", 427 CursorType::Man => "Man", 428 CursorType::Middlebutton => "Middlebutton", 429 CursorType::Mouse => "Mouse", 430 CursorType::Pencil => "Pencil", 431 CursorType::Pirate => "Pirate", 432 CursorType::Plus => "Plus", 433 CursorType::QuestionArrow => "QuestionArrow", 434 CursorType::RightPtr => "RightPtr", 435 CursorType::RightSide => "RightSide", 436 CursorType::RightTee => "RightTee", 437 CursorType::Rightbutton => "Rightbutton", 438 CursorType::RtlLogo => "RtlLogo", 439 CursorType::Sailboat => "Sailboat", 440 CursorType::SbDownArrow => "SbDownArrow", 441 CursorType::SbHDoubleArrow => "SbHDoubleArrow", 442 CursorType::SbLeftArrow => "SbLeftArrow", 443 CursorType::SbRightArrow => "SbRightArrow", 444 CursorType::SbUpArrow => "SbUpArrow", 445 CursorType::SbVDoubleArrow => "SbVDoubleArrow", 446 CursorType::Shuttle => "Shuttle", 447 CursorType::Sizing => "Sizing", 448 CursorType::Spider => "Spider", 449 CursorType::Spraycan => "Spraycan", 450 CursorType::Star => "Star", 451 CursorType::Target => "Target", 452 CursorType::Tcross => "Tcross", 453 CursorType::TopLeftArrow => "TopLeftArrow", 454 CursorType::TopLeftCorner => "TopLeftCorner", 455 CursorType::TopRightCorner => "TopRightCorner", 456 CursorType::TopSide => "TopSide", 457 CursorType::TopTee => "TopTee", 458 CursorType::Trek => "Trek", 459 CursorType::UlAngle => "UlAngle", 460 CursorType::Umbrella => "Umbrella", 461 CursorType::UrAngle => "UrAngle", 462 CursorType::Watch => "Watch", 463 CursorType::Xterm => "Xterm", 464 CursorType::LastCursor => "LastCursor", 465 CursorType::BlankCursor => "BlankCursor", 466 CursorType::CursorIsPixmap => "CursorIsPixmap", 467 _ => "Unknown", 468 } 469 ) 470 } 471 } 472 473 #[doc(hidden)] 474 impl ToGlib for CursorType { 475 type GlibType = gdk_sys::GdkCursorType; 476 to_glib(&self) -> gdk_sys::GdkCursorType477 fn to_glib(&self) -> gdk_sys::GdkCursorType { 478 match *self { 479 CursorType::XCursor => gdk_sys::GDK_X_CURSOR, 480 CursorType::Arrow => gdk_sys::GDK_ARROW, 481 CursorType::BasedArrowDown => gdk_sys::GDK_BASED_ARROW_DOWN, 482 CursorType::BasedArrowUp => gdk_sys::GDK_BASED_ARROW_UP, 483 CursorType::Boat => gdk_sys::GDK_BOAT, 484 CursorType::Bogosity => gdk_sys::GDK_BOGOSITY, 485 CursorType::BottomLeftCorner => gdk_sys::GDK_BOTTOM_LEFT_CORNER, 486 CursorType::BottomRightCorner => gdk_sys::GDK_BOTTOM_RIGHT_CORNER, 487 CursorType::BottomSide => gdk_sys::GDK_BOTTOM_SIDE, 488 CursorType::BottomTee => gdk_sys::GDK_BOTTOM_TEE, 489 CursorType::BoxSpiral => gdk_sys::GDK_BOX_SPIRAL, 490 CursorType::CenterPtr => gdk_sys::GDK_CENTER_PTR, 491 CursorType::Circle => gdk_sys::GDK_CIRCLE, 492 CursorType::Clock => gdk_sys::GDK_CLOCK, 493 CursorType::CoffeeMug => gdk_sys::GDK_COFFEE_MUG, 494 CursorType::Cross => gdk_sys::GDK_CROSS, 495 CursorType::CrossReverse => gdk_sys::GDK_CROSS_REVERSE, 496 CursorType::Crosshair => gdk_sys::GDK_CROSSHAIR, 497 CursorType::DiamondCross => gdk_sys::GDK_DIAMOND_CROSS, 498 CursorType::Dot => gdk_sys::GDK_DOT, 499 CursorType::Dotbox => gdk_sys::GDK_DOTBOX, 500 CursorType::DoubleArrow => gdk_sys::GDK_DOUBLE_ARROW, 501 CursorType::DraftLarge => gdk_sys::GDK_DRAFT_LARGE, 502 CursorType::DraftSmall => gdk_sys::GDK_DRAFT_SMALL, 503 CursorType::DrapedBox => gdk_sys::GDK_DRAPED_BOX, 504 CursorType::Exchange => gdk_sys::GDK_EXCHANGE, 505 CursorType::Fleur => gdk_sys::GDK_FLEUR, 506 CursorType::Gobbler => gdk_sys::GDK_GOBBLER, 507 CursorType::Gumby => gdk_sys::GDK_GUMBY, 508 CursorType::Hand1 => gdk_sys::GDK_HAND1, 509 CursorType::Hand2 => gdk_sys::GDK_HAND2, 510 CursorType::Heart => gdk_sys::GDK_HEART, 511 CursorType::Icon => gdk_sys::GDK_ICON, 512 CursorType::IronCross => gdk_sys::GDK_IRON_CROSS, 513 CursorType::LeftPtr => gdk_sys::GDK_LEFT_PTR, 514 CursorType::LeftSide => gdk_sys::GDK_LEFT_SIDE, 515 CursorType::LeftTee => gdk_sys::GDK_LEFT_TEE, 516 CursorType::Leftbutton => gdk_sys::GDK_LEFTBUTTON, 517 CursorType::LlAngle => gdk_sys::GDK_LL_ANGLE, 518 CursorType::LrAngle => gdk_sys::GDK_LR_ANGLE, 519 CursorType::Man => gdk_sys::GDK_MAN, 520 CursorType::Middlebutton => gdk_sys::GDK_MIDDLEBUTTON, 521 CursorType::Mouse => gdk_sys::GDK_MOUSE, 522 CursorType::Pencil => gdk_sys::GDK_PENCIL, 523 CursorType::Pirate => gdk_sys::GDK_PIRATE, 524 CursorType::Plus => gdk_sys::GDK_PLUS, 525 CursorType::QuestionArrow => gdk_sys::GDK_QUESTION_ARROW, 526 CursorType::RightPtr => gdk_sys::GDK_RIGHT_PTR, 527 CursorType::RightSide => gdk_sys::GDK_RIGHT_SIDE, 528 CursorType::RightTee => gdk_sys::GDK_RIGHT_TEE, 529 CursorType::Rightbutton => gdk_sys::GDK_RIGHTBUTTON, 530 CursorType::RtlLogo => gdk_sys::GDK_RTL_LOGO, 531 CursorType::Sailboat => gdk_sys::GDK_SAILBOAT, 532 CursorType::SbDownArrow => gdk_sys::GDK_SB_DOWN_ARROW, 533 CursorType::SbHDoubleArrow => gdk_sys::GDK_SB_H_DOUBLE_ARROW, 534 CursorType::SbLeftArrow => gdk_sys::GDK_SB_LEFT_ARROW, 535 CursorType::SbRightArrow => gdk_sys::GDK_SB_RIGHT_ARROW, 536 CursorType::SbUpArrow => gdk_sys::GDK_SB_UP_ARROW, 537 CursorType::SbVDoubleArrow => gdk_sys::GDK_SB_V_DOUBLE_ARROW, 538 CursorType::Shuttle => gdk_sys::GDK_SHUTTLE, 539 CursorType::Sizing => gdk_sys::GDK_SIZING, 540 CursorType::Spider => gdk_sys::GDK_SPIDER, 541 CursorType::Spraycan => gdk_sys::GDK_SPRAYCAN, 542 CursorType::Star => gdk_sys::GDK_STAR, 543 CursorType::Target => gdk_sys::GDK_TARGET, 544 CursorType::Tcross => gdk_sys::GDK_TCROSS, 545 CursorType::TopLeftArrow => gdk_sys::GDK_TOP_LEFT_ARROW, 546 CursorType::TopLeftCorner => gdk_sys::GDK_TOP_LEFT_CORNER, 547 CursorType::TopRightCorner => gdk_sys::GDK_TOP_RIGHT_CORNER, 548 CursorType::TopSide => gdk_sys::GDK_TOP_SIDE, 549 CursorType::TopTee => gdk_sys::GDK_TOP_TEE, 550 CursorType::Trek => gdk_sys::GDK_TREK, 551 CursorType::UlAngle => gdk_sys::GDK_UL_ANGLE, 552 CursorType::Umbrella => gdk_sys::GDK_UMBRELLA, 553 CursorType::UrAngle => gdk_sys::GDK_UR_ANGLE, 554 CursorType::Watch => gdk_sys::GDK_WATCH, 555 CursorType::Xterm => gdk_sys::GDK_XTERM, 556 CursorType::LastCursor => gdk_sys::GDK_LAST_CURSOR, 557 CursorType::BlankCursor => gdk_sys::GDK_BLANK_CURSOR, 558 CursorType::CursorIsPixmap => gdk_sys::GDK_CURSOR_IS_PIXMAP, 559 CursorType::__Unknown(value) => value, 560 } 561 } 562 } 563 564 #[doc(hidden)] 565 impl FromGlib<gdk_sys::GdkCursorType> for CursorType { from_glib(value: gdk_sys::GdkCursorType) -> Self566 fn from_glib(value: gdk_sys::GdkCursorType) -> Self { 567 skip_assert_initialized!(); 568 match value { 569 0 => CursorType::XCursor, 570 2 => CursorType::Arrow, 571 4 => CursorType::BasedArrowDown, 572 6 => CursorType::BasedArrowUp, 573 8 => CursorType::Boat, 574 10 => CursorType::Bogosity, 575 12 => CursorType::BottomLeftCorner, 576 14 => CursorType::BottomRightCorner, 577 16 => CursorType::BottomSide, 578 18 => CursorType::BottomTee, 579 20 => CursorType::BoxSpiral, 580 22 => CursorType::CenterPtr, 581 24 => CursorType::Circle, 582 26 => CursorType::Clock, 583 28 => CursorType::CoffeeMug, 584 30 => CursorType::Cross, 585 32 => CursorType::CrossReverse, 586 34 => CursorType::Crosshair, 587 36 => CursorType::DiamondCross, 588 38 => CursorType::Dot, 589 40 => CursorType::Dotbox, 590 42 => CursorType::DoubleArrow, 591 44 => CursorType::DraftLarge, 592 46 => CursorType::DraftSmall, 593 48 => CursorType::DrapedBox, 594 50 => CursorType::Exchange, 595 52 => CursorType::Fleur, 596 54 => CursorType::Gobbler, 597 56 => CursorType::Gumby, 598 58 => CursorType::Hand1, 599 60 => CursorType::Hand2, 600 62 => CursorType::Heart, 601 64 => CursorType::Icon, 602 66 => CursorType::IronCross, 603 68 => CursorType::LeftPtr, 604 70 => CursorType::LeftSide, 605 72 => CursorType::LeftTee, 606 74 => CursorType::Leftbutton, 607 76 => CursorType::LlAngle, 608 78 => CursorType::LrAngle, 609 80 => CursorType::Man, 610 82 => CursorType::Middlebutton, 611 84 => CursorType::Mouse, 612 86 => CursorType::Pencil, 613 88 => CursorType::Pirate, 614 90 => CursorType::Plus, 615 92 => CursorType::QuestionArrow, 616 94 => CursorType::RightPtr, 617 96 => CursorType::RightSide, 618 98 => CursorType::RightTee, 619 100 => CursorType::Rightbutton, 620 102 => CursorType::RtlLogo, 621 104 => CursorType::Sailboat, 622 106 => CursorType::SbDownArrow, 623 108 => CursorType::SbHDoubleArrow, 624 110 => CursorType::SbLeftArrow, 625 112 => CursorType::SbRightArrow, 626 114 => CursorType::SbUpArrow, 627 116 => CursorType::SbVDoubleArrow, 628 118 => CursorType::Shuttle, 629 120 => CursorType::Sizing, 630 122 => CursorType::Spider, 631 124 => CursorType::Spraycan, 632 126 => CursorType::Star, 633 128 => CursorType::Target, 634 130 => CursorType::Tcross, 635 132 => CursorType::TopLeftArrow, 636 134 => CursorType::TopLeftCorner, 637 136 => CursorType::TopRightCorner, 638 138 => CursorType::TopSide, 639 140 => CursorType::TopTee, 640 142 => CursorType::Trek, 641 144 => CursorType::UlAngle, 642 146 => CursorType::Umbrella, 643 148 => CursorType::UrAngle, 644 150 => CursorType::Watch, 645 152 => CursorType::Xterm, 646 153 => CursorType::LastCursor, 647 -2 => CursorType::BlankCursor, 648 -1 => CursorType::CursorIsPixmap, 649 value => CursorType::__Unknown(value), 650 } 651 } 652 } 653 654 impl StaticType for CursorType { static_type() -> Type655 fn static_type() -> Type { 656 unsafe { from_glib(gdk_sys::gdk_cursor_type_get_type()) } 657 } 658 } 659 660 impl<'a> FromValueOptional<'a> for CursorType { from_value_optional(value: &Value) -> Option<Self>661 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 662 Some(FromValue::from_value(value)) 663 } 664 } 665 666 impl<'a> FromValue<'a> for CursorType { from_value(value: &Value) -> Self667 unsafe fn from_value(value: &Value) -> Self { 668 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 669 } 670 } 671 672 impl SetValue for CursorType { set_value(value: &mut Value, this: &Self)673 unsafe fn set_value(value: &mut Value, this: &Self) { 674 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 675 } 676 } 677 678 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 679 pub enum DevicePadFeature { 680 Button, 681 Ring, 682 Strip, 683 #[doc(hidden)] 684 __Unknown(i32), 685 } 686 687 impl fmt::Display for DevicePadFeature { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result688 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 689 write!( 690 f, 691 "DevicePadFeature::{}", 692 match *self { 693 DevicePadFeature::Button => "Button", 694 DevicePadFeature::Ring => "Ring", 695 DevicePadFeature::Strip => "Strip", 696 _ => "Unknown", 697 } 698 ) 699 } 700 } 701 702 #[doc(hidden)] 703 impl ToGlib for DevicePadFeature { 704 type GlibType = gdk_sys::GdkDevicePadFeature; 705 to_glib(&self) -> gdk_sys::GdkDevicePadFeature706 fn to_glib(&self) -> gdk_sys::GdkDevicePadFeature { 707 match *self { 708 DevicePadFeature::Button => gdk_sys::GDK_DEVICE_PAD_FEATURE_BUTTON, 709 DevicePadFeature::Ring => gdk_sys::GDK_DEVICE_PAD_FEATURE_RING, 710 DevicePadFeature::Strip => gdk_sys::GDK_DEVICE_PAD_FEATURE_STRIP, 711 DevicePadFeature::__Unknown(value) => value, 712 } 713 } 714 } 715 716 #[doc(hidden)] 717 impl FromGlib<gdk_sys::GdkDevicePadFeature> for DevicePadFeature { from_glib(value: gdk_sys::GdkDevicePadFeature) -> Self718 fn from_glib(value: gdk_sys::GdkDevicePadFeature) -> Self { 719 skip_assert_initialized!(); 720 match value { 721 0 => DevicePadFeature::Button, 722 1 => DevicePadFeature::Ring, 723 2 => DevicePadFeature::Strip, 724 value => DevicePadFeature::__Unknown(value), 725 } 726 } 727 } 728 729 impl StaticType for DevicePadFeature { static_type() -> Type730 fn static_type() -> Type { 731 unsafe { from_glib(gdk_sys::gdk_device_pad_feature_get_type()) } 732 } 733 } 734 735 impl<'a> FromValueOptional<'a> for DevicePadFeature { from_value_optional(value: &Value) -> Option<Self>736 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 737 Some(FromValue::from_value(value)) 738 } 739 } 740 741 impl<'a> FromValue<'a> for DevicePadFeature { from_value(value: &Value) -> Self742 unsafe fn from_value(value: &Value) -> Self { 743 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 744 } 745 } 746 747 impl SetValue for DevicePadFeature { set_value(value: &mut Value, this: &Self)748 unsafe fn set_value(value: &mut Value, this: &Self) { 749 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 750 } 751 } 752 753 #[cfg(any(feature = "v3_22", feature = "dox"))] 754 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 755 pub enum DeviceToolType { 756 Unknown, 757 Pen, 758 Eraser, 759 Brush, 760 Pencil, 761 Airbrush, 762 Mouse, 763 Lens, 764 #[doc(hidden)] 765 __Unknown(i32), 766 } 767 768 #[cfg(any(feature = "v3_22", feature = "dox"))] 769 impl fmt::Display for DeviceToolType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result770 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 771 write!( 772 f, 773 "DeviceToolType::{}", 774 match *self { 775 DeviceToolType::Unknown => "Unknown", 776 DeviceToolType::Pen => "Pen", 777 DeviceToolType::Eraser => "Eraser", 778 DeviceToolType::Brush => "Brush", 779 DeviceToolType::Pencil => "Pencil", 780 DeviceToolType::Airbrush => "Airbrush", 781 DeviceToolType::Mouse => "Mouse", 782 DeviceToolType::Lens => "Lens", 783 _ => "Unknown", 784 } 785 ) 786 } 787 } 788 789 #[cfg(any(feature = "v3_22", feature = "dox"))] 790 #[doc(hidden)] 791 impl ToGlib for DeviceToolType { 792 type GlibType = gdk_sys::GdkDeviceToolType; 793 to_glib(&self) -> gdk_sys::GdkDeviceToolType794 fn to_glib(&self) -> gdk_sys::GdkDeviceToolType { 795 match *self { 796 DeviceToolType::Unknown => gdk_sys::GDK_DEVICE_TOOL_TYPE_UNKNOWN, 797 DeviceToolType::Pen => gdk_sys::GDK_DEVICE_TOOL_TYPE_PEN, 798 DeviceToolType::Eraser => gdk_sys::GDK_DEVICE_TOOL_TYPE_ERASER, 799 DeviceToolType::Brush => gdk_sys::GDK_DEVICE_TOOL_TYPE_BRUSH, 800 DeviceToolType::Pencil => gdk_sys::GDK_DEVICE_TOOL_TYPE_PENCIL, 801 DeviceToolType::Airbrush => gdk_sys::GDK_DEVICE_TOOL_TYPE_AIRBRUSH, 802 DeviceToolType::Mouse => gdk_sys::GDK_DEVICE_TOOL_TYPE_MOUSE, 803 DeviceToolType::Lens => gdk_sys::GDK_DEVICE_TOOL_TYPE_LENS, 804 DeviceToolType::__Unknown(value) => value, 805 } 806 } 807 } 808 809 #[cfg(any(feature = "v3_22", feature = "dox"))] 810 #[doc(hidden)] 811 impl FromGlib<gdk_sys::GdkDeviceToolType> for DeviceToolType { from_glib(value: gdk_sys::GdkDeviceToolType) -> Self812 fn from_glib(value: gdk_sys::GdkDeviceToolType) -> Self { 813 skip_assert_initialized!(); 814 match value { 815 0 => DeviceToolType::Unknown, 816 1 => DeviceToolType::Pen, 817 2 => DeviceToolType::Eraser, 818 3 => DeviceToolType::Brush, 819 4 => DeviceToolType::Pencil, 820 5 => DeviceToolType::Airbrush, 821 6 => DeviceToolType::Mouse, 822 7 => DeviceToolType::Lens, 823 value => DeviceToolType::__Unknown(value), 824 } 825 } 826 } 827 828 #[cfg(any(feature = "v3_22", feature = "dox"))] 829 impl StaticType for DeviceToolType { static_type() -> Type830 fn static_type() -> Type { 831 unsafe { from_glib(gdk_sys::gdk_device_tool_type_get_type()) } 832 } 833 } 834 835 #[cfg(any(feature = "v3_22", feature = "dox"))] 836 impl<'a> FromValueOptional<'a> for DeviceToolType { from_value_optional(value: &Value) -> Option<Self>837 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 838 Some(FromValue::from_value(value)) 839 } 840 } 841 842 #[cfg(any(feature = "v3_22", feature = "dox"))] 843 impl<'a> FromValue<'a> for DeviceToolType { from_value(value: &Value) -> Self844 unsafe fn from_value(value: &Value) -> Self { 845 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 846 } 847 } 848 849 #[cfg(any(feature = "v3_22", feature = "dox"))] 850 impl SetValue for DeviceToolType { set_value(value: &mut Value, this: &Self)851 unsafe fn set_value(value: &mut Value, this: &Self) { 852 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 853 } 854 } 855 856 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 857 pub enum DeviceType { 858 Master, 859 Slave, 860 Floating, 861 #[doc(hidden)] 862 __Unknown(i32), 863 } 864 865 impl fmt::Display for DeviceType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result866 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 867 write!( 868 f, 869 "DeviceType::{}", 870 match *self { 871 DeviceType::Master => "Master", 872 DeviceType::Slave => "Slave", 873 DeviceType::Floating => "Floating", 874 _ => "Unknown", 875 } 876 ) 877 } 878 } 879 880 #[doc(hidden)] 881 impl ToGlib for DeviceType { 882 type GlibType = gdk_sys::GdkDeviceType; 883 to_glib(&self) -> gdk_sys::GdkDeviceType884 fn to_glib(&self) -> gdk_sys::GdkDeviceType { 885 match *self { 886 DeviceType::Master => gdk_sys::GDK_DEVICE_TYPE_MASTER, 887 DeviceType::Slave => gdk_sys::GDK_DEVICE_TYPE_SLAVE, 888 DeviceType::Floating => gdk_sys::GDK_DEVICE_TYPE_FLOATING, 889 DeviceType::__Unknown(value) => value, 890 } 891 } 892 } 893 894 #[doc(hidden)] 895 impl FromGlib<gdk_sys::GdkDeviceType> for DeviceType { from_glib(value: gdk_sys::GdkDeviceType) -> Self896 fn from_glib(value: gdk_sys::GdkDeviceType) -> Self { 897 skip_assert_initialized!(); 898 match value { 899 0 => DeviceType::Master, 900 1 => DeviceType::Slave, 901 2 => DeviceType::Floating, 902 value => DeviceType::__Unknown(value), 903 } 904 } 905 } 906 907 impl StaticType for DeviceType { static_type() -> Type908 fn static_type() -> Type { 909 unsafe { from_glib(gdk_sys::gdk_device_type_get_type()) } 910 } 911 } 912 913 impl<'a> FromValueOptional<'a> for DeviceType { from_value_optional(value: &Value) -> Option<Self>914 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 915 Some(FromValue::from_value(value)) 916 } 917 } 918 919 impl<'a> FromValue<'a> for DeviceType { from_value(value: &Value) -> Self920 unsafe fn from_value(value: &Value) -> Self { 921 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 922 } 923 } 924 925 impl SetValue for DeviceType { set_value(value: &mut Value, this: &Self)926 unsafe fn set_value(value: &mut Value, this: &Self) { 927 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 928 } 929 } 930 931 #[cfg(any(feature = "v3_20", feature = "dox"))] 932 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 933 pub enum DragCancelReason { 934 NoTarget, 935 UserCancelled, 936 Error, 937 #[doc(hidden)] 938 __Unknown(i32), 939 } 940 941 #[cfg(any(feature = "v3_20", feature = "dox"))] 942 impl fmt::Display for DragCancelReason { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result943 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 944 write!( 945 f, 946 "DragCancelReason::{}", 947 match *self { 948 DragCancelReason::NoTarget => "NoTarget", 949 DragCancelReason::UserCancelled => "UserCancelled", 950 DragCancelReason::Error => "Error", 951 _ => "Unknown", 952 } 953 ) 954 } 955 } 956 957 #[cfg(any(feature = "v3_20", feature = "dox"))] 958 #[doc(hidden)] 959 impl ToGlib for DragCancelReason { 960 type GlibType = gdk_sys::GdkDragCancelReason; 961 to_glib(&self) -> gdk_sys::GdkDragCancelReason962 fn to_glib(&self) -> gdk_sys::GdkDragCancelReason { 963 match *self { 964 DragCancelReason::NoTarget => gdk_sys::GDK_DRAG_CANCEL_NO_TARGET, 965 DragCancelReason::UserCancelled => gdk_sys::GDK_DRAG_CANCEL_USER_CANCELLED, 966 DragCancelReason::Error => gdk_sys::GDK_DRAG_CANCEL_ERROR, 967 DragCancelReason::__Unknown(value) => value, 968 } 969 } 970 } 971 972 #[cfg(any(feature = "v3_20", feature = "dox"))] 973 #[doc(hidden)] 974 impl FromGlib<gdk_sys::GdkDragCancelReason> for DragCancelReason { from_glib(value: gdk_sys::GdkDragCancelReason) -> Self975 fn from_glib(value: gdk_sys::GdkDragCancelReason) -> Self { 976 skip_assert_initialized!(); 977 match value { 978 0 => DragCancelReason::NoTarget, 979 1 => DragCancelReason::UserCancelled, 980 2 => DragCancelReason::Error, 981 value => DragCancelReason::__Unknown(value), 982 } 983 } 984 } 985 986 #[cfg(any(feature = "v3_20", feature = "dox"))] 987 impl StaticType for DragCancelReason { static_type() -> Type988 fn static_type() -> Type { 989 unsafe { from_glib(gdk_sys::gdk_drag_cancel_reason_get_type()) } 990 } 991 } 992 993 #[cfg(any(feature = "v3_20", feature = "dox"))] 994 impl<'a> FromValueOptional<'a> for DragCancelReason { from_value_optional(value: &Value) -> Option<Self>995 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 996 Some(FromValue::from_value(value)) 997 } 998 } 999 1000 #[cfg(any(feature = "v3_20", feature = "dox"))] 1001 impl<'a> FromValue<'a> for DragCancelReason { from_value(value: &Value) -> Self1002 unsafe fn from_value(value: &Value) -> Self { 1003 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1004 } 1005 } 1006 1007 #[cfg(any(feature = "v3_20", feature = "dox"))] 1008 impl SetValue for DragCancelReason { set_value(value: &mut Value, this: &Self)1009 unsafe fn set_value(value: &mut Value, this: &Self) { 1010 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1011 } 1012 } 1013 1014 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1015 pub enum DragProtocol { 1016 None, 1017 Motif, 1018 Xdnd, 1019 Rootwin, 1020 Win32Dropfiles, 1021 Ole2, 1022 Local, 1023 Wayland, 1024 #[doc(hidden)] 1025 __Unknown(i32), 1026 } 1027 1028 impl fmt::Display for DragProtocol { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1029 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1030 write!( 1031 f, 1032 "DragProtocol::{}", 1033 match *self { 1034 DragProtocol::None => "None", 1035 DragProtocol::Motif => "Motif", 1036 DragProtocol::Xdnd => "Xdnd", 1037 DragProtocol::Rootwin => "Rootwin", 1038 DragProtocol::Win32Dropfiles => "Win32Dropfiles", 1039 DragProtocol::Ole2 => "Ole2", 1040 DragProtocol::Local => "Local", 1041 DragProtocol::Wayland => "Wayland", 1042 _ => "Unknown", 1043 } 1044 ) 1045 } 1046 } 1047 1048 #[doc(hidden)] 1049 impl ToGlib for DragProtocol { 1050 type GlibType = gdk_sys::GdkDragProtocol; 1051 to_glib(&self) -> gdk_sys::GdkDragProtocol1052 fn to_glib(&self) -> gdk_sys::GdkDragProtocol { 1053 match *self { 1054 DragProtocol::None => gdk_sys::GDK_DRAG_PROTO_NONE, 1055 DragProtocol::Motif => gdk_sys::GDK_DRAG_PROTO_MOTIF, 1056 DragProtocol::Xdnd => gdk_sys::GDK_DRAG_PROTO_XDND, 1057 DragProtocol::Rootwin => gdk_sys::GDK_DRAG_PROTO_ROOTWIN, 1058 DragProtocol::Win32Dropfiles => gdk_sys::GDK_DRAG_PROTO_WIN32_DROPFILES, 1059 DragProtocol::Ole2 => gdk_sys::GDK_DRAG_PROTO_OLE2, 1060 DragProtocol::Local => gdk_sys::GDK_DRAG_PROTO_LOCAL, 1061 DragProtocol::Wayland => gdk_sys::GDK_DRAG_PROTO_WAYLAND, 1062 DragProtocol::__Unknown(value) => value, 1063 } 1064 } 1065 } 1066 1067 #[doc(hidden)] 1068 impl FromGlib<gdk_sys::GdkDragProtocol> for DragProtocol { from_glib(value: gdk_sys::GdkDragProtocol) -> Self1069 fn from_glib(value: gdk_sys::GdkDragProtocol) -> Self { 1070 skip_assert_initialized!(); 1071 match value { 1072 0 => DragProtocol::None, 1073 1 => DragProtocol::Motif, 1074 2 => DragProtocol::Xdnd, 1075 3 => DragProtocol::Rootwin, 1076 4 => DragProtocol::Win32Dropfiles, 1077 5 => DragProtocol::Ole2, 1078 6 => DragProtocol::Local, 1079 7 => DragProtocol::Wayland, 1080 value => DragProtocol::__Unknown(value), 1081 } 1082 } 1083 } 1084 1085 impl StaticType for DragProtocol { static_type() -> Type1086 fn static_type() -> Type { 1087 unsafe { from_glib(gdk_sys::gdk_drag_protocol_get_type()) } 1088 } 1089 } 1090 1091 impl<'a> FromValueOptional<'a> for DragProtocol { from_value_optional(value: &Value) -> Option<Self>1092 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1093 Some(FromValue::from_value(value)) 1094 } 1095 } 1096 1097 impl<'a> FromValue<'a> for DragProtocol { from_value(value: &Value) -> Self1098 unsafe fn from_value(value: &Value) -> Self { 1099 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1100 } 1101 } 1102 1103 impl SetValue for DragProtocol { set_value(value: &mut Value, this: &Self)1104 unsafe fn set_value(value: &mut Value, this: &Self) { 1105 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1106 } 1107 } 1108 1109 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1110 pub enum EventType { 1111 Nothing, 1112 Delete, 1113 Destroy, 1114 Expose, 1115 MotionNotify, 1116 ButtonPress, 1117 DoubleButtonPress, 1118 TripleButtonPress, 1119 ButtonRelease, 1120 KeyPress, 1121 KeyRelease, 1122 EnterNotify, 1123 LeaveNotify, 1124 FocusChange, 1125 Configure, 1126 Map, 1127 Unmap, 1128 PropertyNotify, 1129 SelectionClear, 1130 SelectionRequest, 1131 SelectionNotify, 1132 ProximityIn, 1133 ProximityOut, 1134 DragEnter, 1135 DragLeave, 1136 DragMotion, 1137 DragStatus, 1138 DropStart, 1139 DropFinished, 1140 ClientEvent, 1141 VisibilityNotify, 1142 Scroll, 1143 WindowState, 1144 Setting, 1145 OwnerChange, 1146 GrabBroken, 1147 Damage, 1148 TouchBegin, 1149 TouchUpdate, 1150 TouchEnd, 1151 TouchCancel, 1152 #[cfg(any(feature = "v3_18", feature = "dox"))] 1153 TouchpadSwipe, 1154 #[cfg(any(feature = "v3_18", feature = "dox"))] 1155 TouchpadPinch, 1156 PadButtonPress, 1157 PadButtonRelease, 1158 PadRing, 1159 PadStrip, 1160 PadGroupMode, 1161 #[doc(hidden)] 1162 __Unknown(i32), 1163 } 1164 1165 impl fmt::Display for EventType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1166 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1167 write!( 1168 f, 1169 "EventType::{}", 1170 match *self { 1171 EventType::Nothing => "Nothing", 1172 EventType::Delete => "Delete", 1173 EventType::Destroy => "Destroy", 1174 EventType::Expose => "Expose", 1175 EventType::MotionNotify => "MotionNotify", 1176 EventType::ButtonPress => "ButtonPress", 1177 EventType::DoubleButtonPress => "DoubleButtonPress", 1178 EventType::TripleButtonPress => "TripleButtonPress", 1179 EventType::ButtonRelease => "ButtonRelease", 1180 EventType::KeyPress => "KeyPress", 1181 EventType::KeyRelease => "KeyRelease", 1182 EventType::EnterNotify => "EnterNotify", 1183 EventType::LeaveNotify => "LeaveNotify", 1184 EventType::FocusChange => "FocusChange", 1185 EventType::Configure => "Configure", 1186 EventType::Map => "Map", 1187 EventType::Unmap => "Unmap", 1188 EventType::PropertyNotify => "PropertyNotify", 1189 EventType::SelectionClear => "SelectionClear", 1190 EventType::SelectionRequest => "SelectionRequest", 1191 EventType::SelectionNotify => "SelectionNotify", 1192 EventType::ProximityIn => "ProximityIn", 1193 EventType::ProximityOut => "ProximityOut", 1194 EventType::DragEnter => "DragEnter", 1195 EventType::DragLeave => "DragLeave", 1196 EventType::DragMotion => "DragMotion", 1197 EventType::DragStatus => "DragStatus", 1198 EventType::DropStart => "DropStart", 1199 EventType::DropFinished => "DropFinished", 1200 EventType::ClientEvent => "ClientEvent", 1201 EventType::VisibilityNotify => "VisibilityNotify", 1202 EventType::Scroll => "Scroll", 1203 EventType::WindowState => "WindowState", 1204 EventType::Setting => "Setting", 1205 EventType::OwnerChange => "OwnerChange", 1206 EventType::GrabBroken => "GrabBroken", 1207 EventType::Damage => "Damage", 1208 EventType::TouchBegin => "TouchBegin", 1209 EventType::TouchUpdate => "TouchUpdate", 1210 EventType::TouchEnd => "TouchEnd", 1211 EventType::TouchCancel => "TouchCancel", 1212 #[cfg(any(feature = "v3_18", feature = "dox"))] 1213 EventType::TouchpadSwipe => "TouchpadSwipe", 1214 #[cfg(any(feature = "v3_18", feature = "dox"))] 1215 EventType::TouchpadPinch => "TouchpadPinch", 1216 EventType::PadButtonPress => "PadButtonPress", 1217 EventType::PadButtonRelease => "PadButtonRelease", 1218 EventType::PadRing => "PadRing", 1219 EventType::PadStrip => "PadStrip", 1220 EventType::PadGroupMode => "PadGroupMode", 1221 _ => "Unknown", 1222 } 1223 ) 1224 } 1225 } 1226 1227 #[doc(hidden)] 1228 impl ToGlib for EventType { 1229 type GlibType = gdk_sys::GdkEventType; 1230 to_glib(&self) -> gdk_sys::GdkEventType1231 fn to_glib(&self) -> gdk_sys::GdkEventType { 1232 match *self { 1233 EventType::Nothing => gdk_sys::GDK_NOTHING, 1234 EventType::Delete => gdk_sys::GDK_DELETE, 1235 EventType::Destroy => gdk_sys::GDK_DESTROY, 1236 EventType::Expose => gdk_sys::GDK_EXPOSE, 1237 EventType::MotionNotify => gdk_sys::GDK_MOTION_NOTIFY, 1238 EventType::ButtonPress => gdk_sys::GDK_BUTTON_PRESS, 1239 EventType::DoubleButtonPress => gdk_sys::GDK_DOUBLE_BUTTON_PRESS, 1240 EventType::TripleButtonPress => gdk_sys::GDK_TRIPLE_BUTTON_PRESS, 1241 EventType::ButtonRelease => gdk_sys::GDK_BUTTON_RELEASE, 1242 EventType::KeyPress => gdk_sys::GDK_KEY_PRESS, 1243 EventType::KeyRelease => gdk_sys::GDK_KEY_RELEASE, 1244 EventType::EnterNotify => gdk_sys::GDK_ENTER_NOTIFY, 1245 EventType::LeaveNotify => gdk_sys::GDK_LEAVE_NOTIFY, 1246 EventType::FocusChange => gdk_sys::GDK_FOCUS_CHANGE, 1247 EventType::Configure => gdk_sys::GDK_CONFIGURE, 1248 EventType::Map => gdk_sys::GDK_MAP, 1249 EventType::Unmap => gdk_sys::GDK_UNMAP, 1250 EventType::PropertyNotify => gdk_sys::GDK_PROPERTY_NOTIFY, 1251 EventType::SelectionClear => gdk_sys::GDK_SELECTION_CLEAR, 1252 EventType::SelectionRequest => gdk_sys::GDK_SELECTION_REQUEST, 1253 EventType::SelectionNotify => gdk_sys::GDK_SELECTION_NOTIFY, 1254 EventType::ProximityIn => gdk_sys::GDK_PROXIMITY_IN, 1255 EventType::ProximityOut => gdk_sys::GDK_PROXIMITY_OUT, 1256 EventType::DragEnter => gdk_sys::GDK_DRAG_ENTER, 1257 EventType::DragLeave => gdk_sys::GDK_DRAG_LEAVE, 1258 EventType::DragMotion => gdk_sys::GDK_DRAG_MOTION, 1259 EventType::DragStatus => gdk_sys::GDK_DRAG_STATUS, 1260 EventType::DropStart => gdk_sys::GDK_DROP_START, 1261 EventType::DropFinished => gdk_sys::GDK_DROP_FINISHED, 1262 EventType::ClientEvent => gdk_sys::GDK_CLIENT_EVENT, 1263 EventType::VisibilityNotify => gdk_sys::GDK_VISIBILITY_NOTIFY, 1264 EventType::Scroll => gdk_sys::GDK_SCROLL, 1265 EventType::WindowState => gdk_sys::GDK_WINDOW_STATE, 1266 EventType::Setting => gdk_sys::GDK_SETTING, 1267 EventType::OwnerChange => gdk_sys::GDK_OWNER_CHANGE, 1268 EventType::GrabBroken => gdk_sys::GDK_GRAB_BROKEN, 1269 EventType::Damage => gdk_sys::GDK_DAMAGE, 1270 EventType::TouchBegin => gdk_sys::GDK_TOUCH_BEGIN, 1271 EventType::TouchUpdate => gdk_sys::GDK_TOUCH_UPDATE, 1272 EventType::TouchEnd => gdk_sys::GDK_TOUCH_END, 1273 EventType::TouchCancel => gdk_sys::GDK_TOUCH_CANCEL, 1274 #[cfg(any(feature = "v3_18", feature = "dox"))] 1275 EventType::TouchpadSwipe => gdk_sys::GDK_TOUCHPAD_SWIPE, 1276 #[cfg(any(feature = "v3_18", feature = "dox"))] 1277 EventType::TouchpadPinch => gdk_sys::GDK_TOUCHPAD_PINCH, 1278 EventType::PadButtonPress => gdk_sys::GDK_PAD_BUTTON_PRESS, 1279 EventType::PadButtonRelease => gdk_sys::GDK_PAD_BUTTON_RELEASE, 1280 EventType::PadRing => gdk_sys::GDK_PAD_RING, 1281 EventType::PadStrip => gdk_sys::GDK_PAD_STRIP, 1282 EventType::PadGroupMode => gdk_sys::GDK_PAD_GROUP_MODE, 1283 EventType::__Unknown(value) => value, 1284 } 1285 } 1286 } 1287 1288 #[doc(hidden)] 1289 impl FromGlib<gdk_sys::GdkEventType> for EventType { from_glib(value: gdk_sys::GdkEventType) -> Self1290 fn from_glib(value: gdk_sys::GdkEventType) -> Self { 1291 skip_assert_initialized!(); 1292 match value { 1293 -1 => EventType::Nothing, 1294 0 => EventType::Delete, 1295 1 => EventType::Destroy, 1296 2 => EventType::Expose, 1297 3 => EventType::MotionNotify, 1298 4 => EventType::ButtonPress, 1299 5 => EventType::DoubleButtonPress, 1300 6 => EventType::TripleButtonPress, 1301 7 => EventType::ButtonRelease, 1302 8 => EventType::KeyPress, 1303 9 => EventType::KeyRelease, 1304 10 => EventType::EnterNotify, 1305 11 => EventType::LeaveNotify, 1306 12 => EventType::FocusChange, 1307 13 => EventType::Configure, 1308 14 => EventType::Map, 1309 15 => EventType::Unmap, 1310 16 => EventType::PropertyNotify, 1311 17 => EventType::SelectionClear, 1312 18 => EventType::SelectionRequest, 1313 19 => EventType::SelectionNotify, 1314 20 => EventType::ProximityIn, 1315 21 => EventType::ProximityOut, 1316 22 => EventType::DragEnter, 1317 23 => EventType::DragLeave, 1318 24 => EventType::DragMotion, 1319 25 => EventType::DragStatus, 1320 26 => EventType::DropStart, 1321 27 => EventType::DropFinished, 1322 28 => EventType::ClientEvent, 1323 29 => EventType::VisibilityNotify, 1324 31 => EventType::Scroll, 1325 32 => EventType::WindowState, 1326 33 => EventType::Setting, 1327 34 => EventType::OwnerChange, 1328 35 => EventType::GrabBroken, 1329 36 => EventType::Damage, 1330 37 => EventType::TouchBegin, 1331 38 => EventType::TouchUpdate, 1332 39 => EventType::TouchEnd, 1333 40 => EventType::TouchCancel, 1334 #[cfg(any(feature = "v3_18", feature = "dox"))] 1335 41 => EventType::TouchpadSwipe, 1336 #[cfg(any(feature = "v3_18", feature = "dox"))] 1337 42 => EventType::TouchpadPinch, 1338 43 => EventType::PadButtonPress, 1339 44 => EventType::PadButtonRelease, 1340 45 => EventType::PadRing, 1341 46 => EventType::PadStrip, 1342 47 => EventType::PadGroupMode, 1343 value => EventType::__Unknown(value), 1344 } 1345 } 1346 } 1347 1348 impl StaticType for EventType { static_type() -> Type1349 fn static_type() -> Type { 1350 unsafe { from_glib(gdk_sys::gdk_event_type_get_type()) } 1351 } 1352 } 1353 1354 impl<'a> FromValueOptional<'a> for EventType { from_value_optional(value: &Value) -> Option<Self>1355 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1356 Some(FromValue::from_value(value)) 1357 } 1358 } 1359 1360 impl<'a> FromValue<'a> for EventType { from_value(value: &Value) -> Self1361 unsafe fn from_value(value: &Value) -> Self { 1362 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1363 } 1364 } 1365 1366 impl SetValue for EventType { set_value(value: &mut Value, this: &Self)1367 unsafe fn set_value(value: &mut Value, this: &Self) { 1368 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1369 } 1370 } 1371 1372 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1373 pub enum FullscreenMode { 1374 CurrentMonitor, 1375 AllMonitors, 1376 #[doc(hidden)] 1377 __Unknown(i32), 1378 } 1379 1380 impl fmt::Display for FullscreenMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1381 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1382 write!( 1383 f, 1384 "FullscreenMode::{}", 1385 match *self { 1386 FullscreenMode::CurrentMonitor => "CurrentMonitor", 1387 FullscreenMode::AllMonitors => "AllMonitors", 1388 _ => "Unknown", 1389 } 1390 ) 1391 } 1392 } 1393 1394 #[doc(hidden)] 1395 impl ToGlib for FullscreenMode { 1396 type GlibType = gdk_sys::GdkFullscreenMode; 1397 to_glib(&self) -> gdk_sys::GdkFullscreenMode1398 fn to_glib(&self) -> gdk_sys::GdkFullscreenMode { 1399 match *self { 1400 FullscreenMode::CurrentMonitor => gdk_sys::GDK_FULLSCREEN_ON_CURRENT_MONITOR, 1401 FullscreenMode::AllMonitors => gdk_sys::GDK_FULLSCREEN_ON_ALL_MONITORS, 1402 FullscreenMode::__Unknown(value) => value, 1403 } 1404 } 1405 } 1406 1407 #[doc(hidden)] 1408 impl FromGlib<gdk_sys::GdkFullscreenMode> for FullscreenMode { from_glib(value: gdk_sys::GdkFullscreenMode) -> Self1409 fn from_glib(value: gdk_sys::GdkFullscreenMode) -> Self { 1410 skip_assert_initialized!(); 1411 match value { 1412 0 => FullscreenMode::CurrentMonitor, 1413 1 => FullscreenMode::AllMonitors, 1414 value => FullscreenMode::__Unknown(value), 1415 } 1416 } 1417 } 1418 1419 impl StaticType for FullscreenMode { static_type() -> Type1420 fn static_type() -> Type { 1421 unsafe { from_glib(gdk_sys::gdk_fullscreen_mode_get_type()) } 1422 } 1423 } 1424 1425 impl<'a> FromValueOptional<'a> for FullscreenMode { from_value_optional(value: &Value) -> Option<Self>1426 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1427 Some(FromValue::from_value(value)) 1428 } 1429 } 1430 1431 impl<'a> FromValue<'a> for FullscreenMode { from_value(value: &Value) -> Self1432 unsafe fn from_value(value: &Value) -> Self { 1433 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1434 } 1435 } 1436 1437 impl SetValue for FullscreenMode { set_value(value: &mut Value, this: &Self)1438 unsafe fn set_value(value: &mut Value, this: &Self) { 1439 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1440 } 1441 } 1442 1443 #[cfg(any(feature = "v3_16", feature = "dox"))] 1444 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1445 pub enum GLError { 1446 NotAvailable, 1447 UnsupportedFormat, 1448 UnsupportedProfile, 1449 #[doc(hidden)] 1450 __Unknown(i32), 1451 } 1452 1453 #[cfg(any(feature = "v3_16", feature = "dox"))] 1454 impl fmt::Display for GLError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1455 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1456 write!( 1457 f, 1458 "GLError::{}", 1459 match *self { 1460 GLError::NotAvailable => "NotAvailable", 1461 GLError::UnsupportedFormat => "UnsupportedFormat", 1462 GLError::UnsupportedProfile => "UnsupportedProfile", 1463 _ => "Unknown", 1464 } 1465 ) 1466 } 1467 } 1468 1469 #[cfg(any(feature = "v3_16", feature = "dox"))] 1470 #[doc(hidden)] 1471 impl ToGlib for GLError { 1472 type GlibType = gdk_sys::GdkGLError; 1473 to_glib(&self) -> gdk_sys::GdkGLError1474 fn to_glib(&self) -> gdk_sys::GdkGLError { 1475 match *self { 1476 GLError::NotAvailable => gdk_sys::GDK_GL_ERROR_NOT_AVAILABLE, 1477 GLError::UnsupportedFormat => gdk_sys::GDK_GL_ERROR_UNSUPPORTED_FORMAT, 1478 GLError::UnsupportedProfile => gdk_sys::GDK_GL_ERROR_UNSUPPORTED_PROFILE, 1479 GLError::__Unknown(value) => value, 1480 } 1481 } 1482 } 1483 1484 #[cfg(any(feature = "v3_16", feature = "dox"))] 1485 #[doc(hidden)] 1486 impl FromGlib<gdk_sys::GdkGLError> for GLError { from_glib(value: gdk_sys::GdkGLError) -> Self1487 fn from_glib(value: gdk_sys::GdkGLError) -> Self { 1488 skip_assert_initialized!(); 1489 match value { 1490 0 => GLError::NotAvailable, 1491 1 => GLError::UnsupportedFormat, 1492 2 => GLError::UnsupportedProfile, 1493 value => GLError::__Unknown(value), 1494 } 1495 } 1496 } 1497 1498 #[cfg(any(feature = "v3_16", feature = "dox"))] 1499 impl ErrorDomain for GLError { domain() -> Quark1500 fn domain() -> Quark { 1501 skip_assert_initialized!(); 1502 unsafe { from_glib(gdk_sys::gdk_gl_error_quark()) } 1503 } 1504 code(self) -> i321505 fn code(self) -> i32 { 1506 self.to_glib() 1507 } 1508 from(code: i32) -> Option<Self>1509 fn from(code: i32) -> Option<Self> { 1510 skip_assert_initialized!(); 1511 match code { 1512 0 => Some(GLError::NotAvailable), 1513 1 => Some(GLError::UnsupportedFormat), 1514 2 => Some(GLError::UnsupportedProfile), 1515 value => Some(GLError::__Unknown(value)), 1516 } 1517 } 1518 } 1519 1520 #[cfg(any(feature = "v3_16", feature = "dox"))] 1521 impl StaticType for GLError { static_type() -> Type1522 fn static_type() -> Type { 1523 unsafe { from_glib(gdk_sys::gdk_gl_error_get_type()) } 1524 } 1525 } 1526 1527 #[cfg(any(feature = "v3_16", feature = "dox"))] 1528 impl<'a> FromValueOptional<'a> for GLError { from_value_optional(value: &Value) -> Option<Self>1529 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1530 Some(FromValue::from_value(value)) 1531 } 1532 } 1533 1534 #[cfg(any(feature = "v3_16", feature = "dox"))] 1535 impl<'a> FromValue<'a> for GLError { from_value(value: &Value) -> Self1536 unsafe fn from_value(value: &Value) -> Self { 1537 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1538 } 1539 } 1540 1541 #[cfg(any(feature = "v3_16", feature = "dox"))] 1542 impl SetValue for GLError { set_value(value: &mut Value, this: &Self)1543 unsafe fn set_value(value: &mut Value, this: &Self) { 1544 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1545 } 1546 } 1547 1548 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1549 pub enum GrabOwnership { 1550 None, 1551 Window, 1552 Application, 1553 #[doc(hidden)] 1554 __Unknown(i32), 1555 } 1556 1557 impl fmt::Display for GrabOwnership { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1558 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1559 write!( 1560 f, 1561 "GrabOwnership::{}", 1562 match *self { 1563 GrabOwnership::None => "None", 1564 GrabOwnership::Window => "Window", 1565 GrabOwnership::Application => "Application", 1566 _ => "Unknown", 1567 } 1568 ) 1569 } 1570 } 1571 1572 #[doc(hidden)] 1573 impl ToGlib for GrabOwnership { 1574 type GlibType = gdk_sys::GdkGrabOwnership; 1575 to_glib(&self) -> gdk_sys::GdkGrabOwnership1576 fn to_glib(&self) -> gdk_sys::GdkGrabOwnership { 1577 match *self { 1578 GrabOwnership::None => gdk_sys::GDK_OWNERSHIP_NONE, 1579 GrabOwnership::Window => gdk_sys::GDK_OWNERSHIP_WINDOW, 1580 GrabOwnership::Application => gdk_sys::GDK_OWNERSHIP_APPLICATION, 1581 GrabOwnership::__Unknown(value) => value, 1582 } 1583 } 1584 } 1585 1586 #[doc(hidden)] 1587 impl FromGlib<gdk_sys::GdkGrabOwnership> for GrabOwnership { from_glib(value: gdk_sys::GdkGrabOwnership) -> Self1588 fn from_glib(value: gdk_sys::GdkGrabOwnership) -> Self { 1589 skip_assert_initialized!(); 1590 match value { 1591 0 => GrabOwnership::None, 1592 1 => GrabOwnership::Window, 1593 2 => GrabOwnership::Application, 1594 value => GrabOwnership::__Unknown(value), 1595 } 1596 } 1597 } 1598 1599 impl StaticType for GrabOwnership { static_type() -> Type1600 fn static_type() -> Type { 1601 unsafe { from_glib(gdk_sys::gdk_grab_ownership_get_type()) } 1602 } 1603 } 1604 1605 impl<'a> FromValueOptional<'a> for GrabOwnership { from_value_optional(value: &Value) -> Option<Self>1606 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1607 Some(FromValue::from_value(value)) 1608 } 1609 } 1610 1611 impl<'a> FromValue<'a> for GrabOwnership { from_value(value: &Value) -> Self1612 unsafe fn from_value(value: &Value) -> Self { 1613 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1614 } 1615 } 1616 1617 impl SetValue for GrabOwnership { set_value(value: &mut Value, this: &Self)1618 unsafe fn set_value(value: &mut Value, this: &Self) { 1619 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1620 } 1621 } 1622 1623 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1624 pub enum GrabStatus { 1625 Success, 1626 AlreadyGrabbed, 1627 InvalidTime, 1628 NotViewable, 1629 Frozen, 1630 Failed, 1631 #[doc(hidden)] 1632 __Unknown(i32), 1633 } 1634 1635 impl fmt::Display for GrabStatus { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1636 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1637 write!( 1638 f, 1639 "GrabStatus::{}", 1640 match *self { 1641 GrabStatus::Success => "Success", 1642 GrabStatus::AlreadyGrabbed => "AlreadyGrabbed", 1643 GrabStatus::InvalidTime => "InvalidTime", 1644 GrabStatus::NotViewable => "NotViewable", 1645 GrabStatus::Frozen => "Frozen", 1646 GrabStatus::Failed => "Failed", 1647 _ => "Unknown", 1648 } 1649 ) 1650 } 1651 } 1652 1653 #[doc(hidden)] 1654 impl ToGlib for GrabStatus { 1655 type GlibType = gdk_sys::GdkGrabStatus; 1656 to_glib(&self) -> gdk_sys::GdkGrabStatus1657 fn to_glib(&self) -> gdk_sys::GdkGrabStatus { 1658 match *self { 1659 GrabStatus::Success => gdk_sys::GDK_GRAB_SUCCESS, 1660 GrabStatus::AlreadyGrabbed => gdk_sys::GDK_GRAB_ALREADY_GRABBED, 1661 GrabStatus::InvalidTime => gdk_sys::GDK_GRAB_INVALID_TIME, 1662 GrabStatus::NotViewable => gdk_sys::GDK_GRAB_NOT_VIEWABLE, 1663 GrabStatus::Frozen => gdk_sys::GDK_GRAB_FROZEN, 1664 GrabStatus::Failed => gdk_sys::GDK_GRAB_FAILED, 1665 GrabStatus::__Unknown(value) => value, 1666 } 1667 } 1668 } 1669 1670 #[doc(hidden)] 1671 impl FromGlib<gdk_sys::GdkGrabStatus> for GrabStatus { from_glib(value: gdk_sys::GdkGrabStatus) -> Self1672 fn from_glib(value: gdk_sys::GdkGrabStatus) -> Self { 1673 skip_assert_initialized!(); 1674 match value { 1675 0 => GrabStatus::Success, 1676 1 => GrabStatus::AlreadyGrabbed, 1677 2 => GrabStatus::InvalidTime, 1678 3 => GrabStatus::NotViewable, 1679 4 => GrabStatus::Frozen, 1680 5 => GrabStatus::Failed, 1681 value => GrabStatus::__Unknown(value), 1682 } 1683 } 1684 } 1685 1686 impl StaticType for GrabStatus { static_type() -> Type1687 fn static_type() -> Type { 1688 unsafe { from_glib(gdk_sys::gdk_grab_status_get_type()) } 1689 } 1690 } 1691 1692 impl<'a> FromValueOptional<'a> for GrabStatus { from_value_optional(value: &Value) -> Option<Self>1693 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1694 Some(FromValue::from_value(value)) 1695 } 1696 } 1697 1698 impl<'a> FromValue<'a> for GrabStatus { from_value(value: &Value) -> Self1699 unsafe fn from_value(value: &Value) -> Self { 1700 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1701 } 1702 } 1703 1704 impl SetValue for GrabStatus { set_value(value: &mut Value, this: &Self)1705 unsafe fn set_value(value: &mut Value, this: &Self) { 1706 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1707 } 1708 } 1709 1710 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1711 pub enum Gravity { 1712 NorthWest, 1713 North, 1714 NorthEast, 1715 West, 1716 Center, 1717 East, 1718 SouthWest, 1719 South, 1720 SouthEast, 1721 Static, 1722 #[doc(hidden)] 1723 __Unknown(i32), 1724 } 1725 1726 impl fmt::Display for Gravity { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1727 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1728 write!( 1729 f, 1730 "Gravity::{}", 1731 match *self { 1732 Gravity::NorthWest => "NorthWest", 1733 Gravity::North => "North", 1734 Gravity::NorthEast => "NorthEast", 1735 Gravity::West => "West", 1736 Gravity::Center => "Center", 1737 Gravity::East => "East", 1738 Gravity::SouthWest => "SouthWest", 1739 Gravity::South => "South", 1740 Gravity::SouthEast => "SouthEast", 1741 Gravity::Static => "Static", 1742 _ => "Unknown", 1743 } 1744 ) 1745 } 1746 } 1747 1748 #[doc(hidden)] 1749 impl ToGlib for Gravity { 1750 type GlibType = gdk_sys::GdkGravity; 1751 to_glib(&self) -> gdk_sys::GdkGravity1752 fn to_glib(&self) -> gdk_sys::GdkGravity { 1753 match *self { 1754 Gravity::NorthWest => gdk_sys::GDK_GRAVITY_NORTH_WEST, 1755 Gravity::North => gdk_sys::GDK_GRAVITY_NORTH, 1756 Gravity::NorthEast => gdk_sys::GDK_GRAVITY_NORTH_EAST, 1757 Gravity::West => gdk_sys::GDK_GRAVITY_WEST, 1758 Gravity::Center => gdk_sys::GDK_GRAVITY_CENTER, 1759 Gravity::East => gdk_sys::GDK_GRAVITY_EAST, 1760 Gravity::SouthWest => gdk_sys::GDK_GRAVITY_SOUTH_WEST, 1761 Gravity::South => gdk_sys::GDK_GRAVITY_SOUTH, 1762 Gravity::SouthEast => gdk_sys::GDK_GRAVITY_SOUTH_EAST, 1763 Gravity::Static => gdk_sys::GDK_GRAVITY_STATIC, 1764 Gravity::__Unknown(value) => value, 1765 } 1766 } 1767 } 1768 1769 #[doc(hidden)] 1770 impl FromGlib<gdk_sys::GdkGravity> for Gravity { from_glib(value: gdk_sys::GdkGravity) -> Self1771 fn from_glib(value: gdk_sys::GdkGravity) -> Self { 1772 skip_assert_initialized!(); 1773 match value { 1774 1 => Gravity::NorthWest, 1775 2 => Gravity::North, 1776 3 => Gravity::NorthEast, 1777 4 => Gravity::West, 1778 5 => Gravity::Center, 1779 6 => Gravity::East, 1780 7 => Gravity::SouthWest, 1781 8 => Gravity::South, 1782 9 => Gravity::SouthEast, 1783 10 => Gravity::Static, 1784 value => Gravity::__Unknown(value), 1785 } 1786 } 1787 } 1788 1789 impl StaticType for Gravity { static_type() -> Type1790 fn static_type() -> Type { 1791 unsafe { from_glib(gdk_sys::gdk_gravity_get_type()) } 1792 } 1793 } 1794 1795 impl<'a> FromValueOptional<'a> for Gravity { from_value_optional(value: &Value) -> Option<Self>1796 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1797 Some(FromValue::from_value(value)) 1798 } 1799 } 1800 1801 impl<'a> FromValue<'a> for Gravity { from_value(value: &Value) -> Self1802 unsafe fn from_value(value: &Value) -> Self { 1803 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1804 } 1805 } 1806 1807 impl SetValue for Gravity { set_value(value: &mut Value, this: &Self)1808 unsafe fn set_value(value: &mut Value, this: &Self) { 1809 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1810 } 1811 } 1812 1813 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1814 pub enum InputMode { 1815 Disabled, 1816 Screen, 1817 Window, 1818 #[doc(hidden)] 1819 __Unknown(i32), 1820 } 1821 1822 impl fmt::Display for InputMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1823 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1824 write!( 1825 f, 1826 "InputMode::{}", 1827 match *self { 1828 InputMode::Disabled => "Disabled", 1829 InputMode::Screen => "Screen", 1830 InputMode::Window => "Window", 1831 _ => "Unknown", 1832 } 1833 ) 1834 } 1835 } 1836 1837 #[doc(hidden)] 1838 impl ToGlib for InputMode { 1839 type GlibType = gdk_sys::GdkInputMode; 1840 to_glib(&self) -> gdk_sys::GdkInputMode1841 fn to_glib(&self) -> gdk_sys::GdkInputMode { 1842 match *self { 1843 InputMode::Disabled => gdk_sys::GDK_MODE_DISABLED, 1844 InputMode::Screen => gdk_sys::GDK_MODE_SCREEN, 1845 InputMode::Window => gdk_sys::GDK_MODE_WINDOW, 1846 InputMode::__Unknown(value) => value, 1847 } 1848 } 1849 } 1850 1851 #[doc(hidden)] 1852 impl FromGlib<gdk_sys::GdkInputMode> for InputMode { from_glib(value: gdk_sys::GdkInputMode) -> Self1853 fn from_glib(value: gdk_sys::GdkInputMode) -> Self { 1854 skip_assert_initialized!(); 1855 match value { 1856 0 => InputMode::Disabled, 1857 1 => InputMode::Screen, 1858 2 => InputMode::Window, 1859 value => InputMode::__Unknown(value), 1860 } 1861 } 1862 } 1863 1864 impl StaticType for InputMode { static_type() -> Type1865 fn static_type() -> Type { 1866 unsafe { from_glib(gdk_sys::gdk_input_mode_get_type()) } 1867 } 1868 } 1869 1870 impl<'a> FromValueOptional<'a> for InputMode { from_value_optional(value: &Value) -> Option<Self>1871 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1872 Some(FromValue::from_value(value)) 1873 } 1874 } 1875 1876 impl<'a> FromValue<'a> for InputMode { from_value(value: &Value) -> Self1877 unsafe fn from_value(value: &Value) -> Self { 1878 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1879 } 1880 } 1881 1882 impl SetValue for InputMode { set_value(value: &mut Value, this: &Self)1883 unsafe fn set_value(value: &mut Value, this: &Self) { 1884 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1885 } 1886 } 1887 1888 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1889 pub enum InputSource { 1890 Mouse, 1891 Pen, 1892 Eraser, 1893 Cursor, 1894 Keyboard, 1895 Touchscreen, 1896 Touchpad, 1897 Trackpoint, 1898 TabletPad, 1899 #[doc(hidden)] 1900 __Unknown(i32), 1901 } 1902 1903 impl fmt::Display for InputSource { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1904 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1905 write!( 1906 f, 1907 "InputSource::{}", 1908 match *self { 1909 InputSource::Mouse => "Mouse", 1910 InputSource::Pen => "Pen", 1911 InputSource::Eraser => "Eraser", 1912 InputSource::Cursor => "Cursor", 1913 InputSource::Keyboard => "Keyboard", 1914 InputSource::Touchscreen => "Touchscreen", 1915 InputSource::Touchpad => "Touchpad", 1916 InputSource::Trackpoint => "Trackpoint", 1917 InputSource::TabletPad => "TabletPad", 1918 _ => "Unknown", 1919 } 1920 ) 1921 } 1922 } 1923 1924 #[doc(hidden)] 1925 impl ToGlib for InputSource { 1926 type GlibType = gdk_sys::GdkInputSource; 1927 to_glib(&self) -> gdk_sys::GdkInputSource1928 fn to_glib(&self) -> gdk_sys::GdkInputSource { 1929 match *self { 1930 InputSource::Mouse => gdk_sys::GDK_SOURCE_MOUSE, 1931 InputSource::Pen => gdk_sys::GDK_SOURCE_PEN, 1932 InputSource::Eraser => gdk_sys::GDK_SOURCE_ERASER, 1933 InputSource::Cursor => gdk_sys::GDK_SOURCE_CURSOR, 1934 InputSource::Keyboard => gdk_sys::GDK_SOURCE_KEYBOARD, 1935 InputSource::Touchscreen => gdk_sys::GDK_SOURCE_TOUCHSCREEN, 1936 InputSource::Touchpad => gdk_sys::GDK_SOURCE_TOUCHPAD, 1937 InputSource::Trackpoint => gdk_sys::GDK_SOURCE_TRACKPOINT, 1938 InputSource::TabletPad => gdk_sys::GDK_SOURCE_TABLET_PAD, 1939 InputSource::__Unknown(value) => value, 1940 } 1941 } 1942 } 1943 1944 #[doc(hidden)] 1945 impl FromGlib<gdk_sys::GdkInputSource> for InputSource { from_glib(value: gdk_sys::GdkInputSource) -> Self1946 fn from_glib(value: gdk_sys::GdkInputSource) -> Self { 1947 skip_assert_initialized!(); 1948 match value { 1949 0 => InputSource::Mouse, 1950 1 => InputSource::Pen, 1951 2 => InputSource::Eraser, 1952 3 => InputSource::Cursor, 1953 4 => InputSource::Keyboard, 1954 5 => InputSource::Touchscreen, 1955 6 => InputSource::Touchpad, 1956 7 => InputSource::Trackpoint, 1957 8 => InputSource::TabletPad, 1958 value => InputSource::__Unknown(value), 1959 } 1960 } 1961 } 1962 1963 impl StaticType for InputSource { static_type() -> Type1964 fn static_type() -> Type { 1965 unsafe { from_glib(gdk_sys::gdk_input_source_get_type()) } 1966 } 1967 } 1968 1969 impl<'a> FromValueOptional<'a> for InputSource { from_value_optional(value: &Value) -> Option<Self>1970 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1971 Some(FromValue::from_value(value)) 1972 } 1973 } 1974 1975 impl<'a> FromValue<'a> for InputSource { from_value(value: &Value) -> Self1976 unsafe fn from_value(value: &Value) -> Self { 1977 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1978 } 1979 } 1980 1981 impl SetValue for InputSource { set_value(value: &mut Value, this: &Self)1982 unsafe fn set_value(value: &mut Value, this: &Self) { 1983 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1984 } 1985 } 1986 1987 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1988 pub enum ModifierIntent { 1989 PrimaryAccelerator, 1990 ContextMenu, 1991 ExtendSelection, 1992 ModifySelection, 1993 NoTextInput, 1994 ShiftGroup, 1995 DefaultModMask, 1996 #[doc(hidden)] 1997 __Unknown(i32), 1998 } 1999 2000 impl fmt::Display for ModifierIntent { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2001 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2002 write!( 2003 f, 2004 "ModifierIntent::{}", 2005 match *self { 2006 ModifierIntent::PrimaryAccelerator => "PrimaryAccelerator", 2007 ModifierIntent::ContextMenu => "ContextMenu", 2008 ModifierIntent::ExtendSelection => "ExtendSelection", 2009 ModifierIntent::ModifySelection => "ModifySelection", 2010 ModifierIntent::NoTextInput => "NoTextInput", 2011 ModifierIntent::ShiftGroup => "ShiftGroup", 2012 ModifierIntent::DefaultModMask => "DefaultModMask", 2013 _ => "Unknown", 2014 } 2015 ) 2016 } 2017 } 2018 2019 #[doc(hidden)] 2020 impl ToGlib for ModifierIntent { 2021 type GlibType = gdk_sys::GdkModifierIntent; 2022 to_glib(&self) -> gdk_sys::GdkModifierIntent2023 fn to_glib(&self) -> gdk_sys::GdkModifierIntent { 2024 match *self { 2025 ModifierIntent::PrimaryAccelerator => gdk_sys::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR, 2026 ModifierIntent::ContextMenu => gdk_sys::GDK_MODIFIER_INTENT_CONTEXT_MENU, 2027 ModifierIntent::ExtendSelection => gdk_sys::GDK_MODIFIER_INTENT_EXTEND_SELECTION, 2028 ModifierIntent::ModifySelection => gdk_sys::GDK_MODIFIER_INTENT_MODIFY_SELECTION, 2029 ModifierIntent::NoTextInput => gdk_sys::GDK_MODIFIER_INTENT_NO_TEXT_INPUT, 2030 ModifierIntent::ShiftGroup => gdk_sys::GDK_MODIFIER_INTENT_SHIFT_GROUP, 2031 ModifierIntent::DefaultModMask => gdk_sys::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK, 2032 ModifierIntent::__Unknown(value) => value, 2033 } 2034 } 2035 } 2036 2037 #[doc(hidden)] 2038 impl FromGlib<gdk_sys::GdkModifierIntent> for ModifierIntent { from_glib(value: gdk_sys::GdkModifierIntent) -> Self2039 fn from_glib(value: gdk_sys::GdkModifierIntent) -> Self { 2040 skip_assert_initialized!(); 2041 match value { 2042 0 => ModifierIntent::PrimaryAccelerator, 2043 1 => ModifierIntent::ContextMenu, 2044 2 => ModifierIntent::ExtendSelection, 2045 3 => ModifierIntent::ModifySelection, 2046 4 => ModifierIntent::NoTextInput, 2047 5 => ModifierIntent::ShiftGroup, 2048 6 => ModifierIntent::DefaultModMask, 2049 value => ModifierIntent::__Unknown(value), 2050 } 2051 } 2052 } 2053 2054 impl StaticType for ModifierIntent { static_type() -> Type2055 fn static_type() -> Type { 2056 unsafe { from_glib(gdk_sys::gdk_modifier_intent_get_type()) } 2057 } 2058 } 2059 2060 impl<'a> FromValueOptional<'a> for ModifierIntent { from_value_optional(value: &Value) -> Option<Self>2061 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2062 Some(FromValue::from_value(value)) 2063 } 2064 } 2065 2066 impl<'a> FromValue<'a> for ModifierIntent { from_value(value: &Value) -> Self2067 unsafe fn from_value(value: &Value) -> Self { 2068 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2069 } 2070 } 2071 2072 impl SetValue for ModifierIntent { set_value(value: &mut Value, this: &Self)2073 unsafe fn set_value(value: &mut Value, this: &Self) { 2074 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2075 } 2076 } 2077 2078 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2079 pub enum NotifyType { 2080 Ancestor, 2081 Virtual, 2082 Inferior, 2083 Nonlinear, 2084 NonlinearVirtual, 2085 Unknown, 2086 #[doc(hidden)] 2087 __Unknown(i32), 2088 } 2089 2090 impl fmt::Display for NotifyType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2091 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2092 write!( 2093 f, 2094 "NotifyType::{}", 2095 match *self { 2096 NotifyType::Ancestor => "Ancestor", 2097 NotifyType::Virtual => "Virtual", 2098 NotifyType::Inferior => "Inferior", 2099 NotifyType::Nonlinear => "Nonlinear", 2100 NotifyType::NonlinearVirtual => "NonlinearVirtual", 2101 NotifyType::Unknown => "Unknown", 2102 _ => "Unknown", 2103 } 2104 ) 2105 } 2106 } 2107 2108 #[doc(hidden)] 2109 impl ToGlib for NotifyType { 2110 type GlibType = gdk_sys::GdkNotifyType; 2111 to_glib(&self) -> gdk_sys::GdkNotifyType2112 fn to_glib(&self) -> gdk_sys::GdkNotifyType { 2113 match *self { 2114 NotifyType::Ancestor => gdk_sys::GDK_NOTIFY_ANCESTOR, 2115 NotifyType::Virtual => gdk_sys::GDK_NOTIFY_VIRTUAL, 2116 NotifyType::Inferior => gdk_sys::GDK_NOTIFY_INFERIOR, 2117 NotifyType::Nonlinear => gdk_sys::GDK_NOTIFY_NONLINEAR, 2118 NotifyType::NonlinearVirtual => gdk_sys::GDK_NOTIFY_NONLINEAR_VIRTUAL, 2119 NotifyType::Unknown => gdk_sys::GDK_NOTIFY_UNKNOWN, 2120 NotifyType::__Unknown(value) => value, 2121 } 2122 } 2123 } 2124 2125 #[doc(hidden)] 2126 impl FromGlib<gdk_sys::GdkNotifyType> for NotifyType { from_glib(value: gdk_sys::GdkNotifyType) -> Self2127 fn from_glib(value: gdk_sys::GdkNotifyType) -> Self { 2128 skip_assert_initialized!(); 2129 match value { 2130 0 => NotifyType::Ancestor, 2131 1 => NotifyType::Virtual, 2132 2 => NotifyType::Inferior, 2133 3 => NotifyType::Nonlinear, 2134 4 => NotifyType::NonlinearVirtual, 2135 5 => NotifyType::Unknown, 2136 value => NotifyType::__Unknown(value), 2137 } 2138 } 2139 } 2140 2141 impl StaticType for NotifyType { static_type() -> Type2142 fn static_type() -> Type { 2143 unsafe { from_glib(gdk_sys::gdk_notify_type_get_type()) } 2144 } 2145 } 2146 2147 impl<'a> FromValueOptional<'a> for NotifyType { from_value_optional(value: &Value) -> Option<Self>2148 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2149 Some(FromValue::from_value(value)) 2150 } 2151 } 2152 2153 impl<'a> FromValue<'a> for NotifyType { from_value(value: &Value) -> Self2154 unsafe fn from_value(value: &Value) -> Self { 2155 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2156 } 2157 } 2158 2159 impl SetValue for NotifyType { set_value(value: &mut Value, this: &Self)2160 unsafe fn set_value(value: &mut Value, this: &Self) { 2161 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2162 } 2163 } 2164 2165 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2166 pub enum OwnerChange { 2167 NewOwner, 2168 Destroy, 2169 Close, 2170 #[doc(hidden)] 2171 __Unknown(i32), 2172 } 2173 2174 impl fmt::Display for OwnerChange { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2175 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2176 write!( 2177 f, 2178 "OwnerChange::{}", 2179 match *self { 2180 OwnerChange::NewOwner => "NewOwner", 2181 OwnerChange::Destroy => "Destroy", 2182 OwnerChange::Close => "Close", 2183 _ => "Unknown", 2184 } 2185 ) 2186 } 2187 } 2188 2189 #[doc(hidden)] 2190 impl ToGlib for OwnerChange { 2191 type GlibType = gdk_sys::GdkOwnerChange; 2192 to_glib(&self) -> gdk_sys::GdkOwnerChange2193 fn to_glib(&self) -> gdk_sys::GdkOwnerChange { 2194 match *self { 2195 OwnerChange::NewOwner => gdk_sys::GDK_OWNER_CHANGE_NEW_OWNER, 2196 OwnerChange::Destroy => gdk_sys::GDK_OWNER_CHANGE_DESTROY, 2197 OwnerChange::Close => gdk_sys::GDK_OWNER_CHANGE_CLOSE, 2198 OwnerChange::__Unknown(value) => value, 2199 } 2200 } 2201 } 2202 2203 #[doc(hidden)] 2204 impl FromGlib<gdk_sys::GdkOwnerChange> for OwnerChange { from_glib(value: gdk_sys::GdkOwnerChange) -> Self2205 fn from_glib(value: gdk_sys::GdkOwnerChange) -> Self { 2206 skip_assert_initialized!(); 2207 match value { 2208 0 => OwnerChange::NewOwner, 2209 1 => OwnerChange::Destroy, 2210 2 => OwnerChange::Close, 2211 value => OwnerChange::__Unknown(value), 2212 } 2213 } 2214 } 2215 2216 impl StaticType for OwnerChange { static_type() -> Type2217 fn static_type() -> Type { 2218 unsafe { from_glib(gdk_sys::gdk_owner_change_get_type()) } 2219 } 2220 } 2221 2222 impl<'a> FromValueOptional<'a> for OwnerChange { from_value_optional(value: &Value) -> Option<Self>2223 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2224 Some(FromValue::from_value(value)) 2225 } 2226 } 2227 2228 impl<'a> FromValue<'a> for OwnerChange { from_value(value: &Value) -> Self2229 unsafe fn from_value(value: &Value) -> Self { 2230 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2231 } 2232 } 2233 2234 impl SetValue for OwnerChange { set_value(value: &mut Value, this: &Self)2235 unsafe fn set_value(value: &mut Value, this: &Self) { 2236 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2237 } 2238 } 2239 2240 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2241 pub enum PropMode { 2242 Replace, 2243 Prepend, 2244 Append, 2245 #[doc(hidden)] 2246 __Unknown(i32), 2247 } 2248 2249 impl fmt::Display for PropMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2250 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2251 write!( 2252 f, 2253 "PropMode::{}", 2254 match *self { 2255 PropMode::Replace => "Replace", 2256 PropMode::Prepend => "Prepend", 2257 PropMode::Append => "Append", 2258 _ => "Unknown", 2259 } 2260 ) 2261 } 2262 } 2263 2264 #[doc(hidden)] 2265 impl ToGlib for PropMode { 2266 type GlibType = gdk_sys::GdkPropMode; 2267 to_glib(&self) -> gdk_sys::GdkPropMode2268 fn to_glib(&self) -> gdk_sys::GdkPropMode { 2269 match *self { 2270 PropMode::Replace => gdk_sys::GDK_PROP_MODE_REPLACE, 2271 PropMode::Prepend => gdk_sys::GDK_PROP_MODE_PREPEND, 2272 PropMode::Append => gdk_sys::GDK_PROP_MODE_APPEND, 2273 PropMode::__Unknown(value) => value, 2274 } 2275 } 2276 } 2277 2278 #[doc(hidden)] 2279 impl FromGlib<gdk_sys::GdkPropMode> for PropMode { from_glib(value: gdk_sys::GdkPropMode) -> Self2280 fn from_glib(value: gdk_sys::GdkPropMode) -> Self { 2281 skip_assert_initialized!(); 2282 match value { 2283 0 => PropMode::Replace, 2284 1 => PropMode::Prepend, 2285 2 => PropMode::Append, 2286 value => PropMode::__Unknown(value), 2287 } 2288 } 2289 } 2290 2291 impl StaticType for PropMode { static_type() -> Type2292 fn static_type() -> Type { 2293 unsafe { from_glib(gdk_sys::gdk_prop_mode_get_type()) } 2294 } 2295 } 2296 2297 impl<'a> FromValueOptional<'a> for PropMode { from_value_optional(value: &Value) -> Option<Self>2298 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2299 Some(FromValue::from_value(value)) 2300 } 2301 } 2302 2303 impl<'a> FromValue<'a> for PropMode { from_value(value: &Value) -> Self2304 unsafe fn from_value(value: &Value) -> Self { 2305 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2306 } 2307 } 2308 2309 impl SetValue for PropMode { set_value(value: &mut Value, this: &Self)2310 unsafe fn set_value(value: &mut Value, this: &Self) { 2311 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2312 } 2313 } 2314 2315 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2316 pub enum PropertyState { 2317 NewValue, 2318 Delete, 2319 #[doc(hidden)] 2320 __Unknown(i32), 2321 } 2322 2323 impl fmt::Display for PropertyState { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2324 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2325 write!( 2326 f, 2327 "PropertyState::{}", 2328 match *self { 2329 PropertyState::NewValue => "NewValue", 2330 PropertyState::Delete => "Delete", 2331 _ => "Unknown", 2332 } 2333 ) 2334 } 2335 } 2336 2337 #[doc(hidden)] 2338 impl ToGlib for PropertyState { 2339 type GlibType = gdk_sys::GdkPropertyState; 2340 to_glib(&self) -> gdk_sys::GdkPropertyState2341 fn to_glib(&self) -> gdk_sys::GdkPropertyState { 2342 match *self { 2343 PropertyState::NewValue => gdk_sys::GDK_PROPERTY_NEW_VALUE, 2344 PropertyState::Delete => gdk_sys::GDK_PROPERTY_DELETE, 2345 PropertyState::__Unknown(value) => value, 2346 } 2347 } 2348 } 2349 2350 #[doc(hidden)] 2351 impl FromGlib<gdk_sys::GdkPropertyState> for PropertyState { from_glib(value: gdk_sys::GdkPropertyState) -> Self2352 fn from_glib(value: gdk_sys::GdkPropertyState) -> Self { 2353 skip_assert_initialized!(); 2354 match value { 2355 0 => PropertyState::NewValue, 2356 1 => PropertyState::Delete, 2357 value => PropertyState::__Unknown(value), 2358 } 2359 } 2360 } 2361 2362 impl StaticType for PropertyState { static_type() -> Type2363 fn static_type() -> Type { 2364 unsafe { from_glib(gdk_sys::gdk_property_state_get_type()) } 2365 } 2366 } 2367 2368 impl<'a> FromValueOptional<'a> for PropertyState { from_value_optional(value: &Value) -> Option<Self>2369 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2370 Some(FromValue::from_value(value)) 2371 } 2372 } 2373 2374 impl<'a> FromValue<'a> for PropertyState { from_value(value: &Value) -> Self2375 unsafe fn from_value(value: &Value) -> Self { 2376 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2377 } 2378 } 2379 2380 impl SetValue for PropertyState { set_value(value: &mut Value, this: &Self)2381 unsafe fn set_value(value: &mut Value, this: &Self) { 2382 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2383 } 2384 } 2385 2386 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2387 pub enum ScrollDirection { 2388 Up, 2389 Down, 2390 Left, 2391 Right, 2392 Smooth, 2393 #[doc(hidden)] 2394 __Unknown(i32), 2395 } 2396 2397 impl fmt::Display for ScrollDirection { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2398 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2399 write!( 2400 f, 2401 "ScrollDirection::{}", 2402 match *self { 2403 ScrollDirection::Up => "Up", 2404 ScrollDirection::Down => "Down", 2405 ScrollDirection::Left => "Left", 2406 ScrollDirection::Right => "Right", 2407 ScrollDirection::Smooth => "Smooth", 2408 _ => "Unknown", 2409 } 2410 ) 2411 } 2412 } 2413 2414 #[doc(hidden)] 2415 impl ToGlib for ScrollDirection { 2416 type GlibType = gdk_sys::GdkScrollDirection; 2417 to_glib(&self) -> gdk_sys::GdkScrollDirection2418 fn to_glib(&self) -> gdk_sys::GdkScrollDirection { 2419 match *self { 2420 ScrollDirection::Up => gdk_sys::GDK_SCROLL_UP, 2421 ScrollDirection::Down => gdk_sys::GDK_SCROLL_DOWN, 2422 ScrollDirection::Left => gdk_sys::GDK_SCROLL_LEFT, 2423 ScrollDirection::Right => gdk_sys::GDK_SCROLL_RIGHT, 2424 ScrollDirection::Smooth => gdk_sys::GDK_SCROLL_SMOOTH, 2425 ScrollDirection::__Unknown(value) => value, 2426 } 2427 } 2428 } 2429 2430 #[doc(hidden)] 2431 impl FromGlib<gdk_sys::GdkScrollDirection> for ScrollDirection { from_glib(value: gdk_sys::GdkScrollDirection) -> Self2432 fn from_glib(value: gdk_sys::GdkScrollDirection) -> Self { 2433 skip_assert_initialized!(); 2434 match value { 2435 0 => ScrollDirection::Up, 2436 1 => ScrollDirection::Down, 2437 2 => ScrollDirection::Left, 2438 3 => ScrollDirection::Right, 2439 4 => ScrollDirection::Smooth, 2440 value => ScrollDirection::__Unknown(value), 2441 } 2442 } 2443 } 2444 2445 impl StaticType for ScrollDirection { static_type() -> Type2446 fn static_type() -> Type { 2447 unsafe { from_glib(gdk_sys::gdk_scroll_direction_get_type()) } 2448 } 2449 } 2450 2451 impl<'a> FromValueOptional<'a> for ScrollDirection { from_value_optional(value: &Value) -> Option<Self>2452 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2453 Some(FromValue::from_value(value)) 2454 } 2455 } 2456 2457 impl<'a> FromValue<'a> for ScrollDirection { from_value(value: &Value) -> Self2458 unsafe fn from_value(value: &Value) -> Self { 2459 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2460 } 2461 } 2462 2463 impl SetValue for ScrollDirection { set_value(value: &mut Value, this: &Self)2464 unsafe fn set_value(value: &mut Value, this: &Self) { 2465 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2466 } 2467 } 2468 2469 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2470 pub enum SettingAction { 2471 New, 2472 Changed, 2473 Deleted, 2474 #[doc(hidden)] 2475 __Unknown(i32), 2476 } 2477 2478 impl fmt::Display for SettingAction { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2479 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2480 write!( 2481 f, 2482 "SettingAction::{}", 2483 match *self { 2484 SettingAction::New => "New", 2485 SettingAction::Changed => "Changed", 2486 SettingAction::Deleted => "Deleted", 2487 _ => "Unknown", 2488 } 2489 ) 2490 } 2491 } 2492 2493 #[doc(hidden)] 2494 impl ToGlib for SettingAction { 2495 type GlibType = gdk_sys::GdkSettingAction; 2496 to_glib(&self) -> gdk_sys::GdkSettingAction2497 fn to_glib(&self) -> gdk_sys::GdkSettingAction { 2498 match *self { 2499 SettingAction::New => gdk_sys::GDK_SETTING_ACTION_NEW, 2500 SettingAction::Changed => gdk_sys::GDK_SETTING_ACTION_CHANGED, 2501 SettingAction::Deleted => gdk_sys::GDK_SETTING_ACTION_DELETED, 2502 SettingAction::__Unknown(value) => value, 2503 } 2504 } 2505 } 2506 2507 #[doc(hidden)] 2508 impl FromGlib<gdk_sys::GdkSettingAction> for SettingAction { from_glib(value: gdk_sys::GdkSettingAction) -> Self2509 fn from_glib(value: gdk_sys::GdkSettingAction) -> Self { 2510 skip_assert_initialized!(); 2511 match value { 2512 0 => SettingAction::New, 2513 1 => SettingAction::Changed, 2514 2 => SettingAction::Deleted, 2515 value => SettingAction::__Unknown(value), 2516 } 2517 } 2518 } 2519 2520 impl StaticType for SettingAction { static_type() -> Type2521 fn static_type() -> Type { 2522 unsafe { from_glib(gdk_sys::gdk_setting_action_get_type()) } 2523 } 2524 } 2525 2526 impl<'a> FromValueOptional<'a> for SettingAction { from_value_optional(value: &Value) -> Option<Self>2527 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2528 Some(FromValue::from_value(value)) 2529 } 2530 } 2531 2532 impl<'a> FromValue<'a> for SettingAction { from_value(value: &Value) -> Self2533 unsafe fn from_value(value: &Value) -> Self { 2534 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2535 } 2536 } 2537 2538 impl SetValue for SettingAction { set_value(value: &mut Value, this: &Self)2539 unsafe fn set_value(value: &mut Value, this: &Self) { 2540 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2541 } 2542 } 2543 2544 #[cfg(any(feature = "v3_22", feature = "dox"))] 2545 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2546 pub enum SubpixelLayout { 2547 Unknown, 2548 None, 2549 HorizontalRgb, 2550 HorizontalBgr, 2551 VerticalRgb, 2552 VerticalBgr, 2553 #[doc(hidden)] 2554 __Unknown(i32), 2555 } 2556 2557 #[cfg(any(feature = "v3_22", feature = "dox"))] 2558 impl fmt::Display for SubpixelLayout { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2559 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2560 write!( 2561 f, 2562 "SubpixelLayout::{}", 2563 match *self { 2564 SubpixelLayout::Unknown => "Unknown", 2565 SubpixelLayout::None => "None", 2566 SubpixelLayout::HorizontalRgb => "HorizontalRgb", 2567 SubpixelLayout::HorizontalBgr => "HorizontalBgr", 2568 SubpixelLayout::VerticalRgb => "VerticalRgb", 2569 SubpixelLayout::VerticalBgr => "VerticalBgr", 2570 _ => "Unknown", 2571 } 2572 ) 2573 } 2574 } 2575 2576 #[cfg(any(feature = "v3_22", feature = "dox"))] 2577 #[doc(hidden)] 2578 impl ToGlib for SubpixelLayout { 2579 type GlibType = gdk_sys::GdkSubpixelLayout; 2580 to_glib(&self) -> gdk_sys::GdkSubpixelLayout2581 fn to_glib(&self) -> gdk_sys::GdkSubpixelLayout { 2582 match *self { 2583 SubpixelLayout::Unknown => gdk_sys::GDK_SUBPIXEL_LAYOUT_UNKNOWN, 2584 SubpixelLayout::None => gdk_sys::GDK_SUBPIXEL_LAYOUT_NONE, 2585 SubpixelLayout::HorizontalRgb => gdk_sys::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB, 2586 SubpixelLayout::HorizontalBgr => gdk_sys::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR, 2587 SubpixelLayout::VerticalRgb => gdk_sys::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB, 2588 SubpixelLayout::VerticalBgr => gdk_sys::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR, 2589 SubpixelLayout::__Unknown(value) => value, 2590 } 2591 } 2592 } 2593 2594 #[cfg(any(feature = "v3_22", feature = "dox"))] 2595 #[doc(hidden)] 2596 impl FromGlib<gdk_sys::GdkSubpixelLayout> for SubpixelLayout { from_glib(value: gdk_sys::GdkSubpixelLayout) -> Self2597 fn from_glib(value: gdk_sys::GdkSubpixelLayout) -> Self { 2598 skip_assert_initialized!(); 2599 match value { 2600 0 => SubpixelLayout::Unknown, 2601 1 => SubpixelLayout::None, 2602 2 => SubpixelLayout::HorizontalRgb, 2603 3 => SubpixelLayout::HorizontalBgr, 2604 4 => SubpixelLayout::VerticalRgb, 2605 5 => SubpixelLayout::VerticalBgr, 2606 value => SubpixelLayout::__Unknown(value), 2607 } 2608 } 2609 } 2610 2611 #[cfg(any(feature = "v3_22", feature = "dox"))] 2612 impl StaticType for SubpixelLayout { static_type() -> Type2613 fn static_type() -> Type { 2614 unsafe { from_glib(gdk_sys::gdk_subpixel_layout_get_type()) } 2615 } 2616 } 2617 2618 #[cfg(any(feature = "v3_22", feature = "dox"))] 2619 impl<'a> FromValueOptional<'a> for SubpixelLayout { from_value_optional(value: &Value) -> Option<Self>2620 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2621 Some(FromValue::from_value(value)) 2622 } 2623 } 2624 2625 #[cfg(any(feature = "v3_22", feature = "dox"))] 2626 impl<'a> FromValue<'a> for SubpixelLayout { from_value(value: &Value) -> Self2627 unsafe fn from_value(value: &Value) -> Self { 2628 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2629 } 2630 } 2631 2632 #[cfg(any(feature = "v3_22", feature = "dox"))] 2633 impl SetValue for SubpixelLayout { set_value(value: &mut Value, this: &Self)2634 unsafe fn set_value(value: &mut Value, this: &Self) { 2635 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2636 } 2637 } 2638 2639 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2640 pub enum VisibilityState { 2641 Unobscured, 2642 Partial, 2643 FullyObscured, 2644 #[doc(hidden)] 2645 __Unknown(i32), 2646 } 2647 2648 impl fmt::Display for VisibilityState { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2649 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2650 write!( 2651 f, 2652 "VisibilityState::{}", 2653 match *self { 2654 VisibilityState::Unobscured => "Unobscured", 2655 VisibilityState::Partial => "Partial", 2656 VisibilityState::FullyObscured => "FullyObscured", 2657 _ => "Unknown", 2658 } 2659 ) 2660 } 2661 } 2662 2663 #[doc(hidden)] 2664 impl ToGlib for VisibilityState { 2665 type GlibType = gdk_sys::GdkVisibilityState; 2666 to_glib(&self) -> gdk_sys::GdkVisibilityState2667 fn to_glib(&self) -> gdk_sys::GdkVisibilityState { 2668 match *self { 2669 VisibilityState::Unobscured => gdk_sys::GDK_VISIBILITY_UNOBSCURED, 2670 VisibilityState::Partial => gdk_sys::GDK_VISIBILITY_PARTIAL, 2671 VisibilityState::FullyObscured => gdk_sys::GDK_VISIBILITY_FULLY_OBSCURED, 2672 VisibilityState::__Unknown(value) => value, 2673 } 2674 } 2675 } 2676 2677 #[doc(hidden)] 2678 impl FromGlib<gdk_sys::GdkVisibilityState> for VisibilityState { from_glib(value: gdk_sys::GdkVisibilityState) -> Self2679 fn from_glib(value: gdk_sys::GdkVisibilityState) -> Self { 2680 skip_assert_initialized!(); 2681 match value { 2682 0 => VisibilityState::Unobscured, 2683 1 => VisibilityState::Partial, 2684 2 => VisibilityState::FullyObscured, 2685 value => VisibilityState::__Unknown(value), 2686 } 2687 } 2688 } 2689 2690 impl StaticType for VisibilityState { static_type() -> Type2691 fn static_type() -> Type { 2692 unsafe { from_glib(gdk_sys::gdk_visibility_state_get_type()) } 2693 } 2694 } 2695 2696 impl<'a> FromValueOptional<'a> for VisibilityState { from_value_optional(value: &Value) -> Option<Self>2697 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2698 Some(FromValue::from_value(value)) 2699 } 2700 } 2701 2702 impl<'a> FromValue<'a> for VisibilityState { from_value(value: &Value) -> Self2703 unsafe fn from_value(value: &Value) -> Self { 2704 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2705 } 2706 } 2707 2708 impl SetValue for VisibilityState { set_value(value: &mut Value, this: &Self)2709 unsafe fn set_value(value: &mut Value, this: &Self) { 2710 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2711 } 2712 } 2713 2714 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2715 pub enum VisualType { 2716 StaticGray, 2717 Grayscale, 2718 StaticColor, 2719 PseudoColor, 2720 TrueColor, 2721 DirectColor, 2722 #[doc(hidden)] 2723 __Unknown(i32), 2724 } 2725 2726 impl fmt::Display for VisualType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2727 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2728 write!( 2729 f, 2730 "VisualType::{}", 2731 match *self { 2732 VisualType::StaticGray => "StaticGray", 2733 VisualType::Grayscale => "Grayscale", 2734 VisualType::StaticColor => "StaticColor", 2735 VisualType::PseudoColor => "PseudoColor", 2736 VisualType::TrueColor => "TrueColor", 2737 VisualType::DirectColor => "DirectColor", 2738 _ => "Unknown", 2739 } 2740 ) 2741 } 2742 } 2743 2744 #[doc(hidden)] 2745 impl ToGlib for VisualType { 2746 type GlibType = gdk_sys::GdkVisualType; 2747 to_glib(&self) -> gdk_sys::GdkVisualType2748 fn to_glib(&self) -> gdk_sys::GdkVisualType { 2749 match *self { 2750 VisualType::StaticGray => gdk_sys::GDK_VISUAL_STATIC_GRAY, 2751 VisualType::Grayscale => gdk_sys::GDK_VISUAL_GRAYSCALE, 2752 VisualType::StaticColor => gdk_sys::GDK_VISUAL_STATIC_COLOR, 2753 VisualType::PseudoColor => gdk_sys::GDK_VISUAL_PSEUDO_COLOR, 2754 VisualType::TrueColor => gdk_sys::GDK_VISUAL_TRUE_COLOR, 2755 VisualType::DirectColor => gdk_sys::GDK_VISUAL_DIRECT_COLOR, 2756 VisualType::__Unknown(value) => value, 2757 } 2758 } 2759 } 2760 2761 #[doc(hidden)] 2762 impl FromGlib<gdk_sys::GdkVisualType> for VisualType { from_glib(value: gdk_sys::GdkVisualType) -> Self2763 fn from_glib(value: gdk_sys::GdkVisualType) -> Self { 2764 skip_assert_initialized!(); 2765 match value { 2766 0 => VisualType::StaticGray, 2767 1 => VisualType::Grayscale, 2768 2 => VisualType::StaticColor, 2769 3 => VisualType::PseudoColor, 2770 4 => VisualType::TrueColor, 2771 5 => VisualType::DirectColor, 2772 value => VisualType::__Unknown(value), 2773 } 2774 } 2775 } 2776 2777 impl StaticType for VisualType { static_type() -> Type2778 fn static_type() -> Type { 2779 unsafe { from_glib(gdk_sys::gdk_visual_type_get_type()) } 2780 } 2781 } 2782 2783 impl<'a> FromValueOptional<'a> for VisualType { from_value_optional(value: &Value) -> Option<Self>2784 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2785 Some(FromValue::from_value(value)) 2786 } 2787 } 2788 2789 impl<'a> FromValue<'a> for VisualType { from_value(value: &Value) -> Self2790 unsafe fn from_value(value: &Value) -> Self { 2791 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2792 } 2793 } 2794 2795 impl SetValue for VisualType { set_value(value: &mut Value, this: &Self)2796 unsafe fn set_value(value: &mut Value, this: &Self) { 2797 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2798 } 2799 } 2800 2801 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2802 pub enum WindowEdge { 2803 NorthWest, 2804 North, 2805 NorthEast, 2806 West, 2807 East, 2808 SouthWest, 2809 South, 2810 SouthEast, 2811 #[doc(hidden)] 2812 __Unknown(i32), 2813 } 2814 2815 impl fmt::Display for WindowEdge { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2816 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2817 write!( 2818 f, 2819 "WindowEdge::{}", 2820 match *self { 2821 WindowEdge::NorthWest => "NorthWest", 2822 WindowEdge::North => "North", 2823 WindowEdge::NorthEast => "NorthEast", 2824 WindowEdge::West => "West", 2825 WindowEdge::East => "East", 2826 WindowEdge::SouthWest => "SouthWest", 2827 WindowEdge::South => "South", 2828 WindowEdge::SouthEast => "SouthEast", 2829 _ => "Unknown", 2830 } 2831 ) 2832 } 2833 } 2834 2835 #[doc(hidden)] 2836 impl ToGlib for WindowEdge { 2837 type GlibType = gdk_sys::GdkWindowEdge; 2838 to_glib(&self) -> gdk_sys::GdkWindowEdge2839 fn to_glib(&self) -> gdk_sys::GdkWindowEdge { 2840 match *self { 2841 WindowEdge::NorthWest => gdk_sys::GDK_WINDOW_EDGE_NORTH_WEST, 2842 WindowEdge::North => gdk_sys::GDK_WINDOW_EDGE_NORTH, 2843 WindowEdge::NorthEast => gdk_sys::GDK_WINDOW_EDGE_NORTH_EAST, 2844 WindowEdge::West => gdk_sys::GDK_WINDOW_EDGE_WEST, 2845 WindowEdge::East => gdk_sys::GDK_WINDOW_EDGE_EAST, 2846 WindowEdge::SouthWest => gdk_sys::GDK_WINDOW_EDGE_SOUTH_WEST, 2847 WindowEdge::South => gdk_sys::GDK_WINDOW_EDGE_SOUTH, 2848 WindowEdge::SouthEast => gdk_sys::GDK_WINDOW_EDGE_SOUTH_EAST, 2849 WindowEdge::__Unknown(value) => value, 2850 } 2851 } 2852 } 2853 2854 #[doc(hidden)] 2855 impl FromGlib<gdk_sys::GdkWindowEdge> for WindowEdge { from_glib(value: gdk_sys::GdkWindowEdge) -> Self2856 fn from_glib(value: gdk_sys::GdkWindowEdge) -> Self { 2857 skip_assert_initialized!(); 2858 match value { 2859 0 => WindowEdge::NorthWest, 2860 1 => WindowEdge::North, 2861 2 => WindowEdge::NorthEast, 2862 3 => WindowEdge::West, 2863 4 => WindowEdge::East, 2864 5 => WindowEdge::SouthWest, 2865 6 => WindowEdge::South, 2866 7 => WindowEdge::SouthEast, 2867 value => WindowEdge::__Unknown(value), 2868 } 2869 } 2870 } 2871 2872 impl StaticType for WindowEdge { static_type() -> Type2873 fn static_type() -> Type { 2874 unsafe { from_glib(gdk_sys::gdk_window_edge_get_type()) } 2875 } 2876 } 2877 2878 impl<'a> FromValueOptional<'a> for WindowEdge { from_value_optional(value: &Value) -> Option<Self>2879 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2880 Some(FromValue::from_value(value)) 2881 } 2882 } 2883 2884 impl<'a> FromValue<'a> for WindowEdge { from_value(value: &Value) -> Self2885 unsafe fn from_value(value: &Value) -> Self { 2886 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2887 } 2888 } 2889 2890 impl SetValue for WindowEdge { set_value(value: &mut Value, this: &Self)2891 unsafe fn set_value(value: &mut Value, this: &Self) { 2892 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2893 } 2894 } 2895 2896 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2897 pub enum WindowType { 2898 Root, 2899 Toplevel, 2900 Child, 2901 Temp, 2902 Foreign, 2903 Offscreen, 2904 Subsurface, 2905 #[doc(hidden)] 2906 __Unknown(i32), 2907 } 2908 2909 impl fmt::Display for WindowType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2910 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2911 write!( 2912 f, 2913 "WindowType::{}", 2914 match *self { 2915 WindowType::Root => "Root", 2916 WindowType::Toplevel => "Toplevel", 2917 WindowType::Child => "Child", 2918 WindowType::Temp => "Temp", 2919 WindowType::Foreign => "Foreign", 2920 WindowType::Offscreen => "Offscreen", 2921 WindowType::Subsurface => "Subsurface", 2922 _ => "Unknown", 2923 } 2924 ) 2925 } 2926 } 2927 2928 #[doc(hidden)] 2929 impl ToGlib for WindowType { 2930 type GlibType = gdk_sys::GdkWindowType; 2931 to_glib(&self) -> gdk_sys::GdkWindowType2932 fn to_glib(&self) -> gdk_sys::GdkWindowType { 2933 match *self { 2934 WindowType::Root => gdk_sys::GDK_WINDOW_ROOT, 2935 WindowType::Toplevel => gdk_sys::GDK_WINDOW_TOPLEVEL, 2936 WindowType::Child => gdk_sys::GDK_WINDOW_CHILD, 2937 WindowType::Temp => gdk_sys::GDK_WINDOW_TEMP, 2938 WindowType::Foreign => gdk_sys::GDK_WINDOW_FOREIGN, 2939 WindowType::Offscreen => gdk_sys::GDK_WINDOW_OFFSCREEN, 2940 WindowType::Subsurface => gdk_sys::GDK_WINDOW_SUBSURFACE, 2941 WindowType::__Unknown(value) => value, 2942 } 2943 } 2944 } 2945 2946 #[doc(hidden)] 2947 impl FromGlib<gdk_sys::GdkWindowType> for WindowType { from_glib(value: gdk_sys::GdkWindowType) -> Self2948 fn from_glib(value: gdk_sys::GdkWindowType) -> Self { 2949 skip_assert_initialized!(); 2950 match value { 2951 0 => WindowType::Root, 2952 1 => WindowType::Toplevel, 2953 2 => WindowType::Child, 2954 3 => WindowType::Temp, 2955 4 => WindowType::Foreign, 2956 5 => WindowType::Offscreen, 2957 6 => WindowType::Subsurface, 2958 value => WindowType::__Unknown(value), 2959 } 2960 } 2961 } 2962 2963 impl StaticType for WindowType { static_type() -> Type2964 fn static_type() -> Type { 2965 unsafe { from_glib(gdk_sys::gdk_window_type_get_type()) } 2966 } 2967 } 2968 2969 impl<'a> FromValueOptional<'a> for WindowType { from_value_optional(value: &Value) -> Option<Self>2970 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2971 Some(FromValue::from_value(value)) 2972 } 2973 } 2974 2975 impl<'a> FromValue<'a> for WindowType { from_value(value: &Value) -> Self2976 unsafe fn from_value(value: &Value) -> Self { 2977 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2978 } 2979 } 2980 2981 impl SetValue for WindowType { set_value(value: &mut Value, this: &Self)2982 unsafe fn set_value(value: &mut Value, this: &Self) { 2983 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2984 } 2985 } 2986 2987 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2988 pub enum WindowTypeHint { 2989 Normal, 2990 Dialog, 2991 Menu, 2992 Toolbar, 2993 Splashscreen, 2994 Utility, 2995 Dock, 2996 Desktop, 2997 DropdownMenu, 2998 PopupMenu, 2999 Tooltip, 3000 Notification, 3001 Combo, 3002 Dnd, 3003 #[doc(hidden)] 3004 __Unknown(i32), 3005 } 3006 3007 impl fmt::Display for WindowTypeHint { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3008 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3009 write!( 3010 f, 3011 "WindowTypeHint::{}", 3012 match *self { 3013 WindowTypeHint::Normal => "Normal", 3014 WindowTypeHint::Dialog => "Dialog", 3015 WindowTypeHint::Menu => "Menu", 3016 WindowTypeHint::Toolbar => "Toolbar", 3017 WindowTypeHint::Splashscreen => "Splashscreen", 3018 WindowTypeHint::Utility => "Utility", 3019 WindowTypeHint::Dock => "Dock", 3020 WindowTypeHint::Desktop => "Desktop", 3021 WindowTypeHint::DropdownMenu => "DropdownMenu", 3022 WindowTypeHint::PopupMenu => "PopupMenu", 3023 WindowTypeHint::Tooltip => "Tooltip", 3024 WindowTypeHint::Notification => "Notification", 3025 WindowTypeHint::Combo => "Combo", 3026 WindowTypeHint::Dnd => "Dnd", 3027 _ => "Unknown", 3028 } 3029 ) 3030 } 3031 } 3032 3033 #[doc(hidden)] 3034 impl ToGlib for WindowTypeHint { 3035 type GlibType = gdk_sys::GdkWindowTypeHint; 3036 to_glib(&self) -> gdk_sys::GdkWindowTypeHint3037 fn to_glib(&self) -> gdk_sys::GdkWindowTypeHint { 3038 match *self { 3039 WindowTypeHint::Normal => gdk_sys::GDK_WINDOW_TYPE_HINT_NORMAL, 3040 WindowTypeHint::Dialog => gdk_sys::GDK_WINDOW_TYPE_HINT_DIALOG, 3041 WindowTypeHint::Menu => gdk_sys::GDK_WINDOW_TYPE_HINT_MENU, 3042 WindowTypeHint::Toolbar => gdk_sys::GDK_WINDOW_TYPE_HINT_TOOLBAR, 3043 WindowTypeHint::Splashscreen => gdk_sys::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN, 3044 WindowTypeHint::Utility => gdk_sys::GDK_WINDOW_TYPE_HINT_UTILITY, 3045 WindowTypeHint::Dock => gdk_sys::GDK_WINDOW_TYPE_HINT_DOCK, 3046 WindowTypeHint::Desktop => gdk_sys::GDK_WINDOW_TYPE_HINT_DESKTOP, 3047 WindowTypeHint::DropdownMenu => gdk_sys::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU, 3048 WindowTypeHint::PopupMenu => gdk_sys::GDK_WINDOW_TYPE_HINT_POPUP_MENU, 3049 WindowTypeHint::Tooltip => gdk_sys::GDK_WINDOW_TYPE_HINT_TOOLTIP, 3050 WindowTypeHint::Notification => gdk_sys::GDK_WINDOW_TYPE_HINT_NOTIFICATION, 3051 WindowTypeHint::Combo => gdk_sys::GDK_WINDOW_TYPE_HINT_COMBO, 3052 WindowTypeHint::Dnd => gdk_sys::GDK_WINDOW_TYPE_HINT_DND, 3053 WindowTypeHint::__Unknown(value) => value, 3054 } 3055 } 3056 } 3057 3058 #[doc(hidden)] 3059 impl FromGlib<gdk_sys::GdkWindowTypeHint> for WindowTypeHint { from_glib(value: gdk_sys::GdkWindowTypeHint) -> Self3060 fn from_glib(value: gdk_sys::GdkWindowTypeHint) -> Self { 3061 skip_assert_initialized!(); 3062 match value { 3063 0 => WindowTypeHint::Normal, 3064 1 => WindowTypeHint::Dialog, 3065 2 => WindowTypeHint::Menu, 3066 3 => WindowTypeHint::Toolbar, 3067 4 => WindowTypeHint::Splashscreen, 3068 5 => WindowTypeHint::Utility, 3069 6 => WindowTypeHint::Dock, 3070 7 => WindowTypeHint::Desktop, 3071 8 => WindowTypeHint::DropdownMenu, 3072 9 => WindowTypeHint::PopupMenu, 3073 10 => WindowTypeHint::Tooltip, 3074 11 => WindowTypeHint::Notification, 3075 12 => WindowTypeHint::Combo, 3076 13 => WindowTypeHint::Dnd, 3077 value => WindowTypeHint::__Unknown(value), 3078 } 3079 } 3080 } 3081 3082 impl StaticType for WindowTypeHint { static_type() -> Type3083 fn static_type() -> Type { 3084 unsafe { from_glib(gdk_sys::gdk_window_type_hint_get_type()) } 3085 } 3086 } 3087 3088 impl<'a> FromValueOptional<'a> for WindowTypeHint { from_value_optional(value: &Value) -> Option<Self>3089 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 3090 Some(FromValue::from_value(value)) 3091 } 3092 } 3093 3094 impl<'a> FromValue<'a> for WindowTypeHint { from_value(value: &Value) -> Self3095 unsafe fn from_value(value: &Value) -> Self { 3096 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 3097 } 3098 } 3099 3100 impl SetValue for WindowTypeHint { set_value(value: &mut Value, this: &Self)3101 unsafe fn set_value(value: &mut Value, this: &Self) { 3102 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 3103 } 3104 } 3105 3106 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 3107 pub enum WindowWindowClass { 3108 InputOutput, 3109 InputOnly, 3110 #[doc(hidden)] 3111 __Unknown(i32), 3112 } 3113 3114 impl fmt::Display for WindowWindowClass { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result3115 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 3116 write!( 3117 f, 3118 "WindowWindowClass::{}", 3119 match *self { 3120 WindowWindowClass::InputOutput => "InputOutput", 3121 WindowWindowClass::InputOnly => "InputOnly", 3122 _ => "Unknown", 3123 } 3124 ) 3125 } 3126 } 3127 3128 #[doc(hidden)] 3129 impl ToGlib for WindowWindowClass { 3130 type GlibType = gdk_sys::GdkWindowWindowClass; 3131 to_glib(&self) -> gdk_sys::GdkWindowWindowClass3132 fn to_glib(&self) -> gdk_sys::GdkWindowWindowClass { 3133 match *self { 3134 WindowWindowClass::InputOutput => gdk_sys::GDK_INPUT_OUTPUT, 3135 WindowWindowClass::InputOnly => gdk_sys::GDK_INPUT_ONLY, 3136 WindowWindowClass::__Unknown(value) => value, 3137 } 3138 } 3139 } 3140 3141 #[doc(hidden)] 3142 impl FromGlib<gdk_sys::GdkWindowWindowClass> for WindowWindowClass { from_glib(value: gdk_sys::GdkWindowWindowClass) -> Self3143 fn from_glib(value: gdk_sys::GdkWindowWindowClass) -> Self { 3144 skip_assert_initialized!(); 3145 match value { 3146 0 => WindowWindowClass::InputOutput, 3147 1 => WindowWindowClass::InputOnly, 3148 value => WindowWindowClass::__Unknown(value), 3149 } 3150 } 3151 } 3152 3153 impl StaticType for WindowWindowClass { static_type() -> Type3154 fn static_type() -> Type { 3155 unsafe { from_glib(gdk_sys::gdk_window_window_class_get_type()) } 3156 } 3157 } 3158 3159 impl<'a> FromValueOptional<'a> for WindowWindowClass { from_value_optional(value: &Value) -> Option<Self>3160 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 3161 Some(FromValue::from_value(value)) 3162 } 3163 } 3164 3165 impl<'a> FromValue<'a> for WindowWindowClass { from_value(value: &Value) -> Self3166 unsafe fn from_value(value: &Value) -> Self { 3167 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 3168 } 3169 } 3170 3171 impl SetValue for WindowWindowClass { set_value(value: &mut Value, this: &Self)3172 unsafe fn set_value(value: &mut Value, this: &Self) { 3173 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 3174 } 3175 } 3176