gio/auto/
flags.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::{bitflags::bitflags, prelude::*, translate::*};
7
8bitflags! {
9    /// Flags used when creating a #GAppInfo.
10    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
11    #[doc(alias = "GAppInfoCreateFlags")]
12    pub struct AppInfoCreateFlags: u32 {
13        /// No flags.
14        #[doc(alias = "G_APP_INFO_CREATE_NONE")]
15        const NONE = ffi::G_APP_INFO_CREATE_NONE as _;
16        /// Application opens in a terminal window.
17        #[doc(alias = "G_APP_INFO_CREATE_NEEDS_TERMINAL")]
18        const NEEDS_TERMINAL = ffi::G_APP_INFO_CREATE_NEEDS_TERMINAL as _;
19        /// Application supports URI arguments.
20        #[doc(alias = "G_APP_INFO_CREATE_SUPPORTS_URIS")]
21        const SUPPORTS_URIS = ffi::G_APP_INFO_CREATE_SUPPORTS_URIS as _;
22        /// Application supports startup notification. Since 2.26
23        #[doc(alias = "G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION")]
24        const SUPPORTS_STARTUP_NOTIFICATION = ffi::G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION as _;
25    }
26}
27
28#[doc(hidden)]
29impl IntoGlib for AppInfoCreateFlags {
30    type GlibType = ffi::GAppInfoCreateFlags;
31
32    #[inline]
33    fn into_glib(self) -> ffi::GAppInfoCreateFlags {
34        self.bits()
35    }
36}
37
38#[doc(hidden)]
39impl FromGlib<ffi::GAppInfoCreateFlags> for AppInfoCreateFlags {
40    #[inline]
41    unsafe fn from_glib(value: ffi::GAppInfoCreateFlags) -> Self {
42        Self::from_bits_truncate(value)
43    }
44}
45
46impl StaticType for AppInfoCreateFlags {
47    #[inline]
48    #[doc(alias = "g_app_info_create_flags_get_type")]
49    fn static_type() -> glib::Type {
50        unsafe { from_glib(ffi::g_app_info_create_flags_get_type()) }
51    }
52}
53
54impl glib::HasParamSpec for AppInfoCreateFlags {
55    type ParamSpec = glib::ParamSpecFlags;
56    type SetValue = Self;
57    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
58
59    fn param_spec_builder() -> Self::BuilderFn {
60        Self::ParamSpec::builder
61    }
62}
63
64impl glib::value::ValueType for AppInfoCreateFlags {
65    type Type = Self;
66}
67
68unsafe impl<'a> glib::value::FromValue<'a> for AppInfoCreateFlags {
69    type Checker = glib::value::GenericValueTypeChecker<Self>;
70
71    #[inline]
72    unsafe fn from_value(value: &'a glib::Value) -> Self {
73        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
74    }
75}
76
77impl ToValue for AppInfoCreateFlags {
78    #[inline]
79    fn to_value(&self) -> glib::Value {
80        let mut value = glib::Value::for_value_type::<Self>();
81        unsafe {
82            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
83        }
84        value
85    }
86
87    #[inline]
88    fn value_type(&self) -> glib::Type {
89        Self::static_type()
90    }
91}
92
93impl From<AppInfoCreateFlags> for glib::Value {
94    #[inline]
95    fn from(v: AppInfoCreateFlags) -> Self {
96        ToValue::to_value(&v)
97    }
98}
99
100bitflags! {
101    /// Flags used to define the behaviour of a #GApplication.
102    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
103    #[doc(alias = "GApplicationFlags")]
104    pub struct ApplicationFlags: u32 {
105        /// Default flags.
106        /// Use [flags@Gio.ApplicationFlags.DEFAULT_FLAGS].
107        #[cfg_attr(feature = "v2_74", deprecated = "Since 2.74")]
108        #[doc(alias = "G_APPLICATION_FLAGS_NONE")]
109        const FLAGS_NONE = ffi::G_APPLICATION_FLAGS_NONE as _;
110        /// Run as a service. In this mode, registration
111        ///      fails if the service is already running, and the application
112        ///      will initially wait up to 10 seconds for an initial activation
113        ///      message to arrive.
114        #[doc(alias = "G_APPLICATION_IS_SERVICE")]
115        const IS_SERVICE = ffi::G_APPLICATION_IS_SERVICE as _;
116        /// Don't try to become the primary instance.
117        #[doc(alias = "G_APPLICATION_IS_LAUNCHER")]
118        const IS_LAUNCHER = ffi::G_APPLICATION_IS_LAUNCHER as _;
119        /// This application handles opening files (in
120        ///     the primary instance). Note that this flag only affects the default
121        ///     implementation of local_command_line(), and has no effect if
122        ///     [`HANDLES_COMMAND_LINE`][Self::HANDLES_COMMAND_LINE] is given.
123        ///     See g_application_run() for details.
124        #[doc(alias = "G_APPLICATION_HANDLES_OPEN")]
125        const HANDLES_OPEN = ffi::G_APPLICATION_HANDLES_OPEN as _;
126        /// This application handles command line
127        ///     arguments (in the primary instance). Note that this flag only affect
128        ///     the default implementation of local_command_line().
129        ///     See g_application_run() for details.
130        #[doc(alias = "G_APPLICATION_HANDLES_COMMAND_LINE")]
131        const HANDLES_COMMAND_LINE = ffi::G_APPLICATION_HANDLES_COMMAND_LINE as _;
132        /// Send the environment of the
133        ///     launching process to the primary instance. Set this flag if your
134        ///     application is expected to behave differently depending on certain
135        ///     environment variables. For instance, an editor might be expected
136        ///     to use the `GIT_COMMITTER_NAME` environment variable
137        ///     when editing a git commit message. The environment is available
138        ///     to the #GApplication::command-line signal handler, via
139        ///     g_application_command_line_getenv().
140        #[doc(alias = "G_APPLICATION_SEND_ENVIRONMENT")]
141        const SEND_ENVIRONMENT = ffi::G_APPLICATION_SEND_ENVIRONMENT as _;
142        /// Make no attempts to do any of the typical
143        ///     single-instance application negotiation, even if the application
144        ///     ID is given.  The application neither attempts to become the
145        ///     owner of the application ID nor does it check if an existing
146        ///     owner already exists.  Everything occurs in the local process.
147        ///     Since: 2.30.
148        #[doc(alias = "G_APPLICATION_NON_UNIQUE")]
149        const NON_UNIQUE = ffi::G_APPLICATION_NON_UNIQUE as _;
150        /// Allow users to override the
151        ///     application ID from the command line with `--gapplication-app-id`.
152        ///     Since: 2.48
153        #[doc(alias = "G_APPLICATION_CAN_OVERRIDE_APP_ID")]
154        const CAN_OVERRIDE_APP_ID = ffi::G_APPLICATION_CAN_OVERRIDE_APP_ID as _;
155        /// Allow another instance to take over
156        ///     the bus name. Since: 2.60
157        #[doc(alias = "G_APPLICATION_ALLOW_REPLACEMENT")]
158        const ALLOW_REPLACEMENT = ffi::G_APPLICATION_ALLOW_REPLACEMENT as _;
159        /// Take over from another instance. This flag is
160        ///     usually set by passing `--gapplication-replace` on the commandline.
161        ///     Since: 2.60
162        #[doc(alias = "G_APPLICATION_REPLACE")]
163        const REPLACE = ffi::G_APPLICATION_REPLACE as _;
164    }
165}
166
167#[doc(hidden)]
168impl IntoGlib for ApplicationFlags {
169    type GlibType = ffi::GApplicationFlags;
170
171    #[inline]
172    fn into_glib(self) -> ffi::GApplicationFlags {
173        self.bits()
174    }
175}
176
177#[doc(hidden)]
178impl FromGlib<ffi::GApplicationFlags> for ApplicationFlags {
179    #[inline]
180    unsafe fn from_glib(value: ffi::GApplicationFlags) -> Self {
181        Self::from_bits_truncate(value)
182    }
183}
184
185impl StaticType for ApplicationFlags {
186    #[inline]
187    #[doc(alias = "g_application_flags_get_type")]
188    fn static_type() -> glib::Type {
189        unsafe { from_glib(ffi::g_application_flags_get_type()) }
190    }
191}
192
193impl glib::HasParamSpec for ApplicationFlags {
194    type ParamSpec = glib::ParamSpecFlags;
195    type SetValue = Self;
196    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
197
198    fn param_spec_builder() -> Self::BuilderFn {
199        Self::ParamSpec::builder
200    }
201}
202
203impl glib::value::ValueType for ApplicationFlags {
204    type Type = Self;
205}
206
207unsafe impl<'a> glib::value::FromValue<'a> for ApplicationFlags {
208    type Checker = glib::value::GenericValueTypeChecker<Self>;
209
210    #[inline]
211    unsafe fn from_value(value: &'a glib::Value) -> Self {
212        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
213    }
214}
215
216impl ToValue for ApplicationFlags {
217    #[inline]
218    fn to_value(&self) -> glib::Value {
219        let mut value = glib::Value::for_value_type::<Self>();
220        unsafe {
221            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
222        }
223        value
224    }
225
226    #[inline]
227    fn value_type(&self) -> glib::Type {
228        Self::static_type()
229    }
230}
231
232impl From<ApplicationFlags> for glib::Value {
233    #[inline]
234    fn from(v: ApplicationFlags) -> Self {
235        ToValue::to_value(&v)
236    }
237}
238
239bitflags! {
240    /// #GAskPasswordFlags are used to request specific information from the
241    /// user, or to notify the user of their choices in an authentication
242    /// situation.
243    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
244    #[doc(alias = "GAskPasswordFlags")]
245    pub struct AskPasswordFlags: u32 {
246        /// operation requires a password.
247        #[doc(alias = "G_ASK_PASSWORD_NEED_PASSWORD")]
248        const NEED_PASSWORD = ffi::G_ASK_PASSWORD_NEED_PASSWORD as _;
249        /// operation requires a username.
250        #[doc(alias = "G_ASK_PASSWORD_NEED_USERNAME")]
251        const NEED_USERNAME = ffi::G_ASK_PASSWORD_NEED_USERNAME as _;
252        /// operation requires a domain.
253        #[doc(alias = "G_ASK_PASSWORD_NEED_DOMAIN")]
254        const NEED_DOMAIN = ffi::G_ASK_PASSWORD_NEED_DOMAIN as _;
255        /// operation supports saving settings.
256        #[doc(alias = "G_ASK_PASSWORD_SAVING_SUPPORTED")]
257        const SAVING_SUPPORTED = ffi::G_ASK_PASSWORD_SAVING_SUPPORTED as _;
258        /// operation supports anonymous users.
259        #[doc(alias = "G_ASK_PASSWORD_ANONYMOUS_SUPPORTED")]
260        const ANONYMOUS_SUPPORTED = ffi::G_ASK_PASSWORD_ANONYMOUS_SUPPORTED as _;
261        /// operation takes TCRYPT parameters (Since: 2.58)
262        #[doc(alias = "G_ASK_PASSWORD_TCRYPT")]
263        const TCRYPT = ffi::G_ASK_PASSWORD_TCRYPT as _;
264    }
265}
266
267#[doc(hidden)]
268impl IntoGlib for AskPasswordFlags {
269    type GlibType = ffi::GAskPasswordFlags;
270
271    #[inline]
272    fn into_glib(self) -> ffi::GAskPasswordFlags {
273        self.bits()
274    }
275}
276
277#[doc(hidden)]
278impl FromGlib<ffi::GAskPasswordFlags> for AskPasswordFlags {
279    #[inline]
280    unsafe fn from_glib(value: ffi::GAskPasswordFlags) -> Self {
281        Self::from_bits_truncate(value)
282    }
283}
284
285impl StaticType for AskPasswordFlags {
286    #[inline]
287    #[doc(alias = "g_ask_password_flags_get_type")]
288    fn static_type() -> glib::Type {
289        unsafe { from_glib(ffi::g_ask_password_flags_get_type()) }
290    }
291}
292
293impl glib::HasParamSpec for AskPasswordFlags {
294    type ParamSpec = glib::ParamSpecFlags;
295    type SetValue = Self;
296    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
297
298    fn param_spec_builder() -> Self::BuilderFn {
299        Self::ParamSpec::builder
300    }
301}
302
303impl glib::value::ValueType for AskPasswordFlags {
304    type Type = Self;
305}
306
307unsafe impl<'a> glib::value::FromValue<'a> for AskPasswordFlags {
308    type Checker = glib::value::GenericValueTypeChecker<Self>;
309
310    #[inline]
311    unsafe fn from_value(value: &'a glib::Value) -> Self {
312        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
313    }
314}
315
316impl ToValue for AskPasswordFlags {
317    #[inline]
318    fn to_value(&self) -> glib::Value {
319        let mut value = glib::Value::for_value_type::<Self>();
320        unsafe {
321            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
322        }
323        value
324    }
325
326    #[inline]
327    fn value_type(&self) -> glib::Type {
328        Self::static_type()
329    }
330}
331
332impl From<AskPasswordFlags> for glib::Value {
333    #[inline]
334    fn from(v: AskPasswordFlags) -> Self {
335        ToValue::to_value(&v)
336    }
337}
338
339bitflags! {
340    /// Flags used in g_bus_own_name().
341    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
342    #[doc(alias = "GBusNameOwnerFlags")]
343    pub struct BusNameOwnerFlags: u32 {
344        /// No flags set.
345        #[doc(alias = "G_BUS_NAME_OWNER_FLAGS_NONE")]
346        const NONE = ffi::G_BUS_NAME_OWNER_FLAGS_NONE as _;
347        /// Allow another message bus connection to claim the name.
348        #[doc(alias = "G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT")]
349        const ALLOW_REPLACEMENT = ffi::G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT as _;
350        /// If another message bus connection owns the name and have
351        /// specified [`ALLOW_REPLACEMENT`][Self::ALLOW_REPLACEMENT], then take the name from the other connection.
352        #[doc(alias = "G_BUS_NAME_OWNER_FLAGS_REPLACE")]
353        const REPLACE = ffi::G_BUS_NAME_OWNER_FLAGS_REPLACE as _;
354        /// If another message bus connection owns the name, immediately
355        /// return an error from g_bus_own_name() rather than entering the waiting queue for that name. (Since 2.54)
356        #[doc(alias = "G_BUS_NAME_OWNER_FLAGS_DO_NOT_QUEUE")]
357        const DO_NOT_QUEUE = ffi::G_BUS_NAME_OWNER_FLAGS_DO_NOT_QUEUE as _;
358    }
359}
360
361#[doc(hidden)]
362impl IntoGlib for BusNameOwnerFlags {
363    type GlibType = ffi::GBusNameOwnerFlags;
364
365    #[inline]
366    fn into_glib(self) -> ffi::GBusNameOwnerFlags {
367        self.bits()
368    }
369}
370
371#[doc(hidden)]
372impl FromGlib<ffi::GBusNameOwnerFlags> for BusNameOwnerFlags {
373    #[inline]
374    unsafe fn from_glib(value: ffi::GBusNameOwnerFlags) -> Self {
375        Self::from_bits_truncate(value)
376    }
377}
378
379impl StaticType for BusNameOwnerFlags {
380    #[inline]
381    #[doc(alias = "g_bus_name_owner_flags_get_type")]
382    fn static_type() -> glib::Type {
383        unsafe { from_glib(ffi::g_bus_name_owner_flags_get_type()) }
384    }
385}
386
387impl glib::HasParamSpec for BusNameOwnerFlags {
388    type ParamSpec = glib::ParamSpecFlags;
389    type SetValue = Self;
390    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
391
392    fn param_spec_builder() -> Self::BuilderFn {
393        Self::ParamSpec::builder
394    }
395}
396
397impl glib::value::ValueType for BusNameOwnerFlags {
398    type Type = Self;
399}
400
401unsafe impl<'a> glib::value::FromValue<'a> for BusNameOwnerFlags {
402    type Checker = glib::value::GenericValueTypeChecker<Self>;
403
404    #[inline]
405    unsafe fn from_value(value: &'a glib::Value) -> Self {
406        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
407    }
408}
409
410impl ToValue for BusNameOwnerFlags {
411    #[inline]
412    fn to_value(&self) -> glib::Value {
413        let mut value = glib::Value::for_value_type::<Self>();
414        unsafe {
415            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
416        }
417        value
418    }
419
420    #[inline]
421    fn value_type(&self) -> glib::Type {
422        Self::static_type()
423    }
424}
425
426impl From<BusNameOwnerFlags> for glib::Value {
427    #[inline]
428    fn from(v: BusNameOwnerFlags) -> Self {
429        ToValue::to_value(&v)
430    }
431}
432
433bitflags! {
434    /// Flags used in g_bus_watch_name().
435    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
436    #[doc(alias = "GBusNameWatcherFlags")]
437    pub struct BusNameWatcherFlags: u32 {
438        /// No flags set.
439        #[doc(alias = "G_BUS_NAME_WATCHER_FLAGS_NONE")]
440        const NONE = ffi::G_BUS_NAME_WATCHER_FLAGS_NONE as _;
441        /// If no-one owns the name when
442        /// beginning to watch the name, ask the bus to launch an owner for the
443        /// name.
444        #[doc(alias = "G_BUS_NAME_WATCHER_FLAGS_AUTO_START")]
445        const AUTO_START = ffi::G_BUS_NAME_WATCHER_FLAGS_AUTO_START as _;
446    }
447}
448
449#[doc(hidden)]
450impl IntoGlib for BusNameWatcherFlags {
451    type GlibType = ffi::GBusNameWatcherFlags;
452
453    #[inline]
454    fn into_glib(self) -> ffi::GBusNameWatcherFlags {
455        self.bits()
456    }
457}
458
459#[doc(hidden)]
460impl FromGlib<ffi::GBusNameWatcherFlags> for BusNameWatcherFlags {
461    #[inline]
462    unsafe fn from_glib(value: ffi::GBusNameWatcherFlags) -> Self {
463        Self::from_bits_truncate(value)
464    }
465}
466
467impl StaticType for BusNameWatcherFlags {
468    #[inline]
469    #[doc(alias = "g_bus_name_watcher_flags_get_type")]
470    fn static_type() -> glib::Type {
471        unsafe { from_glib(ffi::g_bus_name_watcher_flags_get_type()) }
472    }
473}
474
475impl glib::HasParamSpec for BusNameWatcherFlags {
476    type ParamSpec = glib::ParamSpecFlags;
477    type SetValue = Self;
478    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
479
480    fn param_spec_builder() -> Self::BuilderFn {
481        Self::ParamSpec::builder
482    }
483}
484
485impl glib::value::ValueType for BusNameWatcherFlags {
486    type Type = Self;
487}
488
489unsafe impl<'a> glib::value::FromValue<'a> for BusNameWatcherFlags {
490    type Checker = glib::value::GenericValueTypeChecker<Self>;
491
492    #[inline]
493    unsafe fn from_value(value: &'a glib::Value) -> Self {
494        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
495    }
496}
497
498impl ToValue for BusNameWatcherFlags {
499    #[inline]
500    fn to_value(&self) -> glib::Value {
501        let mut value = glib::Value::for_value_type::<Self>();
502        unsafe {
503            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
504        }
505        value
506    }
507
508    #[inline]
509    fn value_type(&self) -> glib::Type {
510        Self::static_type()
511    }
512}
513
514impl From<BusNameWatcherFlags> for glib::Value {
515    #[inline]
516    fn from(v: BusNameWatcherFlags) -> Self {
517        ToValue::to_value(&v)
518    }
519}
520
521bitflags! {
522    /// Flags used when calling a g_converter_convert().
523    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
524    #[doc(alias = "GConverterFlags")]
525    pub struct ConverterFlags: u32 {
526        /// No flags.
527        #[doc(alias = "G_CONVERTER_NO_FLAGS")]
528        const NONE = ffi::G_CONVERTER_NO_FLAGS as _;
529        /// At end of input data
530        #[doc(alias = "G_CONVERTER_INPUT_AT_END")]
531        const INPUT_AT_END = ffi::G_CONVERTER_INPUT_AT_END as _;
532        /// Flush data
533        #[doc(alias = "G_CONVERTER_FLUSH")]
534        const FLUSH = ffi::G_CONVERTER_FLUSH as _;
535    }
536}
537
538#[doc(hidden)]
539impl IntoGlib for ConverterFlags {
540    type GlibType = ffi::GConverterFlags;
541
542    #[inline]
543    fn into_glib(self) -> ffi::GConverterFlags {
544        self.bits()
545    }
546}
547
548#[doc(hidden)]
549impl FromGlib<ffi::GConverterFlags> for ConverterFlags {
550    #[inline]
551    unsafe fn from_glib(value: ffi::GConverterFlags) -> Self {
552        Self::from_bits_truncate(value)
553    }
554}
555
556impl StaticType for ConverterFlags {
557    #[inline]
558    #[doc(alias = "g_converter_flags_get_type")]
559    fn static_type() -> glib::Type {
560        unsafe { from_glib(ffi::g_converter_flags_get_type()) }
561    }
562}
563
564impl glib::HasParamSpec for ConverterFlags {
565    type ParamSpec = glib::ParamSpecFlags;
566    type SetValue = Self;
567    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
568
569    fn param_spec_builder() -> Self::BuilderFn {
570        Self::ParamSpec::builder
571    }
572}
573
574impl glib::value::ValueType for ConverterFlags {
575    type Type = Self;
576}
577
578unsafe impl<'a> glib::value::FromValue<'a> for ConverterFlags {
579    type Checker = glib::value::GenericValueTypeChecker<Self>;
580
581    #[inline]
582    unsafe fn from_value(value: &'a glib::Value) -> Self {
583        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
584    }
585}
586
587impl ToValue for ConverterFlags {
588    #[inline]
589    fn to_value(&self) -> glib::Value {
590        let mut value = glib::Value::for_value_type::<Self>();
591        unsafe {
592            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
593        }
594        value
595    }
596
597    #[inline]
598    fn value_type(&self) -> glib::Type {
599        Self::static_type()
600    }
601}
602
603impl From<ConverterFlags> for glib::Value {
604    #[inline]
605    fn from(v: ConverterFlags) -> Self {
606        ToValue::to_value(&v)
607    }
608}
609
610bitflags! {
611    /// Flags used in g_dbus_connection_call() and similar APIs.
612    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
613    #[doc(alias = "GDBusCallFlags")]
614    pub struct DBusCallFlags: u32 {
615        /// No flags set.
616        #[doc(alias = "G_DBUS_CALL_FLAGS_NONE")]
617        const NONE = ffi::G_DBUS_CALL_FLAGS_NONE as _;
618        /// The bus must not launch
619        /// an owner for the destination name in response to this method
620        /// invocation.
621        #[doc(alias = "G_DBUS_CALL_FLAGS_NO_AUTO_START")]
622        const NO_AUTO_START = ffi::G_DBUS_CALL_FLAGS_NO_AUTO_START as _;
623        /// the caller is prepared to
624        /// wait for interactive authorization. Since 2.46.
625        #[doc(alias = "G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION")]
626        const ALLOW_INTERACTIVE_AUTHORIZATION = ffi::G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION as _;
627    }
628}
629
630#[doc(hidden)]
631impl IntoGlib for DBusCallFlags {
632    type GlibType = ffi::GDBusCallFlags;
633
634    #[inline]
635    fn into_glib(self) -> ffi::GDBusCallFlags {
636        self.bits()
637    }
638}
639
640#[doc(hidden)]
641impl FromGlib<ffi::GDBusCallFlags> for DBusCallFlags {
642    #[inline]
643    unsafe fn from_glib(value: ffi::GDBusCallFlags) -> Self {
644        Self::from_bits_truncate(value)
645    }
646}
647
648impl StaticType for DBusCallFlags {
649    #[inline]
650    #[doc(alias = "g_dbus_call_flags_get_type")]
651    fn static_type() -> glib::Type {
652        unsafe { from_glib(ffi::g_dbus_call_flags_get_type()) }
653    }
654}
655
656impl glib::HasParamSpec for DBusCallFlags {
657    type ParamSpec = glib::ParamSpecFlags;
658    type SetValue = Self;
659    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
660
661    fn param_spec_builder() -> Self::BuilderFn {
662        Self::ParamSpec::builder
663    }
664}
665
666impl glib::value::ValueType for DBusCallFlags {
667    type Type = Self;
668}
669
670unsafe impl<'a> glib::value::FromValue<'a> for DBusCallFlags {
671    type Checker = glib::value::GenericValueTypeChecker<Self>;
672
673    #[inline]
674    unsafe fn from_value(value: &'a glib::Value) -> Self {
675        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
676    }
677}
678
679impl ToValue for DBusCallFlags {
680    #[inline]
681    fn to_value(&self) -> glib::Value {
682        let mut value = glib::Value::for_value_type::<Self>();
683        unsafe {
684            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
685        }
686        value
687    }
688
689    #[inline]
690    fn value_type(&self) -> glib::Type {
691        Self::static_type()
692    }
693}
694
695impl From<DBusCallFlags> for glib::Value {
696    #[inline]
697    fn from(v: DBusCallFlags) -> Self {
698        ToValue::to_value(&v)
699    }
700}
701
702bitflags! {
703    /// Capabilities negotiated with the remote peer.
704    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
705    #[doc(alias = "GDBusCapabilityFlags")]
706    pub struct DBusCapabilityFlags: u32 {
707        /// No flags set.
708        #[doc(alias = "G_DBUS_CAPABILITY_FLAGS_NONE")]
709        const NONE = ffi::G_DBUS_CAPABILITY_FLAGS_NONE as _;
710        /// The connection
711        /// supports exchanging UNIX file descriptors with the remote peer.
712        #[doc(alias = "G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING")]
713        const UNIX_FD_PASSING = ffi::G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING as _;
714    }
715}
716
717#[doc(hidden)]
718impl IntoGlib for DBusCapabilityFlags {
719    type GlibType = ffi::GDBusCapabilityFlags;
720
721    #[inline]
722    fn into_glib(self) -> ffi::GDBusCapabilityFlags {
723        self.bits()
724    }
725}
726
727#[doc(hidden)]
728impl FromGlib<ffi::GDBusCapabilityFlags> for DBusCapabilityFlags {
729    #[inline]
730    unsafe fn from_glib(value: ffi::GDBusCapabilityFlags) -> Self {
731        Self::from_bits_truncate(value)
732    }
733}
734
735impl StaticType for DBusCapabilityFlags {
736    #[inline]
737    #[doc(alias = "g_dbus_capability_flags_get_type")]
738    fn static_type() -> glib::Type {
739        unsafe { from_glib(ffi::g_dbus_capability_flags_get_type()) }
740    }
741}
742
743impl glib::HasParamSpec for DBusCapabilityFlags {
744    type ParamSpec = glib::ParamSpecFlags;
745    type SetValue = Self;
746    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
747
748    fn param_spec_builder() -> Self::BuilderFn {
749        Self::ParamSpec::builder
750    }
751}
752
753impl glib::value::ValueType for DBusCapabilityFlags {
754    type Type = Self;
755}
756
757unsafe impl<'a> glib::value::FromValue<'a> for DBusCapabilityFlags {
758    type Checker = glib::value::GenericValueTypeChecker<Self>;
759
760    #[inline]
761    unsafe fn from_value(value: &'a glib::Value) -> Self {
762        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
763    }
764}
765
766impl ToValue for DBusCapabilityFlags {
767    #[inline]
768    fn to_value(&self) -> glib::Value {
769        let mut value = glib::Value::for_value_type::<Self>();
770        unsafe {
771            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
772        }
773        value
774    }
775
776    #[inline]
777    fn value_type(&self) -> glib::Type {
778        Self::static_type()
779    }
780}
781
782impl From<DBusCapabilityFlags> for glib::Value {
783    #[inline]
784    fn from(v: DBusCapabilityFlags) -> Self {
785        ToValue::to_value(&v)
786    }
787}
788
789bitflags! {
790    /// Flags used when creating a new #GDBusConnection.
791    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
792    #[doc(alias = "GDBusConnectionFlags")]
793    pub struct DBusConnectionFlags: u32 {
794        /// No flags set.
795        #[doc(alias = "G_DBUS_CONNECTION_FLAGS_NONE")]
796        const NONE = ffi::G_DBUS_CONNECTION_FLAGS_NONE as _;
797        /// Perform authentication against server.
798        #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT")]
799        const AUTHENTICATION_CLIENT = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT as _;
800        /// Perform authentication against client.
801        #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER")]
802        const AUTHENTICATION_SERVER = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER as _;
803        /// When
804        /// authenticating as a server, allow the anonymous authentication
805        /// method.
806        #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS")]
807        const AUTHENTICATION_ALLOW_ANONYMOUS = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS as _;
808        /// Pass this flag if connecting to a peer that is a
809        /// message bus. This means that the Hello() method will be invoked as part of the connection setup.
810        #[doc(alias = "G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION")]
811        const MESSAGE_BUS_CONNECTION = ffi::G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION as _;
812        /// If set, processing of D-Bus messages is
813        /// delayed until g_dbus_connection_start_message_processing() is called.
814        #[doc(alias = "G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING")]
815        const DELAY_MESSAGE_PROCESSING = ffi::G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING as _;
816        /// When authenticating
817        /// as a server, require the UID of the peer to be the same as the UID of the server. (Since: 2.68)
818        #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER")]
819        const AUTHENTICATION_REQUIRE_SAME_USER = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER as _;
820        /// When authenticating, try to use
821        ///  protocols that work across a Linux user namespace boundary, even if this
822        ///  reduces interoperability with older D-Bus implementations. This currently
823        ///  affects client-side `EXTERNAL` authentication, for which this flag makes
824        ///  connections to a server in another user namespace succeed, but causes
825        ///  a deadlock when connecting to a GDBus server older than 2.73.3. Since: 2.74
826        #[cfg(feature = "v2_74")]
827        #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
828        #[doc(alias = "G_DBUS_CONNECTION_FLAGS_CROSS_NAMESPACE")]
829        const CROSS_NAMESPACE = ffi::G_DBUS_CONNECTION_FLAGS_CROSS_NAMESPACE as _;
830    }
831}
832
833#[doc(hidden)]
834impl IntoGlib for DBusConnectionFlags {
835    type GlibType = ffi::GDBusConnectionFlags;
836
837    #[inline]
838    fn into_glib(self) -> ffi::GDBusConnectionFlags {
839        self.bits()
840    }
841}
842
843#[doc(hidden)]
844impl FromGlib<ffi::GDBusConnectionFlags> for DBusConnectionFlags {
845    #[inline]
846    unsafe fn from_glib(value: ffi::GDBusConnectionFlags) -> Self {
847        Self::from_bits_truncate(value)
848    }
849}
850
851impl StaticType for DBusConnectionFlags {
852    #[inline]
853    #[doc(alias = "g_dbus_connection_flags_get_type")]
854    fn static_type() -> glib::Type {
855        unsafe { from_glib(ffi::g_dbus_connection_flags_get_type()) }
856    }
857}
858
859impl glib::HasParamSpec for DBusConnectionFlags {
860    type ParamSpec = glib::ParamSpecFlags;
861    type SetValue = Self;
862    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
863
864    fn param_spec_builder() -> Self::BuilderFn {
865        Self::ParamSpec::builder
866    }
867}
868
869impl glib::value::ValueType for DBusConnectionFlags {
870    type Type = Self;
871}
872
873unsafe impl<'a> glib::value::FromValue<'a> for DBusConnectionFlags {
874    type Checker = glib::value::GenericValueTypeChecker<Self>;
875
876    #[inline]
877    unsafe fn from_value(value: &'a glib::Value) -> Self {
878        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
879    }
880}
881
882impl ToValue for DBusConnectionFlags {
883    #[inline]
884    fn to_value(&self) -> glib::Value {
885        let mut value = glib::Value::for_value_type::<Self>();
886        unsafe {
887            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
888        }
889        value
890    }
891
892    #[inline]
893    fn value_type(&self) -> glib::Type {
894        Self::static_type()
895    }
896}
897
898impl From<DBusConnectionFlags> for glib::Value {
899    #[inline]
900    fn from(v: DBusConnectionFlags) -> Self {
901        ToValue::to_value(&v)
902    }
903}
904
905bitflags! {
906    /// Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
907    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
908    #[doc(alias = "GDBusInterfaceSkeletonFlags")]
909    pub struct DBusInterfaceSkeletonFlags: u32 {
910        /// No flags set.
911        #[doc(alias = "G_DBUS_INTERFACE_SKELETON_FLAGS_NONE")]
912        const NONE = ffi::G_DBUS_INTERFACE_SKELETON_FLAGS_NONE as _;
913        /// Each method invocation is handled in
914        ///   a thread dedicated to the invocation. This means that the method implementation can use blocking IO
915        ///   without blocking any other part of the process. It also means that the method implementation must
916        ///   use locking to access data structures used by other threads.
917        #[doc(alias = "G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD")]
918        const HANDLE_METHOD_INVOCATIONS_IN_THREAD = ffi::G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD as _;
919    }
920}
921
922#[doc(hidden)]
923impl IntoGlib for DBusInterfaceSkeletonFlags {
924    type GlibType = ffi::GDBusInterfaceSkeletonFlags;
925
926    #[inline]
927    fn into_glib(self) -> ffi::GDBusInterfaceSkeletonFlags {
928        self.bits()
929    }
930}
931
932#[doc(hidden)]
933impl FromGlib<ffi::GDBusInterfaceSkeletonFlags> for DBusInterfaceSkeletonFlags {
934    #[inline]
935    unsafe fn from_glib(value: ffi::GDBusInterfaceSkeletonFlags) -> Self {
936        Self::from_bits_truncate(value)
937    }
938}
939
940impl StaticType for DBusInterfaceSkeletonFlags {
941    #[inline]
942    #[doc(alias = "g_dbus_interface_skeleton_flags_get_type")]
943    fn static_type() -> glib::Type {
944        unsafe { from_glib(ffi::g_dbus_interface_skeleton_flags_get_type()) }
945    }
946}
947
948impl glib::HasParamSpec for DBusInterfaceSkeletonFlags {
949    type ParamSpec = glib::ParamSpecFlags;
950    type SetValue = Self;
951    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
952
953    fn param_spec_builder() -> Self::BuilderFn {
954        Self::ParamSpec::builder
955    }
956}
957
958impl glib::value::ValueType for DBusInterfaceSkeletonFlags {
959    type Type = Self;
960}
961
962unsafe impl<'a> glib::value::FromValue<'a> for DBusInterfaceSkeletonFlags {
963    type Checker = glib::value::GenericValueTypeChecker<Self>;
964
965    #[inline]
966    unsafe fn from_value(value: &'a glib::Value) -> Self {
967        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
968    }
969}
970
971impl ToValue for DBusInterfaceSkeletonFlags {
972    #[inline]
973    fn to_value(&self) -> glib::Value {
974        let mut value = glib::Value::for_value_type::<Self>();
975        unsafe {
976            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
977        }
978        value
979    }
980
981    #[inline]
982    fn value_type(&self) -> glib::Type {
983        Self::static_type()
984    }
985}
986
987impl From<DBusInterfaceSkeletonFlags> for glib::Value {
988    #[inline]
989    fn from(v: DBusInterfaceSkeletonFlags) -> Self {
990        ToValue::to_value(&v)
991    }
992}
993
994bitflags! {
995    /// Message flags used in #GDBusMessage.
996    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
997    #[doc(alias = "GDBusMessageFlags")]
998    pub struct DBusMessageFlags: u32 {
999        /// No flags set.
1000        #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NONE")]
1001        const NONE = ffi::G_DBUS_MESSAGE_FLAGS_NONE as _;
1002        /// A reply is not expected.
1003        #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED")]
1004        const NO_REPLY_EXPECTED = ffi::G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED as _;
1005        /// The bus must not launch an
1006        /// owner for the destination name in response to this message.
1007        #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NO_AUTO_START")]
1008        const NO_AUTO_START = ffi::G_DBUS_MESSAGE_FLAGS_NO_AUTO_START as _;
1009        /// If set on a method
1010        /// call, this flag means that the caller is prepared to wait for interactive
1011        /// authorization. Since 2.46.
1012        #[doc(alias = "G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION")]
1013        const ALLOW_INTERACTIVE_AUTHORIZATION = ffi::G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION as _;
1014    }
1015}
1016
1017#[doc(hidden)]
1018impl IntoGlib for DBusMessageFlags {
1019    type GlibType = ffi::GDBusMessageFlags;
1020
1021    #[inline]
1022    fn into_glib(self) -> ffi::GDBusMessageFlags {
1023        self.bits()
1024    }
1025}
1026
1027#[doc(hidden)]
1028impl FromGlib<ffi::GDBusMessageFlags> for DBusMessageFlags {
1029    #[inline]
1030    unsafe fn from_glib(value: ffi::GDBusMessageFlags) -> Self {
1031        Self::from_bits_truncate(value)
1032    }
1033}
1034
1035impl StaticType for DBusMessageFlags {
1036    #[inline]
1037    #[doc(alias = "g_dbus_message_flags_get_type")]
1038    fn static_type() -> glib::Type {
1039        unsafe { from_glib(ffi::g_dbus_message_flags_get_type()) }
1040    }
1041}
1042
1043impl glib::HasParamSpec for DBusMessageFlags {
1044    type ParamSpec = glib::ParamSpecFlags;
1045    type SetValue = Self;
1046    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1047
1048    fn param_spec_builder() -> Self::BuilderFn {
1049        Self::ParamSpec::builder
1050    }
1051}
1052
1053impl glib::value::ValueType for DBusMessageFlags {
1054    type Type = Self;
1055}
1056
1057unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageFlags {
1058    type Checker = glib::value::GenericValueTypeChecker<Self>;
1059
1060    #[inline]
1061    unsafe fn from_value(value: &'a glib::Value) -> Self {
1062        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1063    }
1064}
1065
1066impl ToValue for DBusMessageFlags {
1067    #[inline]
1068    fn to_value(&self) -> glib::Value {
1069        let mut value = glib::Value::for_value_type::<Self>();
1070        unsafe {
1071            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1072        }
1073        value
1074    }
1075
1076    #[inline]
1077    fn value_type(&self) -> glib::Type {
1078        Self::static_type()
1079    }
1080}
1081
1082impl From<DBusMessageFlags> for glib::Value {
1083    #[inline]
1084    fn from(v: DBusMessageFlags) -> Self {
1085        ToValue::to_value(&v)
1086    }
1087}
1088
1089bitflags! {
1090    /// Flags used when constructing a #GDBusObjectManagerClient.
1091    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1092    #[doc(alias = "GDBusObjectManagerClientFlags")]
1093    pub struct DBusObjectManagerClientFlags: u32 {
1094        /// No flags set.
1095        #[doc(alias = "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE")]
1096        const NONE = ffi::G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE as _;
1097        /// If not set and the
1098        ///   manager is for a well-known name, then request the bus to launch
1099        ///   an owner for the name if no-one owns the name. This flag can only
1100        ///   be used in managers for well-known names.
1101        #[doc(alias = "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START")]
1102        const DO_NOT_AUTO_START = ffi::G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START as _;
1103    }
1104}
1105
1106#[doc(hidden)]
1107impl IntoGlib for DBusObjectManagerClientFlags {
1108    type GlibType = ffi::GDBusObjectManagerClientFlags;
1109
1110    #[inline]
1111    fn into_glib(self) -> ffi::GDBusObjectManagerClientFlags {
1112        self.bits()
1113    }
1114}
1115
1116#[doc(hidden)]
1117impl FromGlib<ffi::GDBusObjectManagerClientFlags> for DBusObjectManagerClientFlags {
1118    #[inline]
1119    unsafe fn from_glib(value: ffi::GDBusObjectManagerClientFlags) -> Self {
1120        Self::from_bits_truncate(value)
1121    }
1122}
1123
1124impl StaticType for DBusObjectManagerClientFlags {
1125    #[inline]
1126    #[doc(alias = "g_dbus_object_manager_client_flags_get_type")]
1127    fn static_type() -> glib::Type {
1128        unsafe { from_glib(ffi::g_dbus_object_manager_client_flags_get_type()) }
1129    }
1130}
1131
1132impl glib::HasParamSpec for DBusObjectManagerClientFlags {
1133    type ParamSpec = glib::ParamSpecFlags;
1134    type SetValue = Self;
1135    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1136
1137    fn param_spec_builder() -> Self::BuilderFn {
1138        Self::ParamSpec::builder
1139    }
1140}
1141
1142impl glib::value::ValueType for DBusObjectManagerClientFlags {
1143    type Type = Self;
1144}
1145
1146unsafe impl<'a> glib::value::FromValue<'a> for DBusObjectManagerClientFlags {
1147    type Checker = glib::value::GenericValueTypeChecker<Self>;
1148
1149    #[inline]
1150    unsafe fn from_value(value: &'a glib::Value) -> Self {
1151        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1152    }
1153}
1154
1155impl ToValue for DBusObjectManagerClientFlags {
1156    #[inline]
1157    fn to_value(&self) -> glib::Value {
1158        let mut value = glib::Value::for_value_type::<Self>();
1159        unsafe {
1160            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1161        }
1162        value
1163    }
1164
1165    #[inline]
1166    fn value_type(&self) -> glib::Type {
1167        Self::static_type()
1168    }
1169}
1170
1171impl From<DBusObjectManagerClientFlags> for glib::Value {
1172    #[inline]
1173    fn from(v: DBusObjectManagerClientFlags) -> Self {
1174        ToValue::to_value(&v)
1175    }
1176}
1177
1178bitflags! {
1179    /// Flags describing the access control of a D-Bus property.
1180    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1181    #[doc(alias = "GDBusPropertyInfoFlags")]
1182    pub struct DBusPropertyInfoFlags: u32 {
1183        /// No flags set.
1184        #[doc(alias = "G_DBUS_PROPERTY_INFO_FLAGS_NONE")]
1185        const NONE = ffi::G_DBUS_PROPERTY_INFO_FLAGS_NONE as _;
1186        /// Property is readable.
1187        #[doc(alias = "G_DBUS_PROPERTY_INFO_FLAGS_READABLE")]
1188        const READABLE = ffi::G_DBUS_PROPERTY_INFO_FLAGS_READABLE as _;
1189        /// Property is writable.
1190        #[doc(alias = "G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE")]
1191        const WRITABLE = ffi::G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE as _;
1192    }
1193}
1194
1195#[doc(hidden)]
1196impl IntoGlib for DBusPropertyInfoFlags {
1197    type GlibType = ffi::GDBusPropertyInfoFlags;
1198
1199    #[inline]
1200    fn into_glib(self) -> ffi::GDBusPropertyInfoFlags {
1201        self.bits()
1202    }
1203}
1204
1205#[doc(hidden)]
1206impl FromGlib<ffi::GDBusPropertyInfoFlags> for DBusPropertyInfoFlags {
1207    #[inline]
1208    unsafe fn from_glib(value: ffi::GDBusPropertyInfoFlags) -> Self {
1209        Self::from_bits_truncate(value)
1210    }
1211}
1212
1213impl StaticType for DBusPropertyInfoFlags {
1214    #[inline]
1215    #[doc(alias = "g_dbus_property_info_flags_get_type")]
1216    fn static_type() -> glib::Type {
1217        unsafe { from_glib(ffi::g_dbus_property_info_flags_get_type()) }
1218    }
1219}
1220
1221impl glib::HasParamSpec for DBusPropertyInfoFlags {
1222    type ParamSpec = glib::ParamSpecFlags;
1223    type SetValue = Self;
1224    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1225
1226    fn param_spec_builder() -> Self::BuilderFn {
1227        Self::ParamSpec::builder
1228    }
1229}
1230
1231impl glib::value::ValueType for DBusPropertyInfoFlags {
1232    type Type = Self;
1233}
1234
1235unsafe impl<'a> glib::value::FromValue<'a> for DBusPropertyInfoFlags {
1236    type Checker = glib::value::GenericValueTypeChecker<Self>;
1237
1238    #[inline]
1239    unsafe fn from_value(value: &'a glib::Value) -> Self {
1240        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1241    }
1242}
1243
1244impl ToValue for DBusPropertyInfoFlags {
1245    #[inline]
1246    fn to_value(&self) -> glib::Value {
1247        let mut value = glib::Value::for_value_type::<Self>();
1248        unsafe {
1249            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1250        }
1251        value
1252    }
1253
1254    #[inline]
1255    fn value_type(&self) -> glib::Type {
1256        Self::static_type()
1257    }
1258}
1259
1260impl From<DBusPropertyInfoFlags> for glib::Value {
1261    #[inline]
1262    fn from(v: DBusPropertyInfoFlags) -> Self {
1263        ToValue::to_value(&v)
1264    }
1265}
1266
1267bitflags! {
1268    /// Flags used when constructing an instance of a #GDBusProxy derived class.
1269    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1270    #[doc(alias = "GDBusProxyFlags")]
1271    pub struct DBusProxyFlags: u32 {
1272        /// No flags set.
1273        #[doc(alias = "G_DBUS_PROXY_FLAGS_NONE")]
1274        const NONE = ffi::G_DBUS_PROXY_FLAGS_NONE as _;
1275        /// Don't load properties.
1276        #[doc(alias = "G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES")]
1277        const DO_NOT_LOAD_PROPERTIES = ffi::G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES as _;
1278        /// Don't connect to signals on the remote object.
1279        #[doc(alias = "G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS")]
1280        const DO_NOT_CONNECT_SIGNALS = ffi::G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS as _;
1281        /// If the proxy is for a well-known name,
1282        /// do not ask the bus to launch an owner during proxy initialization or a method call.
1283        /// This flag is only meaningful in proxies for well-known names.
1284        #[doc(alias = "G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START")]
1285        const DO_NOT_AUTO_START = ffi::G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START as _;
1286        /// If set, the property value for any __invalidated property__ will be (asynchronously) retrieved upon receiving the [`PropertiesChanged`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties) D-Bus signal and the property will not cause emission of the #GDBusProxy::g-properties-changed signal. When the value is received the #GDBusProxy::g-properties-changed signal is emitted for the property along with the retrieved value. Since 2.32.
1287        #[doc(alias = "G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES")]
1288        const GET_INVALIDATED_PROPERTIES = ffi::G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES as _;
1289        /// If the proxy is for a well-known name,
1290        /// do not ask the bus to launch an owner during proxy initialization, but allow it to be
1291        /// autostarted by a method call. This flag is only meaningful in proxies for well-known names,
1292        /// and only if [`DO_NOT_AUTO_START`][Self::DO_NOT_AUTO_START] is not also specified.
1293        #[doc(alias = "G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION")]
1294        const DO_NOT_AUTO_START_AT_CONSTRUCTION = ffi::G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION as _;
1295        /// Don't actually send the AddMatch D-Bus
1296        ///    call for this signal subscription. This gives you more control
1297        ///    over which match rules you add (but you must add them manually). (Since: 2.72)
1298        #[cfg(feature = "v2_70")]
1299        #[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
1300        #[doc(alias = "G_DBUS_PROXY_FLAGS_NO_MATCH_RULE")]
1301        const NO_MATCH_RULE = ffi::G_DBUS_PROXY_FLAGS_NO_MATCH_RULE as _;
1302    }
1303}
1304
1305#[doc(hidden)]
1306impl IntoGlib for DBusProxyFlags {
1307    type GlibType = ffi::GDBusProxyFlags;
1308
1309    #[inline]
1310    fn into_glib(self) -> ffi::GDBusProxyFlags {
1311        self.bits()
1312    }
1313}
1314
1315#[doc(hidden)]
1316impl FromGlib<ffi::GDBusProxyFlags> for DBusProxyFlags {
1317    #[inline]
1318    unsafe fn from_glib(value: ffi::GDBusProxyFlags) -> Self {
1319        Self::from_bits_truncate(value)
1320    }
1321}
1322
1323impl StaticType for DBusProxyFlags {
1324    #[inline]
1325    #[doc(alias = "g_dbus_proxy_flags_get_type")]
1326    fn static_type() -> glib::Type {
1327        unsafe { from_glib(ffi::g_dbus_proxy_flags_get_type()) }
1328    }
1329}
1330
1331impl glib::HasParamSpec for DBusProxyFlags {
1332    type ParamSpec = glib::ParamSpecFlags;
1333    type SetValue = Self;
1334    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1335
1336    fn param_spec_builder() -> Self::BuilderFn {
1337        Self::ParamSpec::builder
1338    }
1339}
1340
1341impl glib::value::ValueType for DBusProxyFlags {
1342    type Type = Self;
1343}
1344
1345unsafe impl<'a> glib::value::FromValue<'a> for DBusProxyFlags {
1346    type Checker = glib::value::GenericValueTypeChecker<Self>;
1347
1348    #[inline]
1349    unsafe fn from_value(value: &'a glib::Value) -> Self {
1350        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1351    }
1352}
1353
1354impl ToValue for DBusProxyFlags {
1355    #[inline]
1356    fn to_value(&self) -> glib::Value {
1357        let mut value = glib::Value::for_value_type::<Self>();
1358        unsafe {
1359            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1360        }
1361        value
1362    }
1363
1364    #[inline]
1365    fn value_type(&self) -> glib::Type {
1366        Self::static_type()
1367    }
1368}
1369
1370impl From<DBusProxyFlags> for glib::Value {
1371    #[inline]
1372    fn from(v: DBusProxyFlags) -> Self {
1373        ToValue::to_value(&v)
1374    }
1375}
1376
1377bitflags! {
1378    /// Flags used when sending #GDBusMessages on a #GDBusConnection.
1379    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1380    #[doc(alias = "GDBusSendMessageFlags")]
1381    pub struct DBusSendMessageFlags: u32 {
1382        /// No flags set.
1383        #[doc(alias = "G_DBUS_SEND_MESSAGE_FLAGS_NONE")]
1384        const NONE = ffi::G_DBUS_SEND_MESSAGE_FLAGS_NONE as _;
1385        /// Do not automatically
1386        /// assign a serial number from the #GDBusConnection object when
1387        /// sending a message.
1388        #[doc(alias = "G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL")]
1389        const PRESERVE_SERIAL = ffi::G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL as _;
1390    }
1391}
1392
1393#[doc(hidden)]
1394impl IntoGlib for DBusSendMessageFlags {
1395    type GlibType = ffi::GDBusSendMessageFlags;
1396
1397    #[inline]
1398    fn into_glib(self) -> ffi::GDBusSendMessageFlags {
1399        self.bits()
1400    }
1401}
1402
1403#[doc(hidden)]
1404impl FromGlib<ffi::GDBusSendMessageFlags> for DBusSendMessageFlags {
1405    #[inline]
1406    unsafe fn from_glib(value: ffi::GDBusSendMessageFlags) -> Self {
1407        Self::from_bits_truncate(value)
1408    }
1409}
1410
1411impl StaticType for DBusSendMessageFlags {
1412    #[inline]
1413    #[doc(alias = "g_dbus_send_message_flags_get_type")]
1414    fn static_type() -> glib::Type {
1415        unsafe { from_glib(ffi::g_dbus_send_message_flags_get_type()) }
1416    }
1417}
1418
1419impl glib::HasParamSpec for DBusSendMessageFlags {
1420    type ParamSpec = glib::ParamSpecFlags;
1421    type SetValue = Self;
1422    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1423
1424    fn param_spec_builder() -> Self::BuilderFn {
1425        Self::ParamSpec::builder
1426    }
1427}
1428
1429impl glib::value::ValueType for DBusSendMessageFlags {
1430    type Type = Self;
1431}
1432
1433unsafe impl<'a> glib::value::FromValue<'a> for DBusSendMessageFlags {
1434    type Checker = glib::value::GenericValueTypeChecker<Self>;
1435
1436    #[inline]
1437    unsafe fn from_value(value: &'a glib::Value) -> Self {
1438        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1439    }
1440}
1441
1442impl ToValue for DBusSendMessageFlags {
1443    #[inline]
1444    fn to_value(&self) -> glib::Value {
1445        let mut value = glib::Value::for_value_type::<Self>();
1446        unsafe {
1447            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1448        }
1449        value
1450    }
1451
1452    #[inline]
1453    fn value_type(&self) -> glib::Type {
1454        Self::static_type()
1455    }
1456}
1457
1458impl From<DBusSendMessageFlags> for glib::Value {
1459    #[inline]
1460    fn from(v: DBusSendMessageFlags) -> Self {
1461        ToValue::to_value(&v)
1462    }
1463}
1464
1465bitflags! {
1466    /// Flags used when creating a #GDBusServer.
1467    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1468    #[doc(alias = "GDBusServerFlags")]
1469    pub struct DBusServerFlags: u32 {
1470        /// No flags set.
1471        #[doc(alias = "G_DBUS_SERVER_FLAGS_NONE")]
1472        const NONE = ffi::G_DBUS_SERVER_FLAGS_NONE as _;
1473        /// All #GDBusServer::new-connection
1474        /// signals will run in separated dedicated threads (see signal for
1475        /// details).
1476        #[doc(alias = "G_DBUS_SERVER_FLAGS_RUN_IN_THREAD")]
1477        const RUN_IN_THREAD = ffi::G_DBUS_SERVER_FLAGS_RUN_IN_THREAD as _;
1478        /// Allow the anonymous
1479        /// authentication method.
1480        #[doc(alias = "G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS")]
1481        const AUTHENTICATION_ALLOW_ANONYMOUS = ffi::G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS as _;
1482        /// Require the UID of the
1483        /// peer to be the same as the UID of the server when authenticating. (Since: 2.68)
1484        #[doc(alias = "G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER")]
1485        const AUTHENTICATION_REQUIRE_SAME_USER = ffi::G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER as _;
1486    }
1487}
1488
1489#[doc(hidden)]
1490impl IntoGlib for DBusServerFlags {
1491    type GlibType = ffi::GDBusServerFlags;
1492
1493    #[inline]
1494    fn into_glib(self) -> ffi::GDBusServerFlags {
1495        self.bits()
1496    }
1497}
1498
1499#[doc(hidden)]
1500impl FromGlib<ffi::GDBusServerFlags> for DBusServerFlags {
1501    #[inline]
1502    unsafe fn from_glib(value: ffi::GDBusServerFlags) -> Self {
1503        Self::from_bits_truncate(value)
1504    }
1505}
1506
1507impl StaticType for DBusServerFlags {
1508    #[inline]
1509    #[doc(alias = "g_dbus_server_flags_get_type")]
1510    fn static_type() -> glib::Type {
1511        unsafe { from_glib(ffi::g_dbus_server_flags_get_type()) }
1512    }
1513}
1514
1515impl glib::HasParamSpec for DBusServerFlags {
1516    type ParamSpec = glib::ParamSpecFlags;
1517    type SetValue = Self;
1518    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1519
1520    fn param_spec_builder() -> Self::BuilderFn {
1521        Self::ParamSpec::builder
1522    }
1523}
1524
1525impl glib::value::ValueType for DBusServerFlags {
1526    type Type = Self;
1527}
1528
1529unsafe impl<'a> glib::value::FromValue<'a> for DBusServerFlags {
1530    type Checker = glib::value::GenericValueTypeChecker<Self>;
1531
1532    #[inline]
1533    unsafe fn from_value(value: &'a glib::Value) -> Self {
1534        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1535    }
1536}
1537
1538impl ToValue for DBusServerFlags {
1539    #[inline]
1540    fn to_value(&self) -> glib::Value {
1541        let mut value = glib::Value::for_value_type::<Self>();
1542        unsafe {
1543            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1544        }
1545        value
1546    }
1547
1548    #[inline]
1549    fn value_type(&self) -> glib::Type {
1550        Self::static_type()
1551    }
1552}
1553
1554impl From<DBusServerFlags> for glib::Value {
1555    #[inline]
1556    fn from(v: DBusServerFlags) -> Self {
1557        ToValue::to_value(&v)
1558    }
1559}
1560
1561bitflags! {
1562    /// Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
1563    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1564    #[doc(alias = "GDBusSignalFlags")]
1565    pub struct DBusSignalFlags: u32 {
1566        /// No flags set.
1567        #[doc(alias = "G_DBUS_SIGNAL_FLAGS_NONE")]
1568        const NONE = ffi::G_DBUS_SIGNAL_FLAGS_NONE as _;
1569        /// Don't actually send the AddMatch
1570        /// D-Bus call for this signal subscription.  This gives you more control
1571        /// over which match rules you add (but you must add them manually).
1572        #[doc(alias = "G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE")]
1573        const NO_MATCH_RULE = ffi::G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE as _;
1574        /// Match first arguments that
1575        /// contain a bus or interface name with the given namespace.
1576        #[doc(alias = "G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE")]
1577        const MATCH_ARG0_NAMESPACE = ffi::G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE as _;
1578        /// Match first arguments that
1579        /// contain an object path that is either equivalent to the given path,
1580        /// or one of the paths is a subpath of the other.
1581        #[doc(alias = "G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH")]
1582        const MATCH_ARG0_PATH = ffi::G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH as _;
1583    }
1584}
1585
1586#[doc(hidden)]
1587impl IntoGlib for DBusSignalFlags {
1588    type GlibType = ffi::GDBusSignalFlags;
1589
1590    #[inline]
1591    fn into_glib(self) -> ffi::GDBusSignalFlags {
1592        self.bits()
1593    }
1594}
1595
1596#[doc(hidden)]
1597impl FromGlib<ffi::GDBusSignalFlags> for DBusSignalFlags {
1598    #[inline]
1599    unsafe fn from_glib(value: ffi::GDBusSignalFlags) -> Self {
1600        Self::from_bits_truncate(value)
1601    }
1602}
1603
1604impl StaticType for DBusSignalFlags {
1605    #[inline]
1606    #[doc(alias = "g_dbus_signal_flags_get_type")]
1607    fn static_type() -> glib::Type {
1608        unsafe { from_glib(ffi::g_dbus_signal_flags_get_type()) }
1609    }
1610}
1611
1612impl glib::HasParamSpec for DBusSignalFlags {
1613    type ParamSpec = glib::ParamSpecFlags;
1614    type SetValue = Self;
1615    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1616
1617    fn param_spec_builder() -> Self::BuilderFn {
1618        Self::ParamSpec::builder
1619    }
1620}
1621
1622impl glib::value::ValueType for DBusSignalFlags {
1623    type Type = Self;
1624}
1625
1626unsafe impl<'a> glib::value::FromValue<'a> for DBusSignalFlags {
1627    type Checker = glib::value::GenericValueTypeChecker<Self>;
1628
1629    #[inline]
1630    unsafe fn from_value(value: &'a glib::Value) -> Self {
1631        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1632    }
1633}
1634
1635impl ToValue for DBusSignalFlags {
1636    #[inline]
1637    fn to_value(&self) -> glib::Value {
1638        let mut value = glib::Value::for_value_type::<Self>();
1639        unsafe {
1640            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1641        }
1642        value
1643    }
1644
1645    #[inline]
1646    fn value_type(&self) -> glib::Type {
1647        Self::static_type()
1648    }
1649}
1650
1651impl From<DBusSignalFlags> for glib::Value {
1652    #[inline]
1653    fn from(v: DBusSignalFlags) -> Self {
1654        ToValue::to_value(&v)
1655    }
1656}
1657
1658bitflags! {
1659    /// Flags passed to g_dbus_connection_register_subtree().
1660    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1661    #[doc(alias = "GDBusSubtreeFlags")]
1662    pub struct DBusSubtreeFlags: u32 {
1663        /// No flags set.
1664        #[doc(alias = "G_DBUS_SUBTREE_FLAGS_NONE")]
1665        const NONE = ffi::G_DBUS_SUBTREE_FLAGS_NONE as _;
1666        /// Method calls to objects not in the enumerated range
1667        ///                                                       will still be dispatched. This is useful if you want
1668        ///                                                       to dynamically spawn objects in the subtree.
1669        #[doc(alias = "G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES")]
1670        const DISPATCH_TO_UNENUMERATED_NODES = ffi::G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES as _;
1671    }
1672}
1673
1674#[doc(hidden)]
1675impl IntoGlib for DBusSubtreeFlags {
1676    type GlibType = ffi::GDBusSubtreeFlags;
1677
1678    #[inline]
1679    fn into_glib(self) -> ffi::GDBusSubtreeFlags {
1680        self.bits()
1681    }
1682}
1683
1684#[doc(hidden)]
1685impl FromGlib<ffi::GDBusSubtreeFlags> for DBusSubtreeFlags {
1686    #[inline]
1687    unsafe fn from_glib(value: ffi::GDBusSubtreeFlags) -> Self {
1688        Self::from_bits_truncate(value)
1689    }
1690}
1691
1692impl StaticType for DBusSubtreeFlags {
1693    #[inline]
1694    #[doc(alias = "g_dbus_subtree_flags_get_type")]
1695    fn static_type() -> glib::Type {
1696        unsafe { from_glib(ffi::g_dbus_subtree_flags_get_type()) }
1697    }
1698}
1699
1700impl glib::HasParamSpec for DBusSubtreeFlags {
1701    type ParamSpec = glib::ParamSpecFlags;
1702    type SetValue = Self;
1703    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1704
1705    fn param_spec_builder() -> Self::BuilderFn {
1706        Self::ParamSpec::builder
1707    }
1708}
1709
1710impl glib::value::ValueType for DBusSubtreeFlags {
1711    type Type = Self;
1712}
1713
1714unsafe impl<'a> glib::value::FromValue<'a> for DBusSubtreeFlags {
1715    type Checker = glib::value::GenericValueTypeChecker<Self>;
1716
1717    #[inline]
1718    unsafe fn from_value(value: &'a glib::Value) -> Self {
1719        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1720    }
1721}
1722
1723impl ToValue for DBusSubtreeFlags {
1724    #[inline]
1725    fn to_value(&self) -> glib::Value {
1726        let mut value = glib::Value::for_value_type::<Self>();
1727        unsafe {
1728            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1729        }
1730        value
1731    }
1732
1733    #[inline]
1734    fn value_type(&self) -> glib::Type {
1735        Self::static_type()
1736    }
1737}
1738
1739impl From<DBusSubtreeFlags> for glib::Value {
1740    #[inline]
1741    fn from(v: DBusSubtreeFlags) -> Self {
1742        ToValue::to_value(&v)
1743    }
1744}
1745
1746bitflags! {
1747    /// Flags used when starting a drive.
1748    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1749    #[doc(alias = "GDriveStartFlags")]
1750    pub struct DriveStartFlags: u32 {
1751        /// No flags set.
1752        #[doc(alias = "G_DRIVE_START_NONE")]
1753        const NONE = ffi::G_DRIVE_START_NONE as _;
1754    }
1755}
1756
1757#[doc(hidden)]
1758impl IntoGlib for DriveStartFlags {
1759    type GlibType = ffi::GDriveStartFlags;
1760
1761    #[inline]
1762    fn into_glib(self) -> ffi::GDriveStartFlags {
1763        self.bits()
1764    }
1765}
1766
1767#[doc(hidden)]
1768impl FromGlib<ffi::GDriveStartFlags> for DriveStartFlags {
1769    #[inline]
1770    unsafe fn from_glib(value: ffi::GDriveStartFlags) -> Self {
1771        Self::from_bits_truncate(value)
1772    }
1773}
1774
1775impl StaticType for DriveStartFlags {
1776    #[inline]
1777    #[doc(alias = "g_drive_start_flags_get_type")]
1778    fn static_type() -> glib::Type {
1779        unsafe { from_glib(ffi::g_drive_start_flags_get_type()) }
1780    }
1781}
1782
1783impl glib::HasParamSpec for DriveStartFlags {
1784    type ParamSpec = glib::ParamSpecFlags;
1785    type SetValue = Self;
1786    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1787
1788    fn param_spec_builder() -> Self::BuilderFn {
1789        Self::ParamSpec::builder
1790    }
1791}
1792
1793impl glib::value::ValueType for DriveStartFlags {
1794    type Type = Self;
1795}
1796
1797unsafe impl<'a> glib::value::FromValue<'a> for DriveStartFlags {
1798    type Checker = glib::value::GenericValueTypeChecker<Self>;
1799
1800    #[inline]
1801    unsafe fn from_value(value: &'a glib::Value) -> Self {
1802        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1803    }
1804}
1805
1806impl ToValue for DriveStartFlags {
1807    #[inline]
1808    fn to_value(&self) -> glib::Value {
1809        let mut value = glib::Value::for_value_type::<Self>();
1810        unsafe {
1811            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1812        }
1813        value
1814    }
1815
1816    #[inline]
1817    fn value_type(&self) -> glib::Type {
1818        Self::static_type()
1819    }
1820}
1821
1822impl From<DriveStartFlags> for glib::Value {
1823    #[inline]
1824    fn from(v: DriveStartFlags) -> Self {
1825        ToValue::to_value(&v)
1826    }
1827}
1828
1829bitflags! {
1830    /// Flags specifying the behaviour of an attribute.
1831    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1832    #[doc(alias = "GFileAttributeInfoFlags")]
1833    pub struct FileAttributeInfoFlags: u32 {
1834        /// no flags set.
1835        #[doc(alias = "G_FILE_ATTRIBUTE_INFO_NONE")]
1836        const NONE = ffi::G_FILE_ATTRIBUTE_INFO_NONE as _;
1837        /// copy the attribute values when the file is copied.
1838        #[doc(alias = "G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE")]
1839        const COPY_WITH_FILE = ffi::G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE as _;
1840        /// copy the attribute values when the file is moved.
1841        #[doc(alias = "G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED")]
1842        const COPY_WHEN_MOVED = ffi::G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED as _;
1843    }
1844}
1845
1846#[doc(hidden)]
1847impl IntoGlib for FileAttributeInfoFlags {
1848    type GlibType = ffi::GFileAttributeInfoFlags;
1849
1850    #[inline]
1851    fn into_glib(self) -> ffi::GFileAttributeInfoFlags {
1852        self.bits()
1853    }
1854}
1855
1856#[doc(hidden)]
1857impl FromGlib<ffi::GFileAttributeInfoFlags> for FileAttributeInfoFlags {
1858    #[inline]
1859    unsafe fn from_glib(value: ffi::GFileAttributeInfoFlags) -> Self {
1860        Self::from_bits_truncate(value)
1861    }
1862}
1863
1864impl StaticType for FileAttributeInfoFlags {
1865    #[inline]
1866    #[doc(alias = "g_file_attribute_info_flags_get_type")]
1867    fn static_type() -> glib::Type {
1868        unsafe { from_glib(ffi::g_file_attribute_info_flags_get_type()) }
1869    }
1870}
1871
1872impl glib::HasParamSpec for FileAttributeInfoFlags {
1873    type ParamSpec = glib::ParamSpecFlags;
1874    type SetValue = Self;
1875    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1876
1877    fn param_spec_builder() -> Self::BuilderFn {
1878        Self::ParamSpec::builder
1879    }
1880}
1881
1882impl glib::value::ValueType for FileAttributeInfoFlags {
1883    type Type = Self;
1884}
1885
1886unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeInfoFlags {
1887    type Checker = glib::value::GenericValueTypeChecker<Self>;
1888
1889    #[inline]
1890    unsafe fn from_value(value: &'a glib::Value) -> Self {
1891        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1892    }
1893}
1894
1895impl ToValue for FileAttributeInfoFlags {
1896    #[inline]
1897    fn to_value(&self) -> glib::Value {
1898        let mut value = glib::Value::for_value_type::<Self>();
1899        unsafe {
1900            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1901        }
1902        value
1903    }
1904
1905    #[inline]
1906    fn value_type(&self) -> glib::Type {
1907        Self::static_type()
1908    }
1909}
1910
1911impl From<FileAttributeInfoFlags> for glib::Value {
1912    #[inline]
1913    fn from(v: FileAttributeInfoFlags) -> Self {
1914        ToValue::to_value(&v)
1915    }
1916}
1917
1918bitflags! {
1919    /// Flags used when copying or moving files.
1920    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1921    #[doc(alias = "GFileCopyFlags")]
1922    pub struct FileCopyFlags: u32 {
1923        /// No flags set.
1924        #[doc(alias = "G_FILE_COPY_NONE")]
1925        const NONE = ffi::G_FILE_COPY_NONE as _;
1926        /// Overwrite any existing files
1927        #[doc(alias = "G_FILE_COPY_OVERWRITE")]
1928        const OVERWRITE = ffi::G_FILE_COPY_OVERWRITE as _;
1929        /// Make a backup of any existing files.
1930        #[doc(alias = "G_FILE_COPY_BACKUP")]
1931        const BACKUP = ffi::G_FILE_COPY_BACKUP as _;
1932        /// Don't follow symlinks.
1933        #[doc(alias = "G_FILE_COPY_NOFOLLOW_SYMLINKS")]
1934        const NOFOLLOW_SYMLINKS = ffi::G_FILE_COPY_NOFOLLOW_SYMLINKS as _;
1935        /// Copy all file metadata instead of just default set used for copy (see #GFileInfo).
1936        #[doc(alias = "G_FILE_COPY_ALL_METADATA")]
1937        const ALL_METADATA = ffi::G_FILE_COPY_ALL_METADATA as _;
1938        /// Don't use copy and delete fallback if native move not supported.
1939        #[doc(alias = "G_FILE_COPY_NO_FALLBACK_FOR_MOVE")]
1940        const NO_FALLBACK_FOR_MOVE = ffi::G_FILE_COPY_NO_FALLBACK_FOR_MOVE as _;
1941        /// Leaves target file with default perms, instead of setting the source file perms.
1942        #[doc(alias = "G_FILE_COPY_TARGET_DEFAULT_PERMS")]
1943        const TARGET_DEFAULT_PERMS = ffi::G_FILE_COPY_TARGET_DEFAULT_PERMS as _;
1944        /// Use default modification
1945        ///     timestamps instead of copying them from the source file. Since 2.80
1946        #[cfg(feature = "v2_80")]
1947        #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
1948        #[doc(alias = "G_FILE_COPY_TARGET_DEFAULT_MODIFIED_TIME")]
1949        const TARGET_DEFAULT_MODIFIED_TIME = ffi::G_FILE_COPY_TARGET_DEFAULT_MODIFIED_TIME as _;
1950    }
1951}
1952
1953#[doc(hidden)]
1954impl IntoGlib for FileCopyFlags {
1955    type GlibType = ffi::GFileCopyFlags;
1956
1957    #[inline]
1958    fn into_glib(self) -> ffi::GFileCopyFlags {
1959        self.bits()
1960    }
1961}
1962
1963#[doc(hidden)]
1964impl FromGlib<ffi::GFileCopyFlags> for FileCopyFlags {
1965    #[inline]
1966    unsafe fn from_glib(value: ffi::GFileCopyFlags) -> Self {
1967        Self::from_bits_truncate(value)
1968    }
1969}
1970
1971impl StaticType for FileCopyFlags {
1972    #[inline]
1973    #[doc(alias = "g_file_copy_flags_get_type")]
1974    fn static_type() -> glib::Type {
1975        unsafe { from_glib(ffi::g_file_copy_flags_get_type()) }
1976    }
1977}
1978
1979impl glib::HasParamSpec for FileCopyFlags {
1980    type ParamSpec = glib::ParamSpecFlags;
1981    type SetValue = Self;
1982    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1983
1984    fn param_spec_builder() -> Self::BuilderFn {
1985        Self::ParamSpec::builder
1986    }
1987}
1988
1989impl glib::value::ValueType for FileCopyFlags {
1990    type Type = Self;
1991}
1992
1993unsafe impl<'a> glib::value::FromValue<'a> for FileCopyFlags {
1994    type Checker = glib::value::GenericValueTypeChecker<Self>;
1995
1996    #[inline]
1997    unsafe fn from_value(value: &'a glib::Value) -> Self {
1998        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1999    }
2000}
2001
2002impl ToValue for FileCopyFlags {
2003    #[inline]
2004    fn to_value(&self) -> glib::Value {
2005        let mut value = glib::Value::for_value_type::<Self>();
2006        unsafe {
2007            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2008        }
2009        value
2010    }
2011
2012    #[inline]
2013    fn value_type(&self) -> glib::Type {
2014        Self::static_type()
2015    }
2016}
2017
2018impl From<FileCopyFlags> for glib::Value {
2019    #[inline]
2020    fn from(v: FileCopyFlags) -> Self {
2021        ToValue::to_value(&v)
2022    }
2023}
2024
2025bitflags! {
2026    /// Flags used when an operation may create a file.
2027    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2028    #[doc(alias = "GFileCreateFlags")]
2029    pub struct FileCreateFlags: u32 {
2030        /// No flags set.
2031        #[doc(alias = "G_FILE_CREATE_NONE")]
2032        const NONE = ffi::G_FILE_CREATE_NONE as _;
2033        /// Create a file that can only be
2034        ///    accessed by the current user.
2035        #[doc(alias = "G_FILE_CREATE_PRIVATE")]
2036        const PRIVATE = ffi::G_FILE_CREATE_PRIVATE as _;
2037        /// Replace the destination
2038        ///    as if it didn't exist before. Don't try to keep any old
2039        ///    permissions, replace instead of following links. This
2040        ///    is generally useful if you're doing a "copy over"
2041        ///    rather than a "save new version of" replace operation.
2042        ///    You can think of it as "unlink destination" before
2043        ///    writing to it, although the implementation may not
2044        ///    be exactly like that. This flag can only be used with
2045        ///    g_file_replace() and its variants, including g_file_replace_contents().
2046        ///    Since 2.20
2047        #[doc(alias = "G_FILE_CREATE_REPLACE_DESTINATION")]
2048        const REPLACE_DESTINATION = ffi::G_FILE_CREATE_REPLACE_DESTINATION as _;
2049    }
2050}
2051
2052#[doc(hidden)]
2053impl IntoGlib for FileCreateFlags {
2054    type GlibType = ffi::GFileCreateFlags;
2055
2056    #[inline]
2057    fn into_glib(self) -> ffi::GFileCreateFlags {
2058        self.bits()
2059    }
2060}
2061
2062#[doc(hidden)]
2063impl FromGlib<ffi::GFileCreateFlags> for FileCreateFlags {
2064    #[inline]
2065    unsafe fn from_glib(value: ffi::GFileCreateFlags) -> Self {
2066        Self::from_bits_truncate(value)
2067    }
2068}
2069
2070impl StaticType for FileCreateFlags {
2071    #[inline]
2072    #[doc(alias = "g_file_create_flags_get_type")]
2073    fn static_type() -> glib::Type {
2074        unsafe { from_glib(ffi::g_file_create_flags_get_type()) }
2075    }
2076}
2077
2078impl glib::HasParamSpec for FileCreateFlags {
2079    type ParamSpec = glib::ParamSpecFlags;
2080    type SetValue = Self;
2081    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2082
2083    fn param_spec_builder() -> Self::BuilderFn {
2084        Self::ParamSpec::builder
2085    }
2086}
2087
2088impl glib::value::ValueType for FileCreateFlags {
2089    type Type = Self;
2090}
2091
2092unsafe impl<'a> glib::value::FromValue<'a> for FileCreateFlags {
2093    type Checker = glib::value::GenericValueTypeChecker<Self>;
2094
2095    #[inline]
2096    unsafe fn from_value(value: &'a glib::Value) -> Self {
2097        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2098    }
2099}
2100
2101impl ToValue for FileCreateFlags {
2102    #[inline]
2103    fn to_value(&self) -> glib::Value {
2104        let mut value = glib::Value::for_value_type::<Self>();
2105        unsafe {
2106            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2107        }
2108        value
2109    }
2110
2111    #[inline]
2112    fn value_type(&self) -> glib::Type {
2113        Self::static_type()
2114    }
2115}
2116
2117impl From<FileCreateFlags> for glib::Value {
2118    #[inline]
2119    fn from(v: FileCreateFlags) -> Self {
2120        ToValue::to_value(&v)
2121    }
2122}
2123
2124bitflags! {
2125    /// Flags that can be used with g_file_measure_disk_usage().
2126    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2127    #[doc(alias = "GFileMeasureFlags")]
2128    pub struct FileMeasureFlags: u32 {
2129        /// No flags set.
2130        #[doc(alias = "G_FILE_MEASURE_NONE")]
2131        const NONE = ffi::G_FILE_MEASURE_NONE as _;
2132        /// Report any error encountered
2133        ///   while traversing the directory tree.  Normally errors are only
2134        ///   reported for the toplevel file.
2135        #[doc(alias = "G_FILE_MEASURE_REPORT_ANY_ERROR")]
2136        const REPORT_ANY_ERROR = ffi::G_FILE_MEASURE_REPORT_ANY_ERROR as _;
2137        /// Tally usage based on apparent file
2138        ///   sizes.  Normally, the block-size is used, if available, as this is a
2139        ///   more accurate representation of disk space used.
2140        ///   Compare with `du --apparent-size`.
2141        ///   Since GLib 2.78. and similarly to `du` since GNU Coreutils 9.2, this will
2142        ///   ignore the sizes of file types other than regular files and links, as the
2143        ///   sizes of other file types are not specified in a standard way.
2144        #[doc(alias = "G_FILE_MEASURE_APPARENT_SIZE")]
2145        const APPARENT_SIZE = ffi::G_FILE_MEASURE_APPARENT_SIZE as _;
2146        /// Do not cross mount point boundaries.
2147        ///   Compare with `du -x`.
2148        #[doc(alias = "G_FILE_MEASURE_NO_XDEV")]
2149        const NO_XDEV = ffi::G_FILE_MEASURE_NO_XDEV as _;
2150    }
2151}
2152
2153#[doc(hidden)]
2154impl IntoGlib for FileMeasureFlags {
2155    type GlibType = ffi::GFileMeasureFlags;
2156
2157    #[inline]
2158    fn into_glib(self) -> ffi::GFileMeasureFlags {
2159        self.bits()
2160    }
2161}
2162
2163#[doc(hidden)]
2164impl FromGlib<ffi::GFileMeasureFlags> for FileMeasureFlags {
2165    #[inline]
2166    unsafe fn from_glib(value: ffi::GFileMeasureFlags) -> Self {
2167        Self::from_bits_truncate(value)
2168    }
2169}
2170
2171impl StaticType for FileMeasureFlags {
2172    #[inline]
2173    #[doc(alias = "g_file_measure_flags_get_type")]
2174    fn static_type() -> glib::Type {
2175        unsafe { from_glib(ffi::g_file_measure_flags_get_type()) }
2176    }
2177}
2178
2179impl glib::HasParamSpec for FileMeasureFlags {
2180    type ParamSpec = glib::ParamSpecFlags;
2181    type SetValue = Self;
2182    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2183
2184    fn param_spec_builder() -> Self::BuilderFn {
2185        Self::ParamSpec::builder
2186    }
2187}
2188
2189impl glib::value::ValueType for FileMeasureFlags {
2190    type Type = Self;
2191}
2192
2193unsafe impl<'a> glib::value::FromValue<'a> for FileMeasureFlags {
2194    type Checker = glib::value::GenericValueTypeChecker<Self>;
2195
2196    #[inline]
2197    unsafe fn from_value(value: &'a glib::Value) -> Self {
2198        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2199    }
2200}
2201
2202impl ToValue for FileMeasureFlags {
2203    #[inline]
2204    fn to_value(&self) -> glib::Value {
2205        let mut value = glib::Value::for_value_type::<Self>();
2206        unsafe {
2207            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2208        }
2209        value
2210    }
2211
2212    #[inline]
2213    fn value_type(&self) -> glib::Type {
2214        Self::static_type()
2215    }
2216}
2217
2218impl From<FileMeasureFlags> for glib::Value {
2219    #[inline]
2220    fn from(v: FileMeasureFlags) -> Self {
2221        ToValue::to_value(&v)
2222    }
2223}
2224
2225bitflags! {
2226    /// Flags used to set what a #GFileMonitor will watch for.
2227    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2228    #[doc(alias = "GFileMonitorFlags")]
2229    pub struct FileMonitorFlags: u32 {
2230        /// No flags set.
2231        #[doc(alias = "G_FILE_MONITOR_NONE")]
2232        const NONE = ffi::G_FILE_MONITOR_NONE as _;
2233        /// Watch for mount events.
2234        #[doc(alias = "G_FILE_MONITOR_WATCH_MOUNTS")]
2235        const WATCH_MOUNTS = ffi::G_FILE_MONITOR_WATCH_MOUNTS as _;
2236        /// Pair DELETED and CREATED events caused
2237        ///   by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED
2238        ///   event instead (NB: not supported on all backends; the default
2239        ///   behaviour -without specifying this flag- is to send single DELETED
2240        ///   and CREATED events).  Deprecated since 2.46: use
2241        ///   [`WATCH_MOVES`][Self::WATCH_MOVES] instead.
2242        #[doc(alias = "G_FILE_MONITOR_SEND_MOVED")]
2243        const SEND_MOVED = ffi::G_FILE_MONITOR_SEND_MOVED as _;
2244        /// Watch for changes to the file made
2245        ///   via another hard link. Since 2.36.
2246        #[doc(alias = "G_FILE_MONITOR_WATCH_HARD_LINKS")]
2247        const WATCH_HARD_LINKS = ffi::G_FILE_MONITOR_WATCH_HARD_LINKS as _;
2248        /// Watch for rename operations on a
2249        ///   monitored directory.  This causes [`FileMonitorEvent::Renamed`][crate::FileMonitorEvent::Renamed],
2250        ///   [`FileMonitorEvent::MovedIn`][crate::FileMonitorEvent::MovedIn] and [`FileMonitorEvent::MovedOut`][crate::FileMonitorEvent::MovedOut]
2251        ///   events to be emitted when possible.  Since: 2.46.
2252        #[doc(alias = "G_FILE_MONITOR_WATCH_MOVES")]
2253        const WATCH_MOVES = ffi::G_FILE_MONITOR_WATCH_MOVES as _;
2254    }
2255}
2256
2257#[doc(hidden)]
2258impl IntoGlib for FileMonitorFlags {
2259    type GlibType = ffi::GFileMonitorFlags;
2260
2261    #[inline]
2262    fn into_glib(self) -> ffi::GFileMonitorFlags {
2263        self.bits()
2264    }
2265}
2266
2267#[doc(hidden)]
2268impl FromGlib<ffi::GFileMonitorFlags> for FileMonitorFlags {
2269    #[inline]
2270    unsafe fn from_glib(value: ffi::GFileMonitorFlags) -> Self {
2271        Self::from_bits_truncate(value)
2272    }
2273}
2274
2275impl StaticType for FileMonitorFlags {
2276    #[inline]
2277    #[doc(alias = "g_file_monitor_flags_get_type")]
2278    fn static_type() -> glib::Type {
2279        unsafe { from_glib(ffi::g_file_monitor_flags_get_type()) }
2280    }
2281}
2282
2283impl glib::HasParamSpec for FileMonitorFlags {
2284    type ParamSpec = glib::ParamSpecFlags;
2285    type SetValue = Self;
2286    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2287
2288    fn param_spec_builder() -> Self::BuilderFn {
2289        Self::ParamSpec::builder
2290    }
2291}
2292
2293impl glib::value::ValueType for FileMonitorFlags {
2294    type Type = Self;
2295}
2296
2297unsafe impl<'a> glib::value::FromValue<'a> for FileMonitorFlags {
2298    type Checker = glib::value::GenericValueTypeChecker<Self>;
2299
2300    #[inline]
2301    unsafe fn from_value(value: &'a glib::Value) -> Self {
2302        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2303    }
2304}
2305
2306impl ToValue for FileMonitorFlags {
2307    #[inline]
2308    fn to_value(&self) -> glib::Value {
2309        let mut value = glib::Value::for_value_type::<Self>();
2310        unsafe {
2311            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2312        }
2313        value
2314    }
2315
2316    #[inline]
2317    fn value_type(&self) -> glib::Type {
2318        Self::static_type()
2319    }
2320}
2321
2322impl From<FileMonitorFlags> for glib::Value {
2323    #[inline]
2324    fn from(v: FileMonitorFlags) -> Self {
2325        ToValue::to_value(&v)
2326    }
2327}
2328
2329bitflags! {
2330    /// Flags used when querying a #GFileInfo.
2331    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2332    #[doc(alias = "GFileQueryInfoFlags")]
2333    pub struct FileQueryInfoFlags: u32 {
2334        /// No flags set.
2335        #[doc(alias = "G_FILE_QUERY_INFO_NONE")]
2336        const NONE = ffi::G_FILE_QUERY_INFO_NONE as _;
2337        /// Don't follow symlinks.
2338        #[doc(alias = "G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS")]
2339        const NOFOLLOW_SYMLINKS = ffi::G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS as _;
2340    }
2341}
2342
2343#[doc(hidden)]
2344impl IntoGlib for FileQueryInfoFlags {
2345    type GlibType = ffi::GFileQueryInfoFlags;
2346
2347    #[inline]
2348    fn into_glib(self) -> ffi::GFileQueryInfoFlags {
2349        self.bits()
2350    }
2351}
2352
2353#[doc(hidden)]
2354impl FromGlib<ffi::GFileQueryInfoFlags> for FileQueryInfoFlags {
2355    #[inline]
2356    unsafe fn from_glib(value: ffi::GFileQueryInfoFlags) -> Self {
2357        Self::from_bits_truncate(value)
2358    }
2359}
2360
2361impl StaticType for FileQueryInfoFlags {
2362    #[inline]
2363    #[doc(alias = "g_file_query_info_flags_get_type")]
2364    fn static_type() -> glib::Type {
2365        unsafe { from_glib(ffi::g_file_query_info_flags_get_type()) }
2366    }
2367}
2368
2369impl glib::HasParamSpec for FileQueryInfoFlags {
2370    type ParamSpec = glib::ParamSpecFlags;
2371    type SetValue = Self;
2372    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2373
2374    fn param_spec_builder() -> Self::BuilderFn {
2375        Self::ParamSpec::builder
2376    }
2377}
2378
2379impl glib::value::ValueType for FileQueryInfoFlags {
2380    type Type = Self;
2381}
2382
2383unsafe impl<'a> glib::value::FromValue<'a> for FileQueryInfoFlags {
2384    type Checker = glib::value::GenericValueTypeChecker<Self>;
2385
2386    #[inline]
2387    unsafe fn from_value(value: &'a glib::Value) -> Self {
2388        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2389    }
2390}
2391
2392impl ToValue for FileQueryInfoFlags {
2393    #[inline]
2394    fn to_value(&self) -> glib::Value {
2395        let mut value = glib::Value::for_value_type::<Self>();
2396        unsafe {
2397            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2398        }
2399        value
2400    }
2401
2402    #[inline]
2403    fn value_type(&self) -> glib::Type {
2404        Self::static_type()
2405    }
2406}
2407
2408impl From<FileQueryInfoFlags> for glib::Value {
2409    #[inline]
2410    fn from(v: FileQueryInfoFlags) -> Self {
2411        ToValue::to_value(&v)
2412    }
2413}
2414
2415bitflags! {
2416    /// GIOStreamSpliceFlags determine how streams should be spliced.
2417    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2418    #[doc(alias = "GIOStreamSpliceFlags")]
2419    pub struct IOStreamSpliceFlags: u32 {
2420        /// Do not close either stream.
2421        #[doc(alias = "G_IO_STREAM_SPLICE_NONE")]
2422        const NONE = ffi::G_IO_STREAM_SPLICE_NONE as _;
2423        /// Close the first stream after
2424        ///     the splice.
2425        #[doc(alias = "G_IO_STREAM_SPLICE_CLOSE_STREAM1")]
2426        const CLOSE_STREAM1 = ffi::G_IO_STREAM_SPLICE_CLOSE_STREAM1 as _;
2427        /// Close the second stream after
2428        ///     the splice.
2429        #[doc(alias = "G_IO_STREAM_SPLICE_CLOSE_STREAM2")]
2430        const CLOSE_STREAM2 = ffi::G_IO_STREAM_SPLICE_CLOSE_STREAM2 as _;
2431        /// Wait for both splice operations to finish
2432        ///     before calling the callback.
2433        #[doc(alias = "G_IO_STREAM_SPLICE_WAIT_FOR_BOTH")]
2434        const WAIT_FOR_BOTH = ffi::G_IO_STREAM_SPLICE_WAIT_FOR_BOTH as _;
2435    }
2436}
2437
2438#[doc(hidden)]
2439impl IntoGlib for IOStreamSpliceFlags {
2440    type GlibType = ffi::GIOStreamSpliceFlags;
2441
2442    #[inline]
2443    fn into_glib(self) -> ffi::GIOStreamSpliceFlags {
2444        self.bits()
2445    }
2446}
2447
2448#[doc(hidden)]
2449impl FromGlib<ffi::GIOStreamSpliceFlags> for IOStreamSpliceFlags {
2450    #[inline]
2451    unsafe fn from_glib(value: ffi::GIOStreamSpliceFlags) -> Self {
2452        Self::from_bits_truncate(value)
2453    }
2454}
2455
2456impl StaticType for IOStreamSpliceFlags {
2457    #[inline]
2458    #[doc(alias = "g_io_stream_splice_flags_get_type")]
2459    fn static_type() -> glib::Type {
2460        unsafe { from_glib(ffi::g_io_stream_splice_flags_get_type()) }
2461    }
2462}
2463
2464impl glib::HasParamSpec for IOStreamSpliceFlags {
2465    type ParamSpec = glib::ParamSpecFlags;
2466    type SetValue = Self;
2467    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2468
2469    fn param_spec_builder() -> Self::BuilderFn {
2470        Self::ParamSpec::builder
2471    }
2472}
2473
2474impl glib::value::ValueType for IOStreamSpliceFlags {
2475    type Type = Self;
2476}
2477
2478unsafe impl<'a> glib::value::FromValue<'a> for IOStreamSpliceFlags {
2479    type Checker = glib::value::GenericValueTypeChecker<Self>;
2480
2481    #[inline]
2482    unsafe fn from_value(value: &'a glib::Value) -> Self {
2483        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2484    }
2485}
2486
2487impl ToValue for IOStreamSpliceFlags {
2488    #[inline]
2489    fn to_value(&self) -> glib::Value {
2490        let mut value = glib::Value::for_value_type::<Self>();
2491        unsafe {
2492            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2493        }
2494        value
2495    }
2496
2497    #[inline]
2498    fn value_type(&self) -> glib::Type {
2499        Self::static_type()
2500    }
2501}
2502
2503impl From<IOStreamSpliceFlags> for glib::Value {
2504    #[inline]
2505    fn from(v: IOStreamSpliceFlags) -> Self {
2506        ToValue::to_value(&v)
2507    }
2508}
2509
2510bitflags! {
2511    /// Flags used when mounting a mount.
2512    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2513    #[doc(alias = "GMountMountFlags")]
2514    pub struct MountMountFlags: u32 {
2515        /// No flags set.
2516        #[doc(alias = "G_MOUNT_MOUNT_NONE")]
2517        const NONE = ffi::G_MOUNT_MOUNT_NONE as _;
2518    }
2519}
2520
2521#[doc(hidden)]
2522impl IntoGlib for MountMountFlags {
2523    type GlibType = ffi::GMountMountFlags;
2524
2525    #[inline]
2526    fn into_glib(self) -> ffi::GMountMountFlags {
2527        self.bits()
2528    }
2529}
2530
2531#[doc(hidden)]
2532impl FromGlib<ffi::GMountMountFlags> for MountMountFlags {
2533    #[inline]
2534    unsafe fn from_glib(value: ffi::GMountMountFlags) -> Self {
2535        Self::from_bits_truncate(value)
2536    }
2537}
2538
2539impl StaticType for MountMountFlags {
2540    #[inline]
2541    #[doc(alias = "g_mount_mount_flags_get_type")]
2542    fn static_type() -> glib::Type {
2543        unsafe { from_glib(ffi::g_mount_mount_flags_get_type()) }
2544    }
2545}
2546
2547impl glib::HasParamSpec for MountMountFlags {
2548    type ParamSpec = glib::ParamSpecFlags;
2549    type SetValue = Self;
2550    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2551
2552    fn param_spec_builder() -> Self::BuilderFn {
2553        Self::ParamSpec::builder
2554    }
2555}
2556
2557impl glib::value::ValueType for MountMountFlags {
2558    type Type = Self;
2559}
2560
2561unsafe impl<'a> glib::value::FromValue<'a> for MountMountFlags {
2562    type Checker = glib::value::GenericValueTypeChecker<Self>;
2563
2564    #[inline]
2565    unsafe fn from_value(value: &'a glib::Value) -> Self {
2566        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2567    }
2568}
2569
2570impl ToValue for MountMountFlags {
2571    #[inline]
2572    fn to_value(&self) -> glib::Value {
2573        let mut value = glib::Value::for_value_type::<Self>();
2574        unsafe {
2575            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2576        }
2577        value
2578    }
2579
2580    #[inline]
2581    fn value_type(&self) -> glib::Type {
2582        Self::static_type()
2583    }
2584}
2585
2586impl From<MountMountFlags> for glib::Value {
2587    #[inline]
2588    fn from(v: MountMountFlags) -> Self {
2589        ToValue::to_value(&v)
2590    }
2591}
2592
2593bitflags! {
2594    /// Flags used when an unmounting a mount.
2595    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2596    #[doc(alias = "GMountUnmountFlags")]
2597    pub struct MountUnmountFlags: u32 {
2598        /// No flags set.
2599        #[doc(alias = "G_MOUNT_UNMOUNT_NONE")]
2600        const NONE = ffi::G_MOUNT_UNMOUNT_NONE as _;
2601        /// Unmount even if there are outstanding
2602        ///  file operations on the mount.
2603        #[doc(alias = "G_MOUNT_UNMOUNT_FORCE")]
2604        const FORCE = ffi::G_MOUNT_UNMOUNT_FORCE as _;
2605    }
2606}
2607
2608#[doc(hidden)]
2609impl IntoGlib for MountUnmountFlags {
2610    type GlibType = ffi::GMountUnmountFlags;
2611
2612    #[inline]
2613    fn into_glib(self) -> ffi::GMountUnmountFlags {
2614        self.bits()
2615    }
2616}
2617
2618#[doc(hidden)]
2619impl FromGlib<ffi::GMountUnmountFlags> for MountUnmountFlags {
2620    #[inline]
2621    unsafe fn from_glib(value: ffi::GMountUnmountFlags) -> Self {
2622        Self::from_bits_truncate(value)
2623    }
2624}
2625
2626impl StaticType for MountUnmountFlags {
2627    #[inline]
2628    #[doc(alias = "g_mount_unmount_flags_get_type")]
2629    fn static_type() -> glib::Type {
2630        unsafe { from_glib(ffi::g_mount_unmount_flags_get_type()) }
2631    }
2632}
2633
2634impl glib::HasParamSpec for MountUnmountFlags {
2635    type ParamSpec = glib::ParamSpecFlags;
2636    type SetValue = Self;
2637    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2638
2639    fn param_spec_builder() -> Self::BuilderFn {
2640        Self::ParamSpec::builder
2641    }
2642}
2643
2644impl glib::value::ValueType for MountUnmountFlags {
2645    type Type = Self;
2646}
2647
2648unsafe impl<'a> glib::value::FromValue<'a> for MountUnmountFlags {
2649    type Checker = glib::value::GenericValueTypeChecker<Self>;
2650
2651    #[inline]
2652    unsafe fn from_value(value: &'a glib::Value) -> Self {
2653        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2654    }
2655}
2656
2657impl ToValue for MountUnmountFlags {
2658    #[inline]
2659    fn to_value(&self) -> glib::Value {
2660        let mut value = glib::Value::for_value_type::<Self>();
2661        unsafe {
2662            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2663        }
2664        value
2665    }
2666
2667    #[inline]
2668    fn value_type(&self) -> glib::Type {
2669        Self::static_type()
2670    }
2671}
2672
2673impl From<MountUnmountFlags> for glib::Value {
2674    #[inline]
2675    fn from(v: MountUnmountFlags) -> Self {
2676        ToValue::to_value(&v)
2677    }
2678}
2679
2680bitflags! {
2681    /// GOutputStreamSpliceFlags determine how streams should be spliced.
2682    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2683    #[doc(alias = "GOutputStreamSpliceFlags")]
2684    pub struct OutputStreamSpliceFlags: u32 {
2685        /// Do not close either stream.
2686        #[doc(alias = "G_OUTPUT_STREAM_SPLICE_NONE")]
2687        const NONE = ffi::G_OUTPUT_STREAM_SPLICE_NONE as _;
2688        /// Close the source stream after
2689        ///     the splice.
2690        #[doc(alias = "G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE")]
2691        const CLOSE_SOURCE = ffi::G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE as _;
2692        /// Close the target stream after
2693        ///     the splice.
2694        #[doc(alias = "G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET")]
2695        const CLOSE_TARGET = ffi::G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET as _;
2696    }
2697}
2698
2699#[doc(hidden)]
2700impl IntoGlib for OutputStreamSpliceFlags {
2701    type GlibType = ffi::GOutputStreamSpliceFlags;
2702
2703    #[inline]
2704    fn into_glib(self) -> ffi::GOutputStreamSpliceFlags {
2705        self.bits()
2706    }
2707}
2708
2709#[doc(hidden)]
2710impl FromGlib<ffi::GOutputStreamSpliceFlags> for OutputStreamSpliceFlags {
2711    #[inline]
2712    unsafe fn from_glib(value: ffi::GOutputStreamSpliceFlags) -> Self {
2713        Self::from_bits_truncate(value)
2714    }
2715}
2716
2717impl StaticType for OutputStreamSpliceFlags {
2718    #[inline]
2719    #[doc(alias = "g_output_stream_splice_flags_get_type")]
2720    fn static_type() -> glib::Type {
2721        unsafe { from_glib(ffi::g_output_stream_splice_flags_get_type()) }
2722    }
2723}
2724
2725impl glib::HasParamSpec for OutputStreamSpliceFlags {
2726    type ParamSpec = glib::ParamSpecFlags;
2727    type SetValue = Self;
2728    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2729
2730    fn param_spec_builder() -> Self::BuilderFn {
2731        Self::ParamSpec::builder
2732    }
2733}
2734
2735impl glib::value::ValueType for OutputStreamSpliceFlags {
2736    type Type = Self;
2737}
2738
2739unsafe impl<'a> glib::value::FromValue<'a> for OutputStreamSpliceFlags {
2740    type Checker = glib::value::GenericValueTypeChecker<Self>;
2741
2742    #[inline]
2743    unsafe fn from_value(value: &'a glib::Value) -> Self {
2744        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2745    }
2746}
2747
2748impl ToValue for OutputStreamSpliceFlags {
2749    #[inline]
2750    fn to_value(&self) -> glib::Value {
2751        let mut value = glib::Value::for_value_type::<Self>();
2752        unsafe {
2753            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2754        }
2755        value
2756    }
2757
2758    #[inline]
2759    fn value_type(&self) -> glib::Type {
2760        Self::static_type()
2761    }
2762}
2763
2764impl From<OutputStreamSpliceFlags> for glib::Value {
2765    #[inline]
2766    fn from(v: OutputStreamSpliceFlags) -> Self {
2767        ToValue::to_value(&v)
2768    }
2769}
2770
2771#[cfg(feature = "v2_60")]
2772bitflags! {
2773    /// Flags to modify lookup behavior.
2774    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2775    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2776    #[doc(alias = "GResolverNameLookupFlags")]
2777    pub struct ResolverNameLookupFlags: u32 {
2778        /// default behavior (same as g_resolver_lookup_by_name())
2779        #[doc(alias = "G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT")]
2780        const DEFAULT = ffi::G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT as _;
2781        /// only resolve ipv4 addresses
2782        #[doc(alias = "G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY")]
2783        const IPV4_ONLY = ffi::G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY as _;
2784        /// only resolve ipv6 addresses
2785        #[doc(alias = "G_RESOLVER_NAME_LOOKUP_FLAGS_IPV6_ONLY")]
2786        const IPV6_ONLY = ffi::G_RESOLVER_NAME_LOOKUP_FLAGS_IPV6_ONLY as _;
2787    }
2788}
2789
2790#[cfg(feature = "v2_60")]
2791#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2792#[doc(hidden)]
2793impl IntoGlib for ResolverNameLookupFlags {
2794    type GlibType = ffi::GResolverNameLookupFlags;
2795
2796    #[inline]
2797    fn into_glib(self) -> ffi::GResolverNameLookupFlags {
2798        self.bits()
2799    }
2800}
2801
2802#[cfg(feature = "v2_60")]
2803#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2804#[doc(hidden)]
2805impl FromGlib<ffi::GResolverNameLookupFlags> for ResolverNameLookupFlags {
2806    #[inline]
2807    unsafe fn from_glib(value: ffi::GResolverNameLookupFlags) -> Self {
2808        Self::from_bits_truncate(value)
2809    }
2810}
2811
2812#[cfg(feature = "v2_60")]
2813#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2814impl StaticType for ResolverNameLookupFlags {
2815    #[inline]
2816    #[doc(alias = "g_resolver_name_lookup_flags_get_type")]
2817    fn static_type() -> glib::Type {
2818        unsafe { from_glib(ffi::g_resolver_name_lookup_flags_get_type()) }
2819    }
2820}
2821
2822#[cfg(feature = "v2_60")]
2823#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2824impl glib::HasParamSpec for ResolverNameLookupFlags {
2825    type ParamSpec = glib::ParamSpecFlags;
2826    type SetValue = Self;
2827    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2828
2829    fn param_spec_builder() -> Self::BuilderFn {
2830        Self::ParamSpec::builder
2831    }
2832}
2833
2834#[cfg(feature = "v2_60")]
2835#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2836impl glib::value::ValueType for ResolverNameLookupFlags {
2837    type Type = Self;
2838}
2839
2840#[cfg(feature = "v2_60")]
2841#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2842unsafe impl<'a> glib::value::FromValue<'a> for ResolverNameLookupFlags {
2843    type Checker = glib::value::GenericValueTypeChecker<Self>;
2844
2845    #[inline]
2846    unsafe fn from_value(value: &'a glib::Value) -> Self {
2847        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2848    }
2849}
2850
2851#[cfg(feature = "v2_60")]
2852#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2853impl ToValue for ResolverNameLookupFlags {
2854    #[inline]
2855    fn to_value(&self) -> glib::Value {
2856        let mut value = glib::Value::for_value_type::<Self>();
2857        unsafe {
2858            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2859        }
2860        value
2861    }
2862
2863    #[inline]
2864    fn value_type(&self) -> glib::Type {
2865        Self::static_type()
2866    }
2867}
2868
2869#[cfg(feature = "v2_60")]
2870#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2871impl From<ResolverNameLookupFlags> for glib::Value {
2872    #[inline]
2873    fn from(v: ResolverNameLookupFlags) -> Self {
2874        ToValue::to_value(&v)
2875    }
2876}
2877
2878bitflags! {
2879    /// GResourceFlags give information about a particular file inside a resource
2880    /// bundle.
2881    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2882    #[doc(alias = "GResourceFlags")]
2883    pub struct ResourceFlags: u32 {
2884        /// No flags set.
2885        #[doc(alias = "G_RESOURCE_FLAGS_NONE")]
2886        const NONE = ffi::G_RESOURCE_FLAGS_NONE as _;
2887        /// The file is compressed.
2888        #[doc(alias = "G_RESOURCE_FLAGS_COMPRESSED")]
2889        const COMPRESSED = ffi::G_RESOURCE_FLAGS_COMPRESSED as _;
2890    }
2891}
2892
2893#[doc(hidden)]
2894impl IntoGlib for ResourceFlags {
2895    type GlibType = ffi::GResourceFlags;
2896
2897    #[inline]
2898    fn into_glib(self) -> ffi::GResourceFlags {
2899        self.bits()
2900    }
2901}
2902
2903#[doc(hidden)]
2904impl FromGlib<ffi::GResourceFlags> for ResourceFlags {
2905    #[inline]
2906    unsafe fn from_glib(value: ffi::GResourceFlags) -> Self {
2907        Self::from_bits_truncate(value)
2908    }
2909}
2910
2911impl StaticType for ResourceFlags {
2912    #[inline]
2913    #[doc(alias = "g_resource_flags_get_type")]
2914    fn static_type() -> glib::Type {
2915        unsafe { from_glib(ffi::g_resource_flags_get_type()) }
2916    }
2917}
2918
2919impl glib::HasParamSpec for ResourceFlags {
2920    type ParamSpec = glib::ParamSpecFlags;
2921    type SetValue = Self;
2922    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2923
2924    fn param_spec_builder() -> Self::BuilderFn {
2925        Self::ParamSpec::builder
2926    }
2927}
2928
2929impl glib::value::ValueType for ResourceFlags {
2930    type Type = Self;
2931}
2932
2933unsafe impl<'a> glib::value::FromValue<'a> for ResourceFlags {
2934    type Checker = glib::value::GenericValueTypeChecker<Self>;
2935
2936    #[inline]
2937    unsafe fn from_value(value: &'a glib::Value) -> Self {
2938        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2939    }
2940}
2941
2942impl ToValue for ResourceFlags {
2943    #[inline]
2944    fn to_value(&self) -> glib::Value {
2945        let mut value = glib::Value::for_value_type::<Self>();
2946        unsafe {
2947            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2948        }
2949        value
2950    }
2951
2952    #[inline]
2953    fn value_type(&self) -> glib::Type {
2954        Self::static_type()
2955    }
2956}
2957
2958impl From<ResourceFlags> for glib::Value {
2959    #[inline]
2960    fn from(v: ResourceFlags) -> Self {
2961        ToValue::to_value(&v)
2962    }
2963}
2964
2965bitflags! {
2966    /// GResourceLookupFlags determine how resource path lookups are handled.
2967    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2968    #[doc(alias = "GResourceLookupFlags")]
2969    pub struct ResourceLookupFlags: u32 {
2970        /// No flags set.
2971        #[doc(alias = "G_RESOURCE_LOOKUP_FLAGS_NONE")]
2972        const NONE = ffi::G_RESOURCE_LOOKUP_FLAGS_NONE as _;
2973    }
2974}
2975
2976#[doc(hidden)]
2977impl IntoGlib for ResourceLookupFlags {
2978    type GlibType = ffi::GResourceLookupFlags;
2979
2980    #[inline]
2981    fn into_glib(self) -> ffi::GResourceLookupFlags {
2982        self.bits()
2983    }
2984}
2985
2986#[doc(hidden)]
2987impl FromGlib<ffi::GResourceLookupFlags> for ResourceLookupFlags {
2988    #[inline]
2989    unsafe fn from_glib(value: ffi::GResourceLookupFlags) -> Self {
2990        Self::from_bits_truncate(value)
2991    }
2992}
2993
2994impl StaticType for ResourceLookupFlags {
2995    #[inline]
2996    #[doc(alias = "g_resource_lookup_flags_get_type")]
2997    fn static_type() -> glib::Type {
2998        unsafe { from_glib(ffi::g_resource_lookup_flags_get_type()) }
2999    }
3000}
3001
3002impl glib::HasParamSpec for ResourceLookupFlags {
3003    type ParamSpec = glib::ParamSpecFlags;
3004    type SetValue = Self;
3005    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3006
3007    fn param_spec_builder() -> Self::BuilderFn {
3008        Self::ParamSpec::builder
3009    }
3010}
3011
3012impl glib::value::ValueType for ResourceLookupFlags {
3013    type Type = Self;
3014}
3015
3016unsafe impl<'a> glib::value::FromValue<'a> for ResourceLookupFlags {
3017    type Checker = glib::value::GenericValueTypeChecker<Self>;
3018
3019    #[inline]
3020    unsafe fn from_value(value: &'a glib::Value) -> Self {
3021        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3022    }
3023}
3024
3025impl ToValue for ResourceLookupFlags {
3026    #[inline]
3027    fn to_value(&self) -> glib::Value {
3028        let mut value = glib::Value::for_value_type::<Self>();
3029        unsafe {
3030            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3031        }
3032        value
3033    }
3034
3035    #[inline]
3036    fn value_type(&self) -> glib::Type {
3037        Self::static_type()
3038    }
3039}
3040
3041impl From<ResourceLookupFlags> for glib::Value {
3042    #[inline]
3043    fn from(v: ResourceLookupFlags) -> Self {
3044        ToValue::to_value(&v)
3045    }
3046}
3047
3048bitflags! {
3049    /// Flags used when creating a binding. These flags determine in which
3050    /// direction the binding works. The default is to synchronize in both
3051    /// directions.
3052    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3053    #[doc(alias = "GSettingsBindFlags")]
3054    pub struct SettingsBindFlags: u32 {
3055        /// Equivalent to `G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET`
3056        #[doc(alias = "G_SETTINGS_BIND_DEFAULT")]
3057        const DEFAULT = ffi::G_SETTINGS_BIND_DEFAULT as _;
3058        /// Update the #GObject property when the setting changes.
3059        ///     It is an error to use this flag if the property is not writable.
3060        #[doc(alias = "G_SETTINGS_BIND_GET")]
3061        const GET = ffi::G_SETTINGS_BIND_GET as _;
3062        /// Update the setting when the #GObject property changes.
3063        ///     It is an error to use this flag if the property is not readable.
3064        #[doc(alias = "G_SETTINGS_BIND_SET")]
3065        const SET = ffi::G_SETTINGS_BIND_SET as _;
3066        /// Do not try to bind a "sensitivity" property to the writability of the setting
3067        #[doc(alias = "G_SETTINGS_BIND_NO_SENSITIVITY")]
3068        const NO_SENSITIVITY = ffi::G_SETTINGS_BIND_NO_SENSITIVITY as _;
3069        /// When set in addition to [`GET`][Self::GET], set the #GObject property
3070        ///     value initially from the setting, but do not listen for changes of the setting
3071        #[doc(alias = "G_SETTINGS_BIND_GET_NO_CHANGES")]
3072        const GET_NO_CHANGES = ffi::G_SETTINGS_BIND_GET_NO_CHANGES as _;
3073        /// When passed to g_settings_bind(), uses a pair of mapping functions that invert
3074        ///     the boolean value when mapping between the setting and the property.  The setting and property must both
3075        ///     be booleans.  You cannot pass this flag to g_settings_bind_with_mapping().
3076        #[doc(alias = "G_SETTINGS_BIND_INVERT_BOOLEAN")]
3077        const INVERT_BOOLEAN = ffi::G_SETTINGS_BIND_INVERT_BOOLEAN as _;
3078    }
3079}
3080
3081#[doc(hidden)]
3082impl IntoGlib for SettingsBindFlags {
3083    type GlibType = ffi::GSettingsBindFlags;
3084
3085    #[inline]
3086    fn into_glib(self) -> ffi::GSettingsBindFlags {
3087        self.bits()
3088    }
3089}
3090
3091#[doc(hidden)]
3092impl FromGlib<ffi::GSettingsBindFlags> for SettingsBindFlags {
3093    #[inline]
3094    unsafe fn from_glib(value: ffi::GSettingsBindFlags) -> Self {
3095        Self::from_bits_truncate(value)
3096    }
3097}
3098
3099impl StaticType for SettingsBindFlags {
3100    #[inline]
3101    #[doc(alias = "g_settings_bind_flags_get_type")]
3102    fn static_type() -> glib::Type {
3103        unsafe { from_glib(ffi::g_settings_bind_flags_get_type()) }
3104    }
3105}
3106
3107impl glib::HasParamSpec for SettingsBindFlags {
3108    type ParamSpec = glib::ParamSpecFlags;
3109    type SetValue = Self;
3110    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3111
3112    fn param_spec_builder() -> Self::BuilderFn {
3113        Self::ParamSpec::builder
3114    }
3115}
3116
3117impl glib::value::ValueType for SettingsBindFlags {
3118    type Type = Self;
3119}
3120
3121unsafe impl<'a> glib::value::FromValue<'a> for SettingsBindFlags {
3122    type Checker = glib::value::GenericValueTypeChecker<Self>;
3123
3124    #[inline]
3125    unsafe fn from_value(value: &'a glib::Value) -> Self {
3126        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3127    }
3128}
3129
3130impl ToValue for SettingsBindFlags {
3131    #[inline]
3132    fn to_value(&self) -> glib::Value {
3133        let mut value = glib::Value::for_value_type::<Self>();
3134        unsafe {
3135            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3136        }
3137        value
3138    }
3139
3140    #[inline]
3141    fn value_type(&self) -> glib::Type {
3142        Self::static_type()
3143    }
3144}
3145
3146impl From<SettingsBindFlags> for glib::Value {
3147    #[inline]
3148    fn from(v: SettingsBindFlags) -> Self {
3149        ToValue::to_value(&v)
3150    }
3151}
3152
3153bitflags! {
3154    /// Flags to define the behaviour of a #GSubprocess.
3155    ///
3156    /// Note that the default for stdin is to redirect from `/dev/null`.  For
3157    /// stdout and stderr the default are for them to inherit the
3158    /// corresponding descriptor from the calling process.
3159    ///
3160    /// Note that it is a programmer error to mix 'incompatible' flags.  For
3161    /// example, you may not request both [`STDOUT_PIPE`][Self::STDOUT_PIPE] and
3162    /// [`STDOUT_SILENCE`][Self::STDOUT_SILENCE].
3163    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3164    #[doc(alias = "GSubprocessFlags")]
3165    pub struct SubprocessFlags: u32 {
3166        /// No flags.
3167        #[doc(alias = "G_SUBPROCESS_FLAGS_NONE")]
3168        const NONE = ffi::G_SUBPROCESS_FLAGS_NONE as _;
3169        /// create a pipe for the stdin of the
3170        ///   spawned process that can be accessed with
3171        ///   g_subprocess_get_stdin_pipe().
3172        #[doc(alias = "G_SUBPROCESS_FLAGS_STDIN_PIPE")]
3173        const STDIN_PIPE = ffi::G_SUBPROCESS_FLAGS_STDIN_PIPE as _;
3174        /// stdin is inherited from the
3175        ///   calling process.
3176        #[doc(alias = "G_SUBPROCESS_FLAGS_STDIN_INHERIT")]
3177        const STDIN_INHERIT = ffi::G_SUBPROCESS_FLAGS_STDIN_INHERIT as _;
3178        /// create a pipe for the stdout of the
3179        ///   spawned process that can be accessed with
3180        ///   g_subprocess_get_stdout_pipe().
3181        #[doc(alias = "G_SUBPROCESS_FLAGS_STDOUT_PIPE")]
3182        const STDOUT_PIPE = ffi::G_SUBPROCESS_FLAGS_STDOUT_PIPE as _;
3183        /// silence the stdout of the spawned
3184        ///   process (ie: redirect to `/dev/null`).
3185        #[doc(alias = "G_SUBPROCESS_FLAGS_STDOUT_SILENCE")]
3186        const STDOUT_SILENCE = ffi::G_SUBPROCESS_FLAGS_STDOUT_SILENCE as _;
3187        /// create a pipe for the stderr of the
3188        ///   spawned process that can be accessed with
3189        ///   g_subprocess_get_stderr_pipe().
3190        #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_PIPE")]
3191        const STDERR_PIPE = ffi::G_SUBPROCESS_FLAGS_STDERR_PIPE as _;
3192        /// silence the stderr of the spawned
3193        ///   process (ie: redirect to `/dev/null`).
3194        #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_SILENCE")]
3195        const STDERR_SILENCE = ffi::G_SUBPROCESS_FLAGS_STDERR_SILENCE as _;
3196        /// merge the stderr of the spawned
3197        ///   process with whatever the stdout happens to be.  This is a good way
3198        ///   of directing both streams to a common log file, for example.
3199        #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_MERGE")]
3200        const STDERR_MERGE = ffi::G_SUBPROCESS_FLAGS_STDERR_MERGE as _;
3201        /// spawned processes will inherit the
3202        ///   file descriptors of their parent, unless those descriptors have
3203        ///   been explicitly marked as close-on-exec.  This flag has no effect
3204        ///   over the "standard" file descriptors (stdin, stdout, stderr).
3205        #[doc(alias = "G_SUBPROCESS_FLAGS_INHERIT_FDS")]
3206        const INHERIT_FDS = ffi::G_SUBPROCESS_FLAGS_INHERIT_FDS as _;
3207        /// if path searching is
3208        ///   needed when spawning the subprocess, use the `PATH` in the launcher
3209        ///   environment. (Since: 2.72)
3210        #[cfg(feature = "v2_72")]
3211        #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
3212        #[doc(alias = "G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP")]
3213        const SEARCH_PATH_FROM_ENVP = ffi::G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP as _;
3214    }
3215}
3216
3217#[doc(hidden)]
3218impl IntoGlib for SubprocessFlags {
3219    type GlibType = ffi::GSubprocessFlags;
3220
3221    #[inline]
3222    fn into_glib(self) -> ffi::GSubprocessFlags {
3223        self.bits()
3224    }
3225}
3226
3227#[doc(hidden)]
3228impl FromGlib<ffi::GSubprocessFlags> for SubprocessFlags {
3229    #[inline]
3230    unsafe fn from_glib(value: ffi::GSubprocessFlags) -> Self {
3231        Self::from_bits_truncate(value)
3232    }
3233}
3234
3235impl StaticType for SubprocessFlags {
3236    #[inline]
3237    #[doc(alias = "g_subprocess_flags_get_type")]
3238    fn static_type() -> glib::Type {
3239        unsafe { from_glib(ffi::g_subprocess_flags_get_type()) }
3240    }
3241}
3242
3243impl glib::HasParamSpec for SubprocessFlags {
3244    type ParamSpec = glib::ParamSpecFlags;
3245    type SetValue = Self;
3246    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3247
3248    fn param_spec_builder() -> Self::BuilderFn {
3249        Self::ParamSpec::builder
3250    }
3251}
3252
3253impl glib::value::ValueType for SubprocessFlags {
3254    type Type = Self;
3255}
3256
3257unsafe impl<'a> glib::value::FromValue<'a> for SubprocessFlags {
3258    type Checker = glib::value::GenericValueTypeChecker<Self>;
3259
3260    #[inline]
3261    unsafe fn from_value(value: &'a glib::Value) -> Self {
3262        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3263    }
3264}
3265
3266impl ToValue for SubprocessFlags {
3267    #[inline]
3268    fn to_value(&self) -> glib::Value {
3269        let mut value = glib::Value::for_value_type::<Self>();
3270        unsafe {
3271            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3272        }
3273        value
3274    }
3275
3276    #[inline]
3277    fn value_type(&self) -> glib::Type {
3278        Self::static_type()
3279    }
3280}
3281
3282impl From<SubprocessFlags> for glib::Value {
3283    #[inline]
3284    fn from(v: SubprocessFlags) -> Self {
3285        ToValue::to_value(&v)
3286    }
3287}
3288
3289bitflags! {
3290    /// Flags to define future #GTestDBus behaviour.
3291    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3292    #[doc(alias = "GTestDBusFlags")]
3293    pub struct TestDBusFlags: u32 {
3294        /// No flags.
3295        #[doc(alias = "G_TEST_DBUS_NONE")]
3296        const NONE = ffi::G_TEST_DBUS_NONE as _;
3297    }
3298}
3299
3300#[doc(hidden)]
3301impl IntoGlib for TestDBusFlags {
3302    type GlibType = ffi::GTestDBusFlags;
3303
3304    #[inline]
3305    fn into_glib(self) -> ffi::GTestDBusFlags {
3306        self.bits()
3307    }
3308}
3309
3310#[doc(hidden)]
3311impl FromGlib<ffi::GTestDBusFlags> for TestDBusFlags {
3312    #[inline]
3313    unsafe fn from_glib(value: ffi::GTestDBusFlags) -> Self {
3314        Self::from_bits_truncate(value)
3315    }
3316}
3317
3318impl StaticType for TestDBusFlags {
3319    #[inline]
3320    #[doc(alias = "g_test_dbus_flags_get_type")]
3321    fn static_type() -> glib::Type {
3322        unsafe { from_glib(ffi::g_test_dbus_flags_get_type()) }
3323    }
3324}
3325
3326impl glib::HasParamSpec for TestDBusFlags {
3327    type ParamSpec = glib::ParamSpecFlags;
3328    type SetValue = Self;
3329    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3330
3331    fn param_spec_builder() -> Self::BuilderFn {
3332        Self::ParamSpec::builder
3333    }
3334}
3335
3336impl glib::value::ValueType for TestDBusFlags {
3337    type Type = Self;
3338}
3339
3340unsafe impl<'a> glib::value::FromValue<'a> for TestDBusFlags {
3341    type Checker = glib::value::GenericValueTypeChecker<Self>;
3342
3343    #[inline]
3344    unsafe fn from_value(value: &'a glib::Value) -> Self {
3345        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3346    }
3347}
3348
3349impl ToValue for TestDBusFlags {
3350    #[inline]
3351    fn to_value(&self) -> glib::Value {
3352        let mut value = glib::Value::for_value_type::<Self>();
3353        unsafe {
3354            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3355        }
3356        value
3357    }
3358
3359    #[inline]
3360    fn value_type(&self) -> glib::Type {
3361        Self::static_type()
3362    }
3363}
3364
3365impl From<TestDBusFlags> for glib::Value {
3366    #[inline]
3367    fn from(v: TestDBusFlags) -> Self {
3368        ToValue::to_value(&v)
3369    }
3370}
3371
3372bitflags! {
3373    /// A set of flags describing TLS certification validation. This can be
3374    /// used to describe why a particular certificate was rejected (for
3375    /// example, in #GTlsConnection::accept-certificate).
3376    ///
3377    /// GLib guarantees that if certificate verification fails, at least one
3378    /// flag will be set, but it does not guarantee that all possible flags
3379    /// will be set. Accordingly, you may not safely decide to ignore any
3380    /// particular type of error. For example, it would be incorrect to mask
3381    /// [`EXPIRED`][Self::EXPIRED] if you want to allow expired certificates,
3382    /// because this could potentially be the only error flag set even if
3383    /// other problems exist with the certificate.
3384    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3385    #[doc(alias = "GTlsCertificateFlags")]
3386    pub struct TlsCertificateFlags: u32 {
3387        /// The signing certificate authority is
3388        ///   not known.
3389        #[doc(alias = "G_TLS_CERTIFICATE_UNKNOWN_CA")]
3390        const UNKNOWN_CA = ffi::G_TLS_CERTIFICATE_UNKNOWN_CA as _;
3391        /// The certificate does not match the
3392        ///   expected identity of the site that it was retrieved from.
3393        #[doc(alias = "G_TLS_CERTIFICATE_BAD_IDENTITY")]
3394        const BAD_IDENTITY = ffi::G_TLS_CERTIFICATE_BAD_IDENTITY as _;
3395        /// The certificate's activation time
3396        ///   is still in the future
3397        #[doc(alias = "G_TLS_CERTIFICATE_NOT_ACTIVATED")]
3398        const NOT_ACTIVATED = ffi::G_TLS_CERTIFICATE_NOT_ACTIVATED as _;
3399        /// The certificate has expired
3400        #[doc(alias = "G_TLS_CERTIFICATE_EXPIRED")]
3401        const EXPIRED = ffi::G_TLS_CERTIFICATE_EXPIRED as _;
3402        /// The certificate has been revoked
3403        ///   according to the #GTlsConnection's certificate revocation list.
3404        #[doc(alias = "G_TLS_CERTIFICATE_REVOKED")]
3405        const REVOKED = ffi::G_TLS_CERTIFICATE_REVOKED as _;
3406        /// The certificate's algorithm is
3407        ///   considered insecure.
3408        #[doc(alias = "G_TLS_CERTIFICATE_INSECURE")]
3409        const INSECURE = ffi::G_TLS_CERTIFICATE_INSECURE as _;
3410        /// Some other error occurred validating
3411        ///   the certificate
3412        #[doc(alias = "G_TLS_CERTIFICATE_GENERIC_ERROR")]
3413        const GENERIC_ERROR = ffi::G_TLS_CERTIFICATE_GENERIC_ERROR as _;
3414        /// the combination of all of the above
3415        ///   flags
3416        #[doc(alias = "G_TLS_CERTIFICATE_VALIDATE_ALL")]
3417        const VALIDATE_ALL = ffi::G_TLS_CERTIFICATE_VALIDATE_ALL as _;
3418    }
3419}
3420
3421#[doc(hidden)]
3422impl IntoGlib for TlsCertificateFlags {
3423    type GlibType = ffi::GTlsCertificateFlags;
3424
3425    #[inline]
3426    fn into_glib(self) -> ffi::GTlsCertificateFlags {
3427        self.bits()
3428    }
3429}
3430
3431#[doc(hidden)]
3432impl FromGlib<ffi::GTlsCertificateFlags> for TlsCertificateFlags {
3433    #[inline]
3434    unsafe fn from_glib(value: ffi::GTlsCertificateFlags) -> Self {
3435        Self::from_bits_truncate(value)
3436    }
3437}
3438
3439impl StaticType for TlsCertificateFlags {
3440    #[inline]
3441    #[doc(alias = "g_tls_certificate_flags_get_type")]
3442    fn static_type() -> glib::Type {
3443        unsafe { from_glib(ffi::g_tls_certificate_flags_get_type()) }
3444    }
3445}
3446
3447impl glib::HasParamSpec for TlsCertificateFlags {
3448    type ParamSpec = glib::ParamSpecFlags;
3449    type SetValue = Self;
3450    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3451
3452    fn param_spec_builder() -> Self::BuilderFn {
3453        Self::ParamSpec::builder
3454    }
3455}
3456
3457impl glib::value::ValueType for TlsCertificateFlags {
3458    type Type = Self;
3459}
3460
3461unsafe impl<'a> glib::value::FromValue<'a> for TlsCertificateFlags {
3462    type Checker = glib::value::GenericValueTypeChecker<Self>;
3463
3464    #[inline]
3465    unsafe fn from_value(value: &'a glib::Value) -> Self {
3466        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3467    }
3468}
3469
3470impl ToValue for TlsCertificateFlags {
3471    #[inline]
3472    fn to_value(&self) -> glib::Value {
3473        let mut value = glib::Value::for_value_type::<Self>();
3474        unsafe {
3475            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3476        }
3477        value
3478    }
3479
3480    #[inline]
3481    fn value_type(&self) -> glib::Type {
3482        Self::static_type()
3483    }
3484}
3485
3486impl From<TlsCertificateFlags> for glib::Value {
3487    #[inline]
3488    fn from(v: TlsCertificateFlags) -> Self {
3489        ToValue::to_value(&v)
3490    }
3491}
3492
3493bitflags! {
3494    /// Flags for g_tls_database_verify_chain().
3495    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3496    #[doc(alias = "GTlsDatabaseVerifyFlags")]
3497    pub struct TlsDatabaseVerifyFlags: u32 {
3498        /// No verification flags
3499        #[doc(alias = "G_TLS_DATABASE_VERIFY_NONE")]
3500        const NONE = ffi::G_TLS_DATABASE_VERIFY_NONE as _;
3501    }
3502}
3503
3504#[doc(hidden)]
3505impl IntoGlib for TlsDatabaseVerifyFlags {
3506    type GlibType = ffi::GTlsDatabaseVerifyFlags;
3507
3508    #[inline]
3509    fn into_glib(self) -> ffi::GTlsDatabaseVerifyFlags {
3510        self.bits()
3511    }
3512}
3513
3514#[doc(hidden)]
3515impl FromGlib<ffi::GTlsDatabaseVerifyFlags> for TlsDatabaseVerifyFlags {
3516    #[inline]
3517    unsafe fn from_glib(value: ffi::GTlsDatabaseVerifyFlags) -> Self {
3518        Self::from_bits_truncate(value)
3519    }
3520}
3521
3522impl StaticType for TlsDatabaseVerifyFlags {
3523    #[inline]
3524    #[doc(alias = "g_tls_database_verify_flags_get_type")]
3525    fn static_type() -> glib::Type {
3526        unsafe { from_glib(ffi::g_tls_database_verify_flags_get_type()) }
3527    }
3528}
3529
3530impl glib::HasParamSpec for TlsDatabaseVerifyFlags {
3531    type ParamSpec = glib::ParamSpecFlags;
3532    type SetValue = Self;
3533    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3534
3535    fn param_spec_builder() -> Self::BuilderFn {
3536        Self::ParamSpec::builder
3537    }
3538}
3539
3540impl glib::value::ValueType for TlsDatabaseVerifyFlags {
3541    type Type = Self;
3542}
3543
3544unsafe impl<'a> glib::value::FromValue<'a> for TlsDatabaseVerifyFlags {
3545    type Checker = glib::value::GenericValueTypeChecker<Self>;
3546
3547    #[inline]
3548    unsafe fn from_value(value: &'a glib::Value) -> Self {
3549        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3550    }
3551}
3552
3553impl ToValue for TlsDatabaseVerifyFlags {
3554    #[inline]
3555    fn to_value(&self) -> glib::Value {
3556        let mut value = glib::Value::for_value_type::<Self>();
3557        unsafe {
3558            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3559        }
3560        value
3561    }
3562
3563    #[inline]
3564    fn value_type(&self) -> glib::Type {
3565        Self::static_type()
3566    }
3567}
3568
3569impl From<TlsDatabaseVerifyFlags> for glib::Value {
3570    #[inline]
3571    fn from(v: TlsDatabaseVerifyFlags) -> Self {
3572        ToValue::to_value(&v)
3573    }
3574}
3575
3576bitflags! {
3577    /// Various flags for the password.
3578    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3579    #[doc(alias = "GTlsPasswordFlags")]
3580    pub struct TlsPasswordFlags: u32 {
3581        /// No flags
3582        #[doc(alias = "G_TLS_PASSWORD_NONE")]
3583        const NONE = ffi::G_TLS_PASSWORD_NONE as _;
3584        /// The password was wrong, and the user should retry.
3585        #[doc(alias = "G_TLS_PASSWORD_RETRY")]
3586        const RETRY = ffi::G_TLS_PASSWORD_RETRY as _;
3587        /// Hint to the user that the password has been
3588        ///    wrong many times, and the user may not have many chances left.
3589        #[doc(alias = "G_TLS_PASSWORD_MANY_TRIES")]
3590        const MANY_TRIES = ffi::G_TLS_PASSWORD_MANY_TRIES as _;
3591        /// Hint to the user that this is the last try to get
3592        ///    this password right.
3593        #[doc(alias = "G_TLS_PASSWORD_FINAL_TRY")]
3594        const FINAL_TRY = ffi::G_TLS_PASSWORD_FINAL_TRY as _;
3595        /// For PKCS #11, the user PIN is required.
3596        ///    Since: 2.70.
3597        #[doc(alias = "G_TLS_PASSWORD_PKCS11_USER")]
3598        const PKCS11_USER = ffi::G_TLS_PASSWORD_PKCS11_USER as _;
3599        /// For PKCS #11, the security officer
3600        ///    PIN is required. Since: 2.70.
3601        #[doc(alias = "G_TLS_PASSWORD_PKCS11_SECURITY_OFFICER")]
3602        const PKCS11_SECURITY_OFFICER = ffi::G_TLS_PASSWORD_PKCS11_SECURITY_OFFICER as _;
3603        /// For PKCS #11, the context-specific
3604        ///    PIN is required. Since: 2.70.
3605        #[doc(alias = "G_TLS_PASSWORD_PKCS11_CONTEXT_SPECIFIC")]
3606        const PKCS11_CONTEXT_SPECIFIC = ffi::G_TLS_PASSWORD_PKCS11_CONTEXT_SPECIFIC as _;
3607    }
3608}
3609
3610#[doc(hidden)]
3611impl IntoGlib for TlsPasswordFlags {
3612    type GlibType = ffi::GTlsPasswordFlags;
3613
3614    #[inline]
3615    fn into_glib(self) -> ffi::GTlsPasswordFlags {
3616        self.bits()
3617    }
3618}
3619
3620#[doc(hidden)]
3621impl FromGlib<ffi::GTlsPasswordFlags> for TlsPasswordFlags {
3622    #[inline]
3623    unsafe fn from_glib(value: ffi::GTlsPasswordFlags) -> Self {
3624        Self::from_bits_truncate(value)
3625    }
3626}
3627
3628impl StaticType for TlsPasswordFlags {
3629    #[inline]
3630    #[doc(alias = "g_tls_password_flags_get_type")]
3631    fn static_type() -> glib::Type {
3632        unsafe { from_glib(ffi::g_tls_password_flags_get_type()) }
3633    }
3634}
3635
3636impl glib::HasParamSpec for TlsPasswordFlags {
3637    type ParamSpec = glib::ParamSpecFlags;
3638    type SetValue = Self;
3639    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3640
3641    fn param_spec_builder() -> Self::BuilderFn {
3642        Self::ParamSpec::builder
3643    }
3644}
3645
3646impl glib::value::ValueType for TlsPasswordFlags {
3647    type Type = Self;
3648}
3649
3650unsafe impl<'a> glib::value::FromValue<'a> for TlsPasswordFlags {
3651    type Checker = glib::value::GenericValueTypeChecker<Self>;
3652
3653    #[inline]
3654    unsafe fn from_value(value: &'a glib::Value) -> Self {
3655        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3656    }
3657}
3658
3659impl ToValue for TlsPasswordFlags {
3660    #[inline]
3661    fn to_value(&self) -> glib::Value {
3662        let mut value = glib::Value::for_value_type::<Self>();
3663        unsafe {
3664            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3665        }
3666        value
3667    }
3668
3669    #[inline]
3670    fn value_type(&self) -> glib::Type {
3671        Self::static_type()
3672    }
3673}
3674
3675impl From<TlsPasswordFlags> for glib::Value {
3676    #[inline]
3677    fn from(v: TlsPasswordFlags) -> Self {
3678        ToValue::to_value(&v)
3679    }
3680}