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")]
357 const DO_NOT_QUEUE = ffi::G_BUS_NAME_OWNER_FLAGS_DO_NOT_QUEUE as _;
358 }
359}
360
361#[doc(hidden)]
362impl IntoGlib for BusNameOwnerFlags {
363 type GlibType = ffi::GBusNameOwnerFlags;
364
365 #[inline]
366 fn into_glib(self) -> ffi::GBusNameOwnerFlags {
367 self.bits()
368 }
369}
370
371#[doc(hidden)]
372impl FromGlib<ffi::GBusNameOwnerFlags> for BusNameOwnerFlags {
373 #[inline]
374 unsafe fn from_glib(value: ffi::GBusNameOwnerFlags) -> Self {
375 Self::from_bits_truncate(value)
376 }
377}
378
379impl StaticType for BusNameOwnerFlags {
380 #[inline]
381 #[doc(alias = "g_bus_name_owner_flags_get_type")]
382 fn static_type() -> glib::Type {
383 unsafe { from_glib(ffi::g_bus_name_owner_flags_get_type()) }
384 }
385}
386
387impl glib::HasParamSpec for BusNameOwnerFlags {
388 type ParamSpec = glib::ParamSpecFlags;
389 type SetValue = Self;
390 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
391
392 fn param_spec_builder() -> Self::BuilderFn {
393 Self::ParamSpec::builder
394 }
395}
396
397impl glib::value::ValueType for BusNameOwnerFlags {
398 type Type = Self;
399}
400
401unsafe impl<'a> glib::value::FromValue<'a> for BusNameOwnerFlags {
402 type Checker = glib::value::GenericValueTypeChecker<Self>;
403
404 #[inline]
405 unsafe fn from_value(value: &'a glib::Value) -> Self {
406 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
407 }
408}
409
410impl ToValue for BusNameOwnerFlags {
411 #[inline]
412 fn to_value(&self) -> glib::Value {
413 let mut value = glib::Value::for_value_type::<Self>();
414 unsafe {
415 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
416 }
417 value
418 }
419
420 #[inline]
421 fn value_type(&self) -> glib::Type {
422 Self::static_type()
423 }
424}
425
426impl From<BusNameOwnerFlags> for glib::Value {
427 #[inline]
428 fn from(v: BusNameOwnerFlags) -> Self {
429 ToValue::to_value(&v)
430 }
431}
432
433bitflags! {
434 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
436 #[doc(alias = "GBusNameWatcherFlags")]
437 pub struct BusNameWatcherFlags: u32 {
438 #[doc(alias = "G_BUS_NAME_WATCHER_FLAGS_NONE")]
440 const NONE = ffi::G_BUS_NAME_WATCHER_FLAGS_NONE as _;
441 #[doc(alias = "G_BUS_NAME_WATCHER_FLAGS_AUTO_START")]
445 const AUTO_START = ffi::G_BUS_NAME_WATCHER_FLAGS_AUTO_START as _;
446 }
447}
448
449#[doc(hidden)]
450impl IntoGlib for BusNameWatcherFlags {
451 type GlibType = ffi::GBusNameWatcherFlags;
452
453 #[inline]
454 fn into_glib(self) -> ffi::GBusNameWatcherFlags {
455 self.bits()
456 }
457}
458
459#[doc(hidden)]
460impl FromGlib<ffi::GBusNameWatcherFlags> for BusNameWatcherFlags {
461 #[inline]
462 unsafe fn from_glib(value: ffi::GBusNameWatcherFlags) -> Self {
463 Self::from_bits_truncate(value)
464 }
465}
466
467impl StaticType for BusNameWatcherFlags {
468 #[inline]
469 #[doc(alias = "g_bus_name_watcher_flags_get_type")]
470 fn static_type() -> glib::Type {
471 unsafe { from_glib(ffi::g_bus_name_watcher_flags_get_type()) }
472 }
473}
474
475impl glib::HasParamSpec for BusNameWatcherFlags {
476 type ParamSpec = glib::ParamSpecFlags;
477 type SetValue = Self;
478 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
479
480 fn param_spec_builder() -> Self::BuilderFn {
481 Self::ParamSpec::builder
482 }
483}
484
485impl glib::value::ValueType for BusNameWatcherFlags {
486 type Type = Self;
487}
488
489unsafe impl<'a> glib::value::FromValue<'a> for BusNameWatcherFlags {
490 type Checker = glib::value::GenericValueTypeChecker<Self>;
491
492 #[inline]
493 unsafe fn from_value(value: &'a glib::Value) -> Self {
494 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
495 }
496}
497
498impl ToValue for BusNameWatcherFlags {
499 #[inline]
500 fn to_value(&self) -> glib::Value {
501 let mut value = glib::Value::for_value_type::<Self>();
502 unsafe {
503 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
504 }
505 value
506 }
507
508 #[inline]
509 fn value_type(&self) -> glib::Type {
510 Self::static_type()
511 }
512}
513
514impl From<BusNameWatcherFlags> for glib::Value {
515 #[inline]
516 fn from(v: BusNameWatcherFlags) -> Self {
517 ToValue::to_value(&v)
518 }
519}
520
521bitflags! {
522 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
524 #[doc(alias = "GConverterFlags")]
525 pub struct ConverterFlags: u32 {
526 #[doc(alias = "G_CONVERTER_NO_FLAGS")]
528 const NONE = ffi::G_CONVERTER_NO_FLAGS as _;
529 #[doc(alias = "G_CONVERTER_INPUT_AT_END")]
531 const INPUT_AT_END = ffi::G_CONVERTER_INPUT_AT_END as _;
532 #[doc(alias = "G_CONVERTER_FLUSH")]
534 const FLUSH = ffi::G_CONVERTER_FLUSH as _;
535 }
536}
537
538#[doc(hidden)]
539impl IntoGlib for ConverterFlags {
540 type GlibType = ffi::GConverterFlags;
541
542 #[inline]
543 fn into_glib(self) -> ffi::GConverterFlags {
544 self.bits()
545 }
546}
547
548#[doc(hidden)]
549impl FromGlib<ffi::GConverterFlags> for ConverterFlags {
550 #[inline]
551 unsafe fn from_glib(value: ffi::GConverterFlags) -> Self {
552 Self::from_bits_truncate(value)
553 }
554}
555
556impl StaticType for ConverterFlags {
557 #[inline]
558 #[doc(alias = "g_converter_flags_get_type")]
559 fn static_type() -> glib::Type {
560 unsafe { from_glib(ffi::g_converter_flags_get_type()) }
561 }
562}
563
564impl glib::HasParamSpec for ConverterFlags {
565 type ParamSpec = glib::ParamSpecFlags;
566 type SetValue = Self;
567 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
568
569 fn param_spec_builder() -> Self::BuilderFn {
570 Self::ParamSpec::builder
571 }
572}
573
574impl glib::value::ValueType for ConverterFlags {
575 type Type = Self;
576}
577
578unsafe impl<'a> glib::value::FromValue<'a> for ConverterFlags {
579 type Checker = glib::value::GenericValueTypeChecker<Self>;
580
581 #[inline]
582 unsafe fn from_value(value: &'a glib::Value) -> Self {
583 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
584 }
585}
586
587impl ToValue for ConverterFlags {
588 #[inline]
589 fn to_value(&self) -> glib::Value {
590 let mut value = glib::Value::for_value_type::<Self>();
591 unsafe {
592 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
593 }
594 value
595 }
596
597 #[inline]
598 fn value_type(&self) -> glib::Type {
599 Self::static_type()
600 }
601}
602
603impl From<ConverterFlags> for glib::Value {
604 #[inline]
605 fn from(v: ConverterFlags) -> Self {
606 ToValue::to_value(&v)
607 }
608}
609
610bitflags! {
611 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
613 #[doc(alias = "GDBusCallFlags")]
614 pub struct DBusCallFlags: u32 {
615 #[doc(alias = "G_DBUS_CALL_FLAGS_NONE")]
617 const NONE = ffi::G_DBUS_CALL_FLAGS_NONE as _;
618 #[doc(alias = "G_DBUS_CALL_FLAGS_NO_AUTO_START")]
622 const NO_AUTO_START = ffi::G_DBUS_CALL_FLAGS_NO_AUTO_START as _;
623 #[doc(alias = "G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION")]
626 const ALLOW_INTERACTIVE_AUTHORIZATION = ffi::G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION as _;
627 }
628}
629
630#[doc(hidden)]
631impl IntoGlib for DBusCallFlags {
632 type GlibType = ffi::GDBusCallFlags;
633
634 #[inline]
635 fn into_glib(self) -> ffi::GDBusCallFlags {
636 self.bits()
637 }
638}
639
640#[doc(hidden)]
641impl FromGlib<ffi::GDBusCallFlags> for DBusCallFlags {
642 #[inline]
643 unsafe fn from_glib(value: ffi::GDBusCallFlags) -> Self {
644 Self::from_bits_truncate(value)
645 }
646}
647
648impl StaticType for DBusCallFlags {
649 #[inline]
650 #[doc(alias = "g_dbus_call_flags_get_type")]
651 fn static_type() -> glib::Type {
652 unsafe { from_glib(ffi::g_dbus_call_flags_get_type()) }
653 }
654}
655
656impl glib::HasParamSpec for DBusCallFlags {
657 type ParamSpec = glib::ParamSpecFlags;
658 type SetValue = Self;
659 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
660
661 fn param_spec_builder() -> Self::BuilderFn {
662 Self::ParamSpec::builder
663 }
664}
665
666impl glib::value::ValueType for DBusCallFlags {
667 type Type = Self;
668}
669
670unsafe impl<'a> glib::value::FromValue<'a> for DBusCallFlags {
671 type Checker = glib::value::GenericValueTypeChecker<Self>;
672
673 #[inline]
674 unsafe fn from_value(value: &'a glib::Value) -> Self {
675 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
676 }
677}
678
679impl ToValue for DBusCallFlags {
680 #[inline]
681 fn to_value(&self) -> glib::Value {
682 let mut value = glib::Value::for_value_type::<Self>();
683 unsafe {
684 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
685 }
686 value
687 }
688
689 #[inline]
690 fn value_type(&self) -> glib::Type {
691 Self::static_type()
692 }
693}
694
695impl From<DBusCallFlags> for glib::Value {
696 #[inline]
697 fn from(v: DBusCallFlags) -> Self {
698 ToValue::to_value(&v)
699 }
700}
701
702bitflags! {
703 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
705 #[doc(alias = "GDBusCapabilityFlags")]
706 pub struct DBusCapabilityFlags: u32 {
707 #[doc(alias = "G_DBUS_CAPABILITY_FLAGS_NONE")]
709 const NONE = ffi::G_DBUS_CAPABILITY_FLAGS_NONE as _;
710 #[doc(alias = "G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING")]
713 const UNIX_FD_PASSING = ffi::G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING as _;
714 }
715}
716
717#[doc(hidden)]
718impl IntoGlib for DBusCapabilityFlags {
719 type GlibType = ffi::GDBusCapabilityFlags;
720
721 #[inline]
722 fn into_glib(self) -> ffi::GDBusCapabilityFlags {
723 self.bits()
724 }
725}
726
727#[doc(hidden)]
728impl FromGlib<ffi::GDBusCapabilityFlags> for DBusCapabilityFlags {
729 #[inline]
730 unsafe fn from_glib(value: ffi::GDBusCapabilityFlags) -> Self {
731 Self::from_bits_truncate(value)
732 }
733}
734
735impl StaticType for DBusCapabilityFlags {
736 #[inline]
737 #[doc(alias = "g_dbus_capability_flags_get_type")]
738 fn static_type() -> glib::Type {
739 unsafe { from_glib(ffi::g_dbus_capability_flags_get_type()) }
740 }
741}
742
743impl glib::HasParamSpec for DBusCapabilityFlags {
744 type ParamSpec = glib::ParamSpecFlags;
745 type SetValue = Self;
746 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
747
748 fn param_spec_builder() -> Self::BuilderFn {
749 Self::ParamSpec::builder
750 }
751}
752
753impl glib::value::ValueType for DBusCapabilityFlags {
754 type Type = Self;
755}
756
757unsafe impl<'a> glib::value::FromValue<'a> for DBusCapabilityFlags {
758 type Checker = glib::value::GenericValueTypeChecker<Self>;
759
760 #[inline]
761 unsafe fn from_value(value: &'a glib::Value) -> Self {
762 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
763 }
764}
765
766impl ToValue for DBusCapabilityFlags {
767 #[inline]
768 fn to_value(&self) -> glib::Value {
769 let mut value = glib::Value::for_value_type::<Self>();
770 unsafe {
771 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
772 }
773 value
774 }
775
776 #[inline]
777 fn value_type(&self) -> glib::Type {
778 Self::static_type()
779 }
780}
781
782impl From<DBusCapabilityFlags> for glib::Value {
783 #[inline]
784 fn from(v: DBusCapabilityFlags) -> Self {
785 ToValue::to_value(&v)
786 }
787}
788
789bitflags! {
790 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
792 #[doc(alias = "GDBusConnectionFlags")]
793 pub struct DBusConnectionFlags: u32 {
794 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_NONE")]
796 const NONE = ffi::G_DBUS_CONNECTION_FLAGS_NONE as _;
797 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT")]
799 const AUTHENTICATION_CLIENT = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT as _;
800 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER")]
802 const AUTHENTICATION_SERVER = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER as _;
803 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS")]
807 const AUTHENTICATION_ALLOW_ANONYMOUS = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS as _;
808 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION")]
811 const MESSAGE_BUS_CONNECTION = ffi::G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION as _;
812 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING")]
815 const DELAY_MESSAGE_PROCESSING = ffi::G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING as _;
816 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER")]
819 const AUTHENTICATION_REQUIRE_SAME_USER = ffi::G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER as _;
820 #[cfg(feature = "v2_74")]
827 #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
828 #[doc(alias = "G_DBUS_CONNECTION_FLAGS_CROSS_NAMESPACE")]
829 const CROSS_NAMESPACE = ffi::G_DBUS_CONNECTION_FLAGS_CROSS_NAMESPACE as _;
830 }
831}
832
833#[doc(hidden)]
834impl IntoGlib for DBusConnectionFlags {
835 type GlibType = ffi::GDBusConnectionFlags;
836
837 #[inline]
838 fn into_glib(self) -> ffi::GDBusConnectionFlags {
839 self.bits()
840 }
841}
842
843#[doc(hidden)]
844impl FromGlib<ffi::GDBusConnectionFlags> for DBusConnectionFlags {
845 #[inline]
846 unsafe fn from_glib(value: ffi::GDBusConnectionFlags) -> Self {
847 Self::from_bits_truncate(value)
848 }
849}
850
851impl StaticType for DBusConnectionFlags {
852 #[inline]
853 #[doc(alias = "g_dbus_connection_flags_get_type")]
854 fn static_type() -> glib::Type {
855 unsafe { from_glib(ffi::g_dbus_connection_flags_get_type()) }
856 }
857}
858
859impl glib::HasParamSpec for DBusConnectionFlags {
860 type ParamSpec = glib::ParamSpecFlags;
861 type SetValue = Self;
862 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
863
864 fn param_spec_builder() -> Self::BuilderFn {
865 Self::ParamSpec::builder
866 }
867}
868
869impl glib::value::ValueType for DBusConnectionFlags {
870 type Type = Self;
871}
872
873unsafe impl<'a> glib::value::FromValue<'a> for DBusConnectionFlags {
874 type Checker = glib::value::GenericValueTypeChecker<Self>;
875
876 #[inline]
877 unsafe fn from_value(value: &'a glib::Value) -> Self {
878 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
879 }
880}
881
882impl ToValue for DBusConnectionFlags {
883 #[inline]
884 fn to_value(&self) -> glib::Value {
885 let mut value = glib::Value::for_value_type::<Self>();
886 unsafe {
887 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
888 }
889 value
890 }
891
892 #[inline]
893 fn value_type(&self) -> glib::Type {
894 Self::static_type()
895 }
896}
897
898impl From<DBusConnectionFlags> for glib::Value {
899 #[inline]
900 fn from(v: DBusConnectionFlags) -> Self {
901 ToValue::to_value(&v)
902 }
903}
904
905bitflags! {
906 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
908 #[doc(alias = "GDBusInterfaceSkeletonFlags")]
909 pub struct DBusInterfaceSkeletonFlags: u32 {
910 #[doc(alias = "G_DBUS_INTERFACE_SKELETON_FLAGS_NONE")]
912 const NONE = ffi::G_DBUS_INTERFACE_SKELETON_FLAGS_NONE as _;
913 #[doc(alias = "G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD")]
918 const HANDLE_METHOD_INVOCATIONS_IN_THREAD = ffi::G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD as _;
919 }
920}
921
922#[doc(hidden)]
923impl IntoGlib for DBusInterfaceSkeletonFlags {
924 type GlibType = ffi::GDBusInterfaceSkeletonFlags;
925
926 #[inline]
927 fn into_glib(self) -> ffi::GDBusInterfaceSkeletonFlags {
928 self.bits()
929 }
930}
931
932#[doc(hidden)]
933impl FromGlib<ffi::GDBusInterfaceSkeletonFlags> for DBusInterfaceSkeletonFlags {
934 #[inline]
935 unsafe fn from_glib(value: ffi::GDBusInterfaceSkeletonFlags) -> Self {
936 Self::from_bits_truncate(value)
937 }
938}
939
940impl StaticType for DBusInterfaceSkeletonFlags {
941 #[inline]
942 #[doc(alias = "g_dbus_interface_skeleton_flags_get_type")]
943 fn static_type() -> glib::Type {
944 unsafe { from_glib(ffi::g_dbus_interface_skeleton_flags_get_type()) }
945 }
946}
947
948impl glib::HasParamSpec for DBusInterfaceSkeletonFlags {
949 type ParamSpec = glib::ParamSpecFlags;
950 type SetValue = Self;
951 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
952
953 fn param_spec_builder() -> Self::BuilderFn {
954 Self::ParamSpec::builder
955 }
956}
957
958impl glib::value::ValueType for DBusInterfaceSkeletonFlags {
959 type Type = Self;
960}
961
962unsafe impl<'a> glib::value::FromValue<'a> for DBusInterfaceSkeletonFlags {
963 type Checker = glib::value::GenericValueTypeChecker<Self>;
964
965 #[inline]
966 unsafe fn from_value(value: &'a glib::Value) -> Self {
967 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
968 }
969}
970
971impl ToValue for DBusInterfaceSkeletonFlags {
972 #[inline]
973 fn to_value(&self) -> glib::Value {
974 let mut value = glib::Value::for_value_type::<Self>();
975 unsafe {
976 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
977 }
978 value
979 }
980
981 #[inline]
982 fn value_type(&self) -> glib::Type {
983 Self::static_type()
984 }
985}
986
987impl From<DBusInterfaceSkeletonFlags> for glib::Value {
988 #[inline]
989 fn from(v: DBusInterfaceSkeletonFlags) -> Self {
990 ToValue::to_value(&v)
991 }
992}
993
994bitflags! {
995 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
997 #[doc(alias = "GDBusMessageFlags")]
998 pub struct DBusMessageFlags: u32 {
999 #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NONE")]
1001 const NONE = ffi::G_DBUS_MESSAGE_FLAGS_NONE as _;
1002 #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED")]
1004 const NO_REPLY_EXPECTED = ffi::G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED as _;
1005 #[doc(alias = "G_DBUS_MESSAGE_FLAGS_NO_AUTO_START")]
1008 const NO_AUTO_START = ffi::G_DBUS_MESSAGE_FLAGS_NO_AUTO_START as _;
1009 #[doc(alias = "G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION")]
1013 const ALLOW_INTERACTIVE_AUTHORIZATION = ffi::G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION as _;
1014 }
1015}
1016
1017#[doc(hidden)]
1018impl IntoGlib for DBusMessageFlags {
1019 type GlibType = ffi::GDBusMessageFlags;
1020
1021 #[inline]
1022 fn into_glib(self) -> ffi::GDBusMessageFlags {
1023 self.bits()
1024 }
1025}
1026
1027#[doc(hidden)]
1028impl FromGlib<ffi::GDBusMessageFlags> for DBusMessageFlags {
1029 #[inline]
1030 unsafe fn from_glib(value: ffi::GDBusMessageFlags) -> Self {
1031 Self::from_bits_truncate(value)
1032 }
1033}
1034
1035impl StaticType for DBusMessageFlags {
1036 #[inline]
1037 #[doc(alias = "g_dbus_message_flags_get_type")]
1038 fn static_type() -> glib::Type {
1039 unsafe { from_glib(ffi::g_dbus_message_flags_get_type()) }
1040 }
1041}
1042
1043impl glib::HasParamSpec for DBusMessageFlags {
1044 type ParamSpec = glib::ParamSpecFlags;
1045 type SetValue = Self;
1046 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1047
1048 fn param_spec_builder() -> Self::BuilderFn {
1049 Self::ParamSpec::builder
1050 }
1051}
1052
1053impl glib::value::ValueType for DBusMessageFlags {
1054 type Type = Self;
1055}
1056
1057unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageFlags {
1058 type Checker = glib::value::GenericValueTypeChecker<Self>;
1059
1060 #[inline]
1061 unsafe fn from_value(value: &'a glib::Value) -> Self {
1062 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1063 }
1064}
1065
1066impl ToValue for DBusMessageFlags {
1067 #[inline]
1068 fn to_value(&self) -> glib::Value {
1069 let mut value = glib::Value::for_value_type::<Self>();
1070 unsafe {
1071 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1072 }
1073 value
1074 }
1075
1076 #[inline]
1077 fn value_type(&self) -> glib::Type {
1078 Self::static_type()
1079 }
1080}
1081
1082impl From<DBusMessageFlags> for glib::Value {
1083 #[inline]
1084 fn from(v: DBusMessageFlags) -> Self {
1085 ToValue::to_value(&v)
1086 }
1087}
1088
1089bitflags! {
1090 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1092 #[doc(alias = "GDBusObjectManagerClientFlags")]
1093 pub struct DBusObjectManagerClientFlags: u32 {
1094 #[doc(alias = "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE")]
1096 const NONE = ffi::G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE as _;
1097 #[doc(alias = "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START")]
1102 const DO_NOT_AUTO_START = ffi::G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START as _;
1103 }
1104}
1105
1106#[doc(hidden)]
1107impl IntoGlib for DBusObjectManagerClientFlags {
1108 type GlibType = ffi::GDBusObjectManagerClientFlags;
1109
1110 #[inline]
1111 fn into_glib(self) -> ffi::GDBusObjectManagerClientFlags {
1112 self.bits()
1113 }
1114}
1115
1116#[doc(hidden)]
1117impl FromGlib<ffi::GDBusObjectManagerClientFlags> for DBusObjectManagerClientFlags {
1118 #[inline]
1119 unsafe fn from_glib(value: ffi::GDBusObjectManagerClientFlags) -> Self {
1120 Self::from_bits_truncate(value)
1121 }
1122}
1123
1124impl StaticType for DBusObjectManagerClientFlags {
1125 #[inline]
1126 #[doc(alias = "g_dbus_object_manager_client_flags_get_type")]
1127 fn static_type() -> glib::Type {
1128 unsafe { from_glib(ffi::g_dbus_object_manager_client_flags_get_type()) }
1129 }
1130}
1131
1132impl glib::HasParamSpec for DBusObjectManagerClientFlags {
1133 type ParamSpec = glib::ParamSpecFlags;
1134 type SetValue = Self;
1135 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1136
1137 fn param_spec_builder() -> Self::BuilderFn {
1138 Self::ParamSpec::builder
1139 }
1140}
1141
1142impl glib::value::ValueType for DBusObjectManagerClientFlags {
1143 type Type = Self;
1144}
1145
1146unsafe impl<'a> glib::value::FromValue<'a> for DBusObjectManagerClientFlags {
1147 type Checker = glib::value::GenericValueTypeChecker<Self>;
1148
1149 #[inline]
1150 unsafe fn from_value(value: &'a glib::Value) -> Self {
1151 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1152 }
1153}
1154
1155impl ToValue for DBusObjectManagerClientFlags {
1156 #[inline]
1157 fn to_value(&self) -> glib::Value {
1158 let mut value = glib::Value::for_value_type::<Self>();
1159 unsafe {
1160 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1161 }
1162 value
1163 }
1164
1165 #[inline]
1166 fn value_type(&self) -> glib::Type {
1167 Self::static_type()
1168 }
1169}
1170
1171impl From<DBusObjectManagerClientFlags> for glib::Value {
1172 #[inline]
1173 fn from(v: DBusObjectManagerClientFlags) -> Self {
1174 ToValue::to_value(&v)
1175 }
1176}
1177
1178bitflags! {
1179 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1181 #[doc(alias = "GDBusPropertyInfoFlags")]
1182 pub struct DBusPropertyInfoFlags: u32 {
1183 #[doc(alias = "G_DBUS_PROPERTY_INFO_FLAGS_NONE")]
1185 const NONE = ffi::G_DBUS_PROPERTY_INFO_FLAGS_NONE as _;
1186 #[doc(alias = "G_DBUS_PROPERTY_INFO_FLAGS_READABLE")]
1188 const READABLE = ffi::G_DBUS_PROPERTY_INFO_FLAGS_READABLE as _;
1189 #[doc(alias = "G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE")]
1191 const WRITABLE = ffi::G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE as _;
1192 }
1193}
1194
1195#[doc(hidden)]
1196impl IntoGlib for DBusPropertyInfoFlags {
1197 type GlibType = ffi::GDBusPropertyInfoFlags;
1198
1199 #[inline]
1200 fn into_glib(self) -> ffi::GDBusPropertyInfoFlags {
1201 self.bits()
1202 }
1203}
1204
1205#[doc(hidden)]
1206impl FromGlib<ffi::GDBusPropertyInfoFlags> for DBusPropertyInfoFlags {
1207 #[inline]
1208 unsafe fn from_glib(value: ffi::GDBusPropertyInfoFlags) -> Self {
1209 Self::from_bits_truncate(value)
1210 }
1211}
1212
1213impl StaticType for DBusPropertyInfoFlags {
1214 #[inline]
1215 #[doc(alias = "g_dbus_property_info_flags_get_type")]
1216 fn static_type() -> glib::Type {
1217 unsafe { from_glib(ffi::g_dbus_property_info_flags_get_type()) }
1218 }
1219}
1220
1221impl glib::HasParamSpec for DBusPropertyInfoFlags {
1222 type ParamSpec = glib::ParamSpecFlags;
1223 type SetValue = Self;
1224 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1225
1226 fn param_spec_builder() -> Self::BuilderFn {
1227 Self::ParamSpec::builder
1228 }
1229}
1230
1231impl glib::value::ValueType for DBusPropertyInfoFlags {
1232 type Type = Self;
1233}
1234
1235unsafe impl<'a> glib::value::FromValue<'a> for DBusPropertyInfoFlags {
1236 type Checker = glib::value::GenericValueTypeChecker<Self>;
1237
1238 #[inline]
1239 unsafe fn from_value(value: &'a glib::Value) -> Self {
1240 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1241 }
1242}
1243
1244impl ToValue for DBusPropertyInfoFlags {
1245 #[inline]
1246 fn to_value(&self) -> glib::Value {
1247 let mut value = glib::Value::for_value_type::<Self>();
1248 unsafe {
1249 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1250 }
1251 value
1252 }
1253
1254 #[inline]
1255 fn value_type(&self) -> glib::Type {
1256 Self::static_type()
1257 }
1258}
1259
1260impl From<DBusPropertyInfoFlags> for glib::Value {
1261 #[inline]
1262 fn from(v: DBusPropertyInfoFlags) -> Self {
1263 ToValue::to_value(&v)
1264 }
1265}
1266
1267bitflags! {
1268 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1270 #[doc(alias = "GDBusProxyFlags")]
1271 pub struct DBusProxyFlags: u32 {
1272 #[doc(alias = "G_DBUS_PROXY_FLAGS_NONE")]
1274 const NONE = ffi::G_DBUS_PROXY_FLAGS_NONE as _;
1275 #[doc(alias = "G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES")]
1277 const DO_NOT_LOAD_PROPERTIES = ffi::G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES as _;
1278 #[doc(alias = "G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS")]
1280 const DO_NOT_CONNECT_SIGNALS = ffi::G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS as _;
1281 #[doc(alias = "G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START")]
1285 const DO_NOT_AUTO_START = ffi::G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START as _;
1286 #[doc(alias = "G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES")]
1288 const GET_INVALIDATED_PROPERTIES = ffi::G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES as _;
1289 #[doc(alias = "G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION")]
1294 const DO_NOT_AUTO_START_AT_CONSTRUCTION = ffi::G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION as _;
1295 #[cfg(feature = "v2_70")]
1299 #[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
1300 #[doc(alias = "G_DBUS_PROXY_FLAGS_NO_MATCH_RULE")]
1301 const NO_MATCH_RULE = ffi::G_DBUS_PROXY_FLAGS_NO_MATCH_RULE as _;
1302 }
1303}
1304
1305#[doc(hidden)]
1306impl IntoGlib for DBusProxyFlags {
1307 type GlibType = ffi::GDBusProxyFlags;
1308
1309 #[inline]
1310 fn into_glib(self) -> ffi::GDBusProxyFlags {
1311 self.bits()
1312 }
1313}
1314
1315#[doc(hidden)]
1316impl FromGlib<ffi::GDBusProxyFlags> for DBusProxyFlags {
1317 #[inline]
1318 unsafe fn from_glib(value: ffi::GDBusProxyFlags) -> Self {
1319 Self::from_bits_truncate(value)
1320 }
1321}
1322
1323impl StaticType for DBusProxyFlags {
1324 #[inline]
1325 #[doc(alias = "g_dbus_proxy_flags_get_type")]
1326 fn static_type() -> glib::Type {
1327 unsafe { from_glib(ffi::g_dbus_proxy_flags_get_type()) }
1328 }
1329}
1330
1331impl glib::HasParamSpec for DBusProxyFlags {
1332 type ParamSpec = glib::ParamSpecFlags;
1333 type SetValue = Self;
1334 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1335
1336 fn param_spec_builder() -> Self::BuilderFn {
1337 Self::ParamSpec::builder
1338 }
1339}
1340
1341impl glib::value::ValueType for DBusProxyFlags {
1342 type Type = Self;
1343}
1344
1345unsafe impl<'a> glib::value::FromValue<'a> for DBusProxyFlags {
1346 type Checker = glib::value::GenericValueTypeChecker<Self>;
1347
1348 #[inline]
1349 unsafe fn from_value(value: &'a glib::Value) -> Self {
1350 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1351 }
1352}
1353
1354impl ToValue for DBusProxyFlags {
1355 #[inline]
1356 fn to_value(&self) -> glib::Value {
1357 let mut value = glib::Value::for_value_type::<Self>();
1358 unsafe {
1359 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1360 }
1361 value
1362 }
1363
1364 #[inline]
1365 fn value_type(&self) -> glib::Type {
1366 Self::static_type()
1367 }
1368}
1369
1370impl From<DBusProxyFlags> for glib::Value {
1371 #[inline]
1372 fn from(v: DBusProxyFlags) -> Self {
1373 ToValue::to_value(&v)
1374 }
1375}
1376
1377bitflags! {
1378 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1380 #[doc(alias = "GDBusSendMessageFlags")]
1381 pub struct DBusSendMessageFlags: u32 {
1382 #[doc(alias = "G_DBUS_SEND_MESSAGE_FLAGS_NONE")]
1384 const NONE = ffi::G_DBUS_SEND_MESSAGE_FLAGS_NONE as _;
1385 #[doc(alias = "G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL")]
1389 const PRESERVE_SERIAL = ffi::G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL as _;
1390 }
1391}
1392
1393#[doc(hidden)]
1394impl IntoGlib for DBusSendMessageFlags {
1395 type GlibType = ffi::GDBusSendMessageFlags;
1396
1397 #[inline]
1398 fn into_glib(self) -> ffi::GDBusSendMessageFlags {
1399 self.bits()
1400 }
1401}
1402
1403#[doc(hidden)]
1404impl FromGlib<ffi::GDBusSendMessageFlags> for DBusSendMessageFlags {
1405 #[inline]
1406 unsafe fn from_glib(value: ffi::GDBusSendMessageFlags) -> Self {
1407 Self::from_bits_truncate(value)
1408 }
1409}
1410
1411impl StaticType for DBusSendMessageFlags {
1412 #[inline]
1413 #[doc(alias = "g_dbus_send_message_flags_get_type")]
1414 fn static_type() -> glib::Type {
1415 unsafe { from_glib(ffi::g_dbus_send_message_flags_get_type()) }
1416 }
1417}
1418
1419impl glib::HasParamSpec for DBusSendMessageFlags {
1420 type ParamSpec = glib::ParamSpecFlags;
1421 type SetValue = Self;
1422 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1423
1424 fn param_spec_builder() -> Self::BuilderFn {
1425 Self::ParamSpec::builder
1426 }
1427}
1428
1429impl glib::value::ValueType for DBusSendMessageFlags {
1430 type Type = Self;
1431}
1432
1433unsafe impl<'a> glib::value::FromValue<'a> for DBusSendMessageFlags {
1434 type Checker = glib::value::GenericValueTypeChecker<Self>;
1435
1436 #[inline]
1437 unsafe fn from_value(value: &'a glib::Value) -> Self {
1438 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1439 }
1440}
1441
1442impl ToValue for DBusSendMessageFlags {
1443 #[inline]
1444 fn to_value(&self) -> glib::Value {
1445 let mut value = glib::Value::for_value_type::<Self>();
1446 unsafe {
1447 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1448 }
1449 value
1450 }
1451
1452 #[inline]
1453 fn value_type(&self) -> glib::Type {
1454 Self::static_type()
1455 }
1456}
1457
1458impl From<DBusSendMessageFlags> for glib::Value {
1459 #[inline]
1460 fn from(v: DBusSendMessageFlags) -> Self {
1461 ToValue::to_value(&v)
1462 }
1463}
1464
1465bitflags! {
1466 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1468 #[doc(alias = "GDBusServerFlags")]
1469 pub struct DBusServerFlags: u32 {
1470 #[doc(alias = "G_DBUS_SERVER_FLAGS_NONE")]
1472 const NONE = ffi::G_DBUS_SERVER_FLAGS_NONE as _;
1473 #[doc(alias = "G_DBUS_SERVER_FLAGS_RUN_IN_THREAD")]
1477 const RUN_IN_THREAD = ffi::G_DBUS_SERVER_FLAGS_RUN_IN_THREAD as _;
1478 #[doc(alias = "G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS")]
1481 const AUTHENTICATION_ALLOW_ANONYMOUS = ffi::G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS as _;
1482 #[doc(alias = "G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER")]
1485 const AUTHENTICATION_REQUIRE_SAME_USER = ffi::G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER as _;
1486 }
1487}
1488
1489#[doc(hidden)]
1490impl IntoGlib for DBusServerFlags {
1491 type GlibType = ffi::GDBusServerFlags;
1492
1493 #[inline]
1494 fn into_glib(self) -> ffi::GDBusServerFlags {
1495 self.bits()
1496 }
1497}
1498
1499#[doc(hidden)]
1500impl FromGlib<ffi::GDBusServerFlags> for DBusServerFlags {
1501 #[inline]
1502 unsafe fn from_glib(value: ffi::GDBusServerFlags) -> Self {
1503 Self::from_bits_truncate(value)
1504 }
1505}
1506
1507impl StaticType for DBusServerFlags {
1508 #[inline]
1509 #[doc(alias = "g_dbus_server_flags_get_type")]
1510 fn static_type() -> glib::Type {
1511 unsafe { from_glib(ffi::g_dbus_server_flags_get_type()) }
1512 }
1513}
1514
1515impl glib::HasParamSpec for DBusServerFlags {
1516 type ParamSpec = glib::ParamSpecFlags;
1517 type SetValue = Self;
1518 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1519
1520 fn param_spec_builder() -> Self::BuilderFn {
1521 Self::ParamSpec::builder
1522 }
1523}
1524
1525impl glib::value::ValueType for DBusServerFlags {
1526 type Type = Self;
1527}
1528
1529unsafe impl<'a> glib::value::FromValue<'a> for DBusServerFlags {
1530 type Checker = glib::value::GenericValueTypeChecker<Self>;
1531
1532 #[inline]
1533 unsafe fn from_value(value: &'a glib::Value) -> Self {
1534 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1535 }
1536}
1537
1538impl ToValue for DBusServerFlags {
1539 #[inline]
1540 fn to_value(&self) -> glib::Value {
1541 let mut value = glib::Value::for_value_type::<Self>();
1542 unsafe {
1543 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1544 }
1545 value
1546 }
1547
1548 #[inline]
1549 fn value_type(&self) -> glib::Type {
1550 Self::static_type()
1551 }
1552}
1553
1554impl From<DBusServerFlags> for glib::Value {
1555 #[inline]
1556 fn from(v: DBusServerFlags) -> Self {
1557 ToValue::to_value(&v)
1558 }
1559}
1560
1561bitflags! {
1562 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1564 #[doc(alias = "GDBusSignalFlags")]
1565 pub struct DBusSignalFlags: u32 {
1566 #[doc(alias = "G_DBUS_SIGNAL_FLAGS_NONE")]
1568 const NONE = ffi::G_DBUS_SIGNAL_FLAGS_NONE as _;
1569 #[doc(alias = "G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE")]
1573 const NO_MATCH_RULE = ffi::G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE as _;
1574 #[doc(alias = "G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE")]
1577 const MATCH_ARG0_NAMESPACE = ffi::G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE as _;
1578 #[doc(alias = "G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH")]
1582 const MATCH_ARG0_PATH = ffi::G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH as _;
1583 }
1584}
1585
1586#[doc(hidden)]
1587impl IntoGlib for DBusSignalFlags {
1588 type GlibType = ffi::GDBusSignalFlags;
1589
1590 #[inline]
1591 fn into_glib(self) -> ffi::GDBusSignalFlags {
1592 self.bits()
1593 }
1594}
1595
1596#[doc(hidden)]
1597impl FromGlib<ffi::GDBusSignalFlags> for DBusSignalFlags {
1598 #[inline]
1599 unsafe fn from_glib(value: ffi::GDBusSignalFlags) -> Self {
1600 Self::from_bits_truncate(value)
1601 }
1602}
1603
1604impl StaticType for DBusSignalFlags {
1605 #[inline]
1606 #[doc(alias = "g_dbus_signal_flags_get_type")]
1607 fn static_type() -> glib::Type {
1608 unsafe { from_glib(ffi::g_dbus_signal_flags_get_type()) }
1609 }
1610}
1611
1612impl glib::HasParamSpec for DBusSignalFlags {
1613 type ParamSpec = glib::ParamSpecFlags;
1614 type SetValue = Self;
1615 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1616
1617 fn param_spec_builder() -> Self::BuilderFn {
1618 Self::ParamSpec::builder
1619 }
1620}
1621
1622impl glib::value::ValueType for DBusSignalFlags {
1623 type Type = Self;
1624}
1625
1626unsafe impl<'a> glib::value::FromValue<'a> for DBusSignalFlags {
1627 type Checker = glib::value::GenericValueTypeChecker<Self>;
1628
1629 #[inline]
1630 unsafe fn from_value(value: &'a glib::Value) -> Self {
1631 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1632 }
1633}
1634
1635impl ToValue for DBusSignalFlags {
1636 #[inline]
1637 fn to_value(&self) -> glib::Value {
1638 let mut value = glib::Value::for_value_type::<Self>();
1639 unsafe {
1640 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1641 }
1642 value
1643 }
1644
1645 #[inline]
1646 fn value_type(&self) -> glib::Type {
1647 Self::static_type()
1648 }
1649}
1650
1651impl From<DBusSignalFlags> for glib::Value {
1652 #[inline]
1653 fn from(v: DBusSignalFlags) -> Self {
1654 ToValue::to_value(&v)
1655 }
1656}
1657
1658bitflags! {
1659 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1661 #[doc(alias = "GDBusSubtreeFlags")]
1662 pub struct DBusSubtreeFlags: u32 {
1663 #[doc(alias = "G_DBUS_SUBTREE_FLAGS_NONE")]
1665 const NONE = ffi::G_DBUS_SUBTREE_FLAGS_NONE as _;
1666 #[doc(alias = "G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES")]
1670 const DISPATCH_TO_UNENUMERATED_NODES = ffi::G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES as _;
1671 }
1672}
1673
1674#[doc(hidden)]
1675impl IntoGlib for DBusSubtreeFlags {
1676 type GlibType = ffi::GDBusSubtreeFlags;
1677
1678 #[inline]
1679 fn into_glib(self) -> ffi::GDBusSubtreeFlags {
1680 self.bits()
1681 }
1682}
1683
1684#[doc(hidden)]
1685impl FromGlib<ffi::GDBusSubtreeFlags> for DBusSubtreeFlags {
1686 #[inline]
1687 unsafe fn from_glib(value: ffi::GDBusSubtreeFlags) -> Self {
1688 Self::from_bits_truncate(value)
1689 }
1690}
1691
1692impl StaticType for DBusSubtreeFlags {
1693 #[inline]
1694 #[doc(alias = "g_dbus_subtree_flags_get_type")]
1695 fn static_type() -> glib::Type {
1696 unsafe { from_glib(ffi::g_dbus_subtree_flags_get_type()) }
1697 }
1698}
1699
1700impl glib::HasParamSpec for DBusSubtreeFlags {
1701 type ParamSpec = glib::ParamSpecFlags;
1702 type SetValue = Self;
1703 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1704
1705 fn param_spec_builder() -> Self::BuilderFn {
1706 Self::ParamSpec::builder
1707 }
1708}
1709
1710impl glib::value::ValueType for DBusSubtreeFlags {
1711 type Type = Self;
1712}
1713
1714unsafe impl<'a> glib::value::FromValue<'a> for DBusSubtreeFlags {
1715 type Checker = glib::value::GenericValueTypeChecker<Self>;
1716
1717 #[inline]
1718 unsafe fn from_value(value: &'a glib::Value) -> Self {
1719 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1720 }
1721}
1722
1723impl ToValue for DBusSubtreeFlags {
1724 #[inline]
1725 fn to_value(&self) -> glib::Value {
1726 let mut value = glib::Value::for_value_type::<Self>();
1727 unsafe {
1728 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1729 }
1730 value
1731 }
1732
1733 #[inline]
1734 fn value_type(&self) -> glib::Type {
1735 Self::static_type()
1736 }
1737}
1738
1739impl From<DBusSubtreeFlags> for glib::Value {
1740 #[inline]
1741 fn from(v: DBusSubtreeFlags) -> Self {
1742 ToValue::to_value(&v)
1743 }
1744}
1745
1746bitflags! {
1747 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1749 #[doc(alias = "GDriveStartFlags")]
1750 pub struct DriveStartFlags: u32 {
1751 #[doc(alias = "G_DRIVE_START_NONE")]
1753 const NONE = ffi::G_DRIVE_START_NONE as _;
1754 }
1755}
1756
1757#[doc(hidden)]
1758impl IntoGlib for DriveStartFlags {
1759 type GlibType = ffi::GDriveStartFlags;
1760
1761 #[inline]
1762 fn into_glib(self) -> ffi::GDriveStartFlags {
1763 self.bits()
1764 }
1765}
1766
1767#[doc(hidden)]
1768impl FromGlib<ffi::GDriveStartFlags> for DriveStartFlags {
1769 #[inline]
1770 unsafe fn from_glib(value: ffi::GDriveStartFlags) -> Self {
1771 Self::from_bits_truncate(value)
1772 }
1773}
1774
1775impl StaticType for DriveStartFlags {
1776 #[inline]
1777 #[doc(alias = "g_drive_start_flags_get_type")]
1778 fn static_type() -> glib::Type {
1779 unsafe { from_glib(ffi::g_drive_start_flags_get_type()) }
1780 }
1781}
1782
1783impl glib::HasParamSpec for DriveStartFlags {
1784 type ParamSpec = glib::ParamSpecFlags;
1785 type SetValue = Self;
1786 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1787
1788 fn param_spec_builder() -> Self::BuilderFn {
1789 Self::ParamSpec::builder
1790 }
1791}
1792
1793impl glib::value::ValueType for DriveStartFlags {
1794 type Type = Self;
1795}
1796
1797unsafe impl<'a> glib::value::FromValue<'a> for DriveStartFlags {
1798 type Checker = glib::value::GenericValueTypeChecker<Self>;
1799
1800 #[inline]
1801 unsafe fn from_value(value: &'a glib::Value) -> Self {
1802 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1803 }
1804}
1805
1806impl ToValue for DriveStartFlags {
1807 #[inline]
1808 fn to_value(&self) -> glib::Value {
1809 let mut value = glib::Value::for_value_type::<Self>();
1810 unsafe {
1811 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1812 }
1813 value
1814 }
1815
1816 #[inline]
1817 fn value_type(&self) -> glib::Type {
1818 Self::static_type()
1819 }
1820}
1821
1822impl From<DriveStartFlags> for glib::Value {
1823 #[inline]
1824 fn from(v: DriveStartFlags) -> Self {
1825 ToValue::to_value(&v)
1826 }
1827}
1828
1829bitflags! {
1830 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1832 #[doc(alias = "GFileAttributeInfoFlags")]
1833 pub struct FileAttributeInfoFlags: u32 {
1834 #[doc(alias = "G_FILE_ATTRIBUTE_INFO_NONE")]
1836 const NONE = ffi::G_FILE_ATTRIBUTE_INFO_NONE as _;
1837 #[doc(alias = "G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE")]
1839 const COPY_WITH_FILE = ffi::G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE as _;
1840 #[doc(alias = "G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED")]
1842 const COPY_WHEN_MOVED = ffi::G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED as _;
1843 }
1844}
1845
1846#[doc(hidden)]
1847impl IntoGlib for FileAttributeInfoFlags {
1848 type GlibType = ffi::GFileAttributeInfoFlags;
1849
1850 #[inline]
1851 fn into_glib(self) -> ffi::GFileAttributeInfoFlags {
1852 self.bits()
1853 }
1854}
1855
1856#[doc(hidden)]
1857impl FromGlib<ffi::GFileAttributeInfoFlags> for FileAttributeInfoFlags {
1858 #[inline]
1859 unsafe fn from_glib(value: ffi::GFileAttributeInfoFlags) -> Self {
1860 Self::from_bits_truncate(value)
1861 }
1862}
1863
1864impl StaticType for FileAttributeInfoFlags {
1865 #[inline]
1866 #[doc(alias = "g_file_attribute_info_flags_get_type")]
1867 fn static_type() -> glib::Type {
1868 unsafe { from_glib(ffi::g_file_attribute_info_flags_get_type()) }
1869 }
1870}
1871
1872impl glib::HasParamSpec for FileAttributeInfoFlags {
1873 type ParamSpec = glib::ParamSpecFlags;
1874 type SetValue = Self;
1875 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1876
1877 fn param_spec_builder() -> Self::BuilderFn {
1878 Self::ParamSpec::builder
1879 }
1880}
1881
1882impl glib::value::ValueType for FileAttributeInfoFlags {
1883 type Type = Self;
1884}
1885
1886unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeInfoFlags {
1887 type Checker = glib::value::GenericValueTypeChecker<Self>;
1888
1889 #[inline]
1890 unsafe fn from_value(value: &'a glib::Value) -> Self {
1891 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1892 }
1893}
1894
1895impl ToValue for FileAttributeInfoFlags {
1896 #[inline]
1897 fn to_value(&self) -> glib::Value {
1898 let mut value = glib::Value::for_value_type::<Self>();
1899 unsafe {
1900 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1901 }
1902 value
1903 }
1904
1905 #[inline]
1906 fn value_type(&self) -> glib::Type {
1907 Self::static_type()
1908 }
1909}
1910
1911impl From<FileAttributeInfoFlags> for glib::Value {
1912 #[inline]
1913 fn from(v: FileAttributeInfoFlags) -> Self {
1914 ToValue::to_value(&v)
1915 }
1916}
1917
1918bitflags! {
1919 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1921 #[doc(alias = "GFileCopyFlags")]
1922 pub struct FileCopyFlags: u32 {
1923 #[doc(alias = "G_FILE_COPY_NONE")]
1925 const NONE = ffi::G_FILE_COPY_NONE as _;
1926 #[doc(alias = "G_FILE_COPY_OVERWRITE")]
1928 const OVERWRITE = ffi::G_FILE_COPY_OVERWRITE as _;
1929 #[doc(alias = "G_FILE_COPY_BACKUP")]
1931 const BACKUP = ffi::G_FILE_COPY_BACKUP as _;
1932 #[doc(alias = "G_FILE_COPY_NOFOLLOW_SYMLINKS")]
1934 const NOFOLLOW_SYMLINKS = ffi::G_FILE_COPY_NOFOLLOW_SYMLINKS as _;
1935 #[doc(alias = "G_FILE_COPY_ALL_METADATA")]
1937 const ALL_METADATA = ffi::G_FILE_COPY_ALL_METADATA as _;
1938 #[doc(alias = "G_FILE_COPY_NO_FALLBACK_FOR_MOVE")]
1940 const NO_FALLBACK_FOR_MOVE = ffi::G_FILE_COPY_NO_FALLBACK_FOR_MOVE as _;
1941 #[doc(alias = "G_FILE_COPY_TARGET_DEFAULT_PERMS")]
1943 const TARGET_DEFAULT_PERMS = ffi::G_FILE_COPY_TARGET_DEFAULT_PERMS as _;
1944 #[cfg(feature = "v2_80")]
1947 #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
1948 #[doc(alias = "G_FILE_COPY_TARGET_DEFAULT_MODIFIED_TIME")]
1949 const TARGET_DEFAULT_MODIFIED_TIME = ffi::G_FILE_COPY_TARGET_DEFAULT_MODIFIED_TIME as _;
1950 }
1951}
1952
1953#[doc(hidden)]
1954impl IntoGlib for FileCopyFlags {
1955 type GlibType = ffi::GFileCopyFlags;
1956
1957 #[inline]
1958 fn into_glib(self) -> ffi::GFileCopyFlags {
1959 self.bits()
1960 }
1961}
1962
1963#[doc(hidden)]
1964impl FromGlib<ffi::GFileCopyFlags> for FileCopyFlags {
1965 #[inline]
1966 unsafe fn from_glib(value: ffi::GFileCopyFlags) -> Self {
1967 Self::from_bits_truncate(value)
1968 }
1969}
1970
1971impl StaticType for FileCopyFlags {
1972 #[inline]
1973 #[doc(alias = "g_file_copy_flags_get_type")]
1974 fn static_type() -> glib::Type {
1975 unsafe { from_glib(ffi::g_file_copy_flags_get_type()) }
1976 }
1977}
1978
1979impl glib::HasParamSpec for FileCopyFlags {
1980 type ParamSpec = glib::ParamSpecFlags;
1981 type SetValue = Self;
1982 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1983
1984 fn param_spec_builder() -> Self::BuilderFn {
1985 Self::ParamSpec::builder
1986 }
1987}
1988
1989impl glib::value::ValueType for FileCopyFlags {
1990 type Type = Self;
1991}
1992
1993unsafe impl<'a> glib::value::FromValue<'a> for FileCopyFlags {
1994 type Checker = glib::value::GenericValueTypeChecker<Self>;
1995
1996 #[inline]
1997 unsafe fn from_value(value: &'a glib::Value) -> Self {
1998 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1999 }
2000}
2001
2002impl ToValue for FileCopyFlags {
2003 #[inline]
2004 fn to_value(&self) -> glib::Value {
2005 let mut value = glib::Value::for_value_type::<Self>();
2006 unsafe {
2007 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2008 }
2009 value
2010 }
2011
2012 #[inline]
2013 fn value_type(&self) -> glib::Type {
2014 Self::static_type()
2015 }
2016}
2017
2018impl From<FileCopyFlags> for glib::Value {
2019 #[inline]
2020 fn from(v: FileCopyFlags) -> Self {
2021 ToValue::to_value(&v)
2022 }
2023}
2024
2025bitflags! {
2026 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2028 #[doc(alias = "GFileCreateFlags")]
2029 pub struct FileCreateFlags: u32 {
2030 #[doc(alias = "G_FILE_CREATE_NONE")]
2032 const NONE = ffi::G_FILE_CREATE_NONE as _;
2033 #[doc(alias = "G_FILE_CREATE_PRIVATE")]
2036 const PRIVATE = ffi::G_FILE_CREATE_PRIVATE as _;
2037 #[doc(alias = "G_FILE_CREATE_REPLACE_DESTINATION")]
2048 const REPLACE_DESTINATION = ffi::G_FILE_CREATE_REPLACE_DESTINATION as _;
2049 }
2050}
2051
2052#[doc(hidden)]
2053impl IntoGlib for FileCreateFlags {
2054 type GlibType = ffi::GFileCreateFlags;
2055
2056 #[inline]
2057 fn into_glib(self) -> ffi::GFileCreateFlags {
2058 self.bits()
2059 }
2060}
2061
2062#[doc(hidden)]
2063impl FromGlib<ffi::GFileCreateFlags> for FileCreateFlags {
2064 #[inline]
2065 unsafe fn from_glib(value: ffi::GFileCreateFlags) -> Self {
2066 Self::from_bits_truncate(value)
2067 }
2068}
2069
2070impl StaticType for FileCreateFlags {
2071 #[inline]
2072 #[doc(alias = "g_file_create_flags_get_type")]
2073 fn static_type() -> glib::Type {
2074 unsafe { from_glib(ffi::g_file_create_flags_get_type()) }
2075 }
2076}
2077
2078impl glib::HasParamSpec for FileCreateFlags {
2079 type ParamSpec = glib::ParamSpecFlags;
2080 type SetValue = Self;
2081 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2082
2083 fn param_spec_builder() -> Self::BuilderFn {
2084 Self::ParamSpec::builder
2085 }
2086}
2087
2088impl glib::value::ValueType for FileCreateFlags {
2089 type Type = Self;
2090}
2091
2092unsafe impl<'a> glib::value::FromValue<'a> for FileCreateFlags {
2093 type Checker = glib::value::GenericValueTypeChecker<Self>;
2094
2095 #[inline]
2096 unsafe fn from_value(value: &'a glib::Value) -> Self {
2097 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2098 }
2099}
2100
2101impl ToValue for FileCreateFlags {
2102 #[inline]
2103 fn to_value(&self) -> glib::Value {
2104 let mut value = glib::Value::for_value_type::<Self>();
2105 unsafe {
2106 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2107 }
2108 value
2109 }
2110
2111 #[inline]
2112 fn value_type(&self) -> glib::Type {
2113 Self::static_type()
2114 }
2115}
2116
2117impl From<FileCreateFlags> for glib::Value {
2118 #[inline]
2119 fn from(v: FileCreateFlags) -> Self {
2120 ToValue::to_value(&v)
2121 }
2122}
2123
2124bitflags! {
2125 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2127 #[doc(alias = "GFileMeasureFlags")]
2128 pub struct FileMeasureFlags: u32 {
2129 #[doc(alias = "G_FILE_MEASURE_NONE")]
2131 const NONE = ffi::G_FILE_MEASURE_NONE as _;
2132 #[doc(alias = "G_FILE_MEASURE_REPORT_ANY_ERROR")]
2136 const REPORT_ANY_ERROR = ffi::G_FILE_MEASURE_REPORT_ANY_ERROR as _;
2137 #[doc(alias = "G_FILE_MEASURE_APPARENT_SIZE")]
2145 const APPARENT_SIZE = ffi::G_FILE_MEASURE_APPARENT_SIZE as _;
2146 #[doc(alias = "G_FILE_MEASURE_NO_XDEV")]
2149 const NO_XDEV = ffi::G_FILE_MEASURE_NO_XDEV as _;
2150 }
2151}
2152
2153#[doc(hidden)]
2154impl IntoGlib for FileMeasureFlags {
2155 type GlibType = ffi::GFileMeasureFlags;
2156
2157 #[inline]
2158 fn into_glib(self) -> ffi::GFileMeasureFlags {
2159 self.bits()
2160 }
2161}
2162
2163#[doc(hidden)]
2164impl FromGlib<ffi::GFileMeasureFlags> for FileMeasureFlags {
2165 #[inline]
2166 unsafe fn from_glib(value: ffi::GFileMeasureFlags) -> Self {
2167 Self::from_bits_truncate(value)
2168 }
2169}
2170
2171impl StaticType for FileMeasureFlags {
2172 #[inline]
2173 #[doc(alias = "g_file_measure_flags_get_type")]
2174 fn static_type() -> glib::Type {
2175 unsafe { from_glib(ffi::g_file_measure_flags_get_type()) }
2176 }
2177}
2178
2179impl glib::HasParamSpec for FileMeasureFlags {
2180 type ParamSpec = glib::ParamSpecFlags;
2181 type SetValue = Self;
2182 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2183
2184 fn param_spec_builder() -> Self::BuilderFn {
2185 Self::ParamSpec::builder
2186 }
2187}
2188
2189impl glib::value::ValueType for FileMeasureFlags {
2190 type Type = Self;
2191}
2192
2193unsafe impl<'a> glib::value::FromValue<'a> for FileMeasureFlags {
2194 type Checker = glib::value::GenericValueTypeChecker<Self>;
2195
2196 #[inline]
2197 unsafe fn from_value(value: &'a glib::Value) -> Self {
2198 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2199 }
2200}
2201
2202impl ToValue for FileMeasureFlags {
2203 #[inline]
2204 fn to_value(&self) -> glib::Value {
2205 let mut value = glib::Value::for_value_type::<Self>();
2206 unsafe {
2207 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2208 }
2209 value
2210 }
2211
2212 #[inline]
2213 fn value_type(&self) -> glib::Type {
2214 Self::static_type()
2215 }
2216}
2217
2218impl From<FileMeasureFlags> for glib::Value {
2219 #[inline]
2220 fn from(v: FileMeasureFlags) -> Self {
2221 ToValue::to_value(&v)
2222 }
2223}
2224
2225bitflags! {
2226 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2228 #[doc(alias = "GFileMonitorFlags")]
2229 pub struct FileMonitorFlags: u32 {
2230 #[doc(alias = "G_FILE_MONITOR_NONE")]
2232 const NONE = ffi::G_FILE_MONITOR_NONE as _;
2233 #[doc(alias = "G_FILE_MONITOR_WATCH_MOUNTS")]
2235 const WATCH_MOUNTS = ffi::G_FILE_MONITOR_WATCH_MOUNTS as _;
2236 #[doc(alias = "G_FILE_MONITOR_SEND_MOVED")]
2243 const SEND_MOVED = ffi::G_FILE_MONITOR_SEND_MOVED as _;
2244 #[doc(alias = "G_FILE_MONITOR_WATCH_HARD_LINKS")]
2247 const WATCH_HARD_LINKS = ffi::G_FILE_MONITOR_WATCH_HARD_LINKS as _;
2248 #[doc(alias = "G_FILE_MONITOR_WATCH_MOVES")]
2253 const WATCH_MOVES = ffi::G_FILE_MONITOR_WATCH_MOVES as _;
2254 }
2255}
2256
2257#[doc(hidden)]
2258impl IntoGlib for FileMonitorFlags {
2259 type GlibType = ffi::GFileMonitorFlags;
2260
2261 #[inline]
2262 fn into_glib(self) -> ffi::GFileMonitorFlags {
2263 self.bits()
2264 }
2265}
2266
2267#[doc(hidden)]
2268impl FromGlib<ffi::GFileMonitorFlags> for FileMonitorFlags {
2269 #[inline]
2270 unsafe fn from_glib(value: ffi::GFileMonitorFlags) -> Self {
2271 Self::from_bits_truncate(value)
2272 }
2273}
2274
2275impl StaticType for FileMonitorFlags {
2276 #[inline]
2277 #[doc(alias = "g_file_monitor_flags_get_type")]
2278 fn static_type() -> glib::Type {
2279 unsafe { from_glib(ffi::g_file_monitor_flags_get_type()) }
2280 }
2281}
2282
2283impl glib::HasParamSpec for FileMonitorFlags {
2284 type ParamSpec = glib::ParamSpecFlags;
2285 type SetValue = Self;
2286 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2287
2288 fn param_spec_builder() -> Self::BuilderFn {
2289 Self::ParamSpec::builder
2290 }
2291}
2292
2293impl glib::value::ValueType for FileMonitorFlags {
2294 type Type = Self;
2295}
2296
2297unsafe impl<'a> glib::value::FromValue<'a> for FileMonitorFlags {
2298 type Checker = glib::value::GenericValueTypeChecker<Self>;
2299
2300 #[inline]
2301 unsafe fn from_value(value: &'a glib::Value) -> Self {
2302 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2303 }
2304}
2305
2306impl ToValue for FileMonitorFlags {
2307 #[inline]
2308 fn to_value(&self) -> glib::Value {
2309 let mut value = glib::Value::for_value_type::<Self>();
2310 unsafe {
2311 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2312 }
2313 value
2314 }
2315
2316 #[inline]
2317 fn value_type(&self) -> glib::Type {
2318 Self::static_type()
2319 }
2320}
2321
2322impl From<FileMonitorFlags> for glib::Value {
2323 #[inline]
2324 fn from(v: FileMonitorFlags) -> Self {
2325 ToValue::to_value(&v)
2326 }
2327}
2328
2329bitflags! {
2330 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2332 #[doc(alias = "GFileQueryInfoFlags")]
2333 pub struct FileQueryInfoFlags: u32 {
2334 #[doc(alias = "G_FILE_QUERY_INFO_NONE")]
2336 const NONE = ffi::G_FILE_QUERY_INFO_NONE as _;
2337 #[doc(alias = "G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS")]
2339 const NOFOLLOW_SYMLINKS = ffi::G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS as _;
2340 }
2341}
2342
2343#[doc(hidden)]
2344impl IntoGlib for FileQueryInfoFlags {
2345 type GlibType = ffi::GFileQueryInfoFlags;
2346
2347 #[inline]
2348 fn into_glib(self) -> ffi::GFileQueryInfoFlags {
2349 self.bits()
2350 }
2351}
2352
2353#[doc(hidden)]
2354impl FromGlib<ffi::GFileQueryInfoFlags> for FileQueryInfoFlags {
2355 #[inline]
2356 unsafe fn from_glib(value: ffi::GFileQueryInfoFlags) -> Self {
2357 Self::from_bits_truncate(value)
2358 }
2359}
2360
2361impl StaticType for FileQueryInfoFlags {
2362 #[inline]
2363 #[doc(alias = "g_file_query_info_flags_get_type")]
2364 fn static_type() -> glib::Type {
2365 unsafe { from_glib(ffi::g_file_query_info_flags_get_type()) }
2366 }
2367}
2368
2369impl glib::HasParamSpec for FileQueryInfoFlags {
2370 type ParamSpec = glib::ParamSpecFlags;
2371 type SetValue = Self;
2372 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2373
2374 fn param_spec_builder() -> Self::BuilderFn {
2375 Self::ParamSpec::builder
2376 }
2377}
2378
2379impl glib::value::ValueType for FileQueryInfoFlags {
2380 type Type = Self;
2381}
2382
2383unsafe impl<'a> glib::value::FromValue<'a> for FileQueryInfoFlags {
2384 type Checker = glib::value::GenericValueTypeChecker<Self>;
2385
2386 #[inline]
2387 unsafe fn from_value(value: &'a glib::Value) -> Self {
2388 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2389 }
2390}
2391
2392impl ToValue for FileQueryInfoFlags {
2393 #[inline]
2394 fn to_value(&self) -> glib::Value {
2395 let mut value = glib::Value::for_value_type::<Self>();
2396 unsafe {
2397 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2398 }
2399 value
2400 }
2401
2402 #[inline]
2403 fn value_type(&self) -> glib::Type {
2404 Self::static_type()
2405 }
2406}
2407
2408impl From<FileQueryInfoFlags> for glib::Value {
2409 #[inline]
2410 fn from(v: FileQueryInfoFlags) -> Self {
2411 ToValue::to_value(&v)
2412 }
2413}
2414
2415bitflags! {
2416 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2418 #[doc(alias = "GIOStreamSpliceFlags")]
2419 pub struct IOStreamSpliceFlags: u32 {
2420 #[doc(alias = "G_IO_STREAM_SPLICE_NONE")]
2422 const NONE = ffi::G_IO_STREAM_SPLICE_NONE as _;
2423 #[doc(alias = "G_IO_STREAM_SPLICE_CLOSE_STREAM1")]
2426 const CLOSE_STREAM1 = ffi::G_IO_STREAM_SPLICE_CLOSE_STREAM1 as _;
2427 #[doc(alias = "G_IO_STREAM_SPLICE_CLOSE_STREAM2")]
2430 const CLOSE_STREAM2 = ffi::G_IO_STREAM_SPLICE_CLOSE_STREAM2 as _;
2431 #[doc(alias = "G_IO_STREAM_SPLICE_WAIT_FOR_BOTH")]
2434 const WAIT_FOR_BOTH = ffi::G_IO_STREAM_SPLICE_WAIT_FOR_BOTH as _;
2435 }
2436}
2437
2438#[doc(hidden)]
2439impl IntoGlib for IOStreamSpliceFlags {
2440 type GlibType = ffi::GIOStreamSpliceFlags;
2441
2442 #[inline]
2443 fn into_glib(self) -> ffi::GIOStreamSpliceFlags {
2444 self.bits()
2445 }
2446}
2447
2448#[doc(hidden)]
2449impl FromGlib<ffi::GIOStreamSpliceFlags> for IOStreamSpliceFlags {
2450 #[inline]
2451 unsafe fn from_glib(value: ffi::GIOStreamSpliceFlags) -> Self {
2452 Self::from_bits_truncate(value)
2453 }
2454}
2455
2456impl StaticType for IOStreamSpliceFlags {
2457 #[inline]
2458 #[doc(alias = "g_io_stream_splice_flags_get_type")]
2459 fn static_type() -> glib::Type {
2460 unsafe { from_glib(ffi::g_io_stream_splice_flags_get_type()) }
2461 }
2462}
2463
2464impl glib::HasParamSpec for IOStreamSpliceFlags {
2465 type ParamSpec = glib::ParamSpecFlags;
2466 type SetValue = Self;
2467 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2468
2469 fn param_spec_builder() -> Self::BuilderFn {
2470 Self::ParamSpec::builder
2471 }
2472}
2473
2474impl glib::value::ValueType for IOStreamSpliceFlags {
2475 type Type = Self;
2476}
2477
2478unsafe impl<'a> glib::value::FromValue<'a> for IOStreamSpliceFlags {
2479 type Checker = glib::value::GenericValueTypeChecker<Self>;
2480
2481 #[inline]
2482 unsafe fn from_value(value: &'a glib::Value) -> Self {
2483 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2484 }
2485}
2486
2487impl ToValue for IOStreamSpliceFlags {
2488 #[inline]
2489 fn to_value(&self) -> glib::Value {
2490 let mut value = glib::Value::for_value_type::<Self>();
2491 unsafe {
2492 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2493 }
2494 value
2495 }
2496
2497 #[inline]
2498 fn value_type(&self) -> glib::Type {
2499 Self::static_type()
2500 }
2501}
2502
2503impl From<IOStreamSpliceFlags> for glib::Value {
2504 #[inline]
2505 fn from(v: IOStreamSpliceFlags) -> Self {
2506 ToValue::to_value(&v)
2507 }
2508}
2509
2510bitflags! {
2511 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2513 #[doc(alias = "GMountMountFlags")]
2514 pub struct MountMountFlags: u32 {
2515 #[doc(alias = "G_MOUNT_MOUNT_NONE")]
2517 const NONE = ffi::G_MOUNT_MOUNT_NONE as _;
2518 }
2519}
2520
2521#[doc(hidden)]
2522impl IntoGlib for MountMountFlags {
2523 type GlibType = ffi::GMountMountFlags;
2524
2525 #[inline]
2526 fn into_glib(self) -> ffi::GMountMountFlags {
2527 self.bits()
2528 }
2529}
2530
2531#[doc(hidden)]
2532impl FromGlib<ffi::GMountMountFlags> for MountMountFlags {
2533 #[inline]
2534 unsafe fn from_glib(value: ffi::GMountMountFlags) -> Self {
2535 Self::from_bits_truncate(value)
2536 }
2537}
2538
2539impl StaticType for MountMountFlags {
2540 #[inline]
2541 #[doc(alias = "g_mount_mount_flags_get_type")]
2542 fn static_type() -> glib::Type {
2543 unsafe { from_glib(ffi::g_mount_mount_flags_get_type()) }
2544 }
2545}
2546
2547impl glib::HasParamSpec for MountMountFlags {
2548 type ParamSpec = glib::ParamSpecFlags;
2549 type SetValue = Self;
2550 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2551
2552 fn param_spec_builder() -> Self::BuilderFn {
2553 Self::ParamSpec::builder
2554 }
2555}
2556
2557impl glib::value::ValueType for MountMountFlags {
2558 type Type = Self;
2559}
2560
2561unsafe impl<'a> glib::value::FromValue<'a> for MountMountFlags {
2562 type Checker = glib::value::GenericValueTypeChecker<Self>;
2563
2564 #[inline]
2565 unsafe fn from_value(value: &'a glib::Value) -> Self {
2566 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2567 }
2568}
2569
2570impl ToValue for MountMountFlags {
2571 #[inline]
2572 fn to_value(&self) -> glib::Value {
2573 let mut value = glib::Value::for_value_type::<Self>();
2574 unsafe {
2575 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2576 }
2577 value
2578 }
2579
2580 #[inline]
2581 fn value_type(&self) -> glib::Type {
2582 Self::static_type()
2583 }
2584}
2585
2586impl From<MountMountFlags> for glib::Value {
2587 #[inline]
2588 fn from(v: MountMountFlags) -> Self {
2589 ToValue::to_value(&v)
2590 }
2591}
2592
2593bitflags! {
2594 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2596 #[doc(alias = "GMountUnmountFlags")]
2597 pub struct MountUnmountFlags: u32 {
2598 #[doc(alias = "G_MOUNT_UNMOUNT_NONE")]
2600 const NONE = ffi::G_MOUNT_UNMOUNT_NONE as _;
2601 #[doc(alias = "G_MOUNT_UNMOUNT_FORCE")]
2604 const FORCE = ffi::G_MOUNT_UNMOUNT_FORCE as _;
2605 }
2606}
2607
2608#[doc(hidden)]
2609impl IntoGlib for MountUnmountFlags {
2610 type GlibType = ffi::GMountUnmountFlags;
2611
2612 #[inline]
2613 fn into_glib(self) -> ffi::GMountUnmountFlags {
2614 self.bits()
2615 }
2616}
2617
2618#[doc(hidden)]
2619impl FromGlib<ffi::GMountUnmountFlags> for MountUnmountFlags {
2620 #[inline]
2621 unsafe fn from_glib(value: ffi::GMountUnmountFlags) -> Self {
2622 Self::from_bits_truncate(value)
2623 }
2624}
2625
2626impl StaticType for MountUnmountFlags {
2627 #[inline]
2628 #[doc(alias = "g_mount_unmount_flags_get_type")]
2629 fn static_type() -> glib::Type {
2630 unsafe { from_glib(ffi::g_mount_unmount_flags_get_type()) }
2631 }
2632}
2633
2634impl glib::HasParamSpec for MountUnmountFlags {
2635 type ParamSpec = glib::ParamSpecFlags;
2636 type SetValue = Self;
2637 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2638
2639 fn param_spec_builder() -> Self::BuilderFn {
2640 Self::ParamSpec::builder
2641 }
2642}
2643
2644impl glib::value::ValueType for MountUnmountFlags {
2645 type Type = Self;
2646}
2647
2648unsafe impl<'a> glib::value::FromValue<'a> for MountUnmountFlags {
2649 type Checker = glib::value::GenericValueTypeChecker<Self>;
2650
2651 #[inline]
2652 unsafe fn from_value(value: &'a glib::Value) -> Self {
2653 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2654 }
2655}
2656
2657impl ToValue for MountUnmountFlags {
2658 #[inline]
2659 fn to_value(&self) -> glib::Value {
2660 let mut value = glib::Value::for_value_type::<Self>();
2661 unsafe {
2662 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2663 }
2664 value
2665 }
2666
2667 #[inline]
2668 fn value_type(&self) -> glib::Type {
2669 Self::static_type()
2670 }
2671}
2672
2673impl From<MountUnmountFlags> for glib::Value {
2674 #[inline]
2675 fn from(v: MountUnmountFlags) -> Self {
2676 ToValue::to_value(&v)
2677 }
2678}
2679
2680bitflags! {
2681 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2683 #[doc(alias = "GOutputStreamSpliceFlags")]
2684 pub struct OutputStreamSpliceFlags: u32 {
2685 #[doc(alias = "G_OUTPUT_STREAM_SPLICE_NONE")]
2687 const NONE = ffi::G_OUTPUT_STREAM_SPLICE_NONE as _;
2688 #[doc(alias = "G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE")]
2691 const CLOSE_SOURCE = ffi::G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE as _;
2692 #[doc(alias = "G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET")]
2695 const CLOSE_TARGET = ffi::G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET as _;
2696 }
2697}
2698
2699#[doc(hidden)]
2700impl IntoGlib for OutputStreamSpliceFlags {
2701 type GlibType = ffi::GOutputStreamSpliceFlags;
2702
2703 #[inline]
2704 fn into_glib(self) -> ffi::GOutputStreamSpliceFlags {
2705 self.bits()
2706 }
2707}
2708
2709#[doc(hidden)]
2710impl FromGlib<ffi::GOutputStreamSpliceFlags> for OutputStreamSpliceFlags {
2711 #[inline]
2712 unsafe fn from_glib(value: ffi::GOutputStreamSpliceFlags) -> Self {
2713 Self::from_bits_truncate(value)
2714 }
2715}
2716
2717impl StaticType for OutputStreamSpliceFlags {
2718 #[inline]
2719 #[doc(alias = "g_output_stream_splice_flags_get_type")]
2720 fn static_type() -> glib::Type {
2721 unsafe { from_glib(ffi::g_output_stream_splice_flags_get_type()) }
2722 }
2723}
2724
2725impl glib::HasParamSpec for OutputStreamSpliceFlags {
2726 type ParamSpec = glib::ParamSpecFlags;
2727 type SetValue = Self;
2728 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2729
2730 fn param_spec_builder() -> Self::BuilderFn {
2731 Self::ParamSpec::builder
2732 }
2733}
2734
2735impl glib::value::ValueType for OutputStreamSpliceFlags {
2736 type Type = Self;
2737}
2738
2739unsafe impl<'a> glib::value::FromValue<'a> for OutputStreamSpliceFlags {
2740 type Checker = glib::value::GenericValueTypeChecker<Self>;
2741
2742 #[inline]
2743 unsafe fn from_value(value: &'a glib::Value) -> Self {
2744 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2745 }
2746}
2747
2748impl ToValue for OutputStreamSpliceFlags {
2749 #[inline]
2750 fn to_value(&self) -> glib::Value {
2751 let mut value = glib::Value::for_value_type::<Self>();
2752 unsafe {
2753 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2754 }
2755 value
2756 }
2757
2758 #[inline]
2759 fn value_type(&self) -> glib::Type {
2760 Self::static_type()
2761 }
2762}
2763
2764impl From<OutputStreamSpliceFlags> for glib::Value {
2765 #[inline]
2766 fn from(v: OutputStreamSpliceFlags) -> Self {
2767 ToValue::to_value(&v)
2768 }
2769}
2770
2771#[cfg(feature = "v2_60")]
2772bitflags! {
2773 #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2775 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2776 #[doc(alias = "GResolverNameLookupFlags")]
2777 pub struct ResolverNameLookupFlags: u32 {
2778 #[doc(alias = "G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT")]
2780 const DEFAULT = ffi::G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT as _;
2781 #[doc(alias = "G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY")]
2783 const IPV4_ONLY = ffi::G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY as _;
2784 #[doc(alias = "G_RESOLVER_NAME_LOOKUP_FLAGS_IPV6_ONLY")]
2786 const IPV6_ONLY = ffi::G_RESOLVER_NAME_LOOKUP_FLAGS_IPV6_ONLY as _;
2787 }
2788}
2789
2790#[cfg(feature = "v2_60")]
2791#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2792#[doc(hidden)]
2793impl IntoGlib for ResolverNameLookupFlags {
2794 type GlibType = ffi::GResolverNameLookupFlags;
2795
2796 #[inline]
2797 fn into_glib(self) -> ffi::GResolverNameLookupFlags {
2798 self.bits()
2799 }
2800}
2801
2802#[cfg(feature = "v2_60")]
2803#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2804#[doc(hidden)]
2805impl FromGlib<ffi::GResolverNameLookupFlags> for ResolverNameLookupFlags {
2806 #[inline]
2807 unsafe fn from_glib(value: ffi::GResolverNameLookupFlags) -> Self {
2808 Self::from_bits_truncate(value)
2809 }
2810}
2811
2812#[cfg(feature = "v2_60")]
2813#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2814impl StaticType for ResolverNameLookupFlags {
2815 #[inline]
2816 #[doc(alias = "g_resolver_name_lookup_flags_get_type")]
2817 fn static_type() -> glib::Type {
2818 unsafe { from_glib(ffi::g_resolver_name_lookup_flags_get_type()) }
2819 }
2820}
2821
2822#[cfg(feature = "v2_60")]
2823#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2824impl glib::HasParamSpec for ResolverNameLookupFlags {
2825 type ParamSpec = glib::ParamSpecFlags;
2826 type SetValue = Self;
2827 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2828
2829 fn param_spec_builder() -> Self::BuilderFn {
2830 Self::ParamSpec::builder
2831 }
2832}
2833
2834#[cfg(feature = "v2_60")]
2835#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2836impl glib::value::ValueType for ResolverNameLookupFlags {
2837 type Type = Self;
2838}
2839
2840#[cfg(feature = "v2_60")]
2841#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2842unsafe impl<'a> glib::value::FromValue<'a> for ResolverNameLookupFlags {
2843 type Checker = glib::value::GenericValueTypeChecker<Self>;
2844
2845 #[inline]
2846 unsafe fn from_value(value: &'a glib::Value) -> Self {
2847 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2848 }
2849}
2850
2851#[cfg(feature = "v2_60")]
2852#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2853impl ToValue for ResolverNameLookupFlags {
2854 #[inline]
2855 fn to_value(&self) -> glib::Value {
2856 let mut value = glib::Value::for_value_type::<Self>();
2857 unsafe {
2858 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2859 }
2860 value
2861 }
2862
2863 #[inline]
2864 fn value_type(&self) -> glib::Type {
2865 Self::static_type()
2866 }
2867}
2868
2869#[cfg(feature = "v2_60")]
2870#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
2871impl From<ResolverNameLookupFlags> for glib::Value {
2872 #[inline]
2873 fn from(v: ResolverNameLookupFlags) -> Self {
2874 ToValue::to_value(&v)
2875 }
2876}
2877
2878bitflags! {
2879 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2882 #[doc(alias = "GResourceFlags")]
2883 pub struct ResourceFlags: u32 {
2884 #[doc(alias = "G_RESOURCE_FLAGS_NONE")]
2886 const NONE = ffi::G_RESOURCE_FLAGS_NONE as _;
2887 #[doc(alias = "G_RESOURCE_FLAGS_COMPRESSED")]
2889 const COMPRESSED = ffi::G_RESOURCE_FLAGS_COMPRESSED as _;
2890 }
2891}
2892
2893#[doc(hidden)]
2894impl IntoGlib for ResourceFlags {
2895 type GlibType = ffi::GResourceFlags;
2896
2897 #[inline]
2898 fn into_glib(self) -> ffi::GResourceFlags {
2899 self.bits()
2900 }
2901}
2902
2903#[doc(hidden)]
2904impl FromGlib<ffi::GResourceFlags> for ResourceFlags {
2905 #[inline]
2906 unsafe fn from_glib(value: ffi::GResourceFlags) -> Self {
2907 Self::from_bits_truncate(value)
2908 }
2909}
2910
2911impl StaticType for ResourceFlags {
2912 #[inline]
2913 #[doc(alias = "g_resource_flags_get_type")]
2914 fn static_type() -> glib::Type {
2915 unsafe { from_glib(ffi::g_resource_flags_get_type()) }
2916 }
2917}
2918
2919impl glib::HasParamSpec for ResourceFlags {
2920 type ParamSpec = glib::ParamSpecFlags;
2921 type SetValue = Self;
2922 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
2923
2924 fn param_spec_builder() -> Self::BuilderFn {
2925 Self::ParamSpec::builder
2926 }
2927}
2928
2929impl glib::value::ValueType for ResourceFlags {
2930 type Type = Self;
2931}
2932
2933unsafe impl<'a> glib::value::FromValue<'a> for ResourceFlags {
2934 type Checker = glib::value::GenericValueTypeChecker<Self>;
2935
2936 #[inline]
2937 unsafe fn from_value(value: &'a glib::Value) -> Self {
2938 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
2939 }
2940}
2941
2942impl ToValue for ResourceFlags {
2943 #[inline]
2944 fn to_value(&self) -> glib::Value {
2945 let mut value = glib::Value::for_value_type::<Self>();
2946 unsafe {
2947 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
2948 }
2949 value
2950 }
2951
2952 #[inline]
2953 fn value_type(&self) -> glib::Type {
2954 Self::static_type()
2955 }
2956}
2957
2958impl From<ResourceFlags> for glib::Value {
2959 #[inline]
2960 fn from(v: ResourceFlags) -> Self {
2961 ToValue::to_value(&v)
2962 }
2963}
2964
2965bitflags! {
2966 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
2968 #[doc(alias = "GResourceLookupFlags")]
2969 pub struct ResourceLookupFlags: u32 {
2970 #[doc(alias = "G_RESOURCE_LOOKUP_FLAGS_NONE")]
2972 const NONE = ffi::G_RESOURCE_LOOKUP_FLAGS_NONE as _;
2973 }
2974}
2975
2976#[doc(hidden)]
2977impl IntoGlib for ResourceLookupFlags {
2978 type GlibType = ffi::GResourceLookupFlags;
2979
2980 #[inline]
2981 fn into_glib(self) -> ffi::GResourceLookupFlags {
2982 self.bits()
2983 }
2984}
2985
2986#[doc(hidden)]
2987impl FromGlib<ffi::GResourceLookupFlags> for ResourceLookupFlags {
2988 #[inline]
2989 unsafe fn from_glib(value: ffi::GResourceLookupFlags) -> Self {
2990 Self::from_bits_truncate(value)
2991 }
2992}
2993
2994impl StaticType for ResourceLookupFlags {
2995 #[inline]
2996 #[doc(alias = "g_resource_lookup_flags_get_type")]
2997 fn static_type() -> glib::Type {
2998 unsafe { from_glib(ffi::g_resource_lookup_flags_get_type()) }
2999 }
3000}
3001
3002impl glib::HasParamSpec for ResourceLookupFlags {
3003 type ParamSpec = glib::ParamSpecFlags;
3004 type SetValue = Self;
3005 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3006
3007 fn param_spec_builder() -> Self::BuilderFn {
3008 Self::ParamSpec::builder
3009 }
3010}
3011
3012impl glib::value::ValueType for ResourceLookupFlags {
3013 type Type = Self;
3014}
3015
3016unsafe impl<'a> glib::value::FromValue<'a> for ResourceLookupFlags {
3017 type Checker = glib::value::GenericValueTypeChecker<Self>;
3018
3019 #[inline]
3020 unsafe fn from_value(value: &'a glib::Value) -> Self {
3021 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3022 }
3023}
3024
3025impl ToValue for ResourceLookupFlags {
3026 #[inline]
3027 fn to_value(&self) -> glib::Value {
3028 let mut value = glib::Value::for_value_type::<Self>();
3029 unsafe {
3030 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3031 }
3032 value
3033 }
3034
3035 #[inline]
3036 fn value_type(&self) -> glib::Type {
3037 Self::static_type()
3038 }
3039}
3040
3041impl From<ResourceLookupFlags> for glib::Value {
3042 #[inline]
3043 fn from(v: ResourceLookupFlags) -> Self {
3044 ToValue::to_value(&v)
3045 }
3046}
3047
3048bitflags! {
3049 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3053 #[doc(alias = "GSettingsBindFlags")]
3054 pub struct SettingsBindFlags: u32 {
3055 #[doc(alias = "G_SETTINGS_BIND_DEFAULT")]
3057 const DEFAULT = ffi::G_SETTINGS_BIND_DEFAULT as _;
3058 #[doc(alias = "G_SETTINGS_BIND_GET")]
3061 const GET = ffi::G_SETTINGS_BIND_GET as _;
3062 #[doc(alias = "G_SETTINGS_BIND_SET")]
3065 const SET = ffi::G_SETTINGS_BIND_SET as _;
3066 #[doc(alias = "G_SETTINGS_BIND_NO_SENSITIVITY")]
3068 const NO_SENSITIVITY = ffi::G_SETTINGS_BIND_NO_SENSITIVITY as _;
3069 #[doc(alias = "G_SETTINGS_BIND_GET_NO_CHANGES")]
3072 const GET_NO_CHANGES = ffi::G_SETTINGS_BIND_GET_NO_CHANGES as _;
3073 #[doc(alias = "G_SETTINGS_BIND_INVERT_BOOLEAN")]
3077 const INVERT_BOOLEAN = ffi::G_SETTINGS_BIND_INVERT_BOOLEAN as _;
3078 }
3079}
3080
3081#[doc(hidden)]
3082impl IntoGlib for SettingsBindFlags {
3083 type GlibType = ffi::GSettingsBindFlags;
3084
3085 #[inline]
3086 fn into_glib(self) -> ffi::GSettingsBindFlags {
3087 self.bits()
3088 }
3089}
3090
3091#[doc(hidden)]
3092impl FromGlib<ffi::GSettingsBindFlags> for SettingsBindFlags {
3093 #[inline]
3094 unsafe fn from_glib(value: ffi::GSettingsBindFlags) -> Self {
3095 Self::from_bits_truncate(value)
3096 }
3097}
3098
3099impl StaticType for SettingsBindFlags {
3100 #[inline]
3101 #[doc(alias = "g_settings_bind_flags_get_type")]
3102 fn static_type() -> glib::Type {
3103 unsafe { from_glib(ffi::g_settings_bind_flags_get_type()) }
3104 }
3105}
3106
3107impl glib::HasParamSpec for SettingsBindFlags {
3108 type ParamSpec = glib::ParamSpecFlags;
3109 type SetValue = Self;
3110 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3111
3112 fn param_spec_builder() -> Self::BuilderFn {
3113 Self::ParamSpec::builder
3114 }
3115}
3116
3117impl glib::value::ValueType for SettingsBindFlags {
3118 type Type = Self;
3119}
3120
3121unsafe impl<'a> glib::value::FromValue<'a> for SettingsBindFlags {
3122 type Checker = glib::value::GenericValueTypeChecker<Self>;
3123
3124 #[inline]
3125 unsafe fn from_value(value: &'a glib::Value) -> Self {
3126 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3127 }
3128}
3129
3130impl ToValue for SettingsBindFlags {
3131 #[inline]
3132 fn to_value(&self) -> glib::Value {
3133 let mut value = glib::Value::for_value_type::<Self>();
3134 unsafe {
3135 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3136 }
3137 value
3138 }
3139
3140 #[inline]
3141 fn value_type(&self) -> glib::Type {
3142 Self::static_type()
3143 }
3144}
3145
3146impl From<SettingsBindFlags> for glib::Value {
3147 #[inline]
3148 fn from(v: SettingsBindFlags) -> Self {
3149 ToValue::to_value(&v)
3150 }
3151}
3152
3153bitflags! {
3154 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3164 #[doc(alias = "GSubprocessFlags")]
3165 pub struct SubprocessFlags: u32 {
3166 #[doc(alias = "G_SUBPROCESS_FLAGS_NONE")]
3168 const NONE = ffi::G_SUBPROCESS_FLAGS_NONE as _;
3169 #[doc(alias = "G_SUBPROCESS_FLAGS_STDIN_PIPE")]
3173 const STDIN_PIPE = ffi::G_SUBPROCESS_FLAGS_STDIN_PIPE as _;
3174 #[doc(alias = "G_SUBPROCESS_FLAGS_STDIN_INHERIT")]
3177 const STDIN_INHERIT = ffi::G_SUBPROCESS_FLAGS_STDIN_INHERIT as _;
3178 #[doc(alias = "G_SUBPROCESS_FLAGS_STDOUT_PIPE")]
3182 const STDOUT_PIPE = ffi::G_SUBPROCESS_FLAGS_STDOUT_PIPE as _;
3183 #[doc(alias = "G_SUBPROCESS_FLAGS_STDOUT_SILENCE")]
3186 const STDOUT_SILENCE = ffi::G_SUBPROCESS_FLAGS_STDOUT_SILENCE as _;
3187 #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_PIPE")]
3191 const STDERR_PIPE = ffi::G_SUBPROCESS_FLAGS_STDERR_PIPE as _;
3192 #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_SILENCE")]
3195 const STDERR_SILENCE = ffi::G_SUBPROCESS_FLAGS_STDERR_SILENCE as _;
3196 #[doc(alias = "G_SUBPROCESS_FLAGS_STDERR_MERGE")]
3200 const STDERR_MERGE = ffi::G_SUBPROCESS_FLAGS_STDERR_MERGE as _;
3201 #[doc(alias = "G_SUBPROCESS_FLAGS_INHERIT_FDS")]
3206 const INHERIT_FDS = ffi::G_SUBPROCESS_FLAGS_INHERIT_FDS as _;
3207 #[cfg(feature = "v2_72")]
3211 #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
3212 #[doc(alias = "G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP")]
3213 const SEARCH_PATH_FROM_ENVP = ffi::G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP as _;
3214 }
3215}
3216
3217#[doc(hidden)]
3218impl IntoGlib for SubprocessFlags {
3219 type GlibType = ffi::GSubprocessFlags;
3220
3221 #[inline]
3222 fn into_glib(self) -> ffi::GSubprocessFlags {
3223 self.bits()
3224 }
3225}
3226
3227#[doc(hidden)]
3228impl FromGlib<ffi::GSubprocessFlags> for SubprocessFlags {
3229 #[inline]
3230 unsafe fn from_glib(value: ffi::GSubprocessFlags) -> Self {
3231 Self::from_bits_truncate(value)
3232 }
3233}
3234
3235impl StaticType for SubprocessFlags {
3236 #[inline]
3237 #[doc(alias = "g_subprocess_flags_get_type")]
3238 fn static_type() -> glib::Type {
3239 unsafe { from_glib(ffi::g_subprocess_flags_get_type()) }
3240 }
3241}
3242
3243impl glib::HasParamSpec for SubprocessFlags {
3244 type ParamSpec = glib::ParamSpecFlags;
3245 type SetValue = Self;
3246 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3247
3248 fn param_spec_builder() -> Self::BuilderFn {
3249 Self::ParamSpec::builder
3250 }
3251}
3252
3253impl glib::value::ValueType for SubprocessFlags {
3254 type Type = Self;
3255}
3256
3257unsafe impl<'a> glib::value::FromValue<'a> for SubprocessFlags {
3258 type Checker = glib::value::GenericValueTypeChecker<Self>;
3259
3260 #[inline]
3261 unsafe fn from_value(value: &'a glib::Value) -> Self {
3262 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3263 }
3264}
3265
3266impl ToValue for SubprocessFlags {
3267 #[inline]
3268 fn to_value(&self) -> glib::Value {
3269 let mut value = glib::Value::for_value_type::<Self>();
3270 unsafe {
3271 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3272 }
3273 value
3274 }
3275
3276 #[inline]
3277 fn value_type(&self) -> glib::Type {
3278 Self::static_type()
3279 }
3280}
3281
3282impl From<SubprocessFlags> for glib::Value {
3283 #[inline]
3284 fn from(v: SubprocessFlags) -> Self {
3285 ToValue::to_value(&v)
3286 }
3287}
3288
3289bitflags! {
3290 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3292 #[doc(alias = "GTestDBusFlags")]
3293 pub struct TestDBusFlags: u32 {
3294 #[doc(alias = "G_TEST_DBUS_NONE")]
3296 const NONE = ffi::G_TEST_DBUS_NONE as _;
3297 }
3298}
3299
3300#[doc(hidden)]
3301impl IntoGlib for TestDBusFlags {
3302 type GlibType = ffi::GTestDBusFlags;
3303
3304 #[inline]
3305 fn into_glib(self) -> ffi::GTestDBusFlags {
3306 self.bits()
3307 }
3308}
3309
3310#[doc(hidden)]
3311impl FromGlib<ffi::GTestDBusFlags> for TestDBusFlags {
3312 #[inline]
3313 unsafe fn from_glib(value: ffi::GTestDBusFlags) -> Self {
3314 Self::from_bits_truncate(value)
3315 }
3316}
3317
3318impl StaticType for TestDBusFlags {
3319 #[inline]
3320 #[doc(alias = "g_test_dbus_flags_get_type")]
3321 fn static_type() -> glib::Type {
3322 unsafe { from_glib(ffi::g_test_dbus_flags_get_type()) }
3323 }
3324}
3325
3326impl glib::HasParamSpec for TestDBusFlags {
3327 type ParamSpec = glib::ParamSpecFlags;
3328 type SetValue = Self;
3329 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3330
3331 fn param_spec_builder() -> Self::BuilderFn {
3332 Self::ParamSpec::builder
3333 }
3334}
3335
3336impl glib::value::ValueType for TestDBusFlags {
3337 type Type = Self;
3338}
3339
3340unsafe impl<'a> glib::value::FromValue<'a> for TestDBusFlags {
3341 type Checker = glib::value::GenericValueTypeChecker<Self>;
3342
3343 #[inline]
3344 unsafe fn from_value(value: &'a glib::Value) -> Self {
3345 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3346 }
3347}
3348
3349impl ToValue for TestDBusFlags {
3350 #[inline]
3351 fn to_value(&self) -> glib::Value {
3352 let mut value = glib::Value::for_value_type::<Self>();
3353 unsafe {
3354 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3355 }
3356 value
3357 }
3358
3359 #[inline]
3360 fn value_type(&self) -> glib::Type {
3361 Self::static_type()
3362 }
3363}
3364
3365impl From<TestDBusFlags> for glib::Value {
3366 #[inline]
3367 fn from(v: TestDBusFlags) -> Self {
3368 ToValue::to_value(&v)
3369 }
3370}
3371
3372bitflags! {
3373 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3385 #[doc(alias = "GTlsCertificateFlags")]
3386 pub struct TlsCertificateFlags: u32 {
3387 #[doc(alias = "G_TLS_CERTIFICATE_UNKNOWN_CA")]
3390 const UNKNOWN_CA = ffi::G_TLS_CERTIFICATE_UNKNOWN_CA as _;
3391 #[doc(alias = "G_TLS_CERTIFICATE_BAD_IDENTITY")]
3394 const BAD_IDENTITY = ffi::G_TLS_CERTIFICATE_BAD_IDENTITY as _;
3395 #[doc(alias = "G_TLS_CERTIFICATE_NOT_ACTIVATED")]
3398 const NOT_ACTIVATED = ffi::G_TLS_CERTIFICATE_NOT_ACTIVATED as _;
3399 #[doc(alias = "G_TLS_CERTIFICATE_EXPIRED")]
3401 const EXPIRED = ffi::G_TLS_CERTIFICATE_EXPIRED as _;
3402 #[doc(alias = "G_TLS_CERTIFICATE_REVOKED")]
3405 const REVOKED = ffi::G_TLS_CERTIFICATE_REVOKED as _;
3406 #[doc(alias = "G_TLS_CERTIFICATE_INSECURE")]
3409 const INSECURE = ffi::G_TLS_CERTIFICATE_INSECURE as _;
3410 #[doc(alias = "G_TLS_CERTIFICATE_GENERIC_ERROR")]
3413 const GENERIC_ERROR = ffi::G_TLS_CERTIFICATE_GENERIC_ERROR as _;
3414 #[doc(alias = "G_TLS_CERTIFICATE_VALIDATE_ALL")]
3417 const VALIDATE_ALL = ffi::G_TLS_CERTIFICATE_VALIDATE_ALL as _;
3418 }
3419}
3420
3421#[doc(hidden)]
3422impl IntoGlib for TlsCertificateFlags {
3423 type GlibType = ffi::GTlsCertificateFlags;
3424
3425 #[inline]
3426 fn into_glib(self) -> ffi::GTlsCertificateFlags {
3427 self.bits()
3428 }
3429}
3430
3431#[doc(hidden)]
3432impl FromGlib<ffi::GTlsCertificateFlags> for TlsCertificateFlags {
3433 #[inline]
3434 unsafe fn from_glib(value: ffi::GTlsCertificateFlags) -> Self {
3435 Self::from_bits_truncate(value)
3436 }
3437}
3438
3439impl StaticType for TlsCertificateFlags {
3440 #[inline]
3441 #[doc(alias = "g_tls_certificate_flags_get_type")]
3442 fn static_type() -> glib::Type {
3443 unsafe { from_glib(ffi::g_tls_certificate_flags_get_type()) }
3444 }
3445}
3446
3447impl glib::HasParamSpec for TlsCertificateFlags {
3448 type ParamSpec = glib::ParamSpecFlags;
3449 type SetValue = Self;
3450 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3451
3452 fn param_spec_builder() -> Self::BuilderFn {
3453 Self::ParamSpec::builder
3454 }
3455}
3456
3457impl glib::value::ValueType for TlsCertificateFlags {
3458 type Type = Self;
3459}
3460
3461unsafe impl<'a> glib::value::FromValue<'a> for TlsCertificateFlags {
3462 type Checker = glib::value::GenericValueTypeChecker<Self>;
3463
3464 #[inline]
3465 unsafe fn from_value(value: &'a glib::Value) -> Self {
3466 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3467 }
3468}
3469
3470impl ToValue for TlsCertificateFlags {
3471 #[inline]
3472 fn to_value(&self) -> glib::Value {
3473 let mut value = glib::Value::for_value_type::<Self>();
3474 unsafe {
3475 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3476 }
3477 value
3478 }
3479
3480 #[inline]
3481 fn value_type(&self) -> glib::Type {
3482 Self::static_type()
3483 }
3484}
3485
3486impl From<TlsCertificateFlags> for glib::Value {
3487 #[inline]
3488 fn from(v: TlsCertificateFlags) -> Self {
3489 ToValue::to_value(&v)
3490 }
3491}
3492
3493bitflags! {
3494 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3496 #[doc(alias = "GTlsDatabaseVerifyFlags")]
3497 pub struct TlsDatabaseVerifyFlags: u32 {
3498 #[doc(alias = "G_TLS_DATABASE_VERIFY_NONE")]
3500 const NONE = ffi::G_TLS_DATABASE_VERIFY_NONE as _;
3501 }
3502}
3503
3504#[doc(hidden)]
3505impl IntoGlib for TlsDatabaseVerifyFlags {
3506 type GlibType = ffi::GTlsDatabaseVerifyFlags;
3507
3508 #[inline]
3509 fn into_glib(self) -> ffi::GTlsDatabaseVerifyFlags {
3510 self.bits()
3511 }
3512}
3513
3514#[doc(hidden)]
3515impl FromGlib<ffi::GTlsDatabaseVerifyFlags> for TlsDatabaseVerifyFlags {
3516 #[inline]
3517 unsafe fn from_glib(value: ffi::GTlsDatabaseVerifyFlags) -> Self {
3518 Self::from_bits_truncate(value)
3519 }
3520}
3521
3522impl StaticType for TlsDatabaseVerifyFlags {
3523 #[inline]
3524 #[doc(alias = "g_tls_database_verify_flags_get_type")]
3525 fn static_type() -> glib::Type {
3526 unsafe { from_glib(ffi::g_tls_database_verify_flags_get_type()) }
3527 }
3528}
3529
3530impl glib::HasParamSpec for TlsDatabaseVerifyFlags {
3531 type ParamSpec = glib::ParamSpecFlags;
3532 type SetValue = Self;
3533 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3534
3535 fn param_spec_builder() -> Self::BuilderFn {
3536 Self::ParamSpec::builder
3537 }
3538}
3539
3540impl glib::value::ValueType for TlsDatabaseVerifyFlags {
3541 type Type = Self;
3542}
3543
3544unsafe impl<'a> glib::value::FromValue<'a> for TlsDatabaseVerifyFlags {
3545 type Checker = glib::value::GenericValueTypeChecker<Self>;
3546
3547 #[inline]
3548 unsafe fn from_value(value: &'a glib::Value) -> Self {
3549 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3550 }
3551}
3552
3553impl ToValue for TlsDatabaseVerifyFlags {
3554 #[inline]
3555 fn to_value(&self) -> glib::Value {
3556 let mut value = glib::Value::for_value_type::<Self>();
3557 unsafe {
3558 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3559 }
3560 value
3561 }
3562
3563 #[inline]
3564 fn value_type(&self) -> glib::Type {
3565 Self::static_type()
3566 }
3567}
3568
3569impl From<TlsDatabaseVerifyFlags> for glib::Value {
3570 #[inline]
3571 fn from(v: TlsDatabaseVerifyFlags) -> Self {
3572 ToValue::to_value(&v)
3573 }
3574}
3575
3576bitflags! {
3577 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
3579 #[doc(alias = "GTlsPasswordFlags")]
3580 pub struct TlsPasswordFlags: u32 {
3581 #[doc(alias = "G_TLS_PASSWORD_NONE")]
3583 const NONE = ffi::G_TLS_PASSWORD_NONE as _;
3584 #[doc(alias = "G_TLS_PASSWORD_RETRY")]
3586 const RETRY = ffi::G_TLS_PASSWORD_RETRY as _;
3587 #[doc(alias = "G_TLS_PASSWORD_MANY_TRIES")]
3590 const MANY_TRIES = ffi::G_TLS_PASSWORD_MANY_TRIES as _;
3591 #[doc(alias = "G_TLS_PASSWORD_FINAL_TRY")]
3594 const FINAL_TRY = ffi::G_TLS_PASSWORD_FINAL_TRY as _;
3595 #[doc(alias = "G_TLS_PASSWORD_PKCS11_USER")]
3598 const PKCS11_USER = ffi::G_TLS_PASSWORD_PKCS11_USER as _;
3599 #[doc(alias = "G_TLS_PASSWORD_PKCS11_SECURITY_OFFICER")]
3602 const PKCS11_SECURITY_OFFICER = ffi::G_TLS_PASSWORD_PKCS11_SECURITY_OFFICER as _;
3603 #[doc(alias = "G_TLS_PASSWORD_PKCS11_CONTEXT_SPECIFIC")]
3606 const PKCS11_CONTEXT_SPECIFIC = ffi::G_TLS_PASSWORD_PKCS11_CONTEXT_SPECIFIC as _;
3607 }
3608}
3609
3610#[doc(hidden)]
3611impl IntoGlib for TlsPasswordFlags {
3612 type GlibType = ffi::GTlsPasswordFlags;
3613
3614 #[inline]
3615 fn into_glib(self) -> ffi::GTlsPasswordFlags {
3616 self.bits()
3617 }
3618}
3619
3620#[doc(hidden)]
3621impl FromGlib<ffi::GTlsPasswordFlags> for TlsPasswordFlags {
3622 #[inline]
3623 unsafe fn from_glib(value: ffi::GTlsPasswordFlags) -> Self {
3624 Self::from_bits_truncate(value)
3625 }
3626}
3627
3628impl StaticType for TlsPasswordFlags {
3629 #[inline]
3630 #[doc(alias = "g_tls_password_flags_get_type")]
3631 fn static_type() -> glib::Type {
3632 unsafe { from_glib(ffi::g_tls_password_flags_get_type()) }
3633 }
3634}
3635
3636impl glib::HasParamSpec for TlsPasswordFlags {
3637 type ParamSpec = glib::ParamSpecFlags;
3638 type SetValue = Self;
3639 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
3640
3641 fn param_spec_builder() -> Self::BuilderFn {
3642 Self::ParamSpec::builder
3643 }
3644}
3645
3646impl glib::value::ValueType for TlsPasswordFlags {
3647 type Type = Self;
3648}
3649
3650unsafe impl<'a> glib::value::FromValue<'a> for TlsPasswordFlags {
3651 type Checker = glib::value::GenericValueTypeChecker<Self>;
3652
3653 #[inline]
3654 unsafe fn from_value(value: &'a glib::Value) -> Self {
3655 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
3656 }
3657}
3658
3659impl ToValue for TlsPasswordFlags {
3660 #[inline]
3661 fn to_value(&self) -> glib::Value {
3662 let mut value = glib::Value::for_value_type::<Self>();
3663 unsafe {
3664 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
3665 }
3666 value
3667 }
3668
3669 #[inline]
3670 fn value_type(&self) -> glib::Type {
3671 Self::static_type()
3672 }
3673}
3674
3675impl From<TlsPasswordFlags> for glib::Value {
3676 #[inline]
3677 fn from(v: TlsPasswordFlags) -> Self {
3678 ToValue::to_value(&v)
3679 }
3680}