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 gio_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 ConverterResult { 20 Error, 21 Converted, 22 Finished, 23 Flushed, 24 #[doc(hidden)] 25 __Unknown(i32), 26 } 27 28 impl fmt::Display for ConverterResult { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result29 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 30 write!( 31 f, 32 "ConverterResult::{}", 33 match *self { 34 ConverterResult::Error => "Error", 35 ConverterResult::Converted => "Converted", 36 ConverterResult::Finished => "Finished", 37 ConverterResult::Flushed => "Flushed", 38 _ => "Unknown", 39 } 40 ) 41 } 42 } 43 44 #[doc(hidden)] 45 impl ToGlib for ConverterResult { 46 type GlibType = gio_sys::GConverterResult; 47 to_glib(&self) -> gio_sys::GConverterResult48 fn to_glib(&self) -> gio_sys::GConverterResult { 49 match *self { 50 ConverterResult::Error => gio_sys::G_CONVERTER_ERROR, 51 ConverterResult::Converted => gio_sys::G_CONVERTER_CONVERTED, 52 ConverterResult::Finished => gio_sys::G_CONVERTER_FINISHED, 53 ConverterResult::Flushed => gio_sys::G_CONVERTER_FLUSHED, 54 ConverterResult::__Unknown(value) => value, 55 } 56 } 57 } 58 59 #[doc(hidden)] 60 impl FromGlib<gio_sys::GConverterResult> for ConverterResult { from_glib(value: gio_sys::GConverterResult) -> Self61 fn from_glib(value: gio_sys::GConverterResult) -> Self { 62 match value { 63 0 => ConverterResult::Error, 64 1 => ConverterResult::Converted, 65 2 => ConverterResult::Finished, 66 3 => ConverterResult::Flushed, 67 value => ConverterResult::__Unknown(value), 68 } 69 } 70 } 71 72 impl StaticType for ConverterResult { static_type() -> Type73 fn static_type() -> Type { 74 unsafe { from_glib(gio_sys::g_converter_result_get_type()) } 75 } 76 } 77 78 impl<'a> FromValueOptional<'a> for ConverterResult { from_value_optional(value: &Value) -> Option<Self>79 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 80 Some(FromValue::from_value(value)) 81 } 82 } 83 84 impl<'a> FromValue<'a> for ConverterResult { from_value(value: &Value) -> Self85 unsafe fn from_value(value: &Value) -> Self { 86 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 87 } 88 } 89 90 impl SetValue for ConverterResult { set_value(value: &mut Value, this: &Self)91 unsafe fn set_value(value: &mut Value, this: &Self) { 92 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 93 } 94 } 95 96 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 97 pub enum CredentialsType { 98 Invalid, 99 LinuxUcred, 100 FreebsdCmsgcred, 101 OpenbsdSockpeercred, 102 SolarisUcred, 103 NetbsdUnpcbid, 104 #[doc(hidden)] 105 __Unknown(i32), 106 } 107 108 impl fmt::Display for CredentialsType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result109 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 110 write!( 111 f, 112 "CredentialsType::{}", 113 match *self { 114 CredentialsType::Invalid => "Invalid", 115 CredentialsType::LinuxUcred => "LinuxUcred", 116 CredentialsType::FreebsdCmsgcred => "FreebsdCmsgcred", 117 CredentialsType::OpenbsdSockpeercred => "OpenbsdSockpeercred", 118 CredentialsType::SolarisUcred => "SolarisUcred", 119 CredentialsType::NetbsdUnpcbid => "NetbsdUnpcbid", 120 _ => "Unknown", 121 } 122 ) 123 } 124 } 125 126 #[doc(hidden)] 127 impl ToGlib for CredentialsType { 128 type GlibType = gio_sys::GCredentialsType; 129 to_glib(&self) -> gio_sys::GCredentialsType130 fn to_glib(&self) -> gio_sys::GCredentialsType { 131 match *self { 132 CredentialsType::Invalid => gio_sys::G_CREDENTIALS_TYPE_INVALID, 133 CredentialsType::LinuxUcred => gio_sys::G_CREDENTIALS_TYPE_LINUX_UCRED, 134 CredentialsType::FreebsdCmsgcred => gio_sys::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED, 135 CredentialsType::OpenbsdSockpeercred => { 136 gio_sys::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED 137 } 138 CredentialsType::SolarisUcred => gio_sys::G_CREDENTIALS_TYPE_SOLARIS_UCRED, 139 CredentialsType::NetbsdUnpcbid => gio_sys::G_CREDENTIALS_TYPE_NETBSD_UNPCBID, 140 CredentialsType::__Unknown(value) => value, 141 } 142 } 143 } 144 145 #[doc(hidden)] 146 impl FromGlib<gio_sys::GCredentialsType> for CredentialsType { from_glib(value: gio_sys::GCredentialsType) -> Self147 fn from_glib(value: gio_sys::GCredentialsType) -> Self { 148 match value { 149 0 => CredentialsType::Invalid, 150 1 => CredentialsType::LinuxUcred, 151 2 => CredentialsType::FreebsdCmsgcred, 152 3 => CredentialsType::OpenbsdSockpeercred, 153 4 => CredentialsType::SolarisUcred, 154 5 => CredentialsType::NetbsdUnpcbid, 155 value => CredentialsType::__Unknown(value), 156 } 157 } 158 } 159 160 impl StaticType for CredentialsType { static_type() -> Type161 fn static_type() -> Type { 162 unsafe { from_glib(gio_sys::g_credentials_type_get_type()) } 163 } 164 } 165 166 impl<'a> FromValueOptional<'a> for CredentialsType { from_value_optional(value: &Value) -> Option<Self>167 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 168 Some(FromValue::from_value(value)) 169 } 170 } 171 172 impl<'a> FromValue<'a> for CredentialsType { from_value(value: &Value) -> Self173 unsafe fn from_value(value: &Value) -> Self { 174 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 175 } 176 } 177 178 impl SetValue for CredentialsType { set_value(value: &mut Value, this: &Self)179 unsafe fn set_value(value: &mut Value, this: &Self) { 180 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 181 } 182 } 183 184 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 185 pub enum DataStreamByteOrder { 186 BigEndian, 187 LittleEndian, 188 HostEndian, 189 #[doc(hidden)] 190 __Unknown(i32), 191 } 192 193 impl fmt::Display for DataStreamByteOrder { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result194 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 195 write!( 196 f, 197 "DataStreamByteOrder::{}", 198 match *self { 199 DataStreamByteOrder::BigEndian => "BigEndian", 200 DataStreamByteOrder::LittleEndian => "LittleEndian", 201 DataStreamByteOrder::HostEndian => "HostEndian", 202 _ => "Unknown", 203 } 204 ) 205 } 206 } 207 208 #[doc(hidden)] 209 impl ToGlib for DataStreamByteOrder { 210 type GlibType = gio_sys::GDataStreamByteOrder; 211 to_glib(&self) -> gio_sys::GDataStreamByteOrder212 fn to_glib(&self) -> gio_sys::GDataStreamByteOrder { 213 match *self { 214 DataStreamByteOrder::BigEndian => gio_sys::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN, 215 DataStreamByteOrder::LittleEndian => gio_sys::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN, 216 DataStreamByteOrder::HostEndian => gio_sys::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN, 217 DataStreamByteOrder::__Unknown(value) => value, 218 } 219 } 220 } 221 222 #[doc(hidden)] 223 impl FromGlib<gio_sys::GDataStreamByteOrder> for DataStreamByteOrder { from_glib(value: gio_sys::GDataStreamByteOrder) -> Self224 fn from_glib(value: gio_sys::GDataStreamByteOrder) -> Self { 225 match value { 226 0 => DataStreamByteOrder::BigEndian, 227 1 => DataStreamByteOrder::LittleEndian, 228 2 => DataStreamByteOrder::HostEndian, 229 value => DataStreamByteOrder::__Unknown(value), 230 } 231 } 232 } 233 234 impl StaticType for DataStreamByteOrder { static_type() -> Type235 fn static_type() -> Type { 236 unsafe { from_glib(gio_sys::g_data_stream_byte_order_get_type()) } 237 } 238 } 239 240 impl<'a> FromValueOptional<'a> for DataStreamByteOrder { from_value_optional(value: &Value) -> Option<Self>241 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 242 Some(FromValue::from_value(value)) 243 } 244 } 245 246 impl<'a> FromValue<'a> for DataStreamByteOrder { from_value(value: &Value) -> Self247 unsafe fn from_value(value: &Value) -> Self { 248 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 249 } 250 } 251 252 impl SetValue for DataStreamByteOrder { set_value(value: &mut Value, this: &Self)253 unsafe fn set_value(value: &mut Value, this: &Self) { 254 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 255 } 256 } 257 258 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 259 pub enum DataStreamNewlineType { 260 Lf, 261 Cr, 262 CrLf, 263 Any, 264 #[doc(hidden)] 265 __Unknown(i32), 266 } 267 268 impl fmt::Display for DataStreamNewlineType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result269 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 270 write!( 271 f, 272 "DataStreamNewlineType::{}", 273 match *self { 274 DataStreamNewlineType::Lf => "Lf", 275 DataStreamNewlineType::Cr => "Cr", 276 DataStreamNewlineType::CrLf => "CrLf", 277 DataStreamNewlineType::Any => "Any", 278 _ => "Unknown", 279 } 280 ) 281 } 282 } 283 284 #[doc(hidden)] 285 impl ToGlib for DataStreamNewlineType { 286 type GlibType = gio_sys::GDataStreamNewlineType; 287 to_glib(&self) -> gio_sys::GDataStreamNewlineType288 fn to_glib(&self) -> gio_sys::GDataStreamNewlineType { 289 match *self { 290 DataStreamNewlineType::Lf => gio_sys::G_DATA_STREAM_NEWLINE_TYPE_LF, 291 DataStreamNewlineType::Cr => gio_sys::G_DATA_STREAM_NEWLINE_TYPE_CR, 292 DataStreamNewlineType::CrLf => gio_sys::G_DATA_STREAM_NEWLINE_TYPE_CR_LF, 293 DataStreamNewlineType::Any => gio_sys::G_DATA_STREAM_NEWLINE_TYPE_ANY, 294 DataStreamNewlineType::__Unknown(value) => value, 295 } 296 } 297 } 298 299 #[doc(hidden)] 300 impl FromGlib<gio_sys::GDataStreamNewlineType> for DataStreamNewlineType { from_glib(value: gio_sys::GDataStreamNewlineType) -> Self301 fn from_glib(value: gio_sys::GDataStreamNewlineType) -> Self { 302 match value { 303 0 => DataStreamNewlineType::Lf, 304 1 => DataStreamNewlineType::Cr, 305 2 => DataStreamNewlineType::CrLf, 306 3 => DataStreamNewlineType::Any, 307 value => DataStreamNewlineType::__Unknown(value), 308 } 309 } 310 } 311 312 impl StaticType for DataStreamNewlineType { static_type() -> Type313 fn static_type() -> Type { 314 unsafe { from_glib(gio_sys::g_data_stream_newline_type_get_type()) } 315 } 316 } 317 318 impl<'a> FromValueOptional<'a> for DataStreamNewlineType { from_value_optional(value: &Value) -> Option<Self>319 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 320 Some(FromValue::from_value(value)) 321 } 322 } 323 324 impl<'a> FromValue<'a> for DataStreamNewlineType { from_value(value: &Value) -> Self325 unsafe fn from_value(value: &Value) -> Self { 326 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 327 } 328 } 329 330 impl SetValue for DataStreamNewlineType { set_value(value: &mut Value, this: &Self)331 unsafe fn set_value(value: &mut Value, this: &Self) { 332 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 333 } 334 } 335 336 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 337 pub enum DriveStartStopType { 338 Unknown, 339 Shutdown, 340 Network, 341 Multidisk, 342 Password, 343 #[doc(hidden)] 344 __Unknown(i32), 345 } 346 347 impl fmt::Display for DriveStartStopType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result348 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 349 write!( 350 f, 351 "DriveStartStopType::{}", 352 match *self { 353 DriveStartStopType::Unknown => "Unknown", 354 DriveStartStopType::Shutdown => "Shutdown", 355 DriveStartStopType::Network => "Network", 356 DriveStartStopType::Multidisk => "Multidisk", 357 DriveStartStopType::Password => "Password", 358 _ => "Unknown", 359 } 360 ) 361 } 362 } 363 364 #[doc(hidden)] 365 impl ToGlib for DriveStartStopType { 366 type GlibType = gio_sys::GDriveStartStopType; 367 to_glib(&self) -> gio_sys::GDriveStartStopType368 fn to_glib(&self) -> gio_sys::GDriveStartStopType { 369 match *self { 370 DriveStartStopType::Unknown => gio_sys::G_DRIVE_START_STOP_TYPE_UNKNOWN, 371 DriveStartStopType::Shutdown => gio_sys::G_DRIVE_START_STOP_TYPE_SHUTDOWN, 372 DriveStartStopType::Network => gio_sys::G_DRIVE_START_STOP_TYPE_NETWORK, 373 DriveStartStopType::Multidisk => gio_sys::G_DRIVE_START_STOP_TYPE_MULTIDISK, 374 DriveStartStopType::Password => gio_sys::G_DRIVE_START_STOP_TYPE_PASSWORD, 375 DriveStartStopType::__Unknown(value) => value, 376 } 377 } 378 } 379 380 #[doc(hidden)] 381 impl FromGlib<gio_sys::GDriveStartStopType> for DriveStartStopType { from_glib(value: gio_sys::GDriveStartStopType) -> Self382 fn from_glib(value: gio_sys::GDriveStartStopType) -> Self { 383 match value { 384 0 => DriveStartStopType::Unknown, 385 1 => DriveStartStopType::Shutdown, 386 2 => DriveStartStopType::Network, 387 3 => DriveStartStopType::Multidisk, 388 4 => DriveStartStopType::Password, 389 value => DriveStartStopType::__Unknown(value), 390 } 391 } 392 } 393 394 impl StaticType for DriveStartStopType { static_type() -> Type395 fn static_type() -> Type { 396 unsafe { from_glib(gio_sys::g_drive_start_stop_type_get_type()) } 397 } 398 } 399 400 impl<'a> FromValueOptional<'a> for DriveStartStopType { from_value_optional(value: &Value) -> Option<Self>401 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 402 Some(FromValue::from_value(value)) 403 } 404 } 405 406 impl<'a> FromValue<'a> for DriveStartStopType { from_value(value: &Value) -> Self407 unsafe fn from_value(value: &Value) -> Self { 408 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 409 } 410 } 411 412 impl SetValue for DriveStartStopType { set_value(value: &mut Value, this: &Self)413 unsafe fn set_value(value: &mut Value, this: &Self) { 414 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 415 } 416 } 417 418 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 419 pub enum EmblemOrigin { 420 Unknown, 421 Device, 422 Livemetadata, 423 Tag, 424 #[doc(hidden)] 425 __Unknown(i32), 426 } 427 428 impl fmt::Display for EmblemOrigin { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result429 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 430 write!( 431 f, 432 "EmblemOrigin::{}", 433 match *self { 434 EmblemOrigin::Unknown => "Unknown", 435 EmblemOrigin::Device => "Device", 436 EmblemOrigin::Livemetadata => "Livemetadata", 437 EmblemOrigin::Tag => "Tag", 438 _ => "Unknown", 439 } 440 ) 441 } 442 } 443 444 #[doc(hidden)] 445 impl ToGlib for EmblemOrigin { 446 type GlibType = gio_sys::GEmblemOrigin; 447 to_glib(&self) -> gio_sys::GEmblemOrigin448 fn to_glib(&self) -> gio_sys::GEmblemOrigin { 449 match *self { 450 EmblemOrigin::Unknown => gio_sys::G_EMBLEM_ORIGIN_UNKNOWN, 451 EmblemOrigin::Device => gio_sys::G_EMBLEM_ORIGIN_DEVICE, 452 EmblemOrigin::Livemetadata => gio_sys::G_EMBLEM_ORIGIN_LIVEMETADATA, 453 EmblemOrigin::Tag => gio_sys::G_EMBLEM_ORIGIN_TAG, 454 EmblemOrigin::__Unknown(value) => value, 455 } 456 } 457 } 458 459 #[doc(hidden)] 460 impl FromGlib<gio_sys::GEmblemOrigin> for EmblemOrigin { from_glib(value: gio_sys::GEmblemOrigin) -> Self461 fn from_glib(value: gio_sys::GEmblemOrigin) -> Self { 462 match value { 463 0 => EmblemOrigin::Unknown, 464 1 => EmblemOrigin::Device, 465 2 => EmblemOrigin::Livemetadata, 466 3 => EmblemOrigin::Tag, 467 value => EmblemOrigin::__Unknown(value), 468 } 469 } 470 } 471 472 impl StaticType for EmblemOrigin { static_type() -> Type473 fn static_type() -> Type { 474 unsafe { from_glib(gio_sys::g_emblem_origin_get_type()) } 475 } 476 } 477 478 impl<'a> FromValueOptional<'a> for EmblemOrigin { from_value_optional(value: &Value) -> Option<Self>479 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 480 Some(FromValue::from_value(value)) 481 } 482 } 483 484 impl<'a> FromValue<'a> for EmblemOrigin { from_value(value: &Value) -> Self485 unsafe fn from_value(value: &Value) -> Self { 486 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 487 } 488 } 489 490 impl SetValue for EmblemOrigin { set_value(value: &mut Value, this: &Self)491 unsafe fn set_value(value: &mut Value, this: &Self) { 492 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 493 } 494 } 495 496 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 497 pub enum FileAttributeStatus { 498 Unset, 499 Set, 500 ErrorSetting, 501 #[doc(hidden)] 502 __Unknown(i32), 503 } 504 505 impl fmt::Display for FileAttributeStatus { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result506 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 507 write!( 508 f, 509 "FileAttributeStatus::{}", 510 match *self { 511 FileAttributeStatus::Unset => "Unset", 512 FileAttributeStatus::Set => "Set", 513 FileAttributeStatus::ErrorSetting => "ErrorSetting", 514 _ => "Unknown", 515 } 516 ) 517 } 518 } 519 520 #[doc(hidden)] 521 impl ToGlib for FileAttributeStatus { 522 type GlibType = gio_sys::GFileAttributeStatus; 523 to_glib(&self) -> gio_sys::GFileAttributeStatus524 fn to_glib(&self) -> gio_sys::GFileAttributeStatus { 525 match *self { 526 FileAttributeStatus::Unset => gio_sys::G_FILE_ATTRIBUTE_STATUS_UNSET, 527 FileAttributeStatus::Set => gio_sys::G_FILE_ATTRIBUTE_STATUS_SET, 528 FileAttributeStatus::ErrorSetting => gio_sys::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, 529 FileAttributeStatus::__Unknown(value) => value, 530 } 531 } 532 } 533 534 #[doc(hidden)] 535 impl FromGlib<gio_sys::GFileAttributeStatus> for FileAttributeStatus { from_glib(value: gio_sys::GFileAttributeStatus) -> Self536 fn from_glib(value: gio_sys::GFileAttributeStatus) -> Self { 537 match value { 538 0 => FileAttributeStatus::Unset, 539 1 => FileAttributeStatus::Set, 540 2 => FileAttributeStatus::ErrorSetting, 541 value => FileAttributeStatus::__Unknown(value), 542 } 543 } 544 } 545 546 impl StaticType for FileAttributeStatus { static_type() -> Type547 fn static_type() -> Type { 548 unsafe { from_glib(gio_sys::g_file_attribute_status_get_type()) } 549 } 550 } 551 552 impl<'a> FromValueOptional<'a> for FileAttributeStatus { from_value_optional(value: &Value) -> Option<Self>553 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 554 Some(FromValue::from_value(value)) 555 } 556 } 557 558 impl<'a> FromValue<'a> for FileAttributeStatus { from_value(value: &Value) -> Self559 unsafe fn from_value(value: &Value) -> Self { 560 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 561 } 562 } 563 564 impl SetValue for FileAttributeStatus { set_value(value: &mut Value, this: &Self)565 unsafe fn set_value(value: &mut Value, this: &Self) { 566 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 567 } 568 } 569 570 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 571 pub enum FileAttributeType { 572 Invalid, 573 String, 574 ByteString, 575 Boolean, 576 Uint32, 577 Int32, 578 Uint64, 579 Int64, 580 Object, 581 Stringv, 582 #[doc(hidden)] 583 __Unknown(i32), 584 } 585 586 impl fmt::Display for FileAttributeType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result587 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 588 write!( 589 f, 590 "FileAttributeType::{}", 591 match *self { 592 FileAttributeType::Invalid => "Invalid", 593 FileAttributeType::String => "String", 594 FileAttributeType::ByteString => "ByteString", 595 FileAttributeType::Boolean => "Boolean", 596 FileAttributeType::Uint32 => "Uint32", 597 FileAttributeType::Int32 => "Int32", 598 FileAttributeType::Uint64 => "Uint64", 599 FileAttributeType::Int64 => "Int64", 600 FileAttributeType::Object => "Object", 601 FileAttributeType::Stringv => "Stringv", 602 _ => "Unknown", 603 } 604 ) 605 } 606 } 607 608 #[doc(hidden)] 609 impl ToGlib for FileAttributeType { 610 type GlibType = gio_sys::GFileAttributeType; 611 to_glib(&self) -> gio_sys::GFileAttributeType612 fn to_glib(&self) -> gio_sys::GFileAttributeType { 613 match *self { 614 FileAttributeType::Invalid => gio_sys::G_FILE_ATTRIBUTE_TYPE_INVALID, 615 FileAttributeType::String => gio_sys::G_FILE_ATTRIBUTE_TYPE_STRING, 616 FileAttributeType::ByteString => gio_sys::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING, 617 FileAttributeType::Boolean => gio_sys::G_FILE_ATTRIBUTE_TYPE_BOOLEAN, 618 FileAttributeType::Uint32 => gio_sys::G_FILE_ATTRIBUTE_TYPE_UINT32, 619 FileAttributeType::Int32 => gio_sys::G_FILE_ATTRIBUTE_TYPE_INT32, 620 FileAttributeType::Uint64 => gio_sys::G_FILE_ATTRIBUTE_TYPE_UINT64, 621 FileAttributeType::Int64 => gio_sys::G_FILE_ATTRIBUTE_TYPE_INT64, 622 FileAttributeType::Object => gio_sys::G_FILE_ATTRIBUTE_TYPE_OBJECT, 623 FileAttributeType::Stringv => gio_sys::G_FILE_ATTRIBUTE_TYPE_STRINGV, 624 FileAttributeType::__Unknown(value) => value, 625 } 626 } 627 } 628 629 #[doc(hidden)] 630 impl FromGlib<gio_sys::GFileAttributeType> for FileAttributeType { from_glib(value: gio_sys::GFileAttributeType) -> Self631 fn from_glib(value: gio_sys::GFileAttributeType) -> Self { 632 match value { 633 0 => FileAttributeType::Invalid, 634 1 => FileAttributeType::String, 635 2 => FileAttributeType::ByteString, 636 3 => FileAttributeType::Boolean, 637 4 => FileAttributeType::Uint32, 638 5 => FileAttributeType::Int32, 639 6 => FileAttributeType::Uint64, 640 7 => FileAttributeType::Int64, 641 8 => FileAttributeType::Object, 642 9 => FileAttributeType::Stringv, 643 value => FileAttributeType::__Unknown(value), 644 } 645 } 646 } 647 648 impl StaticType for FileAttributeType { static_type() -> Type649 fn static_type() -> Type { 650 unsafe { from_glib(gio_sys::g_file_attribute_type_get_type()) } 651 } 652 } 653 654 impl<'a> FromValueOptional<'a> for FileAttributeType { from_value_optional(value: &Value) -> Option<Self>655 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 656 Some(FromValue::from_value(value)) 657 } 658 } 659 660 impl<'a> FromValue<'a> for FileAttributeType { from_value(value: &Value) -> Self661 unsafe fn from_value(value: &Value) -> Self { 662 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 663 } 664 } 665 666 impl SetValue for FileAttributeType { set_value(value: &mut Value, this: &Self)667 unsafe fn set_value(value: &mut Value, this: &Self) { 668 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 669 } 670 } 671 672 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 673 pub enum FileMonitorEvent { 674 Changed, 675 ChangesDoneHint, 676 Deleted, 677 Created, 678 AttributeChanged, 679 PreUnmount, 680 Unmounted, 681 Moved, 682 Renamed, 683 MovedIn, 684 MovedOut, 685 #[doc(hidden)] 686 __Unknown(i32), 687 } 688 689 impl fmt::Display for FileMonitorEvent { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result690 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 691 write!( 692 f, 693 "FileMonitorEvent::{}", 694 match *self { 695 FileMonitorEvent::Changed => "Changed", 696 FileMonitorEvent::ChangesDoneHint => "ChangesDoneHint", 697 FileMonitorEvent::Deleted => "Deleted", 698 FileMonitorEvent::Created => "Created", 699 FileMonitorEvent::AttributeChanged => "AttributeChanged", 700 FileMonitorEvent::PreUnmount => "PreUnmount", 701 FileMonitorEvent::Unmounted => "Unmounted", 702 FileMonitorEvent::Moved => "Moved", 703 FileMonitorEvent::Renamed => "Renamed", 704 FileMonitorEvent::MovedIn => "MovedIn", 705 FileMonitorEvent::MovedOut => "MovedOut", 706 _ => "Unknown", 707 } 708 ) 709 } 710 } 711 712 #[doc(hidden)] 713 impl ToGlib for FileMonitorEvent { 714 type GlibType = gio_sys::GFileMonitorEvent; 715 to_glib(&self) -> gio_sys::GFileMonitorEvent716 fn to_glib(&self) -> gio_sys::GFileMonitorEvent { 717 match *self { 718 FileMonitorEvent::Changed => gio_sys::G_FILE_MONITOR_EVENT_CHANGED, 719 FileMonitorEvent::ChangesDoneHint => gio_sys::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT, 720 FileMonitorEvent::Deleted => gio_sys::G_FILE_MONITOR_EVENT_DELETED, 721 FileMonitorEvent::Created => gio_sys::G_FILE_MONITOR_EVENT_CREATED, 722 FileMonitorEvent::AttributeChanged => gio_sys::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED, 723 FileMonitorEvent::PreUnmount => gio_sys::G_FILE_MONITOR_EVENT_PRE_UNMOUNT, 724 FileMonitorEvent::Unmounted => gio_sys::G_FILE_MONITOR_EVENT_UNMOUNTED, 725 FileMonitorEvent::Moved => gio_sys::G_FILE_MONITOR_EVENT_MOVED, 726 FileMonitorEvent::Renamed => gio_sys::G_FILE_MONITOR_EVENT_RENAMED, 727 FileMonitorEvent::MovedIn => gio_sys::G_FILE_MONITOR_EVENT_MOVED_IN, 728 FileMonitorEvent::MovedOut => gio_sys::G_FILE_MONITOR_EVENT_MOVED_OUT, 729 FileMonitorEvent::__Unknown(value) => value, 730 } 731 } 732 } 733 734 #[doc(hidden)] 735 impl FromGlib<gio_sys::GFileMonitorEvent> for FileMonitorEvent { from_glib(value: gio_sys::GFileMonitorEvent) -> Self736 fn from_glib(value: gio_sys::GFileMonitorEvent) -> Self { 737 match value { 738 0 => FileMonitorEvent::Changed, 739 1 => FileMonitorEvent::ChangesDoneHint, 740 2 => FileMonitorEvent::Deleted, 741 3 => FileMonitorEvent::Created, 742 4 => FileMonitorEvent::AttributeChanged, 743 5 => FileMonitorEvent::PreUnmount, 744 6 => FileMonitorEvent::Unmounted, 745 7 => FileMonitorEvent::Moved, 746 8 => FileMonitorEvent::Renamed, 747 9 => FileMonitorEvent::MovedIn, 748 10 => FileMonitorEvent::MovedOut, 749 value => FileMonitorEvent::__Unknown(value), 750 } 751 } 752 } 753 754 impl StaticType for FileMonitorEvent { static_type() -> Type755 fn static_type() -> Type { 756 unsafe { from_glib(gio_sys::g_file_monitor_event_get_type()) } 757 } 758 } 759 760 impl<'a> FromValueOptional<'a> for FileMonitorEvent { from_value_optional(value: &Value) -> Option<Self>761 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 762 Some(FromValue::from_value(value)) 763 } 764 } 765 766 impl<'a> FromValue<'a> for FileMonitorEvent { from_value(value: &Value) -> Self767 unsafe fn from_value(value: &Value) -> Self { 768 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 769 } 770 } 771 772 impl SetValue for FileMonitorEvent { set_value(value: &mut Value, this: &Self)773 unsafe fn set_value(value: &mut Value, this: &Self) { 774 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 775 } 776 } 777 778 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 779 pub enum FileType { 780 Unknown, 781 Regular, 782 Directory, 783 SymbolicLink, 784 Special, 785 Shortcut, 786 Mountable, 787 #[doc(hidden)] 788 __Unknown(i32), 789 } 790 791 impl fmt::Display for FileType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result792 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 793 write!( 794 f, 795 "FileType::{}", 796 match *self { 797 FileType::Unknown => "Unknown", 798 FileType::Regular => "Regular", 799 FileType::Directory => "Directory", 800 FileType::SymbolicLink => "SymbolicLink", 801 FileType::Special => "Special", 802 FileType::Shortcut => "Shortcut", 803 FileType::Mountable => "Mountable", 804 _ => "Unknown", 805 } 806 ) 807 } 808 } 809 810 #[doc(hidden)] 811 impl ToGlib for FileType { 812 type GlibType = gio_sys::GFileType; 813 to_glib(&self) -> gio_sys::GFileType814 fn to_glib(&self) -> gio_sys::GFileType { 815 match *self { 816 FileType::Unknown => gio_sys::G_FILE_TYPE_UNKNOWN, 817 FileType::Regular => gio_sys::G_FILE_TYPE_REGULAR, 818 FileType::Directory => gio_sys::G_FILE_TYPE_DIRECTORY, 819 FileType::SymbolicLink => gio_sys::G_FILE_TYPE_SYMBOLIC_LINK, 820 FileType::Special => gio_sys::G_FILE_TYPE_SPECIAL, 821 FileType::Shortcut => gio_sys::G_FILE_TYPE_SHORTCUT, 822 FileType::Mountable => gio_sys::G_FILE_TYPE_MOUNTABLE, 823 FileType::__Unknown(value) => value, 824 } 825 } 826 } 827 828 #[doc(hidden)] 829 impl FromGlib<gio_sys::GFileType> for FileType { from_glib(value: gio_sys::GFileType) -> Self830 fn from_glib(value: gio_sys::GFileType) -> Self { 831 match value { 832 0 => FileType::Unknown, 833 1 => FileType::Regular, 834 2 => FileType::Directory, 835 3 => FileType::SymbolicLink, 836 4 => FileType::Special, 837 5 => FileType::Shortcut, 838 6 => FileType::Mountable, 839 value => FileType::__Unknown(value), 840 } 841 } 842 } 843 844 impl StaticType for FileType { static_type() -> Type845 fn static_type() -> Type { 846 unsafe { from_glib(gio_sys::g_file_type_get_type()) } 847 } 848 } 849 850 impl<'a> FromValueOptional<'a> for FileType { from_value_optional(value: &Value) -> Option<Self>851 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 852 Some(FromValue::from_value(value)) 853 } 854 } 855 856 impl<'a> FromValue<'a> for FileType { from_value(value: &Value) -> Self857 unsafe fn from_value(value: &Value) -> Self { 858 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 859 } 860 } 861 862 impl SetValue for FileType { set_value(value: &mut Value, this: &Self)863 unsafe fn set_value(value: &mut Value, this: &Self) { 864 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 865 } 866 } 867 868 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 869 pub enum IOErrorEnum { 870 Failed, 871 NotFound, 872 Exists, 873 IsDirectory, 874 NotDirectory, 875 NotEmpty, 876 NotRegularFile, 877 NotSymbolicLink, 878 NotMountableFile, 879 FilenameTooLong, 880 InvalidFilename, 881 TooManyLinks, 882 NoSpace, 883 InvalidArgument, 884 PermissionDenied, 885 NotSupported, 886 NotMounted, 887 AlreadyMounted, 888 Closed, 889 Cancelled, 890 Pending, 891 ReadOnly, 892 CantCreateBackup, 893 WrongEtag, 894 TimedOut, 895 WouldRecurse, 896 Busy, 897 WouldBlock, 898 HostNotFound, 899 WouldMerge, 900 FailedHandled, 901 TooManyOpenFiles, 902 NotInitialized, 903 AddressInUse, 904 PartialInput, 905 InvalidData, 906 DbusError, 907 HostUnreachable, 908 NetworkUnreachable, 909 ConnectionRefused, 910 ProxyFailed, 911 ProxyAuthFailed, 912 ProxyNeedAuth, 913 ProxyNotAllowed, 914 BrokenPipe, 915 NotConnected, 916 MessageTooLarge, 917 #[doc(hidden)] 918 __Unknown(i32), 919 } 920 921 impl fmt::Display for IOErrorEnum { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result922 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 923 write!( 924 f, 925 "IOErrorEnum::{}", 926 match *self { 927 IOErrorEnum::Failed => "Failed", 928 IOErrorEnum::NotFound => "NotFound", 929 IOErrorEnum::Exists => "Exists", 930 IOErrorEnum::IsDirectory => "IsDirectory", 931 IOErrorEnum::NotDirectory => "NotDirectory", 932 IOErrorEnum::NotEmpty => "NotEmpty", 933 IOErrorEnum::NotRegularFile => "NotRegularFile", 934 IOErrorEnum::NotSymbolicLink => "NotSymbolicLink", 935 IOErrorEnum::NotMountableFile => "NotMountableFile", 936 IOErrorEnum::FilenameTooLong => "FilenameTooLong", 937 IOErrorEnum::InvalidFilename => "InvalidFilename", 938 IOErrorEnum::TooManyLinks => "TooManyLinks", 939 IOErrorEnum::NoSpace => "NoSpace", 940 IOErrorEnum::InvalidArgument => "InvalidArgument", 941 IOErrorEnum::PermissionDenied => "PermissionDenied", 942 IOErrorEnum::NotSupported => "NotSupported", 943 IOErrorEnum::NotMounted => "NotMounted", 944 IOErrorEnum::AlreadyMounted => "AlreadyMounted", 945 IOErrorEnum::Closed => "Closed", 946 IOErrorEnum::Cancelled => "Cancelled", 947 IOErrorEnum::Pending => "Pending", 948 IOErrorEnum::ReadOnly => "ReadOnly", 949 IOErrorEnum::CantCreateBackup => "CantCreateBackup", 950 IOErrorEnum::WrongEtag => "WrongEtag", 951 IOErrorEnum::TimedOut => "TimedOut", 952 IOErrorEnum::WouldRecurse => "WouldRecurse", 953 IOErrorEnum::Busy => "Busy", 954 IOErrorEnum::WouldBlock => "WouldBlock", 955 IOErrorEnum::HostNotFound => "HostNotFound", 956 IOErrorEnum::WouldMerge => "WouldMerge", 957 IOErrorEnum::FailedHandled => "FailedHandled", 958 IOErrorEnum::TooManyOpenFiles => "TooManyOpenFiles", 959 IOErrorEnum::NotInitialized => "NotInitialized", 960 IOErrorEnum::AddressInUse => "AddressInUse", 961 IOErrorEnum::PartialInput => "PartialInput", 962 IOErrorEnum::InvalidData => "InvalidData", 963 IOErrorEnum::DbusError => "DbusError", 964 IOErrorEnum::HostUnreachable => "HostUnreachable", 965 IOErrorEnum::NetworkUnreachable => "NetworkUnreachable", 966 IOErrorEnum::ConnectionRefused => "ConnectionRefused", 967 IOErrorEnum::ProxyFailed => "ProxyFailed", 968 IOErrorEnum::ProxyAuthFailed => "ProxyAuthFailed", 969 IOErrorEnum::ProxyNeedAuth => "ProxyNeedAuth", 970 IOErrorEnum::ProxyNotAllowed => "ProxyNotAllowed", 971 IOErrorEnum::BrokenPipe => "BrokenPipe", 972 IOErrorEnum::NotConnected => "NotConnected", 973 IOErrorEnum::MessageTooLarge => "MessageTooLarge", 974 _ => "Unknown", 975 } 976 ) 977 } 978 } 979 980 #[doc(hidden)] 981 impl ToGlib for IOErrorEnum { 982 type GlibType = gio_sys::GIOErrorEnum; 983 to_glib(&self) -> gio_sys::GIOErrorEnum984 fn to_glib(&self) -> gio_sys::GIOErrorEnum { 985 match *self { 986 IOErrorEnum::Failed => gio_sys::G_IO_ERROR_FAILED, 987 IOErrorEnum::NotFound => gio_sys::G_IO_ERROR_NOT_FOUND, 988 IOErrorEnum::Exists => gio_sys::G_IO_ERROR_EXISTS, 989 IOErrorEnum::IsDirectory => gio_sys::G_IO_ERROR_IS_DIRECTORY, 990 IOErrorEnum::NotDirectory => gio_sys::G_IO_ERROR_NOT_DIRECTORY, 991 IOErrorEnum::NotEmpty => gio_sys::G_IO_ERROR_NOT_EMPTY, 992 IOErrorEnum::NotRegularFile => gio_sys::G_IO_ERROR_NOT_REGULAR_FILE, 993 IOErrorEnum::NotSymbolicLink => gio_sys::G_IO_ERROR_NOT_SYMBOLIC_LINK, 994 IOErrorEnum::NotMountableFile => gio_sys::G_IO_ERROR_NOT_MOUNTABLE_FILE, 995 IOErrorEnum::FilenameTooLong => gio_sys::G_IO_ERROR_FILENAME_TOO_LONG, 996 IOErrorEnum::InvalidFilename => gio_sys::G_IO_ERROR_INVALID_FILENAME, 997 IOErrorEnum::TooManyLinks => gio_sys::G_IO_ERROR_TOO_MANY_LINKS, 998 IOErrorEnum::NoSpace => gio_sys::G_IO_ERROR_NO_SPACE, 999 IOErrorEnum::InvalidArgument => gio_sys::G_IO_ERROR_INVALID_ARGUMENT, 1000 IOErrorEnum::PermissionDenied => gio_sys::G_IO_ERROR_PERMISSION_DENIED, 1001 IOErrorEnum::NotSupported => gio_sys::G_IO_ERROR_NOT_SUPPORTED, 1002 IOErrorEnum::NotMounted => gio_sys::G_IO_ERROR_NOT_MOUNTED, 1003 IOErrorEnum::AlreadyMounted => gio_sys::G_IO_ERROR_ALREADY_MOUNTED, 1004 IOErrorEnum::Closed => gio_sys::G_IO_ERROR_CLOSED, 1005 IOErrorEnum::Cancelled => gio_sys::G_IO_ERROR_CANCELLED, 1006 IOErrorEnum::Pending => gio_sys::G_IO_ERROR_PENDING, 1007 IOErrorEnum::ReadOnly => gio_sys::G_IO_ERROR_READ_ONLY, 1008 IOErrorEnum::CantCreateBackup => gio_sys::G_IO_ERROR_CANT_CREATE_BACKUP, 1009 IOErrorEnum::WrongEtag => gio_sys::G_IO_ERROR_WRONG_ETAG, 1010 IOErrorEnum::TimedOut => gio_sys::G_IO_ERROR_TIMED_OUT, 1011 IOErrorEnum::WouldRecurse => gio_sys::G_IO_ERROR_WOULD_RECURSE, 1012 IOErrorEnum::Busy => gio_sys::G_IO_ERROR_BUSY, 1013 IOErrorEnum::WouldBlock => gio_sys::G_IO_ERROR_WOULD_BLOCK, 1014 IOErrorEnum::HostNotFound => gio_sys::G_IO_ERROR_HOST_NOT_FOUND, 1015 IOErrorEnum::WouldMerge => gio_sys::G_IO_ERROR_WOULD_MERGE, 1016 IOErrorEnum::FailedHandled => gio_sys::G_IO_ERROR_FAILED_HANDLED, 1017 IOErrorEnum::TooManyOpenFiles => gio_sys::G_IO_ERROR_TOO_MANY_OPEN_FILES, 1018 IOErrorEnum::NotInitialized => gio_sys::G_IO_ERROR_NOT_INITIALIZED, 1019 IOErrorEnum::AddressInUse => gio_sys::G_IO_ERROR_ADDRESS_IN_USE, 1020 IOErrorEnum::PartialInput => gio_sys::G_IO_ERROR_PARTIAL_INPUT, 1021 IOErrorEnum::InvalidData => gio_sys::G_IO_ERROR_INVALID_DATA, 1022 IOErrorEnum::DbusError => gio_sys::G_IO_ERROR_DBUS_ERROR, 1023 IOErrorEnum::HostUnreachable => gio_sys::G_IO_ERROR_HOST_UNREACHABLE, 1024 IOErrorEnum::NetworkUnreachable => gio_sys::G_IO_ERROR_NETWORK_UNREACHABLE, 1025 IOErrorEnum::ConnectionRefused => gio_sys::G_IO_ERROR_CONNECTION_REFUSED, 1026 IOErrorEnum::ProxyFailed => gio_sys::G_IO_ERROR_PROXY_FAILED, 1027 IOErrorEnum::ProxyAuthFailed => gio_sys::G_IO_ERROR_PROXY_AUTH_FAILED, 1028 IOErrorEnum::ProxyNeedAuth => gio_sys::G_IO_ERROR_PROXY_NEED_AUTH, 1029 IOErrorEnum::ProxyNotAllowed => gio_sys::G_IO_ERROR_PROXY_NOT_ALLOWED, 1030 IOErrorEnum::BrokenPipe => gio_sys::G_IO_ERROR_BROKEN_PIPE, 1031 IOErrorEnum::NotConnected => gio_sys::G_IO_ERROR_NOT_CONNECTED, 1032 IOErrorEnum::MessageTooLarge => gio_sys::G_IO_ERROR_MESSAGE_TOO_LARGE, 1033 IOErrorEnum::__Unknown(value) => value, 1034 } 1035 } 1036 } 1037 1038 #[doc(hidden)] 1039 impl FromGlib<gio_sys::GIOErrorEnum> for IOErrorEnum { from_glib(value: gio_sys::GIOErrorEnum) -> Self1040 fn from_glib(value: gio_sys::GIOErrorEnum) -> Self { 1041 match value { 1042 0 => IOErrorEnum::Failed, 1043 1 => IOErrorEnum::NotFound, 1044 2 => IOErrorEnum::Exists, 1045 3 => IOErrorEnum::IsDirectory, 1046 4 => IOErrorEnum::NotDirectory, 1047 5 => IOErrorEnum::NotEmpty, 1048 6 => IOErrorEnum::NotRegularFile, 1049 7 => IOErrorEnum::NotSymbolicLink, 1050 8 => IOErrorEnum::NotMountableFile, 1051 9 => IOErrorEnum::FilenameTooLong, 1052 10 => IOErrorEnum::InvalidFilename, 1053 11 => IOErrorEnum::TooManyLinks, 1054 12 => IOErrorEnum::NoSpace, 1055 13 => IOErrorEnum::InvalidArgument, 1056 14 => IOErrorEnum::PermissionDenied, 1057 15 => IOErrorEnum::NotSupported, 1058 16 => IOErrorEnum::NotMounted, 1059 17 => IOErrorEnum::AlreadyMounted, 1060 18 => IOErrorEnum::Closed, 1061 19 => IOErrorEnum::Cancelled, 1062 20 => IOErrorEnum::Pending, 1063 21 => IOErrorEnum::ReadOnly, 1064 22 => IOErrorEnum::CantCreateBackup, 1065 23 => IOErrorEnum::WrongEtag, 1066 24 => IOErrorEnum::TimedOut, 1067 25 => IOErrorEnum::WouldRecurse, 1068 26 => IOErrorEnum::Busy, 1069 27 => IOErrorEnum::WouldBlock, 1070 28 => IOErrorEnum::HostNotFound, 1071 29 => IOErrorEnum::WouldMerge, 1072 30 => IOErrorEnum::FailedHandled, 1073 31 => IOErrorEnum::TooManyOpenFiles, 1074 32 => IOErrorEnum::NotInitialized, 1075 33 => IOErrorEnum::AddressInUse, 1076 34 => IOErrorEnum::PartialInput, 1077 35 => IOErrorEnum::InvalidData, 1078 36 => IOErrorEnum::DbusError, 1079 37 => IOErrorEnum::HostUnreachable, 1080 38 => IOErrorEnum::NetworkUnreachable, 1081 39 => IOErrorEnum::ConnectionRefused, 1082 40 => IOErrorEnum::ProxyFailed, 1083 41 => IOErrorEnum::ProxyAuthFailed, 1084 42 => IOErrorEnum::ProxyNeedAuth, 1085 43 => IOErrorEnum::ProxyNotAllowed, 1086 44 => IOErrorEnum::BrokenPipe, 1087 45 => IOErrorEnum::NotConnected, 1088 46 => IOErrorEnum::MessageTooLarge, 1089 value => IOErrorEnum::__Unknown(value), 1090 } 1091 } 1092 } 1093 1094 impl ErrorDomain for IOErrorEnum { domain() -> Quark1095 fn domain() -> Quark { 1096 unsafe { from_glib(gio_sys::g_io_error_quark()) } 1097 } 1098 code(self) -> i321099 fn code(self) -> i32 { 1100 self.to_glib() 1101 } 1102 from(code: i32) -> Option<Self>1103 fn from(code: i32) -> Option<Self> { 1104 match code { 1105 0 => Some(IOErrorEnum::Failed), 1106 1 => Some(IOErrorEnum::NotFound), 1107 2 => Some(IOErrorEnum::Exists), 1108 3 => Some(IOErrorEnum::IsDirectory), 1109 4 => Some(IOErrorEnum::NotDirectory), 1110 5 => Some(IOErrorEnum::NotEmpty), 1111 6 => Some(IOErrorEnum::NotRegularFile), 1112 7 => Some(IOErrorEnum::NotSymbolicLink), 1113 8 => Some(IOErrorEnum::NotMountableFile), 1114 9 => Some(IOErrorEnum::FilenameTooLong), 1115 10 => Some(IOErrorEnum::InvalidFilename), 1116 11 => Some(IOErrorEnum::TooManyLinks), 1117 12 => Some(IOErrorEnum::NoSpace), 1118 13 => Some(IOErrorEnum::InvalidArgument), 1119 14 => Some(IOErrorEnum::PermissionDenied), 1120 15 => Some(IOErrorEnum::NotSupported), 1121 16 => Some(IOErrorEnum::NotMounted), 1122 17 => Some(IOErrorEnum::AlreadyMounted), 1123 18 => Some(IOErrorEnum::Closed), 1124 19 => Some(IOErrorEnum::Cancelled), 1125 20 => Some(IOErrorEnum::Pending), 1126 21 => Some(IOErrorEnum::ReadOnly), 1127 22 => Some(IOErrorEnum::CantCreateBackup), 1128 23 => Some(IOErrorEnum::WrongEtag), 1129 24 => Some(IOErrorEnum::TimedOut), 1130 25 => Some(IOErrorEnum::WouldRecurse), 1131 26 => Some(IOErrorEnum::Busy), 1132 27 => Some(IOErrorEnum::WouldBlock), 1133 28 => Some(IOErrorEnum::HostNotFound), 1134 29 => Some(IOErrorEnum::WouldMerge), 1135 30 => Some(IOErrorEnum::FailedHandled), 1136 31 => Some(IOErrorEnum::TooManyOpenFiles), 1137 32 => Some(IOErrorEnum::NotInitialized), 1138 33 => Some(IOErrorEnum::AddressInUse), 1139 34 => Some(IOErrorEnum::PartialInput), 1140 35 => Some(IOErrorEnum::InvalidData), 1141 36 => Some(IOErrorEnum::DbusError), 1142 37 => Some(IOErrorEnum::HostUnreachable), 1143 38 => Some(IOErrorEnum::NetworkUnreachable), 1144 39 => Some(IOErrorEnum::ConnectionRefused), 1145 40 => Some(IOErrorEnum::ProxyFailed), 1146 41 => Some(IOErrorEnum::ProxyAuthFailed), 1147 42 => Some(IOErrorEnum::ProxyNeedAuth), 1148 43 => Some(IOErrorEnum::ProxyNotAllowed), 1149 44 => Some(IOErrorEnum::BrokenPipe), 1150 45 => Some(IOErrorEnum::NotConnected), 1151 46 => Some(IOErrorEnum::MessageTooLarge), 1152 _ => Some(IOErrorEnum::Failed), 1153 } 1154 } 1155 } 1156 1157 impl StaticType for IOErrorEnum { static_type() -> Type1158 fn static_type() -> Type { 1159 unsafe { from_glib(gio_sys::g_io_error_enum_get_type()) } 1160 } 1161 } 1162 1163 impl<'a> FromValueOptional<'a> for IOErrorEnum { from_value_optional(value: &Value) -> Option<Self>1164 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1165 Some(FromValue::from_value(value)) 1166 } 1167 } 1168 1169 impl<'a> FromValue<'a> for IOErrorEnum { from_value(value: &Value) -> Self1170 unsafe fn from_value(value: &Value) -> Self { 1171 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1172 } 1173 } 1174 1175 impl SetValue for IOErrorEnum { set_value(value: &mut Value, this: &Self)1176 unsafe fn set_value(value: &mut Value, this: &Self) { 1177 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1178 } 1179 } 1180 1181 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1182 pub enum MountOperationResult { 1183 Handled, 1184 Aborted, 1185 Unhandled, 1186 #[doc(hidden)] 1187 __Unknown(i32), 1188 } 1189 1190 impl fmt::Display for MountOperationResult { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1191 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1192 write!( 1193 f, 1194 "MountOperationResult::{}", 1195 match *self { 1196 MountOperationResult::Handled => "Handled", 1197 MountOperationResult::Aborted => "Aborted", 1198 MountOperationResult::Unhandled => "Unhandled", 1199 _ => "Unknown", 1200 } 1201 ) 1202 } 1203 } 1204 1205 #[doc(hidden)] 1206 impl ToGlib for MountOperationResult { 1207 type GlibType = gio_sys::GMountOperationResult; 1208 to_glib(&self) -> gio_sys::GMountOperationResult1209 fn to_glib(&self) -> gio_sys::GMountOperationResult { 1210 match *self { 1211 MountOperationResult::Handled => gio_sys::G_MOUNT_OPERATION_HANDLED, 1212 MountOperationResult::Aborted => gio_sys::G_MOUNT_OPERATION_ABORTED, 1213 MountOperationResult::Unhandled => gio_sys::G_MOUNT_OPERATION_UNHANDLED, 1214 MountOperationResult::__Unknown(value) => value, 1215 } 1216 } 1217 } 1218 1219 #[doc(hidden)] 1220 impl FromGlib<gio_sys::GMountOperationResult> for MountOperationResult { from_glib(value: gio_sys::GMountOperationResult) -> Self1221 fn from_glib(value: gio_sys::GMountOperationResult) -> Self { 1222 match value { 1223 0 => MountOperationResult::Handled, 1224 1 => MountOperationResult::Aborted, 1225 2 => MountOperationResult::Unhandled, 1226 value => MountOperationResult::__Unknown(value), 1227 } 1228 } 1229 } 1230 1231 impl StaticType for MountOperationResult { static_type() -> Type1232 fn static_type() -> Type { 1233 unsafe { from_glib(gio_sys::g_mount_operation_result_get_type()) } 1234 } 1235 } 1236 1237 impl<'a> FromValueOptional<'a> for MountOperationResult { from_value_optional(value: &Value) -> Option<Self>1238 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1239 Some(FromValue::from_value(value)) 1240 } 1241 } 1242 1243 impl<'a> FromValue<'a> for MountOperationResult { from_value(value: &Value) -> Self1244 unsafe fn from_value(value: &Value) -> Self { 1245 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1246 } 1247 } 1248 1249 impl SetValue for MountOperationResult { set_value(value: &mut Value, this: &Self)1250 unsafe fn set_value(value: &mut Value, this: &Self) { 1251 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1252 } 1253 } 1254 1255 #[cfg(any(feature = "v2_44", feature = "dox"))] 1256 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1257 pub enum NetworkConnectivity { 1258 Local, 1259 Limited, 1260 Portal, 1261 Full, 1262 #[doc(hidden)] 1263 __Unknown(i32), 1264 } 1265 1266 #[cfg(any(feature = "v2_44", feature = "dox"))] 1267 impl fmt::Display for NetworkConnectivity { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1268 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1269 write!( 1270 f, 1271 "NetworkConnectivity::{}", 1272 match *self { 1273 NetworkConnectivity::Local => "Local", 1274 NetworkConnectivity::Limited => "Limited", 1275 NetworkConnectivity::Portal => "Portal", 1276 NetworkConnectivity::Full => "Full", 1277 _ => "Unknown", 1278 } 1279 ) 1280 } 1281 } 1282 1283 #[cfg(any(feature = "v2_44", feature = "dox"))] 1284 #[doc(hidden)] 1285 impl ToGlib for NetworkConnectivity { 1286 type GlibType = gio_sys::GNetworkConnectivity; 1287 to_glib(&self) -> gio_sys::GNetworkConnectivity1288 fn to_glib(&self) -> gio_sys::GNetworkConnectivity { 1289 match *self { 1290 NetworkConnectivity::Local => gio_sys::G_NETWORK_CONNECTIVITY_LOCAL, 1291 NetworkConnectivity::Limited => gio_sys::G_NETWORK_CONNECTIVITY_LIMITED, 1292 NetworkConnectivity::Portal => gio_sys::G_NETWORK_CONNECTIVITY_PORTAL, 1293 NetworkConnectivity::Full => gio_sys::G_NETWORK_CONNECTIVITY_FULL, 1294 NetworkConnectivity::__Unknown(value) => value, 1295 } 1296 } 1297 } 1298 1299 #[cfg(any(feature = "v2_44", feature = "dox"))] 1300 #[doc(hidden)] 1301 impl FromGlib<gio_sys::GNetworkConnectivity> for NetworkConnectivity { from_glib(value: gio_sys::GNetworkConnectivity) -> Self1302 fn from_glib(value: gio_sys::GNetworkConnectivity) -> Self { 1303 match value { 1304 1 => NetworkConnectivity::Local, 1305 2 => NetworkConnectivity::Limited, 1306 3 => NetworkConnectivity::Portal, 1307 4 => NetworkConnectivity::Full, 1308 value => NetworkConnectivity::__Unknown(value), 1309 } 1310 } 1311 } 1312 1313 #[cfg(any(feature = "v2_44", feature = "dox"))] 1314 impl StaticType for NetworkConnectivity { static_type() -> Type1315 fn static_type() -> Type { 1316 unsafe { from_glib(gio_sys::g_network_connectivity_get_type()) } 1317 } 1318 } 1319 1320 #[cfg(any(feature = "v2_44", feature = "dox"))] 1321 impl<'a> FromValueOptional<'a> for NetworkConnectivity { from_value_optional(value: &Value) -> Option<Self>1322 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1323 Some(FromValue::from_value(value)) 1324 } 1325 } 1326 1327 #[cfg(any(feature = "v2_44", feature = "dox"))] 1328 impl<'a> FromValue<'a> for NetworkConnectivity { from_value(value: &Value) -> Self1329 unsafe fn from_value(value: &Value) -> Self { 1330 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1331 } 1332 } 1333 1334 #[cfg(any(feature = "v2_44", feature = "dox"))] 1335 impl SetValue for NetworkConnectivity { set_value(value: &mut Value, this: &Self)1336 unsafe fn set_value(value: &mut Value, this: &Self) { 1337 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1338 } 1339 } 1340 1341 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1342 pub enum NotificationPriority { 1343 Normal, 1344 Low, 1345 High, 1346 Urgent, 1347 #[doc(hidden)] 1348 __Unknown(i32), 1349 } 1350 1351 impl fmt::Display for NotificationPriority { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1352 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1353 write!( 1354 f, 1355 "NotificationPriority::{}", 1356 match *self { 1357 NotificationPriority::Normal => "Normal", 1358 NotificationPriority::Low => "Low", 1359 NotificationPriority::High => "High", 1360 NotificationPriority::Urgent => "Urgent", 1361 _ => "Unknown", 1362 } 1363 ) 1364 } 1365 } 1366 1367 #[doc(hidden)] 1368 impl ToGlib for NotificationPriority { 1369 type GlibType = gio_sys::GNotificationPriority; 1370 to_glib(&self) -> gio_sys::GNotificationPriority1371 fn to_glib(&self) -> gio_sys::GNotificationPriority { 1372 match *self { 1373 NotificationPriority::Normal => gio_sys::G_NOTIFICATION_PRIORITY_NORMAL, 1374 NotificationPriority::Low => gio_sys::G_NOTIFICATION_PRIORITY_LOW, 1375 NotificationPriority::High => gio_sys::G_NOTIFICATION_PRIORITY_HIGH, 1376 NotificationPriority::Urgent => gio_sys::G_NOTIFICATION_PRIORITY_URGENT, 1377 NotificationPriority::__Unknown(value) => value, 1378 } 1379 } 1380 } 1381 1382 #[doc(hidden)] 1383 impl FromGlib<gio_sys::GNotificationPriority> for NotificationPriority { from_glib(value: gio_sys::GNotificationPriority) -> Self1384 fn from_glib(value: gio_sys::GNotificationPriority) -> Self { 1385 match value { 1386 0 => NotificationPriority::Normal, 1387 1 => NotificationPriority::Low, 1388 2 => NotificationPriority::High, 1389 3 => NotificationPriority::Urgent, 1390 value => NotificationPriority::__Unknown(value), 1391 } 1392 } 1393 } 1394 1395 impl StaticType for NotificationPriority { static_type() -> Type1396 fn static_type() -> Type { 1397 unsafe { from_glib(gio_sys::g_notification_priority_get_type()) } 1398 } 1399 } 1400 1401 impl<'a> FromValueOptional<'a> for NotificationPriority { from_value_optional(value: &Value) -> Option<Self>1402 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1403 Some(FromValue::from_value(value)) 1404 } 1405 } 1406 1407 impl<'a> FromValue<'a> for NotificationPriority { from_value(value: &Value) -> Self1408 unsafe fn from_value(value: &Value) -> Self { 1409 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1410 } 1411 } 1412 1413 impl SetValue for NotificationPriority { set_value(value: &mut Value, this: &Self)1414 unsafe fn set_value(value: &mut Value, this: &Self) { 1415 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1416 } 1417 } 1418 1419 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1420 pub enum PasswordSave { 1421 Never, 1422 ForSession, 1423 Permanently, 1424 #[doc(hidden)] 1425 __Unknown(i32), 1426 } 1427 1428 impl fmt::Display for PasswordSave { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1429 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1430 write!( 1431 f, 1432 "PasswordSave::{}", 1433 match *self { 1434 PasswordSave::Never => "Never", 1435 PasswordSave::ForSession => "ForSession", 1436 PasswordSave::Permanently => "Permanently", 1437 _ => "Unknown", 1438 } 1439 ) 1440 } 1441 } 1442 1443 #[doc(hidden)] 1444 impl ToGlib for PasswordSave { 1445 type GlibType = gio_sys::GPasswordSave; 1446 to_glib(&self) -> gio_sys::GPasswordSave1447 fn to_glib(&self) -> gio_sys::GPasswordSave { 1448 match *self { 1449 PasswordSave::Never => gio_sys::G_PASSWORD_SAVE_NEVER, 1450 PasswordSave::ForSession => gio_sys::G_PASSWORD_SAVE_FOR_SESSION, 1451 PasswordSave::Permanently => gio_sys::G_PASSWORD_SAVE_PERMANENTLY, 1452 PasswordSave::__Unknown(value) => value, 1453 } 1454 } 1455 } 1456 1457 #[doc(hidden)] 1458 impl FromGlib<gio_sys::GPasswordSave> for PasswordSave { from_glib(value: gio_sys::GPasswordSave) -> Self1459 fn from_glib(value: gio_sys::GPasswordSave) -> Self { 1460 match value { 1461 0 => PasswordSave::Never, 1462 1 => PasswordSave::ForSession, 1463 2 => PasswordSave::Permanently, 1464 value => PasswordSave::__Unknown(value), 1465 } 1466 } 1467 } 1468 1469 impl StaticType for PasswordSave { static_type() -> Type1470 fn static_type() -> Type { 1471 unsafe { from_glib(gio_sys::g_password_save_get_type()) } 1472 } 1473 } 1474 1475 impl<'a> FromValueOptional<'a> for PasswordSave { from_value_optional(value: &Value) -> Option<Self>1476 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1477 Some(FromValue::from_value(value)) 1478 } 1479 } 1480 1481 impl<'a> FromValue<'a> for PasswordSave { from_value(value: &Value) -> Self1482 unsafe fn from_value(value: &Value) -> Self { 1483 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1484 } 1485 } 1486 1487 impl SetValue for PasswordSave { set_value(value: &mut Value, this: &Self)1488 unsafe fn set_value(value: &mut Value, this: &Self) { 1489 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1490 } 1491 } 1492 1493 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1494 pub enum ResolverRecordType { 1495 Srv, 1496 Mx, 1497 Txt, 1498 Soa, 1499 Ns, 1500 #[doc(hidden)] 1501 __Unknown(i32), 1502 } 1503 1504 impl fmt::Display for ResolverRecordType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1505 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1506 write!( 1507 f, 1508 "ResolverRecordType::{}", 1509 match *self { 1510 ResolverRecordType::Srv => "Srv", 1511 ResolverRecordType::Mx => "Mx", 1512 ResolverRecordType::Txt => "Txt", 1513 ResolverRecordType::Soa => "Soa", 1514 ResolverRecordType::Ns => "Ns", 1515 _ => "Unknown", 1516 } 1517 ) 1518 } 1519 } 1520 1521 #[doc(hidden)] 1522 impl ToGlib for ResolverRecordType { 1523 type GlibType = gio_sys::GResolverRecordType; 1524 to_glib(&self) -> gio_sys::GResolverRecordType1525 fn to_glib(&self) -> gio_sys::GResolverRecordType { 1526 match *self { 1527 ResolverRecordType::Srv => gio_sys::G_RESOLVER_RECORD_SRV, 1528 ResolverRecordType::Mx => gio_sys::G_RESOLVER_RECORD_MX, 1529 ResolverRecordType::Txt => gio_sys::G_RESOLVER_RECORD_TXT, 1530 ResolverRecordType::Soa => gio_sys::G_RESOLVER_RECORD_SOA, 1531 ResolverRecordType::Ns => gio_sys::G_RESOLVER_RECORD_NS, 1532 ResolverRecordType::__Unknown(value) => value, 1533 } 1534 } 1535 } 1536 1537 #[doc(hidden)] 1538 impl FromGlib<gio_sys::GResolverRecordType> for ResolverRecordType { from_glib(value: gio_sys::GResolverRecordType) -> Self1539 fn from_glib(value: gio_sys::GResolverRecordType) -> Self { 1540 match value { 1541 1 => ResolverRecordType::Srv, 1542 2 => ResolverRecordType::Mx, 1543 3 => ResolverRecordType::Txt, 1544 4 => ResolverRecordType::Soa, 1545 5 => ResolverRecordType::Ns, 1546 value => ResolverRecordType::__Unknown(value), 1547 } 1548 } 1549 } 1550 1551 impl StaticType for ResolverRecordType { static_type() -> Type1552 fn static_type() -> Type { 1553 unsafe { from_glib(gio_sys::g_resolver_record_type_get_type()) } 1554 } 1555 } 1556 1557 impl<'a> FromValueOptional<'a> for ResolverRecordType { from_value_optional(value: &Value) -> Option<Self>1558 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1559 Some(FromValue::from_value(value)) 1560 } 1561 } 1562 1563 impl<'a> FromValue<'a> for ResolverRecordType { from_value(value: &Value) -> Self1564 unsafe fn from_value(value: &Value) -> Self { 1565 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1566 } 1567 } 1568 1569 impl SetValue for ResolverRecordType { set_value(value: &mut Value, this: &Self)1570 unsafe fn set_value(value: &mut Value, this: &Self) { 1571 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1572 } 1573 } 1574 1575 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1576 pub enum ResourceError { 1577 NotFound, 1578 Internal, 1579 #[doc(hidden)] 1580 __Unknown(i32), 1581 } 1582 1583 impl fmt::Display for ResourceError { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1584 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1585 write!( 1586 f, 1587 "ResourceError::{}", 1588 match *self { 1589 ResourceError::NotFound => "NotFound", 1590 ResourceError::Internal => "Internal", 1591 _ => "Unknown", 1592 } 1593 ) 1594 } 1595 } 1596 1597 #[doc(hidden)] 1598 impl ToGlib for ResourceError { 1599 type GlibType = gio_sys::GResourceError; 1600 to_glib(&self) -> gio_sys::GResourceError1601 fn to_glib(&self) -> gio_sys::GResourceError { 1602 match *self { 1603 ResourceError::NotFound => gio_sys::G_RESOURCE_ERROR_NOT_FOUND, 1604 ResourceError::Internal => gio_sys::G_RESOURCE_ERROR_INTERNAL, 1605 ResourceError::__Unknown(value) => value, 1606 } 1607 } 1608 } 1609 1610 #[doc(hidden)] 1611 impl FromGlib<gio_sys::GResourceError> for ResourceError { from_glib(value: gio_sys::GResourceError) -> Self1612 fn from_glib(value: gio_sys::GResourceError) -> Self { 1613 match value { 1614 0 => ResourceError::NotFound, 1615 1 => ResourceError::Internal, 1616 value => ResourceError::__Unknown(value), 1617 } 1618 } 1619 } 1620 1621 impl ErrorDomain for ResourceError { domain() -> Quark1622 fn domain() -> Quark { 1623 unsafe { from_glib(gio_sys::g_resource_error_quark()) } 1624 } 1625 code(self) -> i321626 fn code(self) -> i32 { 1627 self.to_glib() 1628 } 1629 from(code: i32) -> Option<Self>1630 fn from(code: i32) -> Option<Self> { 1631 match code { 1632 0 => Some(ResourceError::NotFound), 1633 1 => Some(ResourceError::Internal), 1634 value => Some(ResourceError::__Unknown(value)), 1635 } 1636 } 1637 } 1638 1639 impl StaticType for ResourceError { static_type() -> Type1640 fn static_type() -> Type { 1641 unsafe { from_glib(gio_sys::g_resource_error_get_type()) } 1642 } 1643 } 1644 1645 impl<'a> FromValueOptional<'a> for ResourceError { from_value_optional(value: &Value) -> Option<Self>1646 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1647 Some(FromValue::from_value(value)) 1648 } 1649 } 1650 1651 impl<'a> FromValue<'a> for ResourceError { from_value(value: &Value) -> Self1652 unsafe fn from_value(value: &Value) -> Self { 1653 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1654 } 1655 } 1656 1657 impl SetValue for ResourceError { set_value(value: &mut Value, this: &Self)1658 unsafe fn set_value(value: &mut Value, this: &Self) { 1659 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1660 } 1661 } 1662 1663 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1664 pub enum SocketClientEvent { 1665 Resolving, 1666 Resolved, 1667 Connecting, 1668 Connected, 1669 ProxyNegotiating, 1670 ProxyNegotiated, 1671 TlsHandshaking, 1672 TlsHandshaked, 1673 Complete, 1674 #[doc(hidden)] 1675 __Unknown(i32), 1676 } 1677 1678 impl fmt::Display for SocketClientEvent { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1679 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1680 write!( 1681 f, 1682 "SocketClientEvent::{}", 1683 match *self { 1684 SocketClientEvent::Resolving => "Resolving", 1685 SocketClientEvent::Resolved => "Resolved", 1686 SocketClientEvent::Connecting => "Connecting", 1687 SocketClientEvent::Connected => "Connected", 1688 SocketClientEvent::ProxyNegotiating => "ProxyNegotiating", 1689 SocketClientEvent::ProxyNegotiated => "ProxyNegotiated", 1690 SocketClientEvent::TlsHandshaking => "TlsHandshaking", 1691 SocketClientEvent::TlsHandshaked => "TlsHandshaked", 1692 SocketClientEvent::Complete => "Complete", 1693 _ => "Unknown", 1694 } 1695 ) 1696 } 1697 } 1698 1699 #[doc(hidden)] 1700 impl ToGlib for SocketClientEvent { 1701 type GlibType = gio_sys::GSocketClientEvent; 1702 to_glib(&self) -> gio_sys::GSocketClientEvent1703 fn to_glib(&self) -> gio_sys::GSocketClientEvent { 1704 match *self { 1705 SocketClientEvent::Resolving => gio_sys::G_SOCKET_CLIENT_RESOLVING, 1706 SocketClientEvent::Resolved => gio_sys::G_SOCKET_CLIENT_RESOLVED, 1707 SocketClientEvent::Connecting => gio_sys::G_SOCKET_CLIENT_CONNECTING, 1708 SocketClientEvent::Connected => gio_sys::G_SOCKET_CLIENT_CONNECTED, 1709 SocketClientEvent::ProxyNegotiating => gio_sys::G_SOCKET_CLIENT_PROXY_NEGOTIATING, 1710 SocketClientEvent::ProxyNegotiated => gio_sys::G_SOCKET_CLIENT_PROXY_NEGOTIATED, 1711 SocketClientEvent::TlsHandshaking => gio_sys::G_SOCKET_CLIENT_TLS_HANDSHAKING, 1712 SocketClientEvent::TlsHandshaked => gio_sys::G_SOCKET_CLIENT_TLS_HANDSHAKED, 1713 SocketClientEvent::Complete => gio_sys::G_SOCKET_CLIENT_COMPLETE, 1714 SocketClientEvent::__Unknown(value) => value, 1715 } 1716 } 1717 } 1718 1719 #[doc(hidden)] 1720 impl FromGlib<gio_sys::GSocketClientEvent> for SocketClientEvent { from_glib(value: gio_sys::GSocketClientEvent) -> Self1721 fn from_glib(value: gio_sys::GSocketClientEvent) -> Self { 1722 match value { 1723 0 => SocketClientEvent::Resolving, 1724 1 => SocketClientEvent::Resolved, 1725 2 => SocketClientEvent::Connecting, 1726 3 => SocketClientEvent::Connected, 1727 4 => SocketClientEvent::ProxyNegotiating, 1728 5 => SocketClientEvent::ProxyNegotiated, 1729 6 => SocketClientEvent::TlsHandshaking, 1730 7 => SocketClientEvent::TlsHandshaked, 1731 8 => SocketClientEvent::Complete, 1732 value => SocketClientEvent::__Unknown(value), 1733 } 1734 } 1735 } 1736 1737 impl StaticType for SocketClientEvent { static_type() -> Type1738 fn static_type() -> Type { 1739 unsafe { from_glib(gio_sys::g_socket_client_event_get_type()) } 1740 } 1741 } 1742 1743 impl<'a> FromValueOptional<'a> for SocketClientEvent { from_value_optional(value: &Value) -> Option<Self>1744 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1745 Some(FromValue::from_value(value)) 1746 } 1747 } 1748 1749 impl<'a> FromValue<'a> for SocketClientEvent { from_value(value: &Value) -> Self1750 unsafe fn from_value(value: &Value) -> Self { 1751 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1752 } 1753 } 1754 1755 impl SetValue for SocketClientEvent { set_value(value: &mut Value, this: &Self)1756 unsafe fn set_value(value: &mut Value, this: &Self) { 1757 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1758 } 1759 } 1760 1761 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1762 pub enum SocketFamily { 1763 Invalid, 1764 Unix, 1765 Ipv4, 1766 Ipv6, 1767 #[doc(hidden)] 1768 __Unknown(i32), 1769 } 1770 1771 impl fmt::Display for SocketFamily { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1772 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1773 write!( 1774 f, 1775 "SocketFamily::{}", 1776 match *self { 1777 SocketFamily::Invalid => "Invalid", 1778 SocketFamily::Unix => "Unix", 1779 SocketFamily::Ipv4 => "Ipv4", 1780 SocketFamily::Ipv6 => "Ipv6", 1781 _ => "Unknown", 1782 } 1783 ) 1784 } 1785 } 1786 1787 #[doc(hidden)] 1788 impl ToGlib for SocketFamily { 1789 type GlibType = gio_sys::GSocketFamily; 1790 to_glib(&self) -> gio_sys::GSocketFamily1791 fn to_glib(&self) -> gio_sys::GSocketFamily { 1792 match *self { 1793 SocketFamily::Invalid => gio_sys::G_SOCKET_FAMILY_INVALID, 1794 SocketFamily::Unix => gio_sys::G_SOCKET_FAMILY_UNIX, 1795 SocketFamily::Ipv4 => gio_sys::G_SOCKET_FAMILY_IPV4, 1796 SocketFamily::Ipv6 => gio_sys::G_SOCKET_FAMILY_IPV6, 1797 SocketFamily::__Unknown(value) => value, 1798 } 1799 } 1800 } 1801 1802 #[doc(hidden)] 1803 impl FromGlib<gio_sys::GSocketFamily> for SocketFamily { from_glib(value: gio_sys::GSocketFamily) -> Self1804 fn from_glib(value: gio_sys::GSocketFamily) -> Self { 1805 match value { 1806 0 => SocketFamily::Invalid, 1807 1 => SocketFamily::Unix, 1808 2 => SocketFamily::Ipv4, 1809 10 => SocketFamily::Ipv6, 1810 value => SocketFamily::__Unknown(value), 1811 } 1812 } 1813 } 1814 1815 impl StaticType for SocketFamily { static_type() -> Type1816 fn static_type() -> Type { 1817 unsafe { from_glib(gio_sys::g_socket_family_get_type()) } 1818 } 1819 } 1820 1821 impl<'a> FromValueOptional<'a> for SocketFamily { from_value_optional(value: &Value) -> Option<Self>1822 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1823 Some(FromValue::from_value(value)) 1824 } 1825 } 1826 1827 impl<'a> FromValue<'a> for SocketFamily { from_value(value: &Value) -> Self1828 unsafe fn from_value(value: &Value) -> Self { 1829 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1830 } 1831 } 1832 1833 impl SetValue for SocketFamily { set_value(value: &mut Value, this: &Self)1834 unsafe fn set_value(value: &mut Value, this: &Self) { 1835 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1836 } 1837 } 1838 1839 #[cfg(any(feature = "v2_46", feature = "dox"))] 1840 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1841 pub enum SocketListenerEvent { 1842 Binding, 1843 Bound, 1844 Listening, 1845 Listened, 1846 #[doc(hidden)] 1847 __Unknown(i32), 1848 } 1849 1850 #[cfg(any(feature = "v2_46", feature = "dox"))] 1851 impl fmt::Display for SocketListenerEvent { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1852 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1853 write!( 1854 f, 1855 "SocketListenerEvent::{}", 1856 match *self { 1857 SocketListenerEvent::Binding => "Binding", 1858 SocketListenerEvent::Bound => "Bound", 1859 SocketListenerEvent::Listening => "Listening", 1860 SocketListenerEvent::Listened => "Listened", 1861 _ => "Unknown", 1862 } 1863 ) 1864 } 1865 } 1866 1867 #[cfg(any(feature = "v2_46", feature = "dox"))] 1868 #[doc(hidden)] 1869 impl ToGlib for SocketListenerEvent { 1870 type GlibType = gio_sys::GSocketListenerEvent; 1871 to_glib(&self) -> gio_sys::GSocketListenerEvent1872 fn to_glib(&self) -> gio_sys::GSocketListenerEvent { 1873 match *self { 1874 SocketListenerEvent::Binding => gio_sys::G_SOCKET_LISTENER_BINDING, 1875 SocketListenerEvent::Bound => gio_sys::G_SOCKET_LISTENER_BOUND, 1876 SocketListenerEvent::Listening => gio_sys::G_SOCKET_LISTENER_LISTENING, 1877 SocketListenerEvent::Listened => gio_sys::G_SOCKET_LISTENER_LISTENED, 1878 SocketListenerEvent::__Unknown(value) => value, 1879 } 1880 } 1881 } 1882 1883 #[cfg(any(feature = "v2_46", feature = "dox"))] 1884 #[doc(hidden)] 1885 impl FromGlib<gio_sys::GSocketListenerEvent> for SocketListenerEvent { from_glib(value: gio_sys::GSocketListenerEvent) -> Self1886 fn from_glib(value: gio_sys::GSocketListenerEvent) -> Self { 1887 match value { 1888 0 => SocketListenerEvent::Binding, 1889 1 => SocketListenerEvent::Bound, 1890 2 => SocketListenerEvent::Listening, 1891 3 => SocketListenerEvent::Listened, 1892 value => SocketListenerEvent::__Unknown(value), 1893 } 1894 } 1895 } 1896 1897 #[cfg(any(feature = "v2_46", feature = "dox"))] 1898 impl StaticType for SocketListenerEvent { static_type() -> Type1899 fn static_type() -> Type { 1900 unsafe { from_glib(gio_sys::g_socket_listener_event_get_type()) } 1901 } 1902 } 1903 1904 #[cfg(any(feature = "v2_46", feature = "dox"))] 1905 impl<'a> FromValueOptional<'a> for SocketListenerEvent { from_value_optional(value: &Value) -> Option<Self>1906 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1907 Some(FromValue::from_value(value)) 1908 } 1909 } 1910 1911 #[cfg(any(feature = "v2_46", feature = "dox"))] 1912 impl<'a> FromValue<'a> for SocketListenerEvent { from_value(value: &Value) -> Self1913 unsafe fn from_value(value: &Value) -> Self { 1914 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1915 } 1916 } 1917 1918 #[cfg(any(feature = "v2_46", feature = "dox"))] 1919 impl SetValue for SocketListenerEvent { set_value(value: &mut Value, this: &Self)1920 unsafe fn set_value(value: &mut Value, this: &Self) { 1921 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 1922 } 1923 } 1924 1925 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 1926 pub enum SocketProtocol { 1927 Unknown, 1928 Default, 1929 Tcp, 1930 Udp, 1931 Sctp, 1932 #[doc(hidden)] 1933 __Unknown(i32), 1934 } 1935 1936 impl fmt::Display for SocketProtocol { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1937 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1938 write!( 1939 f, 1940 "SocketProtocol::{}", 1941 match *self { 1942 SocketProtocol::Unknown => "Unknown", 1943 SocketProtocol::Default => "Default", 1944 SocketProtocol::Tcp => "Tcp", 1945 SocketProtocol::Udp => "Udp", 1946 SocketProtocol::Sctp => "Sctp", 1947 _ => "Unknown", 1948 } 1949 ) 1950 } 1951 } 1952 1953 #[doc(hidden)] 1954 impl ToGlib for SocketProtocol { 1955 type GlibType = gio_sys::GSocketProtocol; 1956 to_glib(&self) -> gio_sys::GSocketProtocol1957 fn to_glib(&self) -> gio_sys::GSocketProtocol { 1958 match *self { 1959 SocketProtocol::Unknown => gio_sys::G_SOCKET_PROTOCOL_UNKNOWN, 1960 SocketProtocol::Default => gio_sys::G_SOCKET_PROTOCOL_DEFAULT, 1961 SocketProtocol::Tcp => gio_sys::G_SOCKET_PROTOCOL_TCP, 1962 SocketProtocol::Udp => gio_sys::G_SOCKET_PROTOCOL_UDP, 1963 SocketProtocol::Sctp => gio_sys::G_SOCKET_PROTOCOL_SCTP, 1964 SocketProtocol::__Unknown(value) => value, 1965 } 1966 } 1967 } 1968 1969 #[doc(hidden)] 1970 impl FromGlib<gio_sys::GSocketProtocol> for SocketProtocol { from_glib(value: gio_sys::GSocketProtocol) -> Self1971 fn from_glib(value: gio_sys::GSocketProtocol) -> Self { 1972 match value { 1973 -1 => SocketProtocol::Unknown, 1974 0 => SocketProtocol::Default, 1975 6 => SocketProtocol::Tcp, 1976 17 => SocketProtocol::Udp, 1977 132 => SocketProtocol::Sctp, 1978 value => SocketProtocol::__Unknown(value), 1979 } 1980 } 1981 } 1982 1983 impl StaticType for SocketProtocol { static_type() -> Type1984 fn static_type() -> Type { 1985 unsafe { from_glib(gio_sys::g_socket_protocol_get_type()) } 1986 } 1987 } 1988 1989 impl<'a> FromValueOptional<'a> for SocketProtocol { from_value_optional(value: &Value) -> Option<Self>1990 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 1991 Some(FromValue::from_value(value)) 1992 } 1993 } 1994 1995 impl<'a> FromValue<'a> for SocketProtocol { from_value(value: &Value) -> Self1996 unsafe fn from_value(value: &Value) -> Self { 1997 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 1998 } 1999 } 2000 2001 impl SetValue for SocketProtocol { set_value(value: &mut Value, this: &Self)2002 unsafe fn set_value(value: &mut Value, this: &Self) { 2003 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2004 } 2005 } 2006 2007 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2008 pub enum SocketType { 2009 Invalid, 2010 Stream, 2011 Datagram, 2012 Seqpacket, 2013 #[doc(hidden)] 2014 __Unknown(i32), 2015 } 2016 2017 impl fmt::Display for SocketType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2018 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2019 write!( 2020 f, 2021 "SocketType::{}", 2022 match *self { 2023 SocketType::Invalid => "Invalid", 2024 SocketType::Stream => "Stream", 2025 SocketType::Datagram => "Datagram", 2026 SocketType::Seqpacket => "Seqpacket", 2027 _ => "Unknown", 2028 } 2029 ) 2030 } 2031 } 2032 2033 #[doc(hidden)] 2034 impl ToGlib for SocketType { 2035 type GlibType = gio_sys::GSocketType; 2036 to_glib(&self) -> gio_sys::GSocketType2037 fn to_glib(&self) -> gio_sys::GSocketType { 2038 match *self { 2039 SocketType::Invalid => gio_sys::G_SOCKET_TYPE_INVALID, 2040 SocketType::Stream => gio_sys::G_SOCKET_TYPE_STREAM, 2041 SocketType::Datagram => gio_sys::G_SOCKET_TYPE_DATAGRAM, 2042 SocketType::Seqpacket => gio_sys::G_SOCKET_TYPE_SEQPACKET, 2043 SocketType::__Unknown(value) => value, 2044 } 2045 } 2046 } 2047 2048 #[doc(hidden)] 2049 impl FromGlib<gio_sys::GSocketType> for SocketType { from_glib(value: gio_sys::GSocketType) -> Self2050 fn from_glib(value: gio_sys::GSocketType) -> Self { 2051 match value { 2052 0 => SocketType::Invalid, 2053 1 => SocketType::Stream, 2054 2 => SocketType::Datagram, 2055 3 => SocketType::Seqpacket, 2056 value => SocketType::__Unknown(value), 2057 } 2058 } 2059 } 2060 2061 impl StaticType for SocketType { static_type() -> Type2062 fn static_type() -> Type { 2063 unsafe { from_glib(gio_sys::g_socket_type_get_type()) } 2064 } 2065 } 2066 2067 impl<'a> FromValueOptional<'a> for SocketType { from_value_optional(value: &Value) -> Option<Self>2068 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2069 Some(FromValue::from_value(value)) 2070 } 2071 } 2072 2073 impl<'a> FromValue<'a> for SocketType { from_value(value: &Value) -> Self2074 unsafe fn from_value(value: &Value) -> Self { 2075 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2076 } 2077 } 2078 2079 impl SetValue for SocketType { set_value(value: &mut Value, this: &Self)2080 unsafe fn set_value(value: &mut Value, this: &Self) { 2081 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2082 } 2083 } 2084 2085 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2086 pub enum TlsAuthenticationMode { 2087 None, 2088 Requested, 2089 Required, 2090 #[doc(hidden)] 2091 __Unknown(i32), 2092 } 2093 2094 impl fmt::Display for TlsAuthenticationMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2095 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2096 write!( 2097 f, 2098 "TlsAuthenticationMode::{}", 2099 match *self { 2100 TlsAuthenticationMode::None => "None", 2101 TlsAuthenticationMode::Requested => "Requested", 2102 TlsAuthenticationMode::Required => "Required", 2103 _ => "Unknown", 2104 } 2105 ) 2106 } 2107 } 2108 2109 #[doc(hidden)] 2110 impl ToGlib for TlsAuthenticationMode { 2111 type GlibType = gio_sys::GTlsAuthenticationMode; 2112 to_glib(&self) -> gio_sys::GTlsAuthenticationMode2113 fn to_glib(&self) -> gio_sys::GTlsAuthenticationMode { 2114 match *self { 2115 TlsAuthenticationMode::None => gio_sys::G_TLS_AUTHENTICATION_NONE, 2116 TlsAuthenticationMode::Requested => gio_sys::G_TLS_AUTHENTICATION_REQUESTED, 2117 TlsAuthenticationMode::Required => gio_sys::G_TLS_AUTHENTICATION_REQUIRED, 2118 TlsAuthenticationMode::__Unknown(value) => value, 2119 } 2120 } 2121 } 2122 2123 #[doc(hidden)] 2124 impl FromGlib<gio_sys::GTlsAuthenticationMode> for TlsAuthenticationMode { from_glib(value: gio_sys::GTlsAuthenticationMode) -> Self2125 fn from_glib(value: gio_sys::GTlsAuthenticationMode) -> Self { 2126 match value { 2127 0 => TlsAuthenticationMode::None, 2128 1 => TlsAuthenticationMode::Requested, 2129 2 => TlsAuthenticationMode::Required, 2130 value => TlsAuthenticationMode::__Unknown(value), 2131 } 2132 } 2133 } 2134 2135 impl StaticType for TlsAuthenticationMode { static_type() -> Type2136 fn static_type() -> Type { 2137 unsafe { from_glib(gio_sys::g_tls_authentication_mode_get_type()) } 2138 } 2139 } 2140 2141 impl<'a> FromValueOptional<'a> for TlsAuthenticationMode { from_value_optional(value: &Value) -> Option<Self>2142 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2143 Some(FromValue::from_value(value)) 2144 } 2145 } 2146 2147 impl<'a> FromValue<'a> for TlsAuthenticationMode { from_value(value: &Value) -> Self2148 unsafe fn from_value(value: &Value) -> Self { 2149 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2150 } 2151 } 2152 2153 impl SetValue for TlsAuthenticationMode { set_value(value: &mut Value, this: &Self)2154 unsafe fn set_value(value: &mut Value, this: &Self) { 2155 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2156 } 2157 } 2158 2159 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2160 pub enum TlsCertificateRequestFlags { 2161 None, 2162 #[doc(hidden)] 2163 __Unknown(i32), 2164 } 2165 2166 impl fmt::Display for TlsCertificateRequestFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2167 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2168 write!( 2169 f, 2170 "TlsCertificateRequestFlags::{}", 2171 match *self { 2172 TlsCertificateRequestFlags::None => "None", 2173 _ => "Unknown", 2174 } 2175 ) 2176 } 2177 } 2178 2179 #[doc(hidden)] 2180 impl ToGlib for TlsCertificateRequestFlags { 2181 type GlibType = gio_sys::GTlsCertificateRequestFlags; 2182 to_glib(&self) -> gio_sys::GTlsCertificateRequestFlags2183 fn to_glib(&self) -> gio_sys::GTlsCertificateRequestFlags { 2184 match *self { 2185 TlsCertificateRequestFlags::None => gio_sys::G_TLS_CERTIFICATE_REQUEST_NONE, 2186 TlsCertificateRequestFlags::__Unknown(value) => value, 2187 } 2188 } 2189 } 2190 2191 #[doc(hidden)] 2192 impl FromGlib<gio_sys::GTlsCertificateRequestFlags> for TlsCertificateRequestFlags { from_glib(value: gio_sys::GTlsCertificateRequestFlags) -> Self2193 fn from_glib(value: gio_sys::GTlsCertificateRequestFlags) -> Self { 2194 match value { 2195 0 => TlsCertificateRequestFlags::None, 2196 value => TlsCertificateRequestFlags::__Unknown(value), 2197 } 2198 } 2199 } 2200 2201 impl StaticType for TlsCertificateRequestFlags { static_type() -> Type2202 fn static_type() -> Type { 2203 unsafe { from_glib(gio_sys::g_tls_certificate_request_flags_get_type()) } 2204 } 2205 } 2206 2207 impl<'a> FromValueOptional<'a> for TlsCertificateRequestFlags { from_value_optional(value: &Value) -> Option<Self>2208 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2209 Some(FromValue::from_value(value)) 2210 } 2211 } 2212 2213 impl<'a> FromValue<'a> for TlsCertificateRequestFlags { from_value(value: &Value) -> Self2214 unsafe fn from_value(value: &Value) -> Self { 2215 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2216 } 2217 } 2218 2219 impl SetValue for TlsCertificateRequestFlags { set_value(value: &mut Value, this: &Self)2220 unsafe fn set_value(value: &mut Value, this: &Self) { 2221 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2222 } 2223 } 2224 2225 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2226 pub enum TlsDatabaseLookupFlags { 2227 None, 2228 Keypair, 2229 #[doc(hidden)] 2230 __Unknown(i32), 2231 } 2232 2233 impl fmt::Display for TlsDatabaseLookupFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2234 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2235 write!( 2236 f, 2237 "TlsDatabaseLookupFlags::{}", 2238 match *self { 2239 TlsDatabaseLookupFlags::None => "None", 2240 TlsDatabaseLookupFlags::Keypair => "Keypair", 2241 _ => "Unknown", 2242 } 2243 ) 2244 } 2245 } 2246 2247 #[doc(hidden)] 2248 impl ToGlib for TlsDatabaseLookupFlags { 2249 type GlibType = gio_sys::GTlsDatabaseLookupFlags; 2250 to_glib(&self) -> gio_sys::GTlsDatabaseLookupFlags2251 fn to_glib(&self) -> gio_sys::GTlsDatabaseLookupFlags { 2252 match *self { 2253 TlsDatabaseLookupFlags::None => gio_sys::G_TLS_DATABASE_LOOKUP_NONE, 2254 TlsDatabaseLookupFlags::Keypair => gio_sys::G_TLS_DATABASE_LOOKUP_KEYPAIR, 2255 TlsDatabaseLookupFlags::__Unknown(value) => value, 2256 } 2257 } 2258 } 2259 2260 #[doc(hidden)] 2261 impl FromGlib<gio_sys::GTlsDatabaseLookupFlags> for TlsDatabaseLookupFlags { from_glib(value: gio_sys::GTlsDatabaseLookupFlags) -> Self2262 fn from_glib(value: gio_sys::GTlsDatabaseLookupFlags) -> Self { 2263 match value { 2264 0 => TlsDatabaseLookupFlags::None, 2265 1 => TlsDatabaseLookupFlags::Keypair, 2266 value => TlsDatabaseLookupFlags::__Unknown(value), 2267 } 2268 } 2269 } 2270 2271 impl StaticType for TlsDatabaseLookupFlags { static_type() -> Type2272 fn static_type() -> Type { 2273 unsafe { from_glib(gio_sys::g_tls_database_lookup_flags_get_type()) } 2274 } 2275 } 2276 2277 impl<'a> FromValueOptional<'a> for TlsDatabaseLookupFlags { from_value_optional(value: &Value) -> Option<Self>2278 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2279 Some(FromValue::from_value(value)) 2280 } 2281 } 2282 2283 impl<'a> FromValue<'a> for TlsDatabaseLookupFlags { from_value(value: &Value) -> Self2284 unsafe fn from_value(value: &Value) -> Self { 2285 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2286 } 2287 } 2288 2289 impl SetValue for TlsDatabaseLookupFlags { set_value(value: &mut Value, this: &Self)2290 unsafe fn set_value(value: &mut Value, this: &Self) { 2291 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2292 } 2293 } 2294 2295 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2296 pub enum TlsInteractionResult { 2297 Unhandled, 2298 Handled, 2299 Failed, 2300 #[doc(hidden)] 2301 __Unknown(i32), 2302 } 2303 2304 impl fmt::Display for TlsInteractionResult { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2305 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2306 write!( 2307 f, 2308 "TlsInteractionResult::{}", 2309 match *self { 2310 TlsInteractionResult::Unhandled => "Unhandled", 2311 TlsInteractionResult::Handled => "Handled", 2312 TlsInteractionResult::Failed => "Failed", 2313 _ => "Unknown", 2314 } 2315 ) 2316 } 2317 } 2318 2319 #[doc(hidden)] 2320 impl ToGlib for TlsInteractionResult { 2321 type GlibType = gio_sys::GTlsInteractionResult; 2322 to_glib(&self) -> gio_sys::GTlsInteractionResult2323 fn to_glib(&self) -> gio_sys::GTlsInteractionResult { 2324 match *self { 2325 TlsInteractionResult::Unhandled => gio_sys::G_TLS_INTERACTION_UNHANDLED, 2326 TlsInteractionResult::Handled => gio_sys::G_TLS_INTERACTION_HANDLED, 2327 TlsInteractionResult::Failed => gio_sys::G_TLS_INTERACTION_FAILED, 2328 TlsInteractionResult::__Unknown(value) => value, 2329 } 2330 } 2331 } 2332 2333 #[doc(hidden)] 2334 impl FromGlib<gio_sys::GTlsInteractionResult> for TlsInteractionResult { from_glib(value: gio_sys::GTlsInteractionResult) -> Self2335 fn from_glib(value: gio_sys::GTlsInteractionResult) -> Self { 2336 match value { 2337 0 => TlsInteractionResult::Unhandled, 2338 1 => TlsInteractionResult::Handled, 2339 2 => TlsInteractionResult::Failed, 2340 value => TlsInteractionResult::__Unknown(value), 2341 } 2342 } 2343 } 2344 2345 impl StaticType for TlsInteractionResult { static_type() -> Type2346 fn static_type() -> Type { 2347 unsafe { from_glib(gio_sys::g_tls_interaction_result_get_type()) } 2348 } 2349 } 2350 2351 impl<'a> FromValueOptional<'a> for TlsInteractionResult { from_value_optional(value: &Value) -> Option<Self>2352 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2353 Some(FromValue::from_value(value)) 2354 } 2355 } 2356 2357 impl<'a> FromValue<'a> for TlsInteractionResult { from_value(value: &Value) -> Self2358 unsafe fn from_value(value: &Value) -> Self { 2359 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2360 } 2361 } 2362 2363 impl SetValue for TlsInteractionResult { set_value(value: &mut Value, this: &Self)2364 unsafe fn set_value(value: &mut Value, this: &Self) { 2365 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2366 } 2367 } 2368 2369 #[cfg_attr(feature = "v2_60", deprecated)] 2370 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2371 pub enum TlsRehandshakeMode { 2372 Never, 2373 Safely, 2374 Unsafely, 2375 #[doc(hidden)] 2376 __Unknown(i32), 2377 } 2378 2379 #[cfg_attr(feature = "v2_60", deprecated)] 2380 impl fmt::Display for TlsRehandshakeMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2381 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2382 write!( 2383 f, 2384 "TlsRehandshakeMode::{}", 2385 match *self { 2386 TlsRehandshakeMode::Never => "Never", 2387 TlsRehandshakeMode::Safely => "Safely", 2388 TlsRehandshakeMode::Unsafely => "Unsafely", 2389 _ => "Unknown", 2390 } 2391 ) 2392 } 2393 } 2394 2395 #[cfg_attr(feature = "v2_60", deprecated)] 2396 #[doc(hidden)] 2397 impl ToGlib for TlsRehandshakeMode { 2398 type GlibType = gio_sys::GTlsRehandshakeMode; 2399 to_glib(&self) -> gio_sys::GTlsRehandshakeMode2400 fn to_glib(&self) -> gio_sys::GTlsRehandshakeMode { 2401 match *self { 2402 TlsRehandshakeMode::Never => gio_sys::G_TLS_REHANDSHAKE_NEVER, 2403 TlsRehandshakeMode::Safely => gio_sys::G_TLS_REHANDSHAKE_SAFELY, 2404 TlsRehandshakeMode::Unsafely => gio_sys::G_TLS_REHANDSHAKE_UNSAFELY, 2405 TlsRehandshakeMode::__Unknown(value) => value, 2406 } 2407 } 2408 } 2409 2410 #[cfg_attr(feature = "v2_60", deprecated)] 2411 #[doc(hidden)] 2412 impl FromGlib<gio_sys::GTlsRehandshakeMode> for TlsRehandshakeMode { from_glib(value: gio_sys::GTlsRehandshakeMode) -> Self2413 fn from_glib(value: gio_sys::GTlsRehandshakeMode) -> Self { 2414 match value { 2415 0 => TlsRehandshakeMode::Never, 2416 1 => TlsRehandshakeMode::Safely, 2417 2 => TlsRehandshakeMode::Unsafely, 2418 value => TlsRehandshakeMode::__Unknown(value), 2419 } 2420 } 2421 } 2422 2423 #[cfg_attr(feature = "v2_60", deprecated)] 2424 impl StaticType for TlsRehandshakeMode { static_type() -> Type2425 fn static_type() -> Type { 2426 unsafe { from_glib(gio_sys::g_tls_rehandshake_mode_get_type()) } 2427 } 2428 } 2429 2430 #[cfg_attr(feature = "v2_60", deprecated)] 2431 impl<'a> FromValueOptional<'a> for TlsRehandshakeMode { from_value_optional(value: &Value) -> Option<Self>2432 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2433 Some(FromValue::from_value(value)) 2434 } 2435 } 2436 2437 #[cfg_attr(feature = "v2_60", deprecated)] 2438 impl<'a> FromValue<'a> for TlsRehandshakeMode { from_value(value: &Value) -> Self2439 unsafe fn from_value(value: &Value) -> Self { 2440 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2441 } 2442 } 2443 2444 #[cfg_attr(feature = "v2_60", deprecated)] 2445 impl SetValue for TlsRehandshakeMode { set_value(value: &mut Value, this: &Self)2446 unsafe fn set_value(value: &mut Value, this: &Self) { 2447 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2448 } 2449 } 2450 2451 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2452 pub enum UnixSocketAddressType { 2453 Invalid, 2454 Anonymous, 2455 Path, 2456 Abstract, 2457 AbstractPadded, 2458 #[doc(hidden)] 2459 __Unknown(i32), 2460 } 2461 2462 impl fmt::Display for UnixSocketAddressType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2463 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2464 write!( 2465 f, 2466 "UnixSocketAddressType::{}", 2467 match *self { 2468 UnixSocketAddressType::Invalid => "Invalid", 2469 UnixSocketAddressType::Anonymous => "Anonymous", 2470 UnixSocketAddressType::Path => "Path", 2471 UnixSocketAddressType::Abstract => "Abstract", 2472 UnixSocketAddressType::AbstractPadded => "AbstractPadded", 2473 _ => "Unknown", 2474 } 2475 ) 2476 } 2477 } 2478 2479 #[doc(hidden)] 2480 impl ToGlib for UnixSocketAddressType { 2481 type GlibType = gio_sys::GUnixSocketAddressType; 2482 to_glib(&self) -> gio_sys::GUnixSocketAddressType2483 fn to_glib(&self) -> gio_sys::GUnixSocketAddressType { 2484 match *self { 2485 UnixSocketAddressType::Invalid => gio_sys::G_UNIX_SOCKET_ADDRESS_INVALID, 2486 UnixSocketAddressType::Anonymous => gio_sys::G_UNIX_SOCKET_ADDRESS_ANONYMOUS, 2487 UnixSocketAddressType::Path => gio_sys::G_UNIX_SOCKET_ADDRESS_PATH, 2488 UnixSocketAddressType::Abstract => gio_sys::G_UNIX_SOCKET_ADDRESS_ABSTRACT, 2489 UnixSocketAddressType::AbstractPadded => gio_sys::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, 2490 UnixSocketAddressType::__Unknown(value) => value, 2491 } 2492 } 2493 } 2494 2495 #[doc(hidden)] 2496 impl FromGlib<gio_sys::GUnixSocketAddressType> for UnixSocketAddressType { from_glib(value: gio_sys::GUnixSocketAddressType) -> Self2497 fn from_glib(value: gio_sys::GUnixSocketAddressType) -> Self { 2498 match value { 2499 0 => UnixSocketAddressType::Invalid, 2500 1 => UnixSocketAddressType::Anonymous, 2501 2 => UnixSocketAddressType::Path, 2502 3 => UnixSocketAddressType::Abstract, 2503 4 => UnixSocketAddressType::AbstractPadded, 2504 value => UnixSocketAddressType::__Unknown(value), 2505 } 2506 } 2507 } 2508 2509 impl StaticType for UnixSocketAddressType { static_type() -> Type2510 fn static_type() -> Type { 2511 unsafe { from_glib(gio_sys::g_unix_socket_address_type_get_type()) } 2512 } 2513 } 2514 2515 impl<'a> FromValueOptional<'a> for UnixSocketAddressType { from_value_optional(value: &Value) -> Option<Self>2516 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2517 Some(FromValue::from_value(value)) 2518 } 2519 } 2520 2521 impl<'a> FromValue<'a> for UnixSocketAddressType { from_value(value: &Value) -> Self2522 unsafe fn from_value(value: &Value) -> Self { 2523 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2524 } 2525 } 2526 2527 impl SetValue for UnixSocketAddressType { set_value(value: &mut Value, this: &Self)2528 unsafe fn set_value(value: &mut Value, this: &Self) { 2529 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2530 } 2531 } 2532 2533 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] 2534 pub enum ZlibCompressorFormat { 2535 Zlib, 2536 Gzip, 2537 Raw, 2538 #[doc(hidden)] 2539 __Unknown(i32), 2540 } 2541 2542 impl fmt::Display for ZlibCompressorFormat { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2543 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2544 write!( 2545 f, 2546 "ZlibCompressorFormat::{}", 2547 match *self { 2548 ZlibCompressorFormat::Zlib => "Zlib", 2549 ZlibCompressorFormat::Gzip => "Gzip", 2550 ZlibCompressorFormat::Raw => "Raw", 2551 _ => "Unknown", 2552 } 2553 ) 2554 } 2555 } 2556 2557 #[doc(hidden)] 2558 impl ToGlib for ZlibCompressorFormat { 2559 type GlibType = gio_sys::GZlibCompressorFormat; 2560 to_glib(&self) -> gio_sys::GZlibCompressorFormat2561 fn to_glib(&self) -> gio_sys::GZlibCompressorFormat { 2562 match *self { 2563 ZlibCompressorFormat::Zlib => gio_sys::G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 2564 ZlibCompressorFormat::Gzip => gio_sys::G_ZLIB_COMPRESSOR_FORMAT_GZIP, 2565 ZlibCompressorFormat::Raw => gio_sys::G_ZLIB_COMPRESSOR_FORMAT_RAW, 2566 ZlibCompressorFormat::__Unknown(value) => value, 2567 } 2568 } 2569 } 2570 2571 #[doc(hidden)] 2572 impl FromGlib<gio_sys::GZlibCompressorFormat> for ZlibCompressorFormat { from_glib(value: gio_sys::GZlibCompressorFormat) -> Self2573 fn from_glib(value: gio_sys::GZlibCompressorFormat) -> Self { 2574 match value { 2575 0 => ZlibCompressorFormat::Zlib, 2576 1 => ZlibCompressorFormat::Gzip, 2577 2 => ZlibCompressorFormat::Raw, 2578 value => ZlibCompressorFormat::__Unknown(value), 2579 } 2580 } 2581 } 2582 2583 impl StaticType for ZlibCompressorFormat { static_type() -> Type2584 fn static_type() -> Type { 2585 unsafe { from_glib(gio_sys::g_zlib_compressor_format_get_type()) } 2586 } 2587 } 2588 2589 impl<'a> FromValueOptional<'a> for ZlibCompressorFormat { from_value_optional(value: &Value) -> Option<Self>2590 unsafe fn from_value_optional(value: &Value) -> Option<Self> { 2591 Some(FromValue::from_value(value)) 2592 } 2593 } 2594 2595 impl<'a> FromValue<'a> for ZlibCompressorFormat { from_value(value: &Value) -> Self2596 unsafe fn from_value(value: &Value) -> Self { 2597 from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) 2598 } 2599 } 2600 2601 impl SetValue for ZlibCompressorFormat { set_value(value: &mut Value, this: &Self)2602 unsafe fn set_value(value: &mut Value, this: &Self) { 2603 gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) 2604 } 2605 } 2606