1use crate::ffi;
7use glib::{prelude::*, translate::*};
8
9#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10#[non_exhaustive]
11#[doc(alias = "SpiceChannelEvent")]
12pub enum ChannelEvent {
13 #[doc(alias = "SPICE_CHANNEL_NONE")]
14 None,
15 #[doc(alias = "SPICE_CHANNEL_OPENED")]
16 Opened,
17 #[doc(alias = "SPICE_CHANNEL_SWITCHING")]
18 Switching,
19 #[doc(alias = "SPICE_CHANNEL_CLOSED")]
20 Closed,
21 #[doc(alias = "SPICE_CHANNEL_ERROR_CONNECT")]
22 ErrorConnect,
23 #[doc(alias = "SPICE_CHANNEL_ERROR_TLS")]
24 ErrorTls,
25 #[doc(alias = "SPICE_CHANNEL_ERROR_LINK")]
26 ErrorLink,
27 #[doc(alias = "SPICE_CHANNEL_ERROR_AUTH")]
28 ErrorAuth,
29 #[doc(alias = "SPICE_CHANNEL_ERROR_IO")]
30 ErrorIo,
31 #[doc(hidden)]
32 __Unknown(i32),
33}
34
35#[doc(hidden)]
36impl IntoGlib for ChannelEvent {
37 type GlibType = ffi::SpiceChannelEvent;
38
39 #[inline]
40 fn into_glib(self) -> ffi::SpiceChannelEvent {
41 match self {
42 Self::None => ffi::SPICE_CHANNEL_NONE,
43 Self::Opened => ffi::SPICE_CHANNEL_OPENED,
44 Self::Switching => ffi::SPICE_CHANNEL_SWITCHING,
45 Self::Closed => ffi::SPICE_CHANNEL_CLOSED,
46 Self::ErrorConnect => ffi::SPICE_CHANNEL_ERROR_CONNECT,
47 Self::ErrorTls => ffi::SPICE_CHANNEL_ERROR_TLS,
48 Self::ErrorLink => ffi::SPICE_CHANNEL_ERROR_LINK,
49 Self::ErrorAuth => ffi::SPICE_CHANNEL_ERROR_AUTH,
50 Self::ErrorIo => ffi::SPICE_CHANNEL_ERROR_IO,
51 Self::__Unknown(value) => value,
52 }
53 }
54}
55
56#[doc(hidden)]
57impl FromGlib<ffi::SpiceChannelEvent> for ChannelEvent {
58 #[inline]
59 unsafe fn from_glib(value: ffi::SpiceChannelEvent) -> Self {
60 skip_assert_initialized!();
61
62 match value {
63 ffi::SPICE_CHANNEL_NONE => Self::None,
64 ffi::SPICE_CHANNEL_OPENED => Self::Opened,
65 ffi::SPICE_CHANNEL_SWITCHING => Self::Switching,
66 ffi::SPICE_CHANNEL_CLOSED => Self::Closed,
67 ffi::SPICE_CHANNEL_ERROR_CONNECT => Self::ErrorConnect,
68 ffi::SPICE_CHANNEL_ERROR_TLS => Self::ErrorTls,
69 ffi::SPICE_CHANNEL_ERROR_LINK => Self::ErrorLink,
70 ffi::SPICE_CHANNEL_ERROR_AUTH => Self::ErrorAuth,
71 ffi::SPICE_CHANNEL_ERROR_IO => Self::ErrorIo,
72 value => Self::__Unknown(value),
73 }
74 }
75}
76
77impl StaticType for ChannelEvent {
78 #[inline]
79 #[doc(alias = "spice_channel_event_get_type")]
80 fn static_type() -> glib::Type {
81 unsafe { from_glib(ffi::spice_channel_event_get_type()) }
82 }
83}
84
85impl glib::HasParamSpec for ChannelEvent {
86 type ParamSpec = glib::ParamSpecEnum;
87 type SetValue = Self;
88 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
89
90 fn param_spec_builder() -> Self::BuilderFn {
91 Self::ParamSpec::builder_with_default
92 }
93}
94
95impl glib::value::ValueType for ChannelEvent {
96 type Type = Self;
97}
98
99unsafe impl<'a> glib::value::FromValue<'a> for ChannelEvent {
100 type Checker = glib::value::GenericValueTypeChecker<Self>;
101
102 #[inline]
103 unsafe fn from_value(value: &'a glib::Value) -> Self {
104 skip_assert_initialized!();
105 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
106 }
107}
108
109impl ToValue for ChannelEvent {
110 #[inline]
111 fn to_value(&self) -> glib::Value {
112 let mut value = glib::Value::for_value_type::<Self>();
113 unsafe {
114 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
115 }
116 value
117 }
118
119 #[inline]
120 fn value_type(&self) -> glib::Type {
121 Self::static_type()
122 }
123}
124
125impl From<ChannelEvent> for glib::Value {
126 #[inline]
127 fn from(v: ChannelEvent) -> Self {
128 skip_assert_initialized!();
129 ToValue::to_value(&v)
130 }
131}
132
133#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
134#[non_exhaustive]
135#[doc(alias = "SpiceClientError")]
136pub enum ClientError {
137 #[doc(alias = "SPICE_CLIENT_ERROR_FAILED")]
138 Failed,
139 #[doc(alias = "SPICE_CLIENT_ERROR_USB_DEVICE_REJECTED")]
140 UsbDeviceRejected,
141 #[doc(alias = "SPICE_CLIENT_ERROR_USB_DEVICE_LOST")]
142 UsbDeviceLost,
143 #[doc(alias = "SPICE_CLIENT_ERROR_AUTH_NEEDS_PASSWORD")]
144 AuthNeedsPassword,
145 #[doc(alias = "SPICE_CLIENT_ERROR_AUTH_NEEDS_USERNAME")]
146 AuthNeedsUsername,
147 #[doc(alias = "SPICE_CLIENT_ERROR_AUTH_NEEDS_PASSWORD_AND_USERNAME")]
148 AuthNeedsPasswordAndUsername,
149 #[doc(alias = "SPICE_CLIENT_ERROR_USB_SERVICE")]
150 UsbService,
151 #[doc(hidden)]
152 __Unknown(i32),
153}
154
155#[doc(hidden)]
156impl IntoGlib for ClientError {
157 type GlibType = ffi::SpiceClientError;
158
159 #[inline]
160 fn into_glib(self) -> ffi::SpiceClientError {
161 match self {
162 Self::Failed => ffi::SPICE_CLIENT_ERROR_FAILED,
163 Self::UsbDeviceRejected => ffi::SPICE_CLIENT_ERROR_USB_DEVICE_REJECTED,
164 Self::UsbDeviceLost => ffi::SPICE_CLIENT_ERROR_USB_DEVICE_LOST,
165 Self::AuthNeedsPassword => ffi::SPICE_CLIENT_ERROR_AUTH_NEEDS_PASSWORD,
166 Self::AuthNeedsUsername => ffi::SPICE_CLIENT_ERROR_AUTH_NEEDS_USERNAME,
167 Self::AuthNeedsPasswordAndUsername => {
168 ffi::SPICE_CLIENT_ERROR_AUTH_NEEDS_PASSWORD_AND_USERNAME
169 }
170 Self::UsbService => ffi::SPICE_CLIENT_ERROR_USB_SERVICE,
171 Self::__Unknown(value) => value,
172 }
173 }
174}
175
176#[doc(hidden)]
177impl FromGlib<ffi::SpiceClientError> for ClientError {
178 #[inline]
179 unsafe fn from_glib(value: ffi::SpiceClientError) -> Self {
180 skip_assert_initialized!();
181
182 match value {
183 ffi::SPICE_CLIENT_ERROR_FAILED => Self::Failed,
184 ffi::SPICE_CLIENT_ERROR_USB_DEVICE_REJECTED => Self::UsbDeviceRejected,
185 ffi::SPICE_CLIENT_ERROR_USB_DEVICE_LOST => Self::UsbDeviceLost,
186 ffi::SPICE_CLIENT_ERROR_AUTH_NEEDS_PASSWORD => Self::AuthNeedsPassword,
187 ffi::SPICE_CLIENT_ERROR_AUTH_NEEDS_USERNAME => Self::AuthNeedsUsername,
188 ffi::SPICE_CLIENT_ERROR_AUTH_NEEDS_PASSWORD_AND_USERNAME => {
189 Self::AuthNeedsPasswordAndUsername
190 }
191 ffi::SPICE_CLIENT_ERROR_USB_SERVICE => Self::UsbService,
192 value => Self::__Unknown(value),
193 }
194 }
195}
196
197impl glib::error::ErrorDomain for ClientError {
198 #[inline]
199 fn domain() -> glib::Quark {
200 skip_assert_initialized!();
201
202 unsafe { from_glib(ffi::spice_client_error_quark()) }
203 }
204
205 #[inline]
206 fn code(self) -> i32 {
207 self.into_glib()
208 }
209
210 #[inline]
211 #[allow(clippy::match_single_binding)]
212 fn from(code: i32) -> Option<Self> {
213 skip_assert_initialized!();
214 match unsafe { from_glib(code) } {
215 Self::__Unknown(_) => Some(Self::Failed),
216 value => Some(value),
217 }
218 }
219}
220
221#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
222#[non_exhaustive]
223#[doc(alias = "SpiceQmpPortVmAction")]
224pub enum QmpPortVmAction {
225 #[doc(alias = "SPICE_QMP_PORT_VM_ACTION_QUIT")]
226 Quit,
227 #[doc(alias = "SPICE_QMP_PORT_VM_ACTION_RESET")]
228 Reset,
229 #[doc(alias = "SPICE_QMP_PORT_VM_ACTION_POWER_DOWN")]
230 PowerDown,
231 #[doc(alias = "SPICE_QMP_PORT_VM_ACTION_PAUSE")]
232 Pause,
233 #[doc(alias = "SPICE_QMP_PORT_VM_ACTION_CONTINUE")]
234 Continue,
235 #[doc(alias = "SPICE_QMP_PORT_VM_ACTION_LAST")]
236 Last,
237 #[doc(hidden)]
238 __Unknown(i32),
239}
240
241#[doc(hidden)]
242impl IntoGlib for QmpPortVmAction {
243 type GlibType = ffi::SpiceQmpPortVmAction;
244
245 #[inline]
246 fn into_glib(self) -> ffi::SpiceQmpPortVmAction {
247 match self {
248 Self::Quit => ffi::SPICE_QMP_PORT_VM_ACTION_QUIT,
249 Self::Reset => ffi::SPICE_QMP_PORT_VM_ACTION_RESET,
250 Self::PowerDown => ffi::SPICE_QMP_PORT_VM_ACTION_POWER_DOWN,
251 Self::Pause => ffi::SPICE_QMP_PORT_VM_ACTION_PAUSE,
252 Self::Continue => ffi::SPICE_QMP_PORT_VM_ACTION_CONTINUE,
253 Self::Last => ffi::SPICE_QMP_PORT_VM_ACTION_LAST,
254 Self::__Unknown(value) => value,
255 }
256 }
257}
258
259#[doc(hidden)]
260impl FromGlib<ffi::SpiceQmpPortVmAction> for QmpPortVmAction {
261 #[inline]
262 unsafe fn from_glib(value: ffi::SpiceQmpPortVmAction) -> Self {
263 skip_assert_initialized!();
264
265 match value {
266 ffi::SPICE_QMP_PORT_VM_ACTION_QUIT => Self::Quit,
267 ffi::SPICE_QMP_PORT_VM_ACTION_RESET => Self::Reset,
268 ffi::SPICE_QMP_PORT_VM_ACTION_POWER_DOWN => Self::PowerDown,
269 ffi::SPICE_QMP_PORT_VM_ACTION_PAUSE => Self::Pause,
270 ffi::SPICE_QMP_PORT_VM_ACTION_CONTINUE => Self::Continue,
271 ffi::SPICE_QMP_PORT_VM_ACTION_LAST => Self::Last,
272 value => Self::__Unknown(value),
273 }
274 }
275}
276
277#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
278#[non_exhaustive]
279#[doc(alias = "SpiceSessionMigration")]
280pub enum SessionMigration {
281 #[doc(alias = "SPICE_SESSION_MIGRATION_NONE")]
282 None,
283 #[doc(alias = "SPICE_SESSION_MIGRATION_SWITCHING")]
284 Switching,
285 #[doc(alias = "SPICE_SESSION_MIGRATION_MIGRATING")]
286 Migrating,
287 #[doc(alias = "SPICE_SESSION_MIGRATION_CONNECTING")]
288 Connecting,
289 #[doc(hidden)]
290 __Unknown(i32),
291}
292
293#[doc(hidden)]
294impl IntoGlib for SessionMigration {
295 type GlibType = ffi::SpiceSessionMigration;
296
297 #[inline]
298 fn into_glib(self) -> ffi::SpiceSessionMigration {
299 match self {
300 Self::None => ffi::SPICE_SESSION_MIGRATION_NONE,
301 Self::Switching => ffi::SPICE_SESSION_MIGRATION_SWITCHING,
302 Self::Migrating => ffi::SPICE_SESSION_MIGRATION_MIGRATING,
303 Self::Connecting => ffi::SPICE_SESSION_MIGRATION_CONNECTING,
304 Self::__Unknown(value) => value,
305 }
306 }
307}
308
309#[doc(hidden)]
310impl FromGlib<ffi::SpiceSessionMigration> for SessionMigration {
311 #[inline]
312 unsafe fn from_glib(value: ffi::SpiceSessionMigration) -> Self {
313 skip_assert_initialized!();
314
315 match value {
316 ffi::SPICE_SESSION_MIGRATION_NONE => Self::None,
317 ffi::SPICE_SESSION_MIGRATION_SWITCHING => Self::Switching,
318 ffi::SPICE_SESSION_MIGRATION_MIGRATING => Self::Migrating,
319 ffi::SPICE_SESSION_MIGRATION_CONNECTING => Self::Connecting,
320 value => Self::__Unknown(value),
321 }
322 }
323}
324
325impl StaticType for SessionMigration {
326 #[inline]
327 #[doc(alias = "spice_session_migration_get_type")]
328 fn static_type() -> glib::Type {
329 unsafe { from_glib(ffi::spice_session_migration_get_type()) }
330 }
331}
332
333impl glib::HasParamSpec for SessionMigration {
334 type ParamSpec = glib::ParamSpecEnum;
335 type SetValue = Self;
336 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
337
338 fn param_spec_builder() -> Self::BuilderFn {
339 Self::ParamSpec::builder_with_default
340 }
341}
342
343impl glib::value::ValueType for SessionMigration {
344 type Type = Self;
345}
346
347unsafe impl<'a> glib::value::FromValue<'a> for SessionMigration {
348 type Checker = glib::value::GenericValueTypeChecker<Self>;
349
350 #[inline]
351 unsafe fn from_value(value: &'a glib::Value) -> Self {
352 skip_assert_initialized!();
353 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
354 }
355}
356
357impl ToValue for SessionMigration {
358 #[inline]
359 fn to_value(&self) -> glib::Value {
360 let mut value = glib::Value::for_value_type::<Self>();
361 unsafe {
362 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
363 }
364 value
365 }
366
367 #[inline]
368 fn value_type(&self) -> glib::Type {
369 Self::static_type()
370 }
371}
372
373impl From<SessionMigration> for glib::Value {
374 #[inline]
375 fn from(v: SessionMigration) -> Self {
376 skip_assert_initialized!();
377 ToValue::to_value(&v)
378 }
379}