alsactl 0.8.0

API binding for alsactl library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::ffi;
use glib::{bitflags::bitflags, prelude::*, translate::*};

bitflags! {
    /// A set of flags for access information of the element.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    #[doc(alias = "ALSACtlElemAccessFlag")]
    pub struct ElemAccessFlag: u32 {
        /// The element supports operation to get its values.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_READ")]
        const READ = ffi::ALSACTL_ELEM_ACCESS_FLAG_READ as _;
        /// The element supports operation to change its values.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_WRITE")]
        const WRITE = ffi::ALSACTL_ELEM_ACCESS_FLAG_WRITE as _;
        /// The state of element is mutable independent of operating system.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_VOLATILE")]
        const VOLATILE = ffi::ALSACTL_ELEM_ACCESS_FLAG_VOLATILE as _;
        /// The element supports operation to get Type-Length-Value data.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_TLV_READ")]
        const TLV_READ = ffi::ALSACTL_ELEM_ACCESS_FLAG_TLV_READ as _;
        /// The element supports operation to change Type-Length-Value data.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_TLV_WRITE")]
        const TLV_WRITE = ffi::ALSACTL_ELEM_ACCESS_FLAG_TLV_WRITE as _;
        /// The element supports operation to use Type-Length-Value data as any command.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_TLV_COMMAND")]
        const TLV_COMMAND = ffi::ALSACTL_ELEM_ACCESS_FLAG_TLV_COMMAND as _;
        /// The element is not activated yet.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_INACTIVE")]
        const INACTIVE = ffi::ALSACTL_ELEM_ACCESS_FLAG_INACTIVE as _;
        /// The element is under locked state from any write operation.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_LOCK")]
        const LOCK = ffi::ALSACTL_ELEM_ACCESS_FLAG_LOCK as _;
        /// The element is owned by the process.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_OWNER")]
        const OWNER = ffi::ALSACTL_ELEM_ACCESS_FLAG_OWNER as _;
        /// The element supports specific operation to process Type-Length-Value data.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_TLV_CALLBACK")]
        const TLV_CALLBACK = ffi::ALSACTL_ELEM_ACCESS_FLAG_TLV_CALLBACK as _;
        /// The element is maintained by any user application, instead of kernel driver.
        #[doc(alias = "ALSACTL_ELEM_ACCESS_FLAG_USER")]
        const USER = ffi::ALSACTL_ELEM_ACCESS_FLAG_USER as _;
    }
}

#[doc(hidden)]
impl IntoGlib for ElemAccessFlag {
    type GlibType = ffi::ALSACtlElemAccessFlag;

    #[inline]
    fn into_glib(self) -> ffi::ALSACtlElemAccessFlag {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSACtlElemAccessFlag> for ElemAccessFlag {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSACtlElemAccessFlag) -> Self {
        Self::from_bits_truncate(value)
    }
}

impl StaticType for ElemAccessFlag {
    #[inline]
    #[doc(alias = "alsactl_elem_access_flag_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsactl_elem_access_flag_get_type()) }
    }
}

impl glib::HasParamSpec for ElemAccessFlag {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder
    }
}

impl glib::value::ValueType for ElemAccessFlag {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ElemAccessFlag {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for ElemAccessFlag {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ElemAccessFlag> for glib::Value {
    #[inline]
    fn from(v: ElemAccessFlag) -> Self {
        ToValue::to_value(&v)
    }
}

bitflags! {
    /// A set of flags for the content of event for the element.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    #[doc(alias = "ALSACtlElemEventMask")]
    pub struct ElemEventMask: u32 {
        /// The event notifies any change of value for the element.
        #[doc(alias = "ALSACTL_ELEM_EVENT_MASK_VALUE")]
        const VALUE = ffi::ALSACTL_ELEM_EVENT_MASK_VALUE as _;
        /// The event notifies any change of information for the element.
        #[doc(alias = "ALSACTL_ELEM_EVENT_MASK_INFO")]
        const INFO = ffi::ALSACTL_ELEM_EVENT_MASK_INFO as _;
        /// The element notifies addition of the element.
        #[doc(alias = "ALSACTL_ELEM_EVENT_MASK_ADD")]
        const ADD = ffi::ALSACTL_ELEM_EVENT_MASK_ADD as _;
        /// The element notifies any change of Type-Length-Value data for the element.
        #[doc(alias = "ALSACTL_ELEM_EVENT_MASK_TLV")]
        const TLV = ffi::ALSACTL_ELEM_EVENT_MASK_TLV as _;
        /// The element notifies removal of the element.
        #[doc(alias = "ALSACTL_ELEM_EVENT_MASK_REMOVE")]
        const REMOVE = ffi::ALSACTL_ELEM_EVENT_MASK_REMOVE as _;
    }
}

#[doc(hidden)]
impl IntoGlib for ElemEventMask {
    type GlibType = ffi::ALSACtlElemEventMask;

    #[inline]
    fn into_glib(self) -> ffi::ALSACtlElemEventMask {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ALSACtlElemEventMask> for ElemEventMask {
    #[inline]
    unsafe fn from_glib(value: ffi::ALSACtlElemEventMask) -> Self {
        Self::from_bits_truncate(value)
    }
}

impl StaticType for ElemEventMask {
    #[inline]
    #[doc(alias = "alsactl_elem_event_mask_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::alsactl_elem_event_mask_get_type()) }
    }
}

impl glib::HasParamSpec for ElemEventMask {
    type ParamSpec = glib::ParamSpecFlags;
    type SetValue = Self;
    type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder
    }
}

impl glib::value::ValueType for ElemEventMask {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ElemEventMask {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for ElemEventMask {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ElemEventMask> for glib::Value {
    #[inline]
    fn from(v: ElemEventMask) -> Self {
        ToValue::to_value(&v)
    }
}