Skip to main content

libglycin_rebind/auto/
enums.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from
3// from gir-files
4// DO NOT EDIT
5
6use glib::prelude::*;
7use glib::translate::*;
8
9use crate::ffi;
10
11#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12#[non_exhaustive]
13#[doc(alias = "GlyLoaderError")]
14pub enum LoaderError {
15    #[doc(alias = "GLY_LOADER_ERROR_FAILED")]
16    Failed,
17    #[doc(alias = "GLY_LOADER_ERROR_UNKNOWN_IMAGE_FORMAT")]
18    UnknownImageFormat,
19    #[doc(alias = "GLY_LOADER_ERROR_NO_MORE_FRAMES")]
20    NoMoreFrames,
21    #[doc(hidden)]
22    __Unknown(i32),
23}
24
25#[doc(hidden)]
26impl IntoGlib for LoaderError {
27    type GlibType = ffi::GlyLoaderError;
28
29    #[inline]
30    fn into_glib(self) -> ffi::GlyLoaderError {
31        match self {
32            Self::Failed => ffi::GLY_LOADER_ERROR_FAILED,
33            Self::UnknownImageFormat => ffi::GLY_LOADER_ERROR_UNKNOWN_IMAGE_FORMAT,
34            Self::NoMoreFrames => ffi::GLY_LOADER_ERROR_NO_MORE_FRAMES,
35            Self::__Unknown(value) => value,
36        }
37    }
38}
39
40#[doc(hidden)]
41impl FromGlib<ffi::GlyLoaderError> for LoaderError {
42    #[inline]
43    unsafe fn from_glib(value: ffi::GlyLoaderError) -> Self {
44        skip_assert_initialized!();
45
46        match value {
47            ffi::GLY_LOADER_ERROR_FAILED => Self::Failed,
48            ffi::GLY_LOADER_ERROR_UNKNOWN_IMAGE_FORMAT => Self::UnknownImageFormat,
49            ffi::GLY_LOADER_ERROR_NO_MORE_FRAMES => Self::NoMoreFrames,
50            value => Self::__Unknown(value),
51        }
52    }
53}
54
55impl glib::error::ErrorDomain for LoaderError {
56    #[inline]
57    fn domain() -> glib::Quark {
58        skip_assert_initialized!();
59
60        unsafe { from_glib(ffi::gly_loader_error_quark()) }
61    }
62
63    #[inline]
64    fn code(self) -> i32 {
65        self.into_glib()
66    }
67
68    #[inline]
69    #[allow(clippy::match_single_binding)]
70    fn from(code: i32) -> Option<Self> {
71        skip_assert_initialized!();
72        match unsafe { from_glib(code) } {
73            Self::__Unknown(_) => Some(Self::Failed),
74            value => Some(value),
75        }
76    }
77}
78
79impl StaticType for LoaderError {
80    #[inline]
81    #[doc(alias = "gly_loader_error_get_type")]
82    fn static_type() -> glib::Type {
83        unsafe { from_glib(ffi::gly_loader_error_get_type()) }
84    }
85}
86
87impl glib::HasParamSpec for LoaderError {
88    type ParamSpec = glib::ParamSpecEnum;
89    type SetValue = Self;
90    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
91
92    fn param_spec_builder() -> Self::BuilderFn {
93        Self::ParamSpec::builder_with_default
94    }
95}
96
97impl glib::value::ValueType for LoaderError {
98    type Type = Self;
99}
100
101unsafe impl<'a> glib::value::FromValue<'a> for LoaderError {
102    type Checker = glib::value::GenericValueTypeChecker<Self>;
103
104    #[inline]
105    unsafe fn from_value(value: &'a glib::Value) -> Self {
106        skip_assert_initialized!();
107        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
108    }
109}
110
111impl ToValue for LoaderError {
112    #[inline]
113    fn to_value(&self) -> glib::Value {
114        let mut value = glib::Value::for_value_type::<Self>();
115        unsafe {
116            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
117        }
118        value
119    }
120
121    #[inline]
122    fn value_type(&self) -> glib::Type {
123        Self::static_type()
124    }
125}
126
127impl From<LoaderError> for glib::Value {
128    #[inline]
129    fn from(v: LoaderError) -> Self {
130        skip_assert_initialized!();
131        ToValue::to_value(&v)
132    }
133}
134
135#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
136#[non_exhaustive]
137#[doc(alias = "GlyMemoryFormat")]
138pub enum MemoryFormat {
139    #[doc(alias = "GLY_MEMORY_B8G8R8A8_PREMULTIPLIED")]
140    B8g8r8a8Premultiplied,
141    #[doc(alias = "GLY_MEMORY_A8R8G8B8_PREMULTIPLIED")]
142    A8r8g8b8Premultiplied,
143    #[doc(alias = "GLY_MEMORY_R8G8B8A8_PREMULTIPLIED")]
144    R8g8b8a8Premultiplied,
145    #[doc(alias = "GLY_MEMORY_B8G8R8A8")]
146    B8g8r8a8,
147    #[doc(alias = "GLY_MEMORY_A8R8G8B8")]
148    A8r8g8b8,
149    #[doc(alias = "GLY_MEMORY_R8G8B8A8")]
150    R8g8b8a8,
151    #[doc(alias = "GLY_MEMORY_A8B8G8R8")]
152    A8b8g8r8,
153    #[doc(alias = "GLY_MEMORY_R8G8B8")]
154    R8g8b8,
155    #[doc(alias = "GLY_MEMORY_B8G8R8")]
156    B8g8r8,
157    #[doc(alias = "GLY_MEMORY_R16G16B16")]
158    R16g16b16,
159    #[doc(alias = "GLY_MEMORY_R16G16B16A16_PREMULTIPLIED")]
160    R16g16b16a16Premultiplied,
161    #[doc(alias = "GLY_MEMORY_R16G16B16A16")]
162    R16g16b16a16,
163    #[doc(alias = "GLY_MEMORY_R16G16B16_FLOAT")]
164    R16g16b16Float,
165    #[doc(alias = "GLY_MEMORY_R16G16B16A16_FLOAT")]
166    R16g16b16a16Float,
167    #[doc(alias = "GLY_MEMORY_R32G32B32_FLOAT")]
168    R32g32b32Float,
169    #[doc(alias = "GLY_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED")]
170    R32g32b32a32FloatPremultiplied,
171    #[doc(alias = "GLY_MEMORY_R32G32B32A32_FLOAT")]
172    R32g32b32a32Float,
173    #[doc(alias = "GLY_MEMORY_G8A8_PREMULTIPLIED")]
174    G8a8Premultiplied,
175    #[doc(alias = "GLY_MEMORY_G8A8")]
176    G8a8,
177    #[doc(alias = "GLY_MEMORY_G8")]
178    G8,
179    #[doc(alias = "GLY_MEMORY_G16A16_PREMULTIPLIED")]
180    G16a16Premultiplied,
181    #[doc(alias = "GLY_MEMORY_G16A16")]
182    G16a16,
183    #[doc(alias = "GLY_MEMORY_G16")]
184    G16,
185    #[doc(hidden)]
186    __Unknown(i32),
187}
188
189impl MemoryFormat {
190    #[doc(alias = "gly_memory_format_has_alpha")]
191    pub fn has_alpha(self) -> bool {
192        assert_initialized_main_thread!();
193        unsafe { from_glib(ffi::gly_memory_format_has_alpha(self.into_glib())) }
194    }
195
196    #[doc(alias = "gly_memory_format_is_premultiplied")]
197    pub fn is_premultiplied(self) -> bool {
198        assert_initialized_main_thread!();
199        unsafe { from_glib(ffi::gly_memory_format_is_premultiplied(self.into_glib())) }
200    }
201}
202
203#[doc(hidden)]
204impl IntoGlib for MemoryFormat {
205    type GlibType = ffi::GlyMemoryFormat;
206
207    fn into_glib(self) -> ffi::GlyMemoryFormat {
208        match self {
209            Self::B8g8r8a8Premultiplied => ffi::GLY_MEMORY_B8G8R8A8_PREMULTIPLIED,
210            Self::A8r8g8b8Premultiplied => ffi::GLY_MEMORY_A8R8G8B8_PREMULTIPLIED,
211            Self::R8g8b8a8Premultiplied => ffi::GLY_MEMORY_R8G8B8A8_PREMULTIPLIED,
212            Self::B8g8r8a8 => ffi::GLY_MEMORY_B8G8R8A8,
213            Self::A8r8g8b8 => ffi::GLY_MEMORY_A8R8G8B8,
214            Self::R8g8b8a8 => ffi::GLY_MEMORY_R8G8B8A8,
215            Self::A8b8g8r8 => ffi::GLY_MEMORY_A8B8G8R8,
216            Self::R8g8b8 => ffi::GLY_MEMORY_R8G8B8,
217            Self::B8g8r8 => ffi::GLY_MEMORY_B8G8R8,
218            Self::R16g16b16 => ffi::GLY_MEMORY_R16G16B16,
219            Self::R16g16b16a16Premultiplied => ffi::GLY_MEMORY_R16G16B16A16_PREMULTIPLIED,
220            Self::R16g16b16a16 => ffi::GLY_MEMORY_R16G16B16A16,
221            Self::R16g16b16Float => ffi::GLY_MEMORY_R16G16B16_FLOAT,
222            Self::R16g16b16a16Float => ffi::GLY_MEMORY_R16G16B16A16_FLOAT,
223            Self::R32g32b32Float => ffi::GLY_MEMORY_R32G32B32_FLOAT,
224            Self::R32g32b32a32FloatPremultiplied => {
225                ffi::GLY_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED
226            }
227            Self::R32g32b32a32Float => ffi::GLY_MEMORY_R32G32B32A32_FLOAT,
228            Self::G8a8Premultiplied => ffi::GLY_MEMORY_G8A8_PREMULTIPLIED,
229            Self::G8a8 => ffi::GLY_MEMORY_G8A8,
230            Self::G8 => ffi::GLY_MEMORY_G8,
231            Self::G16a16Premultiplied => ffi::GLY_MEMORY_G16A16_PREMULTIPLIED,
232            Self::G16a16 => ffi::GLY_MEMORY_G16A16,
233            Self::G16 => ffi::GLY_MEMORY_G16,
234            Self::__Unknown(value) => value,
235        }
236    }
237}
238
239#[doc(hidden)]
240impl FromGlib<ffi::GlyMemoryFormat> for MemoryFormat {
241    unsafe fn from_glib(value: ffi::GlyMemoryFormat) -> Self {
242        skip_assert_initialized!();
243
244        match value {
245            ffi::GLY_MEMORY_B8G8R8A8_PREMULTIPLIED => Self::B8g8r8a8Premultiplied,
246            ffi::GLY_MEMORY_A8R8G8B8_PREMULTIPLIED => Self::A8r8g8b8Premultiplied,
247            ffi::GLY_MEMORY_R8G8B8A8_PREMULTIPLIED => Self::R8g8b8a8Premultiplied,
248            ffi::GLY_MEMORY_B8G8R8A8 => Self::B8g8r8a8,
249            ffi::GLY_MEMORY_A8R8G8B8 => Self::A8r8g8b8,
250            ffi::GLY_MEMORY_R8G8B8A8 => Self::R8g8b8a8,
251            ffi::GLY_MEMORY_A8B8G8R8 => Self::A8b8g8r8,
252            ffi::GLY_MEMORY_R8G8B8 => Self::R8g8b8,
253            ffi::GLY_MEMORY_B8G8R8 => Self::B8g8r8,
254            ffi::GLY_MEMORY_R16G16B16 => Self::R16g16b16,
255            ffi::GLY_MEMORY_R16G16B16A16_PREMULTIPLIED => Self::R16g16b16a16Premultiplied,
256            ffi::GLY_MEMORY_R16G16B16A16 => Self::R16g16b16a16,
257            ffi::GLY_MEMORY_R16G16B16_FLOAT => Self::R16g16b16Float,
258            ffi::GLY_MEMORY_R16G16B16A16_FLOAT => Self::R16g16b16a16Float,
259            ffi::GLY_MEMORY_R32G32B32_FLOAT => Self::R32g32b32Float,
260            ffi::GLY_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED => {
261                Self::R32g32b32a32FloatPremultiplied
262            }
263            ffi::GLY_MEMORY_R32G32B32A32_FLOAT => Self::R32g32b32a32Float,
264            ffi::GLY_MEMORY_G8A8_PREMULTIPLIED => Self::G8a8Premultiplied,
265            ffi::GLY_MEMORY_G8A8 => Self::G8a8,
266            ffi::GLY_MEMORY_G8 => Self::G8,
267            ffi::GLY_MEMORY_G16A16_PREMULTIPLIED => Self::G16a16Premultiplied,
268            ffi::GLY_MEMORY_G16A16 => Self::G16a16,
269            ffi::GLY_MEMORY_G16 => Self::G16,
270            value => Self::__Unknown(value),
271        }
272    }
273}
274
275impl StaticType for MemoryFormat {
276    #[inline]
277    #[doc(alias = "gly_memory_format_get_type")]
278    fn static_type() -> glib::Type {
279        unsafe { from_glib(ffi::gly_memory_format_get_type()) }
280    }
281}
282
283impl glib::HasParamSpec for MemoryFormat {
284    type ParamSpec = glib::ParamSpecEnum;
285    type SetValue = Self;
286    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
287
288    fn param_spec_builder() -> Self::BuilderFn {
289        Self::ParamSpec::builder_with_default
290    }
291}
292
293impl glib::value::ValueType for MemoryFormat {
294    type Type = Self;
295}
296
297unsafe impl<'a> glib::value::FromValue<'a> for MemoryFormat {
298    type Checker = glib::value::GenericValueTypeChecker<Self>;
299
300    #[inline]
301    unsafe fn from_value(value: &'a glib::Value) -> Self {
302        skip_assert_initialized!();
303        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
304    }
305}
306
307impl ToValue for MemoryFormat {
308    #[inline]
309    fn to_value(&self) -> glib::Value {
310        let mut value = glib::Value::for_value_type::<Self>();
311        unsafe {
312            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
313        }
314        value
315    }
316
317    #[inline]
318    fn value_type(&self) -> glib::Type {
319        Self::static_type()
320    }
321}
322
323impl From<MemoryFormat> for glib::Value {
324    #[inline]
325    fn from(v: MemoryFormat) -> Self {
326        skip_assert_initialized!();
327        ToValue::to_value(&v)
328    }
329}
330
331#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
332#[non_exhaustive]
333#[doc(alias = "GlySandboxSelector")]
334pub enum SandboxSelector {
335    #[doc(alias = "GLY_SANDBOX_SELECTOR_AUTO")]
336    Auto,
337    #[doc(alias = "GLY_SANDBOX_SELECTOR_BWRAP")]
338    Bwrap,
339    #[doc(alias = "GLY_SANDBOX_SELECTOR_FLATPAK_SPAWN")]
340    FlatpakSpawn,
341    #[doc(alias = "GLY_SANDBOX_SELECTOR_NOT_SANDBOXED")]
342    NotSandboxed,
343    #[doc(hidden)]
344    __Unknown(i32),
345}
346
347#[doc(hidden)]
348impl IntoGlib for SandboxSelector {
349    type GlibType = ffi::GlySandboxSelector;
350
351    #[inline]
352    fn into_glib(self) -> ffi::GlySandboxSelector {
353        match self {
354            Self::Auto => ffi::GLY_SANDBOX_SELECTOR_AUTO,
355            Self::Bwrap => ffi::GLY_SANDBOX_SELECTOR_BWRAP,
356            Self::FlatpakSpawn => ffi::GLY_SANDBOX_SELECTOR_FLATPAK_SPAWN,
357            Self::NotSandboxed => ffi::GLY_SANDBOX_SELECTOR_NOT_SANDBOXED,
358            Self::__Unknown(value) => value,
359        }
360    }
361}
362
363#[doc(hidden)]
364impl FromGlib<ffi::GlySandboxSelector> for SandboxSelector {
365    #[inline]
366    unsafe fn from_glib(value: ffi::GlySandboxSelector) -> Self {
367        skip_assert_initialized!();
368
369        match value {
370            ffi::GLY_SANDBOX_SELECTOR_AUTO => Self::Auto,
371            ffi::GLY_SANDBOX_SELECTOR_BWRAP => Self::Bwrap,
372            ffi::GLY_SANDBOX_SELECTOR_FLATPAK_SPAWN => Self::FlatpakSpawn,
373            ffi::GLY_SANDBOX_SELECTOR_NOT_SANDBOXED => Self::NotSandboxed,
374            value => Self::__Unknown(value),
375        }
376    }
377}
378
379impl StaticType for SandboxSelector {
380    #[inline]
381    #[doc(alias = "gly_sandbox_selector_get_type")]
382    fn static_type() -> glib::Type {
383        unsafe { from_glib(ffi::gly_sandbox_selector_get_type()) }
384    }
385}
386
387impl glib::HasParamSpec for SandboxSelector {
388    type ParamSpec = glib::ParamSpecEnum;
389    type SetValue = Self;
390    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
391
392    fn param_spec_builder() -> Self::BuilderFn {
393        Self::ParamSpec::builder_with_default
394    }
395}
396
397impl glib::value::ValueType for SandboxSelector {
398    type Type = Self;
399}
400
401unsafe impl<'a> glib::value::FromValue<'a> for SandboxSelector {
402    type Checker = glib::value::GenericValueTypeChecker<Self>;
403
404    #[inline]
405    unsafe fn from_value(value: &'a glib::Value) -> Self {
406        skip_assert_initialized!();
407        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
408    }
409}
410
411impl ToValue for SandboxSelector {
412    #[inline]
413    fn to_value(&self) -> glib::Value {
414        let mut value = glib::Value::for_value_type::<Self>();
415        unsafe {
416            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
417        }
418        value
419    }
420
421    #[inline]
422    fn value_type(&self) -> glib::Type {
423        Self::static_type()
424    }
425}
426
427impl From<SandboxSelector> for glib::Value {
428    #[inline]
429    fn from(v: SandboxSelector) -> Self {
430        skip_assert_initialized!();
431        ToValue::to_value(&v)
432    }
433}