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 bitflags::bitflags; 6 use glib::translate::*; 7 use glib::value::FromValue; 8 use glib::value::ToValue; 9 use glib::StaticType; 10 use glib::Type; 11 use std::fmt; 12 13 bitflags! { 14 #[doc(alias = "GtkAccelFlags")] 15 pub struct AccelFlags: u32 { 16 #[doc(alias = "GTK_ACCEL_VISIBLE")] 17 const VISIBLE = ffi::GTK_ACCEL_VISIBLE as u32; 18 #[doc(alias = "GTK_ACCEL_LOCKED")] 19 const LOCKED = ffi::GTK_ACCEL_LOCKED as u32; 20 #[doc(alias = "GTK_ACCEL_MASK")] 21 const MASK = ffi::GTK_ACCEL_MASK as u32; 22 } 23 } 24 25 impl fmt::Display for AccelFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result26 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 27 <Self as fmt::Debug>::fmt(self, f) 28 } 29 } 30 31 #[doc(hidden)] 32 impl IntoGlib for AccelFlags { 33 type GlibType = ffi::GtkAccelFlags; 34 into_glib(self) -> ffi::GtkAccelFlags35 fn into_glib(self) -> ffi::GtkAccelFlags { 36 self.bits() 37 } 38 } 39 40 #[doc(hidden)] 41 impl FromGlib<ffi::GtkAccelFlags> for AccelFlags { from_glib(value: ffi::GtkAccelFlags) -> Self42 unsafe fn from_glib(value: ffi::GtkAccelFlags) -> Self { 43 skip_assert_initialized!(); 44 Self::from_bits_truncate(value) 45 } 46 } 47 48 impl StaticType for AccelFlags { static_type() -> Type49 fn static_type() -> Type { 50 unsafe { from_glib(ffi::gtk_accel_flags_get_type()) } 51 } 52 } 53 54 impl glib::value::ValueType for AccelFlags { 55 type Type = Self; 56 } 57 58 unsafe impl<'a> FromValue<'a> for AccelFlags { 59 type Checker = glib::value::GenericValueTypeChecker<Self>; 60 from_value(value: &'a glib::Value) -> Self61 unsafe fn from_value(value: &'a glib::Value) -> Self { 62 skip_assert_initialized!(); 63 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 64 } 65 } 66 67 impl ToValue for AccelFlags { to_value(&self) -> glib::Value68 fn to_value(&self) -> glib::Value { 69 let mut value = glib::Value::for_value_type::<Self>(); 70 unsafe { 71 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 72 } 73 value 74 } 75 value_type(&self) -> glib::Type76 fn value_type(&self) -> glib::Type { 77 Self::static_type() 78 } 79 } 80 81 bitflags! { 82 #[doc(alias = "GtkApplicationInhibitFlags")] 83 pub struct ApplicationInhibitFlags: u32 { 84 #[doc(alias = "GTK_APPLICATION_INHIBIT_LOGOUT")] 85 const LOGOUT = ffi::GTK_APPLICATION_INHIBIT_LOGOUT as u32; 86 #[doc(alias = "GTK_APPLICATION_INHIBIT_SWITCH")] 87 const SWITCH = ffi::GTK_APPLICATION_INHIBIT_SWITCH as u32; 88 #[doc(alias = "GTK_APPLICATION_INHIBIT_SUSPEND")] 89 const SUSPEND = ffi::GTK_APPLICATION_INHIBIT_SUSPEND as u32; 90 #[doc(alias = "GTK_APPLICATION_INHIBIT_IDLE")] 91 const IDLE = ffi::GTK_APPLICATION_INHIBIT_IDLE as u32; 92 } 93 } 94 95 impl fmt::Display for ApplicationInhibitFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result96 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 97 <Self as fmt::Debug>::fmt(self, f) 98 } 99 } 100 101 #[doc(hidden)] 102 impl IntoGlib for ApplicationInhibitFlags { 103 type GlibType = ffi::GtkApplicationInhibitFlags; 104 into_glib(self) -> ffi::GtkApplicationInhibitFlags105 fn into_glib(self) -> ffi::GtkApplicationInhibitFlags { 106 self.bits() 107 } 108 } 109 110 #[doc(hidden)] 111 impl FromGlib<ffi::GtkApplicationInhibitFlags> for ApplicationInhibitFlags { from_glib(value: ffi::GtkApplicationInhibitFlags) -> Self112 unsafe fn from_glib(value: ffi::GtkApplicationInhibitFlags) -> Self { 113 skip_assert_initialized!(); 114 Self::from_bits_truncate(value) 115 } 116 } 117 118 impl StaticType for ApplicationInhibitFlags { static_type() -> Type119 fn static_type() -> Type { 120 unsafe { from_glib(ffi::gtk_application_inhibit_flags_get_type()) } 121 } 122 } 123 124 impl glib::value::ValueType for ApplicationInhibitFlags { 125 type Type = Self; 126 } 127 128 unsafe impl<'a> FromValue<'a> for ApplicationInhibitFlags { 129 type Checker = glib::value::GenericValueTypeChecker<Self>; 130 from_value(value: &'a glib::Value) -> Self131 unsafe fn from_value(value: &'a glib::Value) -> Self { 132 skip_assert_initialized!(); 133 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 134 } 135 } 136 137 impl ToValue for ApplicationInhibitFlags { to_value(&self) -> glib::Value138 fn to_value(&self) -> glib::Value { 139 let mut value = glib::Value::for_value_type::<Self>(); 140 unsafe { 141 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 142 } 143 value 144 } 145 value_type(&self) -> glib::Type146 fn value_type(&self) -> glib::Type { 147 Self::static_type() 148 } 149 } 150 151 bitflags! { 152 #[doc(alias = "GtkCalendarDisplayOptions")] 153 pub struct CalendarDisplayOptions: u32 { 154 #[doc(alias = "GTK_CALENDAR_SHOW_HEADING")] 155 const SHOW_HEADING = ffi::GTK_CALENDAR_SHOW_HEADING as u32; 156 #[doc(alias = "GTK_CALENDAR_SHOW_DAY_NAMES")] 157 const SHOW_DAY_NAMES = ffi::GTK_CALENDAR_SHOW_DAY_NAMES as u32; 158 #[doc(alias = "GTK_CALENDAR_NO_MONTH_CHANGE")] 159 const NO_MONTH_CHANGE = ffi::GTK_CALENDAR_NO_MONTH_CHANGE as u32; 160 #[doc(alias = "GTK_CALENDAR_SHOW_WEEK_NUMBERS")] 161 const SHOW_WEEK_NUMBERS = ffi::GTK_CALENDAR_SHOW_WEEK_NUMBERS as u32; 162 #[doc(alias = "GTK_CALENDAR_SHOW_DETAILS")] 163 const SHOW_DETAILS = ffi::GTK_CALENDAR_SHOW_DETAILS as u32; 164 } 165 } 166 167 impl fmt::Display for CalendarDisplayOptions { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result168 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 169 <Self as fmt::Debug>::fmt(self, f) 170 } 171 } 172 173 #[doc(hidden)] 174 impl IntoGlib for CalendarDisplayOptions { 175 type GlibType = ffi::GtkCalendarDisplayOptions; 176 into_glib(self) -> ffi::GtkCalendarDisplayOptions177 fn into_glib(self) -> ffi::GtkCalendarDisplayOptions { 178 self.bits() 179 } 180 } 181 182 #[doc(hidden)] 183 impl FromGlib<ffi::GtkCalendarDisplayOptions> for CalendarDisplayOptions { from_glib(value: ffi::GtkCalendarDisplayOptions) -> Self184 unsafe fn from_glib(value: ffi::GtkCalendarDisplayOptions) -> Self { 185 skip_assert_initialized!(); 186 Self::from_bits_truncate(value) 187 } 188 } 189 190 impl StaticType for CalendarDisplayOptions { static_type() -> Type191 fn static_type() -> Type { 192 unsafe { from_glib(ffi::gtk_calendar_display_options_get_type()) } 193 } 194 } 195 196 impl glib::value::ValueType for CalendarDisplayOptions { 197 type Type = Self; 198 } 199 200 unsafe impl<'a> FromValue<'a> for CalendarDisplayOptions { 201 type Checker = glib::value::GenericValueTypeChecker<Self>; 202 from_value(value: &'a glib::Value) -> Self203 unsafe fn from_value(value: &'a glib::Value) -> Self { 204 skip_assert_initialized!(); 205 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 206 } 207 } 208 209 impl ToValue for CalendarDisplayOptions { to_value(&self) -> glib::Value210 fn to_value(&self) -> glib::Value { 211 let mut value = glib::Value::for_value_type::<Self>(); 212 unsafe { 213 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 214 } 215 value 216 } 217 value_type(&self) -> glib::Type218 fn value_type(&self) -> glib::Type { 219 Self::static_type() 220 } 221 } 222 223 bitflags! { 224 #[doc(alias = "GtkCellRendererState")] 225 pub struct CellRendererState: u32 { 226 #[doc(alias = "GTK_CELL_RENDERER_SELECTED")] 227 const SELECTED = ffi::GTK_CELL_RENDERER_SELECTED as u32; 228 #[doc(alias = "GTK_CELL_RENDERER_PRELIT")] 229 const PRELIT = ffi::GTK_CELL_RENDERER_PRELIT as u32; 230 #[doc(alias = "GTK_CELL_RENDERER_INSENSITIVE")] 231 const INSENSITIVE = ffi::GTK_CELL_RENDERER_INSENSITIVE as u32; 232 #[doc(alias = "GTK_CELL_RENDERER_SORTED")] 233 const SORTED = ffi::GTK_CELL_RENDERER_SORTED as u32; 234 #[doc(alias = "GTK_CELL_RENDERER_FOCUSED")] 235 const FOCUSED = ffi::GTK_CELL_RENDERER_FOCUSED as u32; 236 #[doc(alias = "GTK_CELL_RENDERER_EXPANDABLE")] 237 const EXPANDABLE = ffi::GTK_CELL_RENDERER_EXPANDABLE as u32; 238 #[doc(alias = "GTK_CELL_RENDERER_EXPANDED")] 239 const EXPANDED = ffi::GTK_CELL_RENDERER_EXPANDED as u32; 240 } 241 } 242 243 impl fmt::Display for CellRendererState { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result244 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 245 <Self as fmt::Debug>::fmt(self, f) 246 } 247 } 248 249 #[doc(hidden)] 250 impl IntoGlib for CellRendererState { 251 type GlibType = ffi::GtkCellRendererState; 252 into_glib(self) -> ffi::GtkCellRendererState253 fn into_glib(self) -> ffi::GtkCellRendererState { 254 self.bits() 255 } 256 } 257 258 #[doc(hidden)] 259 impl FromGlib<ffi::GtkCellRendererState> for CellRendererState { from_glib(value: ffi::GtkCellRendererState) -> Self260 unsafe fn from_glib(value: ffi::GtkCellRendererState) -> Self { 261 skip_assert_initialized!(); 262 Self::from_bits_truncate(value) 263 } 264 } 265 266 impl StaticType for CellRendererState { static_type() -> Type267 fn static_type() -> Type { 268 unsafe { from_glib(ffi::gtk_cell_renderer_state_get_type()) } 269 } 270 } 271 272 impl glib::value::ValueType for CellRendererState { 273 type Type = Self; 274 } 275 276 unsafe impl<'a> FromValue<'a> for CellRendererState { 277 type Checker = glib::value::GenericValueTypeChecker<Self>; 278 from_value(value: &'a glib::Value) -> Self279 unsafe fn from_value(value: &'a glib::Value) -> Self { 280 skip_assert_initialized!(); 281 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 282 } 283 } 284 285 impl ToValue for CellRendererState { to_value(&self) -> glib::Value286 fn to_value(&self) -> glib::Value { 287 let mut value = glib::Value::for_value_type::<Self>(); 288 unsafe { 289 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 290 } 291 value 292 } 293 value_type(&self) -> glib::Type294 fn value_type(&self) -> glib::Type { 295 Self::static_type() 296 } 297 } 298 299 bitflags! { 300 #[doc(alias = "GtkDestDefaults")] 301 pub struct DestDefaults: u32 { 302 #[doc(alias = "GTK_DEST_DEFAULT_MOTION")] 303 const MOTION = ffi::GTK_DEST_DEFAULT_MOTION as u32; 304 #[doc(alias = "GTK_DEST_DEFAULT_HIGHLIGHT")] 305 const HIGHLIGHT = ffi::GTK_DEST_DEFAULT_HIGHLIGHT as u32; 306 #[doc(alias = "GTK_DEST_DEFAULT_DROP")] 307 const DROP = ffi::GTK_DEST_DEFAULT_DROP as u32; 308 #[doc(alias = "GTK_DEST_DEFAULT_ALL")] 309 const ALL = ffi::GTK_DEST_DEFAULT_ALL as u32; 310 } 311 } 312 313 impl fmt::Display for DestDefaults { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result314 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 315 <Self as fmt::Debug>::fmt(self, f) 316 } 317 } 318 319 #[doc(hidden)] 320 impl IntoGlib for DestDefaults { 321 type GlibType = ffi::GtkDestDefaults; 322 into_glib(self) -> ffi::GtkDestDefaults323 fn into_glib(self) -> ffi::GtkDestDefaults { 324 self.bits() 325 } 326 } 327 328 #[doc(hidden)] 329 impl FromGlib<ffi::GtkDestDefaults> for DestDefaults { from_glib(value: ffi::GtkDestDefaults) -> Self330 unsafe fn from_glib(value: ffi::GtkDestDefaults) -> Self { 331 skip_assert_initialized!(); 332 Self::from_bits_truncate(value) 333 } 334 } 335 336 impl StaticType for DestDefaults { static_type() -> Type337 fn static_type() -> Type { 338 unsafe { from_glib(ffi::gtk_dest_defaults_get_type()) } 339 } 340 } 341 342 impl glib::value::ValueType for DestDefaults { 343 type Type = Self; 344 } 345 346 unsafe impl<'a> FromValue<'a> for DestDefaults { 347 type Checker = glib::value::GenericValueTypeChecker<Self>; 348 from_value(value: &'a glib::Value) -> Self349 unsafe fn from_value(value: &'a glib::Value) -> Self { 350 skip_assert_initialized!(); 351 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 352 } 353 } 354 355 impl ToValue for DestDefaults { to_value(&self) -> glib::Value356 fn to_value(&self) -> glib::Value { 357 let mut value = glib::Value::for_value_type::<Self>(); 358 unsafe { 359 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 360 } 361 value 362 } 363 value_type(&self) -> glib::Type364 fn value_type(&self) -> glib::Type { 365 Self::static_type() 366 } 367 } 368 369 bitflags! { 370 #[doc(alias = "GtkDialogFlags")] 371 pub struct DialogFlags: u32 { 372 #[doc(alias = "GTK_DIALOG_MODAL")] 373 const MODAL = ffi::GTK_DIALOG_MODAL as u32; 374 #[doc(alias = "GTK_DIALOG_DESTROY_WITH_PARENT")] 375 const DESTROY_WITH_PARENT = ffi::GTK_DIALOG_DESTROY_WITH_PARENT as u32; 376 #[doc(alias = "GTK_DIALOG_USE_HEADER_BAR")] 377 const USE_HEADER_BAR = ffi::GTK_DIALOG_USE_HEADER_BAR as u32; 378 } 379 } 380 381 impl fmt::Display for DialogFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result382 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 383 <Self as fmt::Debug>::fmt(self, f) 384 } 385 } 386 387 #[doc(hidden)] 388 impl IntoGlib for DialogFlags { 389 type GlibType = ffi::GtkDialogFlags; 390 into_glib(self) -> ffi::GtkDialogFlags391 fn into_glib(self) -> ffi::GtkDialogFlags { 392 self.bits() 393 } 394 } 395 396 #[doc(hidden)] 397 impl FromGlib<ffi::GtkDialogFlags> for DialogFlags { from_glib(value: ffi::GtkDialogFlags) -> Self398 unsafe fn from_glib(value: ffi::GtkDialogFlags) -> Self { 399 skip_assert_initialized!(); 400 Self::from_bits_truncate(value) 401 } 402 } 403 404 impl StaticType for DialogFlags { static_type() -> Type405 fn static_type() -> Type { 406 unsafe { from_glib(ffi::gtk_dialog_flags_get_type()) } 407 } 408 } 409 410 impl glib::value::ValueType for DialogFlags { 411 type Type = Self; 412 } 413 414 unsafe impl<'a> FromValue<'a> for DialogFlags { 415 type Checker = glib::value::GenericValueTypeChecker<Self>; 416 from_value(value: &'a glib::Value) -> Self417 unsafe fn from_value(value: &'a glib::Value) -> Self { 418 skip_assert_initialized!(); 419 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 420 } 421 } 422 423 impl ToValue for DialogFlags { to_value(&self) -> glib::Value424 fn to_value(&self) -> glib::Value { 425 let mut value = glib::Value::for_value_type::<Self>(); 426 unsafe { 427 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 428 } 429 value 430 } 431 value_type(&self) -> glib::Type432 fn value_type(&self) -> glib::Type { 433 Self::static_type() 434 } 435 } 436 437 #[cfg(any(feature = "v3_24", feature = "dox"))] 438 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 439 bitflags! { 440 #[doc(alias = "GtkEventControllerScrollFlags")] 441 pub struct EventControllerScrollFlags: u32 { 442 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_NONE")] 443 const NONE = ffi::GTK_EVENT_CONTROLLER_SCROLL_NONE as u32; 444 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_VERTICAL")] 445 const VERTICAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_VERTICAL as u32; 446 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL")] 447 const HORIZONTAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL as u32; 448 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_DISCRETE")] 449 const DISCRETE = ffi::GTK_EVENT_CONTROLLER_SCROLL_DISCRETE as u32; 450 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_KINETIC")] 451 const KINETIC = ffi::GTK_EVENT_CONTROLLER_SCROLL_KINETIC as u32; 452 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES")] 453 const BOTH_AXES = ffi::GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES as u32; 454 } 455 } 456 457 #[cfg(any(feature = "v3_24", feature = "dox"))] 458 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 459 impl fmt::Display for EventControllerScrollFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result460 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 461 <Self as fmt::Debug>::fmt(self, f) 462 } 463 } 464 465 #[cfg(any(feature = "v3_24", feature = "dox"))] 466 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 467 #[doc(hidden)] 468 impl IntoGlib for EventControllerScrollFlags { 469 type GlibType = ffi::GtkEventControllerScrollFlags; 470 into_glib(self) -> ffi::GtkEventControllerScrollFlags471 fn into_glib(self) -> ffi::GtkEventControllerScrollFlags { 472 self.bits() 473 } 474 } 475 476 #[cfg(any(feature = "v3_24", feature = "dox"))] 477 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 478 #[doc(hidden)] 479 impl FromGlib<ffi::GtkEventControllerScrollFlags> for EventControllerScrollFlags { from_glib(value: ffi::GtkEventControllerScrollFlags) -> Self480 unsafe fn from_glib(value: ffi::GtkEventControllerScrollFlags) -> Self { 481 skip_assert_initialized!(); 482 Self::from_bits_truncate(value) 483 } 484 } 485 486 #[cfg(any(feature = "v3_24", feature = "dox"))] 487 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 488 impl StaticType for EventControllerScrollFlags { static_type() -> Type489 fn static_type() -> Type { 490 unsafe { from_glib(ffi::gtk_event_controller_scroll_flags_get_type()) } 491 } 492 } 493 494 #[cfg(any(feature = "v3_24", feature = "dox"))] 495 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 496 impl glib::value::ValueType for EventControllerScrollFlags { 497 type Type = Self; 498 } 499 500 #[cfg(any(feature = "v3_24", feature = "dox"))] 501 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 502 unsafe impl<'a> FromValue<'a> for EventControllerScrollFlags { 503 type Checker = glib::value::GenericValueTypeChecker<Self>; 504 from_value(value: &'a glib::Value) -> Self505 unsafe fn from_value(value: &'a glib::Value) -> Self { 506 skip_assert_initialized!(); 507 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 508 } 509 } 510 511 #[cfg(any(feature = "v3_24", feature = "dox"))] 512 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 513 impl ToValue for EventControllerScrollFlags { to_value(&self) -> glib::Value514 fn to_value(&self) -> glib::Value { 515 let mut value = glib::Value::for_value_type::<Self>(); 516 unsafe { 517 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 518 } 519 value 520 } 521 value_type(&self) -> glib::Type522 fn value_type(&self) -> glib::Type { 523 Self::static_type() 524 } 525 } 526 527 bitflags! { 528 #[doc(alias = "GtkFileFilterFlags")] 529 pub struct FileFilterFlags: u32 { 530 #[doc(alias = "GTK_FILE_FILTER_FILENAME")] 531 const FILENAME = ffi::GTK_FILE_FILTER_FILENAME as u32; 532 #[doc(alias = "GTK_FILE_FILTER_URI")] 533 const URI = ffi::GTK_FILE_FILTER_URI as u32; 534 #[doc(alias = "GTK_FILE_FILTER_DISPLAY_NAME")] 535 const DISPLAY_NAME = ffi::GTK_FILE_FILTER_DISPLAY_NAME as u32; 536 #[doc(alias = "GTK_FILE_FILTER_MIME_TYPE")] 537 const MIME_TYPE = ffi::GTK_FILE_FILTER_MIME_TYPE as u32; 538 } 539 } 540 541 impl fmt::Display for FileFilterFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result542 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 543 <Self as fmt::Debug>::fmt(self, f) 544 } 545 } 546 547 #[doc(hidden)] 548 impl IntoGlib for FileFilterFlags { 549 type GlibType = ffi::GtkFileFilterFlags; 550 into_glib(self) -> ffi::GtkFileFilterFlags551 fn into_glib(self) -> ffi::GtkFileFilterFlags { 552 self.bits() 553 } 554 } 555 556 #[doc(hidden)] 557 impl FromGlib<ffi::GtkFileFilterFlags> for FileFilterFlags { from_glib(value: ffi::GtkFileFilterFlags) -> Self558 unsafe fn from_glib(value: ffi::GtkFileFilterFlags) -> Self { 559 skip_assert_initialized!(); 560 Self::from_bits_truncate(value) 561 } 562 } 563 564 impl StaticType for FileFilterFlags { static_type() -> Type565 fn static_type() -> Type { 566 unsafe { from_glib(ffi::gtk_file_filter_flags_get_type()) } 567 } 568 } 569 570 impl glib::value::ValueType for FileFilterFlags { 571 type Type = Self; 572 } 573 574 unsafe impl<'a> FromValue<'a> for FileFilterFlags { 575 type Checker = glib::value::GenericValueTypeChecker<Self>; 576 from_value(value: &'a glib::Value) -> Self577 unsafe fn from_value(value: &'a glib::Value) -> Self { 578 skip_assert_initialized!(); 579 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 580 } 581 } 582 583 impl ToValue for FileFilterFlags { to_value(&self) -> glib::Value584 fn to_value(&self) -> glib::Value { 585 let mut value = glib::Value::for_value_type::<Self>(); 586 unsafe { 587 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 588 } 589 value 590 } 591 value_type(&self) -> glib::Type592 fn value_type(&self) -> glib::Type { 593 Self::static_type() 594 } 595 } 596 597 #[cfg(any(feature = "v3_24", feature = "dox"))] 598 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 599 bitflags! { 600 #[doc(alias = "GtkFontChooserLevel")] 601 pub struct FontChooserLevel: u32 { 602 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FAMILY")] 603 const FAMILY = ffi::GTK_FONT_CHOOSER_LEVEL_FAMILY as u32; 604 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_STYLE")] 605 const STYLE = ffi::GTK_FONT_CHOOSER_LEVEL_STYLE as u32; 606 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_SIZE")] 607 const SIZE = ffi::GTK_FONT_CHOOSER_LEVEL_SIZE as u32; 608 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_VARIATIONS")] 609 const VARIATIONS = ffi::GTK_FONT_CHOOSER_LEVEL_VARIATIONS as u32; 610 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FEATURES")] 611 const FEATURES = ffi::GTK_FONT_CHOOSER_LEVEL_FEATURES as u32; 612 } 613 } 614 615 #[cfg(any(feature = "v3_24", feature = "dox"))] 616 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 617 impl fmt::Display for FontChooserLevel { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result618 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 619 <Self as fmt::Debug>::fmt(self, f) 620 } 621 } 622 623 #[cfg(any(feature = "v3_24", feature = "dox"))] 624 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 625 #[doc(hidden)] 626 impl IntoGlib for FontChooserLevel { 627 type GlibType = ffi::GtkFontChooserLevel; 628 into_glib(self) -> ffi::GtkFontChooserLevel629 fn into_glib(self) -> ffi::GtkFontChooserLevel { 630 self.bits() 631 } 632 } 633 634 #[cfg(any(feature = "v3_24", feature = "dox"))] 635 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 636 #[doc(hidden)] 637 impl FromGlib<ffi::GtkFontChooserLevel> for FontChooserLevel { from_glib(value: ffi::GtkFontChooserLevel) -> Self638 unsafe fn from_glib(value: ffi::GtkFontChooserLevel) -> Self { 639 skip_assert_initialized!(); 640 Self::from_bits_truncate(value) 641 } 642 } 643 644 #[cfg(any(feature = "v3_24", feature = "dox"))] 645 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 646 impl StaticType for FontChooserLevel { static_type() -> Type647 fn static_type() -> Type { 648 unsafe { from_glib(ffi::gtk_font_chooser_level_get_type()) } 649 } 650 } 651 652 #[cfg(any(feature = "v3_24", feature = "dox"))] 653 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 654 impl glib::value::ValueType for FontChooserLevel { 655 type Type = Self; 656 } 657 658 #[cfg(any(feature = "v3_24", feature = "dox"))] 659 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 660 unsafe impl<'a> FromValue<'a> for FontChooserLevel { 661 type Checker = glib::value::GenericValueTypeChecker<Self>; 662 from_value(value: &'a glib::Value) -> Self663 unsafe fn from_value(value: &'a glib::Value) -> Self { 664 skip_assert_initialized!(); 665 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 666 } 667 } 668 669 #[cfg(any(feature = "v3_24", feature = "dox"))] 670 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))] 671 impl ToValue for FontChooserLevel { to_value(&self) -> glib::Value672 fn to_value(&self) -> glib::Value { 673 let mut value = glib::Value::for_value_type::<Self>(); 674 unsafe { 675 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 676 } 677 value 678 } 679 value_type(&self) -> glib::Type680 fn value_type(&self) -> glib::Type { 681 Self::static_type() 682 } 683 } 684 685 bitflags! { 686 #[doc(alias = "GtkIconLookupFlags")] 687 pub struct IconLookupFlags: u32 { 688 #[doc(alias = "GTK_ICON_LOOKUP_NO_SVG")] 689 const NO_SVG = ffi::GTK_ICON_LOOKUP_NO_SVG as u32; 690 #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SVG")] 691 const FORCE_SVG = ffi::GTK_ICON_LOOKUP_FORCE_SVG as u32; 692 #[doc(alias = "GTK_ICON_LOOKUP_USE_BUILTIN")] 693 const USE_BUILTIN = ffi::GTK_ICON_LOOKUP_USE_BUILTIN as u32; 694 #[doc(alias = "GTK_ICON_LOOKUP_GENERIC_FALLBACK")] 695 const GENERIC_FALLBACK = ffi::GTK_ICON_LOOKUP_GENERIC_FALLBACK as u32; 696 #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SIZE")] 697 const FORCE_SIZE = ffi::GTK_ICON_LOOKUP_FORCE_SIZE as u32; 698 #[doc(alias = "GTK_ICON_LOOKUP_FORCE_REGULAR")] 699 const FORCE_REGULAR = ffi::GTK_ICON_LOOKUP_FORCE_REGULAR as u32; 700 #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SYMBOLIC")] 701 const FORCE_SYMBOLIC = ffi::GTK_ICON_LOOKUP_FORCE_SYMBOLIC as u32; 702 #[doc(alias = "GTK_ICON_LOOKUP_DIR_LTR")] 703 const DIR_LTR = ffi::GTK_ICON_LOOKUP_DIR_LTR as u32; 704 #[doc(alias = "GTK_ICON_LOOKUP_DIR_RTL")] 705 const DIR_RTL = ffi::GTK_ICON_LOOKUP_DIR_RTL as u32; 706 } 707 } 708 709 impl fmt::Display for IconLookupFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result710 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 711 <Self as fmt::Debug>::fmt(self, f) 712 } 713 } 714 715 #[doc(hidden)] 716 impl IntoGlib for IconLookupFlags { 717 type GlibType = ffi::GtkIconLookupFlags; 718 into_glib(self) -> ffi::GtkIconLookupFlags719 fn into_glib(self) -> ffi::GtkIconLookupFlags { 720 self.bits() 721 } 722 } 723 724 #[doc(hidden)] 725 impl FromGlib<ffi::GtkIconLookupFlags> for IconLookupFlags { from_glib(value: ffi::GtkIconLookupFlags) -> Self726 unsafe fn from_glib(value: ffi::GtkIconLookupFlags) -> Self { 727 skip_assert_initialized!(); 728 Self::from_bits_truncate(value) 729 } 730 } 731 732 impl StaticType for IconLookupFlags { static_type() -> Type733 fn static_type() -> Type { 734 unsafe { from_glib(ffi::gtk_icon_lookup_flags_get_type()) } 735 } 736 } 737 738 impl glib::value::ValueType for IconLookupFlags { 739 type Type = Self; 740 } 741 742 unsafe impl<'a> FromValue<'a> for IconLookupFlags { 743 type Checker = glib::value::GenericValueTypeChecker<Self>; 744 from_value(value: &'a glib::Value) -> Self745 unsafe fn from_value(value: &'a glib::Value) -> Self { 746 skip_assert_initialized!(); 747 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 748 } 749 } 750 751 impl ToValue for IconLookupFlags { to_value(&self) -> glib::Value752 fn to_value(&self) -> glib::Value { 753 let mut value = glib::Value::for_value_type::<Self>(); 754 unsafe { 755 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 756 } 757 value 758 } 759 value_type(&self) -> glib::Type760 fn value_type(&self) -> glib::Type { 761 Self::static_type() 762 } 763 } 764 765 bitflags! { 766 #[doc(alias = "GtkInputHints")] 767 pub struct InputHints: u32 { 768 #[doc(alias = "GTK_INPUT_HINT_NONE")] 769 const NONE = ffi::GTK_INPUT_HINT_NONE as u32; 770 #[doc(alias = "GTK_INPUT_HINT_SPELLCHECK")] 771 const SPELLCHECK = ffi::GTK_INPUT_HINT_SPELLCHECK as u32; 772 #[doc(alias = "GTK_INPUT_HINT_NO_SPELLCHECK")] 773 const NO_SPELLCHECK = ffi::GTK_INPUT_HINT_NO_SPELLCHECK as u32; 774 #[doc(alias = "GTK_INPUT_HINT_WORD_COMPLETION")] 775 const WORD_COMPLETION = ffi::GTK_INPUT_HINT_WORD_COMPLETION as u32; 776 #[doc(alias = "GTK_INPUT_HINT_LOWERCASE")] 777 const LOWERCASE = ffi::GTK_INPUT_HINT_LOWERCASE as u32; 778 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_CHARS")] 779 const UPPERCASE_CHARS = ffi::GTK_INPUT_HINT_UPPERCASE_CHARS as u32; 780 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_WORDS")] 781 const UPPERCASE_WORDS = ffi::GTK_INPUT_HINT_UPPERCASE_WORDS as u32; 782 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_SENTENCES")] 783 const UPPERCASE_SENTENCES = ffi::GTK_INPUT_HINT_UPPERCASE_SENTENCES as u32; 784 #[doc(alias = "GTK_INPUT_HINT_INHIBIT_OSK")] 785 const INHIBIT_OSK = ffi::GTK_INPUT_HINT_INHIBIT_OSK as u32; 786 #[doc(alias = "GTK_INPUT_HINT_VERTICAL_WRITING")] 787 const VERTICAL_WRITING = ffi::GTK_INPUT_HINT_VERTICAL_WRITING as u32; 788 #[cfg(any(feature = "v3_22_20", feature = "dox"))] 789 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22_20")))] 790 #[doc(alias = "GTK_INPUT_HINT_EMOJI")] 791 const EMOJI = ffi::GTK_INPUT_HINT_EMOJI as u32; 792 #[cfg(any(feature = "v3_22_20", feature = "dox"))] 793 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22_20")))] 794 #[doc(alias = "GTK_INPUT_HINT_NO_EMOJI")] 795 const NO_EMOJI = ffi::GTK_INPUT_HINT_NO_EMOJI as u32; 796 } 797 } 798 799 impl fmt::Display for InputHints { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result800 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 801 <Self as fmt::Debug>::fmt(self, f) 802 } 803 } 804 805 #[doc(hidden)] 806 impl IntoGlib for InputHints { 807 type GlibType = ffi::GtkInputHints; 808 into_glib(self) -> ffi::GtkInputHints809 fn into_glib(self) -> ffi::GtkInputHints { 810 self.bits() 811 } 812 } 813 814 #[doc(hidden)] 815 impl FromGlib<ffi::GtkInputHints> for InputHints { from_glib(value: ffi::GtkInputHints) -> Self816 unsafe fn from_glib(value: ffi::GtkInputHints) -> Self { 817 skip_assert_initialized!(); 818 Self::from_bits_truncate(value) 819 } 820 } 821 822 impl StaticType for InputHints { static_type() -> Type823 fn static_type() -> Type { 824 unsafe { from_glib(ffi::gtk_input_hints_get_type()) } 825 } 826 } 827 828 impl glib::value::ValueType for InputHints { 829 type Type = Self; 830 } 831 832 unsafe impl<'a> FromValue<'a> for InputHints { 833 type Checker = glib::value::GenericValueTypeChecker<Self>; 834 from_value(value: &'a glib::Value) -> Self835 unsafe fn from_value(value: &'a glib::Value) -> Self { 836 skip_assert_initialized!(); 837 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 838 } 839 } 840 841 impl ToValue for InputHints { to_value(&self) -> glib::Value842 fn to_value(&self) -> glib::Value { 843 let mut value = glib::Value::for_value_type::<Self>(); 844 unsafe { 845 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 846 } 847 value 848 } 849 value_type(&self) -> glib::Type850 fn value_type(&self) -> glib::Type { 851 Self::static_type() 852 } 853 } 854 855 bitflags! { 856 #[doc(alias = "GtkJunctionSides")] 857 pub struct JunctionSides: u32 { 858 #[doc(alias = "GTK_JUNCTION_NONE")] 859 const NONE = ffi::GTK_JUNCTION_NONE as u32; 860 #[doc(alias = "GTK_JUNCTION_CORNER_TOPLEFT")] 861 const CORNER_TOPLEFT = ffi::GTK_JUNCTION_CORNER_TOPLEFT as u32; 862 #[doc(alias = "GTK_JUNCTION_CORNER_TOPRIGHT")] 863 const CORNER_TOPRIGHT = ffi::GTK_JUNCTION_CORNER_TOPRIGHT as u32; 864 #[doc(alias = "GTK_JUNCTION_CORNER_BOTTOMLEFT")] 865 const CORNER_BOTTOMLEFT = ffi::GTK_JUNCTION_CORNER_BOTTOMLEFT as u32; 866 #[doc(alias = "GTK_JUNCTION_CORNER_BOTTOMRIGHT")] 867 const CORNER_BOTTOMRIGHT = ffi::GTK_JUNCTION_CORNER_BOTTOMRIGHT as u32; 868 #[doc(alias = "GTK_JUNCTION_TOP")] 869 const TOP = ffi::GTK_JUNCTION_TOP as u32; 870 #[doc(alias = "GTK_JUNCTION_BOTTOM")] 871 const BOTTOM = ffi::GTK_JUNCTION_BOTTOM as u32; 872 #[doc(alias = "GTK_JUNCTION_LEFT")] 873 const LEFT = ffi::GTK_JUNCTION_LEFT as u32; 874 #[doc(alias = "GTK_JUNCTION_RIGHT")] 875 const RIGHT = ffi::GTK_JUNCTION_RIGHT as u32; 876 } 877 } 878 879 impl fmt::Display for JunctionSides { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result880 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 881 <Self as fmt::Debug>::fmt(self, f) 882 } 883 } 884 885 #[doc(hidden)] 886 impl IntoGlib for JunctionSides { 887 type GlibType = ffi::GtkJunctionSides; 888 into_glib(self) -> ffi::GtkJunctionSides889 fn into_glib(self) -> ffi::GtkJunctionSides { 890 self.bits() 891 } 892 } 893 894 #[doc(hidden)] 895 impl FromGlib<ffi::GtkJunctionSides> for JunctionSides { from_glib(value: ffi::GtkJunctionSides) -> Self896 unsafe fn from_glib(value: ffi::GtkJunctionSides) -> Self { 897 skip_assert_initialized!(); 898 Self::from_bits_truncate(value) 899 } 900 } 901 902 impl StaticType for JunctionSides { static_type() -> Type903 fn static_type() -> Type { 904 unsafe { from_glib(ffi::gtk_junction_sides_get_type()) } 905 } 906 } 907 908 impl glib::value::ValueType for JunctionSides { 909 type Type = Self; 910 } 911 912 unsafe impl<'a> FromValue<'a> for JunctionSides { 913 type Checker = glib::value::GenericValueTypeChecker<Self>; 914 from_value(value: &'a glib::Value) -> Self915 unsafe fn from_value(value: &'a glib::Value) -> Self { 916 skip_assert_initialized!(); 917 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 918 } 919 } 920 921 impl ToValue for JunctionSides { to_value(&self) -> glib::Value922 fn to_value(&self) -> glib::Value { 923 let mut value = glib::Value::for_value_type::<Self>(); 924 unsafe { 925 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 926 } 927 value 928 } 929 value_type(&self) -> glib::Type930 fn value_type(&self) -> glib::Type { 931 Self::static_type() 932 } 933 } 934 935 bitflags! { 936 #[doc(alias = "GtkPlacesOpenFlags")] 937 pub struct PlacesOpenFlags: u32 { 938 #[doc(alias = "GTK_PLACES_OPEN_NORMAL")] 939 const NORMAL = ffi::GTK_PLACES_OPEN_NORMAL as u32; 940 #[doc(alias = "GTK_PLACES_OPEN_NEW_TAB")] 941 const NEW_TAB = ffi::GTK_PLACES_OPEN_NEW_TAB as u32; 942 #[doc(alias = "GTK_PLACES_OPEN_NEW_WINDOW")] 943 const NEW_WINDOW = ffi::GTK_PLACES_OPEN_NEW_WINDOW as u32; 944 } 945 } 946 947 impl fmt::Display for PlacesOpenFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result948 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 949 <Self as fmt::Debug>::fmt(self, f) 950 } 951 } 952 953 #[doc(hidden)] 954 impl IntoGlib for PlacesOpenFlags { 955 type GlibType = ffi::GtkPlacesOpenFlags; 956 into_glib(self) -> ffi::GtkPlacesOpenFlags957 fn into_glib(self) -> ffi::GtkPlacesOpenFlags { 958 self.bits() 959 } 960 } 961 962 #[doc(hidden)] 963 impl FromGlib<ffi::GtkPlacesOpenFlags> for PlacesOpenFlags { from_glib(value: ffi::GtkPlacesOpenFlags) -> Self964 unsafe fn from_glib(value: ffi::GtkPlacesOpenFlags) -> Self { 965 skip_assert_initialized!(); 966 Self::from_bits_truncate(value) 967 } 968 } 969 970 impl StaticType for PlacesOpenFlags { static_type() -> Type971 fn static_type() -> Type { 972 unsafe { from_glib(ffi::gtk_places_open_flags_get_type()) } 973 } 974 } 975 976 impl glib::value::ValueType for PlacesOpenFlags { 977 type Type = Self; 978 } 979 980 unsafe impl<'a> FromValue<'a> for PlacesOpenFlags { 981 type Checker = glib::value::GenericValueTypeChecker<Self>; 982 from_value(value: &'a glib::Value) -> Self983 unsafe fn from_value(value: &'a glib::Value) -> Self { 984 skip_assert_initialized!(); 985 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 986 } 987 } 988 989 impl ToValue for PlacesOpenFlags { to_value(&self) -> glib::Value990 fn to_value(&self) -> glib::Value { 991 let mut value = glib::Value::for_value_type::<Self>(); 992 unsafe { 993 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 994 } 995 value 996 } 997 value_type(&self) -> glib::Type998 fn value_type(&self) -> glib::Type { 999 Self::static_type() 1000 } 1001 } 1002 1003 bitflags! { 1004 #[doc(alias = "GtkRecentFilterFlags")] 1005 pub struct RecentFilterFlags: u32 { 1006 #[doc(alias = "GTK_RECENT_FILTER_URI")] 1007 const URI = ffi::GTK_RECENT_FILTER_URI as u32; 1008 #[doc(alias = "GTK_RECENT_FILTER_DISPLAY_NAME")] 1009 const DISPLAY_NAME = ffi::GTK_RECENT_FILTER_DISPLAY_NAME as u32; 1010 #[doc(alias = "GTK_RECENT_FILTER_MIME_TYPE")] 1011 const MIME_TYPE = ffi::GTK_RECENT_FILTER_MIME_TYPE as u32; 1012 #[doc(alias = "GTK_RECENT_FILTER_APPLICATION")] 1013 const APPLICATION = ffi::GTK_RECENT_FILTER_APPLICATION as u32; 1014 #[doc(alias = "GTK_RECENT_FILTER_GROUP")] 1015 const GROUP = ffi::GTK_RECENT_FILTER_GROUP as u32; 1016 #[doc(alias = "GTK_RECENT_FILTER_AGE")] 1017 const AGE = ffi::GTK_RECENT_FILTER_AGE as u32; 1018 } 1019 } 1020 1021 impl fmt::Display for RecentFilterFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1022 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1023 <Self as fmt::Debug>::fmt(self, f) 1024 } 1025 } 1026 1027 #[doc(hidden)] 1028 impl IntoGlib for RecentFilterFlags { 1029 type GlibType = ffi::GtkRecentFilterFlags; 1030 into_glib(self) -> ffi::GtkRecentFilterFlags1031 fn into_glib(self) -> ffi::GtkRecentFilterFlags { 1032 self.bits() 1033 } 1034 } 1035 1036 #[doc(hidden)] 1037 impl FromGlib<ffi::GtkRecentFilterFlags> for RecentFilterFlags { from_glib(value: ffi::GtkRecentFilterFlags) -> Self1038 unsafe fn from_glib(value: ffi::GtkRecentFilterFlags) -> Self { 1039 skip_assert_initialized!(); 1040 Self::from_bits_truncate(value) 1041 } 1042 } 1043 1044 impl StaticType for RecentFilterFlags { static_type() -> Type1045 fn static_type() -> Type { 1046 unsafe { from_glib(ffi::gtk_recent_filter_flags_get_type()) } 1047 } 1048 } 1049 1050 impl glib::value::ValueType for RecentFilterFlags { 1051 type Type = Self; 1052 } 1053 1054 unsafe impl<'a> FromValue<'a> for RecentFilterFlags { 1055 type Checker = glib::value::GenericValueTypeChecker<Self>; 1056 from_value(value: &'a glib::Value) -> Self1057 unsafe fn from_value(value: &'a glib::Value) -> Self { 1058 skip_assert_initialized!(); 1059 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1060 } 1061 } 1062 1063 impl ToValue for RecentFilterFlags { to_value(&self) -> glib::Value1064 fn to_value(&self) -> glib::Value { 1065 let mut value = glib::Value::for_value_type::<Self>(); 1066 unsafe { 1067 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1068 } 1069 value 1070 } 1071 value_type(&self) -> glib::Type1072 fn value_type(&self) -> glib::Type { 1073 Self::static_type() 1074 } 1075 } 1076 1077 bitflags! { 1078 #[doc(alias = "GtkRegionFlags")] 1079 pub struct RegionFlags: u32 { 1080 #[doc(alias = "GTK_REGION_EVEN")] 1081 const EVEN = ffi::GTK_REGION_EVEN as u32; 1082 #[doc(alias = "GTK_REGION_ODD")] 1083 const ODD = ffi::GTK_REGION_ODD as u32; 1084 #[doc(alias = "GTK_REGION_FIRST")] 1085 const FIRST = ffi::GTK_REGION_FIRST as u32; 1086 #[doc(alias = "GTK_REGION_LAST")] 1087 const LAST = ffi::GTK_REGION_LAST as u32; 1088 #[doc(alias = "GTK_REGION_ONLY")] 1089 const ONLY = ffi::GTK_REGION_ONLY as u32; 1090 #[doc(alias = "GTK_REGION_SORTED")] 1091 const SORTED = ffi::GTK_REGION_SORTED as u32; 1092 } 1093 } 1094 1095 impl fmt::Display for RegionFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1096 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1097 <Self as fmt::Debug>::fmt(self, f) 1098 } 1099 } 1100 1101 #[doc(hidden)] 1102 impl IntoGlib for RegionFlags { 1103 type GlibType = ffi::GtkRegionFlags; 1104 into_glib(self) -> ffi::GtkRegionFlags1105 fn into_glib(self) -> ffi::GtkRegionFlags { 1106 self.bits() 1107 } 1108 } 1109 1110 #[doc(hidden)] 1111 impl FromGlib<ffi::GtkRegionFlags> for RegionFlags { from_glib(value: ffi::GtkRegionFlags) -> Self1112 unsafe fn from_glib(value: ffi::GtkRegionFlags) -> Self { 1113 skip_assert_initialized!(); 1114 Self::from_bits_truncate(value) 1115 } 1116 } 1117 1118 impl StaticType for RegionFlags { static_type() -> Type1119 fn static_type() -> Type { 1120 unsafe { from_glib(ffi::gtk_region_flags_get_type()) } 1121 } 1122 } 1123 1124 impl glib::value::ValueType for RegionFlags { 1125 type Type = Self; 1126 } 1127 1128 unsafe impl<'a> FromValue<'a> for RegionFlags { 1129 type Checker = glib::value::GenericValueTypeChecker<Self>; 1130 from_value(value: &'a glib::Value) -> Self1131 unsafe fn from_value(value: &'a glib::Value) -> Self { 1132 skip_assert_initialized!(); 1133 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1134 } 1135 } 1136 1137 impl ToValue for RegionFlags { to_value(&self) -> glib::Value1138 fn to_value(&self) -> glib::Value { 1139 let mut value = glib::Value::for_value_type::<Self>(); 1140 unsafe { 1141 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1142 } 1143 value 1144 } 1145 value_type(&self) -> glib::Type1146 fn value_type(&self) -> glib::Type { 1147 Self::static_type() 1148 } 1149 } 1150 1151 bitflags! { 1152 #[doc(alias = "GtkStateFlags")] 1153 pub struct StateFlags: u32 { 1154 #[doc(alias = "GTK_STATE_FLAG_NORMAL")] 1155 const NORMAL = ffi::GTK_STATE_FLAG_NORMAL as u32; 1156 #[doc(alias = "GTK_STATE_FLAG_ACTIVE")] 1157 const ACTIVE = ffi::GTK_STATE_FLAG_ACTIVE as u32; 1158 #[doc(alias = "GTK_STATE_FLAG_PRELIGHT")] 1159 const PRELIGHT = ffi::GTK_STATE_FLAG_PRELIGHT as u32; 1160 #[doc(alias = "GTK_STATE_FLAG_SELECTED")] 1161 const SELECTED = ffi::GTK_STATE_FLAG_SELECTED as u32; 1162 #[doc(alias = "GTK_STATE_FLAG_INSENSITIVE")] 1163 const INSENSITIVE = ffi::GTK_STATE_FLAG_INSENSITIVE as u32; 1164 #[doc(alias = "GTK_STATE_FLAG_INCONSISTENT")] 1165 const INCONSISTENT = ffi::GTK_STATE_FLAG_INCONSISTENT as u32; 1166 #[doc(alias = "GTK_STATE_FLAG_FOCUSED")] 1167 const FOCUSED = ffi::GTK_STATE_FLAG_FOCUSED as u32; 1168 #[doc(alias = "GTK_STATE_FLAG_BACKDROP")] 1169 const BACKDROP = ffi::GTK_STATE_FLAG_BACKDROP as u32; 1170 #[doc(alias = "GTK_STATE_FLAG_DIR_LTR")] 1171 const DIR_LTR = ffi::GTK_STATE_FLAG_DIR_LTR as u32; 1172 #[doc(alias = "GTK_STATE_FLAG_DIR_RTL")] 1173 const DIR_RTL = ffi::GTK_STATE_FLAG_DIR_RTL as u32; 1174 #[doc(alias = "GTK_STATE_FLAG_LINK")] 1175 const LINK = ffi::GTK_STATE_FLAG_LINK as u32; 1176 #[doc(alias = "GTK_STATE_FLAG_VISITED")] 1177 const VISITED = ffi::GTK_STATE_FLAG_VISITED as u32; 1178 #[doc(alias = "GTK_STATE_FLAG_CHECKED")] 1179 const CHECKED = ffi::GTK_STATE_FLAG_CHECKED as u32; 1180 #[doc(alias = "GTK_STATE_FLAG_DROP_ACTIVE")] 1181 const DROP_ACTIVE = ffi::GTK_STATE_FLAG_DROP_ACTIVE as u32; 1182 } 1183 } 1184 1185 impl fmt::Display for StateFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1186 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1187 <Self as fmt::Debug>::fmt(self, f) 1188 } 1189 } 1190 1191 #[doc(hidden)] 1192 impl IntoGlib for StateFlags { 1193 type GlibType = ffi::GtkStateFlags; 1194 into_glib(self) -> ffi::GtkStateFlags1195 fn into_glib(self) -> ffi::GtkStateFlags { 1196 self.bits() 1197 } 1198 } 1199 1200 #[doc(hidden)] 1201 impl FromGlib<ffi::GtkStateFlags> for StateFlags { from_glib(value: ffi::GtkStateFlags) -> Self1202 unsafe fn from_glib(value: ffi::GtkStateFlags) -> Self { 1203 skip_assert_initialized!(); 1204 Self::from_bits_truncate(value) 1205 } 1206 } 1207 1208 impl StaticType for StateFlags { static_type() -> Type1209 fn static_type() -> Type { 1210 unsafe { from_glib(ffi::gtk_state_flags_get_type()) } 1211 } 1212 } 1213 1214 impl glib::value::ValueType for StateFlags { 1215 type Type = Self; 1216 } 1217 1218 unsafe impl<'a> FromValue<'a> for StateFlags { 1219 type Checker = glib::value::GenericValueTypeChecker<Self>; 1220 from_value(value: &'a glib::Value) -> Self1221 unsafe fn from_value(value: &'a glib::Value) -> Self { 1222 skip_assert_initialized!(); 1223 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1224 } 1225 } 1226 1227 impl ToValue for StateFlags { to_value(&self) -> glib::Value1228 fn to_value(&self) -> glib::Value { 1229 let mut value = glib::Value::for_value_type::<Self>(); 1230 unsafe { 1231 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1232 } 1233 value 1234 } 1235 value_type(&self) -> glib::Type1236 fn value_type(&self) -> glib::Type { 1237 Self::static_type() 1238 } 1239 } 1240 1241 #[cfg(any(feature = "v3_20", feature = "dox"))] 1242 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1243 bitflags! { 1244 #[doc(alias = "GtkStyleContextPrintFlags")] 1245 pub struct StyleContextPrintFlags: u32 { 1246 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_NONE")] 1247 const NONE = ffi::GTK_STYLE_CONTEXT_PRINT_NONE as u32; 1248 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_RECURSE")] 1249 const RECURSE = ffi::GTK_STYLE_CONTEXT_PRINT_RECURSE as u32; 1250 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE")] 1251 const SHOW_STYLE = ffi::GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE as u32; 1252 } 1253 } 1254 1255 #[cfg(any(feature = "v3_20", feature = "dox"))] 1256 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1257 impl fmt::Display for StyleContextPrintFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1258 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1259 <Self as fmt::Debug>::fmt(self, f) 1260 } 1261 } 1262 1263 #[cfg(any(feature = "v3_20", feature = "dox"))] 1264 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1265 #[doc(hidden)] 1266 impl IntoGlib for StyleContextPrintFlags { 1267 type GlibType = ffi::GtkStyleContextPrintFlags; 1268 into_glib(self) -> ffi::GtkStyleContextPrintFlags1269 fn into_glib(self) -> ffi::GtkStyleContextPrintFlags { 1270 self.bits() 1271 } 1272 } 1273 1274 #[cfg(any(feature = "v3_20", feature = "dox"))] 1275 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1276 #[doc(hidden)] 1277 impl FromGlib<ffi::GtkStyleContextPrintFlags> for StyleContextPrintFlags { from_glib(value: ffi::GtkStyleContextPrintFlags) -> Self1278 unsafe fn from_glib(value: ffi::GtkStyleContextPrintFlags) -> Self { 1279 skip_assert_initialized!(); 1280 Self::from_bits_truncate(value) 1281 } 1282 } 1283 1284 #[cfg(any(feature = "v3_20", feature = "dox"))] 1285 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1286 impl StaticType for StyleContextPrintFlags { static_type() -> Type1287 fn static_type() -> Type { 1288 unsafe { from_glib(ffi::gtk_style_context_print_flags_get_type()) } 1289 } 1290 } 1291 1292 #[cfg(any(feature = "v3_20", feature = "dox"))] 1293 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1294 impl glib::value::ValueType for StyleContextPrintFlags { 1295 type Type = Self; 1296 } 1297 1298 #[cfg(any(feature = "v3_20", feature = "dox"))] 1299 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1300 unsafe impl<'a> FromValue<'a> for StyleContextPrintFlags { 1301 type Checker = glib::value::GenericValueTypeChecker<Self>; 1302 from_value(value: &'a glib::Value) -> Self1303 unsafe fn from_value(value: &'a glib::Value) -> Self { 1304 skip_assert_initialized!(); 1305 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1306 } 1307 } 1308 1309 #[cfg(any(feature = "v3_20", feature = "dox"))] 1310 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))] 1311 impl ToValue for StyleContextPrintFlags { to_value(&self) -> glib::Value1312 fn to_value(&self) -> glib::Value { 1313 let mut value = glib::Value::for_value_type::<Self>(); 1314 unsafe { 1315 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1316 } 1317 value 1318 } 1319 value_type(&self) -> glib::Type1320 fn value_type(&self) -> glib::Type { 1321 Self::static_type() 1322 } 1323 } 1324 1325 bitflags! { 1326 #[doc(alias = "GtkTargetFlags")] 1327 pub struct TargetFlags: u32 { 1328 #[doc(alias = "GTK_TARGET_SAME_APP")] 1329 const SAME_APP = ffi::GTK_TARGET_SAME_APP as u32; 1330 #[doc(alias = "GTK_TARGET_SAME_WIDGET")] 1331 const SAME_WIDGET = ffi::GTK_TARGET_SAME_WIDGET as u32; 1332 #[doc(alias = "GTK_TARGET_OTHER_APP")] 1333 const OTHER_APP = ffi::GTK_TARGET_OTHER_APP as u32; 1334 #[doc(alias = "GTK_TARGET_OTHER_WIDGET")] 1335 const OTHER_WIDGET = ffi::GTK_TARGET_OTHER_WIDGET as u32; 1336 } 1337 } 1338 1339 impl fmt::Display for TargetFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1340 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1341 <Self as fmt::Debug>::fmt(self, f) 1342 } 1343 } 1344 1345 #[doc(hidden)] 1346 impl IntoGlib for TargetFlags { 1347 type GlibType = ffi::GtkTargetFlags; 1348 into_glib(self) -> ffi::GtkTargetFlags1349 fn into_glib(self) -> ffi::GtkTargetFlags { 1350 self.bits() 1351 } 1352 } 1353 1354 #[doc(hidden)] 1355 impl FromGlib<ffi::GtkTargetFlags> for TargetFlags { from_glib(value: ffi::GtkTargetFlags) -> Self1356 unsafe fn from_glib(value: ffi::GtkTargetFlags) -> Self { 1357 skip_assert_initialized!(); 1358 Self::from_bits_truncate(value) 1359 } 1360 } 1361 1362 impl StaticType for TargetFlags { static_type() -> Type1363 fn static_type() -> Type { 1364 unsafe { from_glib(ffi::gtk_target_flags_get_type()) } 1365 } 1366 } 1367 1368 impl glib::value::ValueType for TargetFlags { 1369 type Type = Self; 1370 } 1371 1372 unsafe impl<'a> FromValue<'a> for TargetFlags { 1373 type Checker = glib::value::GenericValueTypeChecker<Self>; 1374 from_value(value: &'a glib::Value) -> Self1375 unsafe fn from_value(value: &'a glib::Value) -> Self { 1376 skip_assert_initialized!(); 1377 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1378 } 1379 } 1380 1381 impl ToValue for TargetFlags { to_value(&self) -> glib::Value1382 fn to_value(&self) -> glib::Value { 1383 let mut value = glib::Value::for_value_type::<Self>(); 1384 unsafe { 1385 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1386 } 1387 value 1388 } 1389 value_type(&self) -> glib::Type1390 fn value_type(&self) -> glib::Type { 1391 Self::static_type() 1392 } 1393 } 1394 1395 bitflags! { 1396 #[doc(alias = "GtkTextSearchFlags")] 1397 pub struct TextSearchFlags: u32 { 1398 #[doc(alias = "GTK_TEXT_SEARCH_VISIBLE_ONLY")] 1399 const VISIBLE_ONLY = ffi::GTK_TEXT_SEARCH_VISIBLE_ONLY as u32; 1400 #[doc(alias = "GTK_TEXT_SEARCH_TEXT_ONLY")] 1401 const TEXT_ONLY = ffi::GTK_TEXT_SEARCH_TEXT_ONLY as u32; 1402 #[doc(alias = "GTK_TEXT_SEARCH_CASE_INSENSITIVE")] 1403 const CASE_INSENSITIVE = ffi::GTK_TEXT_SEARCH_CASE_INSENSITIVE as u32; 1404 } 1405 } 1406 1407 impl fmt::Display for TextSearchFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1408 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1409 <Self as fmt::Debug>::fmt(self, f) 1410 } 1411 } 1412 1413 #[doc(hidden)] 1414 impl IntoGlib for TextSearchFlags { 1415 type GlibType = ffi::GtkTextSearchFlags; 1416 into_glib(self) -> ffi::GtkTextSearchFlags1417 fn into_glib(self) -> ffi::GtkTextSearchFlags { 1418 self.bits() 1419 } 1420 } 1421 1422 #[doc(hidden)] 1423 impl FromGlib<ffi::GtkTextSearchFlags> for TextSearchFlags { from_glib(value: ffi::GtkTextSearchFlags) -> Self1424 unsafe fn from_glib(value: ffi::GtkTextSearchFlags) -> Self { 1425 skip_assert_initialized!(); 1426 Self::from_bits_truncate(value) 1427 } 1428 } 1429 1430 impl StaticType for TextSearchFlags { static_type() -> Type1431 fn static_type() -> Type { 1432 unsafe { from_glib(ffi::gtk_text_search_flags_get_type()) } 1433 } 1434 } 1435 1436 impl glib::value::ValueType for TextSearchFlags { 1437 type Type = Self; 1438 } 1439 1440 unsafe impl<'a> FromValue<'a> for TextSearchFlags { 1441 type Checker = glib::value::GenericValueTypeChecker<Self>; 1442 from_value(value: &'a glib::Value) -> Self1443 unsafe fn from_value(value: &'a glib::Value) -> Self { 1444 skip_assert_initialized!(); 1445 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1446 } 1447 } 1448 1449 impl ToValue for TextSearchFlags { to_value(&self) -> glib::Value1450 fn to_value(&self) -> glib::Value { 1451 let mut value = glib::Value::for_value_type::<Self>(); 1452 unsafe { 1453 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1454 } 1455 value 1456 } 1457 value_type(&self) -> glib::Type1458 fn value_type(&self) -> glib::Type { 1459 Self::static_type() 1460 } 1461 } 1462 1463 bitflags! { 1464 #[doc(alias = "GtkToolPaletteDragTargets")] 1465 pub struct ToolPaletteDragTargets: u32 { 1466 #[doc(alias = "GTK_TOOL_PALETTE_DRAG_ITEMS")] 1467 const ITEMS = ffi::GTK_TOOL_PALETTE_DRAG_ITEMS as u32; 1468 #[doc(alias = "GTK_TOOL_PALETTE_DRAG_GROUPS")] 1469 const GROUPS = ffi::GTK_TOOL_PALETTE_DRAG_GROUPS as u32; 1470 } 1471 } 1472 1473 impl fmt::Display for ToolPaletteDragTargets { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1474 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1475 <Self as fmt::Debug>::fmt(self, f) 1476 } 1477 } 1478 1479 #[doc(hidden)] 1480 impl IntoGlib for ToolPaletteDragTargets { 1481 type GlibType = ffi::GtkToolPaletteDragTargets; 1482 into_glib(self) -> ffi::GtkToolPaletteDragTargets1483 fn into_glib(self) -> ffi::GtkToolPaletteDragTargets { 1484 self.bits() 1485 } 1486 } 1487 1488 #[doc(hidden)] 1489 impl FromGlib<ffi::GtkToolPaletteDragTargets> for ToolPaletteDragTargets { from_glib(value: ffi::GtkToolPaletteDragTargets) -> Self1490 unsafe fn from_glib(value: ffi::GtkToolPaletteDragTargets) -> Self { 1491 skip_assert_initialized!(); 1492 Self::from_bits_truncate(value) 1493 } 1494 } 1495 1496 impl StaticType for ToolPaletteDragTargets { static_type() -> Type1497 fn static_type() -> Type { 1498 unsafe { from_glib(ffi::gtk_tool_palette_drag_targets_get_type()) } 1499 } 1500 } 1501 1502 impl glib::value::ValueType for ToolPaletteDragTargets { 1503 type Type = Self; 1504 } 1505 1506 unsafe impl<'a> FromValue<'a> for ToolPaletteDragTargets { 1507 type Checker = glib::value::GenericValueTypeChecker<Self>; 1508 from_value(value: &'a glib::Value) -> Self1509 unsafe fn from_value(value: &'a glib::Value) -> Self { 1510 skip_assert_initialized!(); 1511 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1512 } 1513 } 1514 1515 impl ToValue for ToolPaletteDragTargets { to_value(&self) -> glib::Value1516 fn to_value(&self) -> glib::Value { 1517 let mut value = glib::Value::for_value_type::<Self>(); 1518 unsafe { 1519 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1520 } 1521 value 1522 } 1523 value_type(&self) -> glib::Type1524 fn value_type(&self) -> glib::Type { 1525 Self::static_type() 1526 } 1527 } 1528 1529 bitflags! { 1530 #[doc(alias = "GtkTreeModelFlags")] 1531 pub struct TreeModelFlags: u32 { 1532 #[doc(alias = "GTK_TREE_MODEL_ITERS_PERSIST")] 1533 const ITERS_PERSIST = ffi::GTK_TREE_MODEL_ITERS_PERSIST as u32; 1534 #[doc(alias = "GTK_TREE_MODEL_LIST_ONLY")] 1535 const LIST_ONLY = ffi::GTK_TREE_MODEL_LIST_ONLY as u32; 1536 } 1537 } 1538 1539 impl fmt::Display for TreeModelFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1540 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1541 <Self as fmt::Debug>::fmt(self, f) 1542 } 1543 } 1544 1545 #[doc(hidden)] 1546 impl IntoGlib for TreeModelFlags { 1547 type GlibType = ffi::GtkTreeModelFlags; 1548 into_glib(self) -> ffi::GtkTreeModelFlags1549 fn into_glib(self) -> ffi::GtkTreeModelFlags { 1550 self.bits() 1551 } 1552 } 1553 1554 #[doc(hidden)] 1555 impl FromGlib<ffi::GtkTreeModelFlags> for TreeModelFlags { from_glib(value: ffi::GtkTreeModelFlags) -> Self1556 unsafe fn from_glib(value: ffi::GtkTreeModelFlags) -> Self { 1557 skip_assert_initialized!(); 1558 Self::from_bits_truncate(value) 1559 } 1560 } 1561 1562 impl StaticType for TreeModelFlags { static_type() -> Type1563 fn static_type() -> Type { 1564 unsafe { from_glib(ffi::gtk_tree_model_flags_get_type()) } 1565 } 1566 } 1567 1568 impl glib::value::ValueType for TreeModelFlags { 1569 type Type = Self; 1570 } 1571 1572 unsafe impl<'a> FromValue<'a> for TreeModelFlags { 1573 type Checker = glib::value::GenericValueTypeChecker<Self>; 1574 from_value(value: &'a glib::Value) -> Self1575 unsafe fn from_value(value: &'a glib::Value) -> Self { 1576 skip_assert_initialized!(); 1577 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) 1578 } 1579 } 1580 1581 impl ToValue for TreeModelFlags { to_value(&self) -> glib::Value1582 fn to_value(&self) -> glib::Value { 1583 let mut value = glib::Value::for_value_type::<Self>(); 1584 unsafe { 1585 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); 1586 } 1587 value 1588 } 1589 value_type(&self) -> glib::Type1590 fn value_type(&self) -> glib::Type { 1591 Self::static_type() 1592 } 1593 } 1594