1use 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}