1use crate::ffi;
7use glib::{bitflags::bitflags, prelude::*, translate::*};
8
9bitflags! {
10 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
12 #[doc(alias = "WebKitEditorTypingAttributes")]
13 pub struct EditorTypingAttributes: u32 {
14 #[doc(alias = "WEBKIT_EDITOR_TYPING_ATTRIBUTE_NONE")]
16 const NONE = ffi::WEBKIT_EDITOR_TYPING_ATTRIBUTE_NONE as _;
17 #[doc(alias = "WEBKIT_EDITOR_TYPING_ATTRIBUTE_BOLD")]
19 const BOLD = ffi::WEBKIT_EDITOR_TYPING_ATTRIBUTE_BOLD as _;
20 #[doc(alias = "WEBKIT_EDITOR_TYPING_ATTRIBUTE_ITALIC")]
22 const ITALIC = ffi::WEBKIT_EDITOR_TYPING_ATTRIBUTE_ITALIC as _;
23 #[doc(alias = "WEBKIT_EDITOR_TYPING_ATTRIBUTE_UNDERLINE")]
25 const UNDERLINE = ffi::WEBKIT_EDITOR_TYPING_ATTRIBUTE_UNDERLINE as _;
26 #[doc(alias = "WEBKIT_EDITOR_TYPING_ATTRIBUTE_STRIKETHROUGH")]
28 const STRIKETHROUGH = ffi::WEBKIT_EDITOR_TYPING_ATTRIBUTE_STRIKETHROUGH as _;
29 }
30}
31
32#[doc(hidden)]
33impl IntoGlib for EditorTypingAttributes {
34 type GlibType = ffi::WebKitEditorTypingAttributes;
35
36 #[inline]
37 fn into_glib(self) -> ffi::WebKitEditorTypingAttributes {
38 self.bits()
39 }
40}
41
42#[doc(hidden)]
43impl FromGlib<ffi::WebKitEditorTypingAttributes> for EditorTypingAttributes {
44 #[inline]
45 unsafe fn from_glib(value: ffi::WebKitEditorTypingAttributes) -> Self {
46 skip_assert_initialized!();
47 Self::from_bits_truncate(value)
48 }
49}
50
51impl StaticType for EditorTypingAttributes {
52 #[inline]
53 #[doc(alias = "webkit_editor_typing_attributes_get_type")]
54 fn static_type() -> glib::Type {
55 unsafe { from_glib(ffi::webkit_editor_typing_attributes_get_type()) }
56 }
57}
58
59impl glib::HasParamSpec for EditorTypingAttributes {
60 type ParamSpec = glib::ParamSpecFlags;
61 type SetValue = Self;
62 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
63
64 fn param_spec_builder() -> Self::BuilderFn {
65 Self::ParamSpec::builder
66 }
67}
68
69impl glib::value::ValueType for EditorTypingAttributes {
70 type Type = Self;
71}
72
73unsafe impl<'a> glib::value::FromValue<'a> for EditorTypingAttributes {
74 type Checker = glib::value::GenericValueTypeChecker<Self>;
75
76 #[inline]
77 unsafe fn from_value(value: &'a glib::Value) -> Self {
78 skip_assert_initialized!();
79 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
80 }
81}
82
83impl ToValue for EditorTypingAttributes {
84 #[inline]
85 fn to_value(&self) -> glib::Value {
86 let mut value = glib::Value::for_value_type::<Self>();
87 unsafe {
88 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
89 }
90 value
91 }
92
93 #[inline]
94 fn value_type(&self) -> glib::Type {
95 Self::static_type()
96 }
97}
98
99impl From<EditorTypingAttributes> for glib::Value {
100 #[inline]
101 fn from(v: EditorTypingAttributes) -> Self {
102 skip_assert_initialized!();
103 ToValue::to_value(&v)
104 }
105}
106
107bitflags! {
108 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
110 #[doc(alias = "WebKitFindOptions")]
111 pub struct FindOptions: u32 {
112 #[doc(alias = "WEBKIT_FIND_OPTIONS_NONE")]
115 const NONE = ffi::WEBKIT_FIND_OPTIONS_NONE as _;
116 #[doc(alias = "WEBKIT_FIND_OPTIONS_CASE_INSENSITIVE")]
118 const CASE_INSENSITIVE = ffi::WEBKIT_FIND_OPTIONS_CASE_INSENSITIVE as _;
119 #[doc(alias = "WEBKIT_FIND_OPTIONS_AT_WORD_STARTS")]
122 const AT_WORD_STARTS = ffi::WEBKIT_FIND_OPTIONS_AT_WORD_STARTS as _;
123 #[doc(alias = "WEBKIT_FIND_OPTIONS_TREAT_MEDIAL_CAPITAL_AS_WORD_START")]
126 const TREAT_MEDIAL_CAPITAL_AS_WORD_START = ffi::WEBKIT_FIND_OPTIONS_TREAT_MEDIAL_CAPITAL_AS_WORD_START as _;
127 #[doc(alias = "WEBKIT_FIND_OPTIONS_BACKWARDS")]
129 const BACKWARDS = ffi::WEBKIT_FIND_OPTIONS_BACKWARDS as _;
130 #[doc(alias = "WEBKIT_FIND_OPTIONS_WRAP_AROUND")]
133 const WRAP_AROUND = ffi::WEBKIT_FIND_OPTIONS_WRAP_AROUND as _;
134 }
135}
136
137#[doc(hidden)]
138impl IntoGlib for FindOptions {
139 type GlibType = ffi::WebKitFindOptions;
140
141 #[inline]
142 fn into_glib(self) -> ffi::WebKitFindOptions {
143 self.bits()
144 }
145}
146
147#[doc(hidden)]
148impl FromGlib<ffi::WebKitFindOptions> for FindOptions {
149 #[inline]
150 unsafe fn from_glib(value: ffi::WebKitFindOptions) -> Self {
151 skip_assert_initialized!();
152 Self::from_bits_truncate(value)
153 }
154}
155
156impl StaticType for FindOptions {
157 #[inline]
158 #[doc(alias = "webkit_find_options_get_type")]
159 fn static_type() -> glib::Type {
160 unsafe { from_glib(ffi::webkit_find_options_get_type()) }
161 }
162}
163
164impl glib::HasParamSpec for FindOptions {
165 type ParamSpec = glib::ParamSpecFlags;
166 type SetValue = Self;
167 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
168
169 fn param_spec_builder() -> Self::BuilderFn {
170 Self::ParamSpec::builder
171 }
172}
173
174impl glib::value::ValueType for FindOptions {
175 type Type = Self;
176}
177
178unsafe impl<'a> glib::value::FromValue<'a> for FindOptions {
179 type Checker = glib::value::GenericValueTypeChecker<Self>;
180
181 #[inline]
182 unsafe fn from_value(value: &'a glib::Value) -> Self {
183 skip_assert_initialized!();
184 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
185 }
186}
187
188impl ToValue for FindOptions {
189 #[inline]
190 fn to_value(&self) -> glib::Value {
191 let mut value = glib::Value::for_value_type::<Self>();
192 unsafe {
193 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
194 }
195 value
196 }
197
198 #[inline]
199 fn value_type(&self) -> glib::Type {
200 Self::static_type()
201 }
202}
203
204impl From<FindOptions> for glib::Value {
205 #[inline]
206 fn from(v: FindOptions) -> Self {
207 skip_assert_initialized!();
208 ToValue::to_value(&v)
209 }
210}
211
212bitflags! {
213 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
215 #[doc(alias = "WebKitHitTestResultContext")]
216 pub struct HitTestResultContext: u32 {
217 #[doc(alias = "WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT")]
219 const DOCUMENT = ffi::WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT as _;
220 #[doc(alias = "WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK")]
222 const LINK = ffi::WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK as _;
223 #[doc(alias = "WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE")]
225 const IMAGE = ffi::WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE as _;
226 #[doc(alias = "WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA")]
228 const MEDIA = ffi::WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA as _;
229 #[doc(alias = "WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE")]
231 const EDITABLE = ffi::WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE as _;
232 #[doc(alias = "WEBKIT_HIT_TEST_RESULT_CONTEXT_SCROLLBAR")]
234 const SCROLLBAR = ffi::WEBKIT_HIT_TEST_RESULT_CONTEXT_SCROLLBAR as _;
235 #[doc(alias = "WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION")]
237 const SELECTION = ffi::WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION as _;
238 }
239}
240
241#[doc(hidden)]
242impl IntoGlib for HitTestResultContext {
243 type GlibType = ffi::WebKitHitTestResultContext;
244
245 #[inline]
246 fn into_glib(self) -> ffi::WebKitHitTestResultContext {
247 self.bits()
248 }
249}
250
251#[doc(hidden)]
252impl FromGlib<ffi::WebKitHitTestResultContext> for HitTestResultContext {
253 #[inline]
254 unsafe fn from_glib(value: ffi::WebKitHitTestResultContext) -> Self {
255 skip_assert_initialized!();
256 Self::from_bits_truncate(value)
257 }
258}
259
260impl StaticType for HitTestResultContext {
261 #[inline]
262 #[doc(alias = "webkit_hit_test_result_context_get_type")]
263 fn static_type() -> glib::Type {
264 unsafe { from_glib(ffi::webkit_hit_test_result_context_get_type()) }
265 }
266}
267
268impl glib::HasParamSpec for HitTestResultContext {
269 type ParamSpec = glib::ParamSpecFlags;
270 type SetValue = Self;
271 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
272
273 fn param_spec_builder() -> Self::BuilderFn {
274 Self::ParamSpec::builder
275 }
276}
277
278impl glib::value::ValueType for HitTestResultContext {
279 type Type = Self;
280}
281
282unsafe impl<'a> glib::value::FromValue<'a> for HitTestResultContext {
283 type Checker = glib::value::GenericValueTypeChecker<Self>;
284
285 #[inline]
286 unsafe fn from_value(value: &'a glib::Value) -> Self {
287 skip_assert_initialized!();
288 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
289 }
290}
291
292impl ToValue for HitTestResultContext {
293 #[inline]
294 fn to_value(&self) -> glib::Value {
295 let mut value = glib::Value::for_value_type::<Self>();
296 unsafe {
297 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
298 }
299 value
300 }
301
302 #[inline]
303 fn value_type(&self) -> glib::Type {
304 Self::static_type()
305 }
306}
307
308impl From<HitTestResultContext> for glib::Value {
309 #[inline]
310 fn from(v: HitTestResultContext) -> Self {
311 skip_assert_initialized!();
312 ToValue::to_value(&v)
313 }
314}
315
316bitflags! {
317 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
319 #[doc(alias = "WebKitInputHints")]
320 pub struct InputHints: u32 {
321 #[doc(alias = "WEBKIT_INPUT_HINT_NONE")]
323 const NONE = ffi::WEBKIT_INPUT_HINT_NONE as _;
324 #[doc(alias = "WEBKIT_INPUT_HINT_SPELLCHECK")]
326 const SPELLCHECK = ffi::WEBKIT_INPUT_HINT_SPELLCHECK as _;
327 #[doc(alias = "WEBKIT_INPUT_HINT_LOWERCASE")]
329 const LOWERCASE = ffi::WEBKIT_INPUT_HINT_LOWERCASE as _;
330 #[doc(alias = "WEBKIT_INPUT_HINT_UPPERCASE_CHARS")]
332 const UPPERCASE_CHARS = ffi::WEBKIT_INPUT_HINT_UPPERCASE_CHARS as _;
333 #[doc(alias = "WEBKIT_INPUT_HINT_UPPERCASE_WORDS")]
335 const UPPERCASE_WORDS = ffi::WEBKIT_INPUT_HINT_UPPERCASE_WORDS as _;
336 #[doc(alias = "WEBKIT_INPUT_HINT_UPPERCASE_SENTENCES")]
338 const UPPERCASE_SENTENCES = ffi::WEBKIT_INPUT_HINT_UPPERCASE_SENTENCES as _;
339 #[doc(alias = "WEBKIT_INPUT_HINT_INHIBIT_OSK")]
341 const INHIBIT_OSK = ffi::WEBKIT_INPUT_HINT_INHIBIT_OSK as _;
342 }
343}
344
345#[doc(hidden)]
346impl IntoGlib for InputHints {
347 type GlibType = ffi::WebKitInputHints;
348
349 #[inline]
350 fn into_glib(self) -> ffi::WebKitInputHints {
351 self.bits()
352 }
353}
354
355#[doc(hidden)]
356impl FromGlib<ffi::WebKitInputHints> for InputHints {
357 #[inline]
358 unsafe fn from_glib(value: ffi::WebKitInputHints) -> Self {
359 skip_assert_initialized!();
360 Self::from_bits_truncate(value)
361 }
362}
363
364impl StaticType for InputHints {
365 #[inline]
366 #[doc(alias = "webkit_input_hints_get_type")]
367 fn static_type() -> glib::Type {
368 unsafe { from_glib(ffi::webkit_input_hints_get_type()) }
369 }
370}
371
372impl glib::HasParamSpec for InputHints {
373 type ParamSpec = glib::ParamSpecFlags;
374 type SetValue = Self;
375 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
376
377 fn param_spec_builder() -> Self::BuilderFn {
378 Self::ParamSpec::builder
379 }
380}
381
382impl glib::value::ValueType for InputHints {
383 type Type = Self;
384}
385
386unsafe impl<'a> glib::value::FromValue<'a> for InputHints {
387 type Checker = glib::value::GenericValueTypeChecker<Self>;
388
389 #[inline]
390 unsafe fn from_value(value: &'a glib::Value) -> Self {
391 skip_assert_initialized!();
392 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
393 }
394}
395
396impl ToValue for InputHints {
397 #[inline]
398 fn to_value(&self) -> glib::Value {
399 let mut value = glib::Value::for_value_type::<Self>();
400 unsafe {
401 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
402 }
403 value
404 }
405
406 #[inline]
407 fn value_type(&self) -> glib::Type {
408 Self::static_type()
409 }
410}
411
412impl From<InputHints> for glib::Value {
413 #[inline]
414 fn from(v: InputHints) -> Self {
415 skip_assert_initialized!();
416 ToValue::to_value(&v)
417 }
418}
419
420bitflags! {
421 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
424 #[doc(alias = "WebKitSnapshotOptions")]
425 pub struct SnapshotOptions: u32 {
426 #[doc(alias = "WEBKIT_SNAPSHOT_OPTIONS_NONE")]
428 const NONE = ffi::WEBKIT_SNAPSHOT_OPTIONS_NONE as _;
429 #[doc(alias = "WEBKIT_SNAPSHOT_OPTIONS_INCLUDE_SELECTION_HIGHLIGHTING")]
432 const INCLUDE_SELECTION_HIGHLIGHTING = ffi::WEBKIT_SNAPSHOT_OPTIONS_INCLUDE_SELECTION_HIGHLIGHTING as _;
433 #[doc(alias = "WEBKIT_SNAPSHOT_OPTIONS_TRANSPARENT_BACKGROUND")]
436 const TRANSPARENT_BACKGROUND = ffi::WEBKIT_SNAPSHOT_OPTIONS_TRANSPARENT_BACKGROUND as _;
437 }
438}
439
440#[doc(hidden)]
441impl IntoGlib for SnapshotOptions {
442 type GlibType = ffi::WebKitSnapshotOptions;
443
444 #[inline]
445 fn into_glib(self) -> ffi::WebKitSnapshotOptions {
446 self.bits()
447 }
448}
449
450#[doc(hidden)]
451impl FromGlib<ffi::WebKitSnapshotOptions> for SnapshotOptions {
452 #[inline]
453 unsafe fn from_glib(value: ffi::WebKitSnapshotOptions) -> Self {
454 skip_assert_initialized!();
455 Self::from_bits_truncate(value)
456 }
457}
458
459impl StaticType for SnapshotOptions {
460 #[inline]
461 #[doc(alias = "webkit_snapshot_options_get_type")]
462 fn static_type() -> glib::Type {
463 unsafe { from_glib(ffi::webkit_snapshot_options_get_type()) }
464 }
465}
466
467impl glib::HasParamSpec for SnapshotOptions {
468 type ParamSpec = glib::ParamSpecFlags;
469 type SetValue = Self;
470 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
471
472 fn param_spec_builder() -> Self::BuilderFn {
473 Self::ParamSpec::builder
474 }
475}
476
477impl glib::value::ValueType for SnapshotOptions {
478 type Type = Self;
479}
480
481unsafe impl<'a> glib::value::FromValue<'a> for SnapshotOptions {
482 type Checker = glib::value::GenericValueTypeChecker<Self>;
483
484 #[inline]
485 unsafe fn from_value(value: &'a glib::Value) -> Self {
486 skip_assert_initialized!();
487 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
488 }
489}
490
491impl ToValue for SnapshotOptions {
492 #[inline]
493 fn to_value(&self) -> glib::Value {
494 let mut value = glib::Value::for_value_type::<Self>();
495 unsafe {
496 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
497 }
498 value
499 }
500
501 #[inline]
502 fn value_type(&self) -> glib::Type {
503 Self::static_type()
504 }
505}
506
507impl From<SnapshotOptions> for glib::Value {
508 #[inline]
509 fn from(v: SnapshotOptions) -> Self {
510 skip_assert_initialized!();
511 ToValue::to_value(&v)
512 }
513}
514
515#[cfg(feature = "v2_48")]
516bitflags! {
517 #[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
519 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
520 #[doc(alias = "WebKitWebExtensionMatchPatternOptions")]
521 pub struct WebExtensionMatchPatternOptions: u32 {
522 #[doc(alias = "WEBKIT_WEB_EXTENSION_MATCH_PATTERN_OPTIONS_NONE")]
524 const NONE = ffi::WEBKIT_WEB_EXTENSION_MATCH_PATTERN_OPTIONS_NONE as _;
525 #[doc(alias = "WEBKIT_WEB_EXTENSION_MATCH_PATTERN_OPTIONS_IGNORE_SCHEMES")]
527 const IGNORE_SCHEMES = ffi::WEBKIT_WEB_EXTENSION_MATCH_PATTERN_OPTIONS_IGNORE_SCHEMES as _;
528 #[doc(alias = "WEBKIT_WEB_EXTENSION_MATCH_PATTERN_OPTIONS_IGNORE_PATHS")]
530 const IGNORE_PATHS = ffi::WEBKIT_WEB_EXTENSION_MATCH_PATTERN_OPTIONS_IGNORE_PATHS as _;
531 #[doc(alias = "WEBKIT_WEB_EXTENSION_MATCH_PATTERN_OPTIONS_MATCH_BIDIRECTIONALLY")]
533 const MATCH_BIDIRECTIONALLY = ffi::WEBKIT_WEB_EXTENSION_MATCH_PATTERN_OPTIONS_MATCH_BIDIRECTIONALLY as _;
534 }
535}
536
537#[cfg(feature = "v2_48")]
538#[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
539#[doc(hidden)]
540impl IntoGlib for WebExtensionMatchPatternOptions {
541 type GlibType = ffi::WebKitWebExtensionMatchPatternOptions;
542
543 #[inline]
544 fn into_glib(self) -> ffi::WebKitWebExtensionMatchPatternOptions {
545 self.bits()
546 }
547}
548
549#[cfg(feature = "v2_48")]
550#[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
551#[doc(hidden)]
552impl FromGlib<ffi::WebKitWebExtensionMatchPatternOptions> for WebExtensionMatchPatternOptions {
553 #[inline]
554 unsafe fn from_glib(value: ffi::WebKitWebExtensionMatchPatternOptions) -> Self {
555 skip_assert_initialized!();
556 Self::from_bits_truncate(value)
557 }
558}
559
560#[cfg(feature = "v2_48")]
561#[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
562impl StaticType for WebExtensionMatchPatternOptions {
563 #[inline]
564 #[doc(alias = "webkit_web_extension_match_pattern_options_get_type")]
565 fn static_type() -> glib::Type {
566 unsafe { from_glib(ffi::webkit_web_extension_match_pattern_options_get_type()) }
567 }
568}
569
570#[cfg(feature = "v2_48")]
571#[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
572impl glib::HasParamSpec for WebExtensionMatchPatternOptions {
573 type ParamSpec = glib::ParamSpecFlags;
574 type SetValue = Self;
575 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
576
577 fn param_spec_builder() -> Self::BuilderFn {
578 Self::ParamSpec::builder
579 }
580}
581
582#[cfg(feature = "v2_48")]
583#[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
584impl glib::value::ValueType for WebExtensionMatchPatternOptions {
585 type Type = Self;
586}
587
588#[cfg(feature = "v2_48")]
589#[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
590unsafe impl<'a> glib::value::FromValue<'a> for WebExtensionMatchPatternOptions {
591 type Checker = glib::value::GenericValueTypeChecker<Self>;
592
593 #[inline]
594 unsafe fn from_value(value: &'a glib::Value) -> Self {
595 skip_assert_initialized!();
596 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
597 }
598}
599
600#[cfg(feature = "v2_48")]
601#[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
602impl ToValue for WebExtensionMatchPatternOptions {
603 #[inline]
604 fn to_value(&self) -> glib::Value {
605 let mut value = glib::Value::for_value_type::<Self>();
606 unsafe {
607 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
608 }
609 value
610 }
611
612 #[inline]
613 fn value_type(&self) -> glib::Type {
614 Self::static_type()
615 }
616}
617
618#[cfg(feature = "v2_48")]
619#[cfg_attr(docsrs, doc(cfg(feature = "v2_48")))]
620impl From<WebExtensionMatchPatternOptions> for glib::Value {
621 #[inline]
622 fn from(v: WebExtensionMatchPatternOptions) -> Self {
623 skip_assert_initialized!();
624 ToValue::to_value(&v)
625 }
626}
627
628bitflags! {
629 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
631 #[doc(alias = "WebKitWebsiteDataTypes")]
632 pub struct WebsiteDataTypes: u32 {
633 #[doc(alias = "WEBKIT_WEBSITE_DATA_MEMORY_CACHE")]
635 const MEMORY_CACHE = ffi::WEBKIT_WEBSITE_DATA_MEMORY_CACHE as _;
636 #[doc(alias = "WEBKIT_WEBSITE_DATA_DISK_CACHE")]
638 const DISK_CACHE = ffi::WEBKIT_WEBSITE_DATA_DISK_CACHE as _;
639 #[doc(alias = "WEBKIT_WEBSITE_DATA_OFFLINE_APPLICATION_CACHE")]
641 const OFFLINE_APPLICATION_CACHE = ffi::WEBKIT_WEBSITE_DATA_OFFLINE_APPLICATION_CACHE as _;
642 #[doc(alias = "WEBKIT_WEBSITE_DATA_SESSION_STORAGE")]
644 const SESSION_STORAGE = ffi::WEBKIT_WEBSITE_DATA_SESSION_STORAGE as _;
645 #[doc(alias = "WEBKIT_WEBSITE_DATA_LOCAL_STORAGE")]
647 const LOCAL_STORAGE = ffi::WEBKIT_WEBSITE_DATA_LOCAL_STORAGE as _;
648 #[doc(alias = "WEBKIT_WEBSITE_DATA_INDEXEDDB_DATABASES")]
650 const INDEXEDDB_DATABASES = ffi::WEBKIT_WEBSITE_DATA_INDEXEDDB_DATABASES as _;
651 #[doc(alias = "WEBKIT_WEBSITE_DATA_COOKIES")]
653 const COOKIES = ffi::WEBKIT_WEBSITE_DATA_COOKIES as _;
654 #[doc(alias = "WEBKIT_WEBSITE_DATA_DEVICE_ID_HASH_SALT")]
656 const DEVICE_ID_HASH_SALT = ffi::WEBKIT_WEBSITE_DATA_DEVICE_ID_HASH_SALT as _;
657 #[doc(alias = "WEBKIT_WEBSITE_DATA_HSTS_CACHE")]
659 const HSTS_CACHE = ffi::WEBKIT_WEBSITE_DATA_HSTS_CACHE as _;
660 #[doc(alias = "WEBKIT_WEBSITE_DATA_ITP")]
662 const ITP = ffi::WEBKIT_WEBSITE_DATA_ITP as _;
663 #[doc(alias = "WEBKIT_WEBSITE_DATA_SERVICE_WORKER_REGISTRATIONS")]
665 const SERVICE_WORKER_REGISTRATIONS = ffi::WEBKIT_WEBSITE_DATA_SERVICE_WORKER_REGISTRATIONS as _;
666 #[doc(alias = "WEBKIT_WEBSITE_DATA_DOM_CACHE")]
668 const DOM_CACHE = ffi::WEBKIT_WEBSITE_DATA_DOM_CACHE as _;
669 #[doc(alias = "WEBKIT_WEBSITE_DATA_ALL")]
671 const ALL = ffi::WEBKIT_WEBSITE_DATA_ALL as _;
672 }
673}
674
675#[doc(hidden)]
676impl IntoGlib for WebsiteDataTypes {
677 type GlibType = ffi::WebKitWebsiteDataTypes;
678
679 #[inline]
680 fn into_glib(self) -> ffi::WebKitWebsiteDataTypes {
681 self.bits()
682 }
683}
684
685#[doc(hidden)]
686impl FromGlib<ffi::WebKitWebsiteDataTypes> for WebsiteDataTypes {
687 #[inline]
688 unsafe fn from_glib(value: ffi::WebKitWebsiteDataTypes) -> Self {
689 skip_assert_initialized!();
690 Self::from_bits_truncate(value)
691 }
692}
693
694impl StaticType for WebsiteDataTypes {
695 #[inline]
696 #[doc(alias = "webkit_website_data_types_get_type")]
697 fn static_type() -> glib::Type {
698 unsafe { from_glib(ffi::webkit_website_data_types_get_type()) }
699 }
700}
701
702impl glib::HasParamSpec for WebsiteDataTypes {
703 type ParamSpec = glib::ParamSpecFlags;
704 type SetValue = Self;
705 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
706
707 fn param_spec_builder() -> Self::BuilderFn {
708 Self::ParamSpec::builder
709 }
710}
711
712impl glib::value::ValueType for WebsiteDataTypes {
713 type Type = Self;
714}
715
716unsafe impl<'a> glib::value::FromValue<'a> for WebsiteDataTypes {
717 type Checker = glib::value::GenericValueTypeChecker<Self>;
718
719 #[inline]
720 unsafe fn from_value(value: &'a glib::Value) -> Self {
721 skip_assert_initialized!();
722 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
723 }
724}
725
726impl ToValue for WebsiteDataTypes {
727 #[inline]
728 fn to_value(&self) -> glib::Value {
729 let mut value = glib::Value::for_value_type::<Self>();
730 unsafe {
731 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
732 }
733 value
734 }
735
736 #[inline]
737 fn value_type(&self) -> glib::Type {
738 Self::static_type()
739 }
740}
741
742impl From<WebsiteDataTypes> for glib::Value {
743 #[inline]
744 fn from(v: WebsiteDataTypes) -> Self {
745 skip_assert_initialized!();
746 ToValue::to_value(&v)
747 }
748}
749
750#[cfg(feature = "v2_52")]
751bitflags! {
752 #[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
757 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
758 #[doc(alias = "WebKitXRSessionFeatures")]
759 pub struct XRSessionFeatures: u32 {
760 #[doc(alias = "WEBKIT_XR_SESSION_FEATURES_VIEWER")]
762 const VIEWER = ffi::WEBKIT_XR_SESSION_FEATURES_VIEWER as _;
763 #[doc(alias = "WEBKIT_XR_SESSION_FEATURES_LOCAL")]
765 const LOCAL = ffi::WEBKIT_XR_SESSION_FEATURES_LOCAL as _;
766 #[doc(alias = "WEBKIT_XR_SESSION_FEATURES_LOCAL_FLOOR")]
768 const LOCAL_FLOOR = ffi::WEBKIT_XR_SESSION_FEATURES_LOCAL_FLOOR as _;
769 #[doc(alias = "WEBKIT_XR_SESSION_FEATURES_BOUNDED_FLOOR")]
771 const BOUNDED_FLOOR = ffi::WEBKIT_XR_SESSION_FEATURES_BOUNDED_FLOOR as _;
772 #[doc(alias = "WEBKIT_XR_SESSION_FEATURES_UNBOUNDED")]
774 const UNBOUNDED = ffi::WEBKIT_XR_SESSION_FEATURES_UNBOUNDED as _;
775 #[doc(alias = "WEBKIT_XR_SESSION_FEATURES_HAND_TRACKING")]
777 const HAND_TRACKING = ffi::WEBKIT_XR_SESSION_FEATURES_HAND_TRACKING as _;
778 #[doc(alias = "WEBKIT_XR_SESSION_FEATURES_HIT_TEST")]
780 const HIT_TEST = ffi::WEBKIT_XR_SESSION_FEATURES_HIT_TEST as _;
781 #[doc(alias = "WEBKIT_XR_SESSION_FEATURES_LAYERS")]
783 const LAYERS = ffi::WEBKIT_XR_SESSION_FEATURES_LAYERS as _;
784 }
785}
786
787#[cfg(feature = "v2_52")]
788#[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
789#[doc(hidden)]
790impl IntoGlib for XRSessionFeatures {
791 type GlibType = ffi::WebKitXRSessionFeatures;
792
793 #[inline]
794 fn into_glib(self) -> ffi::WebKitXRSessionFeatures {
795 self.bits()
796 }
797}
798
799#[cfg(feature = "v2_52")]
800#[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
801#[doc(hidden)]
802impl FromGlib<ffi::WebKitXRSessionFeatures> for XRSessionFeatures {
803 #[inline]
804 unsafe fn from_glib(value: ffi::WebKitXRSessionFeatures) -> Self {
805 skip_assert_initialized!();
806 Self::from_bits_truncate(value)
807 }
808}
809
810#[cfg(feature = "v2_52")]
811#[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
812impl StaticType for XRSessionFeatures {
813 #[inline]
814 #[doc(alias = "webkit_xr_session_features_get_type")]
815 fn static_type() -> glib::Type {
816 unsafe { from_glib(ffi::webkit_xr_session_features_get_type()) }
817 }
818}
819
820#[cfg(feature = "v2_52")]
821#[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
822impl glib::HasParamSpec for XRSessionFeatures {
823 type ParamSpec = glib::ParamSpecFlags;
824 type SetValue = Self;
825 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
826
827 fn param_spec_builder() -> Self::BuilderFn {
828 Self::ParamSpec::builder
829 }
830}
831
832#[cfg(feature = "v2_52")]
833#[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
834impl glib::value::ValueType for XRSessionFeatures {
835 type Type = Self;
836}
837
838#[cfg(feature = "v2_52")]
839#[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
840unsafe impl<'a> glib::value::FromValue<'a> for XRSessionFeatures {
841 type Checker = glib::value::GenericValueTypeChecker<Self>;
842
843 #[inline]
844 unsafe fn from_value(value: &'a glib::Value) -> Self {
845 skip_assert_initialized!();
846 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
847 }
848}
849
850#[cfg(feature = "v2_52")]
851#[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
852impl ToValue for XRSessionFeatures {
853 #[inline]
854 fn to_value(&self) -> glib::Value {
855 let mut value = glib::Value::for_value_type::<Self>();
856 unsafe {
857 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
858 }
859 value
860 }
861
862 #[inline]
863 fn value_type(&self) -> glib::Type {
864 Self::static_type()
865 }
866}
867
868#[cfg(feature = "v2_52")]
869#[cfg_attr(docsrs, doc(cfg(feature = "v2_52")))]
870impl From<XRSessionFeatures> for glib::Value {
871 #[inline]
872 fn from(v: XRSessionFeatures) -> Self {
873 skip_assert_initialized!();
874 ToValue::to_value(&v)
875 }
876}