1use crate::ffi;
7use glib::{prelude::*, translate::*};
8
9#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11#[non_exhaustive]
12#[doc(alias = "ALSASeqClientType")]
13pub enum ClientType {
14 #[doc(alias = "ALSASEQ_CLIENT_TYPE_NONE")]
15 None,
16 #[doc(alias = "ALSASEQ_CLIENT_TYPE_USER")]
17 User,
18 #[doc(alias = "ALSASEQ_CLIENT_TYPE_KERNEL")]
19 Kernel,
20 #[doc(hidden)]
21 __Unknown(i32),
22}
23
24#[doc(hidden)]
25impl IntoGlib for ClientType {
26 type GlibType = ffi::ALSASeqClientType;
27
28 #[inline]
29 fn into_glib(self) -> ffi::ALSASeqClientType {
30 match self {
31 Self::None => ffi::ALSASEQ_CLIENT_TYPE_NONE,
32 Self::User => ffi::ALSASEQ_CLIENT_TYPE_USER,
33 Self::Kernel => ffi::ALSASEQ_CLIENT_TYPE_KERNEL,
34 Self::__Unknown(value) => value,
35 }
36 }
37}
38
39#[doc(hidden)]
40impl FromGlib<ffi::ALSASeqClientType> for ClientType {
41 #[inline]
42 unsafe fn from_glib(value: ffi::ALSASeqClientType) -> Self {
43 match value {
44 ffi::ALSASEQ_CLIENT_TYPE_NONE => Self::None,
45 ffi::ALSASEQ_CLIENT_TYPE_USER => Self::User,
46 ffi::ALSASEQ_CLIENT_TYPE_KERNEL => Self::Kernel,
47 value => Self::__Unknown(value),
48 }
49 }
50}
51
52impl StaticType for ClientType {
53 #[inline]
54 #[doc(alias = "alsaseq_client_type_get_type")]
55 fn static_type() -> glib::Type {
56 unsafe { from_glib(ffi::alsaseq_client_type_get_type()) }
57 }
58}
59
60impl glib::HasParamSpec for ClientType {
61 type ParamSpec = glib::ParamSpecEnum;
62 type SetValue = Self;
63 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
64
65 fn param_spec_builder() -> Self::BuilderFn {
66 Self::ParamSpec::builder_with_default
67 }
68}
69
70impl glib::value::ValueType for ClientType {
71 type Type = Self;
72}
73
74unsafe impl<'a> glib::value::FromValue<'a> for ClientType {
75 type Checker = glib::value::GenericValueTypeChecker<Self>;
76
77 #[inline]
78 unsafe fn from_value(value: &'a glib::Value) -> Self {
79 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
80 }
81}
82
83impl ToValue for ClientType {
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_enum(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<ClientType> for glib::Value {
100 #[inline]
101 fn from(v: ClientType) -> Self {
102 ToValue::to_value(&v)
103 }
104}
105
106#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
108#[non_exhaustive]
109#[doc(alias = "ALSASeqEventError")]
110pub enum EventError {
111 #[doc(alias = "ALSASEQ_EVENT_ERROR_FAILED")]
112 Failed,
113 #[doc(alias = "ALSASEQ_EVENT_ERROR_INVALID_DATA_TYPE")]
114 InvalidDataType,
115 #[doc(alias = "ALSASEQ_EVENT_ERROR_INVALID_LENGTH_MODE")]
116 InvalidLengthMode,
117 #[doc(alias = "ALSASEQ_EVENT_ERROR_INVALID_TSTAMP_MODE")]
118 InvalidTstampMode,
119 #[doc(hidden)]
120 __Unknown(i32),
121}
122
123#[doc(hidden)]
124impl IntoGlib for EventError {
125 type GlibType = ffi::ALSASeqEventError;
126
127 #[inline]
128 fn into_glib(self) -> ffi::ALSASeqEventError {
129 match self {
130 Self::Failed => ffi::ALSASEQ_EVENT_ERROR_FAILED,
131 Self::InvalidDataType => ffi::ALSASEQ_EVENT_ERROR_INVALID_DATA_TYPE,
132 Self::InvalidLengthMode => ffi::ALSASEQ_EVENT_ERROR_INVALID_LENGTH_MODE,
133 Self::InvalidTstampMode => ffi::ALSASEQ_EVENT_ERROR_INVALID_TSTAMP_MODE,
134 Self::__Unknown(value) => value,
135 }
136 }
137}
138
139#[doc(hidden)]
140impl FromGlib<ffi::ALSASeqEventError> for EventError {
141 #[inline]
142 unsafe fn from_glib(value: ffi::ALSASeqEventError) -> Self {
143 match value {
144 ffi::ALSASEQ_EVENT_ERROR_FAILED => Self::Failed,
145 ffi::ALSASEQ_EVENT_ERROR_INVALID_DATA_TYPE => Self::InvalidDataType,
146 ffi::ALSASEQ_EVENT_ERROR_INVALID_LENGTH_MODE => Self::InvalidLengthMode,
147 ffi::ALSASEQ_EVENT_ERROR_INVALID_TSTAMP_MODE => Self::InvalidTstampMode,
148 value => Self::__Unknown(value),
149 }
150 }
151}
152
153impl glib::error::ErrorDomain for EventError {
154 #[inline]
155 fn domain() -> glib::Quark {
156 unsafe { from_glib(ffi::alsaseq_event_error_quark()) }
157 }
158
159 #[inline]
160 fn code(self) -> i32 {
161 self.into_glib()
162 }
163
164 #[inline]
165 #[allow(clippy::match_single_binding)]
166 fn from(code: i32) -> Option<Self> {
167 match unsafe { from_glib(code) } {
168 Self::__Unknown(_) => Some(Self::Failed),
169 value => Some(value),
170 }
171 }
172}
173
174impl StaticType for EventError {
175 #[inline]
176 #[doc(alias = "alsaseq_event_error_get_type")]
177 fn static_type() -> glib::Type {
178 unsafe { from_glib(ffi::alsaseq_event_error_get_type()) }
179 }
180}
181
182impl glib::HasParamSpec for EventError {
183 type ParamSpec = glib::ParamSpecEnum;
184 type SetValue = Self;
185 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
186
187 fn param_spec_builder() -> Self::BuilderFn {
188 Self::ParamSpec::builder_with_default
189 }
190}
191
192impl glib::value::ValueType for EventError {
193 type Type = Self;
194}
195
196unsafe impl<'a> glib::value::FromValue<'a> for EventError {
197 type Checker = glib::value::GenericValueTypeChecker<Self>;
198
199 #[inline]
200 unsafe fn from_value(value: &'a glib::Value) -> Self {
201 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
202 }
203}
204
205impl ToValue for EventError {
206 #[inline]
207 fn to_value(&self) -> glib::Value {
208 let mut value = glib::Value::for_value_type::<Self>();
209 unsafe {
210 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
211 }
212 value
213 }
214
215 #[inline]
216 fn value_type(&self) -> glib::Type {
217 Self::static_type()
218 }
219}
220
221impl From<EventError> for glib::Value {
222 #[inline]
223 fn from(v: EventError) -> Self {
224 ToValue::to_value(&v)
225 }
226}
227
228#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
230#[non_exhaustive]
231#[doc(alias = "ALSASeqEventLengthMode")]
232pub enum EventLengthMode {
233 #[doc(alias = "ALSASEQ_EVENT_LENGTH_MODE_FIXED")]
234 Fixed,
235 #[doc(alias = "ALSASEQ_EVENT_LENGTH_MODE_VARIABLE")]
236 Variable,
237 #[doc(alias = "ALSASEQ_EVENT_LENGTH_MODE_POINTER")]
238 Pointer,
239 #[doc(hidden)]
240 __Unknown(i32),
241}
242
243#[doc(hidden)]
244impl IntoGlib for EventLengthMode {
245 type GlibType = ffi::ALSASeqEventLengthMode;
246
247 #[inline]
248 fn into_glib(self) -> ffi::ALSASeqEventLengthMode {
249 match self {
250 Self::Fixed => ffi::ALSASEQ_EVENT_LENGTH_MODE_FIXED,
251 Self::Variable => ffi::ALSASEQ_EVENT_LENGTH_MODE_VARIABLE,
252 Self::Pointer => ffi::ALSASEQ_EVENT_LENGTH_MODE_POINTER,
253 Self::__Unknown(value) => value,
254 }
255 }
256}
257
258#[doc(hidden)]
259impl FromGlib<ffi::ALSASeqEventLengthMode> for EventLengthMode {
260 #[inline]
261 unsafe fn from_glib(value: ffi::ALSASeqEventLengthMode) -> Self {
262 match value {
263 ffi::ALSASEQ_EVENT_LENGTH_MODE_FIXED => Self::Fixed,
264 ffi::ALSASEQ_EVENT_LENGTH_MODE_VARIABLE => Self::Variable,
265 ffi::ALSASEQ_EVENT_LENGTH_MODE_POINTER => Self::Pointer,
266 value => Self::__Unknown(value),
267 }
268 }
269}
270
271impl StaticType for EventLengthMode {
272 #[inline]
273 #[doc(alias = "alsaseq_event_length_mode_get_type")]
274 fn static_type() -> glib::Type {
275 unsafe { from_glib(ffi::alsaseq_event_length_mode_get_type()) }
276 }
277}
278
279impl glib::HasParamSpec for EventLengthMode {
280 type ParamSpec = glib::ParamSpecEnum;
281 type SetValue = Self;
282 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
283
284 fn param_spec_builder() -> Self::BuilderFn {
285 Self::ParamSpec::builder_with_default
286 }
287}
288
289impl glib::value::ValueType for EventLengthMode {
290 type Type = Self;
291}
292
293unsafe impl<'a> glib::value::FromValue<'a> for EventLengthMode {
294 type Checker = glib::value::GenericValueTypeChecker<Self>;
295
296 #[inline]
297 unsafe fn from_value(value: &'a glib::Value) -> Self {
298 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
299 }
300}
301
302impl ToValue for EventLengthMode {
303 #[inline]
304 fn to_value(&self) -> glib::Value {
305 let mut value = glib::Value::for_value_type::<Self>();
306 unsafe {
307 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
308 }
309 value
310 }
311
312 #[inline]
313 fn value_type(&self) -> glib::Type {
314 Self::static_type()
315 }
316}
317
318impl From<EventLengthMode> for glib::Value {
319 #[inline]
320 fn from(v: EventLengthMode) -> Self {
321 ToValue::to_value(&v)
322 }
323}
324
325#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
327#[non_exhaustive]
328#[doc(alias = "ALSASeqEventPriorityMode")]
329pub enum EventPriorityMode {
330 #[doc(alias = "ALSASEQ_EVENT_PRIORITY_MODE_NORMAL")]
331 Normal,
332 #[doc(alias = "ALSASEQ_EVENT_PRIORITY_MODE_HIGH")]
333 High,
334 #[doc(hidden)]
335 __Unknown(i32),
336}
337
338#[doc(hidden)]
339impl IntoGlib for EventPriorityMode {
340 type GlibType = ffi::ALSASeqEventPriorityMode;
341
342 #[inline]
343 fn into_glib(self) -> ffi::ALSASeqEventPriorityMode {
344 match self {
345 Self::Normal => ffi::ALSASEQ_EVENT_PRIORITY_MODE_NORMAL,
346 Self::High => ffi::ALSASEQ_EVENT_PRIORITY_MODE_HIGH,
347 Self::__Unknown(value) => value,
348 }
349 }
350}
351
352#[doc(hidden)]
353impl FromGlib<ffi::ALSASeqEventPriorityMode> for EventPriorityMode {
354 #[inline]
355 unsafe fn from_glib(value: ffi::ALSASeqEventPriorityMode) -> Self {
356 match value {
357 ffi::ALSASEQ_EVENT_PRIORITY_MODE_NORMAL => Self::Normal,
358 ffi::ALSASEQ_EVENT_PRIORITY_MODE_HIGH => Self::High,
359 value => Self::__Unknown(value),
360 }
361 }
362}
363
364impl StaticType for EventPriorityMode {
365 #[inline]
366 #[doc(alias = "alsaseq_event_priority_mode_get_type")]
367 fn static_type() -> glib::Type {
368 unsafe { from_glib(ffi::alsaseq_event_priority_mode_get_type()) }
369 }
370}
371
372impl glib::HasParamSpec for EventPriorityMode {
373 type ParamSpec = glib::ParamSpecEnum;
374 type SetValue = Self;
375 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
376
377 fn param_spec_builder() -> Self::BuilderFn {
378 Self::ParamSpec::builder_with_default
379 }
380}
381
382impl glib::value::ValueType for EventPriorityMode {
383 type Type = Self;
384}
385
386unsafe impl<'a> glib::value::FromValue<'a> for EventPriorityMode {
387 type Checker = glib::value::GenericValueTypeChecker<Self>;
388
389 #[inline]
390 unsafe fn from_value(value: &'a glib::Value) -> Self {
391 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
392 }
393}
394
395impl ToValue for EventPriorityMode {
396 #[inline]
397 fn to_value(&self) -> glib::Value {
398 let mut value = glib::Value::for_value_type::<Self>();
399 unsafe {
400 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
401 }
402 value
403 }
404
405 #[inline]
406 fn value_type(&self) -> glib::Type {
407 Self::static_type()
408 }
409}
410
411impl From<EventPriorityMode> for glib::Value {
412 #[inline]
413 fn from(v: EventPriorityMode) -> Self {
414 ToValue::to_value(&v)
415 }
416}
417
418#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
420#[non_exhaustive]
421#[doc(alias = "ALSASeqEventTimeMode")]
422pub enum EventTimeMode {
423 #[doc(alias = "ALSASEQ_EVENT_TIME_MODE_ABS")]
424 Abs,
425 #[doc(alias = "ALSASEQ_EVENT_TIME_MODE_REL")]
426 Rel,
427 #[doc(hidden)]
428 __Unknown(i32),
429}
430
431#[doc(hidden)]
432impl IntoGlib for EventTimeMode {
433 type GlibType = ffi::ALSASeqEventTimeMode;
434
435 #[inline]
436 fn into_glib(self) -> ffi::ALSASeqEventTimeMode {
437 match self {
438 Self::Abs => ffi::ALSASEQ_EVENT_TIME_MODE_ABS,
439 Self::Rel => ffi::ALSASEQ_EVENT_TIME_MODE_REL,
440 Self::__Unknown(value) => value,
441 }
442 }
443}
444
445#[doc(hidden)]
446impl FromGlib<ffi::ALSASeqEventTimeMode> for EventTimeMode {
447 #[inline]
448 unsafe fn from_glib(value: ffi::ALSASeqEventTimeMode) -> Self {
449 match value {
450 ffi::ALSASEQ_EVENT_TIME_MODE_ABS => Self::Abs,
451 ffi::ALSASEQ_EVENT_TIME_MODE_REL => Self::Rel,
452 value => Self::__Unknown(value),
453 }
454 }
455}
456
457impl StaticType for EventTimeMode {
458 #[inline]
459 #[doc(alias = "alsaseq_event_time_mode_get_type")]
460 fn static_type() -> glib::Type {
461 unsafe { from_glib(ffi::alsaseq_event_time_mode_get_type()) }
462 }
463}
464
465impl glib::HasParamSpec for EventTimeMode {
466 type ParamSpec = glib::ParamSpecEnum;
467 type SetValue = Self;
468 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
469
470 fn param_spec_builder() -> Self::BuilderFn {
471 Self::ParamSpec::builder_with_default
472 }
473}
474
475impl glib::value::ValueType for EventTimeMode {
476 type Type = Self;
477}
478
479unsafe impl<'a> glib::value::FromValue<'a> for EventTimeMode {
480 type Checker = glib::value::GenericValueTypeChecker<Self>;
481
482 #[inline]
483 unsafe fn from_value(value: &'a glib::Value) -> Self {
484 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
485 }
486}
487
488impl ToValue for EventTimeMode {
489 #[inline]
490 fn to_value(&self) -> glib::Value {
491 let mut value = glib::Value::for_value_type::<Self>();
492 unsafe {
493 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
494 }
495 value
496 }
497
498 #[inline]
499 fn value_type(&self) -> glib::Type {
500 Self::static_type()
501 }
502}
503
504impl From<EventTimeMode> for glib::Value {
505 #[inline]
506 fn from(v: EventTimeMode) -> Self {
507 ToValue::to_value(&v)
508 }
509}
510
511#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
513#[non_exhaustive]
514#[doc(alias = "ALSASeqEventTstampMode")]
515pub enum EventTstampMode {
516 #[doc(alias = "ALSASEQ_EVENT_TSTAMP_MODE_TICK")]
517 Tick,
518 #[doc(alias = "ALSASEQ_EVENT_TSTAMP_MODE_REAL")]
519 Real,
520 #[doc(hidden)]
521 __Unknown(i32),
522}
523
524#[doc(hidden)]
525impl IntoGlib for EventTstampMode {
526 type GlibType = ffi::ALSASeqEventTstampMode;
527
528 #[inline]
529 fn into_glib(self) -> ffi::ALSASeqEventTstampMode {
530 match self {
531 Self::Tick => ffi::ALSASEQ_EVENT_TSTAMP_MODE_TICK,
532 Self::Real => ffi::ALSASEQ_EVENT_TSTAMP_MODE_REAL,
533 Self::__Unknown(value) => value,
534 }
535 }
536}
537
538#[doc(hidden)]
539impl FromGlib<ffi::ALSASeqEventTstampMode> for EventTstampMode {
540 #[inline]
541 unsafe fn from_glib(value: ffi::ALSASeqEventTstampMode) -> Self {
542 match value {
543 ffi::ALSASEQ_EVENT_TSTAMP_MODE_TICK => Self::Tick,
544 ffi::ALSASEQ_EVENT_TSTAMP_MODE_REAL => Self::Real,
545 value => Self::__Unknown(value),
546 }
547 }
548}
549
550impl StaticType for EventTstampMode {
551 #[inline]
552 #[doc(alias = "alsaseq_event_tstamp_mode_get_type")]
553 fn static_type() -> glib::Type {
554 unsafe { from_glib(ffi::alsaseq_event_tstamp_mode_get_type()) }
555 }
556}
557
558impl glib::HasParamSpec for EventTstampMode {
559 type ParamSpec = glib::ParamSpecEnum;
560 type SetValue = Self;
561 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
562
563 fn param_spec_builder() -> Self::BuilderFn {
564 Self::ParamSpec::builder_with_default
565 }
566}
567
568impl glib::value::ValueType for EventTstampMode {
569 type Type = Self;
570}
571
572unsafe impl<'a> glib::value::FromValue<'a> for EventTstampMode {
573 type Checker = glib::value::GenericValueTypeChecker<Self>;
574
575 #[inline]
576 unsafe fn from_value(value: &'a glib::Value) -> Self {
577 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
578 }
579}
580
581impl ToValue for EventTstampMode {
582 #[inline]
583 fn to_value(&self) -> glib::Value {
584 let mut value = glib::Value::for_value_type::<Self>();
585 unsafe {
586 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
587 }
588 value
589 }
590
591 #[inline]
592 fn value_type(&self) -> glib::Type {
593 Self::static_type()
594 }
595}
596
597impl From<EventTstampMode> for glib::Value {
598 #[inline]
599 fn from(v: EventTstampMode) -> Self {
600 ToValue::to_value(&v)
601 }
602}
603
604#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
606#[non_exhaustive]
607#[doc(alias = "ALSASeqEventType")]
608pub enum EventType {
609 #[doc(alias = "ALSASEQ_EVENT_TYPE_SYSTEM")]
610 System,
611 #[doc(alias = "ALSASEQ_EVENT_TYPE_RESULT")]
612 Result,
613 #[doc(alias = "ALSASEQ_EVENT_TYPE_NOTE")]
614 Note,
615 #[doc(alias = "ALSASEQ_EVENT_TYPE_NOTEON")]
616 Noteon,
617 #[doc(alias = "ALSASEQ_EVENT_TYPE_NOTEOFF")]
618 Noteoff,
619 #[doc(alias = "ALSASEQ_EVENT_TYPE_KEYPRESS")]
620 Keypress,
621 #[doc(alias = "ALSASEQ_EVENT_TYPE_CONTROLLER")]
622 Controller,
623 #[doc(alias = "ALSASEQ_EVENT_TYPE_PGMCHANGE")]
624 Pgmchange,
625 #[doc(alias = "ALSASEQ_EVENT_TYPE_CHANPRESS")]
626 Chanpress,
627 #[doc(alias = "ALSASEQ_EVENT_TYPE_PITCHBEND")]
628 Pitchbend,
629 #[doc(alias = "ALSASEQ_EVENT_TYPE_CONTROL14")]
630 Control14,
631 #[doc(alias = "ALSASEQ_EVENT_TYPE_NONREGPARAM")]
632 Nonregparam,
633 #[doc(alias = "ALSASEQ_EVENT_TYPE_REGPARAM")]
634 Regparam,
635 #[doc(alias = "ALSASEQ_EVENT_TYPE_SONGPOS")]
636 Songpos,
637 #[doc(alias = "ALSASEQ_EVENT_TYPE_SONGSEL")]
638 Songsel,
639 #[doc(alias = "ALSASEQ_EVENT_TYPE_QFRAME")]
640 Qframe,
641 #[doc(alias = "ALSASEQ_EVENT_TYPE_TIMESIGN")]
642 Timesign,
643 #[doc(alias = "ALSASEQ_EVENT_TYPE_KEYSIGN")]
644 Keysign,
645 #[doc(alias = "ALSASEQ_EVENT_TYPE_START")]
646 Start,
647 #[doc(alias = "ALSASEQ_EVENT_TYPE_CONTINUE")]
648 Continue,
649 #[doc(alias = "ALSASEQ_EVENT_TYPE_STOP")]
650 Stop,
651 #[doc(alias = "ALSASEQ_EVENT_TYPE_SETPOS_TICK")]
652 SetposTick,
653 #[doc(alias = "ALSASEQ_EVENT_TYPE_SETPOS_TIME")]
654 SetposTime,
655 #[doc(alias = "ALSASEQ_EVENT_TYPE_TEMPO")]
656 Tempo,
657 #[doc(alias = "ALSASEQ_EVENT_TYPE_CLOCK")]
658 Clock,
659 #[doc(alias = "ALSASEQ_EVENT_TYPE_TICK")]
660 Tick,
661 #[doc(alias = "ALSASEQ_EVENT_TYPE_QUEUE_SKEW")]
662 QueueSkew,
663 #[doc(alias = "ALSASEQ_EVENT_TYPE_TUNE_REQUEST")]
664 TuneRequest,
665 #[doc(alias = "ALSASEQ_EVENT_TYPE_RESET")]
666 Reset,
667 #[doc(alias = "ALSASEQ_EVENT_TYPE_SENSING")]
668 Sensing,
669 #[doc(alias = "ALSASEQ_EVENT_TYPE_ECHO")]
670 Echo,
671 #[doc(alias = "ALSASEQ_EVENT_TYPE_OSS")]
672 Oss,
673 #[doc(alias = "ALSASEQ_EVENT_TYPE_CLIENT_START")]
674 ClientStart,
675 #[doc(alias = "ALSASEQ_EVENT_TYPE_CLIENT_EXIT")]
676 ClientExit,
677 #[doc(alias = "ALSASEQ_EVENT_TYPE_CLIENT_CHANGE")]
678 ClientChange,
679 #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_START")]
680 PortStart,
681 #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_EXIT")]
682 PortExit,
683 #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_CHANGE")]
684 PortChange,
685 #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_SUBSCRIBED")]
686 PortSubscribed,
687 #[doc(alias = "ALSASEQ_EVENT_TYPE_PORT_UNSUBSCRIBED")]
688 PortUnsubscribed,
689 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR0")]
690 Usr0,
691 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR1")]
692 Usr1,
693 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR2")]
694 Usr2,
695 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR3")]
696 Usr3,
697 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR4")]
698 Usr4,
699 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR5")]
700 Usr5,
701 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR6")]
702 Usr6,
703 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR7")]
704 Usr7,
705 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR8")]
706 Usr8,
707 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR9")]
708 Usr9,
709 #[doc(alias = "ALSASEQ_EVENT_TYPE_SYSEX")]
710 Sysex,
711 #[doc(alias = "ALSASEQ_EVENT_TYPE_BOUNCE")]
712 Bounce,
713 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR0")]
714 UsrVar0,
715 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR1")]
716 UsrVar1,
717 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR2")]
718 UsrVar2,
719 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR3")]
720 UsrVar3,
721 #[doc(alias = "ALSASEQ_EVENT_TYPE_USR_VAR4")]
722 UsrVar4,
723 #[doc(alias = "ALSASEQ_EVENT_TYPE_NONE")]
724 None,
725 #[doc(hidden)]
726 __Unknown(i32),
727}
728
729#[doc(hidden)]
730impl IntoGlib for EventType {
731 type GlibType = ffi::ALSASeqEventType;
732
733 fn into_glib(self) -> ffi::ALSASeqEventType {
734 match self {
735 Self::System => ffi::ALSASEQ_EVENT_TYPE_SYSTEM,
736 Self::Result => ffi::ALSASEQ_EVENT_TYPE_RESULT,
737 Self::Note => ffi::ALSASEQ_EVENT_TYPE_NOTE,
738 Self::Noteon => ffi::ALSASEQ_EVENT_TYPE_NOTEON,
739 Self::Noteoff => ffi::ALSASEQ_EVENT_TYPE_NOTEOFF,
740 Self::Keypress => ffi::ALSASEQ_EVENT_TYPE_KEYPRESS,
741 Self::Controller => ffi::ALSASEQ_EVENT_TYPE_CONTROLLER,
742 Self::Pgmchange => ffi::ALSASEQ_EVENT_TYPE_PGMCHANGE,
743 Self::Chanpress => ffi::ALSASEQ_EVENT_TYPE_CHANPRESS,
744 Self::Pitchbend => ffi::ALSASEQ_EVENT_TYPE_PITCHBEND,
745 Self::Control14 => ffi::ALSASEQ_EVENT_TYPE_CONTROL14,
746 Self::Nonregparam => ffi::ALSASEQ_EVENT_TYPE_NONREGPARAM,
747 Self::Regparam => ffi::ALSASEQ_EVENT_TYPE_REGPARAM,
748 Self::Songpos => ffi::ALSASEQ_EVENT_TYPE_SONGPOS,
749 Self::Songsel => ffi::ALSASEQ_EVENT_TYPE_SONGSEL,
750 Self::Qframe => ffi::ALSASEQ_EVENT_TYPE_QFRAME,
751 Self::Timesign => ffi::ALSASEQ_EVENT_TYPE_TIMESIGN,
752 Self::Keysign => ffi::ALSASEQ_EVENT_TYPE_KEYSIGN,
753 Self::Start => ffi::ALSASEQ_EVENT_TYPE_START,
754 Self::Continue => ffi::ALSASEQ_EVENT_TYPE_CONTINUE,
755 Self::Stop => ffi::ALSASEQ_EVENT_TYPE_STOP,
756 Self::SetposTick => ffi::ALSASEQ_EVENT_TYPE_SETPOS_TICK,
757 Self::SetposTime => ffi::ALSASEQ_EVENT_TYPE_SETPOS_TIME,
758 Self::Tempo => ffi::ALSASEQ_EVENT_TYPE_TEMPO,
759 Self::Clock => ffi::ALSASEQ_EVENT_TYPE_CLOCK,
760 Self::Tick => ffi::ALSASEQ_EVENT_TYPE_TICK,
761 Self::QueueSkew => ffi::ALSASEQ_EVENT_TYPE_QUEUE_SKEW,
762 Self::TuneRequest => ffi::ALSASEQ_EVENT_TYPE_TUNE_REQUEST,
763 Self::Reset => ffi::ALSASEQ_EVENT_TYPE_RESET,
764 Self::Sensing => ffi::ALSASEQ_EVENT_TYPE_SENSING,
765 Self::Echo => ffi::ALSASEQ_EVENT_TYPE_ECHO,
766 Self::Oss => ffi::ALSASEQ_EVENT_TYPE_OSS,
767 Self::ClientStart => ffi::ALSASEQ_EVENT_TYPE_CLIENT_START,
768 Self::ClientExit => ffi::ALSASEQ_EVENT_TYPE_CLIENT_EXIT,
769 Self::ClientChange => ffi::ALSASEQ_EVENT_TYPE_CLIENT_CHANGE,
770 Self::PortStart => ffi::ALSASEQ_EVENT_TYPE_PORT_START,
771 Self::PortExit => ffi::ALSASEQ_EVENT_TYPE_PORT_EXIT,
772 Self::PortChange => ffi::ALSASEQ_EVENT_TYPE_PORT_CHANGE,
773 Self::PortSubscribed => ffi::ALSASEQ_EVENT_TYPE_PORT_SUBSCRIBED,
774 Self::PortUnsubscribed => ffi::ALSASEQ_EVENT_TYPE_PORT_UNSUBSCRIBED,
775 Self::Usr0 => ffi::ALSASEQ_EVENT_TYPE_USR0,
776 Self::Usr1 => ffi::ALSASEQ_EVENT_TYPE_USR1,
777 Self::Usr2 => ffi::ALSASEQ_EVENT_TYPE_USR2,
778 Self::Usr3 => ffi::ALSASEQ_EVENT_TYPE_USR3,
779 Self::Usr4 => ffi::ALSASEQ_EVENT_TYPE_USR4,
780 Self::Usr5 => ffi::ALSASEQ_EVENT_TYPE_USR5,
781 Self::Usr6 => ffi::ALSASEQ_EVENT_TYPE_USR6,
782 Self::Usr7 => ffi::ALSASEQ_EVENT_TYPE_USR7,
783 Self::Usr8 => ffi::ALSASEQ_EVENT_TYPE_USR8,
784 Self::Usr9 => ffi::ALSASEQ_EVENT_TYPE_USR9,
785 Self::Sysex => ffi::ALSASEQ_EVENT_TYPE_SYSEX,
786 Self::Bounce => ffi::ALSASEQ_EVENT_TYPE_BOUNCE,
787 Self::UsrVar0 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR0,
788 Self::UsrVar1 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR1,
789 Self::UsrVar2 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR2,
790 Self::UsrVar3 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR3,
791 Self::UsrVar4 => ffi::ALSASEQ_EVENT_TYPE_USR_VAR4,
792 Self::None => ffi::ALSASEQ_EVENT_TYPE_NONE,
793 Self::__Unknown(value) => value,
794 }
795 }
796}
797
798#[doc(hidden)]
799impl FromGlib<ffi::ALSASeqEventType> for EventType {
800 unsafe fn from_glib(value: ffi::ALSASeqEventType) -> Self {
801 match value {
802 ffi::ALSASEQ_EVENT_TYPE_SYSTEM => Self::System,
803 ffi::ALSASEQ_EVENT_TYPE_RESULT => Self::Result,
804 ffi::ALSASEQ_EVENT_TYPE_NOTE => Self::Note,
805 ffi::ALSASEQ_EVENT_TYPE_NOTEON => Self::Noteon,
806 ffi::ALSASEQ_EVENT_TYPE_NOTEOFF => Self::Noteoff,
807 ffi::ALSASEQ_EVENT_TYPE_KEYPRESS => Self::Keypress,
808 ffi::ALSASEQ_EVENT_TYPE_CONTROLLER => Self::Controller,
809 ffi::ALSASEQ_EVENT_TYPE_PGMCHANGE => Self::Pgmchange,
810 ffi::ALSASEQ_EVENT_TYPE_CHANPRESS => Self::Chanpress,
811 ffi::ALSASEQ_EVENT_TYPE_PITCHBEND => Self::Pitchbend,
812 ffi::ALSASEQ_EVENT_TYPE_CONTROL14 => Self::Control14,
813 ffi::ALSASEQ_EVENT_TYPE_NONREGPARAM => Self::Nonregparam,
814 ffi::ALSASEQ_EVENT_TYPE_REGPARAM => Self::Regparam,
815 ffi::ALSASEQ_EVENT_TYPE_SONGPOS => Self::Songpos,
816 ffi::ALSASEQ_EVENT_TYPE_SONGSEL => Self::Songsel,
817 ffi::ALSASEQ_EVENT_TYPE_QFRAME => Self::Qframe,
818 ffi::ALSASEQ_EVENT_TYPE_TIMESIGN => Self::Timesign,
819 ffi::ALSASEQ_EVENT_TYPE_KEYSIGN => Self::Keysign,
820 ffi::ALSASEQ_EVENT_TYPE_START => Self::Start,
821 ffi::ALSASEQ_EVENT_TYPE_CONTINUE => Self::Continue,
822 ffi::ALSASEQ_EVENT_TYPE_STOP => Self::Stop,
823 ffi::ALSASEQ_EVENT_TYPE_SETPOS_TICK => Self::SetposTick,
824 ffi::ALSASEQ_EVENT_TYPE_SETPOS_TIME => Self::SetposTime,
825 ffi::ALSASEQ_EVENT_TYPE_TEMPO => Self::Tempo,
826 ffi::ALSASEQ_EVENT_TYPE_CLOCK => Self::Clock,
827 ffi::ALSASEQ_EVENT_TYPE_TICK => Self::Tick,
828 ffi::ALSASEQ_EVENT_TYPE_QUEUE_SKEW => Self::QueueSkew,
829 ffi::ALSASEQ_EVENT_TYPE_TUNE_REQUEST => Self::TuneRequest,
830 ffi::ALSASEQ_EVENT_TYPE_RESET => Self::Reset,
831 ffi::ALSASEQ_EVENT_TYPE_SENSING => Self::Sensing,
832 ffi::ALSASEQ_EVENT_TYPE_ECHO => Self::Echo,
833 ffi::ALSASEQ_EVENT_TYPE_OSS => Self::Oss,
834 ffi::ALSASEQ_EVENT_TYPE_CLIENT_START => Self::ClientStart,
835 ffi::ALSASEQ_EVENT_TYPE_CLIENT_EXIT => Self::ClientExit,
836 ffi::ALSASEQ_EVENT_TYPE_CLIENT_CHANGE => Self::ClientChange,
837 ffi::ALSASEQ_EVENT_TYPE_PORT_START => Self::PortStart,
838 ffi::ALSASEQ_EVENT_TYPE_PORT_EXIT => Self::PortExit,
839 ffi::ALSASEQ_EVENT_TYPE_PORT_CHANGE => Self::PortChange,
840 ffi::ALSASEQ_EVENT_TYPE_PORT_SUBSCRIBED => Self::PortSubscribed,
841 ffi::ALSASEQ_EVENT_TYPE_PORT_UNSUBSCRIBED => Self::PortUnsubscribed,
842 ffi::ALSASEQ_EVENT_TYPE_USR0 => Self::Usr0,
843 ffi::ALSASEQ_EVENT_TYPE_USR1 => Self::Usr1,
844 ffi::ALSASEQ_EVENT_TYPE_USR2 => Self::Usr2,
845 ffi::ALSASEQ_EVENT_TYPE_USR3 => Self::Usr3,
846 ffi::ALSASEQ_EVENT_TYPE_USR4 => Self::Usr4,
847 ffi::ALSASEQ_EVENT_TYPE_USR5 => Self::Usr5,
848 ffi::ALSASEQ_EVENT_TYPE_USR6 => Self::Usr6,
849 ffi::ALSASEQ_EVENT_TYPE_USR7 => Self::Usr7,
850 ffi::ALSASEQ_EVENT_TYPE_USR8 => Self::Usr8,
851 ffi::ALSASEQ_EVENT_TYPE_USR9 => Self::Usr9,
852 ffi::ALSASEQ_EVENT_TYPE_SYSEX => Self::Sysex,
853 ffi::ALSASEQ_EVENT_TYPE_BOUNCE => Self::Bounce,
854 ffi::ALSASEQ_EVENT_TYPE_USR_VAR0 => Self::UsrVar0,
855 ffi::ALSASEQ_EVENT_TYPE_USR_VAR1 => Self::UsrVar1,
856 ffi::ALSASEQ_EVENT_TYPE_USR_VAR2 => Self::UsrVar2,
857 ffi::ALSASEQ_EVENT_TYPE_USR_VAR3 => Self::UsrVar3,
858 ffi::ALSASEQ_EVENT_TYPE_USR_VAR4 => Self::UsrVar4,
859 ffi::ALSASEQ_EVENT_TYPE_NONE => Self::None,
860 value => Self::__Unknown(value),
861 }
862 }
863}
864
865impl StaticType for EventType {
866 #[inline]
867 #[doc(alias = "alsaseq_event_type_get_type")]
868 fn static_type() -> glib::Type {
869 unsafe { from_glib(ffi::alsaseq_event_type_get_type()) }
870 }
871}
872
873impl glib::HasParamSpec for EventType {
874 type ParamSpec = glib::ParamSpecEnum;
875 type SetValue = Self;
876 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
877
878 fn param_spec_builder() -> Self::BuilderFn {
879 Self::ParamSpec::builder_with_default
880 }
881}
882
883impl glib::value::ValueType for EventType {
884 type Type = Self;
885}
886
887unsafe impl<'a> glib::value::FromValue<'a> for EventType {
888 type Checker = glib::value::GenericValueTypeChecker<Self>;
889
890 #[inline]
891 unsafe fn from_value(value: &'a glib::Value) -> Self {
892 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
893 }
894}
895
896impl ToValue for EventType {
897 #[inline]
898 fn to_value(&self) -> glib::Value {
899 let mut value = glib::Value::for_value_type::<Self>();
900 unsafe {
901 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
902 }
903 value
904 }
905
906 #[inline]
907 fn value_type(&self) -> glib::Type {
908 Self::static_type()
909 }
910}
911
912impl From<EventType> for glib::Value {
913 #[inline]
914 fn from(v: EventType) -> Self {
915 ToValue::to_value(&v)
916 }
917}
918
919#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
921#[non_exhaustive]
922#[doc(alias = "ALSASeqQuerySubscribeType")]
923pub enum QuerySubscribeType {
924 #[doc(alias = "ALSASEQ_QUERY_SUBSCRIBE_TYPE_READ")]
925 Read,
926 #[doc(alias = "ALSASEQ_QUERY_SUBSCRIBE_TYPE_WRITE")]
927 Write,
928 #[doc(hidden)]
929 __Unknown(i32),
930}
931
932#[doc(hidden)]
933impl IntoGlib for QuerySubscribeType {
934 type GlibType = ffi::ALSASeqQuerySubscribeType;
935
936 #[inline]
937 fn into_glib(self) -> ffi::ALSASeqQuerySubscribeType {
938 match self {
939 Self::Read => ffi::ALSASEQ_QUERY_SUBSCRIBE_TYPE_READ,
940 Self::Write => ffi::ALSASEQ_QUERY_SUBSCRIBE_TYPE_WRITE,
941 Self::__Unknown(value) => value,
942 }
943 }
944}
945
946#[doc(hidden)]
947impl FromGlib<ffi::ALSASeqQuerySubscribeType> for QuerySubscribeType {
948 #[inline]
949 unsafe fn from_glib(value: ffi::ALSASeqQuerySubscribeType) -> Self {
950 match value {
951 ffi::ALSASEQ_QUERY_SUBSCRIBE_TYPE_READ => Self::Read,
952 ffi::ALSASEQ_QUERY_SUBSCRIBE_TYPE_WRITE => Self::Write,
953 value => Self::__Unknown(value),
954 }
955 }
956}
957
958impl StaticType for QuerySubscribeType {
959 #[inline]
960 #[doc(alias = "alsaseq_query_subscribe_type_get_type")]
961 fn static_type() -> glib::Type {
962 unsafe { from_glib(ffi::alsaseq_query_subscribe_type_get_type()) }
963 }
964}
965
966impl glib::HasParamSpec for QuerySubscribeType {
967 type ParamSpec = glib::ParamSpecEnum;
968 type SetValue = Self;
969 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
970
971 fn param_spec_builder() -> Self::BuilderFn {
972 Self::ParamSpec::builder_with_default
973 }
974}
975
976impl glib::value::ValueType for QuerySubscribeType {
977 type Type = Self;
978}
979
980unsafe impl<'a> glib::value::FromValue<'a> for QuerySubscribeType {
981 type Checker = glib::value::GenericValueTypeChecker<Self>;
982
983 #[inline]
984 unsafe fn from_value(value: &'a glib::Value) -> Self {
985 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
986 }
987}
988
989impl ToValue for QuerySubscribeType {
990 #[inline]
991 fn to_value(&self) -> glib::Value {
992 let mut value = glib::Value::for_value_type::<Self>();
993 unsafe {
994 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
995 }
996 value
997 }
998
999 #[inline]
1000 fn value_type(&self) -> glib::Type {
1001 Self::static_type()
1002 }
1003}
1004
1005impl From<QuerySubscribeType> for glib::Value {
1006 #[inline]
1007 fn from(v: QuerySubscribeType) -> Self {
1008 ToValue::to_value(&v)
1009 }
1010}
1011
1012#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1014#[non_exhaustive]
1015#[doc(alias = "ALSASeqQueueTimerType")]
1016pub enum QueueTimerType {
1017 #[doc(alias = "ALSASEQ_QUEUE_TIMER_TYPE_ALSA")]
1018 Alsa,
1019 #[doc(hidden)]
1020 __Unknown(i32),
1021}
1022
1023#[doc(hidden)]
1024impl IntoGlib for QueueTimerType {
1025 type GlibType = ffi::ALSASeqQueueTimerType;
1026
1027 #[inline]
1028 fn into_glib(self) -> ffi::ALSASeqQueueTimerType {
1029 match self {
1030 Self::Alsa => ffi::ALSASEQ_QUEUE_TIMER_TYPE_ALSA,
1031 Self::__Unknown(value) => value,
1032 }
1033 }
1034}
1035
1036#[doc(hidden)]
1037impl FromGlib<ffi::ALSASeqQueueTimerType> for QueueTimerType {
1038 #[inline]
1039 unsafe fn from_glib(value: ffi::ALSASeqQueueTimerType) -> Self {
1040 match value {
1041 ffi::ALSASEQ_QUEUE_TIMER_TYPE_ALSA => Self::Alsa,
1042 value => Self::__Unknown(value),
1043 }
1044 }
1045}
1046
1047impl StaticType for QueueTimerType {
1048 #[inline]
1049 #[doc(alias = "alsaseq_queue_timer_type_get_type")]
1050 fn static_type() -> glib::Type {
1051 unsafe { from_glib(ffi::alsaseq_queue_timer_type_get_type()) }
1052 }
1053}
1054
1055impl glib::HasParamSpec for QueueTimerType {
1056 type ParamSpec = glib::ParamSpecEnum;
1057 type SetValue = Self;
1058 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1059
1060 fn param_spec_builder() -> Self::BuilderFn {
1061 Self::ParamSpec::builder_with_default
1062 }
1063}
1064
1065impl glib::value::ValueType for QueueTimerType {
1066 type Type = Self;
1067}
1068
1069unsafe impl<'a> glib::value::FromValue<'a> for QueueTimerType {
1070 type Checker = glib::value::GenericValueTypeChecker<Self>;
1071
1072 #[inline]
1073 unsafe fn from_value(value: &'a glib::Value) -> Self {
1074 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1075 }
1076}
1077
1078impl ToValue for QueueTimerType {
1079 #[inline]
1080 fn to_value(&self) -> glib::Value {
1081 let mut value = glib::Value::for_value_type::<Self>();
1082 unsafe {
1083 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1084 }
1085 value
1086 }
1087
1088 #[inline]
1089 fn value_type(&self) -> glib::Type {
1090 Self::static_type()
1091 }
1092}
1093
1094impl From<QueueTimerType> for glib::Value {
1095 #[inline]
1096 fn from(v: QueueTimerType) -> Self {
1097 ToValue::to_value(&v)
1098 }
1099}
1100
1101#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1103#[non_exhaustive]
1104#[doc(alias = "ALSASeqSpecificAddress")]
1105pub enum SpecificAddress {
1106 #[doc(alias = "ALSASEQ_SPECIFIC_ADDRESS_UNKNOWN")]
1107 Unknown,
1108 #[doc(alias = "ALSASEQ_SPECIFIC_ADDRESS_SUBSCRIBERS")]
1109 Subscribers,
1110 #[doc(alias = "ALSASEQ_SPECIFIC_ADDRESS_BROADCAST")]
1111 Broadcast,
1112 #[doc(hidden)]
1113 __Unknown(i32),
1114}
1115
1116#[doc(hidden)]
1117impl IntoGlib for SpecificAddress {
1118 type GlibType = ffi::ALSASeqSpecificAddress;
1119
1120 #[inline]
1121 fn into_glib(self) -> ffi::ALSASeqSpecificAddress {
1122 match self {
1123 Self::Unknown => ffi::ALSASEQ_SPECIFIC_ADDRESS_UNKNOWN,
1124 Self::Subscribers => ffi::ALSASEQ_SPECIFIC_ADDRESS_SUBSCRIBERS,
1125 Self::Broadcast => ffi::ALSASEQ_SPECIFIC_ADDRESS_BROADCAST,
1126 Self::__Unknown(value) => value,
1127 }
1128 }
1129}
1130
1131#[doc(hidden)]
1132impl FromGlib<ffi::ALSASeqSpecificAddress> for SpecificAddress {
1133 #[inline]
1134 unsafe fn from_glib(value: ffi::ALSASeqSpecificAddress) -> Self {
1135 match value {
1136 ffi::ALSASEQ_SPECIFIC_ADDRESS_UNKNOWN => Self::Unknown,
1137 ffi::ALSASEQ_SPECIFIC_ADDRESS_SUBSCRIBERS => Self::Subscribers,
1138 ffi::ALSASEQ_SPECIFIC_ADDRESS_BROADCAST => Self::Broadcast,
1139 value => Self::__Unknown(value),
1140 }
1141 }
1142}
1143
1144impl StaticType for SpecificAddress {
1145 #[inline]
1146 #[doc(alias = "alsaseq_specific_address_get_type")]
1147 fn static_type() -> glib::Type {
1148 unsafe { from_glib(ffi::alsaseq_specific_address_get_type()) }
1149 }
1150}
1151
1152impl glib::HasParamSpec for SpecificAddress {
1153 type ParamSpec = glib::ParamSpecEnum;
1154 type SetValue = Self;
1155 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1156
1157 fn param_spec_builder() -> Self::BuilderFn {
1158 Self::ParamSpec::builder_with_default
1159 }
1160}
1161
1162impl glib::value::ValueType for SpecificAddress {
1163 type Type = Self;
1164}
1165
1166unsafe impl<'a> glib::value::FromValue<'a> for SpecificAddress {
1167 type Checker = glib::value::GenericValueTypeChecker<Self>;
1168
1169 #[inline]
1170 unsafe fn from_value(value: &'a glib::Value) -> Self {
1171 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1172 }
1173}
1174
1175impl ToValue for SpecificAddress {
1176 #[inline]
1177 fn to_value(&self) -> glib::Value {
1178 let mut value = glib::Value::for_value_type::<Self>();
1179 unsafe {
1180 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1181 }
1182 value
1183 }
1184
1185 #[inline]
1186 fn value_type(&self) -> glib::Type {
1187 Self::static_type()
1188 }
1189}
1190
1191impl From<SpecificAddress> for glib::Value {
1192 #[inline]
1193 fn from(v: SpecificAddress) -> Self {
1194 ToValue::to_value(&v)
1195 }
1196}
1197
1198#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1200#[non_exhaustive]
1201#[doc(alias = "ALSASeqSpecificClientId")]
1202pub enum SpecificClientId {
1203 #[doc(alias = "ALSASEQ_SPECIFIC_CLIENT_ID_SYSTEM")]
1204 System,
1205 #[doc(alias = "ALSASEQ_SPECIFIC_CLIENT_ID_DUMMY")]
1206 Dummy,
1207 #[doc(alias = "ALSASEQ_SPECIFIC_CLIENT_ID_OSS")]
1208 Oss,
1209 #[doc(hidden)]
1210 __Unknown(i32),
1211}
1212
1213#[doc(hidden)]
1214impl IntoGlib for SpecificClientId {
1215 type GlibType = ffi::ALSASeqSpecificClientId;
1216
1217 #[inline]
1218 fn into_glib(self) -> ffi::ALSASeqSpecificClientId {
1219 match self {
1220 Self::System => ffi::ALSASEQ_SPECIFIC_CLIENT_ID_SYSTEM,
1221 Self::Dummy => ffi::ALSASEQ_SPECIFIC_CLIENT_ID_DUMMY,
1222 Self::Oss => ffi::ALSASEQ_SPECIFIC_CLIENT_ID_OSS,
1223 Self::__Unknown(value) => value,
1224 }
1225 }
1226}
1227
1228#[doc(hidden)]
1229impl FromGlib<ffi::ALSASeqSpecificClientId> for SpecificClientId {
1230 #[inline]
1231 unsafe fn from_glib(value: ffi::ALSASeqSpecificClientId) -> Self {
1232 match value {
1233 ffi::ALSASEQ_SPECIFIC_CLIENT_ID_SYSTEM => Self::System,
1234 ffi::ALSASEQ_SPECIFIC_CLIENT_ID_DUMMY => Self::Dummy,
1235 ffi::ALSASEQ_SPECIFIC_CLIENT_ID_OSS => Self::Oss,
1236 value => Self::__Unknown(value),
1237 }
1238 }
1239}
1240
1241impl StaticType for SpecificClientId {
1242 #[inline]
1243 #[doc(alias = "alsaseq_specific_client_id_get_type")]
1244 fn static_type() -> glib::Type {
1245 unsafe { from_glib(ffi::alsaseq_specific_client_id_get_type()) }
1246 }
1247}
1248
1249impl glib::HasParamSpec for SpecificClientId {
1250 type ParamSpec = glib::ParamSpecEnum;
1251 type SetValue = Self;
1252 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1253
1254 fn param_spec_builder() -> Self::BuilderFn {
1255 Self::ParamSpec::builder_with_default
1256 }
1257}
1258
1259impl glib::value::ValueType for SpecificClientId {
1260 type Type = Self;
1261}
1262
1263unsafe impl<'a> glib::value::FromValue<'a> for SpecificClientId {
1264 type Checker = glib::value::GenericValueTypeChecker<Self>;
1265
1266 #[inline]
1267 unsafe fn from_value(value: &'a glib::Value) -> Self {
1268 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1269 }
1270}
1271
1272impl ToValue for SpecificClientId {
1273 #[inline]
1274 fn to_value(&self) -> glib::Value {
1275 let mut value = glib::Value::for_value_type::<Self>();
1276 unsafe {
1277 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1278 }
1279 value
1280 }
1281
1282 #[inline]
1283 fn value_type(&self) -> glib::Type {
1284 Self::static_type()
1285 }
1286}
1287
1288impl From<SpecificClientId> for glib::Value {
1289 #[inline]
1290 fn from(v: SpecificClientId) -> Self {
1291 ToValue::to_value(&v)
1292 }
1293}
1294
1295#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1297#[non_exhaustive]
1298#[doc(alias = "ALSASeqSpecificPortId")]
1299pub enum SpecificPortId {
1300 #[doc(alias = "ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_TIMER")]
1301 Timer,
1302 #[doc(alias = "ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_ANNOUNCE")]
1303 Announce,
1304 #[doc(hidden)]
1305 __Unknown(i32),
1306}
1307
1308#[doc(hidden)]
1309impl IntoGlib for SpecificPortId {
1310 type GlibType = ffi::ALSASeqSpecificPortId;
1311
1312 #[inline]
1313 fn into_glib(self) -> ffi::ALSASeqSpecificPortId {
1314 match self {
1315 Self::Timer => ffi::ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_TIMER,
1316 Self::Announce => ffi::ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_ANNOUNCE,
1317 Self::__Unknown(value) => value,
1318 }
1319 }
1320}
1321
1322#[doc(hidden)]
1323impl FromGlib<ffi::ALSASeqSpecificPortId> for SpecificPortId {
1324 #[inline]
1325 unsafe fn from_glib(value: ffi::ALSASeqSpecificPortId) -> Self {
1326 match value {
1327 ffi::ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_TIMER => Self::Timer,
1328 ffi::ALSASEQ_SPECIFIC_PORT_ID_SYSTEM_ANNOUNCE => Self::Announce,
1329 value => Self::__Unknown(value),
1330 }
1331 }
1332}
1333
1334impl StaticType for SpecificPortId {
1335 #[inline]
1336 #[doc(alias = "alsaseq_specific_port_id_get_type")]
1337 fn static_type() -> glib::Type {
1338 unsafe { from_glib(ffi::alsaseq_specific_port_id_get_type()) }
1339 }
1340}
1341
1342impl glib::HasParamSpec for SpecificPortId {
1343 type ParamSpec = glib::ParamSpecEnum;
1344 type SetValue = Self;
1345 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1346
1347 fn param_spec_builder() -> Self::BuilderFn {
1348 Self::ParamSpec::builder_with_default
1349 }
1350}
1351
1352impl glib::value::ValueType for SpecificPortId {
1353 type Type = Self;
1354}
1355
1356unsafe impl<'a> glib::value::FromValue<'a> for SpecificPortId {
1357 type Checker = glib::value::GenericValueTypeChecker<Self>;
1358
1359 #[inline]
1360 unsafe fn from_value(value: &'a glib::Value) -> Self {
1361 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1362 }
1363}
1364
1365impl ToValue for SpecificPortId {
1366 #[inline]
1367 fn to_value(&self) -> glib::Value {
1368 let mut value = glib::Value::for_value_type::<Self>();
1369 unsafe {
1370 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1371 }
1372 value
1373 }
1374
1375 #[inline]
1376 fn value_type(&self) -> glib::Type {
1377 Self::static_type()
1378 }
1379}
1380
1381impl From<SpecificPortId> for glib::Value {
1382 #[inline]
1383 fn from(v: SpecificPortId) -> Self {
1384 ToValue::to_value(&v)
1385 }
1386}
1387
1388#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1390#[non_exhaustive]
1391#[doc(alias = "ALSASeqSpecificQueueId")]
1392pub enum SpecificQueueId {
1393 #[doc(alias = "ALSASEQ_SPECIFIC_QUEUE_ID_DIRECT")]
1394 Direct,
1395 #[doc(hidden)]
1396 __Unknown(i32),
1397}
1398
1399#[doc(hidden)]
1400impl IntoGlib for SpecificQueueId {
1401 type GlibType = ffi::ALSASeqSpecificQueueId;
1402
1403 #[inline]
1404 fn into_glib(self) -> ffi::ALSASeqSpecificQueueId {
1405 match self {
1406 Self::Direct => ffi::ALSASEQ_SPECIFIC_QUEUE_ID_DIRECT,
1407 Self::__Unknown(value) => value,
1408 }
1409 }
1410}
1411
1412#[doc(hidden)]
1413impl FromGlib<ffi::ALSASeqSpecificQueueId> for SpecificQueueId {
1414 #[inline]
1415 unsafe fn from_glib(value: ffi::ALSASeqSpecificQueueId) -> Self {
1416 match value {
1417 ffi::ALSASEQ_SPECIFIC_QUEUE_ID_DIRECT => Self::Direct,
1418 value => Self::__Unknown(value),
1419 }
1420 }
1421}
1422
1423impl StaticType for SpecificQueueId {
1424 #[inline]
1425 #[doc(alias = "alsaseq_specific_queue_id_get_type")]
1426 fn static_type() -> glib::Type {
1427 unsafe { from_glib(ffi::alsaseq_specific_queue_id_get_type()) }
1428 }
1429}
1430
1431impl glib::HasParamSpec for SpecificQueueId {
1432 type ParamSpec = glib::ParamSpecEnum;
1433 type SetValue = Self;
1434 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1435
1436 fn param_spec_builder() -> Self::BuilderFn {
1437 Self::ParamSpec::builder_with_default
1438 }
1439}
1440
1441impl glib::value::ValueType for SpecificQueueId {
1442 type Type = Self;
1443}
1444
1445unsafe impl<'a> glib::value::FromValue<'a> for SpecificQueueId {
1446 type Checker = glib::value::GenericValueTypeChecker<Self>;
1447
1448 #[inline]
1449 unsafe fn from_value(value: &'a glib::Value) -> Self {
1450 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1451 }
1452}
1453
1454impl ToValue for SpecificQueueId {
1455 #[inline]
1456 fn to_value(&self) -> glib::Value {
1457 let mut value = glib::Value::for_value_type::<Self>();
1458 unsafe {
1459 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1460 }
1461 value
1462 }
1463
1464 #[inline]
1465 fn value_type(&self) -> glib::Type {
1466 Self::static_type()
1467 }
1468}
1469
1470impl From<SpecificQueueId> for glib::Value {
1471 #[inline]
1472 fn from(v: SpecificQueueId) -> Self {
1473 ToValue::to_value(&v)
1474 }
1475}
1476
1477#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1479#[non_exhaustive]
1480#[doc(alias = "ALSASeqUserClientError")]
1481pub enum UserClientError {
1482 #[doc(alias = "ALSASEQ_USER_CLIENT_ERROR_FAILED")]
1483 Failed,
1484 #[doc(alias = "ALSASEQ_USER_CLIENT_ERROR_PORT_PERMISSION")]
1485 PortPermission,
1486 #[doc(alias = "ALSASEQ_USER_CLIENT_ERROR_QUEUE_PERMISSION")]
1487 QueuePermission,
1488 #[doc(alias = "ALSASEQ_USER_CLIENT_ERROR_EVENT_UNDELIVERABLE")]
1489 EventUndeliverable,
1490 #[doc(hidden)]
1491 __Unknown(i32),
1492}
1493
1494#[doc(hidden)]
1495impl IntoGlib for UserClientError {
1496 type GlibType = ffi::ALSASeqUserClientError;
1497
1498 #[inline]
1499 fn into_glib(self) -> ffi::ALSASeqUserClientError {
1500 match self {
1501 Self::Failed => ffi::ALSASEQ_USER_CLIENT_ERROR_FAILED,
1502 Self::PortPermission => ffi::ALSASEQ_USER_CLIENT_ERROR_PORT_PERMISSION,
1503 Self::QueuePermission => ffi::ALSASEQ_USER_CLIENT_ERROR_QUEUE_PERMISSION,
1504 Self::EventUndeliverable => ffi::ALSASEQ_USER_CLIENT_ERROR_EVENT_UNDELIVERABLE,
1505 Self::__Unknown(value) => value,
1506 }
1507 }
1508}
1509
1510#[doc(hidden)]
1511impl FromGlib<ffi::ALSASeqUserClientError> for UserClientError {
1512 #[inline]
1513 unsafe fn from_glib(value: ffi::ALSASeqUserClientError) -> Self {
1514 match value {
1515 ffi::ALSASEQ_USER_CLIENT_ERROR_FAILED => Self::Failed,
1516 ffi::ALSASEQ_USER_CLIENT_ERROR_PORT_PERMISSION => Self::PortPermission,
1517 ffi::ALSASEQ_USER_CLIENT_ERROR_QUEUE_PERMISSION => Self::QueuePermission,
1518 ffi::ALSASEQ_USER_CLIENT_ERROR_EVENT_UNDELIVERABLE => Self::EventUndeliverable,
1519 value => Self::__Unknown(value),
1520 }
1521 }
1522}
1523
1524impl glib::error::ErrorDomain for UserClientError {
1525 #[inline]
1526 fn domain() -> glib::Quark {
1527 unsafe { from_glib(ffi::alsaseq_user_client_error_quark()) }
1528 }
1529
1530 #[inline]
1531 fn code(self) -> i32 {
1532 self.into_glib()
1533 }
1534
1535 #[inline]
1536 #[allow(clippy::match_single_binding)]
1537 fn from(code: i32) -> Option<Self> {
1538 match unsafe { from_glib(code) } {
1539 Self::__Unknown(_) => Some(Self::Failed),
1540 value => Some(value),
1541 }
1542 }
1543}
1544
1545impl StaticType for UserClientError {
1546 #[inline]
1547 #[doc(alias = "alsaseq_user_client_error_get_type")]
1548 fn static_type() -> glib::Type {
1549 unsafe { from_glib(ffi::alsaseq_user_client_error_get_type()) }
1550 }
1551}
1552
1553impl glib::HasParamSpec for UserClientError {
1554 type ParamSpec = glib::ParamSpecEnum;
1555 type SetValue = Self;
1556 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1557
1558 fn param_spec_builder() -> Self::BuilderFn {
1559 Self::ParamSpec::builder_with_default
1560 }
1561}
1562
1563impl glib::value::ValueType for UserClientError {
1564 type Type = Self;
1565}
1566
1567unsafe impl<'a> glib::value::FromValue<'a> for UserClientError {
1568 type Checker = glib::value::GenericValueTypeChecker<Self>;
1569
1570 #[inline]
1571 unsafe fn from_value(value: &'a glib::Value) -> Self {
1572 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1573 }
1574}
1575
1576impl ToValue for UserClientError {
1577 #[inline]
1578 fn to_value(&self) -> glib::Value {
1579 let mut value = glib::Value::for_value_type::<Self>();
1580 unsafe {
1581 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1582 }
1583 value
1584 }
1585
1586 #[inline]
1587 fn value_type(&self) -> glib::Type {
1588 Self::static_type()
1589 }
1590}
1591
1592impl From<UserClientError> for glib::Value {
1593 #[inline]
1594 fn from(v: UserClientError) -> Self {
1595 ToValue::to_value(&v)
1596 }
1597}