1use crate::ffi;
7use glib::{bitflags::bitflags, prelude::*, translate::*};
8
9bitflags! {
10 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
11 #[doc(alias = "PopplerAnnotFlag")]
12 pub struct AnnotFlag: u32 {
13 #[doc(alias = "POPPLER_ANNOT_FLAG_UNKNOWN")]
14 const UNKNOWN = ffi::POPPLER_ANNOT_FLAG_UNKNOWN as _;
15 #[doc(alias = "POPPLER_ANNOT_FLAG_INVISIBLE")]
16 const INVISIBLE = ffi::POPPLER_ANNOT_FLAG_INVISIBLE as _;
17 #[doc(alias = "POPPLER_ANNOT_FLAG_HIDDEN")]
18 const HIDDEN = ffi::POPPLER_ANNOT_FLAG_HIDDEN as _;
19 #[doc(alias = "POPPLER_ANNOT_FLAG_PRINT")]
20 const PRINT = ffi::POPPLER_ANNOT_FLAG_PRINT as _;
21 #[doc(alias = "POPPLER_ANNOT_FLAG_NO_ZOOM")]
22 const NO_ZOOM = ffi::POPPLER_ANNOT_FLAG_NO_ZOOM as _;
23 #[doc(alias = "POPPLER_ANNOT_FLAG_NO_ROTATE")]
24 const NO_ROTATE = ffi::POPPLER_ANNOT_FLAG_NO_ROTATE as _;
25 #[doc(alias = "POPPLER_ANNOT_FLAG_NO_VIEW")]
26 const NO_VIEW = ffi::POPPLER_ANNOT_FLAG_NO_VIEW as _;
27 #[doc(alias = "POPPLER_ANNOT_FLAG_READ_ONLY")]
28 const READ_ONLY = ffi::POPPLER_ANNOT_FLAG_READ_ONLY as _;
29 #[doc(alias = "POPPLER_ANNOT_FLAG_LOCKED")]
30 const LOCKED = ffi::POPPLER_ANNOT_FLAG_LOCKED as _;
31 #[doc(alias = "POPPLER_ANNOT_FLAG_TOGGLE_NO_VIEW")]
32 const TOGGLE_NO_VIEW = ffi::POPPLER_ANNOT_FLAG_TOGGLE_NO_VIEW as _;
33 #[doc(alias = "POPPLER_ANNOT_FLAG_LOCKED_CONTENTS")]
34 const LOCKED_CONTENTS = ffi::POPPLER_ANNOT_FLAG_LOCKED_CONTENTS as _;
35 }
36}
37
38#[doc(hidden)]
39impl IntoGlib for AnnotFlag {
40 type GlibType = ffi::PopplerAnnotFlag;
41
42 #[inline]
43 fn into_glib(self) -> ffi::PopplerAnnotFlag {
44 self.bits()
45 }
46}
47
48#[doc(hidden)]
49impl FromGlib<ffi::PopplerAnnotFlag> for AnnotFlag {
50 #[inline]
51 unsafe fn from_glib(value: ffi::PopplerAnnotFlag) -> Self {
52 Self::from_bits_truncate(value)
53 }
54}
55
56impl StaticType for AnnotFlag {
57 #[inline]
58 #[doc(alias = "poppler_annot_flag_get_type")]
59 fn static_type() -> glib::Type {
60 unsafe { from_glib(ffi::poppler_annot_flag_get_type()) }
61 }
62}
63
64impl glib::HasParamSpec for AnnotFlag {
65 type ParamSpec = glib::ParamSpecFlags;
66 type SetValue = Self;
67 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
68
69 fn param_spec_builder() -> Self::BuilderFn {
70 Self::ParamSpec::builder
71 }
72}
73
74impl glib::value::ValueType for AnnotFlag {
75 type Type = Self;
76}
77
78unsafe impl<'a> glib::value::FromValue<'a> for AnnotFlag {
79 type Checker = glib::value::GenericValueTypeChecker<Self>;
80
81 #[inline]
82 unsafe fn from_value(value: &'a glib::Value) -> Self {
83 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
84 }
85}
86
87impl ToValue for AnnotFlag {
88 #[inline]
89 fn to_value(&self) -> glib::Value {
90 let mut value = glib::Value::for_value_type::<Self>();
91 unsafe {
92 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
93 }
94 value
95 }
96
97 #[inline]
98 fn value_type(&self) -> glib::Type {
99 Self::static_type()
100 }
101}
102
103impl From<AnnotFlag> for glib::Value {
104 #[inline]
105 fn from(v: AnnotFlag) -> Self {
106 ToValue::to_value(&v)
107 }
108}
109
110bitflags! {
111 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
112 #[doc(alias = "PopplerFindFlags")]
113 pub struct FindFlags: u32 {
114 #[doc(alias = "POPPLER_FIND_DEFAULT")]
115 const DEFAULT = ffi::POPPLER_FIND_DEFAULT as _;
116 #[doc(alias = "POPPLER_FIND_CASE_SENSITIVE")]
117 const CASE_SENSITIVE = ffi::POPPLER_FIND_CASE_SENSITIVE as _;
118 #[doc(alias = "POPPLER_FIND_BACKWARDS")]
119 const BACKWARDS = ffi::POPPLER_FIND_BACKWARDS as _;
120 #[doc(alias = "POPPLER_FIND_WHOLE_WORDS_ONLY")]
121 const WHOLE_WORDS_ONLY = ffi::POPPLER_FIND_WHOLE_WORDS_ONLY as _;
122 #[doc(alias = "POPPLER_FIND_IGNORE_DIACRITICS")]
123 const IGNORE_DIACRITICS = ffi::POPPLER_FIND_IGNORE_DIACRITICS as _;
124 #[doc(alias = "POPPLER_FIND_MULTILINE")]
125 const MULTILINE = ffi::POPPLER_FIND_MULTILINE as _;
126 }
127}
128
129#[doc(hidden)]
130impl IntoGlib for FindFlags {
131 type GlibType = ffi::PopplerFindFlags;
132
133 #[inline]
134 fn into_glib(self) -> ffi::PopplerFindFlags {
135 self.bits()
136 }
137}
138
139#[doc(hidden)]
140impl FromGlib<ffi::PopplerFindFlags> for FindFlags {
141 #[inline]
142 unsafe fn from_glib(value: ffi::PopplerFindFlags) -> Self {
143 Self::from_bits_truncate(value)
144 }
145}
146
147impl StaticType for FindFlags {
148 #[inline]
149 #[doc(alias = "poppler_find_flags_get_type")]
150 fn static_type() -> glib::Type {
151 unsafe { from_glib(ffi::poppler_find_flags_get_type()) }
152 }
153}
154
155impl glib::HasParamSpec for FindFlags {
156 type ParamSpec = glib::ParamSpecFlags;
157 type SetValue = Self;
158 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
159
160 fn param_spec_builder() -> Self::BuilderFn {
161 Self::ParamSpec::builder
162 }
163}
164
165impl glib::value::ValueType for FindFlags {
166 type Type = Self;
167}
168
169unsafe impl<'a> glib::value::FromValue<'a> for FindFlags {
170 type Checker = glib::value::GenericValueTypeChecker<Self>;
171
172 #[inline]
173 unsafe fn from_value(value: &'a glib::Value) -> Self {
174 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
175 }
176}
177
178impl ToValue for FindFlags {
179 #[inline]
180 fn to_value(&self) -> glib::Value {
181 let mut value = glib::Value::for_value_type::<Self>();
182 unsafe {
183 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
184 }
185 value
186 }
187
188 #[inline]
189 fn value_type(&self) -> glib::Type {
190 Self::static_type()
191 }
192}
193
194impl From<FindFlags> for glib::Value {
195 #[inline]
196 fn from(v: FindFlags) -> Self {
197 ToValue::to_value(&v)
198 }
199}
200
201bitflags! {
202 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
203 #[doc(alias = "PopplerPermissions")]
204 pub struct Permissions: u32 {
205 #[doc(alias = "POPPLER_PERMISSIONS_OK_TO_PRINT")]
206 const OK_TO_PRINT = ffi::POPPLER_PERMISSIONS_OK_TO_PRINT as _;
207 #[doc(alias = "POPPLER_PERMISSIONS_OK_TO_MODIFY")]
208 const OK_TO_MODIFY = ffi::POPPLER_PERMISSIONS_OK_TO_MODIFY as _;
209 #[doc(alias = "POPPLER_PERMISSIONS_OK_TO_COPY")]
210 const OK_TO_COPY = ffi::POPPLER_PERMISSIONS_OK_TO_COPY as _;
211 #[doc(alias = "POPPLER_PERMISSIONS_OK_TO_ADD_NOTES")]
212 const OK_TO_ADD_NOTES = ffi::POPPLER_PERMISSIONS_OK_TO_ADD_NOTES as _;
213 #[doc(alias = "POPPLER_PERMISSIONS_OK_TO_FILL_FORM")]
214 const OK_TO_FILL_FORM = ffi::POPPLER_PERMISSIONS_OK_TO_FILL_FORM as _;
215 #[doc(alias = "POPPLER_PERMISSIONS_OK_TO_EXTRACT_CONTENTS")]
216 const OK_TO_EXTRACT_CONTENTS = ffi::POPPLER_PERMISSIONS_OK_TO_EXTRACT_CONTENTS as _;
217 #[doc(alias = "POPPLER_PERMISSIONS_OK_TO_ASSEMBLE")]
218 const OK_TO_ASSEMBLE = ffi::POPPLER_PERMISSIONS_OK_TO_ASSEMBLE as _;
219 #[doc(alias = "POPPLER_PERMISSIONS_OK_TO_PRINT_HIGH_RESOLUTION")]
220 const OK_TO_PRINT_HIGH_RESOLUTION = ffi::POPPLER_PERMISSIONS_OK_TO_PRINT_HIGH_RESOLUTION as _;
221 #[doc(alias = "POPPLER_PERMISSIONS_FULL")]
222 const FULL = ffi::POPPLER_PERMISSIONS_FULL as _;
223 }
224}
225
226#[doc(hidden)]
227impl IntoGlib for Permissions {
228 type GlibType = ffi::PopplerPermissions;
229
230 #[inline]
231 fn into_glib(self) -> ffi::PopplerPermissions {
232 self.bits()
233 }
234}
235
236#[doc(hidden)]
237impl FromGlib<ffi::PopplerPermissions> for Permissions {
238 #[inline]
239 unsafe fn from_glib(value: ffi::PopplerPermissions) -> Self {
240 Self::from_bits_truncate(value)
241 }
242}
243
244impl StaticType for Permissions {
245 #[inline]
246 #[doc(alias = "poppler_permissions_get_type")]
247 fn static_type() -> glib::Type {
248 unsafe { from_glib(ffi::poppler_permissions_get_type()) }
249 }
250}
251
252impl glib::HasParamSpec for Permissions {
253 type ParamSpec = glib::ParamSpecFlags;
254 type SetValue = Self;
255 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
256
257 fn param_spec_builder() -> Self::BuilderFn {
258 Self::ParamSpec::builder
259 }
260}
261
262impl glib::value::ValueType for Permissions {
263 type Type = Self;
264}
265
266unsafe impl<'a> glib::value::FromValue<'a> for Permissions {
267 type Checker = glib::value::GenericValueTypeChecker<Self>;
268
269 #[inline]
270 unsafe fn from_value(value: &'a glib::Value) -> Self {
271 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
272 }
273}
274
275impl ToValue for Permissions {
276 #[inline]
277 fn to_value(&self) -> glib::Value {
278 let mut value = glib::Value::for_value_type::<Self>();
279 unsafe {
280 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
281 }
282 value
283 }
284
285 #[inline]
286 fn value_type(&self) -> glib::Type {
287 Self::static_type()
288 }
289}
290
291impl From<Permissions> for glib::Value {
292 #[inline]
293 fn from(v: Permissions) -> Self {
294 ToValue::to_value(&v)
295 }
296}
297
298bitflags! {
299 #[cfg_attr(feature = "v25_2", deprecated = "Since 25.2")]
300 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
301 #[doc(alias = "PopplerPrintFlags")]
302 pub struct PrintFlags: u32 {
303 #[doc(alias = "POPPLER_PRINT_DOCUMENT")]
304 const DOCUMENT = ffi::POPPLER_PRINT_DOCUMENT as _;
305 #[doc(alias = "POPPLER_PRINT_MARKUP_ANNOTS")]
306 const MARKUP_ANNOTS = ffi::POPPLER_PRINT_MARKUP_ANNOTS as _;
307 #[doc(alias = "POPPLER_PRINT_STAMP_ANNOTS_ONLY")]
308 const STAMP_ANNOTS_ONLY = ffi::POPPLER_PRINT_STAMP_ANNOTS_ONLY as _;
309 #[doc(alias = "POPPLER_PRINT_ALL")]
310 const ALL = ffi::POPPLER_PRINT_ALL as _;
311 }
312}
313
314#[allow(deprecated)]
315#[doc(hidden)]
316impl IntoGlib for PrintFlags {
317 type GlibType = ffi::PopplerPrintFlags;
318
319 #[inline]
320 fn into_glib(self) -> ffi::PopplerPrintFlags {
321 self.bits()
322 }
323}
324
325#[allow(deprecated)]
326#[doc(hidden)]
327impl FromGlib<ffi::PopplerPrintFlags> for PrintFlags {
328 #[inline]
329 unsafe fn from_glib(value: ffi::PopplerPrintFlags) -> Self {
330 Self::from_bits_truncate(value)
331 }
332}
333
334#[allow(deprecated)]
335impl StaticType for PrintFlags {
336 #[inline]
337 #[doc(alias = "poppler_print_flags_get_type")]
338 fn static_type() -> glib::Type {
339 unsafe { from_glib(ffi::poppler_print_flags_get_type()) }
340 }
341}
342
343#[allow(deprecated)]
344impl glib::HasParamSpec for PrintFlags {
345 type ParamSpec = glib::ParamSpecFlags;
346 type SetValue = Self;
347 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
348
349 fn param_spec_builder() -> Self::BuilderFn {
350 Self::ParamSpec::builder
351 }
352}
353
354#[allow(deprecated)]
355impl glib::value::ValueType for PrintFlags {
356 type Type = Self;
357}
358
359#[allow(deprecated)]
360unsafe impl<'a> glib::value::FromValue<'a> for PrintFlags {
361 type Checker = glib::value::GenericValueTypeChecker<Self>;
362
363 #[inline]
364 unsafe fn from_value(value: &'a glib::Value) -> Self {
365 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
366 }
367}
368
369#[allow(deprecated)]
370impl ToValue for PrintFlags {
371 #[inline]
372 fn to_value(&self) -> glib::Value {
373 let mut value = glib::Value::for_value_type::<Self>();
374 unsafe {
375 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
376 }
377 value
378 }
379
380 #[inline]
381 fn value_type(&self) -> glib::Type {
382 Self::static_type()
383 }
384}
385
386#[allow(deprecated)]
387impl From<PrintFlags> for glib::Value {
388 #[inline]
389 fn from(v: PrintFlags) -> Self {
390 ToValue::to_value(&v)
391 }
392}
393
394#[cfg(feature = "v21_12")]
395bitflags! {
396 #[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
397 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
398 #[doc(alias = "PopplerSignatureValidationFlags")]
399 pub struct SignatureValidationFlags: u32 {
400 #[doc(alias = "POPPLER_SIGNATURE_VALIDATION_FLAG_VALIDATE_CERTIFICATE")]
401 const VALIDATE_CERTIFICATE = ffi::POPPLER_SIGNATURE_VALIDATION_FLAG_VALIDATE_CERTIFICATE as _;
402 #[doc(alias = "POPPLER_SIGNATURE_VALIDATION_FLAG_WITHOUT_OCSP_REVOCATION_CHECK")]
403 const WITHOUT_OCSP_REVOCATION_CHECK = ffi::POPPLER_SIGNATURE_VALIDATION_FLAG_WITHOUT_OCSP_REVOCATION_CHECK as _;
404 #[doc(alias = "POPPLER_SIGNATURE_VALIDATION_FLAG_USE_AIA_CERTIFICATE_FETCH")]
405 const USE_AIA_CERTIFICATE_FETCH = ffi::POPPLER_SIGNATURE_VALIDATION_FLAG_USE_AIA_CERTIFICATE_FETCH as _;
406 }
407}
408
409#[cfg(feature = "v21_12")]
410#[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
411#[doc(hidden)]
412impl IntoGlib for SignatureValidationFlags {
413 type GlibType = ffi::PopplerSignatureValidationFlags;
414
415 #[inline]
416 fn into_glib(self) -> ffi::PopplerSignatureValidationFlags {
417 self.bits()
418 }
419}
420
421#[cfg(feature = "v21_12")]
422#[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
423#[doc(hidden)]
424impl FromGlib<ffi::PopplerSignatureValidationFlags> for SignatureValidationFlags {
425 #[inline]
426 unsafe fn from_glib(value: ffi::PopplerSignatureValidationFlags) -> Self {
427 Self::from_bits_truncate(value)
428 }
429}
430
431#[cfg(feature = "v21_12")]
432#[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
433impl StaticType for SignatureValidationFlags {
434 #[inline]
435 #[doc(alias = "poppler_signature_validation_flags_get_type")]
436 fn static_type() -> glib::Type {
437 unsafe { from_glib(ffi::poppler_signature_validation_flags_get_type()) }
438 }
439}
440
441#[cfg(feature = "v21_12")]
442#[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
443impl glib::HasParamSpec for SignatureValidationFlags {
444 type ParamSpec = glib::ParamSpecFlags;
445 type SetValue = Self;
446 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
447
448 fn param_spec_builder() -> Self::BuilderFn {
449 Self::ParamSpec::builder
450 }
451}
452
453#[cfg(feature = "v21_12")]
454#[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
455impl glib::value::ValueType for SignatureValidationFlags {
456 type Type = Self;
457}
458
459#[cfg(feature = "v21_12")]
460#[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
461unsafe impl<'a> glib::value::FromValue<'a> for SignatureValidationFlags {
462 type Checker = glib::value::GenericValueTypeChecker<Self>;
463
464 #[inline]
465 unsafe fn from_value(value: &'a glib::Value) -> Self {
466 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
467 }
468}
469
470#[cfg(feature = "v21_12")]
471#[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
472impl ToValue for SignatureValidationFlags {
473 #[inline]
474 fn to_value(&self) -> glib::Value {
475 let mut value = glib::Value::for_value_type::<Self>();
476 unsafe {
477 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
478 }
479 value
480 }
481
482 #[inline]
483 fn value_type(&self) -> glib::Type {
484 Self::static_type()
485 }
486}
487
488#[cfg(feature = "v21_12")]
489#[cfg_attr(docsrs, doc(cfg(feature = "v21_12")))]
490impl From<SignatureValidationFlags> for glib::Value {
491 #[inline]
492 fn from(v: SignatureValidationFlags) -> Self {
493 ToValue::to_value(&v)
494 }
495}
496
497bitflags! {
498 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
499 #[doc(alias = "PopplerStructureGetTextFlags")]
500 pub struct StructureGetTextFlags: u32 {
501 #[doc(alias = "POPPLER_STRUCTURE_GET_TEXT_NONE")]
502 const NONE = ffi::POPPLER_STRUCTURE_GET_TEXT_NONE as _;
503 #[doc(alias = "POPPLER_STRUCTURE_GET_TEXT_RECURSIVE")]
504 const RECURSIVE = ffi::POPPLER_STRUCTURE_GET_TEXT_RECURSIVE as _;
505 }
506}
507
508#[doc(hidden)]
509impl IntoGlib for StructureGetTextFlags {
510 type GlibType = ffi::PopplerStructureGetTextFlags;
511
512 #[inline]
513 fn into_glib(self) -> ffi::PopplerStructureGetTextFlags {
514 self.bits()
515 }
516}
517
518#[doc(hidden)]
519impl FromGlib<ffi::PopplerStructureGetTextFlags> for StructureGetTextFlags {
520 #[inline]
521 unsafe fn from_glib(value: ffi::PopplerStructureGetTextFlags) -> Self {
522 Self::from_bits_truncate(value)
523 }
524}
525
526impl StaticType for StructureGetTextFlags {
527 #[inline]
528 #[doc(alias = "poppler_structure_get_text_flags_get_type")]
529 fn static_type() -> glib::Type {
530 unsafe { from_glib(ffi::poppler_structure_get_text_flags_get_type()) }
531 }
532}
533
534impl glib::HasParamSpec for StructureGetTextFlags {
535 type ParamSpec = glib::ParamSpecFlags;
536 type SetValue = Self;
537 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
538
539 fn param_spec_builder() -> Self::BuilderFn {
540 Self::ParamSpec::builder
541 }
542}
543
544impl glib::value::ValueType for StructureGetTextFlags {
545 type Type = Self;
546}
547
548unsafe impl<'a> glib::value::FromValue<'a> for StructureGetTextFlags {
549 type Checker = glib::value::GenericValueTypeChecker<Self>;
550
551 #[inline]
552 unsafe fn from_value(value: &'a glib::Value) -> Self {
553 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
554 }
555}
556
557impl ToValue for StructureGetTextFlags {
558 #[inline]
559 fn to_value(&self) -> glib::Value {
560 let mut value = glib::Value::for_value_type::<Self>();
561 unsafe {
562 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
563 }
564 value
565 }
566
567 #[inline]
568 fn value_type(&self) -> glib::Type {
569 Self::static_type()
570 }
571}
572
573impl From<StructureGetTextFlags> for glib::Value {
574 #[inline]
575 fn from(v: StructureGetTextFlags) -> Self {
576 ToValue::to_value(&v)
577 }
578}
579
580bitflags! {
581 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
582 #[doc(alias = "PopplerViewerPreferences")]
583 pub struct ViewerPreferences: u32 {
584 #[doc(alias = "POPPLER_VIEWER_PREFERENCES_UNSET")]
585 const UNSET = ffi::POPPLER_VIEWER_PREFERENCES_UNSET as _;
586 #[doc(alias = "POPPLER_VIEWER_PREFERENCES_HIDE_TOOLBAR")]
587 const HIDE_TOOLBAR = ffi::POPPLER_VIEWER_PREFERENCES_HIDE_TOOLBAR as _;
588 #[doc(alias = "POPPLER_VIEWER_PREFERENCES_HIDE_MENUBAR")]
589 const HIDE_MENUBAR = ffi::POPPLER_VIEWER_PREFERENCES_HIDE_MENUBAR as _;
590 #[doc(alias = "POPPLER_VIEWER_PREFERENCES_HIDE_WINDOWUI")]
591 const HIDE_WINDOWUI = ffi::POPPLER_VIEWER_PREFERENCES_HIDE_WINDOWUI as _;
592 #[doc(alias = "POPPLER_VIEWER_PREFERENCES_FIT_WINDOW")]
593 const FIT_WINDOW = ffi::POPPLER_VIEWER_PREFERENCES_FIT_WINDOW as _;
594 #[doc(alias = "POPPLER_VIEWER_PREFERENCES_CENTER_WINDOW")]
595 const CENTER_WINDOW = ffi::POPPLER_VIEWER_PREFERENCES_CENTER_WINDOW as _;
596 #[doc(alias = "POPPLER_VIEWER_PREFERENCES_DISPLAY_DOC_TITLE")]
597 const DISPLAY_DOC_TITLE = ffi::POPPLER_VIEWER_PREFERENCES_DISPLAY_DOC_TITLE as _;
598 #[doc(alias = "POPPLER_VIEWER_PREFERENCES_DIRECTION_RTL")]
599 const DIRECTION_RTL = ffi::POPPLER_VIEWER_PREFERENCES_DIRECTION_RTL as _;
600 }
601}
602
603#[doc(hidden)]
604impl IntoGlib for ViewerPreferences {
605 type GlibType = ffi::PopplerViewerPreferences;
606
607 #[inline]
608 fn into_glib(self) -> ffi::PopplerViewerPreferences {
609 self.bits()
610 }
611}
612
613#[doc(hidden)]
614impl FromGlib<ffi::PopplerViewerPreferences> for ViewerPreferences {
615 #[inline]
616 unsafe fn from_glib(value: ffi::PopplerViewerPreferences) -> Self {
617 Self::from_bits_truncate(value)
618 }
619}
620
621impl StaticType for ViewerPreferences {
622 #[inline]
623 #[doc(alias = "poppler_viewer_preferences_get_type")]
624 fn static_type() -> glib::Type {
625 unsafe { from_glib(ffi::poppler_viewer_preferences_get_type()) }
626 }
627}
628
629impl glib::HasParamSpec for ViewerPreferences {
630 type ParamSpec = glib::ParamSpecFlags;
631 type SetValue = Self;
632 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
633
634 fn param_spec_builder() -> Self::BuilderFn {
635 Self::ParamSpec::builder
636 }
637}
638
639impl glib::value::ValueType for ViewerPreferences {
640 type Type = Self;
641}
642
643unsafe impl<'a> glib::value::FromValue<'a> for ViewerPreferences {
644 type Checker = glib::value::GenericValueTypeChecker<Self>;
645
646 #[inline]
647 unsafe fn from_value(value: &'a glib::Value) -> Self {
648 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
649 }
650}
651
652impl ToValue for ViewerPreferences {
653 #[inline]
654 fn to_value(&self) -> glib::Value {
655 let mut value = glib::Value::for_value_type::<Self>();
656 unsafe {
657 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
658 }
659 value
660 }
661
662 #[inline]
663 fn value_type(&self) -> glib::Type {
664 Self::static_type()
665 }
666}
667
668impl From<ViewerPreferences> for glib::Value {
669 #[inline]
670 fn from(v: ViewerPreferences) -> Self {
671 ToValue::to_value(&v)
672 }
673}