1use crate::ffi;
6use glib::{bitflags::bitflags, prelude::*, translate::*};
7
8bitflags! {
9 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
11 #[doc(alias = "GAppInfoCreateFlags")]
12 pub struct AppInfoCreateFlags: u32 {
13 #[doc(alias = "G_APP_INFO_CREATE_NONE")]
15 const NONE = ffi::G_APP_INFO_CREATE_NONE as _;
16 #[doc(alias = "G_APP_INFO_CREATE_NEEDS_TERMINAL")]
18 const NEEDS_TERMINAL = ffi::G_APP_INFO_CREATE_NEEDS_TERMINAL as _;
19 #[doc(alias = "G_APP_INFO_CREATE_SUPPORTS_URIS")]
21 const SUPPORTS_URIS = ffi::G_APP_INFO_CREATE_SUPPORTS_URIS as _;
22 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
103 #[doc(alias = "GApplicationFlags")]
104 pub struct ApplicationFlags: u32 {
105 #[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 #[doc(alias = "G_APPLICATION_IS_SERVICE")]
115 const IS_SERVICE = ffi::G_APPLICATION_IS_SERVICE as _;
116 #[doc(alias = "G_APPLICATION_IS_LAUNCHER")]
118 const IS_LAUNCHER = ffi::G_APPLICATION_IS_LAUNCHER as _;
119 #[doc(alias = "G_APPLICATION_HANDLES_OPEN")]
125 const HANDLES_OPEN = ffi::G_APPLICATION_HANDLES_OPEN as _;
126 #[doc(alias = "G_APPLICATION_HANDLES_COMMAND_LINE")]
131 const HANDLES_COMMAND_LINE = ffi::G_APPLICATION_HANDLES_COMMAND_LINE as _;
132 #[doc(alias = "G_APPLICATION_SEND_ENVIRONMENT")]
141 const SEND_ENVIRONMENT = ffi::G_APPLICATION_SEND_ENVIRONMENT as _;
142 #[doc(alias = "G_APPLICATION_NON_UNIQUE")]
149 const NON_UNIQUE = ffi::G_APPLICATION_NON_UNIQUE as _;
150 #[doc(alias = "G_APPLICATION_CAN_OVERRIDE_APP_ID")]
154 const CAN_OVERRIDE_APP_ID = ffi::G_APPLICATION_CAN_OVERRIDE_APP_ID as _;
155 #[doc(alias = "G_APPLICATION_ALLOW_REPLACEMENT")]
158 const ALLOW_REPLACEMENT = ffi::G_APPLICATION_ALLOW_REPLACEMENT as _;
159 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
244 #[doc(alias = "GAskPasswordFlags")]
245 pub struct AskPasswordFlags: u32 {
246 #[doc(alias = "G_ASK_PASSWORD_NEED_PASSWORD")]
248 const NEED_PASSWORD = ffi::G_ASK_PASSWORD_NEED_PASSWORD as _;
249 #[doc(alias = "G_ASK_PASSWORD_NEED_USERNAME")]
251 const NEED_USERNAME = ffi::G_ASK_PASSWORD_NEED_USERNAME as _;
252 #[doc(alias = "G_ASK_PASSWORD_NEED_DOMAIN")]
254 const NEED_DOMAIN = ffi::G_ASK_PASSWORD_NEED_DOMAIN as _;
255 #[doc(alias = "G_ASK_PASSWORD_SAVING_SUPPORTED")]
257 const SAVING_SUPPORTED = ffi::G_ASK_PASSWORD_SAVING_SUPPORTED as _;
258 #[doc(alias = "G_ASK_PASSWORD_ANONYMOUS_SUPPORTED")]
260 const ANONYMOUS_SUPPORTED = ffi::G_ASK_PASSWORD_ANONYMOUS_SUPPORTED as _;
261 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
342 #[doc(alias = "GBusNameOwnerFlags")]
343 pub struct BusNameOwnerFlags: u32 {
344 #[doc(alias = "G_BUS_NAME_OWNER_FLAGS_NONE")]
346 const NONE = ffi::G_BUS_NAME_OWNER_FLAGS_NONE as _;
347 #[doc(alias = "G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT")]
349 const ALLOW_REPLACEMENT = ffi::G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT as _;
350 #[doc(alias = "G_BUS_NAME_OWNER_FLAGS_REPLACE")]
353 const REPLACE = ffi::G_BUS_NAME_OWNER_FLAGS_REPLACE as _;
354 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
437 #[doc(alias = "GBusNameWatcherFlags")]
438 pub struct BusNameWatcherFlags: u32 {
439 #[doc(alias = "G_BUS_NAME_WATCHER_FLAGS_NONE")]
441 const NONE = ffi::G_BUS_NAME_WATCHER_FLAGS_NONE as _;
442 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
525 #[doc(alias = "GConverterFlags")]
526 pub struct ConverterFlags: u32 {
527 #[doc(alias = "G_CONVERTER_NO_FLAGS")]
529 const NONE = ffi::G_CONVERTER_NO_FLAGS as _;
530 #[doc(alias = "G_CONVERTER_INPUT_AT_END")]
532 const INPUT_AT_END = ffi::G_CONVERTER_INPUT_AT_END as _;
533 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
614 #[doc(alias = "GDBusCallFlags")]
615 pub struct DBusCallFlags: u32 {
616 #[doc(alias = "G_DBUS_CALL_FLAGS_NONE")]
618 const NONE = ffi::G_DBUS_CALL_FLAGS_NONE as _;
619 #[doc(alias = "G_DBUS_CALL_FLAGS_NO_AUTO_START")]
623 const NO_AUTO_START = ffi::G_DBUS_CALL_FLAGS_NO_AUTO_START as _;
624 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
706 #[doc(alias = "GDBusCapabilityFlags")]
707 pub struct DBusCapabilityFlags: u32 {
708 #[doc(alias = "G_DBUS_CAPABILITY_FLAGS_NONE")]
710 const NONE = ffi::G_DBUS_CAPABILITY_FLAGS_NONE as _;
711 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
793 #[doc(alias = "GDBusConnectionFlags")]
794 pub struct DBusConnectionFlags: u32 {
795 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_NONE")]
797 const NONE = ffi::G_DBUS_CONNECTION_FLAGS_NONE as _;
798 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT")]
800 const AUTHENTICATION_CLIENT = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT as _;
801 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER")]
803 const AUTHENTICATION_SERVER = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER as _;
804 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS")]
808 const AUTHENTICATION_ALLOW_ANONYMOUS = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS as _;
809 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION")]
812 const MESSAGE_BUS_CONNECTION = ffi::G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION as _;
813 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING")]
816 const DELAY_MESSAGE_PROCESSING = ffi::G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING as _;
817 #[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 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
909 #[doc(alias = "GDBusInterfaceSkeletonFlags")]
910 pub struct DBusInterfaceSkeletonFlags: u32 {
911 #[doc(alias = "G_DBUS_INTERFACE_SKELETON_FLAGS_NONE")]
913 const NONE = ffi::G_DBUS_INTERFACE_SKELETON_FLAGS_NONE as _;
914 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
998 #[doc(alias = "GDBusMessageFlags")]
999 pub struct DBusMessageFlags: u32 {
1000 #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NONE")]
1002 const NONE = ffi::G_DBUS_MESSAGE_FLAGS_NONE as _;
1003 #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED")]
1005 const NO_REPLY_EXPECTED = ffi::G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED as _;
1006 #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NO_AUTO_START")]
1009 const NO_AUTO_START = ffi::G_DBUS_MESSAGE_FLAGS_NO_AUTO_START as _;
1010 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1093 #[doc(alias = "GDBusObjectManagerClientFlags")]
1094 pub struct DBusObjectManagerClientFlags: u32 {
1095 #[doc(alias = "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE")]
1097 const NONE = ffi::G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE as _;
1098 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1182 #[doc(alias = "GDBusPropertyInfoFlags")]
1183 pub struct DBusPropertyInfoFlags: u32 {
1184 #[doc(alias = "G_DBUS_PROPERTY_INFO_FLAGS_NONE")]
1186 const NONE = ffi::G_DBUS_PROPERTY_INFO_FLAGS_NONE as _;
1187 #[doc(alias = "G_DBUS_PROPERTY_INFO_FLAGS_READABLE")]
1189 const READABLE = ffi::G_DBUS_PROPERTY_INFO_FLAGS_READABLE as _;
1190 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1271 #[doc(alias = "GDBusProxyFlags")]
1272 pub struct DBusProxyFlags: u32 {
1273 #[doc(alias = "G_DBUS_PROXY_FLAGS_NONE")]
1275 const NONE = ffi::G_DBUS_PROXY_FLAGS_NONE as _;
1276 #[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 #[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 #[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 #[doc(alias = "G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES")]
1289 const GET_INVALIDATED_PROPERTIES = ffi::G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES as _;
1290 #[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 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1381 #[doc(alias = "GDBusSendMessageFlags")]
1382 pub struct DBusSendMessageFlags: u32 {
1383 #[doc(alias = "G_DBUS_SEND_MESSAGE_FLAGS_NONE")]
1385 const NONE = ffi::G_DBUS_SEND_MESSAGE_FLAGS_NONE as _;
1386 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1469 #[doc(alias = "GDBusServerFlags")]
1470 pub struct DBusServerFlags: u32 {
1471 #[doc(alias = "G_DBUS_SERVER_FLAGS_NONE")]
1473 const NONE = ffi::G_DBUS_SERVER_FLAGS_NONE as _;
1474 #[doc(alias = "G_DBUS_SERVER_FLAGS_RUN_IN_THREAD")]
1478 const RUN_IN_THREAD = ffi::G_DBUS_SERVER_FLAGS_RUN_IN_THREAD as _;
1479 #[doc(alias = "G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS")]
1482 const AUTHENTICATION_ALLOW_ANONYMOUS = ffi::G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS as _;
1483 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1565 #[doc(alias = "GDBusSignalFlags")]
1566 pub struct DBusSignalFlags: u32 {
1567 #[doc(alias = "G_DBUS_SIGNAL_FLAGS_NONE")]
1569 const NONE = ffi::G_DBUS_SIGNAL_FLAGS_NONE as _;
1570 #[doc(alias = "G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE")]
1574 const NO_MATCH_RULE = ffi::G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE as _;
1575 #[doc(alias = "G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE")]
1578 const MATCH_ARG0_NAMESPACE = ffi::G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE as _;
1579 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1662 #[doc(alias = "GDBusSubtreeFlags")]
1663 pub struct DBusSubtreeFlags: u32 {
1664 #[doc(alias = "G_DBUS_SUBTREE_FLAGS_NONE")]
1666 const NONE = ffi::G_DBUS_SUBTREE_FLAGS_NONE as _;
1667 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1750 #[doc(alias = "GDriveStartFlags")]
1751 pub struct DriveStartFlags: u32 {
1752 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1833 #[doc(alias = "GFileAttributeInfoFlags")]
1834 pub struct FileAttributeInfoFlags: u32 {
1835 #[doc(alias = "G_FILE_ATTRIBUTE_INFO_NONE")]
1837 const NONE = ffi::G_FILE_ATTRIBUTE_INFO_NONE as _;
1838 #[doc(alias = "G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE")]
1840 const COPY_WITH_FILE = ffi::G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE as _;
1841 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1922 #[doc(alias = "GFileCopyFlags")]
1923 pub struct FileCopyFlags: u32 {
1924 #[doc(alias = "G_FILE_COPY_NONE")]
1926 const NONE = ffi::G_FILE_COPY_NONE as _;
1927 #[doc(alias = "G_FILE_COPY_OVERWRITE")]
1929 const OVERWRITE = ffi::G_FILE_COPY_OVERWRITE as _;
1930 #[doc(alias = "G_FILE_COPY_BACKUP")]
1932 const BACKUP = ffi::G_FILE_COPY_BACKUP as _;
1933 #[doc(alias = "G_FILE_COPY_NOFOLLOW_SYMLINKS")]
1935 const NOFOLLOW_SYMLINKS = ffi::G_FILE_COPY_NOFOLLOW_SYMLINKS as _;
1936 #[doc(alias = "G_FILE_COPY_ALL_METADATA")]
1938 const ALL_METADATA = ffi::G_FILE_COPY_ALL_METADATA as _;
1939 #[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 #[doc(alias = "G_FILE_COPY_TARGET_DEFAULT_PERMS")]
1944 const TARGET_DEFAULT_PERMS = ffi::G_FILE_COPY_TARGET_DEFAULT_PERMS as _;
1945 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2029 #[doc(alias = "GFileCreateFlags")]
2030 pub struct FileCreateFlags: u32 {
2031 #[doc(alias = "G_FILE_CREATE_NONE")]
2033 const NONE = ffi::G_FILE_CREATE_NONE as _;
2034 #[doc(alias = "G_FILE_CREATE_PRIVATE")]
2037 const PRIVATE = ffi::G_FILE_CREATE_PRIVATE as _;
2038 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2128 #[doc(alias = "GFileMeasureFlags")]
2129 pub struct FileMeasureFlags: u32 {
2130 #[doc(alias = "G_FILE_MEASURE_NONE")]
2132 const NONE = ffi::G_FILE_MEASURE_NONE as _;
2133 #[doc(alias = "G_FILE_MEASURE_REPORT_ANY_ERROR")]
2137 const REPORT_ANY_ERROR = ffi::G_FILE_MEASURE_REPORT_ANY_ERROR as _;
2138 #[doc(alias = "G_FILE_MEASURE_APPARENT_SIZE")]
2146 const APPARENT_SIZE = ffi::G_FILE_MEASURE_APPARENT_SIZE as _;
2147 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2229 #[doc(alias = "GFileMonitorFlags")]
2230 pub struct FileMonitorFlags: u32 {
2231 #[doc(alias = "G_FILE_MONITOR_NONE")]
2233 const NONE = ffi::G_FILE_MONITOR_NONE as _;
2234 #[doc(alias = "G_FILE_MONITOR_WATCH_MOUNTS")]
2236 const WATCH_MOUNTS = ffi::G_FILE_MONITOR_WATCH_MOUNTS as _;
2237 #[doc(alias = "G_FILE_MONITOR_SEND_MOVED")]
2244 const SEND_MOVED = ffi::G_FILE_MONITOR_SEND_MOVED as _;
2245 #[doc(alias = "G_FILE_MONITOR_WATCH_HARD_LINKS")]
2248 const WATCH_HARD_LINKS = ffi::G_FILE_MONITOR_WATCH_HARD_LINKS as _;
2249 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2333 #[doc(alias = "GFileQueryInfoFlags")]
2334 pub struct FileQueryInfoFlags: u32 {
2335 #[doc(alias = "G_FILE_QUERY_INFO_NONE")]
2337 const NONE = ffi::G_FILE_QUERY_INFO_NONE as _;
2338 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2419 #[doc(alias = "GIOStreamSpliceFlags")]
2420 pub struct IOStreamSpliceFlags: u32 {
2421 #[doc(alias = "G_IO_STREAM_SPLICE_NONE")]
2423 const NONE = ffi::G_IO_STREAM_SPLICE_NONE as _;
2424 #[doc(alias = "G_IO_STREAM_SPLICE_CLOSE_STREAM1")]
2427 const CLOSE_STREAM1 = ffi::G_IO_STREAM_SPLICE_CLOSE_STREAM1 as _;
2428 #[doc(alias = "G_IO_STREAM_SPLICE_CLOSE_STREAM2")]
2431 const CLOSE_STREAM2 = ffi::G_IO_STREAM_SPLICE_CLOSE_STREAM2 as _;
2432 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2514 #[doc(alias = "GMountMountFlags")]
2515 pub struct MountMountFlags: u32 {
2516 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2597 #[doc(alias = "GMountUnmountFlags")]
2598 pub struct MountUnmountFlags: u32 {
2599 #[doc(alias = "G_MOUNT_UNMOUNT_NONE")]
2601 const NONE = ffi::G_MOUNT_UNMOUNT_NONE as _;
2602 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2684 #[doc(alias = "GOutputStreamSpliceFlags")]
2685 pub struct OutputStreamSpliceFlags: u32 {
2686 #[doc(alias = "G_OUTPUT_STREAM_SPLICE_NONE")]
2688 const NONE = ffi::G_OUTPUT_STREAM_SPLICE_NONE as _;
2689 #[doc(alias = "G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE")]
2692 const CLOSE_SOURCE = ffi::G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE as _;
2693 #[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 #[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 #[doc(alias = "G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT")]
2781 const DEFAULT = ffi::G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT as _;
2782 #[doc(alias = "G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY")]
2784 const IPV4_ONLY = ffi::G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY as _;
2785 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2883 #[doc(alias = "GResourceFlags")]
2884 pub struct ResourceFlags: u32 {
2885 #[doc(alias = "G_RESOURCE_FLAGS_NONE")]
2887 const NONE = ffi::G_RESOURCE_FLAGS_NONE as _;
2888 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2969 #[doc(alias = "GResourceLookupFlags")]
2970 pub struct ResourceLookupFlags: u32 {
2971 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3055 #[doc(alias = "GSettingsBindFlags")]
3056 pub struct SettingsBindFlags: u32 {
3057 #[doc(alias = "G_SETTINGS_BIND_DEFAULT")]
3059 const DEFAULT = ffi::G_SETTINGS_BIND_DEFAULT as _;
3060 #[doc(alias = "G_SETTINGS_BIND_GET")]
3063 const GET = ffi::G_SETTINGS_BIND_GET as _;
3064 #[doc(alias = "G_SETTINGS_BIND_SET")]
3067 const SET = ffi::G_SETTINGS_BIND_SET as _;
3068 #[doc(alias = "G_SETTINGS_BIND_NO_SENSITIVITY")]
3070 const NO_SENSITIVITY = ffi::G_SETTINGS_BIND_NO_SENSITIVITY as _;
3071 #[doc(alias = "G_SETTINGS_BIND_GET_NO_CHANGES")]
3075 const GET_NO_CHANGES = ffi::G_SETTINGS_BIND_GET_NO_CHANGES as _;
3076 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3168 #[doc(alias = "GSubprocessFlags")]
3169 pub struct SubprocessFlags: u32 {
3170 #[doc(alias = "G_SUBPROCESS_FLAGS_NONE")]
3172 const NONE = ffi::G_SUBPROCESS_FLAGS_NONE as _;
3173 #[doc(alias = "G_SUBPROCESS_FLAGS_STDIN_PIPE")]
3177 const STDIN_PIPE = ffi::G_SUBPROCESS_FLAGS_STDIN_PIPE as _;
3178 #[doc(alias = "G_SUBPROCESS_FLAGS_STDIN_INHERIT")]
3181 const STDIN_INHERIT = ffi::G_SUBPROCESS_FLAGS_STDIN_INHERIT as _;
3182 #[doc(alias = "G_SUBPROCESS_FLAGS_STDOUT_PIPE")]
3186 const STDOUT_PIPE = ffi::G_SUBPROCESS_FLAGS_STDOUT_PIPE as _;
3187 #[doc(alias = "G_SUBPROCESS_FLAGS_STDOUT_SILENCE")]
3190 const STDOUT_SILENCE = ffi::G_SUBPROCESS_FLAGS_STDOUT_SILENCE as _;
3191 #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_PIPE")]
3195 const STDERR_PIPE = ffi::G_SUBPROCESS_FLAGS_STDERR_PIPE as _;
3196 #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_SILENCE")]
3199 const STDERR_SILENCE = ffi::G_SUBPROCESS_FLAGS_STDERR_SILENCE as _;
3200 #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_MERGE")]
3204 const STDERR_MERGE = ffi::G_SUBPROCESS_FLAGS_STDERR_MERGE as _;
3205 #[doc(alias = "G_SUBPROCESS_FLAGS_INHERIT_FDS")]
3210 const INHERIT_FDS = ffi::G_SUBPROCESS_FLAGS_INHERIT_FDS as _;
3211 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3296 #[doc(alias = "GTestDBusFlags")]
3297 pub struct TestDBusFlags: u32 {
3298 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3389 #[doc(alias = "GTlsCertificateFlags")]
3390 pub struct TlsCertificateFlags: u32 {
3391 #[doc(alias = "G_TLS_CERTIFICATE_UNKNOWN_CA")]
3394 const UNKNOWN_CA = ffi::G_TLS_CERTIFICATE_UNKNOWN_CA as _;
3395 #[doc(alias = "G_TLS_CERTIFICATE_BAD_IDENTITY")]
3398 const BAD_IDENTITY = ffi::G_TLS_CERTIFICATE_BAD_IDENTITY as _;
3399 #[doc(alias = "G_TLS_CERTIFICATE_NOT_ACTIVATED")]
3402 const NOT_ACTIVATED = ffi::G_TLS_CERTIFICATE_NOT_ACTIVATED as _;
3403 #[doc(alias = "G_TLS_CERTIFICATE_EXPIRED")]
3405 const EXPIRED = ffi::G_TLS_CERTIFICATE_EXPIRED as _;
3406 #[doc(alias = "G_TLS_CERTIFICATE_REVOKED")]
3409 const REVOKED = ffi::G_TLS_CERTIFICATE_REVOKED as _;
3410 #[doc(alias = "G_TLS_CERTIFICATE_INSECURE")]
3413 const INSECURE = ffi::G_TLS_CERTIFICATE_INSECURE as _;
3414 #[doc(alias = "G_TLS_CERTIFICATE_GENERIC_ERROR")]
3417 const GENERIC_ERROR = ffi::G_TLS_CERTIFICATE_GENERIC_ERROR as _;
3418 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3500 #[doc(alias = "GTlsDatabaseVerifyFlags")]
3501 pub struct TlsDatabaseVerifyFlags: u32 {
3502 #[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 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3583 #[doc(alias = "GTlsPasswordFlags")]
3584 pub struct TlsPasswordFlags: u32 {
3585 #[doc(alias = "G_TLS_PASSWORD_NONE")]
3587 const NONE = ffi::G_TLS_PASSWORD_NONE as _;
3588 #[doc(alias = "G_TLS_PASSWORD_RETRY")]
3590 const RETRY = ffi::G_TLS_PASSWORD_RETRY as _;
3591 #[doc(alias = "G_TLS_PASSWORD_MANY_TRIES")]
3594 const MANY_TRIES = ffi::G_TLS_PASSWORD_MANY_TRIES as _;
3595 #[doc(alias = "G_TLS_PASSWORD_FINAL_TRY")]
3598 const FINAL_TRY = ffi::G_TLS_PASSWORD_FINAL_TRY as _;
3599 #[doc(alias = "G_TLS_PASSWORD_PKCS11_USER")]
3602 const PKCS11_USER = ffi::G_TLS_PASSWORD_PKCS11_USER as _;
3603 #[doc(alias = "G_TLS_PASSWORD_PKCS11_SECURITY_OFFICER")]
3606 const PKCS11_SECURITY_OFFICER = ffi::G_TLS_PASSWORD_PKCS11_SECURITY_OFFICER as _;
3607 #[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}