gio/auto/
enums.rs

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
5use crate::ffi;
6use glib::{prelude::*, translate::*};
7
8/// An enumeration for well-known message buses.
9#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10#[non_exhaustive]
11#[doc(alias = "GBusType")]
12pub enum BusType {
13    /// An alias for the message bus that activated the process, if any.
14    #[doc(alias = "G_BUS_TYPE_STARTER")]
15    Starter,
16    /// Not a message bus.
17    #[doc(alias = "G_BUS_TYPE_NONE")]
18    None,
19    /// The system-wide message bus.
20    #[doc(alias = "G_BUS_TYPE_SYSTEM")]
21    System,
22    /// The login session message bus.
23    #[doc(alias = "G_BUS_TYPE_SESSION")]
24    Session,
25    #[doc(hidden)]
26    __Unknown(i32),
27}
28
29#[doc(hidden)]
30impl IntoGlib for BusType {
31    type GlibType = ffi::GBusType;
32
33    #[inline]
34    fn into_glib(self) -> ffi::GBusType {
35        match self {
36            Self::Starter => ffi::G_BUS_TYPE_STARTER,
37            Self::None => ffi::G_BUS_TYPE_NONE,
38            Self::System => ffi::G_BUS_TYPE_SYSTEM,
39            Self::Session => ffi::G_BUS_TYPE_SESSION,
40            Self::__Unknown(value) => value,
41        }
42    }
43}
44
45#[doc(hidden)]
46impl FromGlib<ffi::GBusType> for BusType {
47    #[inline]
48    unsafe fn from_glib(value: ffi::GBusType) -> Self {
49        match value {
50            ffi::G_BUS_TYPE_STARTER => Self::Starter,
51            ffi::G_BUS_TYPE_NONE => Self::None,
52            ffi::G_BUS_TYPE_SYSTEM => Self::System,
53            ffi::G_BUS_TYPE_SESSION => Self::Session,
54            value => Self::__Unknown(value),
55        }
56    }
57}
58
59impl StaticType for BusType {
60    #[inline]
61    #[doc(alias = "g_bus_type_get_type")]
62    fn static_type() -> glib::Type {
63        unsafe { from_glib(ffi::g_bus_type_get_type()) }
64    }
65}
66
67impl glib::HasParamSpec for BusType {
68    type ParamSpec = glib::ParamSpecEnum;
69    type SetValue = Self;
70    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
71
72    fn param_spec_builder() -> Self::BuilderFn {
73        Self::ParamSpec::builder_with_default
74    }
75}
76
77impl glib::value::ValueType for BusType {
78    type Type = Self;
79}
80
81unsafe impl<'a> glib::value::FromValue<'a> for BusType {
82    type Checker = glib::value::GenericValueTypeChecker<Self>;
83
84    #[inline]
85    unsafe fn from_value(value: &'a glib::Value) -> Self {
86        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
87    }
88}
89
90impl ToValue for BusType {
91    #[inline]
92    fn to_value(&self) -> glib::Value {
93        let mut value = glib::Value::for_value_type::<Self>();
94        unsafe {
95            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
96        }
97        value
98    }
99
100    #[inline]
101    fn value_type(&self) -> glib::Type {
102        Self::static_type()
103    }
104}
105
106impl From<BusType> for glib::Value {
107    #[inline]
108    fn from(v: BusType) -> Self {
109        ToValue::to_value(&v)
110    }
111}
112
113/// Results returned from g_converter_convert().
114#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
115#[non_exhaustive]
116#[doc(alias = "GConverterResult")]
117pub enum ConverterResult {
118    /// There was an error during conversion.
119    #[doc(alias = "G_CONVERTER_ERROR")]
120    Error,
121    /// Some data was consumed or produced
122    #[doc(alias = "G_CONVERTER_CONVERTED")]
123    Converted,
124    /// The conversion is finished
125    #[doc(alias = "G_CONVERTER_FINISHED")]
126    Finished,
127    /// Flushing is finished
128    #[doc(alias = "G_CONVERTER_FLUSHED")]
129    Flushed,
130    #[doc(hidden)]
131    __Unknown(i32),
132}
133
134#[doc(hidden)]
135impl IntoGlib for ConverterResult {
136    type GlibType = ffi::GConverterResult;
137
138    #[inline]
139    fn into_glib(self) -> ffi::GConverterResult {
140        match self {
141            Self::Error => ffi::G_CONVERTER_ERROR,
142            Self::Converted => ffi::G_CONVERTER_CONVERTED,
143            Self::Finished => ffi::G_CONVERTER_FINISHED,
144            Self::Flushed => ffi::G_CONVERTER_FLUSHED,
145            Self::__Unknown(value) => value,
146        }
147    }
148}
149
150#[doc(hidden)]
151impl FromGlib<ffi::GConverterResult> for ConverterResult {
152    #[inline]
153    unsafe fn from_glib(value: ffi::GConverterResult) -> Self {
154        match value {
155            ffi::G_CONVERTER_ERROR => Self::Error,
156            ffi::G_CONVERTER_CONVERTED => Self::Converted,
157            ffi::G_CONVERTER_FINISHED => Self::Finished,
158            ffi::G_CONVERTER_FLUSHED => Self::Flushed,
159            value => Self::__Unknown(value),
160        }
161    }
162}
163
164impl StaticType for ConverterResult {
165    #[inline]
166    #[doc(alias = "g_converter_result_get_type")]
167    fn static_type() -> glib::Type {
168        unsafe { from_glib(ffi::g_converter_result_get_type()) }
169    }
170}
171
172impl glib::HasParamSpec for ConverterResult {
173    type ParamSpec = glib::ParamSpecEnum;
174    type SetValue = Self;
175    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
176
177    fn param_spec_builder() -> Self::BuilderFn {
178        Self::ParamSpec::builder_with_default
179    }
180}
181
182impl glib::value::ValueType for ConverterResult {
183    type Type = Self;
184}
185
186unsafe impl<'a> glib::value::FromValue<'a> for ConverterResult {
187    type Checker = glib::value::GenericValueTypeChecker<Self>;
188
189    #[inline]
190    unsafe fn from_value(value: &'a glib::Value) -> Self {
191        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
192    }
193}
194
195impl ToValue for ConverterResult {
196    #[inline]
197    fn to_value(&self) -> glib::Value {
198        let mut value = glib::Value::for_value_type::<Self>();
199        unsafe {
200            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
201        }
202        value
203    }
204
205    #[inline]
206    fn value_type(&self) -> glib::Type {
207        Self::static_type()
208    }
209}
210
211impl From<ConverterResult> for glib::Value {
212    #[inline]
213    fn from(v: ConverterResult) -> Self {
214        ToValue::to_value(&v)
215    }
216}
217
218/// Enumeration describing different kinds of native credential types.
219#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
220#[non_exhaustive]
221#[doc(alias = "GCredentialsType")]
222pub enum CredentialsType {
223    /// Indicates an invalid native credential type.
224    #[doc(alias = "G_CREDENTIALS_TYPE_INVALID")]
225    Invalid,
226    /// The native credentials type is a `struct ucred`.
227    #[doc(alias = "G_CREDENTIALS_TYPE_LINUX_UCRED")]
228    LinuxUcred,
229    /// The native credentials type is a `struct cmsgcred`.
230    #[doc(alias = "G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED")]
231    FreebsdCmsgcred,
232    /// The native credentials type is a `struct sockpeercred`. Added in 2.30.
233    #[doc(alias = "G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED")]
234    OpenbsdSockpeercred,
235    /// The native credentials type is a `ucred_t`. Added in 2.40.
236    #[doc(alias = "G_CREDENTIALS_TYPE_SOLARIS_UCRED")]
237    SolarisUcred,
238    /// The native credentials type is a `struct unpcbid`. Added in 2.42.
239    #[doc(alias = "G_CREDENTIALS_TYPE_NETBSD_UNPCBID")]
240    NetbsdUnpcbid,
241    /// The native credentials type is a `struct xucred`. Added in 2.66.
242    #[doc(alias = "G_CREDENTIALS_TYPE_APPLE_XUCRED")]
243    AppleXucred,
244    /// The native credentials type is a PID `DWORD`. Added in 2.72.
245    #[cfg(feature = "v2_72")]
246    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
247    #[doc(alias = "G_CREDENTIALS_TYPE_WIN32_PID")]
248    Win32Pid,
249    #[doc(hidden)]
250    __Unknown(i32),
251}
252
253#[doc(hidden)]
254impl IntoGlib for CredentialsType {
255    type GlibType = ffi::GCredentialsType;
256
257    #[inline]
258    fn into_glib(self) -> ffi::GCredentialsType {
259        match self {
260            Self::Invalid => ffi::G_CREDENTIALS_TYPE_INVALID,
261            Self::LinuxUcred => ffi::G_CREDENTIALS_TYPE_LINUX_UCRED,
262            Self::FreebsdCmsgcred => ffi::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED,
263            Self::OpenbsdSockpeercred => ffi::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED,
264            Self::SolarisUcred => ffi::G_CREDENTIALS_TYPE_SOLARIS_UCRED,
265            Self::NetbsdUnpcbid => ffi::G_CREDENTIALS_TYPE_NETBSD_UNPCBID,
266            Self::AppleXucred => ffi::G_CREDENTIALS_TYPE_APPLE_XUCRED,
267            #[cfg(feature = "v2_72")]
268            Self::Win32Pid => ffi::G_CREDENTIALS_TYPE_WIN32_PID,
269            Self::__Unknown(value) => value,
270        }
271    }
272}
273
274#[doc(hidden)]
275impl FromGlib<ffi::GCredentialsType> for CredentialsType {
276    #[inline]
277    unsafe fn from_glib(value: ffi::GCredentialsType) -> Self {
278        match value {
279            ffi::G_CREDENTIALS_TYPE_INVALID => Self::Invalid,
280            ffi::G_CREDENTIALS_TYPE_LINUX_UCRED => Self::LinuxUcred,
281            ffi::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED => Self::FreebsdCmsgcred,
282            ffi::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED => Self::OpenbsdSockpeercred,
283            ffi::G_CREDENTIALS_TYPE_SOLARIS_UCRED => Self::SolarisUcred,
284            ffi::G_CREDENTIALS_TYPE_NETBSD_UNPCBID => Self::NetbsdUnpcbid,
285            ffi::G_CREDENTIALS_TYPE_APPLE_XUCRED => Self::AppleXucred,
286            #[cfg(feature = "v2_72")]
287            ffi::G_CREDENTIALS_TYPE_WIN32_PID => Self::Win32Pid,
288            value => Self::__Unknown(value),
289        }
290    }
291}
292
293impl StaticType for CredentialsType {
294    #[inline]
295    #[doc(alias = "g_credentials_type_get_type")]
296    fn static_type() -> glib::Type {
297        unsafe { from_glib(ffi::g_credentials_type_get_type()) }
298    }
299}
300
301impl glib::HasParamSpec for CredentialsType {
302    type ParamSpec = glib::ParamSpecEnum;
303    type SetValue = Self;
304    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
305
306    fn param_spec_builder() -> Self::BuilderFn {
307        Self::ParamSpec::builder_with_default
308    }
309}
310
311impl glib::value::ValueType for CredentialsType {
312    type Type = Self;
313}
314
315unsafe impl<'a> glib::value::FromValue<'a> for CredentialsType {
316    type Checker = glib::value::GenericValueTypeChecker<Self>;
317
318    #[inline]
319    unsafe fn from_value(value: &'a glib::Value) -> Self {
320        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
321    }
322}
323
324impl ToValue for CredentialsType {
325    #[inline]
326    fn to_value(&self) -> glib::Value {
327        let mut value = glib::Value::for_value_type::<Self>();
328        unsafe {
329            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
330        }
331        value
332    }
333
334    #[inline]
335    fn value_type(&self) -> glib::Type {
336        Self::static_type()
337    }
338}
339
340impl From<CredentialsType> for glib::Value {
341    #[inline]
342    fn from(v: CredentialsType) -> Self {
343        ToValue::to_value(&v)
344    }
345}
346
347/// Error codes for the `G_DBUS_ERROR` error domain.
348#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
349#[non_exhaustive]
350#[doc(alias = "GDBusError")]
351pub enum DBusError {
352    /// A generic error; "something went wrong" - see the error message for
353    /// more.
354    #[doc(alias = "G_DBUS_ERROR_FAILED")]
355    Failed,
356    /// There was not enough memory to complete an operation.
357    #[doc(alias = "G_DBUS_ERROR_NO_MEMORY")]
358    NoMemory,
359    /// The bus doesn't know how to launch a service to supply the bus name
360    /// you wanted.
361    #[doc(alias = "G_DBUS_ERROR_SERVICE_UNKNOWN")]
362    ServiceUnknown,
363    /// The bus name you referenced doesn't exist (i.e. no application owns
364    /// it).
365    #[doc(alias = "G_DBUS_ERROR_NAME_HAS_NO_OWNER")]
366    NameHasNoOwner,
367    /// No reply to a message expecting one, usually means a timeout occurred.
368    #[doc(alias = "G_DBUS_ERROR_NO_REPLY")]
369    NoReply,
370    /// Something went wrong reading or writing to a socket, for example.
371    #[doc(alias = "G_DBUS_ERROR_IO_ERROR")]
372    IoError,
373    /// A D-Bus bus address was malformed.
374    #[doc(alias = "G_DBUS_ERROR_BAD_ADDRESS")]
375    BadAddress,
376    /// Requested operation isn't supported (like ENOSYS on UNIX).
377    #[doc(alias = "G_DBUS_ERROR_NOT_SUPPORTED")]
378    NotSupported,
379    /// Some limited resource is exhausted.
380    #[doc(alias = "G_DBUS_ERROR_LIMITS_EXCEEDED")]
381    LimitsExceeded,
382    /// Security restrictions don't allow doing what you're trying to do.
383    #[doc(alias = "G_DBUS_ERROR_ACCESS_DENIED")]
384    AccessDenied,
385    /// Authentication didn't work.
386    #[doc(alias = "G_DBUS_ERROR_AUTH_FAILED")]
387    AuthFailed,
388    /// Unable to connect to server (probably caused by ECONNREFUSED on a
389    /// socket).
390    #[doc(alias = "G_DBUS_ERROR_NO_SERVER")]
391    NoServer,
392    /// Certain timeout errors, possibly ETIMEDOUT on a socket.  Note that
393    /// [`NoReply`][Self::NoReply] is used for message reply timeouts. Warning:
394    /// this is confusingly-named given that [`TimedOut`][Self::TimedOut] also
395    /// exists. We can't fix it for compatibility reasons so just be
396    /// careful.
397    #[doc(alias = "G_DBUS_ERROR_TIMEOUT")]
398    Timeout,
399    /// No network access (probably ENETUNREACH on a socket).
400    #[doc(alias = "G_DBUS_ERROR_NO_NETWORK")]
401    NoNetwork,
402    /// Can't bind a socket since its address is in use (i.e. EADDRINUSE).
403    #[doc(alias = "G_DBUS_ERROR_ADDRESS_IN_USE")]
404    AddressInUse,
405    /// The connection is disconnected and you're trying to use it.
406    #[doc(alias = "G_DBUS_ERROR_DISCONNECTED")]
407    Disconnected,
408    /// Invalid arguments passed to a method call.
409    #[doc(alias = "G_DBUS_ERROR_INVALID_ARGS")]
410    InvalidArgs,
411    /// Missing file.
412    #[doc(alias = "G_DBUS_ERROR_FILE_NOT_FOUND")]
413    FileNotFound,
414    /// Existing file and the operation you're using does not silently overwrite.
415    #[doc(alias = "G_DBUS_ERROR_FILE_EXISTS")]
416    FileExists,
417    /// Method name you invoked isn't known by the object you invoked it on.
418    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_METHOD")]
419    UnknownMethod,
420    /// Certain timeout errors, e.g. while starting a service. Warning: this is
421    /// confusingly-named given that [`Timeout`][Self::Timeout] also exists. We
422    /// can't fix it for compatibility reasons so just be careful.
423    #[doc(alias = "G_DBUS_ERROR_TIMED_OUT")]
424    TimedOut,
425    /// Tried to remove or modify a match rule that didn't exist.
426    #[doc(alias = "G_DBUS_ERROR_MATCH_RULE_NOT_FOUND")]
427    MatchRuleNotFound,
428    /// The match rule isn't syntactically valid.
429    #[doc(alias = "G_DBUS_ERROR_MATCH_RULE_INVALID")]
430    MatchRuleInvalid,
431    /// While starting a new process, the exec() call failed.
432    #[doc(alias = "G_DBUS_ERROR_SPAWN_EXEC_FAILED")]
433    SpawnExecFailed,
434    /// While starting a new process, the fork() call failed.
435    #[doc(alias = "G_DBUS_ERROR_SPAWN_FORK_FAILED")]
436    SpawnForkFailed,
437    /// While starting a new process, the child exited with a status code.
438    #[doc(alias = "G_DBUS_ERROR_SPAWN_CHILD_EXITED")]
439    SpawnChildExited,
440    /// While starting a new process, the child exited on a signal.
441    #[doc(alias = "G_DBUS_ERROR_SPAWN_CHILD_SIGNALED")]
442    SpawnChildSignaled,
443    /// While starting a new process, something went wrong.
444    #[doc(alias = "G_DBUS_ERROR_SPAWN_FAILED")]
445    SpawnFailed,
446    /// We failed to setup the environment correctly.
447    #[doc(alias = "G_DBUS_ERROR_SPAWN_SETUP_FAILED")]
448    SpawnSetupFailed,
449    /// We failed to setup the config parser correctly.
450    #[doc(alias = "G_DBUS_ERROR_SPAWN_CONFIG_INVALID")]
451    SpawnConfigInvalid,
452    /// Bus name was not valid.
453    #[doc(alias = "G_DBUS_ERROR_SPAWN_SERVICE_INVALID")]
454    SpawnServiceInvalid,
455    /// Service file not found in system-services directory.
456    #[doc(alias = "G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND")]
457    SpawnServiceNotFound,
458    /// Permissions are incorrect on the setuid helper.
459    #[doc(alias = "G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID")]
460    SpawnPermissionsInvalid,
461    /// Service file invalid (Name, User or Exec missing).
462    #[doc(alias = "G_DBUS_ERROR_SPAWN_FILE_INVALID")]
463    SpawnFileInvalid,
464    /// Tried to get a UNIX process ID and it wasn't available.
465    #[doc(alias = "G_DBUS_ERROR_SPAWN_NO_MEMORY")]
466    SpawnNoMemory,
467    /// Tried to get a UNIX process ID and it wasn't available.
468    #[doc(alias = "G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN")]
469    UnixProcessIdUnknown,
470    /// A type signature is not valid.
471    #[doc(alias = "G_DBUS_ERROR_INVALID_SIGNATURE")]
472    InvalidSignature,
473    /// A file contains invalid syntax or is otherwise broken.
474    #[doc(alias = "G_DBUS_ERROR_INVALID_FILE_CONTENT")]
475    InvalidFileContent,
476    /// Asked for SELinux security context and it wasn't available.
477    #[doc(alias = "G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN")]
478    SelinuxSecurityContextUnknown,
479    /// Asked for ADT audit data and it wasn't available.
480    #[doc(alias = "G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN")]
481    AdtAuditDataUnknown,
482    /// There's already an object with the requested object path.
483    #[doc(alias = "G_DBUS_ERROR_OBJECT_PATH_IN_USE")]
484    ObjectPathInUse,
485    /// Object you invoked a method on isn't known. Since 2.42
486    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_OBJECT")]
487    UnknownObject,
488    /// Interface you invoked a method on isn't known by the object. Since 2.42
489    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_INTERFACE")]
490    UnknownInterface,
491    /// Property you tried to access isn't known by the object. Since 2.42
492    #[doc(alias = "G_DBUS_ERROR_UNKNOWN_PROPERTY")]
493    UnknownProperty,
494    /// Property you tried to set is read-only. Since 2.42
495    #[doc(alias = "G_DBUS_ERROR_PROPERTY_READ_ONLY")]
496    PropertyReadOnly,
497    #[doc(hidden)]
498    __Unknown(i32),
499}
500
501impl DBusError {
502    #[doc(alias = "g_dbus_error_encode_gerror")]
503    pub fn encode_gerror(error: &glib::Error) -> glib::GString {
504        unsafe { from_glib_full(ffi::g_dbus_error_encode_gerror(error.to_glib_none().0)) }
505    }
506
507    #[doc(alias = "g_dbus_error_get_remote_error")]
508    #[doc(alias = "get_remote_error")]
509    pub fn remote_error(error: &glib::Error) -> Option<glib::GString> {
510        unsafe { from_glib_full(ffi::g_dbus_error_get_remote_error(error.to_glib_none().0)) }
511    }
512
513    #[doc(alias = "g_dbus_error_is_remote_error")]
514    pub fn is_remote_error(error: &glib::Error) -> bool {
515        unsafe { from_glib(ffi::g_dbus_error_is_remote_error(error.to_glib_none().0)) }
516    }
517
518    #[doc(alias = "g_dbus_error_new_for_dbus_error")]
519    pub fn new_for_dbus_error(dbus_error_name: &str, dbus_error_message: &str) -> glib::Error {
520        unsafe {
521            from_glib_full(ffi::g_dbus_error_new_for_dbus_error(
522                dbus_error_name.to_glib_none().0,
523                dbus_error_message.to_glib_none().0,
524            ))
525        }
526    }
527
528    #[doc(alias = "g_dbus_error_register_error")]
529    pub fn register_error(
530        error_domain: glib::Quark,
531        error_code: i32,
532        dbus_error_name: &str,
533    ) -> bool {
534        unsafe {
535            from_glib(ffi::g_dbus_error_register_error(
536                error_domain.into_glib(),
537                error_code,
538                dbus_error_name.to_glib_none().0,
539            ))
540        }
541    }
542
543    //#[doc(alias = "g_dbus_error_register_error_domain")]
544    //pub fn register_error_domain(error_domain_quark_name: &str, entries: /*Ignored*/&[DBusErrorEntry]) -> usize {
545    //    unsafe { TODO: call ffi:g_dbus_error_register_error_domain() }
546    //}
547
548    //#[doc(alias = "g_dbus_error_set_dbus_error")]
549    //pub fn set_dbus_error(dbus_error_name: &str, dbus_error_message: &str, format: Option<&str>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<glib::Error> {
550    //    unsafe { TODO: call ffi:g_dbus_error_set_dbus_error() }
551    //}
552
553    //#[doc(alias = "g_dbus_error_set_dbus_error_valist")]
554    //pub fn set_dbus_error_valist(dbus_error_name: &str, dbus_error_message: &str, format: Option<&str>, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) -> Option<glib::Error> {
555    //    unsafe { TODO: call ffi:g_dbus_error_set_dbus_error_valist() }
556    //}
557
558    #[doc(alias = "g_dbus_error_strip_remote_error")]
559    pub fn strip_remote_error(error: &mut glib::Error) -> bool {
560        unsafe {
561            from_glib(ffi::g_dbus_error_strip_remote_error(
562                error.to_glib_none_mut().0,
563            ))
564        }
565    }
566
567    #[doc(alias = "g_dbus_error_unregister_error")]
568    pub fn unregister_error(
569        error_domain: glib::Quark,
570        error_code: i32,
571        dbus_error_name: &str,
572    ) -> bool {
573        unsafe {
574            from_glib(ffi::g_dbus_error_unregister_error(
575                error_domain.into_glib(),
576                error_code,
577                dbus_error_name.to_glib_none().0,
578            ))
579        }
580    }
581}
582
583#[doc(hidden)]
584impl IntoGlib for DBusError {
585    type GlibType = ffi::GDBusError;
586
587    fn into_glib(self) -> ffi::GDBusError {
588        match self {
589            Self::Failed => ffi::G_DBUS_ERROR_FAILED,
590            Self::NoMemory => ffi::G_DBUS_ERROR_NO_MEMORY,
591            Self::ServiceUnknown => ffi::G_DBUS_ERROR_SERVICE_UNKNOWN,
592            Self::NameHasNoOwner => ffi::G_DBUS_ERROR_NAME_HAS_NO_OWNER,
593            Self::NoReply => ffi::G_DBUS_ERROR_NO_REPLY,
594            Self::IoError => ffi::G_DBUS_ERROR_IO_ERROR,
595            Self::BadAddress => ffi::G_DBUS_ERROR_BAD_ADDRESS,
596            Self::NotSupported => ffi::G_DBUS_ERROR_NOT_SUPPORTED,
597            Self::LimitsExceeded => ffi::G_DBUS_ERROR_LIMITS_EXCEEDED,
598            Self::AccessDenied => ffi::G_DBUS_ERROR_ACCESS_DENIED,
599            Self::AuthFailed => ffi::G_DBUS_ERROR_AUTH_FAILED,
600            Self::NoServer => ffi::G_DBUS_ERROR_NO_SERVER,
601            Self::Timeout => ffi::G_DBUS_ERROR_TIMEOUT,
602            Self::NoNetwork => ffi::G_DBUS_ERROR_NO_NETWORK,
603            Self::AddressInUse => ffi::G_DBUS_ERROR_ADDRESS_IN_USE,
604            Self::Disconnected => ffi::G_DBUS_ERROR_DISCONNECTED,
605            Self::InvalidArgs => ffi::G_DBUS_ERROR_INVALID_ARGS,
606            Self::FileNotFound => ffi::G_DBUS_ERROR_FILE_NOT_FOUND,
607            Self::FileExists => ffi::G_DBUS_ERROR_FILE_EXISTS,
608            Self::UnknownMethod => ffi::G_DBUS_ERROR_UNKNOWN_METHOD,
609            Self::TimedOut => ffi::G_DBUS_ERROR_TIMED_OUT,
610            Self::MatchRuleNotFound => ffi::G_DBUS_ERROR_MATCH_RULE_NOT_FOUND,
611            Self::MatchRuleInvalid => ffi::G_DBUS_ERROR_MATCH_RULE_INVALID,
612            Self::SpawnExecFailed => ffi::G_DBUS_ERROR_SPAWN_EXEC_FAILED,
613            Self::SpawnForkFailed => ffi::G_DBUS_ERROR_SPAWN_FORK_FAILED,
614            Self::SpawnChildExited => ffi::G_DBUS_ERROR_SPAWN_CHILD_EXITED,
615            Self::SpawnChildSignaled => ffi::G_DBUS_ERROR_SPAWN_CHILD_SIGNALED,
616            Self::SpawnFailed => ffi::G_DBUS_ERROR_SPAWN_FAILED,
617            Self::SpawnSetupFailed => ffi::G_DBUS_ERROR_SPAWN_SETUP_FAILED,
618            Self::SpawnConfigInvalid => ffi::G_DBUS_ERROR_SPAWN_CONFIG_INVALID,
619            Self::SpawnServiceInvalid => ffi::G_DBUS_ERROR_SPAWN_SERVICE_INVALID,
620            Self::SpawnServiceNotFound => ffi::G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND,
621            Self::SpawnPermissionsInvalid => ffi::G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID,
622            Self::SpawnFileInvalid => ffi::G_DBUS_ERROR_SPAWN_FILE_INVALID,
623            Self::SpawnNoMemory => ffi::G_DBUS_ERROR_SPAWN_NO_MEMORY,
624            Self::UnixProcessIdUnknown => ffi::G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN,
625            Self::InvalidSignature => ffi::G_DBUS_ERROR_INVALID_SIGNATURE,
626            Self::InvalidFileContent => ffi::G_DBUS_ERROR_INVALID_FILE_CONTENT,
627            Self::SelinuxSecurityContextUnknown => {
628                ffi::G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN
629            }
630            Self::AdtAuditDataUnknown => ffi::G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN,
631            Self::ObjectPathInUse => ffi::G_DBUS_ERROR_OBJECT_PATH_IN_USE,
632            Self::UnknownObject => ffi::G_DBUS_ERROR_UNKNOWN_OBJECT,
633            Self::UnknownInterface => ffi::G_DBUS_ERROR_UNKNOWN_INTERFACE,
634            Self::UnknownProperty => ffi::G_DBUS_ERROR_UNKNOWN_PROPERTY,
635            Self::PropertyReadOnly => ffi::G_DBUS_ERROR_PROPERTY_READ_ONLY,
636            Self::__Unknown(value) => value,
637        }
638    }
639}
640
641#[doc(hidden)]
642impl FromGlib<ffi::GDBusError> for DBusError {
643    unsafe fn from_glib(value: ffi::GDBusError) -> Self {
644        match value {
645            ffi::G_DBUS_ERROR_FAILED => Self::Failed,
646            ffi::G_DBUS_ERROR_NO_MEMORY => Self::NoMemory,
647            ffi::G_DBUS_ERROR_SERVICE_UNKNOWN => Self::ServiceUnknown,
648            ffi::G_DBUS_ERROR_NAME_HAS_NO_OWNER => Self::NameHasNoOwner,
649            ffi::G_DBUS_ERROR_NO_REPLY => Self::NoReply,
650            ffi::G_DBUS_ERROR_IO_ERROR => Self::IoError,
651            ffi::G_DBUS_ERROR_BAD_ADDRESS => Self::BadAddress,
652            ffi::G_DBUS_ERROR_NOT_SUPPORTED => Self::NotSupported,
653            ffi::G_DBUS_ERROR_LIMITS_EXCEEDED => Self::LimitsExceeded,
654            ffi::G_DBUS_ERROR_ACCESS_DENIED => Self::AccessDenied,
655            ffi::G_DBUS_ERROR_AUTH_FAILED => Self::AuthFailed,
656            ffi::G_DBUS_ERROR_NO_SERVER => Self::NoServer,
657            ffi::G_DBUS_ERROR_TIMEOUT => Self::Timeout,
658            ffi::G_DBUS_ERROR_NO_NETWORK => Self::NoNetwork,
659            ffi::G_DBUS_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
660            ffi::G_DBUS_ERROR_DISCONNECTED => Self::Disconnected,
661            ffi::G_DBUS_ERROR_INVALID_ARGS => Self::InvalidArgs,
662            ffi::G_DBUS_ERROR_FILE_NOT_FOUND => Self::FileNotFound,
663            ffi::G_DBUS_ERROR_FILE_EXISTS => Self::FileExists,
664            ffi::G_DBUS_ERROR_UNKNOWN_METHOD => Self::UnknownMethod,
665            ffi::G_DBUS_ERROR_TIMED_OUT => Self::TimedOut,
666            ffi::G_DBUS_ERROR_MATCH_RULE_NOT_FOUND => Self::MatchRuleNotFound,
667            ffi::G_DBUS_ERROR_MATCH_RULE_INVALID => Self::MatchRuleInvalid,
668            ffi::G_DBUS_ERROR_SPAWN_EXEC_FAILED => Self::SpawnExecFailed,
669            ffi::G_DBUS_ERROR_SPAWN_FORK_FAILED => Self::SpawnForkFailed,
670            ffi::G_DBUS_ERROR_SPAWN_CHILD_EXITED => Self::SpawnChildExited,
671            ffi::G_DBUS_ERROR_SPAWN_CHILD_SIGNALED => Self::SpawnChildSignaled,
672            ffi::G_DBUS_ERROR_SPAWN_FAILED => Self::SpawnFailed,
673            ffi::G_DBUS_ERROR_SPAWN_SETUP_FAILED => Self::SpawnSetupFailed,
674            ffi::G_DBUS_ERROR_SPAWN_CONFIG_INVALID => Self::SpawnConfigInvalid,
675            ffi::G_DBUS_ERROR_SPAWN_SERVICE_INVALID => Self::SpawnServiceInvalid,
676            ffi::G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND => Self::SpawnServiceNotFound,
677            ffi::G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID => Self::SpawnPermissionsInvalid,
678            ffi::G_DBUS_ERROR_SPAWN_FILE_INVALID => Self::SpawnFileInvalid,
679            ffi::G_DBUS_ERROR_SPAWN_NO_MEMORY => Self::SpawnNoMemory,
680            ffi::G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN => Self::UnixProcessIdUnknown,
681            ffi::G_DBUS_ERROR_INVALID_SIGNATURE => Self::InvalidSignature,
682            ffi::G_DBUS_ERROR_INVALID_FILE_CONTENT => Self::InvalidFileContent,
683            ffi::G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN => {
684                Self::SelinuxSecurityContextUnknown
685            }
686            ffi::G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN => Self::AdtAuditDataUnknown,
687            ffi::G_DBUS_ERROR_OBJECT_PATH_IN_USE => Self::ObjectPathInUse,
688            ffi::G_DBUS_ERROR_UNKNOWN_OBJECT => Self::UnknownObject,
689            ffi::G_DBUS_ERROR_UNKNOWN_INTERFACE => Self::UnknownInterface,
690            ffi::G_DBUS_ERROR_UNKNOWN_PROPERTY => Self::UnknownProperty,
691            ffi::G_DBUS_ERROR_PROPERTY_READ_ONLY => Self::PropertyReadOnly,
692            value => Self::__Unknown(value),
693        }
694    }
695}
696
697impl glib::error::ErrorDomain for DBusError {
698    #[inline]
699    fn domain() -> glib::Quark {
700        unsafe { from_glib(ffi::g_dbus_error_quark()) }
701    }
702
703    #[inline]
704    fn code(self) -> i32 {
705        self.into_glib()
706    }
707
708    #[inline]
709    #[allow(clippy::match_single_binding)]
710    fn from(code: i32) -> Option<Self> {
711        match unsafe { from_glib(code) } {
712            Self::__Unknown(_) => Some(Self::Failed),
713            value => Some(value),
714        }
715    }
716}
717
718impl StaticType for DBusError {
719    #[inline]
720    #[doc(alias = "g_dbus_error_get_type")]
721    fn static_type() -> glib::Type {
722        unsafe { from_glib(ffi::g_dbus_error_get_type()) }
723    }
724}
725
726impl glib::HasParamSpec for DBusError {
727    type ParamSpec = glib::ParamSpecEnum;
728    type SetValue = Self;
729    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
730
731    fn param_spec_builder() -> Self::BuilderFn {
732        Self::ParamSpec::builder_with_default
733    }
734}
735
736impl glib::value::ValueType for DBusError {
737    type Type = Self;
738}
739
740unsafe impl<'a> glib::value::FromValue<'a> for DBusError {
741    type Checker = glib::value::GenericValueTypeChecker<Self>;
742
743    #[inline]
744    unsafe fn from_value(value: &'a glib::Value) -> Self {
745        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
746    }
747}
748
749impl ToValue for DBusError {
750    #[inline]
751    fn to_value(&self) -> glib::Value {
752        let mut value = glib::Value::for_value_type::<Self>();
753        unsafe {
754            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
755        }
756        value
757    }
758
759    #[inline]
760    fn value_type(&self) -> glib::Type {
761        Self::static_type()
762    }
763}
764
765impl From<DBusError> for glib::Value {
766    #[inline]
767    fn from(v: DBusError) -> Self {
768        ToValue::to_value(&v)
769    }
770}
771
772/// Enumeration used to describe the byte order of a D-Bus message.
773#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
774#[non_exhaustive]
775#[doc(alias = "GDBusMessageByteOrder")]
776pub enum DBusMessageByteOrder {
777    /// The byte order is big endian.
778    #[doc(alias = "G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN")]
779    BigEndian,
780    /// The byte order is little endian.
781    #[doc(alias = "G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN")]
782    LittleEndian,
783    #[doc(hidden)]
784    __Unknown(i32),
785}
786
787#[doc(hidden)]
788impl IntoGlib for DBusMessageByteOrder {
789    type GlibType = ffi::GDBusMessageByteOrder;
790
791    #[inline]
792    fn into_glib(self) -> ffi::GDBusMessageByteOrder {
793        match self {
794            Self::BigEndian => ffi::G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN,
795            Self::LittleEndian => ffi::G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN,
796            Self::__Unknown(value) => value,
797        }
798    }
799}
800
801#[doc(hidden)]
802impl FromGlib<ffi::GDBusMessageByteOrder> for DBusMessageByteOrder {
803    #[inline]
804    unsafe fn from_glib(value: ffi::GDBusMessageByteOrder) -> Self {
805        match value {
806            ffi::G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN => Self::BigEndian,
807            ffi::G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN => Self::LittleEndian,
808            value => Self::__Unknown(value),
809        }
810    }
811}
812
813impl StaticType for DBusMessageByteOrder {
814    #[inline]
815    #[doc(alias = "g_dbus_message_byte_order_get_type")]
816    fn static_type() -> glib::Type {
817        unsafe { from_glib(ffi::g_dbus_message_byte_order_get_type()) }
818    }
819}
820
821impl glib::HasParamSpec for DBusMessageByteOrder {
822    type ParamSpec = glib::ParamSpecEnum;
823    type SetValue = Self;
824    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
825
826    fn param_spec_builder() -> Self::BuilderFn {
827        Self::ParamSpec::builder_with_default
828    }
829}
830
831impl glib::value::ValueType for DBusMessageByteOrder {
832    type Type = Self;
833}
834
835unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageByteOrder {
836    type Checker = glib::value::GenericValueTypeChecker<Self>;
837
838    #[inline]
839    unsafe fn from_value(value: &'a glib::Value) -> Self {
840        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
841    }
842}
843
844impl ToValue for DBusMessageByteOrder {
845    #[inline]
846    fn to_value(&self) -> glib::Value {
847        let mut value = glib::Value::for_value_type::<Self>();
848        unsafe {
849            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
850        }
851        value
852    }
853
854    #[inline]
855    fn value_type(&self) -> glib::Type {
856        Self::static_type()
857    }
858}
859
860impl From<DBusMessageByteOrder> for glib::Value {
861    #[inline]
862    fn from(v: DBusMessageByteOrder) -> Self {
863        ToValue::to_value(&v)
864    }
865}
866
867/// Header fields used in #GDBusMessage.
868#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
869#[non_exhaustive]
870#[doc(alias = "GDBusMessageHeaderField")]
871pub enum DBusMessageHeaderField {
872    /// Not a valid header field.
873    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_INVALID")]
874    Invalid,
875    /// The object path.
876    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_PATH")]
877    Path,
878    /// The interface name.
879    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE")]
880    Interface,
881    /// The method or signal name.
882    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_MEMBER")]
883    Member,
884    /// The name of the error that occurred.
885    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME")]
886    ErrorName,
887    /// The serial number the message is a reply to.
888    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL")]
889    ReplySerial,
890    /// The name the message is intended for.
891    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION")]
892    Destination,
893    /// Unique name of the sender of the message (filled in by the bus).
894    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_SENDER")]
895    Sender,
896    /// The signature of the message body.
897    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE")]
898    Signature,
899    /// The number of UNIX file descriptors that accompany the message.
900    #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS")]
901    NumUnixFds,
902    #[doc(hidden)]
903    __Unknown(i32),
904}
905
906#[doc(hidden)]
907impl IntoGlib for DBusMessageHeaderField {
908    type GlibType = ffi::GDBusMessageHeaderField;
909
910    #[inline]
911    fn into_glib(self) -> ffi::GDBusMessageHeaderField {
912        match self {
913            Self::Invalid => ffi::G_DBUS_MESSAGE_HEADER_FIELD_INVALID,
914            Self::Path => ffi::G_DBUS_MESSAGE_HEADER_FIELD_PATH,
915            Self::Interface => ffi::G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE,
916            Self::Member => ffi::G_DBUS_MESSAGE_HEADER_FIELD_MEMBER,
917            Self::ErrorName => ffi::G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME,
918            Self::ReplySerial => ffi::G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL,
919            Self::Destination => ffi::G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION,
920            Self::Sender => ffi::G_DBUS_MESSAGE_HEADER_FIELD_SENDER,
921            Self::Signature => ffi::G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE,
922            Self::NumUnixFds => ffi::G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS,
923            Self::__Unknown(value) => value,
924        }
925    }
926}
927
928#[doc(hidden)]
929impl FromGlib<ffi::GDBusMessageHeaderField> for DBusMessageHeaderField {
930    #[inline]
931    unsafe fn from_glib(value: ffi::GDBusMessageHeaderField) -> Self {
932        match value {
933            ffi::G_DBUS_MESSAGE_HEADER_FIELD_INVALID => Self::Invalid,
934            ffi::G_DBUS_MESSAGE_HEADER_FIELD_PATH => Self::Path,
935            ffi::G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE => Self::Interface,
936            ffi::G_DBUS_MESSAGE_HEADER_FIELD_MEMBER => Self::Member,
937            ffi::G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME => Self::ErrorName,
938            ffi::G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL => Self::ReplySerial,
939            ffi::G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION => Self::Destination,
940            ffi::G_DBUS_MESSAGE_HEADER_FIELD_SENDER => Self::Sender,
941            ffi::G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE => Self::Signature,
942            ffi::G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS => Self::NumUnixFds,
943            value => Self::__Unknown(value),
944        }
945    }
946}
947
948impl StaticType for DBusMessageHeaderField {
949    #[inline]
950    #[doc(alias = "g_dbus_message_header_field_get_type")]
951    fn static_type() -> glib::Type {
952        unsafe { from_glib(ffi::g_dbus_message_header_field_get_type()) }
953    }
954}
955
956impl glib::HasParamSpec for DBusMessageHeaderField {
957    type ParamSpec = glib::ParamSpecEnum;
958    type SetValue = Self;
959    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
960
961    fn param_spec_builder() -> Self::BuilderFn {
962        Self::ParamSpec::builder_with_default
963    }
964}
965
966impl glib::value::ValueType for DBusMessageHeaderField {
967    type Type = Self;
968}
969
970unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageHeaderField {
971    type Checker = glib::value::GenericValueTypeChecker<Self>;
972
973    #[inline]
974    unsafe fn from_value(value: &'a glib::Value) -> Self {
975        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
976    }
977}
978
979impl ToValue for DBusMessageHeaderField {
980    #[inline]
981    fn to_value(&self) -> glib::Value {
982        let mut value = glib::Value::for_value_type::<Self>();
983        unsafe {
984            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
985        }
986        value
987    }
988
989    #[inline]
990    fn value_type(&self) -> glib::Type {
991        Self::static_type()
992    }
993}
994
995impl From<DBusMessageHeaderField> for glib::Value {
996    #[inline]
997    fn from(v: DBusMessageHeaderField) -> Self {
998        ToValue::to_value(&v)
999    }
1000}
1001
1002/// Message types used in #GDBusMessage.
1003#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1004#[non_exhaustive]
1005#[doc(alias = "GDBusMessageType")]
1006pub enum DBusMessageType {
1007    /// Message is of invalid type.
1008    #[doc(alias = "G_DBUS_MESSAGE_TYPE_INVALID")]
1009    Invalid,
1010    /// Method call.
1011    #[doc(alias = "G_DBUS_MESSAGE_TYPE_METHOD_CALL")]
1012    MethodCall,
1013    /// Method reply.
1014    #[doc(alias = "G_DBUS_MESSAGE_TYPE_METHOD_RETURN")]
1015    MethodReturn,
1016    /// Error reply.
1017    #[doc(alias = "G_DBUS_MESSAGE_TYPE_ERROR")]
1018    Error,
1019    /// Signal emission.
1020    #[doc(alias = "G_DBUS_MESSAGE_TYPE_SIGNAL")]
1021    Signal,
1022    #[doc(hidden)]
1023    __Unknown(i32),
1024}
1025
1026#[doc(hidden)]
1027impl IntoGlib for DBusMessageType {
1028    type GlibType = ffi::GDBusMessageType;
1029
1030    #[inline]
1031    fn into_glib(self) -> ffi::GDBusMessageType {
1032        match self {
1033            Self::Invalid => ffi::G_DBUS_MESSAGE_TYPE_INVALID,
1034            Self::MethodCall => ffi::G_DBUS_MESSAGE_TYPE_METHOD_CALL,
1035            Self::MethodReturn => ffi::G_DBUS_MESSAGE_TYPE_METHOD_RETURN,
1036            Self::Error => ffi::G_DBUS_MESSAGE_TYPE_ERROR,
1037            Self::Signal => ffi::G_DBUS_MESSAGE_TYPE_SIGNAL,
1038            Self::__Unknown(value) => value,
1039        }
1040    }
1041}
1042
1043#[doc(hidden)]
1044impl FromGlib<ffi::GDBusMessageType> for DBusMessageType {
1045    #[inline]
1046    unsafe fn from_glib(value: ffi::GDBusMessageType) -> Self {
1047        match value {
1048            ffi::G_DBUS_MESSAGE_TYPE_INVALID => Self::Invalid,
1049            ffi::G_DBUS_MESSAGE_TYPE_METHOD_CALL => Self::MethodCall,
1050            ffi::G_DBUS_MESSAGE_TYPE_METHOD_RETURN => Self::MethodReturn,
1051            ffi::G_DBUS_MESSAGE_TYPE_ERROR => Self::Error,
1052            ffi::G_DBUS_MESSAGE_TYPE_SIGNAL => Self::Signal,
1053            value => Self::__Unknown(value),
1054        }
1055    }
1056}
1057
1058impl StaticType for DBusMessageType {
1059    #[inline]
1060    #[doc(alias = "g_dbus_message_type_get_type")]
1061    fn static_type() -> glib::Type {
1062        unsafe { from_glib(ffi::g_dbus_message_type_get_type()) }
1063    }
1064}
1065
1066impl glib::HasParamSpec for DBusMessageType {
1067    type ParamSpec = glib::ParamSpecEnum;
1068    type SetValue = Self;
1069    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1070
1071    fn param_spec_builder() -> Self::BuilderFn {
1072        Self::ParamSpec::builder_with_default
1073    }
1074}
1075
1076impl glib::value::ValueType for DBusMessageType {
1077    type Type = Self;
1078}
1079
1080unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageType {
1081    type Checker = glib::value::GenericValueTypeChecker<Self>;
1082
1083    #[inline]
1084    unsafe fn from_value(value: &'a glib::Value) -> Self {
1085        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1086    }
1087}
1088
1089impl ToValue for DBusMessageType {
1090    #[inline]
1091    fn to_value(&self) -> glib::Value {
1092        let mut value = glib::Value::for_value_type::<Self>();
1093        unsafe {
1094            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1095        }
1096        value
1097    }
1098
1099    #[inline]
1100    fn value_type(&self) -> glib::Type {
1101        Self::static_type()
1102    }
1103}
1104
1105impl From<DBusMessageType> for glib::Value {
1106    #[inline]
1107    fn from(v: DBusMessageType) -> Self {
1108        ToValue::to_value(&v)
1109    }
1110}
1111
1112/// #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
1113/// across various machine architectures.
1114#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1115#[non_exhaustive]
1116#[doc(alias = "GDataStreamByteOrder")]
1117pub enum DataStreamByteOrder {
1118    /// Selects Big Endian byte order.
1119    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN")]
1120    BigEndian,
1121    /// Selects Little Endian byte order.
1122    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN")]
1123    LittleEndian,
1124    /// Selects endianness based on host machine's architecture.
1125    #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN")]
1126    HostEndian,
1127    #[doc(hidden)]
1128    __Unknown(i32),
1129}
1130
1131#[doc(hidden)]
1132impl IntoGlib for DataStreamByteOrder {
1133    type GlibType = ffi::GDataStreamByteOrder;
1134
1135    #[inline]
1136    fn into_glib(self) -> ffi::GDataStreamByteOrder {
1137        match self {
1138            Self::BigEndian => ffi::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN,
1139            Self::LittleEndian => ffi::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN,
1140            Self::HostEndian => ffi::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN,
1141            Self::__Unknown(value) => value,
1142        }
1143    }
1144}
1145
1146#[doc(hidden)]
1147impl FromGlib<ffi::GDataStreamByteOrder> for DataStreamByteOrder {
1148    #[inline]
1149    unsafe fn from_glib(value: ffi::GDataStreamByteOrder) -> Self {
1150        match value {
1151            ffi::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN => Self::BigEndian,
1152            ffi::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN => Self::LittleEndian,
1153            ffi::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN => Self::HostEndian,
1154            value => Self::__Unknown(value),
1155        }
1156    }
1157}
1158
1159impl StaticType for DataStreamByteOrder {
1160    #[inline]
1161    #[doc(alias = "g_data_stream_byte_order_get_type")]
1162    fn static_type() -> glib::Type {
1163        unsafe { from_glib(ffi::g_data_stream_byte_order_get_type()) }
1164    }
1165}
1166
1167impl glib::HasParamSpec for DataStreamByteOrder {
1168    type ParamSpec = glib::ParamSpecEnum;
1169    type SetValue = Self;
1170    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1171
1172    fn param_spec_builder() -> Self::BuilderFn {
1173        Self::ParamSpec::builder_with_default
1174    }
1175}
1176
1177impl glib::value::ValueType for DataStreamByteOrder {
1178    type Type = Self;
1179}
1180
1181unsafe impl<'a> glib::value::FromValue<'a> for DataStreamByteOrder {
1182    type Checker = glib::value::GenericValueTypeChecker<Self>;
1183
1184    #[inline]
1185    unsafe fn from_value(value: &'a glib::Value) -> Self {
1186        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1187    }
1188}
1189
1190impl ToValue for DataStreamByteOrder {
1191    #[inline]
1192    fn to_value(&self) -> glib::Value {
1193        let mut value = glib::Value::for_value_type::<Self>();
1194        unsafe {
1195            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1196        }
1197        value
1198    }
1199
1200    #[inline]
1201    fn value_type(&self) -> glib::Type {
1202        Self::static_type()
1203    }
1204}
1205
1206impl From<DataStreamByteOrder> for glib::Value {
1207    #[inline]
1208    fn from(v: DataStreamByteOrder) -> Self {
1209        ToValue::to_value(&v)
1210    }
1211}
1212
1213/// #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
1214#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1215#[non_exhaustive]
1216#[doc(alias = "GDataStreamNewlineType")]
1217pub enum DataStreamNewlineType {
1218    /// Selects "LF" line endings, common on most modern UNIX platforms.
1219    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_LF")]
1220    Lf,
1221    /// Selects "CR" line endings.
1222    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_CR")]
1223    Cr,
1224    /// Selects "CR, LF" line ending, common on Microsoft Windows.
1225    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_CR_LF")]
1226    CrLf,
1227    /// Automatically try to handle any line ending type.
1228    #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_ANY")]
1229    Any,
1230    #[doc(hidden)]
1231    __Unknown(i32),
1232}
1233
1234#[doc(hidden)]
1235impl IntoGlib for DataStreamNewlineType {
1236    type GlibType = ffi::GDataStreamNewlineType;
1237
1238    #[inline]
1239    fn into_glib(self) -> ffi::GDataStreamNewlineType {
1240        match self {
1241            Self::Lf => ffi::G_DATA_STREAM_NEWLINE_TYPE_LF,
1242            Self::Cr => ffi::G_DATA_STREAM_NEWLINE_TYPE_CR,
1243            Self::CrLf => ffi::G_DATA_STREAM_NEWLINE_TYPE_CR_LF,
1244            Self::Any => ffi::G_DATA_STREAM_NEWLINE_TYPE_ANY,
1245            Self::__Unknown(value) => value,
1246        }
1247    }
1248}
1249
1250#[doc(hidden)]
1251impl FromGlib<ffi::GDataStreamNewlineType> for DataStreamNewlineType {
1252    #[inline]
1253    unsafe fn from_glib(value: ffi::GDataStreamNewlineType) -> Self {
1254        match value {
1255            ffi::G_DATA_STREAM_NEWLINE_TYPE_LF => Self::Lf,
1256            ffi::G_DATA_STREAM_NEWLINE_TYPE_CR => Self::Cr,
1257            ffi::G_DATA_STREAM_NEWLINE_TYPE_CR_LF => Self::CrLf,
1258            ffi::G_DATA_STREAM_NEWLINE_TYPE_ANY => Self::Any,
1259            value => Self::__Unknown(value),
1260        }
1261    }
1262}
1263
1264impl StaticType for DataStreamNewlineType {
1265    #[inline]
1266    #[doc(alias = "g_data_stream_newline_type_get_type")]
1267    fn static_type() -> glib::Type {
1268        unsafe { from_glib(ffi::g_data_stream_newline_type_get_type()) }
1269    }
1270}
1271
1272impl glib::HasParamSpec for DataStreamNewlineType {
1273    type ParamSpec = glib::ParamSpecEnum;
1274    type SetValue = Self;
1275    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1276
1277    fn param_spec_builder() -> Self::BuilderFn {
1278        Self::ParamSpec::builder_with_default
1279    }
1280}
1281
1282impl glib::value::ValueType for DataStreamNewlineType {
1283    type Type = Self;
1284}
1285
1286unsafe impl<'a> glib::value::FromValue<'a> for DataStreamNewlineType {
1287    type Checker = glib::value::GenericValueTypeChecker<Self>;
1288
1289    #[inline]
1290    unsafe fn from_value(value: &'a glib::Value) -> Self {
1291        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1292    }
1293}
1294
1295impl ToValue for DataStreamNewlineType {
1296    #[inline]
1297    fn to_value(&self) -> glib::Value {
1298        let mut value = glib::Value::for_value_type::<Self>();
1299        unsafe {
1300            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1301        }
1302        value
1303    }
1304
1305    #[inline]
1306    fn value_type(&self) -> glib::Type {
1307        Self::static_type()
1308    }
1309}
1310
1311impl From<DataStreamNewlineType> for glib::Value {
1312    #[inline]
1313    fn from(v: DataStreamNewlineType) -> Self {
1314        ToValue::to_value(&v)
1315    }
1316}
1317
1318/// Enumeration describing how a drive can be started/stopped.
1319#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1320#[non_exhaustive]
1321#[doc(alias = "GDriveStartStopType")]
1322pub enum DriveStartStopType {
1323    /// Unknown or drive doesn't support
1324    ///    start/stop.
1325    #[doc(alias = "G_DRIVE_START_STOP_TYPE_UNKNOWN")]
1326    Unknown,
1327    /// The stop method will physically
1328    ///    shut down the drive and e.g. power down the port the drive is
1329    ///    attached to.
1330    #[doc(alias = "G_DRIVE_START_STOP_TYPE_SHUTDOWN")]
1331    Shutdown,
1332    /// The start/stop methods are used
1333    ///    for connecting/disconnect to the drive over the network.
1334    #[doc(alias = "G_DRIVE_START_STOP_TYPE_NETWORK")]
1335    Network,
1336    /// The start/stop methods will
1337    ///    assemble/disassemble a virtual drive from several physical
1338    ///    drives.
1339    #[doc(alias = "G_DRIVE_START_STOP_TYPE_MULTIDISK")]
1340    Multidisk,
1341    /// The start/stop methods will
1342    ///    unlock/lock the disk (for example using the ATA `SECURITY UNLOCK
1343    ///    DEVICE` command)
1344    #[doc(alias = "G_DRIVE_START_STOP_TYPE_PASSWORD")]
1345    Password,
1346    #[doc(hidden)]
1347    __Unknown(i32),
1348}
1349
1350#[doc(hidden)]
1351impl IntoGlib for DriveStartStopType {
1352    type GlibType = ffi::GDriveStartStopType;
1353
1354    #[inline]
1355    fn into_glib(self) -> ffi::GDriveStartStopType {
1356        match self {
1357            Self::Unknown => ffi::G_DRIVE_START_STOP_TYPE_UNKNOWN,
1358            Self::Shutdown => ffi::G_DRIVE_START_STOP_TYPE_SHUTDOWN,
1359            Self::Network => ffi::G_DRIVE_START_STOP_TYPE_NETWORK,
1360            Self::Multidisk => ffi::G_DRIVE_START_STOP_TYPE_MULTIDISK,
1361            Self::Password => ffi::G_DRIVE_START_STOP_TYPE_PASSWORD,
1362            Self::__Unknown(value) => value,
1363        }
1364    }
1365}
1366
1367#[doc(hidden)]
1368impl FromGlib<ffi::GDriveStartStopType> for DriveStartStopType {
1369    #[inline]
1370    unsafe fn from_glib(value: ffi::GDriveStartStopType) -> Self {
1371        match value {
1372            ffi::G_DRIVE_START_STOP_TYPE_UNKNOWN => Self::Unknown,
1373            ffi::G_DRIVE_START_STOP_TYPE_SHUTDOWN => Self::Shutdown,
1374            ffi::G_DRIVE_START_STOP_TYPE_NETWORK => Self::Network,
1375            ffi::G_DRIVE_START_STOP_TYPE_MULTIDISK => Self::Multidisk,
1376            ffi::G_DRIVE_START_STOP_TYPE_PASSWORD => Self::Password,
1377            value => Self::__Unknown(value),
1378        }
1379    }
1380}
1381
1382impl StaticType for DriveStartStopType {
1383    #[inline]
1384    #[doc(alias = "g_drive_start_stop_type_get_type")]
1385    fn static_type() -> glib::Type {
1386        unsafe { from_glib(ffi::g_drive_start_stop_type_get_type()) }
1387    }
1388}
1389
1390impl glib::HasParamSpec for DriveStartStopType {
1391    type ParamSpec = glib::ParamSpecEnum;
1392    type SetValue = Self;
1393    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1394
1395    fn param_spec_builder() -> Self::BuilderFn {
1396        Self::ParamSpec::builder_with_default
1397    }
1398}
1399
1400impl glib::value::ValueType for DriveStartStopType {
1401    type Type = Self;
1402}
1403
1404unsafe impl<'a> glib::value::FromValue<'a> for DriveStartStopType {
1405    type Checker = glib::value::GenericValueTypeChecker<Self>;
1406
1407    #[inline]
1408    unsafe fn from_value(value: &'a glib::Value) -> Self {
1409        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1410    }
1411}
1412
1413impl ToValue for DriveStartStopType {
1414    #[inline]
1415    fn to_value(&self) -> glib::Value {
1416        let mut value = glib::Value::for_value_type::<Self>();
1417        unsafe {
1418            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1419        }
1420        value
1421    }
1422
1423    #[inline]
1424    fn value_type(&self) -> glib::Type {
1425        Self::static_type()
1426    }
1427}
1428
1429impl From<DriveStartStopType> for glib::Value {
1430    #[inline]
1431    fn from(v: DriveStartStopType) -> Self {
1432        ToValue::to_value(&v)
1433    }
1434}
1435
1436/// Possible values of Explicit Congestion Notification code points.
1437///
1438/// These appear in `TOS` (IPv4) or `TCLASS` (IPv6) packet headers and
1439/// are described in [RFC 3168](https://www.rfc-editor.org/rfc/rfc3168#section-5).
1440#[cfg(feature = "v2_88")]
1441#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1442#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1443#[non_exhaustive]
1444#[doc(alias = "GEcnCodePoint")]
1445pub enum EcnCodePoint {
1446    /// Not ECN-capable transport
1447    #[doc(alias = "G_ECN_NO_ECN")]
1448    NoEcn,
1449    /// ECN Capable Transport(1)
1450    #[doc(alias = "G_ECN_ECT_1")]
1451    Ect1,
1452    /// ECN Capable Transport(0)
1453    #[doc(alias = "G_ECN_ECT_0")]
1454    Ect0,
1455    /// Congestion Experienced
1456    #[doc(alias = "G_ECN_ECT_CE")]
1457    EctCe,
1458    #[doc(hidden)]
1459    __Unknown(i32),
1460}
1461
1462#[cfg(feature = "v2_88")]
1463#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1464#[doc(hidden)]
1465impl IntoGlib for EcnCodePoint {
1466    type GlibType = ffi::GEcnCodePoint;
1467
1468    #[inline]
1469    fn into_glib(self) -> ffi::GEcnCodePoint {
1470        match self {
1471            Self::NoEcn => ffi::G_ECN_NO_ECN,
1472            Self::Ect1 => ffi::G_ECN_ECT_1,
1473            Self::Ect0 => ffi::G_ECN_ECT_0,
1474            Self::EctCe => ffi::G_ECN_ECT_CE,
1475            Self::__Unknown(value) => value,
1476        }
1477    }
1478}
1479
1480#[cfg(feature = "v2_88")]
1481#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1482#[doc(hidden)]
1483impl FromGlib<ffi::GEcnCodePoint> for EcnCodePoint {
1484    #[inline]
1485    unsafe fn from_glib(value: ffi::GEcnCodePoint) -> Self {
1486        match value {
1487            ffi::G_ECN_NO_ECN => Self::NoEcn,
1488            ffi::G_ECN_ECT_1 => Self::Ect1,
1489            ffi::G_ECN_ECT_0 => Self::Ect0,
1490            ffi::G_ECN_ECT_CE => Self::EctCe,
1491            value => Self::__Unknown(value),
1492        }
1493    }
1494}
1495
1496#[cfg(feature = "v2_88")]
1497#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1498impl StaticType for EcnCodePoint {
1499    #[inline]
1500    #[doc(alias = "g_ecn_code_point_get_type")]
1501    fn static_type() -> glib::Type {
1502        unsafe { from_glib(ffi::g_ecn_code_point_get_type()) }
1503    }
1504}
1505
1506#[cfg(feature = "v2_88")]
1507#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1508impl glib::HasParamSpec for EcnCodePoint {
1509    type ParamSpec = glib::ParamSpecEnum;
1510    type SetValue = Self;
1511    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1512
1513    fn param_spec_builder() -> Self::BuilderFn {
1514        Self::ParamSpec::builder_with_default
1515    }
1516}
1517
1518#[cfg(feature = "v2_88")]
1519#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1520impl glib::value::ValueType for EcnCodePoint {
1521    type Type = Self;
1522}
1523
1524#[cfg(feature = "v2_88")]
1525#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1526unsafe impl<'a> glib::value::FromValue<'a> for EcnCodePoint {
1527    type Checker = glib::value::GenericValueTypeChecker<Self>;
1528
1529    #[inline]
1530    unsafe fn from_value(value: &'a glib::Value) -> Self {
1531        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1532    }
1533}
1534
1535#[cfg(feature = "v2_88")]
1536#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1537impl ToValue for EcnCodePoint {
1538    #[inline]
1539    fn to_value(&self) -> glib::Value {
1540        let mut value = glib::Value::for_value_type::<Self>();
1541        unsafe {
1542            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1543        }
1544        value
1545    }
1546
1547    #[inline]
1548    fn value_type(&self) -> glib::Type {
1549        Self::static_type()
1550    }
1551}
1552
1553#[cfg(feature = "v2_88")]
1554#[cfg_attr(docsrs, doc(cfg(feature = "v2_88")))]
1555impl From<EcnCodePoint> for glib::Value {
1556    #[inline]
1557    fn from(v: EcnCodePoint) -> Self {
1558        ToValue::to_value(&v)
1559    }
1560}
1561
1562/// GEmblemOrigin is used to add information about the origin of the emblem
1563/// to #GEmblem.
1564#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1565#[non_exhaustive]
1566#[doc(alias = "GEmblemOrigin")]
1567pub enum EmblemOrigin {
1568    /// Emblem of unknown origin
1569    #[doc(alias = "G_EMBLEM_ORIGIN_UNKNOWN")]
1570    Unknown,
1571    /// Emblem adds device-specific information
1572    #[doc(alias = "G_EMBLEM_ORIGIN_DEVICE")]
1573    Device,
1574    /// Emblem depicts live metadata, such as "readonly"
1575    #[doc(alias = "G_EMBLEM_ORIGIN_LIVEMETADATA")]
1576    Livemetadata,
1577    /// Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
1578    #[doc(alias = "G_EMBLEM_ORIGIN_TAG")]
1579    Tag,
1580    #[doc(hidden)]
1581    __Unknown(i32),
1582}
1583
1584#[doc(hidden)]
1585impl IntoGlib for EmblemOrigin {
1586    type GlibType = ffi::GEmblemOrigin;
1587
1588    #[inline]
1589    fn into_glib(self) -> ffi::GEmblemOrigin {
1590        match self {
1591            Self::Unknown => ffi::G_EMBLEM_ORIGIN_UNKNOWN,
1592            Self::Device => ffi::G_EMBLEM_ORIGIN_DEVICE,
1593            Self::Livemetadata => ffi::G_EMBLEM_ORIGIN_LIVEMETADATA,
1594            Self::Tag => ffi::G_EMBLEM_ORIGIN_TAG,
1595            Self::__Unknown(value) => value,
1596        }
1597    }
1598}
1599
1600#[doc(hidden)]
1601impl FromGlib<ffi::GEmblemOrigin> for EmblemOrigin {
1602    #[inline]
1603    unsafe fn from_glib(value: ffi::GEmblemOrigin) -> Self {
1604        match value {
1605            ffi::G_EMBLEM_ORIGIN_UNKNOWN => Self::Unknown,
1606            ffi::G_EMBLEM_ORIGIN_DEVICE => Self::Device,
1607            ffi::G_EMBLEM_ORIGIN_LIVEMETADATA => Self::Livemetadata,
1608            ffi::G_EMBLEM_ORIGIN_TAG => Self::Tag,
1609            value => Self::__Unknown(value),
1610        }
1611    }
1612}
1613
1614impl StaticType for EmblemOrigin {
1615    #[inline]
1616    #[doc(alias = "g_emblem_origin_get_type")]
1617    fn static_type() -> glib::Type {
1618        unsafe { from_glib(ffi::g_emblem_origin_get_type()) }
1619    }
1620}
1621
1622impl glib::HasParamSpec for EmblemOrigin {
1623    type ParamSpec = glib::ParamSpecEnum;
1624    type SetValue = Self;
1625    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1626
1627    fn param_spec_builder() -> Self::BuilderFn {
1628        Self::ParamSpec::builder_with_default
1629    }
1630}
1631
1632impl glib::value::ValueType for EmblemOrigin {
1633    type Type = Self;
1634}
1635
1636unsafe impl<'a> glib::value::FromValue<'a> for EmblemOrigin {
1637    type Checker = glib::value::GenericValueTypeChecker<Self>;
1638
1639    #[inline]
1640    unsafe fn from_value(value: &'a glib::Value) -> Self {
1641        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1642    }
1643}
1644
1645impl ToValue for EmblemOrigin {
1646    #[inline]
1647    fn to_value(&self) -> glib::Value {
1648        let mut value = glib::Value::for_value_type::<Self>();
1649        unsafe {
1650            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1651        }
1652        value
1653    }
1654
1655    #[inline]
1656    fn value_type(&self) -> glib::Type {
1657        Self::static_type()
1658    }
1659}
1660
1661impl From<EmblemOrigin> for glib::Value {
1662    #[inline]
1663    fn from(v: EmblemOrigin) -> Self {
1664        ToValue::to_value(&v)
1665    }
1666}
1667
1668/// Used by g_file_set_attributes_from_info() when setting file attributes.
1669#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1670#[non_exhaustive]
1671#[doc(alias = "GFileAttributeStatus")]
1672pub enum FileAttributeStatus {
1673    /// Attribute value is unset (empty).
1674    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_UNSET")]
1675    Unset,
1676    /// Attribute value is set.
1677    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_SET")]
1678    Set,
1679    /// Indicates an error in setting the value.
1680    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING")]
1681    ErrorSetting,
1682    #[doc(hidden)]
1683    __Unknown(i32),
1684}
1685
1686#[doc(hidden)]
1687impl IntoGlib for FileAttributeStatus {
1688    type GlibType = ffi::GFileAttributeStatus;
1689
1690    #[inline]
1691    fn into_glib(self) -> ffi::GFileAttributeStatus {
1692        match self {
1693            Self::Unset => ffi::G_FILE_ATTRIBUTE_STATUS_UNSET,
1694            Self::Set => ffi::G_FILE_ATTRIBUTE_STATUS_SET,
1695            Self::ErrorSetting => ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING,
1696            Self::__Unknown(value) => value,
1697        }
1698    }
1699}
1700
1701#[doc(hidden)]
1702impl FromGlib<ffi::GFileAttributeStatus> for FileAttributeStatus {
1703    #[inline]
1704    unsafe fn from_glib(value: ffi::GFileAttributeStatus) -> Self {
1705        match value {
1706            ffi::G_FILE_ATTRIBUTE_STATUS_UNSET => Self::Unset,
1707            ffi::G_FILE_ATTRIBUTE_STATUS_SET => Self::Set,
1708            ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING => Self::ErrorSetting,
1709            value => Self::__Unknown(value),
1710        }
1711    }
1712}
1713
1714impl StaticType for FileAttributeStatus {
1715    #[inline]
1716    #[doc(alias = "g_file_attribute_status_get_type")]
1717    fn static_type() -> glib::Type {
1718        unsafe { from_glib(ffi::g_file_attribute_status_get_type()) }
1719    }
1720}
1721
1722impl glib::HasParamSpec for FileAttributeStatus {
1723    type ParamSpec = glib::ParamSpecEnum;
1724    type SetValue = Self;
1725    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1726
1727    fn param_spec_builder() -> Self::BuilderFn {
1728        Self::ParamSpec::builder_with_default
1729    }
1730}
1731
1732impl glib::value::ValueType for FileAttributeStatus {
1733    type Type = Self;
1734}
1735
1736unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeStatus {
1737    type Checker = glib::value::GenericValueTypeChecker<Self>;
1738
1739    #[inline]
1740    unsafe fn from_value(value: &'a glib::Value) -> Self {
1741        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1742    }
1743}
1744
1745impl ToValue for FileAttributeStatus {
1746    #[inline]
1747    fn to_value(&self) -> glib::Value {
1748        let mut value = glib::Value::for_value_type::<Self>();
1749        unsafe {
1750            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1751        }
1752        value
1753    }
1754
1755    #[inline]
1756    fn value_type(&self) -> glib::Type {
1757        Self::static_type()
1758    }
1759}
1760
1761impl From<FileAttributeStatus> for glib::Value {
1762    #[inline]
1763    fn from(v: FileAttributeStatus) -> Self {
1764        ToValue::to_value(&v)
1765    }
1766}
1767
1768/// The data types for file attributes.
1769#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1770#[non_exhaustive]
1771#[doc(alias = "GFileAttributeType")]
1772pub enum FileAttributeType {
1773    /// indicates an invalid or uninitialized type.
1774    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INVALID")]
1775    Invalid,
1776    /// a null terminated UTF8 string.
1777    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRING")]
1778    String,
1779    /// a zero terminated string of non-zero bytes.
1780    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BYTE_STRING")]
1781    ByteString,
1782    /// a boolean value.
1783    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BOOLEAN")]
1784    Boolean,
1785    /// an unsigned 4-byte/32-bit integer.
1786    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT32")]
1787    Uint32,
1788    /// a signed 4-byte/32-bit integer.
1789    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT32")]
1790    Int32,
1791    /// an unsigned 8-byte/64-bit integer.
1792    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT64")]
1793    Uint64,
1794    /// a signed 8-byte/64-bit integer.
1795    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT64")]
1796    Int64,
1797    /// a #GObject.
1798    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_OBJECT")]
1799    Object,
1800    /// a [`None`] terminated char **. Since 2.22
1801    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRINGV")]
1802    Stringv,
1803    #[doc(hidden)]
1804    __Unknown(i32),
1805}
1806
1807#[doc(hidden)]
1808impl IntoGlib for FileAttributeType {
1809    type GlibType = ffi::GFileAttributeType;
1810
1811    #[inline]
1812    fn into_glib(self) -> ffi::GFileAttributeType {
1813        match self {
1814            Self::Invalid => ffi::G_FILE_ATTRIBUTE_TYPE_INVALID,
1815            Self::String => ffi::G_FILE_ATTRIBUTE_TYPE_STRING,
1816            Self::ByteString => ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING,
1817            Self::Boolean => ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN,
1818            Self::Uint32 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT32,
1819            Self::Int32 => ffi::G_FILE_ATTRIBUTE_TYPE_INT32,
1820            Self::Uint64 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT64,
1821            Self::Int64 => ffi::G_FILE_ATTRIBUTE_TYPE_INT64,
1822            Self::Object => ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT,
1823            Self::Stringv => ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV,
1824            Self::__Unknown(value) => value,
1825        }
1826    }
1827}
1828
1829#[doc(hidden)]
1830impl FromGlib<ffi::GFileAttributeType> for FileAttributeType {
1831    #[inline]
1832    unsafe fn from_glib(value: ffi::GFileAttributeType) -> Self {
1833        match value {
1834            ffi::G_FILE_ATTRIBUTE_TYPE_INVALID => Self::Invalid,
1835            ffi::G_FILE_ATTRIBUTE_TYPE_STRING => Self::String,
1836            ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING => Self::ByteString,
1837            ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN => Self::Boolean,
1838            ffi::G_FILE_ATTRIBUTE_TYPE_UINT32 => Self::Uint32,
1839            ffi::G_FILE_ATTRIBUTE_TYPE_INT32 => Self::Int32,
1840            ffi::G_FILE_ATTRIBUTE_TYPE_UINT64 => Self::Uint64,
1841            ffi::G_FILE_ATTRIBUTE_TYPE_INT64 => Self::Int64,
1842            ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT => Self::Object,
1843            ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV => Self::Stringv,
1844            value => Self::__Unknown(value),
1845        }
1846    }
1847}
1848
1849impl StaticType for FileAttributeType {
1850    #[inline]
1851    #[doc(alias = "g_file_attribute_type_get_type")]
1852    fn static_type() -> glib::Type {
1853        unsafe { from_glib(ffi::g_file_attribute_type_get_type()) }
1854    }
1855}
1856
1857impl glib::HasParamSpec for FileAttributeType {
1858    type ParamSpec = glib::ParamSpecEnum;
1859    type SetValue = Self;
1860    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1861
1862    fn param_spec_builder() -> Self::BuilderFn {
1863        Self::ParamSpec::builder_with_default
1864    }
1865}
1866
1867impl glib::value::ValueType for FileAttributeType {
1868    type Type = Self;
1869}
1870
1871unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeType {
1872    type Checker = glib::value::GenericValueTypeChecker<Self>;
1873
1874    #[inline]
1875    unsafe fn from_value(value: &'a glib::Value) -> Self {
1876        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1877    }
1878}
1879
1880impl ToValue for FileAttributeType {
1881    #[inline]
1882    fn to_value(&self) -> glib::Value {
1883        let mut value = glib::Value::for_value_type::<Self>();
1884        unsafe {
1885            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1886        }
1887        value
1888    }
1889
1890    #[inline]
1891    fn value_type(&self) -> glib::Type {
1892        Self::static_type()
1893    }
1894}
1895
1896impl From<FileAttributeType> for glib::Value {
1897    #[inline]
1898    fn from(v: FileAttributeType) -> Self {
1899        ToValue::to_value(&v)
1900    }
1901}
1902
1903/// Specifies what type of event a monitor event is.
1904#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1905#[non_exhaustive]
1906#[doc(alias = "GFileMonitorEvent")]
1907pub enum FileMonitorEvent {
1908    /// a file changed.
1909    #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGED")]
1910    Changed,
1911    /// a hint that this was probably the last change in a set of changes.
1912    #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT")]
1913    ChangesDoneHint,
1914    /// a file was deleted.
1915    #[doc(alias = "G_FILE_MONITOR_EVENT_DELETED")]
1916    Deleted,
1917    /// a file was created.
1918    #[doc(alias = "G_FILE_MONITOR_EVENT_CREATED")]
1919    Created,
1920    /// a file attribute was changed.
1921    #[doc(alias = "G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED")]
1922    AttributeChanged,
1923    /// the file location will soon be unmounted.
1924    #[doc(alias = "G_FILE_MONITOR_EVENT_PRE_UNMOUNT")]
1925    PreUnmount,
1926    /// the file location was unmounted.
1927    #[doc(alias = "G_FILE_MONITOR_EVENT_UNMOUNTED")]
1928    Unmounted,
1929    /// the file was moved -- only sent if the
1930    ///   (deprecated) [`FileMonitorFlags::SEND_MOVED`][crate::FileMonitorFlags::SEND_MOVED] flag is set
1931    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED")]
1932    Moved,
1933    /// the file was renamed within the
1934    ///   current directory -- only sent if the [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES]
1935    ///   flag is set.  Since: 2.46.
1936    #[doc(alias = "G_FILE_MONITOR_EVENT_RENAMED")]
1937    Renamed,
1938    /// the file was moved into the
1939    ///   monitored directory from another location -- only sent if the
1940    ///   [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES] flag is set.  Since: 2.46.
1941    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_IN")]
1942    MovedIn,
1943    /// the file was moved out of the
1944    ///   monitored directory to another location -- only sent if the
1945    ///   [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES] flag is set.  Since: 2.46
1946    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_OUT")]
1947    MovedOut,
1948    #[doc(hidden)]
1949    __Unknown(i32),
1950}
1951
1952#[doc(hidden)]
1953impl IntoGlib for FileMonitorEvent {
1954    type GlibType = ffi::GFileMonitorEvent;
1955
1956    #[inline]
1957    fn into_glib(self) -> ffi::GFileMonitorEvent {
1958        match self {
1959            Self::Changed => ffi::G_FILE_MONITOR_EVENT_CHANGED,
1960            Self::ChangesDoneHint => ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
1961            Self::Deleted => ffi::G_FILE_MONITOR_EVENT_DELETED,
1962            Self::Created => ffi::G_FILE_MONITOR_EVENT_CREATED,
1963            Self::AttributeChanged => ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED,
1964            Self::PreUnmount => ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT,
1965            Self::Unmounted => ffi::G_FILE_MONITOR_EVENT_UNMOUNTED,
1966            Self::Moved => ffi::G_FILE_MONITOR_EVENT_MOVED,
1967            Self::Renamed => ffi::G_FILE_MONITOR_EVENT_RENAMED,
1968            Self::MovedIn => ffi::G_FILE_MONITOR_EVENT_MOVED_IN,
1969            Self::MovedOut => ffi::G_FILE_MONITOR_EVENT_MOVED_OUT,
1970            Self::__Unknown(value) => value,
1971        }
1972    }
1973}
1974
1975#[doc(hidden)]
1976impl FromGlib<ffi::GFileMonitorEvent> for FileMonitorEvent {
1977    #[inline]
1978    unsafe fn from_glib(value: ffi::GFileMonitorEvent) -> Self {
1979        match value {
1980            ffi::G_FILE_MONITOR_EVENT_CHANGED => Self::Changed,
1981            ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT => Self::ChangesDoneHint,
1982            ffi::G_FILE_MONITOR_EVENT_DELETED => Self::Deleted,
1983            ffi::G_FILE_MONITOR_EVENT_CREATED => Self::Created,
1984            ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED => Self::AttributeChanged,
1985            ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT => Self::PreUnmount,
1986            ffi::G_FILE_MONITOR_EVENT_UNMOUNTED => Self::Unmounted,
1987            ffi::G_FILE_MONITOR_EVENT_MOVED => Self::Moved,
1988            ffi::G_FILE_MONITOR_EVENT_RENAMED => Self::Renamed,
1989            ffi::G_FILE_MONITOR_EVENT_MOVED_IN => Self::MovedIn,
1990            ffi::G_FILE_MONITOR_EVENT_MOVED_OUT => Self::MovedOut,
1991            value => Self::__Unknown(value),
1992        }
1993    }
1994}
1995
1996impl StaticType for FileMonitorEvent {
1997    #[inline]
1998    #[doc(alias = "g_file_monitor_event_get_type")]
1999    fn static_type() -> glib::Type {
2000        unsafe { from_glib(ffi::g_file_monitor_event_get_type()) }
2001    }
2002}
2003
2004impl glib::HasParamSpec for FileMonitorEvent {
2005    type ParamSpec = glib::ParamSpecEnum;
2006    type SetValue = Self;
2007    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2008
2009    fn param_spec_builder() -> Self::BuilderFn {
2010        Self::ParamSpec::builder_with_default
2011    }
2012}
2013
2014impl glib::value::ValueType for FileMonitorEvent {
2015    type Type = Self;
2016}
2017
2018unsafe impl<'a> glib::value::FromValue<'a> for FileMonitorEvent {
2019    type Checker = glib::value::GenericValueTypeChecker<Self>;
2020
2021    #[inline]
2022    unsafe fn from_value(value: &'a glib::Value) -> Self {
2023        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2024    }
2025}
2026
2027impl ToValue for FileMonitorEvent {
2028    #[inline]
2029    fn to_value(&self) -> glib::Value {
2030        let mut value = glib::Value::for_value_type::<Self>();
2031        unsafe {
2032            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2033        }
2034        value
2035    }
2036
2037    #[inline]
2038    fn value_type(&self) -> glib::Type {
2039        Self::static_type()
2040    }
2041}
2042
2043impl From<FileMonitorEvent> for glib::Value {
2044    #[inline]
2045    fn from(v: FileMonitorEvent) -> Self {
2046        ToValue::to_value(&v)
2047    }
2048}
2049
2050/// Indicates the file's on-disk type.
2051///
2052/// On Windows systems a file will never have [`SymbolicLink`][Self::SymbolicLink] type;
2053/// use #GFileInfo and [`FILE_ATTRIBUTE_STANDARD_IS_SYMLINK`][crate::FILE_ATTRIBUTE_STANDARD_IS_SYMLINK] to determine
2054/// whether a file is a symlink or not. This is due to the fact that NTFS does
2055/// not have a single filesystem object type for symbolic links - it has
2056/// files that symlink to files, and directories that symlink to directories.
2057/// #GFileType enumeration cannot precisely represent this important distinction,
2058/// which is why all Windows symlinks will continue to be reported as
2059/// [`Regular`][Self::Regular] or [`Directory`][Self::Directory].
2060#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2061#[non_exhaustive]
2062#[doc(alias = "GFileType")]
2063pub enum FileType {
2064    /// File's type is unknown.
2065    #[doc(alias = "G_FILE_TYPE_UNKNOWN")]
2066    Unknown,
2067    /// File handle represents a regular file.
2068    #[doc(alias = "G_FILE_TYPE_REGULAR")]
2069    Regular,
2070    /// File handle represents a directory.
2071    #[doc(alias = "G_FILE_TYPE_DIRECTORY")]
2072    Directory,
2073    /// File handle represents a symbolic link
2074    ///    (Unix systems).
2075    #[doc(alias = "G_FILE_TYPE_SYMBOLIC_LINK")]
2076    SymbolicLink,
2077    /// File is a "special" file, such as a socket, fifo,
2078    ///    block device, or character device.
2079    #[doc(alias = "G_FILE_TYPE_SPECIAL")]
2080    Special,
2081    /// File is a shortcut (Windows systems).
2082    #[doc(alias = "G_FILE_TYPE_SHORTCUT")]
2083    Shortcut,
2084    /// File is a mountable location.
2085    #[doc(alias = "G_FILE_TYPE_MOUNTABLE")]
2086    Mountable,
2087    #[doc(hidden)]
2088    __Unknown(i32),
2089}
2090
2091#[doc(hidden)]
2092impl IntoGlib for FileType {
2093    type GlibType = ffi::GFileType;
2094
2095    #[inline]
2096    fn into_glib(self) -> ffi::GFileType {
2097        match self {
2098            Self::Unknown => ffi::G_FILE_TYPE_UNKNOWN,
2099            Self::Regular => ffi::G_FILE_TYPE_REGULAR,
2100            Self::Directory => ffi::G_FILE_TYPE_DIRECTORY,
2101            Self::SymbolicLink => ffi::G_FILE_TYPE_SYMBOLIC_LINK,
2102            Self::Special => ffi::G_FILE_TYPE_SPECIAL,
2103            Self::Shortcut => ffi::G_FILE_TYPE_SHORTCUT,
2104            Self::Mountable => ffi::G_FILE_TYPE_MOUNTABLE,
2105            Self::__Unknown(value) => value,
2106        }
2107    }
2108}
2109
2110#[doc(hidden)]
2111impl FromGlib<ffi::GFileType> for FileType {
2112    #[inline]
2113    unsafe fn from_glib(value: ffi::GFileType) -> Self {
2114        match value {
2115            ffi::G_FILE_TYPE_UNKNOWN => Self::Unknown,
2116            ffi::G_FILE_TYPE_REGULAR => Self::Regular,
2117            ffi::G_FILE_TYPE_DIRECTORY => Self::Directory,
2118            ffi::G_FILE_TYPE_SYMBOLIC_LINK => Self::SymbolicLink,
2119            ffi::G_FILE_TYPE_SPECIAL => Self::Special,
2120            ffi::G_FILE_TYPE_SHORTCUT => Self::Shortcut,
2121            ffi::G_FILE_TYPE_MOUNTABLE => Self::Mountable,
2122            value => Self::__Unknown(value),
2123        }
2124    }
2125}
2126
2127impl StaticType for FileType {
2128    #[inline]
2129    #[doc(alias = "g_file_type_get_type")]
2130    fn static_type() -> glib::Type {
2131        unsafe { from_glib(ffi::g_file_type_get_type()) }
2132    }
2133}
2134
2135impl glib::HasParamSpec for FileType {
2136    type ParamSpec = glib::ParamSpecEnum;
2137    type SetValue = Self;
2138    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2139
2140    fn param_spec_builder() -> Self::BuilderFn {
2141        Self::ParamSpec::builder_with_default
2142    }
2143}
2144
2145impl glib::value::ValueType for FileType {
2146    type Type = Self;
2147}
2148
2149unsafe impl<'a> glib::value::FromValue<'a> for FileType {
2150    type Checker = glib::value::GenericValueTypeChecker<Self>;
2151
2152    #[inline]
2153    unsafe fn from_value(value: &'a glib::Value) -> Self {
2154        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2155    }
2156}
2157
2158impl ToValue for FileType {
2159    #[inline]
2160    fn to_value(&self) -> glib::Value {
2161        let mut value = glib::Value::for_value_type::<Self>();
2162        unsafe {
2163            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2164        }
2165        value
2166    }
2167
2168    #[inline]
2169    fn value_type(&self) -> glib::Type {
2170        Self::static_type()
2171    }
2172}
2173
2174impl From<FileType> for glib::Value {
2175    #[inline]
2176    fn from(v: FileType) -> Self {
2177        ToValue::to_value(&v)
2178    }
2179}
2180
2181/// Indicates a hint from the file system whether files should be
2182/// previewed in a file manager. Returned as the value of the key
2183/// [`FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW`][crate::FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW].
2184#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2185#[non_exhaustive]
2186#[doc(alias = "GFilesystemPreviewType")]
2187pub enum FilesystemPreviewType {
2188    /// Only preview files if user has explicitly requested it.
2189    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS")]
2190    IfAlways,
2191    /// Preview files if user has requested preview of "local" files.
2192    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL")]
2193    IfLocal,
2194    /// Never preview files.
2195    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_NEVER")]
2196    Never,
2197    #[doc(hidden)]
2198    __Unknown(i32),
2199}
2200
2201#[doc(hidden)]
2202impl IntoGlib for FilesystemPreviewType {
2203    type GlibType = ffi::GFilesystemPreviewType;
2204
2205    #[inline]
2206    fn into_glib(self) -> ffi::GFilesystemPreviewType {
2207        match self {
2208            Self::IfAlways => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS,
2209            Self::IfLocal => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL,
2210            Self::Never => ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER,
2211            Self::__Unknown(value) => value,
2212        }
2213    }
2214}
2215
2216#[doc(hidden)]
2217impl FromGlib<ffi::GFilesystemPreviewType> for FilesystemPreviewType {
2218    #[inline]
2219    unsafe fn from_glib(value: ffi::GFilesystemPreviewType) -> Self {
2220        match value {
2221            ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS => Self::IfAlways,
2222            ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL => Self::IfLocal,
2223            ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER => Self::Never,
2224            value => Self::__Unknown(value),
2225        }
2226    }
2227}
2228
2229impl StaticType for FilesystemPreviewType {
2230    #[inline]
2231    #[doc(alias = "g_filesystem_preview_type_get_type")]
2232    fn static_type() -> glib::Type {
2233        unsafe { from_glib(ffi::g_filesystem_preview_type_get_type()) }
2234    }
2235}
2236
2237impl glib::HasParamSpec for FilesystemPreviewType {
2238    type ParamSpec = glib::ParamSpecEnum;
2239    type SetValue = Self;
2240    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2241
2242    fn param_spec_builder() -> Self::BuilderFn {
2243        Self::ParamSpec::builder_with_default
2244    }
2245}
2246
2247impl glib::value::ValueType for FilesystemPreviewType {
2248    type Type = Self;
2249}
2250
2251unsafe impl<'a> glib::value::FromValue<'a> for FilesystemPreviewType {
2252    type Checker = glib::value::GenericValueTypeChecker<Self>;
2253
2254    #[inline]
2255    unsafe fn from_value(value: &'a glib::Value) -> Self {
2256        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2257    }
2258}
2259
2260impl ToValue for FilesystemPreviewType {
2261    #[inline]
2262    fn to_value(&self) -> glib::Value {
2263        let mut value = glib::Value::for_value_type::<Self>();
2264        unsafe {
2265            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2266        }
2267        value
2268    }
2269
2270    #[inline]
2271    fn value_type(&self) -> glib::Type {
2272        Self::static_type()
2273    }
2274}
2275
2276impl From<FilesystemPreviewType> for glib::Value {
2277    #[inline]
2278    fn from(v: FilesystemPreviewType) -> Self {
2279        ToValue::to_value(&v)
2280    }
2281}
2282
2283///
2284/// if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
2285///   {
2286///     // Assume that this is EPRINTERONFIRE
2287///     ...
2288///   }
2289/// ]|
2290/// but should instead treat all unrecognized error codes the same as
2291/// [`Failed`][Self::Failed].
2292///
2293/// See also #GPollableReturn for a cheaper way of returning
2294/// [`WouldBlock`][Self::WouldBlock] to callers without allocating a #GError.
2295#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2296#[non_exhaustive]
2297#[doc(alias = "GIOErrorEnum")]
2298pub enum IOErrorEnum {
2299    /// Generic error condition for when an operation fails
2300    ///     and no more specific #GIOErrorEnum value is defined.
2301    #[doc(alias = "G_IO_ERROR_FAILED")]
2302    Failed,
2303    /// File not found.
2304    #[doc(alias = "G_IO_ERROR_NOT_FOUND")]
2305    NotFound,
2306    /// File already exists.
2307    #[doc(alias = "G_IO_ERROR_EXISTS")]
2308    Exists,
2309    /// File is a directory.
2310    #[doc(alias = "G_IO_ERROR_IS_DIRECTORY")]
2311    IsDirectory,
2312    /// File is not a directory.
2313    #[doc(alias = "G_IO_ERROR_NOT_DIRECTORY")]
2314    NotDirectory,
2315    /// File is a directory that isn't empty.
2316    #[doc(alias = "G_IO_ERROR_NOT_EMPTY")]
2317    NotEmpty,
2318    /// File is not a regular file.
2319    #[doc(alias = "G_IO_ERROR_NOT_REGULAR_FILE")]
2320    NotRegularFile,
2321    /// File is not a symbolic link.
2322    #[doc(alias = "G_IO_ERROR_NOT_SYMBOLIC_LINK")]
2323    NotSymbolicLink,
2324    /// File cannot be mounted.
2325    #[doc(alias = "G_IO_ERROR_NOT_MOUNTABLE_FILE")]
2326    NotMountableFile,
2327    /// Filename is too many characters.
2328    #[doc(alias = "G_IO_ERROR_FILENAME_TOO_LONG")]
2329    FilenameTooLong,
2330    /// Filename is invalid or contains invalid characters.
2331    #[doc(alias = "G_IO_ERROR_INVALID_FILENAME")]
2332    InvalidFilename,
2333    /// File contains too many symbolic links.
2334    #[doc(alias = "G_IO_ERROR_TOO_MANY_LINKS")]
2335    TooManyLinks,
2336    /// No space left on drive.
2337    #[doc(alias = "G_IO_ERROR_NO_SPACE")]
2338    NoSpace,
2339    /// Invalid argument.
2340    #[doc(alias = "G_IO_ERROR_INVALID_ARGUMENT")]
2341    InvalidArgument,
2342    /// Permission denied.
2343    #[doc(alias = "G_IO_ERROR_PERMISSION_DENIED")]
2344    PermissionDenied,
2345    /// Operation (or one of its parameters) not supported
2346    #[doc(alias = "G_IO_ERROR_NOT_SUPPORTED")]
2347    NotSupported,
2348    /// File isn't mounted.
2349    #[doc(alias = "G_IO_ERROR_NOT_MOUNTED")]
2350    NotMounted,
2351    /// File is already mounted.
2352    #[doc(alias = "G_IO_ERROR_ALREADY_MOUNTED")]
2353    AlreadyMounted,
2354    /// File was closed.
2355    #[doc(alias = "G_IO_ERROR_CLOSED")]
2356    Closed,
2357    /// Operation was cancelled. See #GCancellable.
2358    #[doc(alias = "G_IO_ERROR_CANCELLED")]
2359    Cancelled,
2360    /// Operations are still pending.
2361    #[doc(alias = "G_IO_ERROR_PENDING")]
2362    Pending,
2363    /// File is read only.
2364    #[doc(alias = "G_IO_ERROR_READ_ONLY")]
2365    ReadOnly,
2366    /// Backup couldn't be created.
2367    #[doc(alias = "G_IO_ERROR_CANT_CREATE_BACKUP")]
2368    CantCreateBackup,
2369    /// File's Entity Tag was incorrect.
2370    #[doc(alias = "G_IO_ERROR_WRONG_ETAG")]
2371    WrongEtag,
2372    /// Operation timed out.
2373    #[doc(alias = "G_IO_ERROR_TIMED_OUT")]
2374    TimedOut,
2375    /// Operation would be recursive.
2376    #[doc(alias = "G_IO_ERROR_WOULD_RECURSE")]
2377    WouldRecurse,
2378    /// File is busy.
2379    #[doc(alias = "G_IO_ERROR_BUSY")]
2380    Busy,
2381    /// Operation would block.
2382    #[doc(alias = "G_IO_ERROR_WOULD_BLOCK")]
2383    WouldBlock,
2384    /// Host couldn't be found (remote operations).
2385    #[doc(alias = "G_IO_ERROR_HOST_NOT_FOUND")]
2386    HostNotFound,
2387    /// Operation would merge files.
2388    #[doc(alias = "G_IO_ERROR_WOULD_MERGE")]
2389    WouldMerge,
2390    /// Operation failed and a helper program has
2391    ///     already interacted with the user. Do not display any error dialog.
2392    #[doc(alias = "G_IO_ERROR_FAILED_HANDLED")]
2393    FailedHandled,
2394    /// The current process has too many files
2395    ///     open and can't open any more. Duplicate descriptors do count toward
2396    ///     this limit. Since 2.20
2397    #[doc(alias = "G_IO_ERROR_TOO_MANY_OPEN_FILES")]
2398    TooManyOpenFiles,
2399    /// The object has not been initialized. Since 2.22
2400    #[doc(alias = "G_IO_ERROR_NOT_INITIALIZED")]
2401    NotInitialized,
2402    /// The requested address is already in use. Since 2.22
2403    #[doc(alias = "G_IO_ERROR_ADDRESS_IN_USE")]
2404    AddressInUse,
2405    /// Need more input to finish operation. Since 2.24
2406    #[doc(alias = "G_IO_ERROR_PARTIAL_INPUT")]
2407    PartialInput,
2408    /// The input data was invalid. Since 2.24
2409    #[doc(alias = "G_IO_ERROR_INVALID_DATA")]
2410    InvalidData,
2411    /// A remote object generated an error that
2412    ///     doesn't correspond to a locally registered #GError error
2413    ///     domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
2414    ///     error name and g_dbus_error_strip_remote_error() to fix up the
2415    ///     message so it matches what was received on the wire. Since 2.26.
2416    #[doc(alias = "G_IO_ERROR_DBUS_ERROR")]
2417    DbusError,
2418    /// Host unreachable. Since 2.26
2419    #[doc(alias = "G_IO_ERROR_HOST_UNREACHABLE")]
2420    HostUnreachable,
2421    /// Network unreachable. Since 2.26
2422    #[doc(alias = "G_IO_ERROR_NETWORK_UNREACHABLE")]
2423    NetworkUnreachable,
2424    /// Connection refused. Since 2.26
2425    #[doc(alias = "G_IO_ERROR_CONNECTION_REFUSED")]
2426    ConnectionRefused,
2427    /// Connection to proxy server failed. Since 2.26
2428    #[doc(alias = "G_IO_ERROR_PROXY_FAILED")]
2429    ProxyFailed,
2430    /// Proxy authentication failed. Since 2.26
2431    #[doc(alias = "G_IO_ERROR_PROXY_AUTH_FAILED")]
2432    ProxyAuthFailed,
2433    /// Proxy server needs authentication. Since 2.26
2434    #[doc(alias = "G_IO_ERROR_PROXY_NEED_AUTH")]
2435    ProxyNeedAuth,
2436    /// Proxy connection is not allowed by ruleset.
2437    ///     Since 2.26
2438    #[doc(alias = "G_IO_ERROR_PROXY_NOT_ALLOWED")]
2439    ProxyNotAllowed,
2440    /// Broken pipe. Since 2.36
2441    #[doc(alias = "G_IO_ERROR_BROKEN_PIPE")]
2442    BrokenPipe,
2443    /// Transport endpoint is not connected. Since 2.44
2444    #[doc(alias = "G_IO_ERROR_NOT_CONNECTED")]
2445    NotConnected,
2446    /// Message too large. Since 2.48.
2447    #[doc(alias = "G_IO_ERROR_MESSAGE_TOO_LARGE")]
2448    MessageTooLarge,
2449    /// No such device found. Since 2.74
2450    #[cfg(feature = "v2_72")]
2451    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
2452    #[doc(alias = "G_IO_ERROR_NO_SUCH_DEVICE")]
2453    NoSuchDevice,
2454    /// Destination address unset. Since 2.80
2455    #[cfg(feature = "v2_80")]
2456    #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
2457    #[doc(alias = "G_IO_ERROR_DESTINATION_UNSET")]
2458    DestinationUnset,
2459    #[doc(hidden)]
2460    __Unknown(i32),
2461}
2462
2463#[doc(hidden)]
2464impl IntoGlib for IOErrorEnum {
2465    type GlibType = ffi::GIOErrorEnum;
2466
2467    fn into_glib(self) -> ffi::GIOErrorEnum {
2468        match self {
2469            Self::Failed => ffi::G_IO_ERROR_FAILED,
2470            Self::NotFound => ffi::G_IO_ERROR_NOT_FOUND,
2471            Self::Exists => ffi::G_IO_ERROR_EXISTS,
2472            Self::IsDirectory => ffi::G_IO_ERROR_IS_DIRECTORY,
2473            Self::NotDirectory => ffi::G_IO_ERROR_NOT_DIRECTORY,
2474            Self::NotEmpty => ffi::G_IO_ERROR_NOT_EMPTY,
2475            Self::NotRegularFile => ffi::G_IO_ERROR_NOT_REGULAR_FILE,
2476            Self::NotSymbolicLink => ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK,
2477            Self::NotMountableFile => ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE,
2478            Self::FilenameTooLong => ffi::G_IO_ERROR_FILENAME_TOO_LONG,
2479            Self::InvalidFilename => ffi::G_IO_ERROR_INVALID_FILENAME,
2480            Self::TooManyLinks => ffi::G_IO_ERROR_TOO_MANY_LINKS,
2481            Self::NoSpace => ffi::G_IO_ERROR_NO_SPACE,
2482            Self::InvalidArgument => ffi::G_IO_ERROR_INVALID_ARGUMENT,
2483            Self::PermissionDenied => ffi::G_IO_ERROR_PERMISSION_DENIED,
2484            Self::NotSupported => ffi::G_IO_ERROR_NOT_SUPPORTED,
2485            Self::NotMounted => ffi::G_IO_ERROR_NOT_MOUNTED,
2486            Self::AlreadyMounted => ffi::G_IO_ERROR_ALREADY_MOUNTED,
2487            Self::Closed => ffi::G_IO_ERROR_CLOSED,
2488            Self::Cancelled => ffi::G_IO_ERROR_CANCELLED,
2489            Self::Pending => ffi::G_IO_ERROR_PENDING,
2490            Self::ReadOnly => ffi::G_IO_ERROR_READ_ONLY,
2491            Self::CantCreateBackup => ffi::G_IO_ERROR_CANT_CREATE_BACKUP,
2492            Self::WrongEtag => ffi::G_IO_ERROR_WRONG_ETAG,
2493            Self::TimedOut => ffi::G_IO_ERROR_TIMED_OUT,
2494            Self::WouldRecurse => ffi::G_IO_ERROR_WOULD_RECURSE,
2495            Self::Busy => ffi::G_IO_ERROR_BUSY,
2496            Self::WouldBlock => ffi::G_IO_ERROR_WOULD_BLOCK,
2497            Self::HostNotFound => ffi::G_IO_ERROR_HOST_NOT_FOUND,
2498            Self::WouldMerge => ffi::G_IO_ERROR_WOULD_MERGE,
2499            Self::FailedHandled => ffi::G_IO_ERROR_FAILED_HANDLED,
2500            Self::TooManyOpenFiles => ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES,
2501            Self::NotInitialized => ffi::G_IO_ERROR_NOT_INITIALIZED,
2502            Self::AddressInUse => ffi::G_IO_ERROR_ADDRESS_IN_USE,
2503            Self::PartialInput => ffi::G_IO_ERROR_PARTIAL_INPUT,
2504            Self::InvalidData => ffi::G_IO_ERROR_INVALID_DATA,
2505            Self::DbusError => ffi::G_IO_ERROR_DBUS_ERROR,
2506            Self::HostUnreachable => ffi::G_IO_ERROR_HOST_UNREACHABLE,
2507            Self::NetworkUnreachable => ffi::G_IO_ERROR_NETWORK_UNREACHABLE,
2508            Self::ConnectionRefused => ffi::G_IO_ERROR_CONNECTION_REFUSED,
2509            Self::ProxyFailed => ffi::G_IO_ERROR_PROXY_FAILED,
2510            Self::ProxyAuthFailed => ffi::G_IO_ERROR_PROXY_AUTH_FAILED,
2511            Self::ProxyNeedAuth => ffi::G_IO_ERROR_PROXY_NEED_AUTH,
2512            Self::ProxyNotAllowed => ffi::G_IO_ERROR_PROXY_NOT_ALLOWED,
2513            Self::BrokenPipe => ffi::G_IO_ERROR_BROKEN_PIPE,
2514            Self::NotConnected => ffi::G_IO_ERROR_NOT_CONNECTED,
2515            Self::MessageTooLarge => ffi::G_IO_ERROR_MESSAGE_TOO_LARGE,
2516            #[cfg(feature = "v2_72")]
2517            Self::NoSuchDevice => ffi::G_IO_ERROR_NO_SUCH_DEVICE,
2518            #[cfg(feature = "v2_80")]
2519            Self::DestinationUnset => ffi::G_IO_ERROR_DESTINATION_UNSET,
2520            Self::__Unknown(value) => value,
2521        }
2522    }
2523}
2524
2525#[doc(hidden)]
2526impl FromGlib<ffi::GIOErrorEnum> for IOErrorEnum {
2527    unsafe fn from_glib(value: ffi::GIOErrorEnum) -> Self {
2528        match value {
2529            ffi::G_IO_ERROR_FAILED => Self::Failed,
2530            ffi::G_IO_ERROR_NOT_FOUND => Self::NotFound,
2531            ffi::G_IO_ERROR_EXISTS => Self::Exists,
2532            ffi::G_IO_ERROR_IS_DIRECTORY => Self::IsDirectory,
2533            ffi::G_IO_ERROR_NOT_DIRECTORY => Self::NotDirectory,
2534            ffi::G_IO_ERROR_NOT_EMPTY => Self::NotEmpty,
2535            ffi::G_IO_ERROR_NOT_REGULAR_FILE => Self::NotRegularFile,
2536            ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK => Self::NotSymbolicLink,
2537            ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE => Self::NotMountableFile,
2538            ffi::G_IO_ERROR_FILENAME_TOO_LONG => Self::FilenameTooLong,
2539            ffi::G_IO_ERROR_INVALID_FILENAME => Self::InvalidFilename,
2540            ffi::G_IO_ERROR_TOO_MANY_LINKS => Self::TooManyLinks,
2541            ffi::G_IO_ERROR_NO_SPACE => Self::NoSpace,
2542            ffi::G_IO_ERROR_INVALID_ARGUMENT => Self::InvalidArgument,
2543            ffi::G_IO_ERROR_PERMISSION_DENIED => Self::PermissionDenied,
2544            ffi::G_IO_ERROR_NOT_SUPPORTED => Self::NotSupported,
2545            ffi::G_IO_ERROR_NOT_MOUNTED => Self::NotMounted,
2546            ffi::G_IO_ERROR_ALREADY_MOUNTED => Self::AlreadyMounted,
2547            ffi::G_IO_ERROR_CLOSED => Self::Closed,
2548            ffi::G_IO_ERROR_CANCELLED => Self::Cancelled,
2549            ffi::G_IO_ERROR_PENDING => Self::Pending,
2550            ffi::G_IO_ERROR_READ_ONLY => Self::ReadOnly,
2551            ffi::G_IO_ERROR_CANT_CREATE_BACKUP => Self::CantCreateBackup,
2552            ffi::G_IO_ERROR_WRONG_ETAG => Self::WrongEtag,
2553            ffi::G_IO_ERROR_TIMED_OUT => Self::TimedOut,
2554            ffi::G_IO_ERROR_WOULD_RECURSE => Self::WouldRecurse,
2555            ffi::G_IO_ERROR_BUSY => Self::Busy,
2556            ffi::G_IO_ERROR_WOULD_BLOCK => Self::WouldBlock,
2557            ffi::G_IO_ERROR_HOST_NOT_FOUND => Self::HostNotFound,
2558            ffi::G_IO_ERROR_WOULD_MERGE => Self::WouldMerge,
2559            ffi::G_IO_ERROR_FAILED_HANDLED => Self::FailedHandled,
2560            ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES => Self::TooManyOpenFiles,
2561            ffi::G_IO_ERROR_NOT_INITIALIZED => Self::NotInitialized,
2562            ffi::G_IO_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
2563            ffi::G_IO_ERROR_PARTIAL_INPUT => Self::PartialInput,
2564            ffi::G_IO_ERROR_INVALID_DATA => Self::InvalidData,
2565            ffi::G_IO_ERROR_DBUS_ERROR => Self::DbusError,
2566            ffi::G_IO_ERROR_HOST_UNREACHABLE => Self::HostUnreachable,
2567            ffi::G_IO_ERROR_NETWORK_UNREACHABLE => Self::NetworkUnreachable,
2568            ffi::G_IO_ERROR_CONNECTION_REFUSED => Self::ConnectionRefused,
2569            ffi::G_IO_ERROR_PROXY_FAILED => Self::ProxyFailed,
2570            ffi::G_IO_ERROR_PROXY_AUTH_FAILED => Self::ProxyAuthFailed,
2571            ffi::G_IO_ERROR_PROXY_NEED_AUTH => Self::ProxyNeedAuth,
2572            ffi::G_IO_ERROR_PROXY_NOT_ALLOWED => Self::ProxyNotAllowed,
2573            ffi::G_IO_ERROR_BROKEN_PIPE => Self::BrokenPipe,
2574            ffi::G_IO_ERROR_NOT_CONNECTED => Self::NotConnected,
2575            ffi::G_IO_ERROR_MESSAGE_TOO_LARGE => Self::MessageTooLarge,
2576            #[cfg(feature = "v2_72")]
2577            ffi::G_IO_ERROR_NO_SUCH_DEVICE => Self::NoSuchDevice,
2578            #[cfg(feature = "v2_80")]
2579            ffi::G_IO_ERROR_DESTINATION_UNSET => Self::DestinationUnset,
2580            value => Self::__Unknown(value),
2581        }
2582    }
2583}
2584
2585impl glib::error::ErrorDomain for IOErrorEnum {
2586    #[inline]
2587    fn domain() -> glib::Quark {
2588        unsafe { from_glib(ffi::g_io_error_quark()) }
2589    }
2590
2591    #[inline]
2592    fn code(self) -> i32 {
2593        self.into_glib()
2594    }
2595
2596    #[inline]
2597    #[allow(clippy::match_single_binding)]
2598    fn from(code: i32) -> Option<Self> {
2599        match unsafe { from_glib(code) } {
2600            Self::__Unknown(_) => Some(Self::Failed),
2601            value => Some(value),
2602        }
2603    }
2604}
2605
2606impl StaticType for IOErrorEnum {
2607    #[inline]
2608    #[doc(alias = "g_io_error_enum_get_type")]
2609    fn static_type() -> glib::Type {
2610        unsafe { from_glib(ffi::g_io_error_enum_get_type()) }
2611    }
2612}
2613
2614impl glib::HasParamSpec for IOErrorEnum {
2615    type ParamSpec = glib::ParamSpecEnum;
2616    type SetValue = Self;
2617    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2618
2619    fn param_spec_builder() -> Self::BuilderFn {
2620        Self::ParamSpec::builder_with_default
2621    }
2622}
2623
2624impl glib::value::ValueType for IOErrorEnum {
2625    type Type = Self;
2626}
2627
2628unsafe impl<'a> glib::value::FromValue<'a> for IOErrorEnum {
2629    type Checker = glib::value::GenericValueTypeChecker<Self>;
2630
2631    #[inline]
2632    unsafe fn from_value(value: &'a glib::Value) -> Self {
2633        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2634    }
2635}
2636
2637impl ToValue for IOErrorEnum {
2638    #[inline]
2639    fn to_value(&self) -> glib::Value {
2640        let mut value = glib::Value::for_value_type::<Self>();
2641        unsafe {
2642            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2643        }
2644        value
2645    }
2646
2647    #[inline]
2648    fn value_type(&self) -> glib::Type {
2649        Self::static_type()
2650    }
2651}
2652
2653impl From<IOErrorEnum> for glib::Value {
2654    #[inline]
2655    fn from(v: IOErrorEnum) -> Self {
2656        ToValue::to_value(&v)
2657    }
2658}
2659
2660///  G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
2661///   drop_caches ();
2662/// ]|
2663#[cfg(feature = "v2_64")]
2664#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2665#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2666#[non_exhaustive]
2667#[doc(alias = "GMemoryMonitorWarningLevel")]
2668pub enum MemoryMonitorWarningLevel {
2669    /// Memory on the device is low, processes
2670    ///   should free up unneeded resources (for example, in-memory caches) so they can
2671    ///   be used elsewhere.
2672    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_LOW")]
2673    Low,
2674    /// Same as @G_MEMORY_MONITOR_WARNING_LEVEL_LOW
2675    ///   but the device has even less free memory, so processes should try harder to free
2676    ///   up unneeded resources. If your process does not need to stay running, it is a
2677    ///   good time for it to quit.
2678    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM")]
2679    Medium,
2680    /// The system will soon start terminating
2681    ///   processes to reclaim memory, including background processes.
2682    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL")]
2683    Critical,
2684    #[doc(hidden)]
2685    __Unknown(i32),
2686}
2687
2688#[cfg(feature = "v2_64")]
2689#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2690#[doc(hidden)]
2691impl IntoGlib for MemoryMonitorWarningLevel {
2692    type GlibType = ffi::GMemoryMonitorWarningLevel;
2693
2694    #[inline]
2695    fn into_glib(self) -> ffi::GMemoryMonitorWarningLevel {
2696        match self {
2697            Self::Low => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW,
2698            Self::Medium => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM,
2699            Self::Critical => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL,
2700            Self::__Unknown(value) => value,
2701        }
2702    }
2703}
2704
2705#[cfg(feature = "v2_64")]
2706#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2707#[doc(hidden)]
2708impl FromGlib<ffi::GMemoryMonitorWarningLevel> for MemoryMonitorWarningLevel {
2709    #[inline]
2710    unsafe fn from_glib(value: ffi::GMemoryMonitorWarningLevel) -> Self {
2711        match value {
2712            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW => Self::Low,
2713            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM => Self::Medium,
2714            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL => Self::Critical,
2715            value => Self::__Unknown(value),
2716        }
2717    }
2718}
2719
2720#[cfg(feature = "v2_64")]
2721#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2722impl StaticType for MemoryMonitorWarningLevel {
2723    #[inline]
2724    #[doc(alias = "g_memory_monitor_warning_level_get_type")]
2725    fn static_type() -> glib::Type {
2726        unsafe { from_glib(ffi::g_memory_monitor_warning_level_get_type()) }
2727    }
2728}
2729
2730#[cfg(feature = "v2_64")]
2731#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2732impl glib::HasParamSpec for MemoryMonitorWarningLevel {
2733    type ParamSpec = glib::ParamSpecEnum;
2734    type SetValue = Self;
2735    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2736
2737    fn param_spec_builder() -> Self::BuilderFn {
2738        Self::ParamSpec::builder_with_default
2739    }
2740}
2741
2742#[cfg(feature = "v2_64")]
2743#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2744impl glib::value::ValueType for MemoryMonitorWarningLevel {
2745    type Type = Self;
2746}
2747
2748#[cfg(feature = "v2_64")]
2749#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2750unsafe impl<'a> glib::value::FromValue<'a> for MemoryMonitorWarningLevel {
2751    type Checker = glib::value::GenericValueTypeChecker<Self>;
2752
2753    #[inline]
2754    unsafe fn from_value(value: &'a glib::Value) -> Self {
2755        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2756    }
2757}
2758
2759#[cfg(feature = "v2_64")]
2760#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2761impl ToValue for MemoryMonitorWarningLevel {
2762    #[inline]
2763    fn to_value(&self) -> glib::Value {
2764        let mut value = glib::Value::for_value_type::<Self>();
2765        unsafe {
2766            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2767        }
2768        value
2769    }
2770
2771    #[inline]
2772    fn value_type(&self) -> glib::Type {
2773        Self::static_type()
2774    }
2775}
2776
2777#[cfg(feature = "v2_64")]
2778#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2779impl From<MemoryMonitorWarningLevel> for glib::Value {
2780    #[inline]
2781    fn from(v: MemoryMonitorWarningLevel) -> Self {
2782        ToValue::to_value(&v)
2783    }
2784}
2785
2786/// #GMountOperationResult is returned as a result when a request for
2787/// information is send by the mounting operation.
2788#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2789#[non_exhaustive]
2790#[doc(alias = "GMountOperationResult")]
2791pub enum MountOperationResult {
2792    /// The request was fulfilled and the
2793    ///     user specified data is now available
2794    #[doc(alias = "G_MOUNT_OPERATION_HANDLED")]
2795    Handled,
2796    /// The user requested the mount operation
2797    ///     to be aborted
2798    #[doc(alias = "G_MOUNT_OPERATION_ABORTED")]
2799    Aborted,
2800    /// The request was unhandled (i.e. not
2801    ///     implemented)
2802    #[doc(alias = "G_MOUNT_OPERATION_UNHANDLED")]
2803    Unhandled,
2804    #[doc(hidden)]
2805    __Unknown(i32),
2806}
2807
2808#[doc(hidden)]
2809impl IntoGlib for MountOperationResult {
2810    type GlibType = ffi::GMountOperationResult;
2811
2812    #[inline]
2813    fn into_glib(self) -> ffi::GMountOperationResult {
2814        match self {
2815            Self::Handled => ffi::G_MOUNT_OPERATION_HANDLED,
2816            Self::Aborted => ffi::G_MOUNT_OPERATION_ABORTED,
2817            Self::Unhandled => ffi::G_MOUNT_OPERATION_UNHANDLED,
2818            Self::__Unknown(value) => value,
2819        }
2820    }
2821}
2822
2823#[doc(hidden)]
2824impl FromGlib<ffi::GMountOperationResult> for MountOperationResult {
2825    #[inline]
2826    unsafe fn from_glib(value: ffi::GMountOperationResult) -> Self {
2827        match value {
2828            ffi::G_MOUNT_OPERATION_HANDLED => Self::Handled,
2829            ffi::G_MOUNT_OPERATION_ABORTED => Self::Aborted,
2830            ffi::G_MOUNT_OPERATION_UNHANDLED => Self::Unhandled,
2831            value => Self::__Unknown(value),
2832        }
2833    }
2834}
2835
2836impl StaticType for MountOperationResult {
2837    #[inline]
2838    #[doc(alias = "g_mount_operation_result_get_type")]
2839    fn static_type() -> glib::Type {
2840        unsafe { from_glib(ffi::g_mount_operation_result_get_type()) }
2841    }
2842}
2843
2844impl glib::HasParamSpec for MountOperationResult {
2845    type ParamSpec = glib::ParamSpecEnum;
2846    type SetValue = Self;
2847    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2848
2849    fn param_spec_builder() -> Self::BuilderFn {
2850        Self::ParamSpec::builder_with_default
2851    }
2852}
2853
2854impl glib::value::ValueType for MountOperationResult {
2855    type Type = Self;
2856}
2857
2858unsafe impl<'a> glib::value::FromValue<'a> for MountOperationResult {
2859    type Checker = glib::value::GenericValueTypeChecker<Self>;
2860
2861    #[inline]
2862    unsafe fn from_value(value: &'a glib::Value) -> Self {
2863        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2864    }
2865}
2866
2867impl ToValue for MountOperationResult {
2868    #[inline]
2869    fn to_value(&self) -> glib::Value {
2870        let mut value = glib::Value::for_value_type::<Self>();
2871        unsafe {
2872            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2873        }
2874        value
2875    }
2876
2877    #[inline]
2878    fn value_type(&self) -> glib::Type {
2879        Self::static_type()
2880    }
2881}
2882
2883impl From<MountOperationResult> for glib::Value {
2884    #[inline]
2885    fn from(v: MountOperationResult) -> Self {
2886        ToValue::to_value(&v)
2887    }
2888}
2889
2890/// The host's network connectivity state, as reported by #GNetworkMonitor.
2891#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2892#[non_exhaustive]
2893#[doc(alias = "GNetworkConnectivity")]
2894pub enum NetworkConnectivity {
2895    /// The host is not configured with a
2896    ///   route to the Internet; it may or may not be connected to a local
2897    ///   network.
2898    #[doc(alias = "G_NETWORK_CONNECTIVITY_LOCAL")]
2899    Local,
2900    /// The host is connected to a network, but
2901    ///   does not appear to be able to reach the full Internet, perhaps
2902    ///   due to upstream network problems.
2903    #[doc(alias = "G_NETWORK_CONNECTIVITY_LIMITED")]
2904    Limited,
2905    /// The host is behind a captive portal and
2906    ///   cannot reach the full Internet.
2907    #[doc(alias = "G_NETWORK_CONNECTIVITY_PORTAL")]
2908    Portal,
2909    /// The host is connected to a network, and
2910    ///   appears to be able to reach the full Internet.
2911    #[doc(alias = "G_NETWORK_CONNECTIVITY_FULL")]
2912    Full,
2913    #[doc(hidden)]
2914    __Unknown(i32),
2915}
2916
2917#[doc(hidden)]
2918impl IntoGlib for NetworkConnectivity {
2919    type GlibType = ffi::GNetworkConnectivity;
2920
2921    #[inline]
2922    fn into_glib(self) -> ffi::GNetworkConnectivity {
2923        match self {
2924            Self::Local => ffi::G_NETWORK_CONNECTIVITY_LOCAL,
2925            Self::Limited => ffi::G_NETWORK_CONNECTIVITY_LIMITED,
2926            Self::Portal => ffi::G_NETWORK_CONNECTIVITY_PORTAL,
2927            Self::Full => ffi::G_NETWORK_CONNECTIVITY_FULL,
2928            Self::__Unknown(value) => value,
2929        }
2930    }
2931}
2932
2933#[doc(hidden)]
2934impl FromGlib<ffi::GNetworkConnectivity> for NetworkConnectivity {
2935    #[inline]
2936    unsafe fn from_glib(value: ffi::GNetworkConnectivity) -> Self {
2937        match value {
2938            ffi::G_NETWORK_CONNECTIVITY_LOCAL => Self::Local,
2939            ffi::G_NETWORK_CONNECTIVITY_LIMITED => Self::Limited,
2940            ffi::G_NETWORK_CONNECTIVITY_PORTAL => Self::Portal,
2941            ffi::G_NETWORK_CONNECTIVITY_FULL => Self::Full,
2942            value => Self::__Unknown(value),
2943        }
2944    }
2945}
2946
2947impl StaticType for NetworkConnectivity {
2948    #[inline]
2949    #[doc(alias = "g_network_connectivity_get_type")]
2950    fn static_type() -> glib::Type {
2951        unsafe { from_glib(ffi::g_network_connectivity_get_type()) }
2952    }
2953}
2954
2955impl glib::HasParamSpec for NetworkConnectivity {
2956    type ParamSpec = glib::ParamSpecEnum;
2957    type SetValue = Self;
2958    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2959
2960    fn param_spec_builder() -> Self::BuilderFn {
2961        Self::ParamSpec::builder_with_default
2962    }
2963}
2964
2965impl glib::value::ValueType for NetworkConnectivity {
2966    type Type = Self;
2967}
2968
2969unsafe impl<'a> glib::value::FromValue<'a> for NetworkConnectivity {
2970    type Checker = glib::value::GenericValueTypeChecker<Self>;
2971
2972    #[inline]
2973    unsafe fn from_value(value: &'a glib::Value) -> Self {
2974        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2975    }
2976}
2977
2978impl ToValue for NetworkConnectivity {
2979    #[inline]
2980    fn to_value(&self) -> glib::Value {
2981        let mut value = glib::Value::for_value_type::<Self>();
2982        unsafe {
2983            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2984        }
2985        value
2986    }
2987
2988    #[inline]
2989    fn value_type(&self) -> glib::Type {
2990        Self::static_type()
2991    }
2992}
2993
2994impl From<NetworkConnectivity> for glib::Value {
2995    #[inline]
2996    fn from(v: NetworkConnectivity) -> Self {
2997        ToValue::to_value(&v)
2998    }
2999}
3000
3001/// Priority levels for #GNotifications.
3002#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3003#[non_exhaustive]
3004#[doc(alias = "GNotificationPriority")]
3005pub enum NotificationPriority {
3006    /// the default priority, to be used for the
3007    ///   majority of notifications (for example email messages, software updates,
3008    ///   completed download/sync operations)
3009    #[doc(alias = "G_NOTIFICATION_PRIORITY_NORMAL")]
3010    Normal,
3011    /// for notifications that do not require
3012    ///   immediate attention - typically used for contextual background
3013    ///   information, such as contact birthdays or local weather
3014    #[doc(alias = "G_NOTIFICATION_PRIORITY_LOW")]
3015    Low,
3016    /// for events that require more attention,
3017    ///   usually because responses are time-sensitive (for example chat and SMS
3018    ///   messages or alarms)
3019    #[doc(alias = "G_NOTIFICATION_PRIORITY_HIGH")]
3020    High,
3021    /// for urgent notifications, or notifications
3022    ///   that require a response in a short space of time (for example phone calls
3023    ///   or emergency warnings)
3024    #[doc(alias = "G_NOTIFICATION_PRIORITY_URGENT")]
3025    Urgent,
3026    #[doc(hidden)]
3027    __Unknown(i32),
3028}
3029
3030#[doc(hidden)]
3031impl IntoGlib for NotificationPriority {
3032    type GlibType = ffi::GNotificationPriority;
3033
3034    #[inline]
3035    fn into_glib(self) -> ffi::GNotificationPriority {
3036        match self {
3037            Self::Normal => ffi::G_NOTIFICATION_PRIORITY_NORMAL,
3038            Self::Low => ffi::G_NOTIFICATION_PRIORITY_LOW,
3039            Self::High => ffi::G_NOTIFICATION_PRIORITY_HIGH,
3040            Self::Urgent => ffi::G_NOTIFICATION_PRIORITY_URGENT,
3041            Self::__Unknown(value) => value,
3042        }
3043    }
3044}
3045
3046#[doc(hidden)]
3047impl FromGlib<ffi::GNotificationPriority> for NotificationPriority {
3048    #[inline]
3049    unsafe fn from_glib(value: ffi::GNotificationPriority) -> Self {
3050        match value {
3051            ffi::G_NOTIFICATION_PRIORITY_NORMAL => Self::Normal,
3052            ffi::G_NOTIFICATION_PRIORITY_LOW => Self::Low,
3053            ffi::G_NOTIFICATION_PRIORITY_HIGH => Self::High,
3054            ffi::G_NOTIFICATION_PRIORITY_URGENT => Self::Urgent,
3055            value => Self::__Unknown(value),
3056        }
3057    }
3058}
3059
3060impl StaticType for NotificationPriority {
3061    #[inline]
3062    #[doc(alias = "g_notification_priority_get_type")]
3063    fn static_type() -> glib::Type {
3064        unsafe { from_glib(ffi::g_notification_priority_get_type()) }
3065    }
3066}
3067
3068impl glib::HasParamSpec for NotificationPriority {
3069    type ParamSpec = glib::ParamSpecEnum;
3070    type SetValue = Self;
3071    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3072
3073    fn param_spec_builder() -> Self::BuilderFn {
3074        Self::ParamSpec::builder_with_default
3075    }
3076}
3077
3078impl glib::value::ValueType for NotificationPriority {
3079    type Type = Self;
3080}
3081
3082unsafe impl<'a> glib::value::FromValue<'a> for NotificationPriority {
3083    type Checker = glib::value::GenericValueTypeChecker<Self>;
3084
3085    #[inline]
3086    unsafe fn from_value(value: &'a glib::Value) -> Self {
3087        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3088    }
3089}
3090
3091impl ToValue for NotificationPriority {
3092    #[inline]
3093    fn to_value(&self) -> glib::Value {
3094        let mut value = glib::Value::for_value_type::<Self>();
3095        unsafe {
3096            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3097        }
3098        value
3099    }
3100
3101    #[inline]
3102    fn value_type(&self) -> glib::Type {
3103        Self::static_type()
3104    }
3105}
3106
3107impl From<NotificationPriority> for glib::Value {
3108    #[inline]
3109    fn from(v: NotificationPriority) -> Self {
3110        ToValue::to_value(&v)
3111    }
3112}
3113
3114/// #GPasswordSave is used to indicate the lifespan of a saved password.
3115///
3116/// #Gvfs stores passwords in the Gnome keyring when this flag allows it
3117/// to, and later retrieves it again from there.
3118#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3119#[non_exhaustive]
3120#[doc(alias = "GPasswordSave")]
3121pub enum PasswordSave {
3122    /// never save a password.
3123    #[doc(alias = "G_PASSWORD_SAVE_NEVER")]
3124    Never,
3125    /// save a password for the session.
3126    #[doc(alias = "G_PASSWORD_SAVE_FOR_SESSION")]
3127    ForSession,
3128    /// save a password permanently.
3129    #[doc(alias = "G_PASSWORD_SAVE_PERMANENTLY")]
3130    Permanently,
3131    #[doc(hidden)]
3132    __Unknown(i32),
3133}
3134
3135#[doc(hidden)]
3136impl IntoGlib for PasswordSave {
3137    type GlibType = ffi::GPasswordSave;
3138
3139    #[inline]
3140    fn into_glib(self) -> ffi::GPasswordSave {
3141        match self {
3142            Self::Never => ffi::G_PASSWORD_SAVE_NEVER,
3143            Self::ForSession => ffi::G_PASSWORD_SAVE_FOR_SESSION,
3144            Self::Permanently => ffi::G_PASSWORD_SAVE_PERMANENTLY,
3145            Self::__Unknown(value) => value,
3146        }
3147    }
3148}
3149
3150#[doc(hidden)]
3151impl FromGlib<ffi::GPasswordSave> for PasswordSave {
3152    #[inline]
3153    unsafe fn from_glib(value: ffi::GPasswordSave) -> Self {
3154        match value {
3155            ffi::G_PASSWORD_SAVE_NEVER => Self::Never,
3156            ffi::G_PASSWORD_SAVE_FOR_SESSION => Self::ForSession,
3157            ffi::G_PASSWORD_SAVE_PERMANENTLY => Self::Permanently,
3158            value => Self::__Unknown(value),
3159        }
3160    }
3161}
3162
3163impl StaticType for PasswordSave {
3164    #[inline]
3165    #[doc(alias = "g_password_save_get_type")]
3166    fn static_type() -> glib::Type {
3167        unsafe { from_glib(ffi::g_password_save_get_type()) }
3168    }
3169}
3170
3171impl glib::HasParamSpec for PasswordSave {
3172    type ParamSpec = glib::ParamSpecEnum;
3173    type SetValue = Self;
3174    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3175
3176    fn param_spec_builder() -> Self::BuilderFn {
3177        Self::ParamSpec::builder_with_default
3178    }
3179}
3180
3181impl glib::value::ValueType for PasswordSave {
3182    type Type = Self;
3183}
3184
3185unsafe impl<'a> glib::value::FromValue<'a> for PasswordSave {
3186    type Checker = glib::value::GenericValueTypeChecker<Self>;
3187
3188    #[inline]
3189    unsafe fn from_value(value: &'a glib::Value) -> Self {
3190        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3191    }
3192}
3193
3194impl ToValue for PasswordSave {
3195    #[inline]
3196    fn to_value(&self) -> glib::Value {
3197        let mut value = glib::Value::for_value_type::<Self>();
3198        unsafe {
3199            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3200        }
3201        value
3202    }
3203
3204    #[inline]
3205    fn value_type(&self) -> glib::Type {
3206        Self::static_type()
3207    }
3208}
3209
3210impl From<PasswordSave> for glib::Value {
3211    #[inline]
3212    fn from(v: PasswordSave) -> Self {
3213        ToValue::to_value(&v)
3214    }
3215}
3216
3217/// Return value for various IO operations that signal errors via the
3218/// return value and not necessarily via a #GError.
3219///
3220/// This enum exists to be able to return errors to callers without having to
3221/// allocate a #GError. Allocating #GErrors can be quite expensive for
3222/// regularly happening errors like [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock].
3223///
3224/// In case of [`Failed`][Self::Failed] a #GError should be set for the
3225/// operation to give details about the error that happened.
3226#[cfg(feature = "v2_60")]
3227#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3228#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3229#[non_exhaustive]
3230#[doc(alias = "GPollableReturn")]
3231pub enum PollableReturn {
3232    /// Generic error condition for when an operation fails.
3233    #[doc(alias = "G_POLLABLE_RETURN_FAILED")]
3234    Failed,
3235    /// The operation was successfully finished.
3236    #[doc(alias = "G_POLLABLE_RETURN_OK")]
3237    Ok,
3238    /// The operation would block.
3239    #[doc(alias = "G_POLLABLE_RETURN_WOULD_BLOCK")]
3240    WouldBlock,
3241    #[doc(hidden)]
3242    __Unknown(i32),
3243}
3244
3245#[cfg(feature = "v2_60")]
3246#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3247#[doc(hidden)]
3248impl IntoGlib for PollableReturn {
3249    type GlibType = ffi::GPollableReturn;
3250
3251    #[inline]
3252    fn into_glib(self) -> ffi::GPollableReturn {
3253        match self {
3254            Self::Failed => ffi::G_POLLABLE_RETURN_FAILED,
3255            Self::Ok => ffi::G_POLLABLE_RETURN_OK,
3256            Self::WouldBlock => ffi::G_POLLABLE_RETURN_WOULD_BLOCK,
3257            Self::__Unknown(value) => value,
3258        }
3259    }
3260}
3261
3262#[cfg(feature = "v2_60")]
3263#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3264#[doc(hidden)]
3265impl FromGlib<ffi::GPollableReturn> for PollableReturn {
3266    #[inline]
3267    unsafe fn from_glib(value: ffi::GPollableReturn) -> Self {
3268        match value {
3269            ffi::G_POLLABLE_RETURN_FAILED => Self::Failed,
3270            ffi::G_POLLABLE_RETURN_OK => Self::Ok,
3271            ffi::G_POLLABLE_RETURN_WOULD_BLOCK => Self::WouldBlock,
3272            value => Self::__Unknown(value),
3273        }
3274    }
3275}
3276
3277#[cfg(feature = "v2_60")]
3278#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3279impl StaticType for PollableReturn {
3280    #[inline]
3281    #[doc(alias = "g_pollable_return_get_type")]
3282    fn static_type() -> glib::Type {
3283        unsafe { from_glib(ffi::g_pollable_return_get_type()) }
3284    }
3285}
3286
3287#[cfg(feature = "v2_60")]
3288#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3289impl glib::HasParamSpec for PollableReturn {
3290    type ParamSpec = glib::ParamSpecEnum;
3291    type SetValue = Self;
3292    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3293
3294    fn param_spec_builder() -> Self::BuilderFn {
3295        Self::ParamSpec::builder_with_default
3296    }
3297}
3298
3299#[cfg(feature = "v2_60")]
3300#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3301impl glib::value::ValueType for PollableReturn {
3302    type Type = Self;
3303}
3304
3305#[cfg(feature = "v2_60")]
3306#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3307unsafe impl<'a> glib::value::FromValue<'a> for PollableReturn {
3308    type Checker = glib::value::GenericValueTypeChecker<Self>;
3309
3310    #[inline]
3311    unsafe fn from_value(value: &'a glib::Value) -> Self {
3312        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3313    }
3314}
3315
3316#[cfg(feature = "v2_60")]
3317#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3318impl ToValue for PollableReturn {
3319    #[inline]
3320    fn to_value(&self) -> glib::Value {
3321        let mut value = glib::Value::for_value_type::<Self>();
3322        unsafe {
3323            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3324        }
3325        value
3326    }
3327
3328    #[inline]
3329    fn value_type(&self) -> glib::Type {
3330        Self::static_type()
3331    }
3332}
3333
3334#[cfg(feature = "v2_60")]
3335#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3336impl From<PollableReturn> for glib::Value {
3337    #[inline]
3338    fn from(v: PollableReturn) -> Self {
3339        ToValue::to_value(&v)
3340    }
3341}
3342
3343/// An error code used with `G_RESOLVER_ERROR` in a #GError returned
3344/// from a #GResolver routine.
3345#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3346#[non_exhaustive]
3347#[doc(alias = "GResolverError")]
3348pub enum ResolverError {
3349    /// the requested name/address/service was not
3350    ///     found
3351    #[doc(alias = "G_RESOLVER_ERROR_NOT_FOUND")]
3352    NotFound,
3353    /// the requested information could not
3354    ///     be looked up due to a network error or similar problem
3355    #[doc(alias = "G_RESOLVER_ERROR_TEMPORARY_FAILURE")]
3356    TemporaryFailure,
3357    /// unknown error
3358    #[doc(alias = "G_RESOLVER_ERROR_INTERNAL")]
3359    Internal,
3360    #[doc(hidden)]
3361    __Unknown(i32),
3362}
3363
3364#[doc(hidden)]
3365impl IntoGlib for ResolverError {
3366    type GlibType = ffi::GResolverError;
3367
3368    #[inline]
3369    fn into_glib(self) -> ffi::GResolverError {
3370        match self {
3371            Self::NotFound => ffi::G_RESOLVER_ERROR_NOT_FOUND,
3372            Self::TemporaryFailure => ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE,
3373            Self::Internal => ffi::G_RESOLVER_ERROR_INTERNAL,
3374            Self::__Unknown(value) => value,
3375        }
3376    }
3377}
3378
3379#[doc(hidden)]
3380impl FromGlib<ffi::GResolverError> for ResolverError {
3381    #[inline]
3382    unsafe fn from_glib(value: ffi::GResolverError) -> Self {
3383        match value {
3384            ffi::G_RESOLVER_ERROR_NOT_FOUND => Self::NotFound,
3385            ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE => Self::TemporaryFailure,
3386            ffi::G_RESOLVER_ERROR_INTERNAL => Self::Internal,
3387            value => Self::__Unknown(value),
3388        }
3389    }
3390}
3391
3392impl glib::error::ErrorDomain for ResolverError {
3393    #[inline]
3394    fn domain() -> glib::Quark {
3395        unsafe { from_glib(ffi::g_resolver_error_quark()) }
3396    }
3397
3398    #[inline]
3399    fn code(self) -> i32 {
3400        self.into_glib()
3401    }
3402
3403    #[inline]
3404    #[allow(clippy::match_single_binding)]
3405    fn from(code: i32) -> Option<Self> {
3406        match unsafe { from_glib(code) } {
3407            value => Some(value),
3408        }
3409    }
3410}
3411
3412impl StaticType for ResolverError {
3413    #[inline]
3414    #[doc(alias = "g_resolver_error_get_type")]
3415    fn static_type() -> glib::Type {
3416        unsafe { from_glib(ffi::g_resolver_error_get_type()) }
3417    }
3418}
3419
3420impl glib::HasParamSpec for ResolverError {
3421    type ParamSpec = glib::ParamSpecEnum;
3422    type SetValue = Self;
3423    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3424
3425    fn param_spec_builder() -> Self::BuilderFn {
3426        Self::ParamSpec::builder_with_default
3427    }
3428}
3429
3430impl glib::value::ValueType for ResolverError {
3431    type Type = Self;
3432}
3433
3434unsafe impl<'a> glib::value::FromValue<'a> for ResolverError {
3435    type Checker = glib::value::GenericValueTypeChecker<Self>;
3436
3437    #[inline]
3438    unsafe fn from_value(value: &'a glib::Value) -> Self {
3439        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3440    }
3441}
3442
3443impl ToValue for ResolverError {
3444    #[inline]
3445    fn to_value(&self) -> glib::Value {
3446        let mut value = glib::Value::for_value_type::<Self>();
3447        unsafe {
3448            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3449        }
3450        value
3451    }
3452
3453    #[inline]
3454    fn value_type(&self) -> glib::Type {
3455        Self::static_type()
3456    }
3457}
3458
3459impl From<ResolverError> for glib::Value {
3460    #[inline]
3461    fn from(v: ResolverError) -> Self {
3462        ToValue::to_value(&v)
3463    }
3464}
3465
3466/// The type of record that g_resolver_lookup_records() or
3467/// g_resolver_lookup_records_async() should retrieve. The records are returned
3468/// as lists of #GVariant tuples. Each record type has different values in
3469/// the variant tuples returned.
3470///
3471/// [`Srv`][Self::Srv] records are returned as variants with the signature
3472/// `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the
3473/// weight, a `guint16` with the port, and a string of the hostname.
3474///
3475/// [`Mx`][Self::Mx] records are returned as variants with the signature
3476/// `(qs)`, representing a `guint16` with the preference, and a string containing
3477/// the mail exchanger hostname.
3478///
3479/// [`Txt`][Self::Txt] records are returned as variants with the signature
3480/// `(as)`, representing an array of the strings in the text record. Note: Most TXT
3481/// records only contain a single string, but
3482/// [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a
3483/// record to contain multiple strings. The RFC which defines the interpretation
3484/// of a specific TXT record will likely require concatenation of multiple
3485/// strings if they are present, as with
3486/// [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3).
3487///
3488/// [`Soa`][Self::Soa] records are returned as variants with the signature
3489/// `(ssuuuuu)`, representing a string containing the primary name server, a
3490/// string containing the administrator, the serial as a `guint32`, the refresh
3491/// interval as a `guint32`, the retry interval as a `guint32`, the expire timeout
3492/// as a `guint32`, and the TTL as a `guint32`.
3493///
3494/// [`Ns`][Self::Ns] records are returned as variants with the signature
3495/// `(s)`, representing a string of the hostname of the name server.
3496#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3497#[non_exhaustive]
3498#[doc(alias = "GResolverRecordType")]
3499pub enum ResolverRecordType {
3500    /// look up DNS SRV records for a domain
3501    #[doc(alias = "G_RESOLVER_RECORD_SRV")]
3502    Srv,
3503    /// look up DNS MX records for a domain
3504    #[doc(alias = "G_RESOLVER_RECORD_MX")]
3505    Mx,
3506    /// look up DNS TXT records for a name
3507    #[doc(alias = "G_RESOLVER_RECORD_TXT")]
3508    Txt,
3509    /// look up DNS SOA records for a zone
3510    #[doc(alias = "G_RESOLVER_RECORD_SOA")]
3511    Soa,
3512    /// look up DNS NS records for a domain
3513    #[doc(alias = "G_RESOLVER_RECORD_NS")]
3514    Ns,
3515    #[doc(hidden)]
3516    __Unknown(i32),
3517}
3518
3519#[doc(hidden)]
3520impl IntoGlib for ResolverRecordType {
3521    type GlibType = ffi::GResolverRecordType;
3522
3523    #[inline]
3524    fn into_glib(self) -> ffi::GResolverRecordType {
3525        match self {
3526            Self::Srv => ffi::G_RESOLVER_RECORD_SRV,
3527            Self::Mx => ffi::G_RESOLVER_RECORD_MX,
3528            Self::Txt => ffi::G_RESOLVER_RECORD_TXT,
3529            Self::Soa => ffi::G_RESOLVER_RECORD_SOA,
3530            Self::Ns => ffi::G_RESOLVER_RECORD_NS,
3531            Self::__Unknown(value) => value,
3532        }
3533    }
3534}
3535
3536#[doc(hidden)]
3537impl FromGlib<ffi::GResolverRecordType> for ResolverRecordType {
3538    #[inline]
3539    unsafe fn from_glib(value: ffi::GResolverRecordType) -> Self {
3540        match value {
3541            ffi::G_RESOLVER_RECORD_SRV => Self::Srv,
3542            ffi::G_RESOLVER_RECORD_MX => Self::Mx,
3543            ffi::G_RESOLVER_RECORD_TXT => Self::Txt,
3544            ffi::G_RESOLVER_RECORD_SOA => Self::Soa,
3545            ffi::G_RESOLVER_RECORD_NS => Self::Ns,
3546            value => Self::__Unknown(value),
3547        }
3548    }
3549}
3550
3551impl StaticType for ResolverRecordType {
3552    #[inline]
3553    #[doc(alias = "g_resolver_record_type_get_type")]
3554    fn static_type() -> glib::Type {
3555        unsafe { from_glib(ffi::g_resolver_record_type_get_type()) }
3556    }
3557}
3558
3559impl glib::HasParamSpec for ResolverRecordType {
3560    type ParamSpec = glib::ParamSpecEnum;
3561    type SetValue = Self;
3562    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3563
3564    fn param_spec_builder() -> Self::BuilderFn {
3565        Self::ParamSpec::builder_with_default
3566    }
3567}
3568
3569impl glib::value::ValueType for ResolverRecordType {
3570    type Type = Self;
3571}
3572
3573unsafe impl<'a> glib::value::FromValue<'a> for ResolverRecordType {
3574    type Checker = glib::value::GenericValueTypeChecker<Self>;
3575
3576    #[inline]
3577    unsafe fn from_value(value: &'a glib::Value) -> Self {
3578        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3579    }
3580}
3581
3582impl ToValue for ResolverRecordType {
3583    #[inline]
3584    fn to_value(&self) -> glib::Value {
3585        let mut value = glib::Value::for_value_type::<Self>();
3586        unsafe {
3587            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3588        }
3589        value
3590    }
3591
3592    #[inline]
3593    fn value_type(&self) -> glib::Type {
3594        Self::static_type()
3595    }
3596}
3597
3598impl From<ResolverRecordType> for glib::Value {
3599    #[inline]
3600    fn from(v: ResolverRecordType) -> Self {
3601        ToValue::to_value(&v)
3602    }
3603}
3604
3605/// An error code used with `G_RESOURCE_ERROR` in a #GError returned
3606/// from a #GResource routine.
3607#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3608#[non_exhaustive]
3609#[doc(alias = "GResourceError")]
3610pub enum ResourceError {
3611    /// no file was found at the requested path
3612    #[doc(alias = "G_RESOURCE_ERROR_NOT_FOUND")]
3613    NotFound,
3614    /// unknown error
3615    #[doc(alias = "G_RESOURCE_ERROR_INTERNAL")]
3616    Internal,
3617    #[doc(hidden)]
3618    __Unknown(i32),
3619}
3620
3621#[doc(hidden)]
3622impl IntoGlib for ResourceError {
3623    type GlibType = ffi::GResourceError;
3624
3625    #[inline]
3626    fn into_glib(self) -> ffi::GResourceError {
3627        match self {
3628            Self::NotFound => ffi::G_RESOURCE_ERROR_NOT_FOUND,
3629            Self::Internal => ffi::G_RESOURCE_ERROR_INTERNAL,
3630            Self::__Unknown(value) => value,
3631        }
3632    }
3633}
3634
3635#[doc(hidden)]
3636impl FromGlib<ffi::GResourceError> for ResourceError {
3637    #[inline]
3638    unsafe fn from_glib(value: ffi::GResourceError) -> Self {
3639        match value {
3640            ffi::G_RESOURCE_ERROR_NOT_FOUND => Self::NotFound,
3641            ffi::G_RESOURCE_ERROR_INTERNAL => Self::Internal,
3642            value => Self::__Unknown(value),
3643        }
3644    }
3645}
3646
3647impl glib::error::ErrorDomain for ResourceError {
3648    #[inline]
3649    fn domain() -> glib::Quark {
3650        unsafe { from_glib(ffi::g_resource_error_quark()) }
3651    }
3652
3653    #[inline]
3654    fn code(self) -> i32 {
3655        self.into_glib()
3656    }
3657
3658    #[inline]
3659    #[allow(clippy::match_single_binding)]
3660    fn from(code: i32) -> Option<Self> {
3661        match unsafe { from_glib(code) } {
3662            value => Some(value),
3663        }
3664    }
3665}
3666
3667impl StaticType for ResourceError {
3668    #[inline]
3669    #[doc(alias = "g_resource_error_get_type")]
3670    fn static_type() -> glib::Type {
3671        unsafe { from_glib(ffi::g_resource_error_get_type()) }
3672    }
3673}
3674
3675impl glib::HasParamSpec for ResourceError {
3676    type ParamSpec = glib::ParamSpecEnum;
3677    type SetValue = Self;
3678    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3679
3680    fn param_spec_builder() -> Self::BuilderFn {
3681        Self::ParamSpec::builder_with_default
3682    }
3683}
3684
3685impl glib::value::ValueType for ResourceError {
3686    type Type = Self;
3687}
3688
3689unsafe impl<'a> glib::value::FromValue<'a> for ResourceError {
3690    type Checker = glib::value::GenericValueTypeChecker<Self>;
3691
3692    #[inline]
3693    unsafe fn from_value(value: &'a glib::Value) -> Self {
3694        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3695    }
3696}
3697
3698impl ToValue for ResourceError {
3699    #[inline]
3700    fn to_value(&self) -> glib::Value {
3701        let mut value = glib::Value::for_value_type::<Self>();
3702        unsafe {
3703            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3704        }
3705        value
3706    }
3707
3708    #[inline]
3709    fn value_type(&self) -> glib::Type {
3710        Self::static_type()
3711    }
3712}
3713
3714impl From<ResourceError> for glib::Value {
3715    #[inline]
3716    fn from(v: ResourceError) -> Self {
3717        ToValue::to_value(&v)
3718    }
3719}
3720
3721/// Describes an event occurring on a #GSocketClient. See the
3722/// #GSocketClient::event signal for more details.
3723///
3724/// Additional values may be added to this type in the future.
3725#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3726#[non_exhaustive]
3727#[doc(alias = "GSocketClientEvent")]
3728pub enum SocketClientEvent {
3729    /// The client is doing a DNS lookup.
3730    #[doc(alias = "G_SOCKET_CLIENT_RESOLVING")]
3731    Resolving,
3732    /// The client has completed a DNS lookup.
3733    #[doc(alias = "G_SOCKET_CLIENT_RESOLVED")]
3734    Resolved,
3735    /// The client is connecting to a remote
3736    ///   host (either a proxy or the destination server).
3737    #[doc(alias = "G_SOCKET_CLIENT_CONNECTING")]
3738    Connecting,
3739    /// The client has connected to a remote
3740    ///   host.
3741    #[doc(alias = "G_SOCKET_CLIENT_CONNECTED")]
3742    Connected,
3743    /// The client is negotiating
3744    ///   with a proxy to connect to the destination server.
3745    #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATING")]
3746    ProxyNegotiating,
3747    /// The client has negotiated
3748    ///   with the proxy server.
3749    #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATED")]
3750    ProxyNegotiated,
3751    /// The client is performing a
3752    ///   TLS handshake.
3753    #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKING")]
3754    TlsHandshaking,
3755    /// The client has performed a
3756    ///   TLS handshake.
3757    #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKED")]
3758    TlsHandshaked,
3759    /// The client is done with a particular
3760    ///   #GSocketConnectable.
3761    #[doc(alias = "G_SOCKET_CLIENT_COMPLETE")]
3762    Complete,
3763    #[doc(hidden)]
3764    __Unknown(i32),
3765}
3766
3767#[doc(hidden)]
3768impl IntoGlib for SocketClientEvent {
3769    type GlibType = ffi::GSocketClientEvent;
3770
3771    #[inline]
3772    fn into_glib(self) -> ffi::GSocketClientEvent {
3773        match self {
3774            Self::Resolving => ffi::G_SOCKET_CLIENT_RESOLVING,
3775            Self::Resolved => ffi::G_SOCKET_CLIENT_RESOLVED,
3776            Self::Connecting => ffi::G_SOCKET_CLIENT_CONNECTING,
3777            Self::Connected => ffi::G_SOCKET_CLIENT_CONNECTED,
3778            Self::ProxyNegotiating => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING,
3779            Self::ProxyNegotiated => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED,
3780            Self::TlsHandshaking => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING,
3781            Self::TlsHandshaked => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED,
3782            Self::Complete => ffi::G_SOCKET_CLIENT_COMPLETE,
3783            Self::__Unknown(value) => value,
3784        }
3785    }
3786}
3787
3788#[doc(hidden)]
3789impl FromGlib<ffi::GSocketClientEvent> for SocketClientEvent {
3790    #[inline]
3791    unsafe fn from_glib(value: ffi::GSocketClientEvent) -> Self {
3792        match value {
3793            ffi::G_SOCKET_CLIENT_RESOLVING => Self::Resolving,
3794            ffi::G_SOCKET_CLIENT_RESOLVED => Self::Resolved,
3795            ffi::G_SOCKET_CLIENT_CONNECTING => Self::Connecting,
3796            ffi::G_SOCKET_CLIENT_CONNECTED => Self::Connected,
3797            ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING => Self::ProxyNegotiating,
3798            ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED => Self::ProxyNegotiated,
3799            ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING => Self::TlsHandshaking,
3800            ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED => Self::TlsHandshaked,
3801            ffi::G_SOCKET_CLIENT_COMPLETE => Self::Complete,
3802            value => Self::__Unknown(value),
3803        }
3804    }
3805}
3806
3807impl StaticType for SocketClientEvent {
3808    #[inline]
3809    #[doc(alias = "g_socket_client_event_get_type")]
3810    fn static_type() -> glib::Type {
3811        unsafe { from_glib(ffi::g_socket_client_event_get_type()) }
3812    }
3813}
3814
3815impl glib::HasParamSpec for SocketClientEvent {
3816    type ParamSpec = glib::ParamSpecEnum;
3817    type SetValue = Self;
3818    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3819
3820    fn param_spec_builder() -> Self::BuilderFn {
3821        Self::ParamSpec::builder_with_default
3822    }
3823}
3824
3825impl glib::value::ValueType for SocketClientEvent {
3826    type Type = Self;
3827}
3828
3829unsafe impl<'a> glib::value::FromValue<'a> for SocketClientEvent {
3830    type Checker = glib::value::GenericValueTypeChecker<Self>;
3831
3832    #[inline]
3833    unsafe fn from_value(value: &'a glib::Value) -> Self {
3834        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3835    }
3836}
3837
3838impl ToValue for SocketClientEvent {
3839    #[inline]
3840    fn to_value(&self) -> glib::Value {
3841        let mut value = glib::Value::for_value_type::<Self>();
3842        unsafe {
3843            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3844        }
3845        value
3846    }
3847
3848    #[inline]
3849    fn value_type(&self) -> glib::Type {
3850        Self::static_type()
3851    }
3852}
3853
3854impl From<SocketClientEvent> for glib::Value {
3855    #[inline]
3856    fn from(v: SocketClientEvent) -> Self {
3857        ToValue::to_value(&v)
3858    }
3859}
3860
3861/// The protocol family of a #GSocketAddress. (These values are
3862/// identical to the system defines `AF_INET`, `AF_INET6` and `AF_UNIX`,
3863/// if available.)
3864#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3865#[non_exhaustive]
3866#[doc(alias = "GSocketFamily")]
3867pub enum SocketFamily {
3868    /// no address family
3869    #[doc(alias = "G_SOCKET_FAMILY_INVALID")]
3870    Invalid,
3871    /// the UNIX domain family
3872    #[doc(alias = "G_SOCKET_FAMILY_UNIX")]
3873    Unix,
3874    /// the IPv4 family
3875    #[doc(alias = "G_SOCKET_FAMILY_IPV4")]
3876    Ipv4,
3877    /// the IPv6 family
3878    #[doc(alias = "G_SOCKET_FAMILY_IPV6")]
3879    Ipv6,
3880    #[doc(hidden)]
3881    __Unknown(i32),
3882}
3883
3884#[doc(hidden)]
3885impl IntoGlib for SocketFamily {
3886    type GlibType = ffi::GSocketFamily;
3887
3888    #[inline]
3889    fn into_glib(self) -> ffi::GSocketFamily {
3890        match self {
3891            Self::Invalid => ffi::G_SOCKET_FAMILY_INVALID,
3892            Self::Unix => ffi::G_SOCKET_FAMILY_UNIX,
3893            Self::Ipv4 => ffi::G_SOCKET_FAMILY_IPV4,
3894            Self::Ipv6 => ffi::G_SOCKET_FAMILY_IPV6,
3895            Self::__Unknown(value) => value,
3896        }
3897    }
3898}
3899
3900#[doc(hidden)]
3901impl FromGlib<ffi::GSocketFamily> for SocketFamily {
3902    #[inline]
3903    unsafe fn from_glib(value: ffi::GSocketFamily) -> Self {
3904        match value {
3905            ffi::G_SOCKET_FAMILY_INVALID => Self::Invalid,
3906            ffi::G_SOCKET_FAMILY_UNIX => Self::Unix,
3907            ffi::G_SOCKET_FAMILY_IPV4 => Self::Ipv4,
3908            ffi::G_SOCKET_FAMILY_IPV6 => Self::Ipv6,
3909            value => Self::__Unknown(value),
3910        }
3911    }
3912}
3913
3914impl StaticType for SocketFamily {
3915    #[inline]
3916    #[doc(alias = "g_socket_family_get_type")]
3917    fn static_type() -> glib::Type {
3918        unsafe { from_glib(ffi::g_socket_family_get_type()) }
3919    }
3920}
3921
3922impl glib::HasParamSpec for SocketFamily {
3923    type ParamSpec = glib::ParamSpecEnum;
3924    type SetValue = Self;
3925    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3926
3927    fn param_spec_builder() -> Self::BuilderFn {
3928        Self::ParamSpec::builder_with_default
3929    }
3930}
3931
3932impl glib::value::ValueType for SocketFamily {
3933    type Type = Self;
3934}
3935
3936unsafe impl<'a> glib::value::FromValue<'a> for SocketFamily {
3937    type Checker = glib::value::GenericValueTypeChecker<Self>;
3938
3939    #[inline]
3940    unsafe fn from_value(value: &'a glib::Value) -> Self {
3941        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3942    }
3943}
3944
3945impl ToValue for SocketFamily {
3946    #[inline]
3947    fn to_value(&self) -> glib::Value {
3948        let mut value = glib::Value::for_value_type::<Self>();
3949        unsafe {
3950            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3951        }
3952        value
3953    }
3954
3955    #[inline]
3956    fn value_type(&self) -> glib::Type {
3957        Self::static_type()
3958    }
3959}
3960
3961impl From<SocketFamily> for glib::Value {
3962    #[inline]
3963    fn from(v: SocketFamily) -> Self {
3964        ToValue::to_value(&v)
3965    }
3966}
3967
3968/// Describes an event occurring on a #GSocketListener. See the
3969/// #GSocketListener::event signal for more details.
3970///
3971/// Additional values may be added to this type in the future.
3972#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3973#[non_exhaustive]
3974#[doc(alias = "GSocketListenerEvent")]
3975pub enum SocketListenerEvent {
3976    /// The listener is about to bind a socket.
3977    #[doc(alias = "G_SOCKET_LISTENER_BINDING")]
3978    Binding,
3979    /// The listener has bound a socket.
3980    #[doc(alias = "G_SOCKET_LISTENER_BOUND")]
3981    Bound,
3982    /// The listener is about to start
3983    ///    listening on this socket.
3984    #[doc(alias = "G_SOCKET_LISTENER_LISTENING")]
3985    Listening,
3986    /// The listener is now listening on
3987    ///   this socket.
3988    #[doc(alias = "G_SOCKET_LISTENER_LISTENED")]
3989    Listened,
3990    #[doc(hidden)]
3991    __Unknown(i32),
3992}
3993
3994#[doc(hidden)]
3995impl IntoGlib for SocketListenerEvent {
3996    type GlibType = ffi::GSocketListenerEvent;
3997
3998    #[inline]
3999    fn into_glib(self) -> ffi::GSocketListenerEvent {
4000        match self {
4001            Self::Binding => ffi::G_SOCKET_LISTENER_BINDING,
4002            Self::Bound => ffi::G_SOCKET_LISTENER_BOUND,
4003            Self::Listening => ffi::G_SOCKET_LISTENER_LISTENING,
4004            Self::Listened => ffi::G_SOCKET_LISTENER_LISTENED,
4005            Self::__Unknown(value) => value,
4006        }
4007    }
4008}
4009
4010#[doc(hidden)]
4011impl FromGlib<ffi::GSocketListenerEvent> for SocketListenerEvent {
4012    #[inline]
4013    unsafe fn from_glib(value: ffi::GSocketListenerEvent) -> Self {
4014        match value {
4015            ffi::G_SOCKET_LISTENER_BINDING => Self::Binding,
4016            ffi::G_SOCKET_LISTENER_BOUND => Self::Bound,
4017            ffi::G_SOCKET_LISTENER_LISTENING => Self::Listening,
4018            ffi::G_SOCKET_LISTENER_LISTENED => Self::Listened,
4019            value => Self::__Unknown(value),
4020        }
4021    }
4022}
4023
4024impl StaticType for SocketListenerEvent {
4025    #[inline]
4026    #[doc(alias = "g_socket_listener_event_get_type")]
4027    fn static_type() -> glib::Type {
4028        unsafe { from_glib(ffi::g_socket_listener_event_get_type()) }
4029    }
4030}
4031
4032impl glib::HasParamSpec for SocketListenerEvent {
4033    type ParamSpec = glib::ParamSpecEnum;
4034    type SetValue = Self;
4035    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4036
4037    fn param_spec_builder() -> Self::BuilderFn {
4038        Self::ParamSpec::builder_with_default
4039    }
4040}
4041
4042impl glib::value::ValueType for SocketListenerEvent {
4043    type Type = Self;
4044}
4045
4046unsafe impl<'a> glib::value::FromValue<'a> for SocketListenerEvent {
4047    type Checker = glib::value::GenericValueTypeChecker<Self>;
4048
4049    #[inline]
4050    unsafe fn from_value(value: &'a glib::Value) -> Self {
4051        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4052    }
4053}
4054
4055impl ToValue for SocketListenerEvent {
4056    #[inline]
4057    fn to_value(&self) -> glib::Value {
4058        let mut value = glib::Value::for_value_type::<Self>();
4059        unsafe {
4060            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4061        }
4062        value
4063    }
4064
4065    #[inline]
4066    fn value_type(&self) -> glib::Type {
4067        Self::static_type()
4068    }
4069}
4070
4071impl From<SocketListenerEvent> for glib::Value {
4072    #[inline]
4073    fn from(v: SocketListenerEvent) -> Self {
4074        ToValue::to_value(&v)
4075    }
4076}
4077
4078/// A protocol identifier is specified when creating a #GSocket, which is a
4079/// family/type specific identifier, where 0 means the default protocol for
4080/// the particular family/type.
4081///
4082/// This enum contains a set of commonly available and used protocols. You
4083/// can also pass any other identifiers handled by the platform in order to
4084/// use protocols not listed here.
4085#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4086#[non_exhaustive]
4087#[doc(alias = "GSocketProtocol")]
4088pub enum SocketProtocol {
4089    /// The protocol type is unknown
4090    #[doc(alias = "G_SOCKET_PROTOCOL_UNKNOWN")]
4091    Unknown,
4092    /// The default protocol for the family/type
4093    #[doc(alias = "G_SOCKET_PROTOCOL_DEFAULT")]
4094    Default,
4095    /// TCP over IP
4096    #[doc(alias = "G_SOCKET_PROTOCOL_TCP")]
4097    Tcp,
4098    /// UDP over IP
4099    #[doc(alias = "G_SOCKET_PROTOCOL_UDP")]
4100    Udp,
4101    /// SCTP over IP
4102    #[doc(alias = "G_SOCKET_PROTOCOL_SCTP")]
4103    Sctp,
4104    #[doc(hidden)]
4105    __Unknown(i32),
4106}
4107
4108#[doc(hidden)]
4109impl IntoGlib for SocketProtocol {
4110    type GlibType = ffi::GSocketProtocol;
4111
4112    #[inline]
4113    fn into_glib(self) -> ffi::GSocketProtocol {
4114        match self {
4115            Self::Unknown => ffi::G_SOCKET_PROTOCOL_UNKNOWN,
4116            Self::Default => ffi::G_SOCKET_PROTOCOL_DEFAULT,
4117            Self::Tcp => ffi::G_SOCKET_PROTOCOL_TCP,
4118            Self::Udp => ffi::G_SOCKET_PROTOCOL_UDP,
4119            Self::Sctp => ffi::G_SOCKET_PROTOCOL_SCTP,
4120            Self::__Unknown(value) => value,
4121        }
4122    }
4123}
4124
4125#[doc(hidden)]
4126impl FromGlib<ffi::GSocketProtocol> for SocketProtocol {
4127    #[inline]
4128    unsafe fn from_glib(value: ffi::GSocketProtocol) -> Self {
4129        match value {
4130            ffi::G_SOCKET_PROTOCOL_UNKNOWN => Self::Unknown,
4131            ffi::G_SOCKET_PROTOCOL_DEFAULT => Self::Default,
4132            ffi::G_SOCKET_PROTOCOL_TCP => Self::Tcp,
4133            ffi::G_SOCKET_PROTOCOL_UDP => Self::Udp,
4134            ffi::G_SOCKET_PROTOCOL_SCTP => Self::Sctp,
4135            value => Self::__Unknown(value),
4136        }
4137    }
4138}
4139
4140impl StaticType for SocketProtocol {
4141    #[inline]
4142    #[doc(alias = "g_socket_protocol_get_type")]
4143    fn static_type() -> glib::Type {
4144        unsafe { from_glib(ffi::g_socket_protocol_get_type()) }
4145    }
4146}
4147
4148impl glib::HasParamSpec for SocketProtocol {
4149    type ParamSpec = glib::ParamSpecEnum;
4150    type SetValue = Self;
4151    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4152
4153    fn param_spec_builder() -> Self::BuilderFn {
4154        Self::ParamSpec::builder_with_default
4155    }
4156}
4157
4158impl glib::value::ValueType for SocketProtocol {
4159    type Type = Self;
4160}
4161
4162unsafe impl<'a> glib::value::FromValue<'a> for SocketProtocol {
4163    type Checker = glib::value::GenericValueTypeChecker<Self>;
4164
4165    #[inline]
4166    unsafe fn from_value(value: &'a glib::Value) -> Self {
4167        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4168    }
4169}
4170
4171impl ToValue for SocketProtocol {
4172    #[inline]
4173    fn to_value(&self) -> glib::Value {
4174        let mut value = glib::Value::for_value_type::<Self>();
4175        unsafe {
4176            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4177        }
4178        value
4179    }
4180
4181    #[inline]
4182    fn value_type(&self) -> glib::Type {
4183        Self::static_type()
4184    }
4185}
4186
4187impl From<SocketProtocol> for glib::Value {
4188    #[inline]
4189    fn from(v: SocketProtocol) -> Self {
4190        ToValue::to_value(&v)
4191    }
4192}
4193
4194/// Flags used when creating a #GSocket. Some protocols may not implement
4195/// all the socket types.
4196#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4197#[non_exhaustive]
4198#[doc(alias = "GSocketType")]
4199pub enum SocketType {
4200    /// Type unknown or wrong
4201    #[doc(alias = "G_SOCKET_TYPE_INVALID")]
4202    Invalid,
4203    /// Reliable connection-based byte streams (e.g. TCP).
4204    #[doc(alias = "G_SOCKET_TYPE_STREAM")]
4205    Stream,
4206    /// Connectionless, unreliable datagram passing.
4207    ///     (e.g. UDP)
4208    #[doc(alias = "G_SOCKET_TYPE_DATAGRAM")]
4209    Datagram,
4210    /// Reliable connection-based passing of datagrams
4211    ///     of fixed maximum length (e.g. SCTP).
4212    #[doc(alias = "G_SOCKET_TYPE_SEQPACKET")]
4213    Seqpacket,
4214    #[doc(hidden)]
4215    __Unknown(i32),
4216}
4217
4218#[doc(hidden)]
4219impl IntoGlib for SocketType {
4220    type GlibType = ffi::GSocketType;
4221
4222    #[inline]
4223    fn into_glib(self) -> ffi::GSocketType {
4224        match self {
4225            Self::Invalid => ffi::G_SOCKET_TYPE_INVALID,
4226            Self::Stream => ffi::G_SOCKET_TYPE_STREAM,
4227            Self::Datagram => ffi::G_SOCKET_TYPE_DATAGRAM,
4228            Self::Seqpacket => ffi::G_SOCKET_TYPE_SEQPACKET,
4229            Self::__Unknown(value) => value,
4230        }
4231    }
4232}
4233
4234#[doc(hidden)]
4235impl FromGlib<ffi::GSocketType> for SocketType {
4236    #[inline]
4237    unsafe fn from_glib(value: ffi::GSocketType) -> Self {
4238        match value {
4239            ffi::G_SOCKET_TYPE_INVALID => Self::Invalid,
4240            ffi::G_SOCKET_TYPE_STREAM => Self::Stream,
4241            ffi::G_SOCKET_TYPE_DATAGRAM => Self::Datagram,
4242            ffi::G_SOCKET_TYPE_SEQPACKET => Self::Seqpacket,
4243            value => Self::__Unknown(value),
4244        }
4245    }
4246}
4247
4248impl StaticType for SocketType {
4249    #[inline]
4250    #[doc(alias = "g_socket_type_get_type")]
4251    fn static_type() -> glib::Type {
4252        unsafe { from_glib(ffi::g_socket_type_get_type()) }
4253    }
4254}
4255
4256impl glib::HasParamSpec for SocketType {
4257    type ParamSpec = glib::ParamSpecEnum;
4258    type SetValue = Self;
4259    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4260
4261    fn param_spec_builder() -> Self::BuilderFn {
4262        Self::ParamSpec::builder_with_default
4263    }
4264}
4265
4266impl glib::value::ValueType for SocketType {
4267    type Type = Self;
4268}
4269
4270unsafe impl<'a> glib::value::FromValue<'a> for SocketType {
4271    type Checker = glib::value::GenericValueTypeChecker<Self>;
4272
4273    #[inline]
4274    unsafe fn from_value(value: &'a glib::Value) -> Self {
4275        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4276    }
4277}
4278
4279impl ToValue for SocketType {
4280    #[inline]
4281    fn to_value(&self) -> glib::Value {
4282        let mut value = glib::Value::for_value_type::<Self>();
4283        unsafe {
4284            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4285        }
4286        value
4287    }
4288
4289    #[inline]
4290    fn value_type(&self) -> glib::Type {
4291        Self::static_type()
4292    }
4293}
4294
4295impl From<SocketType> for glib::Value {
4296    #[inline]
4297    fn from(v: SocketType) -> Self {
4298        ToValue::to_value(&v)
4299    }
4300}
4301
4302/// The client authentication mode for a #GTlsServerConnection.
4303#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4304#[non_exhaustive]
4305#[doc(alias = "GTlsAuthenticationMode")]
4306pub enum TlsAuthenticationMode {
4307    /// client authentication not required
4308    #[doc(alias = "G_TLS_AUTHENTICATION_NONE")]
4309    None,
4310    /// client authentication is requested
4311    #[doc(alias = "G_TLS_AUTHENTICATION_REQUESTED")]
4312    Requested,
4313    /// client authentication is required
4314    #[doc(alias = "G_TLS_AUTHENTICATION_REQUIRED")]
4315    Required,
4316    #[doc(hidden)]
4317    __Unknown(i32),
4318}
4319
4320#[doc(hidden)]
4321impl IntoGlib for TlsAuthenticationMode {
4322    type GlibType = ffi::GTlsAuthenticationMode;
4323
4324    #[inline]
4325    fn into_glib(self) -> ffi::GTlsAuthenticationMode {
4326        match self {
4327            Self::None => ffi::G_TLS_AUTHENTICATION_NONE,
4328            Self::Requested => ffi::G_TLS_AUTHENTICATION_REQUESTED,
4329            Self::Required => ffi::G_TLS_AUTHENTICATION_REQUIRED,
4330            Self::__Unknown(value) => value,
4331        }
4332    }
4333}
4334
4335#[doc(hidden)]
4336impl FromGlib<ffi::GTlsAuthenticationMode> for TlsAuthenticationMode {
4337    #[inline]
4338    unsafe fn from_glib(value: ffi::GTlsAuthenticationMode) -> Self {
4339        match value {
4340            ffi::G_TLS_AUTHENTICATION_NONE => Self::None,
4341            ffi::G_TLS_AUTHENTICATION_REQUESTED => Self::Requested,
4342            ffi::G_TLS_AUTHENTICATION_REQUIRED => Self::Required,
4343            value => Self::__Unknown(value),
4344        }
4345    }
4346}
4347
4348impl StaticType for TlsAuthenticationMode {
4349    #[inline]
4350    #[doc(alias = "g_tls_authentication_mode_get_type")]
4351    fn static_type() -> glib::Type {
4352        unsafe { from_glib(ffi::g_tls_authentication_mode_get_type()) }
4353    }
4354}
4355
4356impl glib::HasParamSpec for TlsAuthenticationMode {
4357    type ParamSpec = glib::ParamSpecEnum;
4358    type SetValue = Self;
4359    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4360
4361    fn param_spec_builder() -> Self::BuilderFn {
4362        Self::ParamSpec::builder_with_default
4363    }
4364}
4365
4366impl glib::value::ValueType for TlsAuthenticationMode {
4367    type Type = Self;
4368}
4369
4370unsafe impl<'a> glib::value::FromValue<'a> for TlsAuthenticationMode {
4371    type Checker = glib::value::GenericValueTypeChecker<Self>;
4372
4373    #[inline]
4374    unsafe fn from_value(value: &'a glib::Value) -> Self {
4375        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4376    }
4377}
4378
4379impl ToValue for TlsAuthenticationMode {
4380    #[inline]
4381    fn to_value(&self) -> glib::Value {
4382        let mut value = glib::Value::for_value_type::<Self>();
4383        unsafe {
4384            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4385        }
4386        value
4387    }
4388
4389    #[inline]
4390    fn value_type(&self) -> glib::Type {
4391        Self::static_type()
4392    }
4393}
4394
4395impl From<TlsAuthenticationMode> for glib::Value {
4396    #[inline]
4397    fn from(v: TlsAuthenticationMode) -> Self {
4398        ToValue::to_value(&v)
4399    }
4400}
4401
4402/// An error code used with `G_TLS_CHANNEL_BINDING_ERROR` in a #GError to
4403/// indicate a TLS channel binding retrieval error.
4404#[cfg(feature = "v2_66")]
4405#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4406#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4407#[non_exhaustive]
4408#[doc(alias = "GTlsChannelBindingError")]
4409pub enum TlsChannelBindingError {
4410    /// Either entire binding
4411    ///    retrieval facility or specific binding type is not implemented in the
4412    ///    TLS backend.
4413    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED")]
4414    NotImplemented,
4415    /// The handshake is not yet
4416    ///    complete on the connection which is a strong requirement for any existing
4417    ///    binding type.
4418    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE")]
4419    InvalidState,
4420    /// Handshake is complete but
4421    ///    binding data is not available. That normally indicates the TLS
4422    ///    implementation failed to provide the binding data. For example, some
4423    ///    implementations do not provide a peer certificate for resumed connections.
4424    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE")]
4425    NotAvailable,
4426    /// Binding type is not supported
4427    ///    on the current connection. This error could be triggered when requesting
4428    ///    `tls-server-end-point` binding data for a certificate which has no hash
4429    ///    function or uses multiple hash functions.
4430    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED")]
4431    NotSupported,
4432    /// Any other backend error
4433    ///    preventing binding data retrieval.
4434    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR")]
4435    GeneralError,
4436    #[doc(hidden)]
4437    __Unknown(i32),
4438}
4439
4440#[cfg(feature = "v2_66")]
4441#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4442#[doc(hidden)]
4443impl IntoGlib for TlsChannelBindingError {
4444    type GlibType = ffi::GTlsChannelBindingError;
4445
4446    #[inline]
4447    fn into_glib(self) -> ffi::GTlsChannelBindingError {
4448        match self {
4449            Self::NotImplemented => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED,
4450            Self::InvalidState => ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE,
4451            Self::NotAvailable => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE,
4452            Self::NotSupported => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED,
4453            Self::GeneralError => ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR,
4454            Self::__Unknown(value) => value,
4455        }
4456    }
4457}
4458
4459#[cfg(feature = "v2_66")]
4460#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4461#[doc(hidden)]
4462impl FromGlib<ffi::GTlsChannelBindingError> for TlsChannelBindingError {
4463    #[inline]
4464    unsafe fn from_glib(value: ffi::GTlsChannelBindingError) -> Self {
4465        match value {
4466            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
4467            ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE => Self::InvalidState,
4468            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE => Self::NotAvailable,
4469            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED => Self::NotSupported,
4470            ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR => Self::GeneralError,
4471            value => Self::__Unknown(value),
4472        }
4473    }
4474}
4475
4476#[cfg(feature = "v2_66")]
4477#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4478impl glib::error::ErrorDomain for TlsChannelBindingError {
4479    #[inline]
4480    fn domain() -> glib::Quark {
4481        unsafe { from_glib(ffi::g_tls_channel_binding_error_quark()) }
4482    }
4483
4484    #[inline]
4485    fn code(self) -> i32 {
4486        self.into_glib()
4487    }
4488
4489    #[inline]
4490    #[allow(clippy::match_single_binding)]
4491    fn from(code: i32) -> Option<Self> {
4492        match unsafe { from_glib(code) } {
4493            value => Some(value),
4494        }
4495    }
4496}
4497
4498#[cfg(feature = "v2_66")]
4499#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4500impl StaticType for TlsChannelBindingError {
4501    #[inline]
4502    #[doc(alias = "g_tls_channel_binding_error_get_type")]
4503    fn static_type() -> glib::Type {
4504        unsafe { from_glib(ffi::g_tls_channel_binding_error_get_type()) }
4505    }
4506}
4507
4508#[cfg(feature = "v2_66")]
4509#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4510impl glib::HasParamSpec for TlsChannelBindingError {
4511    type ParamSpec = glib::ParamSpecEnum;
4512    type SetValue = Self;
4513    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4514
4515    fn param_spec_builder() -> Self::BuilderFn {
4516        Self::ParamSpec::builder_with_default
4517    }
4518}
4519
4520#[cfg(feature = "v2_66")]
4521#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4522impl glib::value::ValueType for TlsChannelBindingError {
4523    type Type = Self;
4524}
4525
4526#[cfg(feature = "v2_66")]
4527#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4528unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingError {
4529    type Checker = glib::value::GenericValueTypeChecker<Self>;
4530
4531    #[inline]
4532    unsafe fn from_value(value: &'a glib::Value) -> Self {
4533        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4534    }
4535}
4536
4537#[cfg(feature = "v2_66")]
4538#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4539impl ToValue for TlsChannelBindingError {
4540    #[inline]
4541    fn to_value(&self) -> glib::Value {
4542        let mut value = glib::Value::for_value_type::<Self>();
4543        unsafe {
4544            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4545        }
4546        value
4547    }
4548
4549    #[inline]
4550    fn value_type(&self) -> glib::Type {
4551        Self::static_type()
4552    }
4553}
4554
4555#[cfg(feature = "v2_66")]
4556#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4557impl From<TlsChannelBindingError> for glib::Value {
4558    #[inline]
4559    fn from(v: TlsChannelBindingError) -> Self {
4560        ToValue::to_value(&v)
4561    }
4562}
4563
4564/// The type of TLS channel binding data to retrieve from #GTlsConnection
4565/// or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The
4566/// [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5)
4567/// binding type is not currently implemented.
4568#[cfg(feature = "v2_66")]
4569#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4570#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4571#[non_exhaustive]
4572#[doc(alias = "GTlsChannelBindingType")]
4573pub enum TlsChannelBindingType {
4574    /// [`tls-unique`](https://tools.ietf.org/html/rfc5929#section-3) binding
4575    ///    type
4576    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_UNIQUE")]
4577    Unique,
4578    /// [`tls-server-end-point`](https://tools.ietf.org/html/rfc5929#section-4)
4579    ///    binding type
4580    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT")]
4581    ServerEndPoint,
4582    /// [`tls-exporter`](https://www.rfc-editor.org/rfc/rfc9266.html) binding
4583    ///    type. Since: 2.74
4584    #[cfg(feature = "v2_74")]
4585    #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
4586    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_EXPORTER")]
4587    Exporter,
4588    #[doc(hidden)]
4589    __Unknown(i32),
4590}
4591
4592#[cfg(feature = "v2_66")]
4593#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4594#[doc(hidden)]
4595impl IntoGlib for TlsChannelBindingType {
4596    type GlibType = ffi::GTlsChannelBindingType;
4597
4598    #[inline]
4599    fn into_glib(self) -> ffi::GTlsChannelBindingType {
4600        match self {
4601            Self::Unique => ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE,
4602            Self::ServerEndPoint => ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT,
4603            #[cfg(feature = "v2_74")]
4604            Self::Exporter => ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER,
4605            Self::__Unknown(value) => value,
4606        }
4607    }
4608}
4609
4610#[cfg(feature = "v2_66")]
4611#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4612#[doc(hidden)]
4613impl FromGlib<ffi::GTlsChannelBindingType> for TlsChannelBindingType {
4614    #[inline]
4615    unsafe fn from_glib(value: ffi::GTlsChannelBindingType) -> Self {
4616        match value {
4617            ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE => Self::Unique,
4618            ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT => Self::ServerEndPoint,
4619            #[cfg(feature = "v2_74")]
4620            ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER => Self::Exporter,
4621            value => Self::__Unknown(value),
4622        }
4623    }
4624}
4625
4626#[cfg(feature = "v2_66")]
4627#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4628impl StaticType for TlsChannelBindingType {
4629    #[inline]
4630    #[doc(alias = "g_tls_channel_binding_type_get_type")]
4631    fn static_type() -> glib::Type {
4632        unsafe { from_glib(ffi::g_tls_channel_binding_type_get_type()) }
4633    }
4634}
4635
4636#[cfg(feature = "v2_66")]
4637#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4638impl glib::HasParamSpec for TlsChannelBindingType {
4639    type ParamSpec = glib::ParamSpecEnum;
4640    type SetValue = Self;
4641    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4642
4643    fn param_spec_builder() -> Self::BuilderFn {
4644        Self::ParamSpec::builder_with_default
4645    }
4646}
4647
4648#[cfg(feature = "v2_66")]
4649#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4650impl glib::value::ValueType for TlsChannelBindingType {
4651    type Type = Self;
4652}
4653
4654#[cfg(feature = "v2_66")]
4655#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4656unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingType {
4657    type Checker = glib::value::GenericValueTypeChecker<Self>;
4658
4659    #[inline]
4660    unsafe fn from_value(value: &'a glib::Value) -> Self {
4661        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4662    }
4663}
4664
4665#[cfg(feature = "v2_66")]
4666#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4667impl ToValue for TlsChannelBindingType {
4668    #[inline]
4669    fn to_value(&self) -> glib::Value {
4670        let mut value = glib::Value::for_value_type::<Self>();
4671        unsafe {
4672            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4673        }
4674        value
4675    }
4676
4677    #[inline]
4678    fn value_type(&self) -> glib::Type {
4679        Self::static_type()
4680    }
4681}
4682
4683#[cfg(feature = "v2_66")]
4684#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4685impl From<TlsChannelBindingType> for glib::Value {
4686    #[inline]
4687    fn from(v: TlsChannelBindingType) -> Self {
4688        ToValue::to_value(&v)
4689    }
4690}
4691
4692/// An error code used with `G_TLS_ERROR` in a #GError returned from a
4693/// TLS-related routine.
4694#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4695#[non_exhaustive]
4696#[doc(alias = "GTlsError")]
4697pub enum TlsError {
4698    /// No TLS provider is available
4699    #[doc(alias = "G_TLS_ERROR_UNAVAILABLE")]
4700    Unavailable,
4701    /// Miscellaneous TLS error
4702    #[doc(alias = "G_TLS_ERROR_MISC")]
4703    Misc,
4704    /// The certificate presented could not
4705    ///   be parsed or failed validation.
4706    #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE")]
4707    BadCertificate,
4708    /// The TLS handshake failed because the
4709    ///   peer does not seem to be a TLS server.
4710    #[doc(alias = "G_TLS_ERROR_NOT_TLS")]
4711    NotTls,
4712    /// The TLS handshake failed because the
4713    ///   peer's certificate was not acceptable.
4714    #[doc(alias = "G_TLS_ERROR_HANDSHAKE")]
4715    Handshake,
4716    /// The TLS handshake failed because
4717    ///   the server requested a client-side certificate, but none was
4718    ///   provided. See g_tls_connection_set_certificate().
4719    #[doc(alias = "G_TLS_ERROR_CERTIFICATE_REQUIRED")]
4720    CertificateRequired,
4721    /// The TLS connection was closed without proper
4722    ///   notice, which may indicate an attack. See
4723    ///   g_tls_connection_set_require_close_notify().
4724    #[doc(alias = "G_TLS_ERROR_EOF")]
4725    Eof,
4726    /// The TLS handshake failed
4727    ///   because the client sent the fallback SCSV, indicating a protocol
4728    ///   downgrade attack. Since: 2.60
4729    #[doc(alias = "G_TLS_ERROR_INAPPROPRIATE_FALLBACK")]
4730    InappropriateFallback,
4731    /// The certificate failed
4732    ///   to load because a password was incorrect. Since: 2.72
4733    #[cfg(feature = "v2_72")]
4734    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
4735    #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD")]
4736    BadCertificatePassword,
4737    #[doc(hidden)]
4738    __Unknown(i32),
4739}
4740
4741#[doc(hidden)]
4742impl IntoGlib for TlsError {
4743    type GlibType = ffi::GTlsError;
4744
4745    #[inline]
4746    fn into_glib(self) -> ffi::GTlsError {
4747        match self {
4748            Self::Unavailable => ffi::G_TLS_ERROR_UNAVAILABLE,
4749            Self::Misc => ffi::G_TLS_ERROR_MISC,
4750            Self::BadCertificate => ffi::G_TLS_ERROR_BAD_CERTIFICATE,
4751            Self::NotTls => ffi::G_TLS_ERROR_NOT_TLS,
4752            Self::Handshake => ffi::G_TLS_ERROR_HANDSHAKE,
4753            Self::CertificateRequired => ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED,
4754            Self::Eof => ffi::G_TLS_ERROR_EOF,
4755            Self::InappropriateFallback => ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK,
4756            #[cfg(feature = "v2_72")]
4757            Self::BadCertificatePassword => ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD,
4758            Self::__Unknown(value) => value,
4759        }
4760    }
4761}
4762
4763#[doc(hidden)]
4764impl FromGlib<ffi::GTlsError> for TlsError {
4765    #[inline]
4766    unsafe fn from_glib(value: ffi::GTlsError) -> Self {
4767        match value {
4768            ffi::G_TLS_ERROR_UNAVAILABLE => Self::Unavailable,
4769            ffi::G_TLS_ERROR_MISC => Self::Misc,
4770            ffi::G_TLS_ERROR_BAD_CERTIFICATE => Self::BadCertificate,
4771            ffi::G_TLS_ERROR_NOT_TLS => Self::NotTls,
4772            ffi::G_TLS_ERROR_HANDSHAKE => Self::Handshake,
4773            ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED => Self::CertificateRequired,
4774            ffi::G_TLS_ERROR_EOF => Self::Eof,
4775            ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK => Self::InappropriateFallback,
4776            #[cfg(feature = "v2_72")]
4777            ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD => Self::BadCertificatePassword,
4778            value => Self::__Unknown(value),
4779        }
4780    }
4781}
4782
4783impl glib::error::ErrorDomain for TlsError {
4784    #[inline]
4785    fn domain() -> glib::Quark {
4786        unsafe { from_glib(ffi::g_tls_error_quark()) }
4787    }
4788
4789    #[inline]
4790    fn code(self) -> i32 {
4791        self.into_glib()
4792    }
4793
4794    #[inline]
4795    #[allow(clippy::match_single_binding)]
4796    fn from(code: i32) -> Option<Self> {
4797        match unsafe { from_glib(code) } {
4798            value => Some(value),
4799        }
4800    }
4801}
4802
4803impl StaticType for TlsError {
4804    #[inline]
4805    #[doc(alias = "g_tls_error_get_type")]
4806    fn static_type() -> glib::Type {
4807        unsafe { from_glib(ffi::g_tls_error_get_type()) }
4808    }
4809}
4810
4811impl glib::HasParamSpec for TlsError {
4812    type ParamSpec = glib::ParamSpecEnum;
4813    type SetValue = Self;
4814    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4815
4816    fn param_spec_builder() -> Self::BuilderFn {
4817        Self::ParamSpec::builder_with_default
4818    }
4819}
4820
4821impl glib::value::ValueType for TlsError {
4822    type Type = Self;
4823}
4824
4825unsafe impl<'a> glib::value::FromValue<'a> for TlsError {
4826    type Checker = glib::value::GenericValueTypeChecker<Self>;
4827
4828    #[inline]
4829    unsafe fn from_value(value: &'a glib::Value) -> Self {
4830        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4831    }
4832}
4833
4834impl ToValue for TlsError {
4835    #[inline]
4836    fn to_value(&self) -> glib::Value {
4837        let mut value = glib::Value::for_value_type::<Self>();
4838        unsafe {
4839            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4840        }
4841        value
4842    }
4843
4844    #[inline]
4845    fn value_type(&self) -> glib::Type {
4846        Self::static_type()
4847    }
4848}
4849
4850impl From<TlsError> for glib::Value {
4851    #[inline]
4852    fn from(v: TlsError) -> Self {
4853        ToValue::to_value(&v)
4854    }
4855}
4856
4857/// #GTlsInteractionResult is returned by various functions in #GTlsInteraction
4858/// when finishing an interaction request.
4859#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4860#[non_exhaustive]
4861#[doc(alias = "GTlsInteractionResult")]
4862pub enum TlsInteractionResult {
4863    /// The interaction was unhandled (i.e. not
4864    ///     implemented).
4865    #[doc(alias = "G_TLS_INTERACTION_UNHANDLED")]
4866    Unhandled,
4867    /// The interaction completed, and resulting data
4868    ///     is available.
4869    #[doc(alias = "G_TLS_INTERACTION_HANDLED")]
4870    Handled,
4871    /// The interaction has failed, or was cancelled.
4872    ///     and the operation should be aborted.
4873    #[doc(alias = "G_TLS_INTERACTION_FAILED")]
4874    Failed,
4875    #[doc(hidden)]
4876    __Unknown(i32),
4877}
4878
4879#[doc(hidden)]
4880impl IntoGlib for TlsInteractionResult {
4881    type GlibType = ffi::GTlsInteractionResult;
4882
4883    #[inline]
4884    fn into_glib(self) -> ffi::GTlsInteractionResult {
4885        match self {
4886            Self::Unhandled => ffi::G_TLS_INTERACTION_UNHANDLED,
4887            Self::Handled => ffi::G_TLS_INTERACTION_HANDLED,
4888            Self::Failed => ffi::G_TLS_INTERACTION_FAILED,
4889            Self::__Unknown(value) => value,
4890        }
4891    }
4892}
4893
4894#[doc(hidden)]
4895impl FromGlib<ffi::GTlsInteractionResult> for TlsInteractionResult {
4896    #[inline]
4897    unsafe fn from_glib(value: ffi::GTlsInteractionResult) -> Self {
4898        match value {
4899            ffi::G_TLS_INTERACTION_UNHANDLED => Self::Unhandled,
4900            ffi::G_TLS_INTERACTION_HANDLED => Self::Handled,
4901            ffi::G_TLS_INTERACTION_FAILED => Self::Failed,
4902            value => Self::__Unknown(value),
4903        }
4904    }
4905}
4906
4907impl StaticType for TlsInteractionResult {
4908    #[inline]
4909    #[doc(alias = "g_tls_interaction_result_get_type")]
4910    fn static_type() -> glib::Type {
4911        unsafe { from_glib(ffi::g_tls_interaction_result_get_type()) }
4912    }
4913}
4914
4915impl glib::HasParamSpec for TlsInteractionResult {
4916    type ParamSpec = glib::ParamSpecEnum;
4917    type SetValue = Self;
4918    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4919
4920    fn param_spec_builder() -> Self::BuilderFn {
4921        Self::ParamSpec::builder_with_default
4922    }
4923}
4924
4925impl glib::value::ValueType for TlsInteractionResult {
4926    type Type = Self;
4927}
4928
4929unsafe impl<'a> glib::value::FromValue<'a> for TlsInteractionResult {
4930    type Checker = glib::value::GenericValueTypeChecker<Self>;
4931
4932    #[inline]
4933    unsafe fn from_value(value: &'a glib::Value) -> Self {
4934        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4935    }
4936}
4937
4938impl ToValue for TlsInteractionResult {
4939    #[inline]
4940    fn to_value(&self) -> glib::Value {
4941        let mut value = glib::Value::for_value_type::<Self>();
4942        unsafe {
4943            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4944        }
4945        value
4946    }
4947
4948    #[inline]
4949    fn value_type(&self) -> glib::Type {
4950        Self::static_type()
4951    }
4952}
4953
4954impl From<TlsInteractionResult> for glib::Value {
4955    #[inline]
4956    fn from(v: TlsInteractionResult) -> Self {
4957        ToValue::to_value(&v)
4958    }
4959}
4960
4961/// The TLS or DTLS protocol version used by a #GTlsConnection or
4962/// #GDtlsConnection. The integer values of these versions are sequential
4963/// to ensure newer known protocol versions compare greater than older
4964/// known versions. Any known DTLS protocol version will compare greater
4965/// than any SSL or TLS protocol version. The protocol version may be
4966/// [`Unknown`][Self::Unknown] if the TLS backend supports a newer
4967/// protocol version that GLib does not yet know about. This means that
4968/// it's possible for an unknown DTLS protocol version to compare less
4969/// than the TLS protocol versions.
4970#[cfg(feature = "v2_70")]
4971#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
4972#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4973#[non_exhaustive]
4974#[doc(alias = "GTlsProtocolVersion")]
4975pub enum TlsProtocolVersion {
4976    /// No protocol version or unknown protocol version
4977    #[doc(alias = "G_TLS_PROTOCOL_VERSION_UNKNOWN")]
4978    Unknown,
4979    /// SSL 3.0, which is insecure and should not be used
4980    #[doc(alias = "G_TLS_PROTOCOL_VERSION_SSL_3_0")]
4981    Ssl30,
4982    /// TLS 1.0, which is insecure and should not be used
4983    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_0")]
4984    Tls10,
4985    /// TLS 1.1, which is insecure and should not be used
4986    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_1")]
4987    Tls11,
4988    /// TLS 1.2, defined by [RFC 5246](https://datatracker.ietf.org/doc/html/rfc5246)
4989    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_2")]
4990    Tls12,
4991    /// TLS 1.3, defined by [RFC 8446](https://datatracker.ietf.org/doc/html/rfc8446)
4992    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_3")]
4993    Tls13,
4994    /// DTLS 1.0, which is insecure and should not be used
4995    #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_0")]
4996    Dtls10,
4997    /// DTLS 1.2, defined by [RFC 6347](https://datatracker.ietf.org/doc/html/rfc6347)
4998    #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_2")]
4999    Dtls12,
5000    #[doc(hidden)]
5001    __Unknown(i32),
5002}
5003
5004#[cfg(feature = "v2_70")]
5005#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5006#[doc(hidden)]
5007impl IntoGlib for TlsProtocolVersion {
5008    type GlibType = ffi::GTlsProtocolVersion;
5009
5010    #[inline]
5011    fn into_glib(self) -> ffi::GTlsProtocolVersion {
5012        match self {
5013            Self::Unknown => ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN,
5014            Self::Ssl30 => ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0,
5015            Self::Tls10 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0,
5016            Self::Tls11 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1,
5017            Self::Tls12 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2,
5018            Self::Tls13 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3,
5019            Self::Dtls10 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0,
5020            Self::Dtls12 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2,
5021            Self::__Unknown(value) => value,
5022        }
5023    }
5024}
5025
5026#[cfg(feature = "v2_70")]
5027#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5028#[doc(hidden)]
5029impl FromGlib<ffi::GTlsProtocolVersion> for TlsProtocolVersion {
5030    #[inline]
5031    unsafe fn from_glib(value: ffi::GTlsProtocolVersion) -> Self {
5032        match value {
5033            ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN => Self::Unknown,
5034            ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0 => Self::Ssl30,
5035            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0 => Self::Tls10,
5036            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1 => Self::Tls11,
5037            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2 => Self::Tls12,
5038            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3 => Self::Tls13,
5039            ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0 => Self::Dtls10,
5040            ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2 => Self::Dtls12,
5041            value => Self::__Unknown(value),
5042        }
5043    }
5044}
5045
5046#[cfg(feature = "v2_70")]
5047#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5048impl StaticType for TlsProtocolVersion {
5049    #[inline]
5050    #[doc(alias = "g_tls_protocol_version_get_type")]
5051    fn static_type() -> glib::Type {
5052        unsafe { from_glib(ffi::g_tls_protocol_version_get_type()) }
5053    }
5054}
5055
5056#[cfg(feature = "v2_70")]
5057#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5058impl glib::HasParamSpec for TlsProtocolVersion {
5059    type ParamSpec = glib::ParamSpecEnum;
5060    type SetValue = Self;
5061    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5062
5063    fn param_spec_builder() -> Self::BuilderFn {
5064        Self::ParamSpec::builder_with_default
5065    }
5066}
5067
5068#[cfg(feature = "v2_70")]
5069#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5070impl glib::value::ValueType for TlsProtocolVersion {
5071    type Type = Self;
5072}
5073
5074#[cfg(feature = "v2_70")]
5075#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5076unsafe impl<'a> glib::value::FromValue<'a> for TlsProtocolVersion {
5077    type Checker = glib::value::GenericValueTypeChecker<Self>;
5078
5079    #[inline]
5080    unsafe fn from_value(value: &'a glib::Value) -> Self {
5081        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
5082    }
5083}
5084
5085#[cfg(feature = "v2_70")]
5086#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5087impl ToValue for TlsProtocolVersion {
5088    #[inline]
5089    fn to_value(&self) -> glib::Value {
5090        let mut value = glib::Value::for_value_type::<Self>();
5091        unsafe {
5092            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5093        }
5094        value
5095    }
5096
5097    #[inline]
5098    fn value_type(&self) -> glib::Type {
5099        Self::static_type()
5100    }
5101}
5102
5103#[cfg(feature = "v2_70")]
5104#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5105impl From<TlsProtocolVersion> for glib::Value {
5106    #[inline]
5107    fn from(v: TlsProtocolVersion) -> Self {
5108        ToValue::to_value(&v)
5109    }
5110}
5111
5112/// When to allow rehandshaking. See
5113/// g_tls_connection_set_rehandshake_mode().
5114///
5115/// # Deprecated since 2.60
5116///
5117/// Changing the rehandshake mode is no longer
5118///   required for compatibility. Also, rehandshaking has been removed
5119///   from the TLS protocol in TLS 1.3.
5120#[cfg_attr(feature = "v2_60", deprecated = "Since 2.60")]
5121#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5122#[non_exhaustive]
5123#[doc(alias = "GTlsRehandshakeMode")]
5124pub enum TlsRehandshakeMode {
5125    /// Never allow rehandshaking
5126    #[doc(alias = "G_TLS_REHANDSHAKE_NEVER")]
5127    Never,
5128    /// Allow safe rehandshaking only
5129    #[doc(alias = "G_TLS_REHANDSHAKE_SAFELY")]
5130    Safely,
5131    /// Allow unsafe rehandshaking
5132    #[doc(alias = "G_TLS_REHANDSHAKE_UNSAFELY")]
5133    Unsafely,
5134    #[doc(hidden)]
5135    __Unknown(i32),
5136}
5137
5138#[allow(deprecated)]
5139#[doc(hidden)]
5140impl IntoGlib for TlsRehandshakeMode {
5141    type GlibType = ffi::GTlsRehandshakeMode;
5142
5143    #[inline]
5144    fn into_glib(self) -> ffi::GTlsRehandshakeMode {
5145        match self {
5146            Self::Never => ffi::G_TLS_REHANDSHAKE_NEVER,
5147            Self::Safely => ffi::G_TLS_REHANDSHAKE_SAFELY,
5148            Self::Unsafely => ffi::G_TLS_REHANDSHAKE_UNSAFELY,
5149            Self::__Unknown(value) => value,
5150        }
5151    }
5152}
5153
5154#[allow(deprecated)]
5155#[doc(hidden)]
5156impl FromGlib<ffi::GTlsRehandshakeMode> for TlsRehandshakeMode {
5157    #[inline]
5158    unsafe fn from_glib(value: ffi::GTlsRehandshakeMode) -> Self {
5159        match value {
5160            ffi::G_TLS_REHANDSHAKE_NEVER => Self::Never,
5161            ffi::G_TLS_REHANDSHAKE_SAFELY => Self::Safely,
5162            ffi::G_TLS_REHANDSHAKE_UNSAFELY => Self::Unsafely,
5163            value => Self::__Unknown(value),
5164        }
5165    }
5166}
5167
5168#[allow(deprecated)]
5169impl StaticType for TlsRehandshakeMode {
5170    #[inline]
5171    #[doc(alias = "g_tls_rehandshake_mode_get_type")]
5172    fn static_type() -> glib::Type {
5173        unsafe { from_glib(ffi::g_tls_rehandshake_mode_get_type()) }
5174    }
5175}
5176
5177#[allow(deprecated)]
5178impl glib::HasParamSpec for TlsRehandshakeMode {
5179    type ParamSpec = glib::ParamSpecEnum;
5180    type SetValue = Self;
5181    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5182
5183    fn param_spec_builder() -> Self::BuilderFn {
5184        Self::ParamSpec::builder_with_default
5185    }
5186}
5187
5188#[allow(deprecated)]
5189impl glib::value::ValueType for TlsRehandshakeMode {
5190    type Type = Self;
5191}
5192
5193#[allow(deprecated)]
5194unsafe impl<'a> glib::value::FromValue<'a> for TlsRehandshakeMode {
5195    type Checker = glib::value::GenericValueTypeChecker<Self>;
5196
5197    #[inline]
5198    unsafe fn from_value(value: &'a glib::Value) -> Self {
5199        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
5200    }
5201}
5202
5203#[allow(deprecated)]
5204impl ToValue for TlsRehandshakeMode {
5205    #[inline]
5206    fn to_value(&self) -> glib::Value {
5207        let mut value = glib::Value::for_value_type::<Self>();
5208        unsafe {
5209            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5210        }
5211        value
5212    }
5213
5214    #[inline]
5215    fn value_type(&self) -> glib::Type {
5216        Self::static_type()
5217    }
5218}
5219
5220#[allow(deprecated)]
5221impl From<TlsRehandshakeMode> for glib::Value {
5222    #[inline]
5223    fn from(v: TlsRehandshakeMode) -> Self {
5224        ToValue::to_value(&v)
5225    }
5226}
5227
5228/// The type of name used by a #GUnixSocketAddress.
5229/// [`Path`][Self::Path] indicates a traditional unix domain
5230/// socket bound to a filesystem path. [`Anonymous`][Self::Anonymous]
5231/// indicates a socket not bound to any name (eg, a client-side socket,
5232/// or a socket created with socketpair()).
5233///
5234/// For abstract sockets, there are two incompatible ways of naming
5235/// them; the man pages suggest using the entire `struct sockaddr_un`
5236/// as the name, padding the unused parts of the `sun_path` field with
5237/// zeroes; this corresponds to [`AbstractPadded`][Self::AbstractPadded].
5238/// However, many programs instead just use a portion of `sun_path`, and
5239/// pass an appropriate smaller length to bind() or connect(). This is
5240/// [`Abstract`][Self::Abstract].
5241#[cfg(unix)]
5242#[cfg_attr(docsrs, doc(cfg(unix)))]
5243#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5244#[non_exhaustive]
5245#[doc(alias = "GUnixSocketAddressType")]
5246pub enum UnixSocketAddressType {
5247    /// invalid
5248    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_INVALID")]
5249    Invalid,
5250    /// anonymous
5251    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ANONYMOUS")]
5252    Anonymous,
5253    /// a filesystem path
5254    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_PATH")]
5255    Path,
5256    /// an abstract name
5257    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT")]
5258    Abstract,
5259    /// an abstract name, 0-padded
5260    ///   to the full length of a unix socket name
5261    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED")]
5262    AbstractPadded,
5263    #[doc(hidden)]
5264    __Unknown(i32),
5265}
5266
5267#[cfg(unix)]
5268#[doc(hidden)]
5269impl IntoGlib for UnixSocketAddressType {
5270    type GlibType = ffi::GUnixSocketAddressType;
5271
5272    #[inline]
5273    fn into_glib(self) -> ffi::GUnixSocketAddressType {
5274        match self {
5275            Self::Invalid => ffi::G_UNIX_SOCKET_ADDRESS_INVALID,
5276            Self::Anonymous => ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS,
5277            Self::Path => ffi::G_UNIX_SOCKET_ADDRESS_PATH,
5278            Self::Abstract => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT,
5279            Self::AbstractPadded => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED,
5280            Self::__Unknown(value) => value,
5281        }
5282    }
5283}
5284
5285#[cfg(unix)]
5286#[doc(hidden)]
5287impl FromGlib<ffi::GUnixSocketAddressType> for UnixSocketAddressType {
5288    #[inline]
5289    unsafe fn from_glib(value: ffi::GUnixSocketAddressType) -> Self {
5290        match value {
5291            ffi::G_UNIX_SOCKET_ADDRESS_INVALID => Self::Invalid,
5292            ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS => Self::Anonymous,
5293            ffi::G_UNIX_SOCKET_ADDRESS_PATH => Self::Path,
5294            ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT => Self::Abstract,
5295            ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED => Self::AbstractPadded,
5296            value => Self::__Unknown(value),
5297        }
5298    }
5299}
5300
5301#[cfg(unix)]
5302impl StaticType for UnixSocketAddressType {
5303    #[inline]
5304    #[doc(alias = "g_unix_socket_address_type_get_type")]
5305    fn static_type() -> glib::Type {
5306        unsafe { from_glib(ffi::g_unix_socket_address_type_get_type()) }
5307    }
5308}
5309
5310#[cfg(unix)]
5311impl glib::HasParamSpec for UnixSocketAddressType {
5312    type ParamSpec = glib::ParamSpecEnum;
5313    type SetValue = Self;
5314    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5315
5316    fn param_spec_builder() -> Self::BuilderFn {
5317        Self::ParamSpec::builder_with_default
5318    }
5319}
5320
5321#[cfg(unix)]
5322impl glib::value::ValueType for UnixSocketAddressType {
5323    type Type = Self;
5324}
5325
5326#[cfg(unix)]
5327unsafe impl<'a> glib::value::FromValue<'a> for UnixSocketAddressType {
5328    type Checker = glib::value::GenericValueTypeChecker<Self>;
5329
5330    #[inline]
5331    unsafe fn from_value(value: &'a glib::Value) -> Self {
5332        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
5333    }
5334}
5335
5336#[cfg(unix)]
5337impl ToValue for UnixSocketAddressType {
5338    #[inline]
5339    fn to_value(&self) -> glib::Value {
5340        let mut value = glib::Value::for_value_type::<Self>();
5341        unsafe {
5342            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5343        }
5344        value
5345    }
5346
5347    #[inline]
5348    fn value_type(&self) -> glib::Type {
5349        Self::static_type()
5350    }
5351}
5352
5353#[cfg(unix)]
5354impl From<UnixSocketAddressType> for glib::Value {
5355    #[inline]
5356    fn from(v: UnixSocketAddressType) -> Self {
5357        ToValue::to_value(&v)
5358    }
5359}
5360
5361/// Used to select the type of data format to use for #GZlibDecompressor
5362/// and #GZlibCompressor.
5363#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5364#[non_exhaustive]
5365#[doc(alias = "GZlibCompressorFormat")]
5366pub enum ZlibCompressorFormat {
5367    /// deflate compression with zlib header
5368    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_ZLIB")]
5369    Zlib,
5370    /// gzip file format
5371    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_GZIP")]
5372    Gzip,
5373    /// deflate compression with no header
5374    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_RAW")]
5375    Raw,
5376    #[doc(hidden)]
5377    __Unknown(i32),
5378}
5379
5380#[doc(hidden)]
5381impl IntoGlib for ZlibCompressorFormat {
5382    type GlibType = ffi::GZlibCompressorFormat;
5383
5384    #[inline]
5385    fn into_glib(self) -> ffi::GZlibCompressorFormat {
5386        match self {
5387            Self::Zlib => ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB,
5388            Self::Gzip => ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP,
5389            Self::Raw => ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW,
5390            Self::__Unknown(value) => value,
5391        }
5392    }
5393}
5394
5395#[doc(hidden)]
5396impl FromGlib<ffi::GZlibCompressorFormat> for ZlibCompressorFormat {
5397    #[inline]
5398    unsafe fn from_glib(value: ffi::GZlibCompressorFormat) -> Self {
5399        match value {
5400            ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB => Self::Zlib,
5401            ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP => Self::Gzip,
5402            ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW => Self::Raw,
5403            value => Self::__Unknown(value),
5404        }
5405    }
5406}
5407
5408impl StaticType for ZlibCompressorFormat {
5409    #[inline]
5410    #[doc(alias = "g_zlib_compressor_format_get_type")]
5411    fn static_type() -> glib::Type {
5412        unsafe { from_glib(ffi::g_zlib_compressor_format_get_type()) }
5413    }
5414}
5415
5416impl glib::HasParamSpec for ZlibCompressorFormat {
5417    type ParamSpec = glib::ParamSpecEnum;
5418    type SetValue = Self;
5419    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5420
5421    fn param_spec_builder() -> Self::BuilderFn {
5422        Self::ParamSpec::builder_with_default
5423    }
5424}
5425
5426impl glib::value::ValueType for ZlibCompressorFormat {
5427    type Type = Self;
5428}
5429
5430unsafe impl<'a> glib::value::FromValue<'a> for ZlibCompressorFormat {
5431    type Checker = glib::value::GenericValueTypeChecker<Self>;
5432
5433    #[inline]
5434    unsafe fn from_value(value: &'a glib::Value) -> Self {
5435        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
5436    }
5437}
5438
5439impl ToValue for ZlibCompressorFormat {
5440    #[inline]
5441    fn to_value(&self) -> glib::Value {
5442        let mut value = glib::Value::for_value_type::<Self>();
5443        unsafe {
5444            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5445        }
5446        value
5447    }
5448
5449    #[inline]
5450    fn value_type(&self) -> glib::Type {
5451        Self::static_type()
5452    }
5453}
5454
5455impl From<ZlibCompressorFormat> for glib::Value {
5456    #[inline]
5457    fn from(v: ZlibCompressorFormat) -> Self {
5458        ToValue::to_value(&v)
5459    }
5460}
gio/auto/enums.rs

gio/auto/
enums.rs
