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        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        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        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, quark_volatile: usize, entries: /*Ignored*/&[DBusErrorEntry]) {
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(error: &mut glib::Error, dbus_error_name: &str, dbus_error_message: &str, format: Option<&str>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
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(error: &mut glib::Error, dbus_error_name: &str, dbus_error_message: &str, format: Option<&str>, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
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        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        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        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        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        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        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        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/// GEmblemOrigin is used to add information about the origin of the emblem
1437/// to #GEmblem.
1438#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1439#[non_exhaustive]
1440#[doc(alias = "GEmblemOrigin")]
1441pub enum EmblemOrigin {
1442    /// Emblem of unknown origin
1443    #[doc(alias = "G_EMBLEM_ORIGIN_UNKNOWN")]
1444    Unknown,
1445    /// Emblem adds device-specific information
1446    #[doc(alias = "G_EMBLEM_ORIGIN_DEVICE")]
1447    Device,
1448    /// Emblem depicts live metadata, such as "readonly"
1449    #[doc(alias = "G_EMBLEM_ORIGIN_LIVEMETADATA")]
1450    Livemetadata,
1451    /// Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
1452    #[doc(alias = "G_EMBLEM_ORIGIN_TAG")]
1453    Tag,
1454    #[doc(hidden)]
1455    __Unknown(i32),
1456}
1457
1458#[doc(hidden)]
1459impl IntoGlib for EmblemOrigin {
1460    type GlibType = ffi::GEmblemOrigin;
1461
1462    #[inline]
1463    fn into_glib(self) -> ffi::GEmblemOrigin {
1464        match self {
1465            Self::Unknown => ffi::G_EMBLEM_ORIGIN_UNKNOWN,
1466            Self::Device => ffi::G_EMBLEM_ORIGIN_DEVICE,
1467            Self::Livemetadata => ffi::G_EMBLEM_ORIGIN_LIVEMETADATA,
1468            Self::Tag => ffi::G_EMBLEM_ORIGIN_TAG,
1469            Self::__Unknown(value) => value,
1470        }
1471    }
1472}
1473
1474#[doc(hidden)]
1475impl FromGlib<ffi::GEmblemOrigin> for EmblemOrigin {
1476    #[inline]
1477    unsafe fn from_glib(value: ffi::GEmblemOrigin) -> Self {
1478        match value {
1479            ffi::G_EMBLEM_ORIGIN_UNKNOWN => Self::Unknown,
1480            ffi::G_EMBLEM_ORIGIN_DEVICE => Self::Device,
1481            ffi::G_EMBLEM_ORIGIN_LIVEMETADATA => Self::Livemetadata,
1482            ffi::G_EMBLEM_ORIGIN_TAG => Self::Tag,
1483            value => Self::__Unknown(value),
1484        }
1485    }
1486}
1487
1488impl StaticType for EmblemOrigin {
1489    #[inline]
1490    #[doc(alias = "g_emblem_origin_get_type")]
1491    fn static_type() -> glib::Type {
1492        unsafe { from_glib(ffi::g_emblem_origin_get_type()) }
1493    }
1494}
1495
1496impl glib::HasParamSpec for EmblemOrigin {
1497    type ParamSpec = glib::ParamSpecEnum;
1498    type SetValue = Self;
1499    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1500
1501    fn param_spec_builder() -> Self::BuilderFn {
1502        Self::ParamSpec::builder_with_default
1503    }
1504}
1505
1506impl glib::value::ValueType for EmblemOrigin {
1507    type Type = Self;
1508}
1509
1510unsafe impl<'a> glib::value::FromValue<'a> for EmblemOrigin {
1511    type Checker = glib::value::GenericValueTypeChecker<Self>;
1512
1513    #[inline]
1514    unsafe fn from_value(value: &'a glib::Value) -> Self {
1515        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1516    }
1517}
1518
1519impl ToValue for EmblemOrigin {
1520    #[inline]
1521    fn to_value(&self) -> glib::Value {
1522        let mut value = glib::Value::for_value_type::<Self>();
1523        unsafe {
1524            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1525        }
1526        value
1527    }
1528
1529    #[inline]
1530    fn value_type(&self) -> glib::Type {
1531        Self::static_type()
1532    }
1533}
1534
1535impl From<EmblemOrigin> for glib::Value {
1536    #[inline]
1537    fn from(v: EmblemOrigin) -> Self {
1538        ToValue::to_value(&v)
1539    }
1540}
1541
1542/// Used by g_file_set_attributes_from_info() when setting file attributes.
1543#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1544#[non_exhaustive]
1545#[doc(alias = "GFileAttributeStatus")]
1546pub enum FileAttributeStatus {
1547    /// Attribute value is unset (empty).
1548    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_UNSET")]
1549    Unset,
1550    /// Attribute value is set.
1551    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_SET")]
1552    Set,
1553    /// Indicates an error in setting the value.
1554    #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING")]
1555    ErrorSetting,
1556    #[doc(hidden)]
1557    __Unknown(i32),
1558}
1559
1560#[doc(hidden)]
1561impl IntoGlib for FileAttributeStatus {
1562    type GlibType = ffi::GFileAttributeStatus;
1563
1564    #[inline]
1565    fn into_glib(self) -> ffi::GFileAttributeStatus {
1566        match self {
1567            Self::Unset => ffi::G_FILE_ATTRIBUTE_STATUS_UNSET,
1568            Self::Set => ffi::G_FILE_ATTRIBUTE_STATUS_SET,
1569            Self::ErrorSetting => ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING,
1570            Self::__Unknown(value) => value,
1571        }
1572    }
1573}
1574
1575#[doc(hidden)]
1576impl FromGlib<ffi::GFileAttributeStatus> for FileAttributeStatus {
1577    #[inline]
1578    unsafe fn from_glib(value: ffi::GFileAttributeStatus) -> Self {
1579        match value {
1580            ffi::G_FILE_ATTRIBUTE_STATUS_UNSET => Self::Unset,
1581            ffi::G_FILE_ATTRIBUTE_STATUS_SET => Self::Set,
1582            ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING => Self::ErrorSetting,
1583            value => Self::__Unknown(value),
1584        }
1585    }
1586}
1587
1588impl StaticType for FileAttributeStatus {
1589    #[inline]
1590    #[doc(alias = "g_file_attribute_status_get_type")]
1591    fn static_type() -> glib::Type {
1592        unsafe { from_glib(ffi::g_file_attribute_status_get_type()) }
1593    }
1594}
1595
1596impl glib::HasParamSpec for FileAttributeStatus {
1597    type ParamSpec = glib::ParamSpecEnum;
1598    type SetValue = Self;
1599    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1600
1601    fn param_spec_builder() -> Self::BuilderFn {
1602        Self::ParamSpec::builder_with_default
1603    }
1604}
1605
1606impl glib::value::ValueType for FileAttributeStatus {
1607    type Type = Self;
1608}
1609
1610unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeStatus {
1611    type Checker = glib::value::GenericValueTypeChecker<Self>;
1612
1613    #[inline]
1614    unsafe fn from_value(value: &'a glib::Value) -> Self {
1615        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1616    }
1617}
1618
1619impl ToValue for FileAttributeStatus {
1620    #[inline]
1621    fn to_value(&self) -> glib::Value {
1622        let mut value = glib::Value::for_value_type::<Self>();
1623        unsafe {
1624            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1625        }
1626        value
1627    }
1628
1629    #[inline]
1630    fn value_type(&self) -> glib::Type {
1631        Self::static_type()
1632    }
1633}
1634
1635impl From<FileAttributeStatus> for glib::Value {
1636    #[inline]
1637    fn from(v: FileAttributeStatus) -> Self {
1638        ToValue::to_value(&v)
1639    }
1640}
1641
1642/// The data types for file attributes.
1643#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1644#[non_exhaustive]
1645#[doc(alias = "GFileAttributeType")]
1646pub enum FileAttributeType {
1647    /// indicates an invalid or uninitialized type.
1648    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INVALID")]
1649    Invalid,
1650    /// a null terminated UTF8 string.
1651    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRING")]
1652    String,
1653    /// a zero terminated string of non-zero bytes.
1654    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BYTE_STRING")]
1655    ByteString,
1656    /// a boolean value.
1657    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BOOLEAN")]
1658    Boolean,
1659    /// an unsigned 4-byte/32-bit integer.
1660    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT32")]
1661    Uint32,
1662    /// a signed 4-byte/32-bit integer.
1663    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT32")]
1664    Int32,
1665    /// an unsigned 8-byte/64-bit integer.
1666    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT64")]
1667    Uint64,
1668    /// a signed 8-byte/64-bit integer.
1669    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT64")]
1670    Int64,
1671    /// a #GObject.
1672    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_OBJECT")]
1673    Object,
1674    /// a [`None`] terminated char **. Since 2.22
1675    #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRINGV")]
1676    Stringv,
1677    #[doc(hidden)]
1678    __Unknown(i32),
1679}
1680
1681#[doc(hidden)]
1682impl IntoGlib for FileAttributeType {
1683    type GlibType = ffi::GFileAttributeType;
1684
1685    #[inline]
1686    fn into_glib(self) -> ffi::GFileAttributeType {
1687        match self {
1688            Self::Invalid => ffi::G_FILE_ATTRIBUTE_TYPE_INVALID,
1689            Self::String => ffi::G_FILE_ATTRIBUTE_TYPE_STRING,
1690            Self::ByteString => ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING,
1691            Self::Boolean => ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN,
1692            Self::Uint32 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT32,
1693            Self::Int32 => ffi::G_FILE_ATTRIBUTE_TYPE_INT32,
1694            Self::Uint64 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT64,
1695            Self::Int64 => ffi::G_FILE_ATTRIBUTE_TYPE_INT64,
1696            Self::Object => ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT,
1697            Self::Stringv => ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV,
1698            Self::__Unknown(value) => value,
1699        }
1700    }
1701}
1702
1703#[doc(hidden)]
1704impl FromGlib<ffi::GFileAttributeType> for FileAttributeType {
1705    #[inline]
1706    unsafe fn from_glib(value: ffi::GFileAttributeType) -> Self {
1707        match value {
1708            ffi::G_FILE_ATTRIBUTE_TYPE_INVALID => Self::Invalid,
1709            ffi::G_FILE_ATTRIBUTE_TYPE_STRING => Self::String,
1710            ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING => Self::ByteString,
1711            ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN => Self::Boolean,
1712            ffi::G_FILE_ATTRIBUTE_TYPE_UINT32 => Self::Uint32,
1713            ffi::G_FILE_ATTRIBUTE_TYPE_INT32 => Self::Int32,
1714            ffi::G_FILE_ATTRIBUTE_TYPE_UINT64 => Self::Uint64,
1715            ffi::G_FILE_ATTRIBUTE_TYPE_INT64 => Self::Int64,
1716            ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT => Self::Object,
1717            ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV => Self::Stringv,
1718            value => Self::__Unknown(value),
1719        }
1720    }
1721}
1722
1723impl StaticType for FileAttributeType {
1724    #[inline]
1725    #[doc(alias = "g_file_attribute_type_get_type")]
1726    fn static_type() -> glib::Type {
1727        unsafe { from_glib(ffi::g_file_attribute_type_get_type()) }
1728    }
1729}
1730
1731impl glib::HasParamSpec for FileAttributeType {
1732    type ParamSpec = glib::ParamSpecEnum;
1733    type SetValue = Self;
1734    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1735
1736    fn param_spec_builder() -> Self::BuilderFn {
1737        Self::ParamSpec::builder_with_default
1738    }
1739}
1740
1741impl glib::value::ValueType for FileAttributeType {
1742    type Type = Self;
1743}
1744
1745unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeType {
1746    type Checker = glib::value::GenericValueTypeChecker<Self>;
1747
1748    #[inline]
1749    unsafe fn from_value(value: &'a glib::Value) -> Self {
1750        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1751    }
1752}
1753
1754impl ToValue for FileAttributeType {
1755    #[inline]
1756    fn to_value(&self) -> glib::Value {
1757        let mut value = glib::Value::for_value_type::<Self>();
1758        unsafe {
1759            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1760        }
1761        value
1762    }
1763
1764    #[inline]
1765    fn value_type(&self) -> glib::Type {
1766        Self::static_type()
1767    }
1768}
1769
1770impl From<FileAttributeType> for glib::Value {
1771    #[inline]
1772    fn from(v: FileAttributeType) -> Self {
1773        ToValue::to_value(&v)
1774    }
1775}
1776
1777/// Specifies what type of event a monitor event is.
1778#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1779#[non_exhaustive]
1780#[doc(alias = "GFileMonitorEvent")]
1781pub enum FileMonitorEvent {
1782    /// a file changed.
1783    #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGED")]
1784    Changed,
1785    /// a hint that this was probably the last change in a set of changes.
1786    #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT")]
1787    ChangesDoneHint,
1788    /// a file was deleted.
1789    #[doc(alias = "G_FILE_MONITOR_EVENT_DELETED")]
1790    Deleted,
1791    /// a file was created.
1792    #[doc(alias = "G_FILE_MONITOR_EVENT_CREATED")]
1793    Created,
1794    /// a file attribute was changed.
1795    #[doc(alias = "G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED")]
1796    AttributeChanged,
1797    /// the file location will soon be unmounted.
1798    #[doc(alias = "G_FILE_MONITOR_EVENT_PRE_UNMOUNT")]
1799    PreUnmount,
1800    /// the file location was unmounted.
1801    #[doc(alias = "G_FILE_MONITOR_EVENT_UNMOUNTED")]
1802    Unmounted,
1803    /// the file was moved -- only sent if the
1804    ///   (deprecated) [`FileMonitorFlags::SEND_MOVED`][crate::FileMonitorFlags::SEND_MOVED] flag is set
1805    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED")]
1806    Moved,
1807    /// the file was renamed within the
1808    ///   current directory -- only sent if the [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES]
1809    ///   flag is set.  Since: 2.46.
1810    #[doc(alias = "G_FILE_MONITOR_EVENT_RENAMED")]
1811    Renamed,
1812    /// the file was moved into the
1813    ///   monitored directory from another location -- only sent if the
1814    ///   [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES] flag is set.  Since: 2.46.
1815    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_IN")]
1816    MovedIn,
1817    /// the file was moved out of the
1818    ///   monitored directory to another location -- only sent if the
1819    ///   [`FileMonitorFlags::WATCH_MOVES`][crate::FileMonitorFlags::WATCH_MOVES] flag is set.  Since: 2.46
1820    #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_OUT")]
1821    MovedOut,
1822    #[doc(hidden)]
1823    __Unknown(i32),
1824}
1825
1826#[doc(hidden)]
1827impl IntoGlib for FileMonitorEvent {
1828    type GlibType = ffi::GFileMonitorEvent;
1829
1830    #[inline]
1831    fn into_glib(self) -> ffi::GFileMonitorEvent {
1832        match self {
1833            Self::Changed => ffi::G_FILE_MONITOR_EVENT_CHANGED,
1834            Self::ChangesDoneHint => ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
1835            Self::Deleted => ffi::G_FILE_MONITOR_EVENT_DELETED,
1836            Self::Created => ffi::G_FILE_MONITOR_EVENT_CREATED,
1837            Self::AttributeChanged => ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED,
1838            Self::PreUnmount => ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT,
1839            Self::Unmounted => ffi::G_FILE_MONITOR_EVENT_UNMOUNTED,
1840            Self::Moved => ffi::G_FILE_MONITOR_EVENT_MOVED,
1841            Self::Renamed => ffi::G_FILE_MONITOR_EVENT_RENAMED,
1842            Self::MovedIn => ffi::G_FILE_MONITOR_EVENT_MOVED_IN,
1843            Self::MovedOut => ffi::G_FILE_MONITOR_EVENT_MOVED_OUT,
1844            Self::__Unknown(value) => value,
1845        }
1846    }
1847}
1848
1849#[doc(hidden)]
1850impl FromGlib<ffi::GFileMonitorEvent> for FileMonitorEvent {
1851    #[inline]
1852    unsafe fn from_glib(value: ffi::GFileMonitorEvent) -> Self {
1853        match value {
1854            ffi::G_FILE_MONITOR_EVENT_CHANGED => Self::Changed,
1855            ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT => Self::ChangesDoneHint,
1856            ffi::G_FILE_MONITOR_EVENT_DELETED => Self::Deleted,
1857            ffi::G_FILE_MONITOR_EVENT_CREATED => Self::Created,
1858            ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED => Self::AttributeChanged,
1859            ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT => Self::PreUnmount,
1860            ffi::G_FILE_MONITOR_EVENT_UNMOUNTED => Self::Unmounted,
1861            ffi::G_FILE_MONITOR_EVENT_MOVED => Self::Moved,
1862            ffi::G_FILE_MONITOR_EVENT_RENAMED => Self::Renamed,
1863            ffi::G_FILE_MONITOR_EVENT_MOVED_IN => Self::MovedIn,
1864            ffi::G_FILE_MONITOR_EVENT_MOVED_OUT => Self::MovedOut,
1865            value => Self::__Unknown(value),
1866        }
1867    }
1868}
1869
1870impl StaticType for FileMonitorEvent {
1871    #[inline]
1872    #[doc(alias = "g_file_monitor_event_get_type")]
1873    fn static_type() -> glib::Type {
1874        unsafe { from_glib(ffi::g_file_monitor_event_get_type()) }
1875    }
1876}
1877
1878impl glib::HasParamSpec for FileMonitorEvent {
1879    type ParamSpec = glib::ParamSpecEnum;
1880    type SetValue = Self;
1881    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1882
1883    fn param_spec_builder() -> Self::BuilderFn {
1884        Self::ParamSpec::builder_with_default
1885    }
1886}
1887
1888impl glib::value::ValueType for FileMonitorEvent {
1889    type Type = Self;
1890}
1891
1892unsafe impl<'a> glib::value::FromValue<'a> for FileMonitorEvent {
1893    type Checker = glib::value::GenericValueTypeChecker<Self>;
1894
1895    #[inline]
1896    unsafe fn from_value(value: &'a glib::Value) -> Self {
1897        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1898    }
1899}
1900
1901impl ToValue for FileMonitorEvent {
1902    #[inline]
1903    fn to_value(&self) -> glib::Value {
1904        let mut value = glib::Value::for_value_type::<Self>();
1905        unsafe {
1906            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1907        }
1908        value
1909    }
1910
1911    #[inline]
1912    fn value_type(&self) -> glib::Type {
1913        Self::static_type()
1914    }
1915}
1916
1917impl From<FileMonitorEvent> for glib::Value {
1918    #[inline]
1919    fn from(v: FileMonitorEvent) -> Self {
1920        ToValue::to_value(&v)
1921    }
1922}
1923
1924/// Indicates the file's on-disk type.
1925///
1926/// On Windows systems a file will never have [`SymbolicLink`][Self::SymbolicLink] type;
1927/// use #GFileInfo and [`FILE_ATTRIBUTE_STANDARD_IS_SYMLINK`][crate::FILE_ATTRIBUTE_STANDARD_IS_SYMLINK] to determine
1928/// whether a file is a symlink or not. This is due to the fact that NTFS does
1929/// not have a single filesystem object type for symbolic links - it has
1930/// files that symlink to files, and directories that symlink to directories.
1931/// #GFileType enumeration cannot precisely represent this important distinction,
1932/// which is why all Windows symlinks will continue to be reported as
1933/// [`Regular`][Self::Regular] or [`Directory`][Self::Directory].
1934#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1935#[non_exhaustive]
1936#[doc(alias = "GFileType")]
1937pub enum FileType {
1938    /// File's type is unknown.
1939    #[doc(alias = "G_FILE_TYPE_UNKNOWN")]
1940    Unknown,
1941    /// File handle represents a regular file.
1942    #[doc(alias = "G_FILE_TYPE_REGULAR")]
1943    Regular,
1944    /// File handle represents a directory.
1945    #[doc(alias = "G_FILE_TYPE_DIRECTORY")]
1946    Directory,
1947    /// File handle represents a symbolic link
1948    ///    (Unix systems).
1949    #[doc(alias = "G_FILE_TYPE_SYMBOLIC_LINK")]
1950    SymbolicLink,
1951    /// File is a "special" file, such as a socket, fifo,
1952    ///    block device, or character device.
1953    #[doc(alias = "G_FILE_TYPE_SPECIAL")]
1954    Special,
1955    /// File is a shortcut (Windows systems).
1956    #[doc(alias = "G_FILE_TYPE_SHORTCUT")]
1957    Shortcut,
1958    /// File is a mountable location.
1959    #[doc(alias = "G_FILE_TYPE_MOUNTABLE")]
1960    Mountable,
1961    #[doc(hidden)]
1962    __Unknown(i32),
1963}
1964
1965#[doc(hidden)]
1966impl IntoGlib for FileType {
1967    type GlibType = ffi::GFileType;
1968
1969    #[inline]
1970    fn into_glib(self) -> ffi::GFileType {
1971        match self {
1972            Self::Unknown => ffi::G_FILE_TYPE_UNKNOWN,
1973            Self::Regular => ffi::G_FILE_TYPE_REGULAR,
1974            Self::Directory => ffi::G_FILE_TYPE_DIRECTORY,
1975            Self::SymbolicLink => ffi::G_FILE_TYPE_SYMBOLIC_LINK,
1976            Self::Special => ffi::G_FILE_TYPE_SPECIAL,
1977            Self::Shortcut => ffi::G_FILE_TYPE_SHORTCUT,
1978            Self::Mountable => ffi::G_FILE_TYPE_MOUNTABLE,
1979            Self::__Unknown(value) => value,
1980        }
1981    }
1982}
1983
1984#[doc(hidden)]
1985impl FromGlib<ffi::GFileType> for FileType {
1986    #[inline]
1987    unsafe fn from_glib(value: ffi::GFileType) -> Self {
1988        match value {
1989            ffi::G_FILE_TYPE_UNKNOWN => Self::Unknown,
1990            ffi::G_FILE_TYPE_REGULAR => Self::Regular,
1991            ffi::G_FILE_TYPE_DIRECTORY => Self::Directory,
1992            ffi::G_FILE_TYPE_SYMBOLIC_LINK => Self::SymbolicLink,
1993            ffi::G_FILE_TYPE_SPECIAL => Self::Special,
1994            ffi::G_FILE_TYPE_SHORTCUT => Self::Shortcut,
1995            ffi::G_FILE_TYPE_MOUNTABLE => Self::Mountable,
1996            value => Self::__Unknown(value),
1997        }
1998    }
1999}
2000
2001impl StaticType for FileType {
2002    #[inline]
2003    #[doc(alias = "g_file_type_get_type")]
2004    fn static_type() -> glib::Type {
2005        unsafe { from_glib(ffi::g_file_type_get_type()) }
2006    }
2007}
2008
2009impl glib::HasParamSpec for FileType {
2010    type ParamSpec = glib::ParamSpecEnum;
2011    type SetValue = Self;
2012    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2013
2014    fn param_spec_builder() -> Self::BuilderFn {
2015        Self::ParamSpec::builder_with_default
2016    }
2017}
2018
2019impl glib::value::ValueType for FileType {
2020    type Type = Self;
2021}
2022
2023unsafe impl<'a> glib::value::FromValue<'a> for FileType {
2024    type Checker = glib::value::GenericValueTypeChecker<Self>;
2025
2026    #[inline]
2027    unsafe fn from_value(value: &'a glib::Value) -> Self {
2028        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2029    }
2030}
2031
2032impl ToValue for FileType {
2033    #[inline]
2034    fn to_value(&self) -> glib::Value {
2035        let mut value = glib::Value::for_value_type::<Self>();
2036        unsafe {
2037            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2038        }
2039        value
2040    }
2041
2042    #[inline]
2043    fn value_type(&self) -> glib::Type {
2044        Self::static_type()
2045    }
2046}
2047
2048impl From<FileType> for glib::Value {
2049    #[inline]
2050    fn from(v: FileType) -> Self {
2051        ToValue::to_value(&v)
2052    }
2053}
2054
2055/// Indicates a hint from the file system whether files should be
2056/// previewed in a file manager. Returned as the value of the key
2057/// [`FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW`][crate::FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW].
2058#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2059#[non_exhaustive]
2060#[doc(alias = "GFilesystemPreviewType")]
2061pub enum FilesystemPreviewType {
2062    /// Only preview files if user has explicitly requested it.
2063    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS")]
2064    IfAlways,
2065    /// Preview files if user has requested preview of "local" files.
2066    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL")]
2067    IfLocal,
2068    /// Never preview files.
2069    #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_NEVER")]
2070    Never,
2071    #[doc(hidden)]
2072    __Unknown(i32),
2073}
2074
2075#[doc(hidden)]
2076impl IntoGlib for FilesystemPreviewType {
2077    type GlibType = ffi::GFilesystemPreviewType;
2078
2079    #[inline]
2080    fn into_glib(self) -> ffi::GFilesystemPreviewType {
2081        match self {
2082            Self::IfAlways => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS,
2083            Self::IfLocal => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL,
2084            Self::Never => ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER,
2085            Self::__Unknown(value) => value,
2086        }
2087    }
2088}
2089
2090#[doc(hidden)]
2091impl FromGlib<ffi::GFilesystemPreviewType> for FilesystemPreviewType {
2092    #[inline]
2093    unsafe fn from_glib(value: ffi::GFilesystemPreviewType) -> Self {
2094        match value {
2095            ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS => Self::IfAlways,
2096            ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL => Self::IfLocal,
2097            ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER => Self::Never,
2098            value => Self::__Unknown(value),
2099        }
2100    }
2101}
2102
2103impl StaticType for FilesystemPreviewType {
2104    #[inline]
2105    #[doc(alias = "g_filesystem_preview_type_get_type")]
2106    fn static_type() -> glib::Type {
2107        unsafe { from_glib(ffi::g_filesystem_preview_type_get_type()) }
2108    }
2109}
2110
2111impl glib::HasParamSpec for FilesystemPreviewType {
2112    type ParamSpec = glib::ParamSpecEnum;
2113    type SetValue = Self;
2114    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2115
2116    fn param_spec_builder() -> Self::BuilderFn {
2117        Self::ParamSpec::builder_with_default
2118    }
2119}
2120
2121impl glib::value::ValueType for FilesystemPreviewType {
2122    type Type = Self;
2123}
2124
2125unsafe impl<'a> glib::value::FromValue<'a> for FilesystemPreviewType {
2126    type Checker = glib::value::GenericValueTypeChecker<Self>;
2127
2128    #[inline]
2129    unsafe fn from_value(value: &'a glib::Value) -> Self {
2130        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2131    }
2132}
2133
2134impl ToValue for FilesystemPreviewType {
2135    #[inline]
2136    fn to_value(&self) -> glib::Value {
2137        let mut value = glib::Value::for_value_type::<Self>();
2138        unsafe {
2139            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2140        }
2141        value
2142    }
2143
2144    #[inline]
2145    fn value_type(&self) -> glib::Type {
2146        Self::static_type()
2147    }
2148}
2149
2150impl From<FilesystemPreviewType> for glib::Value {
2151    #[inline]
2152    fn from(v: FilesystemPreviewType) -> Self {
2153        ToValue::to_value(&v)
2154    }
2155}
2156
2157/// Error codes returned by GIO functions.
2158///
2159/// Note that this domain may be extended in future GLib releases. In
2160/// general, new error codes either only apply to new APIs, or else
2161/// replace [`Failed`][Self::Failed] in cases that were not explicitly
2162/// distinguished before. You should therefore avoid writing code like
2163///
2164///
2165/// **⚠️ The following code is in C ⚠️**
2166///
2167/// ```C
2168/// if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
2169///   {
2170///     // Assume that this is EPRINTERONFIRE
2171///     ...
2172///   }
2173/// ```
2174/// but should instead treat all unrecognized error codes the same as
2175/// [`Failed`][Self::Failed].
2176///
2177/// See also #GPollableReturn for a cheaper way of returning
2178/// [`WouldBlock`][Self::WouldBlock] to callers without allocating a #GError.
2179#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2180#[non_exhaustive]
2181#[doc(alias = "GIOErrorEnum")]
2182pub enum IOErrorEnum {
2183    /// Generic error condition for when an operation fails
2184    ///     and no more specific #GIOErrorEnum value is defined.
2185    #[doc(alias = "G_IO_ERROR_FAILED")]
2186    Failed,
2187    /// File not found.
2188    #[doc(alias = "G_IO_ERROR_NOT_FOUND")]
2189    NotFound,
2190    /// File already exists.
2191    #[doc(alias = "G_IO_ERROR_EXISTS")]
2192    Exists,
2193    /// File is a directory.
2194    #[doc(alias = "G_IO_ERROR_IS_DIRECTORY")]
2195    IsDirectory,
2196    /// File is not a directory.
2197    #[doc(alias = "G_IO_ERROR_NOT_DIRECTORY")]
2198    NotDirectory,
2199    /// File is a directory that isn't empty.
2200    #[doc(alias = "G_IO_ERROR_NOT_EMPTY")]
2201    NotEmpty,
2202    /// File is not a regular file.
2203    #[doc(alias = "G_IO_ERROR_NOT_REGULAR_FILE")]
2204    NotRegularFile,
2205    /// File is not a symbolic link.
2206    #[doc(alias = "G_IO_ERROR_NOT_SYMBOLIC_LINK")]
2207    NotSymbolicLink,
2208    /// File cannot be mounted.
2209    #[doc(alias = "G_IO_ERROR_NOT_MOUNTABLE_FILE")]
2210    NotMountableFile,
2211    /// Filename is too many characters.
2212    #[doc(alias = "G_IO_ERROR_FILENAME_TOO_LONG")]
2213    FilenameTooLong,
2214    /// Filename is invalid or contains invalid characters.
2215    #[doc(alias = "G_IO_ERROR_INVALID_FILENAME")]
2216    InvalidFilename,
2217    /// File contains too many symbolic links.
2218    #[doc(alias = "G_IO_ERROR_TOO_MANY_LINKS")]
2219    TooManyLinks,
2220    /// No space left on drive.
2221    #[doc(alias = "G_IO_ERROR_NO_SPACE")]
2222    NoSpace,
2223    /// Invalid argument.
2224    #[doc(alias = "G_IO_ERROR_INVALID_ARGUMENT")]
2225    InvalidArgument,
2226    /// Permission denied.
2227    #[doc(alias = "G_IO_ERROR_PERMISSION_DENIED")]
2228    PermissionDenied,
2229    /// Operation (or one of its parameters) not supported
2230    #[doc(alias = "G_IO_ERROR_NOT_SUPPORTED")]
2231    NotSupported,
2232    /// File isn't mounted.
2233    #[doc(alias = "G_IO_ERROR_NOT_MOUNTED")]
2234    NotMounted,
2235    /// File is already mounted.
2236    #[doc(alias = "G_IO_ERROR_ALREADY_MOUNTED")]
2237    AlreadyMounted,
2238    /// File was closed.
2239    #[doc(alias = "G_IO_ERROR_CLOSED")]
2240    Closed,
2241    /// Operation was cancelled. See #GCancellable.
2242    #[doc(alias = "G_IO_ERROR_CANCELLED")]
2243    Cancelled,
2244    /// Operations are still pending.
2245    #[doc(alias = "G_IO_ERROR_PENDING")]
2246    Pending,
2247    /// File is read only.
2248    #[doc(alias = "G_IO_ERROR_READ_ONLY")]
2249    ReadOnly,
2250    /// Backup couldn't be created.
2251    #[doc(alias = "G_IO_ERROR_CANT_CREATE_BACKUP")]
2252    CantCreateBackup,
2253    /// File's Entity Tag was incorrect.
2254    #[doc(alias = "G_IO_ERROR_WRONG_ETAG")]
2255    WrongEtag,
2256    /// Operation timed out.
2257    #[doc(alias = "G_IO_ERROR_TIMED_OUT")]
2258    TimedOut,
2259    /// Operation would be recursive.
2260    #[doc(alias = "G_IO_ERROR_WOULD_RECURSE")]
2261    WouldRecurse,
2262    /// File is busy.
2263    #[doc(alias = "G_IO_ERROR_BUSY")]
2264    Busy,
2265    /// Operation would block.
2266    #[doc(alias = "G_IO_ERROR_WOULD_BLOCK")]
2267    WouldBlock,
2268    /// Host couldn't be found (remote operations).
2269    #[doc(alias = "G_IO_ERROR_HOST_NOT_FOUND")]
2270    HostNotFound,
2271    /// Operation would merge files.
2272    #[doc(alias = "G_IO_ERROR_WOULD_MERGE")]
2273    WouldMerge,
2274    /// Operation failed and a helper program has
2275    ///     already interacted with the user. Do not display any error dialog.
2276    #[doc(alias = "G_IO_ERROR_FAILED_HANDLED")]
2277    FailedHandled,
2278    /// The current process has too many files
2279    ///     open and can't open any more. Duplicate descriptors do count toward
2280    ///     this limit. Since 2.20
2281    #[doc(alias = "G_IO_ERROR_TOO_MANY_OPEN_FILES")]
2282    TooManyOpenFiles,
2283    /// The object has not been initialized. Since 2.22
2284    #[doc(alias = "G_IO_ERROR_NOT_INITIALIZED")]
2285    NotInitialized,
2286    /// The requested address is already in use. Since 2.22
2287    #[doc(alias = "G_IO_ERROR_ADDRESS_IN_USE")]
2288    AddressInUse,
2289    /// Need more input to finish operation. Since 2.24
2290    #[doc(alias = "G_IO_ERROR_PARTIAL_INPUT")]
2291    PartialInput,
2292    /// The input data was invalid. Since 2.24
2293    #[doc(alias = "G_IO_ERROR_INVALID_DATA")]
2294    InvalidData,
2295    /// A remote object generated an error that
2296    ///     doesn't correspond to a locally registered #GError error
2297    ///     domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
2298    ///     error name and g_dbus_error_strip_remote_error() to fix up the
2299    ///     message so it matches what was received on the wire. Since 2.26.
2300    #[doc(alias = "G_IO_ERROR_DBUS_ERROR")]
2301    DbusError,
2302    /// Host unreachable. Since 2.26
2303    #[doc(alias = "G_IO_ERROR_HOST_UNREACHABLE")]
2304    HostUnreachable,
2305    /// Network unreachable. Since 2.26
2306    #[doc(alias = "G_IO_ERROR_NETWORK_UNREACHABLE")]
2307    NetworkUnreachable,
2308    /// Connection refused. Since 2.26
2309    #[doc(alias = "G_IO_ERROR_CONNECTION_REFUSED")]
2310    ConnectionRefused,
2311    /// Connection to proxy server failed. Since 2.26
2312    #[doc(alias = "G_IO_ERROR_PROXY_FAILED")]
2313    ProxyFailed,
2314    /// Proxy authentication failed. Since 2.26
2315    #[doc(alias = "G_IO_ERROR_PROXY_AUTH_FAILED")]
2316    ProxyAuthFailed,
2317    /// Proxy server needs authentication. Since 2.26
2318    #[doc(alias = "G_IO_ERROR_PROXY_NEED_AUTH")]
2319    ProxyNeedAuth,
2320    /// Proxy connection is not allowed by ruleset.
2321    ///     Since 2.26
2322    #[doc(alias = "G_IO_ERROR_PROXY_NOT_ALLOWED")]
2323    ProxyNotAllowed,
2324    /// Broken pipe. Since 2.36
2325    #[doc(alias = "G_IO_ERROR_BROKEN_PIPE")]
2326    BrokenPipe,
2327    /// Transport endpoint is not connected. Since 2.44
2328    #[doc(alias = "G_IO_ERROR_NOT_CONNECTED")]
2329    NotConnected,
2330    /// Message too large. Since 2.48.
2331    #[doc(alias = "G_IO_ERROR_MESSAGE_TOO_LARGE")]
2332    MessageTooLarge,
2333    /// No such device found. Since 2.74
2334    #[cfg(feature = "v2_72")]
2335    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
2336    #[doc(alias = "G_IO_ERROR_NO_SUCH_DEVICE")]
2337    NoSuchDevice,
2338    /// Destination address unset. Since 2.80
2339    #[cfg(feature = "v2_80")]
2340    #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
2341    #[doc(alias = "G_IO_ERROR_DESTINATION_UNSET")]
2342    DestinationUnset,
2343    #[doc(hidden)]
2344    __Unknown(i32),
2345}
2346
2347#[doc(hidden)]
2348impl IntoGlib for IOErrorEnum {
2349    type GlibType = ffi::GIOErrorEnum;
2350
2351    fn into_glib(self) -> ffi::GIOErrorEnum {
2352        match self {
2353            Self::Failed => ffi::G_IO_ERROR_FAILED,
2354            Self::NotFound => ffi::G_IO_ERROR_NOT_FOUND,
2355            Self::Exists => ffi::G_IO_ERROR_EXISTS,
2356            Self::IsDirectory => ffi::G_IO_ERROR_IS_DIRECTORY,
2357            Self::NotDirectory => ffi::G_IO_ERROR_NOT_DIRECTORY,
2358            Self::NotEmpty => ffi::G_IO_ERROR_NOT_EMPTY,
2359            Self::NotRegularFile => ffi::G_IO_ERROR_NOT_REGULAR_FILE,
2360            Self::NotSymbolicLink => ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK,
2361            Self::NotMountableFile => ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE,
2362            Self::FilenameTooLong => ffi::G_IO_ERROR_FILENAME_TOO_LONG,
2363            Self::InvalidFilename => ffi::G_IO_ERROR_INVALID_FILENAME,
2364            Self::TooManyLinks => ffi::G_IO_ERROR_TOO_MANY_LINKS,
2365            Self::NoSpace => ffi::G_IO_ERROR_NO_SPACE,
2366            Self::InvalidArgument => ffi::G_IO_ERROR_INVALID_ARGUMENT,
2367            Self::PermissionDenied => ffi::G_IO_ERROR_PERMISSION_DENIED,
2368            Self::NotSupported => ffi::G_IO_ERROR_NOT_SUPPORTED,
2369            Self::NotMounted => ffi::G_IO_ERROR_NOT_MOUNTED,
2370            Self::AlreadyMounted => ffi::G_IO_ERROR_ALREADY_MOUNTED,
2371            Self::Closed => ffi::G_IO_ERROR_CLOSED,
2372            Self::Cancelled => ffi::G_IO_ERROR_CANCELLED,
2373            Self::Pending => ffi::G_IO_ERROR_PENDING,
2374            Self::ReadOnly => ffi::G_IO_ERROR_READ_ONLY,
2375            Self::CantCreateBackup => ffi::G_IO_ERROR_CANT_CREATE_BACKUP,
2376            Self::WrongEtag => ffi::G_IO_ERROR_WRONG_ETAG,
2377            Self::TimedOut => ffi::G_IO_ERROR_TIMED_OUT,
2378            Self::WouldRecurse => ffi::G_IO_ERROR_WOULD_RECURSE,
2379            Self::Busy => ffi::G_IO_ERROR_BUSY,
2380            Self::WouldBlock => ffi::G_IO_ERROR_WOULD_BLOCK,
2381            Self::HostNotFound => ffi::G_IO_ERROR_HOST_NOT_FOUND,
2382            Self::WouldMerge => ffi::G_IO_ERROR_WOULD_MERGE,
2383            Self::FailedHandled => ffi::G_IO_ERROR_FAILED_HANDLED,
2384            Self::TooManyOpenFiles => ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES,
2385            Self::NotInitialized => ffi::G_IO_ERROR_NOT_INITIALIZED,
2386            Self::AddressInUse => ffi::G_IO_ERROR_ADDRESS_IN_USE,
2387            Self::PartialInput => ffi::G_IO_ERROR_PARTIAL_INPUT,
2388            Self::InvalidData => ffi::G_IO_ERROR_INVALID_DATA,
2389            Self::DbusError => ffi::G_IO_ERROR_DBUS_ERROR,
2390            Self::HostUnreachable => ffi::G_IO_ERROR_HOST_UNREACHABLE,
2391            Self::NetworkUnreachable => ffi::G_IO_ERROR_NETWORK_UNREACHABLE,
2392            Self::ConnectionRefused => ffi::G_IO_ERROR_CONNECTION_REFUSED,
2393            Self::ProxyFailed => ffi::G_IO_ERROR_PROXY_FAILED,
2394            Self::ProxyAuthFailed => ffi::G_IO_ERROR_PROXY_AUTH_FAILED,
2395            Self::ProxyNeedAuth => ffi::G_IO_ERROR_PROXY_NEED_AUTH,
2396            Self::ProxyNotAllowed => ffi::G_IO_ERROR_PROXY_NOT_ALLOWED,
2397            Self::BrokenPipe => ffi::G_IO_ERROR_BROKEN_PIPE,
2398            Self::NotConnected => ffi::G_IO_ERROR_NOT_CONNECTED,
2399            Self::MessageTooLarge => ffi::G_IO_ERROR_MESSAGE_TOO_LARGE,
2400            #[cfg(feature = "v2_72")]
2401            Self::NoSuchDevice => ffi::G_IO_ERROR_NO_SUCH_DEVICE,
2402            #[cfg(feature = "v2_80")]
2403            Self::DestinationUnset => ffi::G_IO_ERROR_DESTINATION_UNSET,
2404            Self::__Unknown(value) => value,
2405        }
2406    }
2407}
2408
2409#[doc(hidden)]
2410impl FromGlib<ffi::GIOErrorEnum> for IOErrorEnum {
2411    unsafe fn from_glib(value: ffi::GIOErrorEnum) -> Self {
2412        match value {
2413            ffi::G_IO_ERROR_FAILED => Self::Failed,
2414            ffi::G_IO_ERROR_NOT_FOUND => Self::NotFound,
2415            ffi::G_IO_ERROR_EXISTS => Self::Exists,
2416            ffi::G_IO_ERROR_IS_DIRECTORY => Self::IsDirectory,
2417            ffi::G_IO_ERROR_NOT_DIRECTORY => Self::NotDirectory,
2418            ffi::G_IO_ERROR_NOT_EMPTY => Self::NotEmpty,
2419            ffi::G_IO_ERROR_NOT_REGULAR_FILE => Self::NotRegularFile,
2420            ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK => Self::NotSymbolicLink,
2421            ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE => Self::NotMountableFile,
2422            ffi::G_IO_ERROR_FILENAME_TOO_LONG => Self::FilenameTooLong,
2423            ffi::G_IO_ERROR_INVALID_FILENAME => Self::InvalidFilename,
2424            ffi::G_IO_ERROR_TOO_MANY_LINKS => Self::TooManyLinks,
2425            ffi::G_IO_ERROR_NO_SPACE => Self::NoSpace,
2426            ffi::G_IO_ERROR_INVALID_ARGUMENT => Self::InvalidArgument,
2427            ffi::G_IO_ERROR_PERMISSION_DENIED => Self::PermissionDenied,
2428            ffi::G_IO_ERROR_NOT_SUPPORTED => Self::NotSupported,
2429            ffi::G_IO_ERROR_NOT_MOUNTED => Self::NotMounted,
2430            ffi::G_IO_ERROR_ALREADY_MOUNTED => Self::AlreadyMounted,
2431            ffi::G_IO_ERROR_CLOSED => Self::Closed,
2432            ffi::G_IO_ERROR_CANCELLED => Self::Cancelled,
2433            ffi::G_IO_ERROR_PENDING => Self::Pending,
2434            ffi::G_IO_ERROR_READ_ONLY => Self::ReadOnly,
2435            ffi::G_IO_ERROR_CANT_CREATE_BACKUP => Self::CantCreateBackup,
2436            ffi::G_IO_ERROR_WRONG_ETAG => Self::WrongEtag,
2437            ffi::G_IO_ERROR_TIMED_OUT => Self::TimedOut,
2438            ffi::G_IO_ERROR_WOULD_RECURSE => Self::WouldRecurse,
2439            ffi::G_IO_ERROR_BUSY => Self::Busy,
2440            ffi::G_IO_ERROR_WOULD_BLOCK => Self::WouldBlock,
2441            ffi::G_IO_ERROR_HOST_NOT_FOUND => Self::HostNotFound,
2442            ffi::G_IO_ERROR_WOULD_MERGE => Self::WouldMerge,
2443            ffi::G_IO_ERROR_FAILED_HANDLED => Self::FailedHandled,
2444            ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES => Self::TooManyOpenFiles,
2445            ffi::G_IO_ERROR_NOT_INITIALIZED => Self::NotInitialized,
2446            ffi::G_IO_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
2447            ffi::G_IO_ERROR_PARTIAL_INPUT => Self::PartialInput,
2448            ffi::G_IO_ERROR_INVALID_DATA => Self::InvalidData,
2449            ffi::G_IO_ERROR_DBUS_ERROR => Self::DbusError,
2450            ffi::G_IO_ERROR_HOST_UNREACHABLE => Self::HostUnreachable,
2451            ffi::G_IO_ERROR_NETWORK_UNREACHABLE => Self::NetworkUnreachable,
2452            ffi::G_IO_ERROR_CONNECTION_REFUSED => Self::ConnectionRefused,
2453            ffi::G_IO_ERROR_PROXY_FAILED => Self::ProxyFailed,
2454            ffi::G_IO_ERROR_PROXY_AUTH_FAILED => Self::ProxyAuthFailed,
2455            ffi::G_IO_ERROR_PROXY_NEED_AUTH => Self::ProxyNeedAuth,
2456            ffi::G_IO_ERROR_PROXY_NOT_ALLOWED => Self::ProxyNotAllowed,
2457            ffi::G_IO_ERROR_BROKEN_PIPE => Self::BrokenPipe,
2458            ffi::G_IO_ERROR_NOT_CONNECTED => Self::NotConnected,
2459            ffi::G_IO_ERROR_MESSAGE_TOO_LARGE => Self::MessageTooLarge,
2460            #[cfg(feature = "v2_72")]
2461            ffi::G_IO_ERROR_NO_SUCH_DEVICE => Self::NoSuchDevice,
2462            #[cfg(feature = "v2_80")]
2463            ffi::G_IO_ERROR_DESTINATION_UNSET => Self::DestinationUnset,
2464            value => Self::__Unknown(value),
2465        }
2466    }
2467}
2468
2469impl glib::error::ErrorDomain for IOErrorEnum {
2470    #[inline]
2471    fn domain() -> glib::Quark {
2472        unsafe { from_glib(ffi::g_io_error_quark()) }
2473    }
2474
2475    #[inline]
2476    fn code(self) -> i32 {
2477        self.into_glib()
2478    }
2479
2480    #[inline]
2481    #[allow(clippy::match_single_binding)]
2482    fn from(code: i32) -> Option<Self> {
2483        match unsafe { from_glib(code) } {
2484            Self::__Unknown(_) => Some(Self::Failed),
2485            value => Some(value),
2486        }
2487    }
2488}
2489
2490impl StaticType for IOErrorEnum {
2491    #[inline]
2492    #[doc(alias = "g_io_error_enum_get_type")]
2493    fn static_type() -> glib::Type {
2494        unsafe { from_glib(ffi::g_io_error_enum_get_type()) }
2495    }
2496}
2497
2498impl glib::HasParamSpec for IOErrorEnum {
2499    type ParamSpec = glib::ParamSpecEnum;
2500    type SetValue = Self;
2501    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2502
2503    fn param_spec_builder() -> Self::BuilderFn {
2504        Self::ParamSpec::builder_with_default
2505    }
2506}
2507
2508impl glib::value::ValueType for IOErrorEnum {
2509    type Type = Self;
2510}
2511
2512unsafe impl<'a> glib::value::FromValue<'a> for IOErrorEnum {
2513    type Checker = glib::value::GenericValueTypeChecker<Self>;
2514
2515    #[inline]
2516    unsafe fn from_value(value: &'a glib::Value) -> Self {
2517        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2518    }
2519}
2520
2521impl ToValue for IOErrorEnum {
2522    #[inline]
2523    fn to_value(&self) -> glib::Value {
2524        let mut value = glib::Value::for_value_type::<Self>();
2525        unsafe {
2526            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2527        }
2528        value
2529    }
2530
2531    #[inline]
2532    fn value_type(&self) -> glib::Type {
2533        Self::static_type()
2534    }
2535}
2536
2537impl From<IOErrorEnum> for glib::Value {
2538    #[inline]
2539    fn from(v: IOErrorEnum) -> Self {
2540        ToValue::to_value(&v)
2541    }
2542}
2543
2544/// Flags for use with g_io_module_scope_new().
2545#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2546#[non_exhaustive]
2547#[doc(alias = "GIOModuleScopeFlags")]
2548pub enum IOModuleScopeFlags {
2549    /// No module scan flags
2550    #[doc(alias = "G_IO_MODULE_SCOPE_NONE")]
2551    None,
2552    /// When using this scope to load or
2553    ///     scan modules, automatically block a modules which has the same base
2554    ///     basename as previously loaded module.
2555    #[doc(alias = "G_IO_MODULE_SCOPE_BLOCK_DUPLICATES")]
2556    BlockDuplicates,
2557    #[doc(hidden)]
2558    __Unknown(i32),
2559}
2560
2561#[doc(hidden)]
2562impl IntoGlib for IOModuleScopeFlags {
2563    type GlibType = ffi::GIOModuleScopeFlags;
2564
2565    #[inline]
2566    fn into_glib(self) -> ffi::GIOModuleScopeFlags {
2567        match self {
2568            Self::None => ffi::G_IO_MODULE_SCOPE_NONE,
2569            Self::BlockDuplicates => ffi::G_IO_MODULE_SCOPE_BLOCK_DUPLICATES,
2570            Self::__Unknown(value) => value,
2571        }
2572    }
2573}
2574
2575#[doc(hidden)]
2576impl FromGlib<ffi::GIOModuleScopeFlags> for IOModuleScopeFlags {
2577    #[inline]
2578    unsafe fn from_glib(value: ffi::GIOModuleScopeFlags) -> Self {
2579        match value {
2580            ffi::G_IO_MODULE_SCOPE_NONE => Self::None,
2581            ffi::G_IO_MODULE_SCOPE_BLOCK_DUPLICATES => Self::BlockDuplicates,
2582            value => Self::__Unknown(value),
2583        }
2584    }
2585}
2586
2587impl StaticType for IOModuleScopeFlags {
2588    #[inline]
2589    #[doc(alias = "g_io_module_scope_flags_get_type")]
2590    fn static_type() -> glib::Type {
2591        unsafe { from_glib(ffi::g_io_module_scope_flags_get_type()) }
2592    }
2593}
2594
2595impl glib::HasParamSpec for IOModuleScopeFlags {
2596    type ParamSpec = glib::ParamSpecEnum;
2597    type SetValue = Self;
2598    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2599
2600    fn param_spec_builder() -> Self::BuilderFn {
2601        Self::ParamSpec::builder_with_default
2602    }
2603}
2604
2605impl glib::value::ValueType for IOModuleScopeFlags {
2606    type Type = Self;
2607}
2608
2609unsafe impl<'a> glib::value::FromValue<'a> for IOModuleScopeFlags {
2610    type Checker = glib::value::GenericValueTypeChecker<Self>;
2611
2612    #[inline]
2613    unsafe fn from_value(value: &'a glib::Value) -> Self {
2614        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2615    }
2616}
2617
2618impl ToValue for IOModuleScopeFlags {
2619    #[inline]
2620    fn to_value(&self) -> glib::Value {
2621        let mut value = glib::Value::for_value_type::<Self>();
2622        unsafe {
2623            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2624        }
2625        value
2626    }
2627
2628    #[inline]
2629    fn value_type(&self) -> glib::Type {
2630        Self::static_type()
2631    }
2632}
2633
2634impl From<IOModuleScopeFlags> for glib::Value {
2635    #[inline]
2636    fn from(v: IOModuleScopeFlags) -> Self {
2637        ToValue::to_value(&v)
2638    }
2639}
2640
2641/// Memory availability warning levels.
2642///
2643/// Note that because new values might be added, it is recommended that applications check
2644/// #GMemoryMonitorWarningLevel as ranges, for example:
2645///
2646///
2647/// **⚠️ The following code is in C ⚠️**
2648///
2649/// ```C
2650/// if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
2651///   drop_caches ();
2652/// ```
2653#[cfg(feature = "v2_64")]
2654#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2655#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2656#[non_exhaustive]
2657#[doc(alias = "GMemoryMonitorWarningLevel")]
2658pub enum MemoryMonitorWarningLevel {
2659    /// Memory on the device is low, processes
2660    ///   should free up unneeded resources (for example, in-memory caches) so they can
2661    ///   be used elsewhere.
2662    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_LOW")]
2663    Low,
2664    /// Same as @G_MEMORY_MONITOR_WARNING_LEVEL_LOW
2665    ///   but the device has even less free memory, so processes should try harder to free
2666    ///   up unneeded resources. If your process does not need to stay running, it is a
2667    ///   good time for it to quit.
2668    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM")]
2669    Medium,
2670    /// The system will soon start terminating
2671    ///   processes to reclaim memory, including background processes.
2672    #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL")]
2673    Critical,
2674    #[doc(hidden)]
2675    __Unknown(i32),
2676}
2677
2678#[cfg(feature = "v2_64")]
2679#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2680#[doc(hidden)]
2681impl IntoGlib for MemoryMonitorWarningLevel {
2682    type GlibType = ffi::GMemoryMonitorWarningLevel;
2683
2684    #[inline]
2685    fn into_glib(self) -> ffi::GMemoryMonitorWarningLevel {
2686        match self {
2687            Self::Low => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW,
2688            Self::Medium => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM,
2689            Self::Critical => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL,
2690            Self::__Unknown(value) => value,
2691        }
2692    }
2693}
2694
2695#[cfg(feature = "v2_64")]
2696#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2697#[doc(hidden)]
2698impl FromGlib<ffi::GMemoryMonitorWarningLevel> for MemoryMonitorWarningLevel {
2699    #[inline]
2700    unsafe fn from_glib(value: ffi::GMemoryMonitorWarningLevel) -> Self {
2701        match value {
2702            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW => Self::Low,
2703            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM => Self::Medium,
2704            ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL => Self::Critical,
2705            value => Self::__Unknown(value),
2706        }
2707    }
2708}
2709
2710#[cfg(feature = "v2_64")]
2711#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2712impl StaticType for MemoryMonitorWarningLevel {
2713    #[inline]
2714    #[doc(alias = "g_memory_monitor_warning_level_get_type")]
2715    fn static_type() -> glib::Type {
2716        unsafe { from_glib(ffi::g_memory_monitor_warning_level_get_type()) }
2717    }
2718}
2719
2720#[cfg(feature = "v2_64")]
2721#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2722impl glib::HasParamSpec for MemoryMonitorWarningLevel {
2723    type ParamSpec = glib::ParamSpecEnum;
2724    type SetValue = Self;
2725    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2726
2727    fn param_spec_builder() -> Self::BuilderFn {
2728        Self::ParamSpec::builder_with_default
2729    }
2730}
2731
2732#[cfg(feature = "v2_64")]
2733#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2734impl glib::value::ValueType for MemoryMonitorWarningLevel {
2735    type Type = Self;
2736}
2737
2738#[cfg(feature = "v2_64")]
2739#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2740unsafe impl<'a> glib::value::FromValue<'a> for MemoryMonitorWarningLevel {
2741    type Checker = glib::value::GenericValueTypeChecker<Self>;
2742
2743    #[inline]
2744    unsafe fn from_value(value: &'a glib::Value) -> Self {
2745        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2746    }
2747}
2748
2749#[cfg(feature = "v2_64")]
2750#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2751impl ToValue for MemoryMonitorWarningLevel {
2752    #[inline]
2753    fn to_value(&self) -> glib::Value {
2754        let mut value = glib::Value::for_value_type::<Self>();
2755        unsafe {
2756            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2757        }
2758        value
2759    }
2760
2761    #[inline]
2762    fn value_type(&self) -> glib::Type {
2763        Self::static_type()
2764    }
2765}
2766
2767#[cfg(feature = "v2_64")]
2768#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2769impl From<MemoryMonitorWarningLevel> for glib::Value {
2770    #[inline]
2771    fn from(v: MemoryMonitorWarningLevel) -> Self {
2772        ToValue::to_value(&v)
2773    }
2774}
2775
2776/// #GMountOperationResult is returned as a result when a request for
2777/// information is send by the mounting operation.
2778#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2779#[non_exhaustive]
2780#[doc(alias = "GMountOperationResult")]
2781pub enum MountOperationResult {
2782    /// The request was fulfilled and the
2783    ///     user specified data is now available
2784    #[doc(alias = "G_MOUNT_OPERATION_HANDLED")]
2785    Handled,
2786    /// The user requested the mount operation
2787    ///     to be aborted
2788    #[doc(alias = "G_MOUNT_OPERATION_ABORTED")]
2789    Aborted,
2790    /// The request was unhandled (i.e. not
2791    ///     implemented)
2792    #[doc(alias = "G_MOUNT_OPERATION_UNHANDLED")]
2793    Unhandled,
2794    #[doc(hidden)]
2795    __Unknown(i32),
2796}
2797
2798#[doc(hidden)]
2799impl IntoGlib for MountOperationResult {
2800    type GlibType = ffi::GMountOperationResult;
2801
2802    #[inline]
2803    fn into_glib(self) -> ffi::GMountOperationResult {
2804        match self {
2805            Self::Handled => ffi::G_MOUNT_OPERATION_HANDLED,
2806            Self::Aborted => ffi::G_MOUNT_OPERATION_ABORTED,
2807            Self::Unhandled => ffi::G_MOUNT_OPERATION_UNHANDLED,
2808            Self::__Unknown(value) => value,
2809        }
2810    }
2811}
2812
2813#[doc(hidden)]
2814impl FromGlib<ffi::GMountOperationResult> for MountOperationResult {
2815    #[inline]
2816    unsafe fn from_glib(value: ffi::GMountOperationResult) -> Self {
2817        match value {
2818            ffi::G_MOUNT_OPERATION_HANDLED => Self::Handled,
2819            ffi::G_MOUNT_OPERATION_ABORTED => Self::Aborted,
2820            ffi::G_MOUNT_OPERATION_UNHANDLED => Self::Unhandled,
2821            value => Self::__Unknown(value),
2822        }
2823    }
2824}
2825
2826impl StaticType for MountOperationResult {
2827    #[inline]
2828    #[doc(alias = "g_mount_operation_result_get_type")]
2829    fn static_type() -> glib::Type {
2830        unsafe { from_glib(ffi::g_mount_operation_result_get_type()) }
2831    }
2832}
2833
2834impl glib::HasParamSpec for MountOperationResult {
2835    type ParamSpec = glib::ParamSpecEnum;
2836    type SetValue = Self;
2837    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2838
2839    fn param_spec_builder() -> Self::BuilderFn {
2840        Self::ParamSpec::builder_with_default
2841    }
2842}
2843
2844impl glib::value::ValueType for MountOperationResult {
2845    type Type = Self;
2846}
2847
2848unsafe impl<'a> glib::value::FromValue<'a> for MountOperationResult {
2849    type Checker = glib::value::GenericValueTypeChecker<Self>;
2850
2851    #[inline]
2852    unsafe fn from_value(value: &'a glib::Value) -> Self {
2853        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2854    }
2855}
2856
2857impl ToValue for MountOperationResult {
2858    #[inline]
2859    fn to_value(&self) -> glib::Value {
2860        let mut value = glib::Value::for_value_type::<Self>();
2861        unsafe {
2862            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2863        }
2864        value
2865    }
2866
2867    #[inline]
2868    fn value_type(&self) -> glib::Type {
2869        Self::static_type()
2870    }
2871}
2872
2873impl From<MountOperationResult> for glib::Value {
2874    #[inline]
2875    fn from(v: MountOperationResult) -> Self {
2876        ToValue::to_value(&v)
2877    }
2878}
2879
2880/// The host's network connectivity state, as reported by #GNetworkMonitor.
2881#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2882#[non_exhaustive]
2883#[doc(alias = "GNetworkConnectivity")]
2884pub enum NetworkConnectivity {
2885    /// The host is not configured with a
2886    ///   route to the Internet; it may or may not be connected to a local
2887    ///   network.
2888    #[doc(alias = "G_NETWORK_CONNECTIVITY_LOCAL")]
2889    Local,
2890    /// The host is connected to a network, but
2891    ///   does not appear to be able to reach the full Internet, perhaps
2892    ///   due to upstream network problems.
2893    #[doc(alias = "G_NETWORK_CONNECTIVITY_LIMITED")]
2894    Limited,
2895    /// The host is behind a captive portal and
2896    ///   cannot reach the full Internet.
2897    #[doc(alias = "G_NETWORK_CONNECTIVITY_PORTAL")]
2898    Portal,
2899    /// The host is connected to a network, and
2900    ///   appears to be able to reach the full Internet.
2901    #[doc(alias = "G_NETWORK_CONNECTIVITY_FULL")]
2902    Full,
2903    #[doc(hidden)]
2904    __Unknown(i32),
2905}
2906
2907#[doc(hidden)]
2908impl IntoGlib for NetworkConnectivity {
2909    type GlibType = ffi::GNetworkConnectivity;
2910
2911    #[inline]
2912    fn into_glib(self) -> ffi::GNetworkConnectivity {
2913        match self {
2914            Self::Local => ffi::G_NETWORK_CONNECTIVITY_LOCAL,
2915            Self::Limited => ffi::G_NETWORK_CONNECTIVITY_LIMITED,
2916            Self::Portal => ffi::G_NETWORK_CONNECTIVITY_PORTAL,
2917            Self::Full => ffi::G_NETWORK_CONNECTIVITY_FULL,
2918            Self::__Unknown(value) => value,
2919        }
2920    }
2921}
2922
2923#[doc(hidden)]
2924impl FromGlib<ffi::GNetworkConnectivity> for NetworkConnectivity {
2925    #[inline]
2926    unsafe fn from_glib(value: ffi::GNetworkConnectivity) -> Self {
2927        match value {
2928            ffi::G_NETWORK_CONNECTIVITY_LOCAL => Self::Local,
2929            ffi::G_NETWORK_CONNECTIVITY_LIMITED => Self::Limited,
2930            ffi::G_NETWORK_CONNECTIVITY_PORTAL => Self::Portal,
2931            ffi::G_NETWORK_CONNECTIVITY_FULL => Self::Full,
2932            value => Self::__Unknown(value),
2933        }
2934    }
2935}
2936
2937impl StaticType for NetworkConnectivity {
2938    #[inline]
2939    #[doc(alias = "g_network_connectivity_get_type")]
2940    fn static_type() -> glib::Type {
2941        unsafe { from_glib(ffi::g_network_connectivity_get_type()) }
2942    }
2943}
2944
2945impl glib::HasParamSpec for NetworkConnectivity {
2946    type ParamSpec = glib::ParamSpecEnum;
2947    type SetValue = Self;
2948    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2949
2950    fn param_spec_builder() -> Self::BuilderFn {
2951        Self::ParamSpec::builder_with_default
2952    }
2953}
2954
2955impl glib::value::ValueType for NetworkConnectivity {
2956    type Type = Self;
2957}
2958
2959unsafe impl<'a> glib::value::FromValue<'a> for NetworkConnectivity {
2960    type Checker = glib::value::GenericValueTypeChecker<Self>;
2961
2962    #[inline]
2963    unsafe fn from_value(value: &'a glib::Value) -> Self {
2964        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2965    }
2966}
2967
2968impl ToValue for NetworkConnectivity {
2969    #[inline]
2970    fn to_value(&self) -> glib::Value {
2971        let mut value = glib::Value::for_value_type::<Self>();
2972        unsafe {
2973            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2974        }
2975        value
2976    }
2977
2978    #[inline]
2979    fn value_type(&self) -> glib::Type {
2980        Self::static_type()
2981    }
2982}
2983
2984impl From<NetworkConnectivity> for glib::Value {
2985    #[inline]
2986    fn from(v: NetworkConnectivity) -> Self {
2987        ToValue::to_value(&v)
2988    }
2989}
2990
2991/// Priority levels for #GNotifications.
2992#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2993#[non_exhaustive]
2994#[doc(alias = "GNotificationPriority")]
2995pub enum NotificationPriority {
2996    /// the default priority, to be used for the
2997    ///   majority of notifications (for example email messages, software updates,
2998    ///   completed download/sync operations)
2999    #[doc(alias = "G_NOTIFICATION_PRIORITY_NORMAL")]
3000    Normal,
3001    /// for notifications that do not require
3002    ///   immediate attention - typically used for contextual background
3003    ///   information, such as contact birthdays or local weather
3004    #[doc(alias = "G_NOTIFICATION_PRIORITY_LOW")]
3005    Low,
3006    /// for events that require more attention,
3007    ///   usually because responses are time-sensitive (for example chat and SMS
3008    ///   messages or alarms)
3009    #[doc(alias = "G_NOTIFICATION_PRIORITY_HIGH")]
3010    High,
3011    /// for urgent notifications, or notifications
3012    ///   that require a response in a short space of time (for example phone calls
3013    ///   or emergency warnings)
3014    #[doc(alias = "G_NOTIFICATION_PRIORITY_URGENT")]
3015    Urgent,
3016    #[doc(hidden)]
3017    __Unknown(i32),
3018}
3019
3020#[doc(hidden)]
3021impl IntoGlib for NotificationPriority {
3022    type GlibType = ffi::GNotificationPriority;
3023
3024    #[inline]
3025    fn into_glib(self) -> ffi::GNotificationPriority {
3026        match self {
3027            Self::Normal => ffi::G_NOTIFICATION_PRIORITY_NORMAL,
3028            Self::Low => ffi::G_NOTIFICATION_PRIORITY_LOW,
3029            Self::High => ffi::G_NOTIFICATION_PRIORITY_HIGH,
3030            Self::Urgent => ffi::G_NOTIFICATION_PRIORITY_URGENT,
3031            Self::__Unknown(value) => value,
3032        }
3033    }
3034}
3035
3036#[doc(hidden)]
3037impl FromGlib<ffi::GNotificationPriority> for NotificationPriority {
3038    #[inline]
3039    unsafe fn from_glib(value: ffi::GNotificationPriority) -> Self {
3040        match value {
3041            ffi::G_NOTIFICATION_PRIORITY_NORMAL => Self::Normal,
3042            ffi::G_NOTIFICATION_PRIORITY_LOW => Self::Low,
3043            ffi::G_NOTIFICATION_PRIORITY_HIGH => Self::High,
3044            ffi::G_NOTIFICATION_PRIORITY_URGENT => Self::Urgent,
3045            value => Self::__Unknown(value),
3046        }
3047    }
3048}
3049
3050impl StaticType for NotificationPriority {
3051    #[inline]
3052    #[doc(alias = "g_notification_priority_get_type")]
3053    fn static_type() -> glib::Type {
3054        unsafe { from_glib(ffi::g_notification_priority_get_type()) }
3055    }
3056}
3057
3058impl glib::HasParamSpec for NotificationPriority {
3059    type ParamSpec = glib::ParamSpecEnum;
3060    type SetValue = Self;
3061    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3062
3063    fn param_spec_builder() -> Self::BuilderFn {
3064        Self::ParamSpec::builder_with_default
3065    }
3066}
3067
3068impl glib::value::ValueType for NotificationPriority {
3069    type Type = Self;
3070}
3071
3072unsafe impl<'a> glib::value::FromValue<'a> for NotificationPriority {
3073    type Checker = glib::value::GenericValueTypeChecker<Self>;
3074
3075    #[inline]
3076    unsafe fn from_value(value: &'a glib::Value) -> Self {
3077        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3078    }
3079}
3080
3081impl ToValue for NotificationPriority {
3082    #[inline]
3083    fn to_value(&self) -> glib::Value {
3084        let mut value = glib::Value::for_value_type::<Self>();
3085        unsafe {
3086            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3087        }
3088        value
3089    }
3090
3091    #[inline]
3092    fn value_type(&self) -> glib::Type {
3093        Self::static_type()
3094    }
3095}
3096
3097impl From<NotificationPriority> for glib::Value {
3098    #[inline]
3099    fn from(v: NotificationPriority) -> Self {
3100        ToValue::to_value(&v)
3101    }
3102}
3103
3104/// #GPasswordSave is used to indicate the lifespan of a saved password.
3105///
3106/// #Gvfs stores passwords in the Gnome keyring when this flag allows it
3107/// to, and later retrieves it again from there.
3108#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3109#[non_exhaustive]
3110#[doc(alias = "GPasswordSave")]
3111pub enum PasswordSave {
3112    /// never save a password.
3113    #[doc(alias = "G_PASSWORD_SAVE_NEVER")]
3114    Never,
3115    /// save a password for the session.
3116    #[doc(alias = "G_PASSWORD_SAVE_FOR_SESSION")]
3117    ForSession,
3118    /// save a password permanently.
3119    #[doc(alias = "G_PASSWORD_SAVE_PERMANENTLY")]
3120    Permanently,
3121    #[doc(hidden)]
3122    __Unknown(i32),
3123}
3124
3125#[doc(hidden)]
3126impl IntoGlib for PasswordSave {
3127    type GlibType = ffi::GPasswordSave;
3128
3129    #[inline]
3130    fn into_glib(self) -> ffi::GPasswordSave {
3131        match self {
3132            Self::Never => ffi::G_PASSWORD_SAVE_NEVER,
3133            Self::ForSession => ffi::G_PASSWORD_SAVE_FOR_SESSION,
3134            Self::Permanently => ffi::G_PASSWORD_SAVE_PERMANENTLY,
3135            Self::__Unknown(value) => value,
3136        }
3137    }
3138}
3139
3140#[doc(hidden)]
3141impl FromGlib<ffi::GPasswordSave> for PasswordSave {
3142    #[inline]
3143    unsafe fn from_glib(value: ffi::GPasswordSave) -> Self {
3144        match value {
3145            ffi::G_PASSWORD_SAVE_NEVER => Self::Never,
3146            ffi::G_PASSWORD_SAVE_FOR_SESSION => Self::ForSession,
3147            ffi::G_PASSWORD_SAVE_PERMANENTLY => Self::Permanently,
3148            value => Self::__Unknown(value),
3149        }
3150    }
3151}
3152
3153impl StaticType for PasswordSave {
3154    #[inline]
3155    #[doc(alias = "g_password_save_get_type")]
3156    fn static_type() -> glib::Type {
3157        unsafe { from_glib(ffi::g_password_save_get_type()) }
3158    }
3159}
3160
3161impl glib::HasParamSpec for PasswordSave {
3162    type ParamSpec = glib::ParamSpecEnum;
3163    type SetValue = Self;
3164    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3165
3166    fn param_spec_builder() -> Self::BuilderFn {
3167        Self::ParamSpec::builder_with_default
3168    }
3169}
3170
3171impl glib::value::ValueType for PasswordSave {
3172    type Type = Self;
3173}
3174
3175unsafe impl<'a> glib::value::FromValue<'a> for PasswordSave {
3176    type Checker = glib::value::GenericValueTypeChecker<Self>;
3177
3178    #[inline]
3179    unsafe fn from_value(value: &'a glib::Value) -> Self {
3180        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3181    }
3182}
3183
3184impl ToValue for PasswordSave {
3185    #[inline]
3186    fn to_value(&self) -> glib::Value {
3187        let mut value = glib::Value::for_value_type::<Self>();
3188        unsafe {
3189            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3190        }
3191        value
3192    }
3193
3194    #[inline]
3195    fn value_type(&self) -> glib::Type {
3196        Self::static_type()
3197    }
3198}
3199
3200impl From<PasswordSave> for glib::Value {
3201    #[inline]
3202    fn from(v: PasswordSave) -> Self {
3203        ToValue::to_value(&v)
3204    }
3205}
3206
3207/// Return value for various IO operations that signal errors via the
3208/// return value and not necessarily via a #GError.
3209///
3210/// This enum exists to be able to return errors to callers without having to
3211/// allocate a #GError. Allocating #GErrors can be quite expensive for
3212/// regularly happening errors like [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock].
3213///
3214/// In case of [`Failed`][Self::Failed] a #GError should be set for the
3215/// operation to give details about the error that happened.
3216#[cfg(feature = "v2_60")]
3217#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3218#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3219#[non_exhaustive]
3220#[doc(alias = "GPollableReturn")]
3221pub enum PollableReturn {
3222    /// Generic error condition for when an operation fails.
3223    #[doc(alias = "G_POLLABLE_RETURN_FAILED")]
3224    Failed,
3225    /// The operation was successfully finished.
3226    #[doc(alias = "G_POLLABLE_RETURN_OK")]
3227    Ok,
3228    /// The operation would block.
3229    #[doc(alias = "G_POLLABLE_RETURN_WOULD_BLOCK")]
3230    WouldBlock,
3231    #[doc(hidden)]
3232    __Unknown(i32),
3233}
3234
3235#[cfg(feature = "v2_60")]
3236#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3237#[doc(hidden)]
3238impl IntoGlib for PollableReturn {
3239    type GlibType = ffi::GPollableReturn;
3240
3241    #[inline]
3242    fn into_glib(self) -> ffi::GPollableReturn {
3243        match self {
3244            Self::Failed => ffi::G_POLLABLE_RETURN_FAILED,
3245            Self::Ok => ffi::G_POLLABLE_RETURN_OK,
3246            Self::WouldBlock => ffi::G_POLLABLE_RETURN_WOULD_BLOCK,
3247            Self::__Unknown(value) => value,
3248        }
3249    }
3250}
3251
3252#[cfg(feature = "v2_60")]
3253#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3254#[doc(hidden)]
3255impl FromGlib<ffi::GPollableReturn> for PollableReturn {
3256    #[inline]
3257    unsafe fn from_glib(value: ffi::GPollableReturn) -> Self {
3258        match value {
3259            ffi::G_POLLABLE_RETURN_FAILED => Self::Failed,
3260            ffi::G_POLLABLE_RETURN_OK => Self::Ok,
3261            ffi::G_POLLABLE_RETURN_WOULD_BLOCK => Self::WouldBlock,
3262            value => Self::__Unknown(value),
3263        }
3264    }
3265}
3266
3267#[cfg(feature = "v2_60")]
3268#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3269impl StaticType for PollableReturn {
3270    #[inline]
3271    #[doc(alias = "g_pollable_return_get_type")]
3272    fn static_type() -> glib::Type {
3273        unsafe { from_glib(ffi::g_pollable_return_get_type()) }
3274    }
3275}
3276
3277#[cfg(feature = "v2_60")]
3278#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3279impl glib::HasParamSpec for PollableReturn {
3280    type ParamSpec = glib::ParamSpecEnum;
3281    type SetValue = Self;
3282    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3283
3284    fn param_spec_builder() -> Self::BuilderFn {
3285        Self::ParamSpec::builder_with_default
3286    }
3287}
3288
3289#[cfg(feature = "v2_60")]
3290#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3291impl glib::value::ValueType for PollableReturn {
3292    type Type = Self;
3293}
3294
3295#[cfg(feature = "v2_60")]
3296#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3297unsafe impl<'a> glib::value::FromValue<'a> for PollableReturn {
3298    type Checker = glib::value::GenericValueTypeChecker<Self>;
3299
3300    #[inline]
3301    unsafe fn from_value(value: &'a glib::Value) -> Self {
3302        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3303    }
3304}
3305
3306#[cfg(feature = "v2_60")]
3307#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3308impl ToValue for PollableReturn {
3309    #[inline]
3310    fn to_value(&self) -> glib::Value {
3311        let mut value = glib::Value::for_value_type::<Self>();
3312        unsafe {
3313            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3314        }
3315        value
3316    }
3317
3318    #[inline]
3319    fn value_type(&self) -> glib::Type {
3320        Self::static_type()
3321    }
3322}
3323
3324#[cfg(feature = "v2_60")]
3325#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3326impl From<PollableReturn> for glib::Value {
3327    #[inline]
3328    fn from(v: PollableReturn) -> Self {
3329        ToValue::to_value(&v)
3330    }
3331}
3332
3333/// An error code used with `G_RESOLVER_ERROR` in a #GError returned
3334/// from a #GResolver routine.
3335#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3336#[non_exhaustive]
3337#[doc(alias = "GResolverError")]
3338pub enum ResolverError {
3339    /// the requested name/address/service was not
3340    ///     found
3341    #[doc(alias = "G_RESOLVER_ERROR_NOT_FOUND")]
3342    NotFound,
3343    /// the requested information could not
3344    ///     be looked up due to a network error or similar problem
3345    #[doc(alias = "G_RESOLVER_ERROR_TEMPORARY_FAILURE")]
3346    TemporaryFailure,
3347    /// unknown error
3348    #[doc(alias = "G_RESOLVER_ERROR_INTERNAL")]
3349    Internal,
3350    #[doc(hidden)]
3351    __Unknown(i32),
3352}
3353
3354#[doc(hidden)]
3355impl IntoGlib for ResolverError {
3356    type GlibType = ffi::GResolverError;
3357
3358    #[inline]
3359    fn into_glib(self) -> ffi::GResolverError {
3360        match self {
3361            Self::NotFound => ffi::G_RESOLVER_ERROR_NOT_FOUND,
3362            Self::TemporaryFailure => ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE,
3363            Self::Internal => ffi::G_RESOLVER_ERROR_INTERNAL,
3364            Self::__Unknown(value) => value,
3365        }
3366    }
3367}
3368
3369#[doc(hidden)]
3370impl FromGlib<ffi::GResolverError> for ResolverError {
3371    #[inline]
3372    unsafe fn from_glib(value: ffi::GResolverError) -> Self {
3373        match value {
3374            ffi::G_RESOLVER_ERROR_NOT_FOUND => Self::NotFound,
3375            ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE => Self::TemporaryFailure,
3376            ffi::G_RESOLVER_ERROR_INTERNAL => Self::Internal,
3377            value => Self::__Unknown(value),
3378        }
3379    }
3380}
3381
3382impl glib::error::ErrorDomain for ResolverError {
3383    #[inline]
3384    fn domain() -> glib::Quark {
3385        unsafe { from_glib(ffi::g_resolver_error_quark()) }
3386    }
3387
3388    #[inline]
3389    fn code(self) -> i32 {
3390        self.into_glib()
3391    }
3392
3393    #[inline]
3394    #[allow(clippy::match_single_binding)]
3395    fn from(code: i32) -> Option<Self> {
3396        match unsafe { from_glib(code) } {
3397            value => Some(value),
3398        }
3399    }
3400}
3401
3402impl StaticType for ResolverError {
3403    #[inline]
3404    #[doc(alias = "g_resolver_error_get_type")]
3405    fn static_type() -> glib::Type {
3406        unsafe { from_glib(ffi::g_resolver_error_get_type()) }
3407    }
3408}
3409
3410impl glib::HasParamSpec for ResolverError {
3411    type ParamSpec = glib::ParamSpecEnum;
3412    type SetValue = Self;
3413    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3414
3415    fn param_spec_builder() -> Self::BuilderFn {
3416        Self::ParamSpec::builder_with_default
3417    }
3418}
3419
3420impl glib::value::ValueType for ResolverError {
3421    type Type = Self;
3422}
3423
3424unsafe impl<'a> glib::value::FromValue<'a> for ResolverError {
3425    type Checker = glib::value::GenericValueTypeChecker<Self>;
3426
3427    #[inline]
3428    unsafe fn from_value(value: &'a glib::Value) -> Self {
3429        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3430    }
3431}
3432
3433impl ToValue for ResolverError {
3434    #[inline]
3435    fn to_value(&self) -> glib::Value {
3436        let mut value = glib::Value::for_value_type::<Self>();
3437        unsafe {
3438            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3439        }
3440        value
3441    }
3442
3443    #[inline]
3444    fn value_type(&self) -> glib::Type {
3445        Self::static_type()
3446    }
3447}
3448
3449impl From<ResolverError> for glib::Value {
3450    #[inline]
3451    fn from(v: ResolverError) -> Self {
3452        ToValue::to_value(&v)
3453    }
3454}
3455
3456/// The type of record that g_resolver_lookup_records() or
3457/// g_resolver_lookup_records_async() should retrieve. The records are returned
3458/// as lists of #GVariant tuples. Each record type has different values in
3459/// the variant tuples returned.
3460///
3461/// [`Srv`][Self::Srv] records are returned as variants with the signature
3462/// `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the
3463/// weight, a `guint16` with the port, and a string of the hostname.
3464///
3465/// [`Mx`][Self::Mx] records are returned as variants with the signature
3466/// `(qs)`, representing a `guint16` with the preference, and a string containing
3467/// the mail exchanger hostname.
3468///
3469/// [`Txt`][Self::Txt] records are returned as variants with the signature
3470/// `(as)`, representing an array of the strings in the text record. Note: Most TXT
3471/// records only contain a single string, but
3472/// [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a
3473/// record to contain multiple strings. The RFC which defines the interpretation
3474/// of a specific TXT record will likely require concatenation of multiple
3475/// strings if they are present, as with
3476/// [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3).
3477///
3478/// [`Soa`][Self::Soa] records are returned as variants with the signature
3479/// `(ssuuuuu)`, representing a string containing the primary name server, a
3480/// string containing the administrator, the serial as a `guint32`, the refresh
3481/// interval as a `guint32`, the retry interval as a `guint32`, the expire timeout
3482/// as a `guint32`, and the TTL as a `guint32`.
3483///
3484/// [`Ns`][Self::Ns] records are returned as variants with the signature
3485/// `(s)`, representing a string of the hostname of the name server.
3486#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3487#[non_exhaustive]
3488#[doc(alias = "GResolverRecordType")]
3489pub enum ResolverRecordType {
3490    /// look up DNS SRV records for a domain
3491    #[doc(alias = "G_RESOLVER_RECORD_SRV")]
3492    Srv,
3493    /// look up DNS MX records for a domain
3494    #[doc(alias = "G_RESOLVER_RECORD_MX")]
3495    Mx,
3496    /// look up DNS TXT records for a name
3497    #[doc(alias = "G_RESOLVER_RECORD_TXT")]
3498    Txt,
3499    /// look up DNS SOA records for a zone
3500    #[doc(alias = "G_RESOLVER_RECORD_SOA")]
3501    Soa,
3502    /// look up DNS NS records for a domain
3503    #[doc(alias = "G_RESOLVER_RECORD_NS")]
3504    Ns,
3505    #[doc(hidden)]
3506    __Unknown(i32),
3507}
3508
3509#[doc(hidden)]
3510impl IntoGlib for ResolverRecordType {
3511    type GlibType = ffi::GResolverRecordType;
3512
3513    #[inline]
3514    fn into_glib(self) -> ffi::GResolverRecordType {
3515        match self {
3516            Self::Srv => ffi::G_RESOLVER_RECORD_SRV,
3517            Self::Mx => ffi::G_RESOLVER_RECORD_MX,
3518            Self::Txt => ffi::G_RESOLVER_RECORD_TXT,
3519            Self::Soa => ffi::G_RESOLVER_RECORD_SOA,
3520            Self::Ns => ffi::G_RESOLVER_RECORD_NS,
3521            Self::__Unknown(value) => value,
3522        }
3523    }
3524}
3525
3526#[doc(hidden)]
3527impl FromGlib<ffi::GResolverRecordType> for ResolverRecordType {
3528    #[inline]
3529    unsafe fn from_glib(value: ffi::GResolverRecordType) -> Self {
3530        match value {
3531            ffi::G_RESOLVER_RECORD_SRV => Self::Srv,
3532            ffi::G_RESOLVER_RECORD_MX => Self::Mx,
3533            ffi::G_RESOLVER_RECORD_TXT => Self::Txt,
3534            ffi::G_RESOLVER_RECORD_SOA => Self::Soa,
3535            ffi::G_RESOLVER_RECORD_NS => Self::Ns,
3536            value => Self::__Unknown(value),
3537        }
3538    }
3539}
3540
3541impl StaticType for ResolverRecordType {
3542    #[inline]
3543    #[doc(alias = "g_resolver_record_type_get_type")]
3544    fn static_type() -> glib::Type {
3545        unsafe { from_glib(ffi::g_resolver_record_type_get_type()) }
3546    }
3547}
3548
3549impl glib::HasParamSpec for ResolverRecordType {
3550    type ParamSpec = glib::ParamSpecEnum;
3551    type SetValue = Self;
3552    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3553
3554    fn param_spec_builder() -> Self::BuilderFn {
3555        Self::ParamSpec::builder_with_default
3556    }
3557}
3558
3559impl glib::value::ValueType for ResolverRecordType {
3560    type Type = Self;
3561}
3562
3563unsafe impl<'a> glib::value::FromValue<'a> for ResolverRecordType {
3564    type Checker = glib::value::GenericValueTypeChecker<Self>;
3565
3566    #[inline]
3567    unsafe fn from_value(value: &'a glib::Value) -> Self {
3568        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3569    }
3570}
3571
3572impl ToValue for ResolverRecordType {
3573    #[inline]
3574    fn to_value(&self) -> glib::Value {
3575        let mut value = glib::Value::for_value_type::<Self>();
3576        unsafe {
3577            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3578        }
3579        value
3580    }
3581
3582    #[inline]
3583    fn value_type(&self) -> glib::Type {
3584        Self::static_type()
3585    }
3586}
3587
3588impl From<ResolverRecordType> for glib::Value {
3589    #[inline]
3590    fn from(v: ResolverRecordType) -> Self {
3591        ToValue::to_value(&v)
3592    }
3593}
3594
3595/// An error code used with `G_RESOURCE_ERROR` in a #GError returned
3596/// from a #GResource routine.
3597#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3598#[non_exhaustive]
3599#[doc(alias = "GResourceError")]
3600pub enum ResourceError {
3601    /// no file was found at the requested path
3602    #[doc(alias = "G_RESOURCE_ERROR_NOT_FOUND")]
3603    NotFound,
3604    /// unknown error
3605    #[doc(alias = "G_RESOURCE_ERROR_INTERNAL")]
3606    Internal,
3607    #[doc(hidden)]
3608    __Unknown(i32),
3609}
3610
3611#[doc(hidden)]
3612impl IntoGlib for ResourceError {
3613    type GlibType = ffi::GResourceError;
3614
3615    #[inline]
3616    fn into_glib(self) -> ffi::GResourceError {
3617        match self {
3618            Self::NotFound => ffi::G_RESOURCE_ERROR_NOT_FOUND,
3619            Self::Internal => ffi::G_RESOURCE_ERROR_INTERNAL,
3620            Self::__Unknown(value) => value,
3621        }
3622    }
3623}
3624
3625#[doc(hidden)]
3626impl FromGlib<ffi::GResourceError> for ResourceError {
3627    #[inline]
3628    unsafe fn from_glib(value: ffi::GResourceError) -> Self {
3629        match value {
3630            ffi::G_RESOURCE_ERROR_NOT_FOUND => Self::NotFound,
3631            ffi::G_RESOURCE_ERROR_INTERNAL => Self::Internal,
3632            value => Self::__Unknown(value),
3633        }
3634    }
3635}
3636
3637impl glib::error::ErrorDomain for ResourceError {
3638    #[inline]
3639    fn domain() -> glib::Quark {
3640        unsafe { from_glib(ffi::g_resource_error_quark()) }
3641    }
3642
3643    #[inline]
3644    fn code(self) -> i32 {
3645        self.into_glib()
3646    }
3647
3648    #[inline]
3649    #[allow(clippy::match_single_binding)]
3650    fn from(code: i32) -> Option<Self> {
3651        match unsafe { from_glib(code) } {
3652            value => Some(value),
3653        }
3654    }
3655}
3656
3657impl StaticType for ResourceError {
3658    #[inline]
3659    #[doc(alias = "g_resource_error_get_type")]
3660    fn static_type() -> glib::Type {
3661        unsafe { from_glib(ffi::g_resource_error_get_type()) }
3662    }
3663}
3664
3665impl glib::HasParamSpec for ResourceError {
3666    type ParamSpec = glib::ParamSpecEnum;
3667    type SetValue = Self;
3668    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3669
3670    fn param_spec_builder() -> Self::BuilderFn {
3671        Self::ParamSpec::builder_with_default
3672    }
3673}
3674
3675impl glib::value::ValueType for ResourceError {
3676    type Type = Self;
3677}
3678
3679unsafe impl<'a> glib::value::FromValue<'a> for ResourceError {
3680    type Checker = glib::value::GenericValueTypeChecker<Self>;
3681
3682    #[inline]
3683    unsafe fn from_value(value: &'a glib::Value) -> Self {
3684        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3685    }
3686}
3687
3688impl ToValue for ResourceError {
3689    #[inline]
3690    fn to_value(&self) -> glib::Value {
3691        let mut value = glib::Value::for_value_type::<Self>();
3692        unsafe {
3693            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3694        }
3695        value
3696    }
3697
3698    #[inline]
3699    fn value_type(&self) -> glib::Type {
3700        Self::static_type()
3701    }
3702}
3703
3704impl From<ResourceError> for glib::Value {
3705    #[inline]
3706    fn from(v: ResourceError) -> Self {
3707        ToValue::to_value(&v)
3708    }
3709}
3710
3711/// Describes an event occurring on a #GSocketClient. See the
3712/// #GSocketClient::event signal for more details.
3713///
3714/// Additional values may be added to this type in the future.
3715#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3716#[non_exhaustive]
3717#[doc(alias = "GSocketClientEvent")]
3718pub enum SocketClientEvent {
3719    /// The client is doing a DNS lookup.
3720    #[doc(alias = "G_SOCKET_CLIENT_RESOLVING")]
3721    Resolving,
3722    /// The client has completed a DNS lookup.
3723    #[doc(alias = "G_SOCKET_CLIENT_RESOLVED")]
3724    Resolved,
3725    /// The client is connecting to a remote
3726    ///   host (either a proxy or the destination server).
3727    #[doc(alias = "G_SOCKET_CLIENT_CONNECTING")]
3728    Connecting,
3729    /// The client has connected to a remote
3730    ///   host.
3731    #[doc(alias = "G_SOCKET_CLIENT_CONNECTED")]
3732    Connected,
3733    /// The client is negotiating
3734    ///   with a proxy to connect to the destination server.
3735    #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATING")]
3736    ProxyNegotiating,
3737    /// The client has negotiated
3738    ///   with the proxy server.
3739    #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATED")]
3740    ProxyNegotiated,
3741    /// The client is performing a
3742    ///   TLS handshake.
3743    #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKING")]
3744    TlsHandshaking,
3745    /// The client has performed a
3746    ///   TLS handshake.
3747    #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKED")]
3748    TlsHandshaked,
3749    /// The client is done with a particular
3750    ///   #GSocketConnectable.
3751    #[doc(alias = "G_SOCKET_CLIENT_COMPLETE")]
3752    Complete,
3753    #[doc(hidden)]
3754    __Unknown(i32),
3755}
3756
3757#[doc(hidden)]
3758impl IntoGlib for SocketClientEvent {
3759    type GlibType = ffi::GSocketClientEvent;
3760
3761    #[inline]
3762    fn into_glib(self) -> ffi::GSocketClientEvent {
3763        match self {
3764            Self::Resolving => ffi::G_SOCKET_CLIENT_RESOLVING,
3765            Self::Resolved => ffi::G_SOCKET_CLIENT_RESOLVED,
3766            Self::Connecting => ffi::G_SOCKET_CLIENT_CONNECTING,
3767            Self::Connected => ffi::G_SOCKET_CLIENT_CONNECTED,
3768            Self::ProxyNegotiating => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING,
3769            Self::ProxyNegotiated => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED,
3770            Self::TlsHandshaking => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING,
3771            Self::TlsHandshaked => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED,
3772            Self::Complete => ffi::G_SOCKET_CLIENT_COMPLETE,
3773            Self::__Unknown(value) => value,
3774        }
3775    }
3776}
3777
3778#[doc(hidden)]
3779impl FromGlib<ffi::GSocketClientEvent> for SocketClientEvent {
3780    #[inline]
3781    unsafe fn from_glib(value: ffi::GSocketClientEvent) -> Self {
3782        match value {
3783            ffi::G_SOCKET_CLIENT_RESOLVING => Self::Resolving,
3784            ffi::G_SOCKET_CLIENT_RESOLVED => Self::Resolved,
3785            ffi::G_SOCKET_CLIENT_CONNECTING => Self::Connecting,
3786            ffi::G_SOCKET_CLIENT_CONNECTED => Self::Connected,
3787            ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING => Self::ProxyNegotiating,
3788            ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED => Self::ProxyNegotiated,
3789            ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING => Self::TlsHandshaking,
3790            ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED => Self::TlsHandshaked,
3791            ffi::G_SOCKET_CLIENT_COMPLETE => Self::Complete,
3792            value => Self::__Unknown(value),
3793        }
3794    }
3795}
3796
3797impl StaticType for SocketClientEvent {
3798    #[inline]
3799    #[doc(alias = "g_socket_client_event_get_type")]
3800    fn static_type() -> glib::Type {
3801        unsafe { from_glib(ffi::g_socket_client_event_get_type()) }
3802    }
3803}
3804
3805impl glib::HasParamSpec for SocketClientEvent {
3806    type ParamSpec = glib::ParamSpecEnum;
3807    type SetValue = Self;
3808    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3809
3810    fn param_spec_builder() -> Self::BuilderFn {
3811        Self::ParamSpec::builder_with_default
3812    }
3813}
3814
3815impl glib::value::ValueType for SocketClientEvent {
3816    type Type = Self;
3817}
3818
3819unsafe impl<'a> glib::value::FromValue<'a> for SocketClientEvent {
3820    type Checker = glib::value::GenericValueTypeChecker<Self>;
3821
3822    #[inline]
3823    unsafe fn from_value(value: &'a glib::Value) -> Self {
3824        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3825    }
3826}
3827
3828impl ToValue for SocketClientEvent {
3829    #[inline]
3830    fn to_value(&self) -> glib::Value {
3831        let mut value = glib::Value::for_value_type::<Self>();
3832        unsafe {
3833            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3834        }
3835        value
3836    }
3837
3838    #[inline]
3839    fn value_type(&self) -> glib::Type {
3840        Self::static_type()
3841    }
3842}
3843
3844impl From<SocketClientEvent> for glib::Value {
3845    #[inline]
3846    fn from(v: SocketClientEvent) -> Self {
3847        ToValue::to_value(&v)
3848    }
3849}
3850
3851/// The protocol family of a #GSocketAddress. (These values are
3852/// identical to the system defines `AF_INET`, `AF_INET6` and `AF_UNIX`,
3853/// if available.)
3854#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3855#[non_exhaustive]
3856#[doc(alias = "GSocketFamily")]
3857pub enum SocketFamily {
3858    /// no address family
3859    #[doc(alias = "G_SOCKET_FAMILY_INVALID")]
3860    Invalid,
3861    /// the UNIX domain family
3862    #[doc(alias = "G_SOCKET_FAMILY_UNIX")]
3863    Unix,
3864    /// the IPv4 family
3865    #[doc(alias = "G_SOCKET_FAMILY_IPV4")]
3866    Ipv4,
3867    /// the IPv6 family
3868    #[doc(alias = "G_SOCKET_FAMILY_IPV6")]
3869    Ipv6,
3870    #[doc(hidden)]
3871    __Unknown(i32),
3872}
3873
3874#[doc(hidden)]
3875impl IntoGlib for SocketFamily {
3876    type GlibType = ffi::GSocketFamily;
3877
3878    #[inline]
3879    fn into_glib(self) -> ffi::GSocketFamily {
3880        match self {
3881            Self::Invalid => ffi::G_SOCKET_FAMILY_INVALID,
3882            Self::Unix => ffi::G_SOCKET_FAMILY_UNIX,
3883            Self::Ipv4 => ffi::G_SOCKET_FAMILY_IPV4,
3884            Self::Ipv6 => ffi::G_SOCKET_FAMILY_IPV6,
3885            Self::__Unknown(value) => value,
3886        }
3887    }
3888}
3889
3890#[doc(hidden)]
3891impl FromGlib<ffi::GSocketFamily> for SocketFamily {
3892    #[inline]
3893    unsafe fn from_glib(value: ffi::GSocketFamily) -> Self {
3894        match value {
3895            ffi::G_SOCKET_FAMILY_INVALID => Self::Invalid,
3896            ffi::G_SOCKET_FAMILY_UNIX => Self::Unix,
3897            ffi::G_SOCKET_FAMILY_IPV4 => Self::Ipv4,
3898            ffi::G_SOCKET_FAMILY_IPV6 => Self::Ipv6,
3899            value => Self::__Unknown(value),
3900        }
3901    }
3902}
3903
3904impl StaticType for SocketFamily {
3905    #[inline]
3906    #[doc(alias = "g_socket_family_get_type")]
3907    fn static_type() -> glib::Type {
3908        unsafe { from_glib(ffi::g_socket_family_get_type()) }
3909    }
3910}
3911
3912impl glib::HasParamSpec for SocketFamily {
3913    type ParamSpec = glib::ParamSpecEnum;
3914    type SetValue = Self;
3915    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3916
3917    fn param_spec_builder() -> Self::BuilderFn {
3918        Self::ParamSpec::builder_with_default
3919    }
3920}
3921
3922impl glib::value::ValueType for SocketFamily {
3923    type Type = Self;
3924}
3925
3926unsafe impl<'a> glib::value::FromValue<'a> for SocketFamily {
3927    type Checker = glib::value::GenericValueTypeChecker<Self>;
3928
3929    #[inline]
3930    unsafe fn from_value(value: &'a glib::Value) -> Self {
3931        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3932    }
3933}
3934
3935impl ToValue for SocketFamily {
3936    #[inline]
3937    fn to_value(&self) -> glib::Value {
3938        let mut value = glib::Value::for_value_type::<Self>();
3939        unsafe {
3940            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3941        }
3942        value
3943    }
3944
3945    #[inline]
3946    fn value_type(&self) -> glib::Type {
3947        Self::static_type()
3948    }
3949}
3950
3951impl From<SocketFamily> for glib::Value {
3952    #[inline]
3953    fn from(v: SocketFamily) -> Self {
3954        ToValue::to_value(&v)
3955    }
3956}
3957
3958/// Describes an event occurring on a #GSocketListener. See the
3959/// #GSocketListener::event signal for more details.
3960///
3961/// Additional values may be added to this type in the future.
3962#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3963#[non_exhaustive]
3964#[doc(alias = "GSocketListenerEvent")]
3965pub enum SocketListenerEvent {
3966    /// The listener is about to bind a socket.
3967    #[doc(alias = "G_SOCKET_LISTENER_BINDING")]
3968    Binding,
3969    /// The listener has bound a socket.
3970    #[doc(alias = "G_SOCKET_LISTENER_BOUND")]
3971    Bound,
3972    /// The listener is about to start
3973    ///    listening on this socket.
3974    #[doc(alias = "G_SOCKET_LISTENER_LISTENING")]
3975    Listening,
3976    /// The listener is now listening on
3977    ///   this socket.
3978    #[doc(alias = "G_SOCKET_LISTENER_LISTENED")]
3979    Listened,
3980    #[doc(hidden)]
3981    __Unknown(i32),
3982}
3983
3984#[doc(hidden)]
3985impl IntoGlib for SocketListenerEvent {
3986    type GlibType = ffi::GSocketListenerEvent;
3987
3988    #[inline]
3989    fn into_glib(self) -> ffi::GSocketListenerEvent {
3990        match self {
3991            Self::Binding => ffi::G_SOCKET_LISTENER_BINDING,
3992            Self::Bound => ffi::G_SOCKET_LISTENER_BOUND,
3993            Self::Listening => ffi::G_SOCKET_LISTENER_LISTENING,
3994            Self::Listened => ffi::G_SOCKET_LISTENER_LISTENED,
3995            Self::__Unknown(value) => value,
3996        }
3997    }
3998}
3999
4000#[doc(hidden)]
4001impl FromGlib<ffi::GSocketListenerEvent> for SocketListenerEvent {
4002    #[inline]
4003    unsafe fn from_glib(value: ffi::GSocketListenerEvent) -> Self {
4004        match value {
4005            ffi::G_SOCKET_LISTENER_BINDING => Self::Binding,
4006            ffi::G_SOCKET_LISTENER_BOUND => Self::Bound,
4007            ffi::G_SOCKET_LISTENER_LISTENING => Self::Listening,
4008            ffi::G_SOCKET_LISTENER_LISTENED => Self::Listened,
4009            value => Self::__Unknown(value),
4010        }
4011    }
4012}
4013
4014impl StaticType for SocketListenerEvent {
4015    #[inline]
4016    #[doc(alias = "g_socket_listener_event_get_type")]
4017    fn static_type() -> glib::Type {
4018        unsafe { from_glib(ffi::g_socket_listener_event_get_type()) }
4019    }
4020}
4021
4022impl glib::HasParamSpec for SocketListenerEvent {
4023    type ParamSpec = glib::ParamSpecEnum;
4024    type SetValue = Self;
4025    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4026
4027    fn param_spec_builder() -> Self::BuilderFn {
4028        Self::ParamSpec::builder_with_default
4029    }
4030}
4031
4032impl glib::value::ValueType for SocketListenerEvent {
4033    type Type = Self;
4034}
4035
4036unsafe impl<'a> glib::value::FromValue<'a> for SocketListenerEvent {
4037    type Checker = glib::value::GenericValueTypeChecker<Self>;
4038
4039    #[inline]
4040    unsafe fn from_value(value: &'a glib::Value) -> Self {
4041        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4042    }
4043}
4044
4045impl ToValue for SocketListenerEvent {
4046    #[inline]
4047    fn to_value(&self) -> glib::Value {
4048        let mut value = glib::Value::for_value_type::<Self>();
4049        unsafe {
4050            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4051        }
4052        value
4053    }
4054
4055    #[inline]
4056    fn value_type(&self) -> glib::Type {
4057        Self::static_type()
4058    }
4059}
4060
4061impl From<SocketListenerEvent> for glib::Value {
4062    #[inline]
4063    fn from(v: SocketListenerEvent) -> Self {
4064        ToValue::to_value(&v)
4065    }
4066}
4067
4068/// A protocol identifier is specified when creating a #GSocket, which is a
4069/// family/type specific identifier, where 0 means the default protocol for
4070/// the particular family/type.
4071///
4072/// This enum contains a set of commonly available and used protocols. You
4073/// can also pass any other identifiers handled by the platform in order to
4074/// use protocols not listed here.
4075#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4076#[non_exhaustive]
4077#[doc(alias = "GSocketProtocol")]
4078pub enum SocketProtocol {
4079    /// The protocol type is unknown
4080    #[doc(alias = "G_SOCKET_PROTOCOL_UNKNOWN")]
4081    Unknown,
4082    /// The default protocol for the family/type
4083    #[doc(alias = "G_SOCKET_PROTOCOL_DEFAULT")]
4084    Default,
4085    /// TCP over IP
4086    #[doc(alias = "G_SOCKET_PROTOCOL_TCP")]
4087    Tcp,
4088    /// UDP over IP
4089    #[doc(alias = "G_SOCKET_PROTOCOL_UDP")]
4090    Udp,
4091    /// SCTP over IP
4092    #[doc(alias = "G_SOCKET_PROTOCOL_SCTP")]
4093    Sctp,
4094    #[doc(hidden)]
4095    __Unknown(i32),
4096}
4097
4098#[doc(hidden)]
4099impl IntoGlib for SocketProtocol {
4100    type GlibType = ffi::GSocketProtocol;
4101
4102    #[inline]
4103    fn into_glib(self) -> ffi::GSocketProtocol {
4104        match self {
4105            Self::Unknown => ffi::G_SOCKET_PROTOCOL_UNKNOWN,
4106            Self::Default => ffi::G_SOCKET_PROTOCOL_DEFAULT,
4107            Self::Tcp => ffi::G_SOCKET_PROTOCOL_TCP,
4108            Self::Udp => ffi::G_SOCKET_PROTOCOL_UDP,
4109            Self::Sctp => ffi::G_SOCKET_PROTOCOL_SCTP,
4110            Self::__Unknown(value) => value,
4111        }
4112    }
4113}
4114
4115#[doc(hidden)]
4116impl FromGlib<ffi::GSocketProtocol> for SocketProtocol {
4117    #[inline]
4118    unsafe fn from_glib(value: ffi::GSocketProtocol) -> Self {
4119        match value {
4120            ffi::G_SOCKET_PROTOCOL_UNKNOWN => Self::Unknown,
4121            ffi::G_SOCKET_PROTOCOL_DEFAULT => Self::Default,
4122            ffi::G_SOCKET_PROTOCOL_TCP => Self::Tcp,
4123            ffi::G_SOCKET_PROTOCOL_UDP => Self::Udp,
4124            ffi::G_SOCKET_PROTOCOL_SCTP => Self::Sctp,
4125            value => Self::__Unknown(value),
4126        }
4127    }
4128}
4129
4130impl StaticType for SocketProtocol {
4131    #[inline]
4132    #[doc(alias = "g_socket_protocol_get_type")]
4133    fn static_type() -> glib::Type {
4134        unsafe { from_glib(ffi::g_socket_protocol_get_type()) }
4135    }
4136}
4137
4138impl glib::HasParamSpec for SocketProtocol {
4139    type ParamSpec = glib::ParamSpecEnum;
4140    type SetValue = Self;
4141    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4142
4143    fn param_spec_builder() -> Self::BuilderFn {
4144        Self::ParamSpec::builder_with_default
4145    }
4146}
4147
4148impl glib::value::ValueType for SocketProtocol {
4149    type Type = Self;
4150}
4151
4152unsafe impl<'a> glib::value::FromValue<'a> for SocketProtocol {
4153    type Checker = glib::value::GenericValueTypeChecker<Self>;
4154
4155    #[inline]
4156    unsafe fn from_value(value: &'a glib::Value) -> Self {
4157        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4158    }
4159}
4160
4161impl ToValue for SocketProtocol {
4162    #[inline]
4163    fn to_value(&self) -> glib::Value {
4164        let mut value = glib::Value::for_value_type::<Self>();
4165        unsafe {
4166            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4167        }
4168        value
4169    }
4170
4171    #[inline]
4172    fn value_type(&self) -> glib::Type {
4173        Self::static_type()
4174    }
4175}
4176
4177impl From<SocketProtocol> for glib::Value {
4178    #[inline]
4179    fn from(v: SocketProtocol) -> Self {
4180        ToValue::to_value(&v)
4181    }
4182}
4183
4184/// Flags used when creating a #GSocket. Some protocols may not implement
4185/// all the socket types.
4186#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4187#[non_exhaustive]
4188#[doc(alias = "GSocketType")]
4189pub enum SocketType {
4190    /// Type unknown or wrong
4191    #[doc(alias = "G_SOCKET_TYPE_INVALID")]
4192    Invalid,
4193    /// Reliable connection-based byte streams (e.g. TCP).
4194    #[doc(alias = "G_SOCKET_TYPE_STREAM")]
4195    Stream,
4196    /// Connectionless, unreliable datagram passing.
4197    ///     (e.g. UDP)
4198    #[doc(alias = "G_SOCKET_TYPE_DATAGRAM")]
4199    Datagram,
4200    /// Reliable connection-based passing of datagrams
4201    ///     of fixed maximum length (e.g. SCTP).
4202    #[doc(alias = "G_SOCKET_TYPE_SEQPACKET")]
4203    Seqpacket,
4204    #[doc(hidden)]
4205    __Unknown(i32),
4206}
4207
4208#[doc(hidden)]
4209impl IntoGlib for SocketType {
4210    type GlibType = ffi::GSocketType;
4211
4212    #[inline]
4213    fn into_glib(self) -> ffi::GSocketType {
4214        match self {
4215            Self::Invalid => ffi::G_SOCKET_TYPE_INVALID,
4216            Self::Stream => ffi::G_SOCKET_TYPE_STREAM,
4217            Self::Datagram => ffi::G_SOCKET_TYPE_DATAGRAM,
4218            Self::Seqpacket => ffi::G_SOCKET_TYPE_SEQPACKET,
4219            Self::__Unknown(value) => value,
4220        }
4221    }
4222}
4223
4224#[doc(hidden)]
4225impl FromGlib<ffi::GSocketType> for SocketType {
4226    #[inline]
4227    unsafe fn from_glib(value: ffi::GSocketType) -> Self {
4228        match value {
4229            ffi::G_SOCKET_TYPE_INVALID => Self::Invalid,
4230            ffi::G_SOCKET_TYPE_STREAM => Self::Stream,
4231            ffi::G_SOCKET_TYPE_DATAGRAM => Self::Datagram,
4232            ffi::G_SOCKET_TYPE_SEQPACKET => Self::Seqpacket,
4233            value => Self::__Unknown(value),
4234        }
4235    }
4236}
4237
4238impl StaticType for SocketType {
4239    #[inline]
4240    #[doc(alias = "g_socket_type_get_type")]
4241    fn static_type() -> glib::Type {
4242        unsafe { from_glib(ffi::g_socket_type_get_type()) }
4243    }
4244}
4245
4246impl glib::HasParamSpec for SocketType {
4247    type ParamSpec = glib::ParamSpecEnum;
4248    type SetValue = Self;
4249    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4250
4251    fn param_spec_builder() -> Self::BuilderFn {
4252        Self::ParamSpec::builder_with_default
4253    }
4254}
4255
4256impl glib::value::ValueType for SocketType {
4257    type Type = Self;
4258}
4259
4260unsafe impl<'a> glib::value::FromValue<'a> for SocketType {
4261    type Checker = glib::value::GenericValueTypeChecker<Self>;
4262
4263    #[inline]
4264    unsafe fn from_value(value: &'a glib::Value) -> Self {
4265        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4266    }
4267}
4268
4269impl ToValue for SocketType {
4270    #[inline]
4271    fn to_value(&self) -> glib::Value {
4272        let mut value = glib::Value::for_value_type::<Self>();
4273        unsafe {
4274            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4275        }
4276        value
4277    }
4278
4279    #[inline]
4280    fn value_type(&self) -> glib::Type {
4281        Self::static_type()
4282    }
4283}
4284
4285impl From<SocketType> for glib::Value {
4286    #[inline]
4287    fn from(v: SocketType) -> Self {
4288        ToValue::to_value(&v)
4289    }
4290}
4291
4292/// The client authentication mode for a #GTlsServerConnection.
4293#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4294#[non_exhaustive]
4295#[doc(alias = "GTlsAuthenticationMode")]
4296pub enum TlsAuthenticationMode {
4297    /// client authentication not required
4298    #[doc(alias = "G_TLS_AUTHENTICATION_NONE")]
4299    None,
4300    /// client authentication is requested
4301    #[doc(alias = "G_TLS_AUTHENTICATION_REQUESTED")]
4302    Requested,
4303    /// client authentication is required
4304    #[doc(alias = "G_TLS_AUTHENTICATION_REQUIRED")]
4305    Required,
4306    #[doc(hidden)]
4307    __Unknown(i32),
4308}
4309
4310#[doc(hidden)]
4311impl IntoGlib for TlsAuthenticationMode {
4312    type GlibType = ffi::GTlsAuthenticationMode;
4313
4314    #[inline]
4315    fn into_glib(self) -> ffi::GTlsAuthenticationMode {
4316        match self {
4317            Self::None => ffi::G_TLS_AUTHENTICATION_NONE,
4318            Self::Requested => ffi::G_TLS_AUTHENTICATION_REQUESTED,
4319            Self::Required => ffi::G_TLS_AUTHENTICATION_REQUIRED,
4320            Self::__Unknown(value) => value,
4321        }
4322    }
4323}
4324
4325#[doc(hidden)]
4326impl FromGlib<ffi::GTlsAuthenticationMode> for TlsAuthenticationMode {
4327    #[inline]
4328    unsafe fn from_glib(value: ffi::GTlsAuthenticationMode) -> Self {
4329        match value {
4330            ffi::G_TLS_AUTHENTICATION_NONE => Self::None,
4331            ffi::G_TLS_AUTHENTICATION_REQUESTED => Self::Requested,
4332            ffi::G_TLS_AUTHENTICATION_REQUIRED => Self::Required,
4333            value => Self::__Unknown(value),
4334        }
4335    }
4336}
4337
4338impl StaticType for TlsAuthenticationMode {
4339    #[inline]
4340    #[doc(alias = "g_tls_authentication_mode_get_type")]
4341    fn static_type() -> glib::Type {
4342        unsafe { from_glib(ffi::g_tls_authentication_mode_get_type()) }
4343    }
4344}
4345
4346impl glib::HasParamSpec for TlsAuthenticationMode {
4347    type ParamSpec = glib::ParamSpecEnum;
4348    type SetValue = Self;
4349    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4350
4351    fn param_spec_builder() -> Self::BuilderFn {
4352        Self::ParamSpec::builder_with_default
4353    }
4354}
4355
4356impl glib::value::ValueType for TlsAuthenticationMode {
4357    type Type = Self;
4358}
4359
4360unsafe impl<'a> glib::value::FromValue<'a> for TlsAuthenticationMode {
4361    type Checker = glib::value::GenericValueTypeChecker<Self>;
4362
4363    #[inline]
4364    unsafe fn from_value(value: &'a glib::Value) -> Self {
4365        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4366    }
4367}
4368
4369impl ToValue for TlsAuthenticationMode {
4370    #[inline]
4371    fn to_value(&self) -> glib::Value {
4372        let mut value = glib::Value::for_value_type::<Self>();
4373        unsafe {
4374            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4375        }
4376        value
4377    }
4378
4379    #[inline]
4380    fn value_type(&self) -> glib::Type {
4381        Self::static_type()
4382    }
4383}
4384
4385impl From<TlsAuthenticationMode> for glib::Value {
4386    #[inline]
4387    fn from(v: TlsAuthenticationMode) -> Self {
4388        ToValue::to_value(&v)
4389    }
4390}
4391
4392/// Flags for g_tls_interaction_request_certificate(),
4393/// g_tls_interaction_request_certificate_async(), and
4394/// g_tls_interaction_invoke_request_certificate().
4395#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4396#[non_exhaustive]
4397#[doc(alias = "GTlsCertificateRequestFlags")]
4398pub enum TlsCertificateRequestFlags {
4399    /// No flags
4400    #[doc(alias = "G_TLS_CERTIFICATE_REQUEST_NONE")]
4401    None,
4402    #[doc(hidden)]
4403    __Unknown(i32),
4404}
4405
4406#[doc(hidden)]
4407impl IntoGlib for TlsCertificateRequestFlags {
4408    type GlibType = ffi::GTlsCertificateRequestFlags;
4409
4410    #[inline]
4411    fn into_glib(self) -> ffi::GTlsCertificateRequestFlags {
4412        match self {
4413            Self::None => ffi::G_TLS_CERTIFICATE_REQUEST_NONE,
4414            Self::__Unknown(value) => value,
4415        }
4416    }
4417}
4418
4419#[doc(hidden)]
4420impl FromGlib<ffi::GTlsCertificateRequestFlags> for TlsCertificateRequestFlags {
4421    #[inline]
4422    unsafe fn from_glib(value: ffi::GTlsCertificateRequestFlags) -> Self {
4423        match value {
4424            ffi::G_TLS_CERTIFICATE_REQUEST_NONE => Self::None,
4425            value => Self::__Unknown(value),
4426        }
4427    }
4428}
4429
4430impl StaticType for TlsCertificateRequestFlags {
4431    #[inline]
4432    #[doc(alias = "g_tls_certificate_request_flags_get_type")]
4433    fn static_type() -> glib::Type {
4434        unsafe { from_glib(ffi::g_tls_certificate_request_flags_get_type()) }
4435    }
4436}
4437
4438impl glib::HasParamSpec for TlsCertificateRequestFlags {
4439    type ParamSpec = glib::ParamSpecEnum;
4440    type SetValue = Self;
4441    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4442
4443    fn param_spec_builder() -> Self::BuilderFn {
4444        Self::ParamSpec::builder_with_default
4445    }
4446}
4447
4448impl glib::value::ValueType for TlsCertificateRequestFlags {
4449    type Type = Self;
4450}
4451
4452unsafe impl<'a> glib::value::FromValue<'a> for TlsCertificateRequestFlags {
4453    type Checker = glib::value::GenericValueTypeChecker<Self>;
4454
4455    #[inline]
4456    unsafe fn from_value(value: &'a glib::Value) -> Self {
4457        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4458    }
4459}
4460
4461impl ToValue for TlsCertificateRequestFlags {
4462    #[inline]
4463    fn to_value(&self) -> glib::Value {
4464        let mut value = glib::Value::for_value_type::<Self>();
4465        unsafe {
4466            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4467        }
4468        value
4469    }
4470
4471    #[inline]
4472    fn value_type(&self) -> glib::Type {
4473        Self::static_type()
4474    }
4475}
4476
4477impl From<TlsCertificateRequestFlags> for glib::Value {
4478    #[inline]
4479    fn from(v: TlsCertificateRequestFlags) -> Self {
4480        ToValue::to_value(&v)
4481    }
4482}
4483
4484/// An error code used with `G_TLS_CHANNEL_BINDING_ERROR` in a #GError to
4485/// indicate a TLS channel binding retrieval error.
4486#[cfg(feature = "v2_66")]
4487#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4488#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4489#[non_exhaustive]
4490#[doc(alias = "GTlsChannelBindingError")]
4491pub enum TlsChannelBindingError {
4492    /// Either entire binding
4493    ///    retrieval facility or specific binding type is not implemented in the
4494    ///    TLS backend.
4495    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED")]
4496    NotImplemented,
4497    /// The handshake is not yet
4498    ///    complete on the connection which is a strong requirement for any existing
4499    ///    binding type.
4500    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE")]
4501    InvalidState,
4502    /// Handshake is complete but
4503    ///    binding data is not available. That normally indicates the TLS
4504    ///    implementation failed to provide the binding data. For example, some
4505    ///    implementations do not provide a peer certificate for resumed connections.
4506    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE")]
4507    NotAvailable,
4508    /// Binding type is not supported
4509    ///    on the current connection. This error could be triggered when requesting
4510    ///    `tls-server-end-point` binding data for a certificate which has no hash
4511    ///    function or uses multiple hash functions.
4512    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED")]
4513    NotSupported,
4514    /// Any other backend error
4515    ///    preventing binding data retrieval.
4516    #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR")]
4517    GeneralError,
4518    #[doc(hidden)]
4519    __Unknown(i32),
4520}
4521
4522#[cfg(feature = "v2_66")]
4523#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4524#[doc(hidden)]
4525impl IntoGlib for TlsChannelBindingError {
4526    type GlibType = ffi::GTlsChannelBindingError;
4527
4528    #[inline]
4529    fn into_glib(self) -> ffi::GTlsChannelBindingError {
4530        match self {
4531            Self::NotImplemented => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED,
4532            Self::InvalidState => ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE,
4533            Self::NotAvailable => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE,
4534            Self::NotSupported => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED,
4535            Self::GeneralError => ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR,
4536            Self::__Unknown(value) => value,
4537        }
4538    }
4539}
4540
4541#[cfg(feature = "v2_66")]
4542#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4543#[doc(hidden)]
4544impl FromGlib<ffi::GTlsChannelBindingError> for TlsChannelBindingError {
4545    #[inline]
4546    unsafe fn from_glib(value: ffi::GTlsChannelBindingError) -> Self {
4547        match value {
4548            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
4549            ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE => Self::InvalidState,
4550            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE => Self::NotAvailable,
4551            ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED => Self::NotSupported,
4552            ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR => Self::GeneralError,
4553            value => Self::__Unknown(value),
4554        }
4555    }
4556}
4557
4558#[cfg(feature = "v2_66")]
4559#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4560impl glib::error::ErrorDomain for TlsChannelBindingError {
4561    #[inline]
4562    fn domain() -> glib::Quark {
4563        unsafe { from_glib(ffi::g_tls_channel_binding_error_quark()) }
4564    }
4565
4566    #[inline]
4567    fn code(self) -> i32 {
4568        self.into_glib()
4569    }
4570
4571    #[inline]
4572    #[allow(clippy::match_single_binding)]
4573    fn from(code: i32) -> Option<Self> {
4574        match unsafe { from_glib(code) } {
4575            value => Some(value),
4576        }
4577    }
4578}
4579
4580#[cfg(feature = "v2_66")]
4581#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4582impl StaticType for TlsChannelBindingError {
4583    #[inline]
4584    #[doc(alias = "g_tls_channel_binding_error_get_type")]
4585    fn static_type() -> glib::Type {
4586        unsafe { from_glib(ffi::g_tls_channel_binding_error_get_type()) }
4587    }
4588}
4589
4590#[cfg(feature = "v2_66")]
4591#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4592impl glib::HasParamSpec for TlsChannelBindingError {
4593    type ParamSpec = glib::ParamSpecEnum;
4594    type SetValue = Self;
4595    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4596
4597    fn param_spec_builder() -> Self::BuilderFn {
4598        Self::ParamSpec::builder_with_default
4599    }
4600}
4601
4602#[cfg(feature = "v2_66")]
4603#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4604impl glib::value::ValueType for TlsChannelBindingError {
4605    type Type = Self;
4606}
4607
4608#[cfg(feature = "v2_66")]
4609#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4610unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingError {
4611    type Checker = glib::value::GenericValueTypeChecker<Self>;
4612
4613    #[inline]
4614    unsafe fn from_value(value: &'a glib::Value) -> Self {
4615        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4616    }
4617}
4618
4619#[cfg(feature = "v2_66")]
4620#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4621impl ToValue for TlsChannelBindingError {
4622    #[inline]
4623    fn to_value(&self) -> glib::Value {
4624        let mut value = glib::Value::for_value_type::<Self>();
4625        unsafe {
4626            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4627        }
4628        value
4629    }
4630
4631    #[inline]
4632    fn value_type(&self) -> glib::Type {
4633        Self::static_type()
4634    }
4635}
4636
4637#[cfg(feature = "v2_66")]
4638#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4639impl From<TlsChannelBindingError> for glib::Value {
4640    #[inline]
4641    fn from(v: TlsChannelBindingError) -> Self {
4642        ToValue::to_value(&v)
4643    }
4644}
4645
4646/// The type of TLS channel binding data to retrieve from #GTlsConnection
4647/// or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The
4648/// [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5)
4649/// binding type is not currently implemented.
4650#[cfg(feature = "v2_66")]
4651#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4652#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4653#[non_exhaustive]
4654#[doc(alias = "GTlsChannelBindingType")]
4655pub enum TlsChannelBindingType {
4656    /// [`tls-unique`](https://tools.ietf.org/html/rfc5929#section-3) binding
4657    ///    type
4658    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_UNIQUE")]
4659    Unique,
4660    /// [`tls-server-end-point`](https://tools.ietf.org/html/rfc5929#section-4)
4661    ///    binding type
4662    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT")]
4663    ServerEndPoint,
4664    /// [`tls-exporter`](https://www.rfc-editor.org/rfc/rfc9266.html) binding
4665    ///    type. Since: 2.74
4666    #[cfg(feature = "v2_74")]
4667    #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
4668    #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_EXPORTER")]
4669    Exporter,
4670    #[doc(hidden)]
4671    __Unknown(i32),
4672}
4673
4674#[cfg(feature = "v2_66")]
4675#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4676#[doc(hidden)]
4677impl IntoGlib for TlsChannelBindingType {
4678    type GlibType = ffi::GTlsChannelBindingType;
4679
4680    #[inline]
4681    fn into_glib(self) -> ffi::GTlsChannelBindingType {
4682        match self {
4683            Self::Unique => ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE,
4684            Self::ServerEndPoint => ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT,
4685            #[cfg(feature = "v2_74")]
4686            Self::Exporter => ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER,
4687            Self::__Unknown(value) => value,
4688        }
4689    }
4690}
4691
4692#[cfg(feature = "v2_66")]
4693#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4694#[doc(hidden)]
4695impl FromGlib<ffi::GTlsChannelBindingType> for TlsChannelBindingType {
4696    #[inline]
4697    unsafe fn from_glib(value: ffi::GTlsChannelBindingType) -> Self {
4698        match value {
4699            ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE => Self::Unique,
4700            ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT => Self::ServerEndPoint,
4701            #[cfg(feature = "v2_74")]
4702            ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER => Self::Exporter,
4703            value => Self::__Unknown(value),
4704        }
4705    }
4706}
4707
4708#[cfg(feature = "v2_66")]
4709#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4710impl StaticType for TlsChannelBindingType {
4711    #[inline]
4712    #[doc(alias = "g_tls_channel_binding_type_get_type")]
4713    fn static_type() -> glib::Type {
4714        unsafe { from_glib(ffi::g_tls_channel_binding_type_get_type()) }
4715    }
4716}
4717
4718#[cfg(feature = "v2_66")]
4719#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4720impl glib::HasParamSpec for TlsChannelBindingType {
4721    type ParamSpec = glib::ParamSpecEnum;
4722    type SetValue = Self;
4723    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4724
4725    fn param_spec_builder() -> Self::BuilderFn {
4726        Self::ParamSpec::builder_with_default
4727    }
4728}
4729
4730#[cfg(feature = "v2_66")]
4731#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4732impl glib::value::ValueType for TlsChannelBindingType {
4733    type Type = Self;
4734}
4735
4736#[cfg(feature = "v2_66")]
4737#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4738unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingType {
4739    type Checker = glib::value::GenericValueTypeChecker<Self>;
4740
4741    #[inline]
4742    unsafe fn from_value(value: &'a glib::Value) -> Self {
4743        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4744    }
4745}
4746
4747#[cfg(feature = "v2_66")]
4748#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4749impl ToValue for TlsChannelBindingType {
4750    #[inline]
4751    fn to_value(&self) -> glib::Value {
4752        let mut value = glib::Value::for_value_type::<Self>();
4753        unsafe {
4754            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4755        }
4756        value
4757    }
4758
4759    #[inline]
4760    fn value_type(&self) -> glib::Type {
4761        Self::static_type()
4762    }
4763}
4764
4765#[cfg(feature = "v2_66")]
4766#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4767impl From<TlsChannelBindingType> for glib::Value {
4768    #[inline]
4769    fn from(v: TlsChannelBindingType) -> Self {
4770        ToValue::to_value(&v)
4771    }
4772}
4773
4774/// Flags for g_tls_database_lookup_certificate_for_handle(),
4775/// g_tls_database_lookup_certificate_issuer(),
4776/// and g_tls_database_lookup_certificates_issued_by().
4777#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4778#[non_exhaustive]
4779#[doc(alias = "GTlsDatabaseLookupFlags")]
4780pub enum TlsDatabaseLookupFlags {
4781    /// No lookup flags
4782    #[doc(alias = "G_TLS_DATABASE_LOOKUP_NONE")]
4783    None,
4784    /// Restrict lookup to certificates that have
4785    ///     a private key.
4786    #[doc(alias = "G_TLS_DATABASE_LOOKUP_KEYPAIR")]
4787    Keypair,
4788    #[doc(hidden)]
4789    __Unknown(i32),
4790}
4791
4792#[doc(hidden)]
4793impl IntoGlib for TlsDatabaseLookupFlags {
4794    type GlibType = ffi::GTlsDatabaseLookupFlags;
4795
4796    #[inline]
4797    fn into_glib(self) -> ffi::GTlsDatabaseLookupFlags {
4798        match self {
4799            Self::None => ffi::G_TLS_DATABASE_LOOKUP_NONE,
4800            Self::Keypair => ffi::G_TLS_DATABASE_LOOKUP_KEYPAIR,
4801            Self::__Unknown(value) => value,
4802        }
4803    }
4804}
4805
4806#[doc(hidden)]
4807impl FromGlib<ffi::GTlsDatabaseLookupFlags> for TlsDatabaseLookupFlags {
4808    #[inline]
4809    unsafe fn from_glib(value: ffi::GTlsDatabaseLookupFlags) -> Self {
4810        match value {
4811            ffi::G_TLS_DATABASE_LOOKUP_NONE => Self::None,
4812            ffi::G_TLS_DATABASE_LOOKUP_KEYPAIR => Self::Keypair,
4813            value => Self::__Unknown(value),
4814        }
4815    }
4816}
4817
4818impl StaticType for TlsDatabaseLookupFlags {
4819    #[inline]
4820    #[doc(alias = "g_tls_database_lookup_flags_get_type")]
4821    fn static_type() -> glib::Type {
4822        unsafe { from_glib(ffi::g_tls_database_lookup_flags_get_type()) }
4823    }
4824}
4825
4826impl glib::HasParamSpec for TlsDatabaseLookupFlags {
4827    type ParamSpec = glib::ParamSpecEnum;
4828    type SetValue = Self;
4829    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4830
4831    fn param_spec_builder() -> Self::BuilderFn {
4832        Self::ParamSpec::builder_with_default
4833    }
4834}
4835
4836impl glib::value::ValueType for TlsDatabaseLookupFlags {
4837    type Type = Self;
4838}
4839
4840unsafe impl<'a> glib::value::FromValue<'a> for TlsDatabaseLookupFlags {
4841    type Checker = glib::value::GenericValueTypeChecker<Self>;
4842
4843    #[inline]
4844    unsafe fn from_value(value: &'a glib::Value) -> Self {
4845        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4846    }
4847}
4848
4849impl ToValue for TlsDatabaseLookupFlags {
4850    #[inline]
4851    fn to_value(&self) -> glib::Value {
4852        let mut value = glib::Value::for_value_type::<Self>();
4853        unsafe {
4854            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4855        }
4856        value
4857    }
4858
4859    #[inline]
4860    fn value_type(&self) -> glib::Type {
4861        Self::static_type()
4862    }
4863}
4864
4865impl From<TlsDatabaseLookupFlags> for glib::Value {
4866    #[inline]
4867    fn from(v: TlsDatabaseLookupFlags) -> Self {
4868        ToValue::to_value(&v)
4869    }
4870}
4871
4872/// An error code used with `G_TLS_ERROR` in a #GError returned from a
4873/// TLS-related routine.
4874#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4875#[non_exhaustive]
4876#[doc(alias = "GTlsError")]
4877pub enum TlsError {
4878    /// No TLS provider is available
4879    #[doc(alias = "G_TLS_ERROR_UNAVAILABLE")]
4880    Unavailable,
4881    /// Miscellaneous TLS error
4882    #[doc(alias = "G_TLS_ERROR_MISC")]
4883    Misc,
4884    /// The certificate presented could not
4885    ///   be parsed or failed validation.
4886    #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE")]
4887    BadCertificate,
4888    /// The TLS handshake failed because the
4889    ///   peer does not seem to be a TLS server.
4890    #[doc(alias = "G_TLS_ERROR_NOT_TLS")]
4891    NotTls,
4892    /// The TLS handshake failed because the
4893    ///   peer's certificate was not acceptable.
4894    #[doc(alias = "G_TLS_ERROR_HANDSHAKE")]
4895    Handshake,
4896    /// The TLS handshake failed because
4897    ///   the server requested a client-side certificate, but none was
4898    ///   provided. See g_tls_connection_set_certificate().
4899    #[doc(alias = "G_TLS_ERROR_CERTIFICATE_REQUIRED")]
4900    CertificateRequired,
4901    /// The TLS connection was closed without proper
4902    ///   notice, which may indicate an attack. See
4903    ///   g_tls_connection_set_require_close_notify().
4904    #[doc(alias = "G_TLS_ERROR_EOF")]
4905    Eof,
4906    /// The TLS handshake failed
4907    ///   because the client sent the fallback SCSV, indicating a protocol
4908    ///   downgrade attack. Since: 2.60
4909    #[doc(alias = "G_TLS_ERROR_INAPPROPRIATE_FALLBACK")]
4910    InappropriateFallback,
4911    /// The certificate failed
4912    ///   to load because a password was incorrect. Since: 2.72
4913    #[cfg(feature = "v2_72")]
4914    #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
4915    #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD")]
4916    BadCertificatePassword,
4917    #[doc(hidden)]
4918    __Unknown(i32),
4919}
4920
4921#[doc(hidden)]
4922impl IntoGlib for TlsError {
4923    type GlibType = ffi::GTlsError;
4924
4925    #[inline]
4926    fn into_glib(self) -> ffi::GTlsError {
4927        match self {
4928            Self::Unavailable => ffi::G_TLS_ERROR_UNAVAILABLE,
4929            Self::Misc => ffi::G_TLS_ERROR_MISC,
4930            Self::BadCertificate => ffi::G_TLS_ERROR_BAD_CERTIFICATE,
4931            Self::NotTls => ffi::G_TLS_ERROR_NOT_TLS,
4932            Self::Handshake => ffi::G_TLS_ERROR_HANDSHAKE,
4933            Self::CertificateRequired => ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED,
4934            Self::Eof => ffi::G_TLS_ERROR_EOF,
4935            Self::InappropriateFallback => ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK,
4936            #[cfg(feature = "v2_72")]
4937            Self::BadCertificatePassword => ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD,
4938            Self::__Unknown(value) => value,
4939        }
4940    }
4941}
4942
4943#[doc(hidden)]
4944impl FromGlib<ffi::GTlsError> for TlsError {
4945    #[inline]
4946    unsafe fn from_glib(value: ffi::GTlsError) -> Self {
4947        match value {
4948            ffi::G_TLS_ERROR_UNAVAILABLE => Self::Unavailable,
4949            ffi::G_TLS_ERROR_MISC => Self::Misc,
4950            ffi::G_TLS_ERROR_BAD_CERTIFICATE => Self::BadCertificate,
4951            ffi::G_TLS_ERROR_NOT_TLS => Self::NotTls,
4952            ffi::G_TLS_ERROR_HANDSHAKE => Self::Handshake,
4953            ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED => Self::CertificateRequired,
4954            ffi::G_TLS_ERROR_EOF => Self::Eof,
4955            ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK => Self::InappropriateFallback,
4956            #[cfg(feature = "v2_72")]
4957            ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD => Self::BadCertificatePassword,
4958            value => Self::__Unknown(value),
4959        }
4960    }
4961}
4962
4963impl glib::error::ErrorDomain for TlsError {
4964    #[inline]
4965    fn domain() -> glib::Quark {
4966        unsafe { from_glib(ffi::g_tls_error_quark()) }
4967    }
4968
4969    #[inline]
4970    fn code(self) -> i32 {
4971        self.into_glib()
4972    }
4973
4974    #[inline]
4975    #[allow(clippy::match_single_binding)]
4976    fn from(code: i32) -> Option<Self> {
4977        match unsafe { from_glib(code) } {
4978            value => Some(value),
4979        }
4980    }
4981}
4982
4983impl StaticType for TlsError {
4984    #[inline]
4985    #[doc(alias = "g_tls_error_get_type")]
4986    fn static_type() -> glib::Type {
4987        unsafe { from_glib(ffi::g_tls_error_get_type()) }
4988    }
4989}
4990
4991impl glib::HasParamSpec for TlsError {
4992    type ParamSpec = glib::ParamSpecEnum;
4993    type SetValue = Self;
4994    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4995
4996    fn param_spec_builder() -> Self::BuilderFn {
4997        Self::ParamSpec::builder_with_default
4998    }
4999}
5000
5001impl glib::value::ValueType for TlsError {
5002    type Type = Self;
5003}
5004
5005unsafe impl<'a> glib::value::FromValue<'a> for TlsError {
5006    type Checker = glib::value::GenericValueTypeChecker<Self>;
5007
5008    #[inline]
5009    unsafe fn from_value(value: &'a glib::Value) -> Self {
5010        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5011    }
5012}
5013
5014impl ToValue for TlsError {
5015    #[inline]
5016    fn to_value(&self) -> glib::Value {
5017        let mut value = glib::Value::for_value_type::<Self>();
5018        unsafe {
5019            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5020        }
5021        value
5022    }
5023
5024    #[inline]
5025    fn value_type(&self) -> glib::Type {
5026        Self::static_type()
5027    }
5028}
5029
5030impl From<TlsError> for glib::Value {
5031    #[inline]
5032    fn from(v: TlsError) -> Self {
5033        ToValue::to_value(&v)
5034    }
5035}
5036
5037/// #GTlsInteractionResult is returned by various functions in #GTlsInteraction
5038/// when finishing an interaction request.
5039#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5040#[non_exhaustive]
5041#[doc(alias = "GTlsInteractionResult")]
5042pub enum TlsInteractionResult {
5043    /// The interaction was unhandled (i.e. not
5044    ///     implemented).
5045    #[doc(alias = "G_TLS_INTERACTION_UNHANDLED")]
5046    Unhandled,
5047    /// The interaction completed, and resulting data
5048    ///     is available.
5049    #[doc(alias = "G_TLS_INTERACTION_HANDLED")]
5050    Handled,
5051    /// The interaction has failed, or was cancelled.
5052    ///     and the operation should be aborted.
5053    #[doc(alias = "G_TLS_INTERACTION_FAILED")]
5054    Failed,
5055    #[doc(hidden)]
5056    __Unknown(i32),
5057}
5058
5059#[doc(hidden)]
5060impl IntoGlib for TlsInteractionResult {
5061    type GlibType = ffi::GTlsInteractionResult;
5062
5063    #[inline]
5064    fn into_glib(self) -> ffi::GTlsInteractionResult {
5065        match self {
5066            Self::Unhandled => ffi::G_TLS_INTERACTION_UNHANDLED,
5067            Self::Handled => ffi::G_TLS_INTERACTION_HANDLED,
5068            Self::Failed => ffi::G_TLS_INTERACTION_FAILED,
5069            Self::__Unknown(value) => value,
5070        }
5071    }
5072}
5073
5074#[doc(hidden)]
5075impl FromGlib<ffi::GTlsInteractionResult> for TlsInteractionResult {
5076    #[inline]
5077    unsafe fn from_glib(value: ffi::GTlsInteractionResult) -> Self {
5078        match value {
5079            ffi::G_TLS_INTERACTION_UNHANDLED => Self::Unhandled,
5080            ffi::G_TLS_INTERACTION_HANDLED => Self::Handled,
5081            ffi::G_TLS_INTERACTION_FAILED => Self::Failed,
5082            value => Self::__Unknown(value),
5083        }
5084    }
5085}
5086
5087impl StaticType for TlsInteractionResult {
5088    #[inline]
5089    #[doc(alias = "g_tls_interaction_result_get_type")]
5090    fn static_type() -> glib::Type {
5091        unsafe { from_glib(ffi::g_tls_interaction_result_get_type()) }
5092    }
5093}
5094
5095impl glib::HasParamSpec for TlsInteractionResult {
5096    type ParamSpec = glib::ParamSpecEnum;
5097    type SetValue = Self;
5098    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5099
5100    fn param_spec_builder() -> Self::BuilderFn {
5101        Self::ParamSpec::builder_with_default
5102    }
5103}
5104
5105impl glib::value::ValueType for TlsInteractionResult {
5106    type Type = Self;
5107}
5108
5109unsafe impl<'a> glib::value::FromValue<'a> for TlsInteractionResult {
5110    type Checker = glib::value::GenericValueTypeChecker<Self>;
5111
5112    #[inline]
5113    unsafe fn from_value(value: &'a glib::Value) -> Self {
5114        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5115    }
5116}
5117
5118impl ToValue for TlsInteractionResult {
5119    #[inline]
5120    fn to_value(&self) -> glib::Value {
5121        let mut value = glib::Value::for_value_type::<Self>();
5122        unsafe {
5123            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5124        }
5125        value
5126    }
5127
5128    #[inline]
5129    fn value_type(&self) -> glib::Type {
5130        Self::static_type()
5131    }
5132}
5133
5134impl From<TlsInteractionResult> for glib::Value {
5135    #[inline]
5136    fn from(v: TlsInteractionResult) -> Self {
5137        ToValue::to_value(&v)
5138    }
5139}
5140
5141/// The TLS or DTLS protocol version used by a #GTlsConnection or
5142/// #GDtlsConnection. The integer values of these versions are sequential
5143/// to ensure newer known protocol versions compare greater than older
5144/// known versions. Any known DTLS protocol version will compare greater
5145/// than any SSL or TLS protocol version. The protocol version may be
5146/// [`Unknown`][Self::Unknown] if the TLS backend supports a newer
5147/// protocol version that GLib does not yet know about. This means that
5148/// it's possible for an unknown DTLS protocol version to compare less
5149/// than the TLS protocol versions.
5150#[cfg(feature = "v2_70")]
5151#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5152#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5153#[non_exhaustive]
5154#[doc(alias = "GTlsProtocolVersion")]
5155pub enum TlsProtocolVersion {
5156    /// No protocol version or unknown protocol version
5157    #[doc(alias = "G_TLS_PROTOCOL_VERSION_UNKNOWN")]
5158    Unknown,
5159    /// SSL 3.0, which is insecure and should not be used
5160    #[doc(alias = "G_TLS_PROTOCOL_VERSION_SSL_3_0")]
5161    Ssl30,
5162    /// TLS 1.0, which is insecure and should not be used
5163    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_0")]
5164    Tls10,
5165    /// TLS 1.1, which is insecure and should not be used
5166    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_1")]
5167    Tls11,
5168    /// TLS 1.2, defined by [RFC 5246](https://datatracker.ietf.org/doc/html/rfc5246)
5169    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_2")]
5170    Tls12,
5171    /// TLS 1.3, defined by [RFC 8446](https://datatracker.ietf.org/doc/html/rfc8446)
5172    #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_3")]
5173    Tls13,
5174    /// DTLS 1.0, which is insecure and should not be used
5175    #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_0")]
5176    Dtls10,
5177    /// DTLS 1.2, defined by [RFC 6347](https://datatracker.ietf.org/doc/html/rfc6347)
5178    #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_2")]
5179    Dtls12,
5180    #[doc(hidden)]
5181    __Unknown(i32),
5182}
5183
5184#[cfg(feature = "v2_70")]
5185#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5186#[doc(hidden)]
5187impl IntoGlib for TlsProtocolVersion {
5188    type GlibType = ffi::GTlsProtocolVersion;
5189
5190    #[inline]
5191    fn into_glib(self) -> ffi::GTlsProtocolVersion {
5192        match self {
5193            Self::Unknown => ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN,
5194            Self::Ssl30 => ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0,
5195            Self::Tls10 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0,
5196            Self::Tls11 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1,
5197            Self::Tls12 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2,
5198            Self::Tls13 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3,
5199            Self::Dtls10 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0,
5200            Self::Dtls12 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2,
5201            Self::__Unknown(value) => value,
5202        }
5203    }
5204}
5205
5206#[cfg(feature = "v2_70")]
5207#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5208#[doc(hidden)]
5209impl FromGlib<ffi::GTlsProtocolVersion> for TlsProtocolVersion {
5210    #[inline]
5211    unsafe fn from_glib(value: ffi::GTlsProtocolVersion) -> Self {
5212        match value {
5213            ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN => Self::Unknown,
5214            ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0 => Self::Ssl30,
5215            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0 => Self::Tls10,
5216            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1 => Self::Tls11,
5217            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2 => Self::Tls12,
5218            ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3 => Self::Tls13,
5219            ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0 => Self::Dtls10,
5220            ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2 => Self::Dtls12,
5221            value => Self::__Unknown(value),
5222        }
5223    }
5224}
5225
5226#[cfg(feature = "v2_70")]
5227#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5228impl StaticType for TlsProtocolVersion {
5229    #[inline]
5230    #[doc(alias = "g_tls_protocol_version_get_type")]
5231    fn static_type() -> glib::Type {
5232        unsafe { from_glib(ffi::g_tls_protocol_version_get_type()) }
5233    }
5234}
5235
5236#[cfg(feature = "v2_70")]
5237#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5238impl glib::HasParamSpec for TlsProtocolVersion {
5239    type ParamSpec = glib::ParamSpecEnum;
5240    type SetValue = Self;
5241    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5242
5243    fn param_spec_builder() -> Self::BuilderFn {
5244        Self::ParamSpec::builder_with_default
5245    }
5246}
5247
5248#[cfg(feature = "v2_70")]
5249#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5250impl glib::value::ValueType for TlsProtocolVersion {
5251    type Type = Self;
5252}
5253
5254#[cfg(feature = "v2_70")]
5255#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5256unsafe impl<'a> glib::value::FromValue<'a> for TlsProtocolVersion {
5257    type Checker = glib::value::GenericValueTypeChecker<Self>;
5258
5259    #[inline]
5260    unsafe fn from_value(value: &'a glib::Value) -> Self {
5261        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5262    }
5263}
5264
5265#[cfg(feature = "v2_70")]
5266#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5267impl ToValue for TlsProtocolVersion {
5268    #[inline]
5269    fn to_value(&self) -> glib::Value {
5270        let mut value = glib::Value::for_value_type::<Self>();
5271        unsafe {
5272            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5273        }
5274        value
5275    }
5276
5277    #[inline]
5278    fn value_type(&self) -> glib::Type {
5279        Self::static_type()
5280    }
5281}
5282
5283#[cfg(feature = "v2_70")]
5284#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5285impl From<TlsProtocolVersion> for glib::Value {
5286    #[inline]
5287    fn from(v: TlsProtocolVersion) -> Self {
5288        ToValue::to_value(&v)
5289    }
5290}
5291
5292/// When to allow rehandshaking. See
5293/// g_tls_connection_set_rehandshake_mode().
5294///
5295/// # Deprecated since 2.60
5296///
5297/// Changing the rehandshake mode is no longer
5298///   required for compatibility. Also, rehandshaking has been removed
5299///   from the TLS protocol in TLS 1.3.
5300#[cfg_attr(feature = "v2_60", deprecated = "Since 2.60")]
5301#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5302#[non_exhaustive]
5303#[doc(alias = "GTlsRehandshakeMode")]
5304pub enum TlsRehandshakeMode {
5305    /// Never allow rehandshaking
5306    #[doc(alias = "G_TLS_REHANDSHAKE_NEVER")]
5307    Never,
5308    /// Allow safe rehandshaking only
5309    #[doc(alias = "G_TLS_REHANDSHAKE_SAFELY")]
5310    Safely,
5311    /// Allow unsafe rehandshaking
5312    #[doc(alias = "G_TLS_REHANDSHAKE_UNSAFELY")]
5313    Unsafely,
5314    #[doc(hidden)]
5315    __Unknown(i32),
5316}
5317
5318#[allow(deprecated)]
5319#[doc(hidden)]
5320impl IntoGlib for TlsRehandshakeMode {
5321    type GlibType = ffi::GTlsRehandshakeMode;
5322
5323    #[inline]
5324    fn into_glib(self) -> ffi::GTlsRehandshakeMode {
5325        match self {
5326            Self::Never => ffi::G_TLS_REHANDSHAKE_NEVER,
5327            Self::Safely => ffi::G_TLS_REHANDSHAKE_SAFELY,
5328            Self::Unsafely => ffi::G_TLS_REHANDSHAKE_UNSAFELY,
5329            Self::__Unknown(value) => value,
5330        }
5331    }
5332}
5333
5334#[allow(deprecated)]
5335#[doc(hidden)]
5336impl FromGlib<ffi::GTlsRehandshakeMode> for TlsRehandshakeMode {
5337    #[inline]
5338    unsafe fn from_glib(value: ffi::GTlsRehandshakeMode) -> Self {
5339        match value {
5340            ffi::G_TLS_REHANDSHAKE_NEVER => Self::Never,
5341            ffi::G_TLS_REHANDSHAKE_SAFELY => Self::Safely,
5342            ffi::G_TLS_REHANDSHAKE_UNSAFELY => Self::Unsafely,
5343            value => Self::__Unknown(value),
5344        }
5345    }
5346}
5347
5348#[allow(deprecated)]
5349impl StaticType for TlsRehandshakeMode {
5350    #[inline]
5351    #[doc(alias = "g_tls_rehandshake_mode_get_type")]
5352    fn static_type() -> glib::Type {
5353        unsafe { from_glib(ffi::g_tls_rehandshake_mode_get_type()) }
5354    }
5355}
5356
5357#[allow(deprecated)]
5358impl glib::HasParamSpec for TlsRehandshakeMode {
5359    type ParamSpec = glib::ParamSpecEnum;
5360    type SetValue = Self;
5361    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5362
5363    fn param_spec_builder() -> Self::BuilderFn {
5364        Self::ParamSpec::builder_with_default
5365    }
5366}
5367
5368#[allow(deprecated)]
5369impl glib::value::ValueType for TlsRehandshakeMode {
5370    type Type = Self;
5371}
5372
5373#[allow(deprecated)]
5374unsafe impl<'a> glib::value::FromValue<'a> for TlsRehandshakeMode {
5375    type Checker = glib::value::GenericValueTypeChecker<Self>;
5376
5377    #[inline]
5378    unsafe fn from_value(value: &'a glib::Value) -> Self {
5379        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5380    }
5381}
5382
5383#[allow(deprecated)]
5384impl ToValue for TlsRehandshakeMode {
5385    #[inline]
5386    fn to_value(&self) -> glib::Value {
5387        let mut value = glib::Value::for_value_type::<Self>();
5388        unsafe {
5389            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5390        }
5391        value
5392    }
5393
5394    #[inline]
5395    fn value_type(&self) -> glib::Type {
5396        Self::static_type()
5397    }
5398}
5399
5400#[allow(deprecated)]
5401impl From<TlsRehandshakeMode> for glib::Value {
5402    #[inline]
5403    fn from(v: TlsRehandshakeMode) -> Self {
5404        ToValue::to_value(&v)
5405    }
5406}
5407
5408/// The type of name used by a #GUnixSocketAddress.
5409/// [`Path`][Self::Path] indicates a traditional unix domain
5410/// socket bound to a filesystem path. [`Anonymous`][Self::Anonymous]
5411/// indicates a socket not bound to any name (eg, a client-side socket,
5412/// or a socket created with socketpair()).
5413///
5414/// For abstract sockets, there are two incompatible ways of naming
5415/// them; the man pages suggest using the entire `struct sockaddr_un`
5416/// as the name, padding the unused parts of the `sun_path` field with
5417/// zeroes; this corresponds to [`AbstractPadded`][Self::AbstractPadded].
5418/// However, many programs instead just use a portion of `sun_path`, and
5419/// pass an appropriate smaller length to bind() or connect(). This is
5420/// [`Abstract`][Self::Abstract].
5421#[cfg(unix)]
5422#[cfg_attr(docsrs, doc(cfg(unix)))]
5423#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5424#[non_exhaustive]
5425#[doc(alias = "GUnixSocketAddressType")]
5426pub enum UnixSocketAddressType {
5427    /// invalid
5428    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_INVALID")]
5429    Invalid,
5430    /// anonymous
5431    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ANONYMOUS")]
5432    Anonymous,
5433    /// a filesystem path
5434    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_PATH")]
5435    Path,
5436    /// an abstract name
5437    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT")]
5438    Abstract,
5439    /// an abstract name, 0-padded
5440    ///   to the full length of a unix socket name
5441    #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED")]
5442    AbstractPadded,
5443    #[doc(hidden)]
5444    __Unknown(i32),
5445}
5446
5447#[cfg(unix)]
5448#[doc(hidden)]
5449impl IntoGlib for UnixSocketAddressType {
5450    type GlibType = ffi::GUnixSocketAddressType;
5451
5452    #[inline]
5453    fn into_glib(self) -> ffi::GUnixSocketAddressType {
5454        match self {
5455            Self::Invalid => ffi::G_UNIX_SOCKET_ADDRESS_INVALID,
5456            Self::Anonymous => ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS,
5457            Self::Path => ffi::G_UNIX_SOCKET_ADDRESS_PATH,
5458            Self::Abstract => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT,
5459            Self::AbstractPadded => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED,
5460            Self::__Unknown(value) => value,
5461        }
5462    }
5463}
5464
5465#[cfg(unix)]
5466#[doc(hidden)]
5467impl FromGlib<ffi::GUnixSocketAddressType> for UnixSocketAddressType {
5468    #[inline]
5469    unsafe fn from_glib(value: ffi::GUnixSocketAddressType) -> Self {
5470        match value {
5471            ffi::G_UNIX_SOCKET_ADDRESS_INVALID => Self::Invalid,
5472            ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS => Self::Anonymous,
5473            ffi::G_UNIX_SOCKET_ADDRESS_PATH => Self::Path,
5474            ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT => Self::Abstract,
5475            ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED => Self::AbstractPadded,
5476            value => Self::__Unknown(value),
5477        }
5478    }
5479}
5480
5481#[cfg(unix)]
5482impl StaticType for UnixSocketAddressType {
5483    #[inline]
5484    #[doc(alias = "g_unix_socket_address_type_get_type")]
5485    fn static_type() -> glib::Type {
5486        unsafe { from_glib(ffi::g_unix_socket_address_type_get_type()) }
5487    }
5488}
5489
5490#[cfg(unix)]
5491impl glib::HasParamSpec for UnixSocketAddressType {
5492    type ParamSpec = glib::ParamSpecEnum;
5493    type SetValue = Self;
5494    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5495
5496    fn param_spec_builder() -> Self::BuilderFn {
5497        Self::ParamSpec::builder_with_default
5498    }
5499}
5500
5501#[cfg(unix)]
5502impl glib::value::ValueType for UnixSocketAddressType {
5503    type Type = Self;
5504}
5505
5506#[cfg(unix)]
5507unsafe impl<'a> glib::value::FromValue<'a> for UnixSocketAddressType {
5508    type Checker = glib::value::GenericValueTypeChecker<Self>;
5509
5510    #[inline]
5511    unsafe fn from_value(value: &'a glib::Value) -> Self {
5512        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5513    }
5514}
5515
5516#[cfg(unix)]
5517impl ToValue for UnixSocketAddressType {
5518    #[inline]
5519    fn to_value(&self) -> glib::Value {
5520        let mut value = glib::Value::for_value_type::<Self>();
5521        unsafe {
5522            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5523        }
5524        value
5525    }
5526
5527    #[inline]
5528    fn value_type(&self) -> glib::Type {
5529        Self::static_type()
5530    }
5531}
5532
5533#[cfg(unix)]
5534impl From<UnixSocketAddressType> for glib::Value {
5535    #[inline]
5536    fn from(v: UnixSocketAddressType) -> Self {
5537        ToValue::to_value(&v)
5538    }
5539}
5540
5541/// Used to select the type of data format to use for #GZlibDecompressor
5542/// and #GZlibCompressor.
5543#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5544#[non_exhaustive]
5545#[doc(alias = "GZlibCompressorFormat")]
5546pub enum ZlibCompressorFormat {
5547    /// deflate compression with zlib header
5548    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_ZLIB")]
5549    Zlib,
5550    /// gzip file format
5551    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_GZIP")]
5552    Gzip,
5553    /// deflate compression with no header
5554    #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_RAW")]
5555    Raw,
5556    #[doc(hidden)]
5557    __Unknown(i32),
5558}
5559
5560#[doc(hidden)]
5561impl IntoGlib for ZlibCompressorFormat {
5562    type GlibType = ffi::GZlibCompressorFormat;
5563
5564    #[inline]
5565    fn into_glib(self) -> ffi::GZlibCompressorFormat {
5566        match self {
5567            Self::Zlib => ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB,
5568            Self::Gzip => ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP,
5569            Self::Raw => ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW,
5570            Self::__Unknown(value) => value,
5571        }
5572    }
5573}
5574
5575#[doc(hidden)]
5576impl FromGlib<ffi::GZlibCompressorFormat> for ZlibCompressorFormat {
5577    #[inline]
5578    unsafe fn from_glib(value: ffi::GZlibCompressorFormat) -> Self {
5579        match value {
5580            ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB => Self::Zlib,
5581            ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP => Self::Gzip,
5582            ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW => Self::Raw,
5583            value => Self::__Unknown(value),
5584        }
5585    }
5586}
5587
5588impl StaticType for ZlibCompressorFormat {
5589    #[inline]
5590    #[doc(alias = "g_zlib_compressor_format_get_type")]
5591    fn static_type() -> glib::Type {
5592        unsafe { from_glib(ffi::g_zlib_compressor_format_get_type()) }
5593    }
5594}
5595
5596impl glib::HasParamSpec for ZlibCompressorFormat {
5597    type ParamSpec = glib::ParamSpecEnum;
5598    type SetValue = Self;
5599    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5600
5601    fn param_spec_builder() -> Self::BuilderFn {
5602        Self::ParamSpec::builder_with_default
5603    }
5604}
5605
5606impl glib::value::ValueType for ZlibCompressorFormat {
5607    type Type = Self;
5608}
5609
5610unsafe impl<'a> glib::value::FromValue<'a> for ZlibCompressorFormat {
5611    type Checker = glib::value::GenericValueTypeChecker<Self>;
5612
5613    #[inline]
5614    unsafe fn from_value(value: &'a glib::Value) -> Self {
5615        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5616    }
5617}
5618
5619impl ToValue for ZlibCompressorFormat {
5620    #[inline]
5621    fn to_value(&self) -> glib::Value {
5622        let mut value = glib::Value::for_value_type::<Self>();
5623        unsafe {
5624            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5625        }
5626        value
5627    }
5628
5629    #[inline]
5630    fn value_type(&self) -> glib::Type {
5631        Self::static_type()
5632    }
5633}
5634
5635impl From<ZlibCompressorFormat> for glib::Value {
5636    #[inline]
5637    fn from(v: ZlibCompressorFormat) -> Self {
5638        ToValue::to_value(&v)
5639    }
5640}