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