diff options
author | Takashi Sakamoto <o-takashi@sakamocchi.jp> | 2022-03-18 14:59:34 +0900 |
---|---|---|
committer | 坂本 貴史 <o-takashi@sakamocchi.jp> | 2022-03-18 15:15:25 +0900 |
commit | dc12db077ab0dffd1f98725b055924a4a56075bf (patch) | |
tree | d5249fb1a3a578a1a086143cf0b27929edf12cd4 | |
parent | 9481947c8240e67793981543c6cc60105fd3e612 (diff) | |
download | hinawa-rs-dc12db077ab0dffd1f98725b055924a4a56075bf.tar.gz |
hinawa: regenerate API crate
This commit regenerate API crate.
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
27 files changed, 1848 insertions, 1301 deletions
@@ -30,6 +30,12 @@ Dependencies * ``glib-sys`` >= 0.15 * ``gobject-sys`` >= 0.15 +* API crate (`hinawa`) + + * ``libc`` >= 0.2 + * ``glib`` >= 0.15 + * FFI crate (``hinawa-sys``) + Sample code =========== diff --git a/hinawa/Cargo.toml b/hinawa/Cargo.toml index 4811a68..26e185a 100644 --- a/hinawa/Cargo.toml +++ b/hinawa/Cargo.toml @@ -1,22 +1,20 @@ [package] -name = "hinawa" -version = "0.5.0" -description = "API bindings for libhinawa2 library" authors = ["Takashi Sakamoto <o-takashi@sakamocchi.jp>"] +description = "API bindings for libhinawa2 library" +edition = "2021" license = "MIT" +name = "hinawa" repository = "https://github.com/alsa-project/hinawa-rs/" +rust-version = "1.57" +version = "0.5.0" [lib] name = "hinawa" [dependencies] libc = "0.2" - -glib = "0.10" -glib-sys = "0.10" -gobject-sys = "0.10" - -hinawa-sys = { path = "../hinawa-sys", version = "0.5" } +glib = "0.15" +ffi = {package = "hinawa-sys", path = "../hinawa-sys", version = "0.5"} [dev-dependencies] gir-format-check = "^0.1" diff --git a/conf/gir-hinawa.toml b/hinawa/Gir.toml index 1bfbe75..2d7a43a 100644 --- a/conf/gir-hinawa.toml +++ b/hinawa/Gir.toml @@ -1,7 +1,9 @@ [options] +girs_directories = ["../gir-files", ".."] work_mode = "normal" library = "Hinawa" version = "3.0" +use_gi_docgen = true min_cfg_version = "3.0" single_version_file = true diff --git a/hinawa/src/auto/enums.rs b/hinawa/src/auto/enums.rs index 4456f6f..a0f1279 100644 --- a/hinawa/src/auto/enums.rs +++ b/hinawa/src/auto/enums.rs @@ -1,25 +1,24 @@ // 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 glib::error::ErrorDomain; use glib::translate::*; use glib::value::FromValue; -use glib::value::FromValueOptional; -use glib::value::SetValue; -use glib::value::Value; +use glib::value::ToValue; use glib::Quark; use glib::StaticType; use glib::Type; -use gobject_sys; -use hinawa_sys; use std::fmt; -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaFwFcpError")] pub enum FwFcpError { + #[doc(alias = "HINAWA_FW_FCP_ERROR_TIMEOUT")] Timeout, + #[doc(alias = "HINAWA_FW_FCP_ERROR_LARGE_RESP")] LargeResp, #[doc(hidden)] __Unknown(i32), @@ -27,87 +26,103 @@ pub enum FwFcpError { impl fmt::Display for FwFcpError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwFcpError::{}", match *self { - FwFcpError::Timeout => "Timeout", - FwFcpError::LargeResp => "LargeResp", - _ => "Unknown", - }) + write!( + f, + "FwFcpError::{}", + match *self { + Self::Timeout => "Timeout", + Self::LargeResp => "LargeResp", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for FwFcpError { - type GlibType = hinawa_sys::HinawaFwFcpError; - - fn to_glib(&self) -> hinawa_sys::HinawaFwFcpError { - match *self { - FwFcpError::Timeout => hinawa_sys::HINAWA_FW_FCP_ERROR_TIMEOUT, - FwFcpError::LargeResp => hinawa_sys::HINAWA_FW_FCP_ERROR_LARGE_RESP, - FwFcpError::__Unknown(value) => value +impl IntoGlib for FwFcpError { + type GlibType = ffi::HinawaFwFcpError; + + fn into_glib(self) -> ffi::HinawaFwFcpError { + match self { + Self::Timeout => ffi::HINAWA_FW_FCP_ERROR_TIMEOUT, + Self::LargeResp => ffi::HINAWA_FW_FCP_ERROR_LARGE_RESP, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaFwFcpError> for FwFcpError { - fn from_glib(value: hinawa_sys::HinawaFwFcpError) -> Self { +impl FromGlib<ffi::HinawaFwFcpError> for FwFcpError { + unsafe fn from_glib(value: ffi::HinawaFwFcpError) -> Self { match value { - 0 => FwFcpError::Timeout, - 1 => FwFcpError::LargeResp, - value => FwFcpError::__Unknown(value), + ffi::HINAWA_FW_FCP_ERROR_TIMEOUT => Self::Timeout, + ffi::HINAWA_FW_FCP_ERROR_LARGE_RESP => Self::LargeResp, + value => Self::__Unknown(value), } } } impl ErrorDomain for FwFcpError { fn domain() -> Quark { - unsafe { from_glib(hinawa_sys::hinawa_fw_fcp_error_quark()) } + unsafe { from_glib(ffi::hinawa_fw_fcp_error_quark()) } } fn code(self) -> i32 { - self.to_glib() + self.into_glib() } fn from(code: i32) -> Option<Self> { match code { - 0 => Some(FwFcpError::Timeout), - 1 => Some(FwFcpError::LargeResp), - value => Some(FwFcpError::__Unknown(value)), + ffi::HINAWA_FW_FCP_ERROR_TIMEOUT => Some(Self::Timeout), + ffi::HINAWA_FW_FCP_ERROR_LARGE_RESP => Some(Self::LargeResp), + value => Some(Self::__Unknown(value)), } } } impl StaticType for FwFcpError { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_fw_fcp_error_get_type()) } + unsafe { from_glib(ffi::hinawa_fw_fcp_error_get_type()) } } } -impl<'a> FromValueOptional<'a> for FwFcpError { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for FwFcpError { + type Type = Self; } -impl<'a> FromValue<'a> for FwFcpError { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for FwFcpError { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for FwFcpError { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for FwFcpError { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaFwNodeError")] pub enum FwNodeError { + #[doc(alias = "HINAWA_FW_NODE_ERROR_DISCONNECTED")] Disconnected, + #[doc(alias = "HINAWA_FW_NODE_ERROR_OPENED")] Opened, + #[doc(alias = "HINAWA_FW_NODE_ERROR_NOT_OPENED")] NotOpened, + #[doc(alias = "HINAWA_FW_NODE_ERROR_FAILED")] Failed, #[doc(hidden)] __Unknown(i32), @@ -115,102 +130,125 @@ pub enum FwNodeError { impl fmt::Display for FwNodeError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwNodeError::{}", match *self { - FwNodeError::Disconnected => "Disconnected", - FwNodeError::Opened => "Opened", - FwNodeError::NotOpened => "NotOpened", - FwNodeError::Failed => "Failed", - _ => "Unknown", - }) + write!( + f, + "FwNodeError::{}", + match *self { + Self::Disconnected => "Disconnected", + Self::Opened => "Opened", + Self::NotOpened => "NotOpened", + Self::Failed => "Failed", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for FwNodeError { - type GlibType = hinawa_sys::HinawaFwNodeError; - - fn to_glib(&self) -> hinawa_sys::HinawaFwNodeError { - match *self { - FwNodeError::Disconnected => hinawa_sys::HINAWA_FW_NODE_ERROR_DISCONNECTED, - FwNodeError::Opened => hinawa_sys::HINAWA_FW_NODE_ERROR_OPENED, - FwNodeError::NotOpened => hinawa_sys::HINAWA_FW_NODE_ERROR_NOT_OPENED, - FwNodeError::Failed => hinawa_sys::HINAWA_FW_NODE_ERROR_FAILED, - FwNodeError::__Unknown(value) => value +impl IntoGlib for FwNodeError { + type GlibType = ffi::HinawaFwNodeError; + + fn into_glib(self) -> ffi::HinawaFwNodeError { + match self { + Self::Disconnected => ffi::HINAWA_FW_NODE_ERROR_DISCONNECTED, + Self::Opened => ffi::HINAWA_FW_NODE_ERROR_OPENED, + Self::NotOpened => ffi::HINAWA_FW_NODE_ERROR_NOT_OPENED, + Self::Failed => ffi::HINAWA_FW_NODE_ERROR_FAILED, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaFwNodeError> for FwNodeError { - fn from_glib(value: hinawa_sys::HinawaFwNodeError) -> Self { +impl FromGlib<ffi::HinawaFwNodeError> for FwNodeError { + unsafe fn from_glib(value: ffi::HinawaFwNodeError) -> Self { match value { - 0 => FwNodeError::Disconnected, - 1 => FwNodeError::Opened, - 2 => FwNodeError::NotOpened, - 3 => FwNodeError::Failed, - value => FwNodeError::__Unknown(value), + ffi::HINAWA_FW_NODE_ERROR_DISCONNECTED => Self::Disconnected, + ffi::HINAWA_FW_NODE_ERROR_OPENED => Self::Opened, + ffi::HINAWA_FW_NODE_ERROR_NOT_OPENED => Self::NotOpened, + ffi::HINAWA_FW_NODE_ERROR_FAILED => Self::Failed, + value => Self::__Unknown(value), } } } impl ErrorDomain for FwNodeError { fn domain() -> Quark { - unsafe { from_glib(hinawa_sys::hinawa_fw_node_error_quark()) } + unsafe { from_glib(ffi::hinawa_fw_node_error_quark()) } } fn code(self) -> i32 { - self.to_glib() + self.into_glib() } fn from(code: i32) -> Option<Self> { match code { - 0 => Some(FwNodeError::Disconnected), - 1 => Some(FwNodeError::Opened), - 2 => Some(FwNodeError::NotOpened), - 3 => Some(FwNodeError::Failed), - _ => Some(FwNodeError::Failed), + ffi::HINAWA_FW_NODE_ERROR_DISCONNECTED => Some(Self::Disconnected), + ffi::HINAWA_FW_NODE_ERROR_OPENED => Some(Self::Opened), + ffi::HINAWA_FW_NODE_ERROR_NOT_OPENED => Some(Self::NotOpened), + ffi::HINAWA_FW_NODE_ERROR_FAILED => Some(Self::Failed), + _ => Some(Self::Failed), } } } impl StaticType for FwNodeError { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_fw_node_error_get_type()) } + unsafe { from_glib(ffi::hinawa_fw_node_error_get_type()) } } } -impl<'a> FromValueOptional<'a> for FwNodeError { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for FwNodeError { + type Type = Self; } -impl<'a> FromValue<'a> for FwNodeError { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for FwNodeError { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for FwNodeError { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for FwNodeError { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaFwRcode")] pub enum FwRcode { + #[doc(alias = "HINAWA_FW_RCODE_COMPLETE")] Complete, + #[doc(alias = "HINAWA_FW_RCODE_CONFLICT_ERROR")] ConflictError, + #[doc(alias = "HINAWA_FW_RCODE_DATA_ERROR")] DataError, + #[doc(alias = "HINAWA_FW_RCODE_TYPE_ERROR")] TypeError, + #[doc(alias = "HINAWA_FW_RCODE_ADDRESS_ERROR")] AddressError, + #[doc(alias = "HINAWA_FW_RCODE_SEND_ERROR")] SendError, + #[doc(alias = "HINAWA_FW_RCODE_CANCELLED")] Cancelled, + #[doc(alias = "HINAWA_FW_RCODE_BUSY")] Busy, + #[doc(alias = "HINAWA_FW_RCODE_GENERATION")] Generation, + #[doc(alias = "HINAWA_FW_RCODE_NO_ACK")] NoAck, + #[doc(alias = "HINAWA_FW_RCODE_INVALID")] Invalid, #[doc(hidden)] __Unknown(i32), @@ -218,95 +256,110 @@ pub enum FwRcode { impl fmt::Display for FwRcode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwRcode::{}", match *self { - FwRcode::Complete => "Complete", - FwRcode::ConflictError => "ConflictError", - FwRcode::DataError => "DataError", - FwRcode::TypeError => "TypeError", - FwRcode::AddressError => "AddressError", - FwRcode::SendError => "SendError", - FwRcode::Cancelled => "Cancelled", - FwRcode::Busy => "Busy", - FwRcode::Generation => "Generation", - FwRcode::NoAck => "NoAck", - FwRcode::Invalid => "Invalid", - _ => "Unknown", - }) + write!( + f, + "FwRcode::{}", + match *self { + Self::Complete => "Complete", + Self::ConflictError => "ConflictError", + Self::DataError => "DataError", + Self::TypeError => "TypeError", + Self::AddressError => "AddressError", + Self::SendError => "SendError", + Self::Cancelled => "Cancelled", + Self::Busy => "Busy", + Self::Generation => "Generation", + Self::NoAck => "NoAck", + Self::Invalid => "Invalid", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for FwRcode { - type GlibType = hinawa_sys::HinawaFwRcode; - - fn to_glib(&self) -> hinawa_sys::HinawaFwRcode { - match *self { - FwRcode::Complete => hinawa_sys::HINAWA_FW_RCODE_COMPLETE, - FwRcode::ConflictError => hinawa_sys::HINAWA_FW_RCODE_CONFLICT_ERROR, - FwRcode::DataError => hinawa_sys::HINAWA_FW_RCODE_DATA_ERROR, - FwRcode::TypeError => hinawa_sys::HINAWA_FW_RCODE_TYPE_ERROR, - FwRcode::AddressError => hinawa_sys::HINAWA_FW_RCODE_ADDRESS_ERROR, - FwRcode::SendError => hinawa_sys::HINAWA_FW_RCODE_SEND_ERROR, - FwRcode::Cancelled => hinawa_sys::HINAWA_FW_RCODE_CANCELLED, - FwRcode::Busy => hinawa_sys::HINAWA_FW_RCODE_BUSY, - FwRcode::Generation => hinawa_sys::HINAWA_FW_RCODE_GENERATION, - FwRcode::NoAck => hinawa_sys::HINAWA_FW_RCODE_NO_ACK, - FwRcode::Invalid => hinawa_sys::HINAWA_FW_RCODE_INVALID, - FwRcode::__Unknown(value) => value +impl IntoGlib for FwRcode { + type GlibType = ffi::HinawaFwRcode; + + fn into_glib(self) -> ffi::HinawaFwRcode { + match self { + Self::Complete => ffi::HINAWA_FW_RCODE_COMPLETE, + Self::ConflictError => ffi::HINAWA_FW_RCODE_CONFLICT_ERROR, + Self::DataError => ffi::HINAWA_FW_RCODE_DATA_ERROR, + Self::TypeError => ffi::HINAWA_FW_RCODE_TYPE_ERROR, + Self::AddressError => ffi::HINAWA_FW_RCODE_ADDRESS_ERROR, + Self::SendError => ffi::HINAWA_FW_RCODE_SEND_ERROR, + Self::Cancelled => ffi::HINAWA_FW_RCODE_CANCELLED, + Self::Busy => ffi::HINAWA_FW_RCODE_BUSY, + Self::Generation => ffi::HINAWA_FW_RCODE_GENERATION, + Self::NoAck => ffi::HINAWA_FW_RCODE_NO_ACK, + Self::Invalid => ffi::HINAWA_FW_RCODE_INVALID, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaFwRcode> for FwRcode { - fn from_glib(value: hinawa_sys::HinawaFwRcode) -> Self { +impl FromGlib<ffi::HinawaFwRcode> for FwRcode { + unsafe fn from_glib(value: ffi::HinawaFwRcode) -> Self { match value { - 0 => FwRcode::Complete, - 4 => FwRcode::ConflictError, - 5 => FwRcode::DataError, - 6 => FwRcode::TypeError, - 7 => FwRcode::AddressError, - 16 => FwRcode::SendError, - 17 => FwRcode::Cancelled, - 18 => FwRcode::Busy, - 19 => FwRcode::Generation, - 20 => FwRcode::NoAck, - 21 => FwRcode::Invalid, - value => FwRcode::__Unknown(value), + ffi::HINAWA_FW_RCODE_COMPLETE => Self::Complete, + ffi::HINAWA_FW_RCODE_CONFLICT_ERROR => Self::ConflictError, + ffi::HINAWA_FW_RCODE_DATA_ERROR => Self::DataError, + ffi::HINAWA_FW_RCODE_TYPE_ERROR => Self::TypeError, + ffi::HINAWA_FW_RCODE_ADDRESS_ERROR => Self::AddressError, + ffi::HINAWA_FW_RCODE_SEND_ERROR => Self::SendError, + ffi::HINAWA_FW_RCODE_CANCELLED => Self::Cancelled, + ffi::HINAWA_FW_RCODE_BUSY => Self::Busy, + ffi::HINAWA_FW_RCODE_GENERATION => Self::Generation, + ffi::HINAWA_FW_RCODE_NO_ACK => Self::NoAck, + ffi::HINAWA_FW_RCODE_INVALID => Self::Invalid, + value => Self::__Unknown(value), } } } impl StaticType for FwRcode { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_fw_rcode_get_type()) } + unsafe { from_glib(ffi::hinawa_fw_rcode_get_type()) } } } -impl<'a> FromValueOptional<'a> for FwRcode { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for FwRcode { + type Type = Self; } -impl<'a> FromValue<'a> for FwRcode { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for FwRcode { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for FwRcode { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for FwRcode { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaFwRespError")] pub enum FwRespError { + #[doc(alias = "HINAWA_FW_RESP_ERROR_FAILED")] Failed, + #[doc(alias = "HINAWA_FW_RESP_ERROR_RESERVED")] Reserved, + #[doc(alias = "HINAWA_FW_RESP_ERROR_ADDR_SPACE_USED")] AddrSpaceUsed, #[doc(hidden)] __Unknown(i32), @@ -314,105 +367,135 @@ pub enum FwRespError { impl fmt::Display for FwRespError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwRespError::{}", match *self { - FwRespError::Failed => "Failed", - FwRespError::Reserved => "Reserved", - FwRespError::AddrSpaceUsed => "AddrSpaceUsed", - _ => "Unknown", - }) + write!( + f, + "FwRespError::{}", + match *self { + Self::Failed => "Failed", + Self::Reserved => "Reserved", + Self::AddrSpaceUsed => "AddrSpaceUsed", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for FwRespError { - type GlibType = hinawa_sys::HinawaFwRespError; - - fn to_glib(&self) -> hinawa_sys::HinawaFwRespError { - match *self { - FwRespError::Failed => hinawa_sys::HINAWA_FW_RESP_ERROR_FAILED, - FwRespError::Reserved => hinawa_sys::HINAWA_FW_RESP_ERROR_RESERVED, - FwRespError::AddrSpaceUsed => hinawa_sys::HINAWA_FW_RESP_ERROR_ADDR_SPACE_USED, - FwRespError::__Unknown(value) => value +impl IntoGlib for FwRespError { + type GlibType = ffi::HinawaFwRespError; + + fn into_glib(self) -> ffi::HinawaFwRespError { + match self { + Self::Failed => ffi::HINAWA_FW_RESP_ERROR_FAILED, + Self::Reserved => ffi::HINAWA_FW_RESP_ERROR_RESERVED, + Self::AddrSpaceUsed => ffi::HINAWA_FW_RESP_ERROR_ADDR_SPACE_USED, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaFwRespError> for FwRespError { - fn from_glib(value: hinawa_sys::HinawaFwRespError) -> Self { +impl FromGlib<ffi::HinawaFwRespError> for FwRespError { + unsafe fn from_glib(value: ffi::HinawaFwRespError) -> Self { match value { - 0 => FwRespError::Failed, - 1 => FwRespError::Reserved, - 2 => FwRespError::AddrSpaceUsed, - value => FwRespError::__Unknown(value), + ffi::HINAWA_FW_RESP_ERROR_FAILED => Self::Failed, + ffi::HINAWA_FW_RESP_ERROR_RESERVED => Self::Reserved, + ffi::HINAWA_FW_RESP_ERROR_ADDR_SPACE_USED => Self::AddrSpaceUsed, + value => Self::__Unknown(value), } } } impl ErrorDomain for FwRespError { fn domain() -> Quark { - unsafe { from_glib(hinawa_sys::hinawa_fw_resp_error_quark()) } + unsafe { from_glib(ffi::hinawa_fw_resp_error_quark()) } } fn code(self) -> i32 { - self.to_glib() + self.into_glib() } fn from(code: i32) -> Option<Self> { match code { - 0 => Some(FwRespError::Failed), - 1 => Some(FwRespError::Reserved), - 2 => Some(FwRespError::AddrSpaceUsed), - _ => Some(FwRespError::Failed), + ffi::HINAWA_FW_RESP_ERROR_FAILED => Some(Self::Failed), + ffi::HINAWA_FW_RESP_ERROR_RESERVED => Some(Self::Reserved), + ffi::HINAWA_FW_RESP_ERROR_ADDR_SPACE_USED => Some(Self::AddrSpaceUsed), + _ => Some(Self::Failed), } } } impl StaticType for FwRespError { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_fw_resp_error_get_type()) } + unsafe { from_glib(ffi::hinawa_fw_resp_error_get_type()) } } } -impl<'a> FromValueOptional<'a> for FwRespError { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for FwRespError { + type Type = Self; } -impl<'a> FromValue<'a> for FwRespError { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for FwRespError { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for FwRespError { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for FwRespError { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaFwTcode")] pub enum FwTcode { + #[doc(alias = "HINAWA_FW_TCODE_WRITE_QUADLET_REQUEST")] WriteQuadletRequest, + #[doc(alias = "HINAWA_FW_TCODE_WRITE_BLOCK_REQUEST")] WriteBlockRequest, + #[doc(alias = "HINAWA_FW_TCODE_WRITE_RESPONSE")] WriteResponse, + #[doc(alias = "HINAWA_FW_TCODE_READ_QUADLET_REQUEST")] ReadQuadletRequest, + #[doc(alias = "HINAWA_FW_TCODE_READ_BLOCK_REQUEST")] ReadBlockRequest, + #[doc(alias = "HINAWA_FW_TCODE_READ_QUADLET_RESPONSE")] ReadQuadletResponse, + #[doc(alias = "HINAWA_FW_TCODE_READ_BLOCK_RESPONSE")] ReadBlockResponse, + #[doc(alias = "HINAWA_FW_TCODE_CYCLE_START")] CycleStart, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_REQUEST")] LockRequest, + #[doc(alias = "HINAWA_FW_TCODE_STREAM_DATA")] StreamData, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_RESPONSE")] LockResponse, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_MASK_SWAP")] LockMaskSwap, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_COMPARE_SWAP")] LockCompareSwap, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_FETCH_ADD")] LockFetchAdd, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_LITTLE_ADD")] LockLittleAdd, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_BOUNDED_ADD")] LockBoundedAdd, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_WRAP_ADD")] LockWrapAdd, + #[doc(alias = "HINAWA_FW_TCODE_LOCK_VENDOR_DEPENDENT")] LockVendorDependent, #[doc(hidden)] __Unknown(i32), @@ -420,114 +503,127 @@ pub enum FwTcode { impl fmt::Display for FwTcode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwTcode::{}", match *self { - FwTcode::WriteQuadletRequest => "WriteQuadletRequest", - FwTcode::WriteBlockRequest => "WriteBlockRequest", - FwTcode::WriteResponse => "WriteResponse", - FwTcode::ReadQuadletRequest => "ReadQuadletRequest", - FwTcode::ReadBlockRequest => "ReadBlockRequest", - FwTcode::ReadQuadletResponse => "ReadQuadletResponse", - FwTcode::ReadBlockResponse => "ReadBlockResponse", - FwTcode::CycleStart => "CycleStart", - FwTcode::LockRequest => "LockRequest", - FwTcode::StreamData => "StreamData", - FwTcode::LockResponse => "LockResponse", - FwTcode::LockMaskSwap => "LockMaskSwap", - FwTcode::LockCompareSwap => "LockCompareSwap", - FwTcode::LockFetchAdd => "LockFetchAdd", - FwTcode::LockLittleAdd => "LockLittleAdd", - FwTcode::LockBoundedAdd => "LockBoundedAdd", - FwTcode::LockWrapAdd => "LockWrapAdd", - FwTcode::LockVendorDependent => "LockVendorDependent", - _ => "Unknown", - }) + write!( + f, + "FwTcode::{}", + match *self { + Self::WriteQuadletRequest => "WriteQuadletRequest", + Self::WriteBlockRequest => "WriteBlockRequest", + Self::WriteResponse => "WriteResponse", + Self::ReadQuadletRequest => "ReadQuadletRequest", + Self::ReadBlockRequest => "ReadBlockRequest", + Self::ReadQuadletResponse => "ReadQuadletResponse", + Self::ReadBlockResponse => "ReadBlockResponse", + Self::CycleStart => "CycleStart", + Self::LockRequest => "LockRequest", + Self::StreamData => "StreamData", + Self::LockResponse => "LockResponse", + Self::LockMaskSwap => "LockMaskSwap", + Self::LockCompareSwap => "LockCompareSwap", + Self::LockFetchAdd => "LockFetchAdd", + Self::LockLittleAdd => "LockLittleAdd", + Self::LockBoundedAdd => "LockBoundedAdd", + Self::LockWrapAdd => "LockWrapAdd", + Self::LockVendorDependent => "LockVendorDependent", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for FwTcode { - type GlibType = hinawa_sys::HinawaFwTcode; - - fn to_glib(&self) -> hinawa_sys::HinawaFwTcode { - match *self { - FwTcode::WriteQuadletRequest => hinawa_sys::HINAWA_FW_TCODE_WRITE_QUADLET_REQUEST, - FwTcode::WriteBlockRequest => hinawa_sys::HINAWA_FW_TCODE_WRITE_BLOCK_REQUEST, - FwTcode::WriteResponse => hinawa_sys::HINAWA_FW_TCODE_WRITE_RESPONSE, - FwTcode::ReadQuadletRequest => hinawa_sys::HINAWA_FW_TCODE_READ_QUADLET_REQUEST, - FwTcode::ReadBlockRequest => hinawa_sys::HINAWA_FW_TCODE_READ_BLOCK_REQUEST, - FwTcode::ReadQuadletResponse => hinawa_sys::HINAWA_FW_TCODE_READ_QUADLET_RESPONSE, - FwTcode::ReadBlockResponse => hinawa_sys::HINAWA_FW_TCODE_READ_BLOCK_RESPONSE, - FwTcode::CycleStart => hinawa_sys::HINAWA_FW_TCODE_CYCLE_START, - FwTcode::LockRequest => hinawa_sys::HINAWA_FW_TCODE_LOCK_REQUEST, - FwTcode::StreamData => hinawa_sys::HINAWA_FW_TCODE_STREAM_DATA, - FwTcode::LockResponse => hinawa_sys::HINAWA_FW_TCODE_LOCK_RESPONSE, - FwTcode::LockMaskSwap => hinawa_sys::HINAWA_FW_TCODE_LOCK_MASK_SWAP, - FwTcode::LockCompareSwap => hinawa_sys::HINAWA_FW_TCODE_LOCK_COMPARE_SWAP, - FwTcode::LockFetchAdd => hinawa_sys::HINAWA_FW_TCODE_LOCK_FETCH_ADD, - FwTcode::LockLittleAdd => hinawa_sys::HINAWA_FW_TCODE_LOCK_LITTLE_ADD, - FwTcode::LockBoundedAdd => hinawa_sys::HINAWA_FW_TCODE_LOCK_BOUNDED_ADD, - FwTcode::LockWrapAdd => hinawa_sys::HINAWA_FW_TCODE_LOCK_WRAP_ADD, - FwTcode::LockVendorDependent => hinawa_sys::HINAWA_FW_TCODE_LOCK_VENDOR_DEPENDENT, - FwTcode::__Unknown(value) => value +impl IntoGlib for FwTcode { + type GlibType = ffi::HinawaFwTcode; + + fn into_glib(self) -> ffi::HinawaFwTcode { + match self { + Self::WriteQuadletRequest => ffi::HINAWA_FW_TCODE_WRITE_QUADLET_REQUEST, + Self::WriteBlockRequest => ffi::HINAWA_FW_TCODE_WRITE_BLOCK_REQUEST, + Self::WriteResponse => ffi::HINAWA_FW_TCODE_WRITE_RESPONSE, + Self::ReadQuadletRequest => ffi::HINAWA_FW_TCODE_READ_QUADLET_REQUEST, + Self::ReadBlockRequest => ffi::HINAWA_FW_TCODE_READ_BLOCK_REQUEST, + Self::ReadQuadletResponse => ffi::HINAWA_FW_TCODE_READ_QUADLET_RESPONSE, + Self::ReadBlockResponse => ffi::HINAWA_FW_TCODE_READ_BLOCK_RESPONSE, + Self::CycleStart => ffi::HINAWA_FW_TCODE_CYCLE_START, + Self::LockRequest => ffi::HINAWA_FW_TCODE_LOCK_REQUEST, + Self::StreamData => ffi::HINAWA_FW_TCODE_STREAM_DATA, + Self::LockResponse => ffi::HINAWA_FW_TCODE_LOCK_RESPONSE, + Self::LockMaskSwap => ffi::HINAWA_FW_TCODE_LOCK_MASK_SWAP, + Self::LockCompareSwap => ffi::HINAWA_FW_TCODE_LOCK_COMPARE_SWAP, + Self::LockFetchAdd => ffi::HINAWA_FW_TCODE_LOCK_FETCH_ADD, + Self::LockLittleAdd => ffi::HINAWA_FW_TCODE_LOCK_LITTLE_ADD, + Self::LockBoundedAdd => ffi::HINAWA_FW_TCODE_LOCK_BOUNDED_ADD, + Self::LockWrapAdd => ffi::HINAWA_FW_TCODE_LOCK_WRAP_ADD, + Self::LockVendorDependent => ffi::HINAWA_FW_TCODE_LOCK_VENDOR_DEPENDENT, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaFwTcode> for FwTcode { - fn from_glib(value: hinawa_sys::HinawaFwTcode) -> Self { +impl FromGlib<ffi::HinawaFwTcode> for FwTcode { + unsafe fn from_glib(value: ffi::HinawaFwTcode) -> Self { match value { - 0 => FwTcode::WriteQuadletRequest, - 1 => FwTcode::WriteBlockRequest, - 2 => FwTcode::WriteResponse, - 4 => FwTcode::ReadQuadletRequest, - 5 => FwTcode::ReadBlockRequest, - 6 => FwTcode::ReadQuadletResponse, - 7 => FwTcode::ReadBlockResponse, - 8 => FwTcode::CycleStart, - 9 => FwTcode::LockRequest, - 10 => FwTcode::StreamData, - 11 => FwTcode::LockResponse, - 17 => FwTcode::LockMaskSwap, - 18 => FwTcode::LockCompareSwap, - 19 => FwTcode::LockFetchAdd, - 20 => FwTcode::LockLittleAdd, - 21 => FwTcode::LockBoundedAdd, - 22 => FwTcode::LockWrapAdd, - 23 => FwTcode::LockVendorDependent, - value => FwTcode::__Unknown(value), + ffi::HINAWA_FW_TCODE_WRITE_QUADLET_REQUEST => Self::WriteQuadletRequest, + ffi::HINAWA_FW_TCODE_WRITE_BLOCK_REQUEST => Self::WriteBlockRequest, + ffi::HINAWA_FW_TCODE_WRITE_RESPONSE => Self::WriteResponse, + ffi::HINAWA_FW_TCODE_READ_QUADLET_REQUEST => Self::ReadQuadletRequest, + ffi::HINAWA_FW_TCODE_READ_BLOCK_REQUEST => Self::ReadBlockRequest, + ffi::HINAWA_FW_TCODE_READ_QUADLET_RESPONSE => Self::ReadQuadletResponse, + ffi::HINAWA_FW_TCODE_READ_BLOCK_RESPONSE => Self::ReadBlockResponse, + ffi::HINAWA_FW_TCODE_CYCLE_START => Self::CycleStart, + ffi::HINAWA_FW_TCODE_LOCK_REQUEST => Self::LockRequest, + ffi::HINAWA_FW_TCODE_STREAM_DATA => Self::StreamData, + ffi::HINAWA_FW_TCODE_LOCK_RESPONSE => Self::LockResponse, + ffi::HINAWA_FW_TCODE_LOCK_MASK_SWAP => Self::LockMaskSwap, + ffi::HINAWA_FW_TCODE_LOCK_COMPARE_SWAP => Self::LockCompareSwap, + ffi::HINAWA_FW_TCODE_LOCK_FETCH_ADD => Self::LockFetchAdd, + ffi::HINAWA_FW_TCODE_LOCK_LITTLE_ADD => Self::LockLittleAdd, + ffi::HINAWA_FW_TCODE_LOCK_BOUNDED_ADD => Self::LockBoundedAdd, + ffi::HINAWA_FW_TCODE_LOCK_WRAP_ADD => Self::LockWrapAdd, + ffi::HINAWA_FW_TCODE_LOCK_VENDOR_DEPENDENT => Self::LockVendorDependent, + value => Self::__Unknown(value), } } } impl StaticType for FwTcode { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_fw_tcode_get_type()) } + unsafe { from_glib(ffi::hinawa_fw_tcode_get_type()) } } } -impl<'a> FromValueOptional<'a> for FwTcode { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for FwTcode { + type Type = Self; } -impl<'a> FromValue<'a> for FwTcode { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for FwTcode { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for FwTcode { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for FwTcode { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaSndDiceError")] pub enum SndDiceError { + #[doc(alias = "HINAWA_SND_DICE_ERROR_TIMEOUT")] Timeout, #[doc(hidden)] __Unknown(i32), @@ -535,96 +631,125 @@ pub enum SndDiceError { impl fmt::Display for SndDiceError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndDiceError::{}", match *self { - SndDiceError::Timeout => "Timeout", - _ => "Unknown", - }) + write!( + f, + "SndDiceError::{}", + match *self { + Self::Timeout => "Timeout", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for SndDiceError { - type GlibType = hinawa_sys::HinawaSndDiceError; +impl IntoGlib for SndDiceError { + type GlibType = ffi::HinawaSndDiceError; - fn to_glib(&self) -> hinawa_sys::HinawaSndDiceError { - match *self { - SndDiceError::Timeout => hinawa_sys::HINAWA_SND_DICE_ERROR_TIMEOUT, - SndDiceError::__Unknown(value) => value + fn into_glib(self) -> ffi::HinawaSndDiceError { + match self { + Self::Timeout => ffi::HINAWA_SND_DICE_ERROR_TIMEOUT, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaSndDiceError> for SndDiceError { - fn from_glib(value: hinawa_sys::HinawaSndDiceError) -> Self { +impl FromGlib<ffi::HinawaSndDiceError> for SndDiceError { + unsafe fn from_glib(value: ffi::HinawaSndDiceError) -> Self { match value { - 0 => SndDiceError::Timeout, - value => SndDiceError::__Unknown(value), + ffi::HINAWA_SND_DICE_ERROR_TIMEOUT => Self::Timeout, + value => Self::__Unknown(value), } } } impl ErrorDomain for SndDiceError { fn domain() -> Quark { - unsafe { from_glib(hinawa_sys::hinawa_snd_dice_error_quark()) } + unsafe { from_glib(ffi::hinawa_snd_dice_error_quark()) } } fn code(self) -> i32 { - self.to_glib() + self.into_glib() } fn from(code: i32) -> Option<Self> { match code { - 0 => Some(SndDiceError::Timeout), - value => Some(SndDiceError::__Unknown(value)), + ffi::HINAWA_SND_DICE_ERROR_TIMEOUT => Some(Self::Timeout), + value => Some(Self::__Unknown(value)), } } } impl StaticType for SndDiceError { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_snd_dice_error_get_type()) } + unsafe { from_glib(ffi::hinawa_snd_dice_error_get_type()) } } } -impl<'a> FromValueOptional<'a> for SndDiceError { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for SndDiceError { + type Type = Self; } -impl<'a> FromValue<'a> for SndDiceError { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for SndDiceError { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for SndDiceError { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for SndDiceError { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaSndEfwStatus")] pub enum SndEfwStatus { + #[doc(alias = "HINAWA_SND_EFW_STATUS_OK")] Ok, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD")] Bad, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_COMMAND")] BadCommand, + #[doc(alias = "HINAWA_SND_EFW_STATUS_COMM_ERR")] CommErr, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_QUAD_COUNT")] BadQuadCount, + #[doc(alias = "HINAWA_SND_EFW_STATUS_UNSUPPORTED")] Unsupported, + #[doc(alias = "HINAWA_SND_EFW_STATUS_TIMEOUT")] Timeout, + #[doc(alias = "HINAWA_SND_EFW_STATUS_DSP_TIMEOUT")] DspTimeout, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_RATE")] BadRate, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_CLOCK")] BadClock, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_CHANNEL")] BadChannel, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_PAN")] BadPan, + #[doc(alias = "HINAWA_SND_EFW_STATUS_FLASH_BUSY")] FlashBusy, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_MIRROR")] BadMirror, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_LED")] BadLed, + #[doc(alias = "HINAWA_SND_EFW_STATUS_BAD_PARAMETER")] BadParameter, + #[doc(alias = "HINAWA_SND_EFW_STATUS_LARGE_RESP")] LargeResp, #[doc(hidden)] __Unknown(i32), @@ -632,118 +757,138 @@ pub enum SndEfwStatus { impl fmt::Display for SndEfwStatus { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndEfwStatus::{}", match *self { - SndEfwStatus::Ok => "Ok", - SndEfwStatus::Bad => "Bad", - SndEfwStatus::BadCommand => "BadCommand", - SndEfwStatus::CommErr => "CommErr", - SndEfwStatus::BadQuadCount => "BadQuadCount", - SndEfwStatus::Unsupported => "Unsupported", - SndEfwStatus::Timeout => "Timeout", - SndEfwStatus::DspTimeout => "DspTimeout", - SndEfwStatus::BadRate => "BadRate", - SndEfwStatus::BadClock => "BadClock", - SndEfwStatus::BadChannel => "BadChannel", - SndEfwStatus::BadPan => "BadPan", - SndEfwStatus::FlashBusy => "FlashBusy", - SndEfwStatus::BadMirror => "BadMirror", - SndEfwStatus::BadLed => "BadLed", - SndEfwStatus::BadParameter => "BadParameter", - SndEfwStatus::LargeResp => "LargeResp", - _ => "Unknown", - }) + write!( + f, + "SndEfwStatus::{}", + match *self { + Self::Ok => "Ok", + Self::Bad => "Bad", + Self::BadCommand => "BadCommand", + Self::CommErr => "CommErr", + Self::BadQuadCount => "BadQuadCount", + Self::Unsupported => "Unsupported", + Self::Timeout => "Timeout", + Self::DspTimeout => "DspTimeout", + Self::BadRate => "BadRate", + Self::BadClock => "BadClock", + Self::BadChannel => "BadChannel", + Self::BadPan => "BadPan", + Self::FlashBusy => "FlashBusy", + Self::BadMirror => "BadMirror", + Self::BadLed => "BadLed", + Self::BadParameter => "BadParameter", + Self::LargeResp => "LargeResp", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for SndEfwStatus { - type GlibType = hinawa_sys::HinawaSndEfwStatus; - - fn to_glib(&self) -> hinawa_sys::HinawaSndEfwStatus { - match *self { - SndEfwStatus::Ok => hinawa_sys::HINAWA_SND_EFW_STATUS_OK, - SndEfwStatus::Bad => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD, - SndEfwStatus::BadCommand => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_COMMAND, - SndEfwStatus::CommErr => hinawa_sys::HINAWA_SND_EFW_STATUS_COMM_ERR, - SndEfwStatus::BadQuadCount => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_QUAD_COUNT, - SndEfwStatus::Unsupported => hinawa_sys::HINAWA_SND_EFW_STATUS_UNSUPPORTED, - SndEfwStatus::Timeout => hinawa_sys::HINAWA_SND_EFW_STATUS_TIMEOUT, - SndEfwStatus::DspTimeout => hinawa_sys::HINAWA_SND_EFW_STATUS_DSP_TIMEOUT, - SndEfwStatus::BadRate => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_RATE, - SndEfwStatus::BadClock => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_CLOCK, - SndEfwStatus::BadChannel => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_CHANNEL, - SndEfwStatus::BadPan => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_PAN, - SndEfwStatus::FlashBusy => hinawa_sys::HINAWA_SND_EFW_STATUS_FLASH_BUSY, - SndEfwStatus::BadMirror => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_MIRROR, - SndEfwStatus::BadLed => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_LED, - SndEfwStatus::BadParameter => hinawa_sys::HINAWA_SND_EFW_STATUS_BAD_PARAMETER, - SndEfwStatus::LargeResp => hinawa_sys::HINAWA_SND_EFW_STATUS_LARGE_RESP, - SndEfwStatus::__Unknown(value) => value +impl IntoGlib for SndEfwStatus { + type GlibType = ffi::HinawaSndEfwStatus; + + fn into_glib(self) -> ffi::HinawaSndEfwStatus { + match self { + Self::Ok => ffi::HINAWA_SND_EFW_STATUS_OK, + Self::Bad => ffi::HINAWA_SND_EFW_STATUS_BAD, + Self::BadCommand => ffi::HINAWA_SND_EFW_STATUS_BAD_COMMAND, + Self::CommErr => ffi::HINAWA_SND_EFW_STATUS_COMM_ERR, + Self::BadQuadCount => ffi::HINAWA_SND_EFW_STATUS_BAD_QUAD_COUNT, + Self::Unsupported => ffi::HINAWA_SND_EFW_STATUS_UNSUPPORTED, + Self::Timeout => ffi::HINAWA_SND_EFW_STATUS_TIMEOUT, + Self::DspTimeout => ffi::HINAWA_SND_EFW_STATUS_DSP_TIMEOUT, + Self::BadRate => ffi::HINAWA_SND_EFW_STATUS_BAD_RATE, + Self::BadClock => ffi::HINAWA_SND_EFW_STATUS_BAD_CLOCK, + Self::BadChannel => ffi::HINAWA_SND_EFW_STATUS_BAD_CHANNEL, + Self::BadPan => ffi::HINAWA_SND_EFW_STATUS_BAD_PAN, + Self::FlashBusy => ffi::HINAWA_SND_EFW_STATUS_FLASH_BUSY, + Self::BadMirror => ffi::HINAWA_SND_EFW_STATUS_BAD_MIRROR, + Self::BadLed => ffi::HINAWA_SND_EFW_STATUS_BAD_LED, + Self::BadParameter => ffi::HINAWA_SND_EFW_STATUS_BAD_PARAMETER, + Self::LargeResp => ffi::HINAWA_SND_EFW_STATUS_LARGE_RESP, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaSndEfwStatus> for SndEfwStatus { - fn from_glib(value: hinawa_sys::HinawaSndEfwStatus) -> Self { +impl FromGlib<ffi::HinawaSndEfwStatus> for SndEfwStatus { + unsafe fn from_glib(value: ffi::HinawaSndEfwStatus) -> Self { match value { - 0 => SndEfwStatus::Ok, - 1 => SndEfwStatus::Bad, - 2 => SndEfwStatus::BadCommand, - 3 => SndEfwStatus::CommErr, - 4 => SndEfwStatus::BadQuadCount, - 5 => SndEfwStatus::Unsupported, - 6 => SndEfwStatus::Timeout, - 7 => SndEfwStatus::DspTimeout, - 8 => SndEfwStatus::BadRate, - 9 => SndEfwStatus::BadClock, - 10 => SndEfwStatus::BadChannel, - 11 => SndEfwStatus::BadPan, - 12 => SndEfwStatus::FlashBusy, - 13 => SndEfwStatus::BadMirror, - 14 => SndEfwStatus::BadLed, - 15 => SndEfwStatus::BadParameter, - 16 => SndEfwStatus::LargeResp, - value => SndEfwStatus::__Unknown(value), + ffi::HINAWA_SND_EFW_STATUS_OK => Self::Ok, + ffi::HINAWA_SND_EFW_STATUS_BAD => Self::Bad, + ffi::HINAWA_SND_EFW_STATUS_BAD_COMMAND => Self::BadCommand, + ffi::HINAWA_SND_EFW_STATUS_COMM_ERR => Self::CommErr, + ffi::HINAWA_SND_EFW_STATUS_BAD_QUAD_COUNT => Self::BadQuadCount, + ffi::HINAWA_SND_EFW_STATUS_UNSUPPORTED => Self::Unsupported, + ffi::HINAWA_SND_EFW_STATUS_TIMEOUT => Self::Timeout, + ffi::HINAWA_SND_EFW_STATUS_DSP_TIMEOUT => Self::DspTimeout, + ffi::HINAWA_SND_EFW_STATUS_BAD_RATE => Self::BadRate, + ffi::HINAWA_SND_EFW_STATUS_BAD_CLOCK => Self::BadClock, + ffi::HINAWA_SND_EFW_STATUS_BAD_CHANNEL => Self::BadChannel, + ffi::HINAWA_SND_EFW_STATUS_BAD_PAN => Self::BadPan, + ffi::HINAWA_SND_EFW_STATUS_FLASH_BUSY => Self::FlashBusy, + ffi::HINAWA_SND_EFW_STATUS_BAD_MIRROR => Self::BadMirror, + ffi::HINAWA_SND_EFW_STATUS_BAD_LED => Self::BadLed, + ffi::HINAWA_SND_EFW_STATUS_BAD_PARAMETER => Self::BadParameter, + ffi::HINAWA_SND_EFW_STATUS_LARGE_RESP => Self::LargeResp, + value => Self::__Unknown(value), } } } impl StaticType for SndEfwStatus { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_snd_efw_status_get_type()) } + unsafe { from_glib(ffi::hinawa_snd_efw_status_get_type()) } } } -impl<'a> FromValueOptional<'a> for SndEfwStatus { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for SndEfwStatus { + type Type = Self; } -impl<'a> FromValue<'a> for SndEfwStatus { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for SndEfwStatus { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for SndEfwStatus { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for SndEfwStatus { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaSndUnitError")] pub enum SndUnitError { + #[doc(alias = "HINAWA_SND_UNIT_ERROR_DISCONNECTED")] Disconnected, + #[doc(alias = "HINAWA_SND_UNIT_ERROR_USED")] Used, + #[doc(alias = "HINAWA_SND_UNIT_ERROR_OPENED")] Opened, + #[doc(alias = "HINAWA_SND_UNIT_ERROR_NOT_OPENED")] NotOpened, + #[doc(alias = "HINAWA_SND_UNIT_ERROR_LOCKED")] Locked, + #[doc(alias = "HINAWA_SND_UNIT_ERROR_UNLOCKED")] Unlocked, + #[doc(alias = "HINAWA_SND_UNIT_ERROR_WRONG_CLASS")] WrongClass, + #[doc(alias = "HINAWA_SND_UNIT_ERROR_FAILED")] Failed, #[doc(hidden)] __Unknown(i32), @@ -751,115 +896,135 @@ pub enum SndUnitError { impl fmt::Display for SndUnitError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndUnitError::{}", match *self { - SndUnitError::Disconnected => "Disconnected", - SndUnitError::Used => "Used", - SndUnitError::Opened => "Opened", - SndUnitError::NotOpened => "NotOpened", - SndUnitError::Locked => "Locked", - SndUnitError::Unlocked => "Unlocked", - SndUnitError::WrongClass => "WrongClass", - SndUnitError::Failed => "Failed", - _ => "Unknown", - }) + write!( + f, + "SndUnitError::{}", + match *self { + Self::Disconnected => "Disconnected", + Self::Used => "Used", + Self::Opened => "Opened", + Self::NotOpened => "NotOpened", + Self::Locked => "Locked", + Self::Unlocked => "Unlocked", + Self::WrongClass => "WrongClass", + Self::Failed => "Failed", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for SndUnitError { - type GlibType = hinawa_sys::HinawaSndUnitError; - - fn to_glib(&self) -> hinawa_sys::HinawaSndUnitError { - match *self { - SndUnitError::Disconnected => hinawa_sys::HINAWA_SND_UNIT_ERROR_DISCONNECTED, - SndUnitError::Used => hinawa_sys::HINAWA_SND_UNIT_ERROR_USED, - SndUnitError::Opened => hinawa_sys::HINAWA_SND_UNIT_ERROR_OPENED, - SndUnitError::NotOpened => hinawa_sys::HINAWA_SND_UNIT_ERROR_NOT_OPENED, - SndUnitError::Locked => hinawa_sys::HINAWA_SND_UNIT_ERROR_LOCKED, - SndUnitError::Unlocked => hinawa_sys::HINAWA_SND_UNIT_ERROR_UNLOCKED, - SndUnitError::WrongClass => hinawa_sys::HINAWA_SND_UNIT_ERROR_WRONG_CLASS, - SndUnitError::Failed => hinawa_sys::HINAWA_SND_UNIT_ERROR_FAILED, - SndUnitError::__Unknown(value) => value +impl IntoGlib for SndUnitError { + type GlibType = ffi::HinawaSndUnitError; + + fn into_glib(self) -> ffi::HinawaSndUnitError { + match self { + Self::Disconnected => ffi::HINAWA_SND_UNIT_ERROR_DISCONNECTED, + Self::Used => ffi::HINAWA_SND_UNIT_ERROR_USED, + Self::Opened => ffi::HINAWA_SND_UNIT_ERROR_OPENED, + Self::NotOpened => ffi::HINAWA_SND_UNIT_ERROR_NOT_OPENED, + Self::Locked => ffi::HINAWA_SND_UNIT_ERROR_LOCKED, + Self::Unlocked => ffi::HINAWA_SND_UNIT_ERROR_UNLOCKED, + Self::WrongClass => ffi::HINAWA_SND_UNIT_ERROR_WRONG_CLASS, + Self::Failed => ffi::HINAWA_SND_UNIT_ERROR_FAILED, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaSndUnitError> for SndUnitError { - fn from_glib(value: hinawa_sys::HinawaSndUnitError) -> Self { +impl FromGlib<ffi::HinawaSndUnitError> for SndUnitError { + unsafe fn from_glib(value: ffi::HinawaSndUnitError) -> Self { match value { - 0 => SndUnitError::Disconnected, - 1 => SndUnitError::Used, - 2 => SndUnitError::Opened, - 3 => SndUnitError::NotOpened, - 4 => SndUnitError::Locked, - 5 => SndUnitError::Unlocked, - 6 => SndUnitError::WrongClass, - 7 => SndUnitError::Failed, - value => SndUnitError::__Unknown(value), + ffi::HINAWA_SND_UNIT_ERROR_DISCONNECTED => Self::Disconnected, + ffi::HINAWA_SND_UNIT_ERROR_USED => Self::Used, + ffi::HINAWA_SND_UNIT_ERROR_OPENED => Self::Opened, + ffi::HINAWA_SND_UNIT_ERROR_NOT_OPENED => Self::NotOpened, + ffi::HINAWA_SND_UNIT_ERROR_LOCKED => Self::Locked, + ffi::HINAWA_SND_UNIT_ERROR_UNLOCKED => Self::Unlocked, + ffi::HINAWA_SND_UNIT_ERROR_WRONG_CLASS => Self::WrongClass, + ffi::HINAWA_SND_UNIT_ERROR_FAILED => Self::Failed, + value => Self::__Unknown(value), } } } impl ErrorDomain for SndUnitError { fn domain() -> Quark { - unsafe { from_glib(hinawa_sys::hinawa_snd_unit_error_quark()) } + unsafe { from_glib(ffi::hinawa_snd_unit_error_quark()) } } fn code(self) -> i32 { - self.to_glib() + self.into_glib() } fn from(code: i32) -> Option<Self> { match code { - 0 => Some(SndUnitError::Disconnected), - 1 => Some(SndUnitError::Used), - 2 => Some(SndUnitError::Opened), - 3 => Some(SndUnitError::NotOpened), - 4 => Some(SndUnitError::Locked), - 5 => Some(SndUnitError::Unlocked), - 6 => Some(SndUnitError::WrongClass), - 7 => Some(SndUnitError::Failed), - _ => Some(SndUnitError::Failed), + ffi::HINAWA_SND_UNIT_ERROR_DISCONNECTED => Some(Self::Disconnected), + ffi::HINAWA_SND_UNIT_ERROR_USED => Some(Self::Used), + ffi::HINAWA_SND_UNIT_ERROR_OPENED => Some(Self::Opened), + ffi::HINAWA_SND_UNIT_ERROR_NOT_OPENED => Some(Self::NotOpened), + ffi::HINAWA_SND_UNIT_ERROR_LOCKED => Some(Self::Locked), + ffi::HINAWA_SND_UNIT_ERROR_UNLOCKED => Some(Self::Unlocked), + ffi::HINAWA_SND_UNIT_ERROR_WRONG_CLASS => Some(Self::WrongClass), + ffi::HINAWA_SND_UNIT_ERROR_FAILED => Some(Self::Failed), + _ => Some(Self::Failed), } } } impl StaticType for SndUnitError { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_snd_unit_error_get_type()) } + unsafe { from_glib(ffi::hinawa_snd_unit_error_get_type()) } } } -impl<'a> FromValueOptional<'a> for SndUnitError { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for SndUnitError { + type Type = Self; } -impl<'a> FromValue<'a> for SndUnitError { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for SndUnitError { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for SndUnitError { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for SndUnitError { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } -#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] -#[derive(Clone, Copy)] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] +#[doc(alias = "HinawaSndUnitType")] pub enum SndUnitType { + #[doc(alias = "HINAWA_SND_UNIT_TYPE_DICE")] Dice, + #[doc(alias = "HINAWA_SND_UNIT_TYPE_FIREWORKS")] Fireworks, + #[doc(alias = "HINAWA_SND_UNIT_TYPE_BEBOB")] Bebob, + #[doc(alias = "HINAWA_SND_UNIT_TYPE_OXFW")] Oxfw, + #[doc(alias = "HINAWA_SND_UNIT_TYPE_DIGI00X")] Digi00x, + #[doc(alias = "HINAWA_SND_UNIT_TYPE_TASCAM")] Tascam, + #[doc(alias = "HINAWA_SND_UNIT_TYPE_MOTU")] Motu, + #[doc(alias = "HINAWA_SND_UNIT_TYPE_FIREFACE")] Fireface, #[doc(hidden)] __Unknown(i32), @@ -867,77 +1032,88 @@ pub enum SndUnitType { impl fmt::Display for SndUnitType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndUnitType::{}", match *self { - SndUnitType::Dice => "Dice", - SndUnitType::Fireworks => "Fireworks", - SndUnitType::Bebob => "Bebob", - SndUnitType::Oxfw => "Oxfw", - SndUnitType::Digi00x => "Digi00x", - SndUnitType::Tascam => "Tascam", - SndUnitType::Motu => "Motu", - SndUnitType::Fireface => "Fireface", - _ => "Unknown", - }) + write!( + f, + "SndUnitType::{}", + match *self { + Self::Dice => "Dice", + Self::Fireworks => "Fireworks", + Self::Bebob => "Bebob", + Self::Oxfw => "Oxfw", + Self::Digi00x => "Digi00x", + Self::Tascam => "Tascam", + Self::Motu => "Motu", + Self::Fireface => "Fireface", + _ => "Unknown", + } + ) } } #[doc(hidden)] -impl ToGlib for SndUnitType { - type GlibType = hinawa_sys::HinawaSndUnitType; - - fn to_glib(&self) -> hinawa_sys::HinawaSndUnitType { - match *self { - SndUnitType::Dice => hinawa_sys::HINAWA_SND_UNIT_TYPE_DICE, - SndUnitType::Fireworks => hinawa_sys::HINAWA_SND_UNIT_TYPE_FIREWORKS, - SndUnitType::Bebob => hinawa_sys::HINAWA_SND_UNIT_TYPE_BEBOB, - SndUnitType::Oxfw => hinawa_sys::HINAWA_SND_UNIT_TYPE_OXFW, - SndUnitType::Digi00x => hinawa_sys::HINAWA_SND_UNIT_TYPE_DIGI00X, - SndUnitType::Tascam => hinawa_sys::HINAWA_SND_UNIT_TYPE_TASCAM, - SndUnitType::Motu => hinawa_sys::HINAWA_SND_UNIT_TYPE_MOTU, - SndUnitType::Fireface => hinawa_sys::HINAWA_SND_UNIT_TYPE_FIREFACE, - SndUnitType::__Unknown(value) => value +impl IntoGlib for SndUnitType { + type GlibType = ffi::HinawaSndUnitType; + + fn into_glib(self) -> ffi::HinawaSndUnitType { + match self { + Self::Dice => ffi::HINAWA_SND_UNIT_TYPE_DICE, + Self::Fireworks => ffi::HINAWA_SND_UNIT_TYPE_FIREWORKS, + Self::Bebob => ffi::HINAWA_SND_UNIT_TYPE_BEBOB, + Self::Oxfw => ffi::HINAWA_SND_UNIT_TYPE_OXFW, + Self::Digi00x => ffi::HINAWA_SND_UNIT_TYPE_DIGI00X, + Self::Tascam => ffi::HINAWA_SND_UNIT_TYPE_TASCAM, + Self::Motu => ffi::HINAWA_SND_UNIT_TYPE_MOTU, + Self::Fireface => ffi::HINAWA_SND_UNIT_TYPE_FIREFACE, + Self::__Unknown(value) => value, } } } #[doc(hidden)] -impl FromGlib<hinawa_sys::HinawaSndUnitType> for SndUnitType { - fn from_glib(value: hinawa_sys::HinawaSndUnitType) -> Self { +impl FromGlib<ffi::HinawaSndUnitType> for SndUnitType { + unsafe fn from_glib(value: ffi::HinawaSndUnitType) -> Self { match value { - 1 => SndUnitType::Dice, - 2 => SndUnitType::Fireworks, - 3 => SndUnitType::Bebob, - 4 => SndUnitType::Oxfw, - 5 => SndUnitType::Digi00x, - 6 => SndUnitType::Tascam, - 7 => SndUnitType::Motu, - 8 => SndUnitType::Fireface, - value => SndUnitType::__Unknown(value), + ffi::HINAWA_SND_UNIT_TYPE_DICE => Self::Dice, + ffi::HINAWA_SND_UNIT_TYPE_FIREWORKS => Self::Fireworks, + ffi::HINAWA_SND_UNIT_TYPE_BEBOB => Self::Bebob, + ffi::HINAWA_SND_UNIT_TYPE_OXFW => Self::Oxfw, + ffi::HINAWA_SND_UNIT_TYPE_DIGI00X => Self::Digi00x, + ffi::HINAWA_SND_UNIT_TYPE_TASCAM => Self::Tascam, + ffi::HINAWA_SND_UNIT_TYPE_MOTU => Self::Motu, + ffi::HINAWA_SND_UNIT_TYPE_FIREFACE => Self::Fireface, + value => Self::__Unknown(value), } } } impl StaticType for SndUnitType { fn static_type() -> Type { - unsafe { from_glib(hinawa_sys::hinawa_snd_unit_type_get_type()) } + unsafe { from_glib(ffi::hinawa_snd_unit_type_get_type()) } } } -impl<'a> FromValueOptional<'a> for SndUnitType { - unsafe fn from_value_optional(value: &Value) -> Option<Self> { - Some(FromValue::from_value(value)) - } +impl glib::value::ValueType for SndUnitType { + type Type = Self; } -impl<'a> FromValue<'a> for SndUnitType { - unsafe fn from_value(value: &Value) -> Self { - from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0)) +unsafe impl<'a> FromValue<'a> for SndUnitType { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } -impl SetValue for SndUnitType { - unsafe fn set_value(value: &mut Value, this: &Self) { - gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) +impl ToValue for SndUnitType { + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + fn value_type(&self) -> glib::Type { + Self::static_type() } } - diff --git a/hinawa/src/auto/fw_fcp.rs b/hinawa/src/auto/fw_fcp.rs index f0525e6..969d17a 100644 --- a/hinawa/src/auto/fw_fcp.rs +++ b/hinawa/src/auto/fw_fcp.rs @@ -1,38 +1,35 @@ // 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 glib; +use crate::FwNode; +use crate::FwResp; use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib::StaticType; -use glib::Value; -use glib_sys; -use gobject_sys; -use hinawa_sys; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; -use FwNode; -use FwResp; -glib_wrapper! { - pub struct FwFcp(Object<hinawa_sys::HinawaFwFcp, hinawa_sys::HinawaFwFcpClass, FwFcpClass>) @extends FwResp; +glib::wrapper! { + #[doc(alias = "HinawaFwFcp")] + pub struct FwFcp(Object<ffi::HinawaFwFcp, ffi::HinawaFwFcpClass>) @extends FwResp; match fn { - get_type => || hinawa_sys::hinawa_fw_fcp_get_type(), + type_ => || ffi::hinawa_fw_fcp_get_type(), } } impl FwFcp { + pub const NONE: Option<&'static FwFcp> = None; + + #[doc(alias = "hinawa_fw_fcp_new")] pub fn new() -> FwFcp { - unsafe { - from_glib_full(hinawa_sys::hinawa_fw_fcp_new()) - } + unsafe { from_glib_full(ffi::hinawa_fw_fcp_new()) } } } @@ -42,35 +39,47 @@ impl Default for FwFcp { } } -pub const NONE_FW_FCP: Option<&FwFcp> = None; - pub trait FwFcpExt: 'static { - fn bind<P: IsA<FwNode>>(&self, node: &P) -> Result<(), glib::Error>; + #[doc(alias = "hinawa_fw_fcp_bind")] + fn bind(&self, node: &impl IsA<FwNode>) -> Result<(), glib::Error>; + #[doc(alias = "hinawa_fw_fcp_command")] fn command(&self, cmd: &[u8], timeout_ms: u32) -> Result<(), glib::Error>; + #[doc(alias = "hinawa_fw_fcp_unbind")] fn unbind(&self); - fn get_property_is_bound(&self) -> bool; + #[doc(alias = "is-bound")] + fn is_bound(&self) -> bool; - #[deprecated] - fn get_property_timeout(&self) -> u32; + #[cfg_attr(feature = "v2_1", deprecated = "Since 2.1")] + fn timeout(&self) -> u32; - #[deprecated] - fn set_property_timeout(&self, timeout: u32); + #[cfg_attr(feature = "v2_1", deprecated = "Since 2.1")] + fn set_timeout(&self, timeout: u32); - fn connect_property_is_bound_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "is-bound")] + fn connect_is_bound_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - #[deprecated] - fn connect_property_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[deprecated = "Since 2.1"] + #[doc(alias = "timeout")] + fn connect_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; } impl<O: IsA<FwFcp>> FwFcpExt for O { - fn bind<P: IsA<FwNode>>(&self, node: &P) -> Result<(), glib::Error> { + fn bind(&self, node: &impl IsA<FwNode>) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_fw_fcp_bind(self.as_ref().to_glib_none().0, node.as_ref().to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_fw_fcp_bind( + self.as_ref().to_glib_none().0, + node.as_ref().to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } @@ -78,70 +87,86 @@ impl<O: IsA<FwFcp>> FwFcpExt for O { let cmd_size = cmd.len() as usize; unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_fw_fcp_command(self.as_ref().to_glib_none().0, cmd.to_glib_none().0, cmd_size, timeout_ms, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_fw_fcp_command( + self.as_ref().to_glib_none().0, + cmd.to_glib_none().0, + cmd_size, + timeout_ms, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } fn unbind(&self) { unsafe { - hinawa_sys::hinawa_fw_fcp_unbind(self.as_ref().to_glib_none().0); + ffi::hinawa_fw_fcp_unbind(self.as_ref().to_glib_none().0); } } - fn get_property_is_bound(&self) -> bool { - unsafe { - let mut value = Value::from_type(<bool as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"is-bound\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `is-bound` getter").unwrap() - } + fn is_bound(&self) -> bool { + glib::ObjectExt::property(self.as_ref(), "is-bound") } - fn get_property_timeout(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"timeout\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `timeout` getter").unwrap() - } + fn timeout(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "timeout") } - fn set_property_timeout(&self, timeout: u32) { - unsafe { - gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"timeout\0".as_ptr() as *const _, Value::from(&timeout).to_glib_none().0); - } + fn set_timeout(&self, timeout: u32) { + glib::ObjectExt::set_property(self.as_ref(), "timeout", &timeout) } - fn connect_property_is_bound_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_is_bound_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwFcp, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwFcp> - { + fn connect_is_bound_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_is_bound_trampoline<P: IsA<FwFcp>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwFcp, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwFcp::from_glib_borrow(this).unsafe_cast_ref()) + f(FwFcp::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::is-bound\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_is_bound_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::is-bound\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_is_bound_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwFcp, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwFcp> - { + fn connect_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_timeout_trampoline<P: IsA<FwFcp>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwFcp, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwFcp::from_glib_borrow(this).unsafe_cast_ref()) + f(FwFcp::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::timeout\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_timeout_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::timeout\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_timeout_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for FwFcp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwFcp") + f.write_str("FwFcp") } } diff --git a/hinawa/src/auto/fw_node.rs b/hinawa/src/auto/fw_node.rs index daeff6d..4ca530c 100644 --- a/hinawa/src/auto/fw_node.rs +++ b/hinawa/src/auto/fw_node.rs @@ -1,36 +1,33 @@ // 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 glib; use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib::StaticType; -use glib::Value; -use glib_sys; -use gobject_sys; -use hinawa_sys; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; -glib_wrapper! { - pub struct FwNode(Object<hinawa_sys::HinawaFwNode, hinawa_sys::HinawaFwNodeClass, FwNodeClass>); +glib::wrapper! { + #[doc(alias = "HinawaFwNode")] + pub struct FwNode(Object<ffi::HinawaFwNode, ffi::HinawaFwNodeClass>); match fn { - get_type => || hinawa_sys::hinawa_fw_node_get_type(), + type_ => || ffi::hinawa_fw_node_get_type(), } } impl FwNode { + pub const NONE: Option<&'static FwNode> = None; + + #[doc(alias = "hinawa_fw_node_new")] pub fn new() -> FwNode { - unsafe { - from_glib_full(hinawa_sys::hinawa_fw_node_new()) - } + unsafe { from_glib_full(ffi::hinawa_fw_node_new()) } } } @@ -40,40 +37,53 @@ impl Default for FwNode { } } -pub const NONE_FW_NODE: Option<&FwNode> = None; - pub trait FwNodeExt: 'static { + #[doc(alias = "hinawa_fw_node_create_source")] fn create_source(&self) -> Result<glib::Source, glib::Error>; + #[doc(alias = "hinawa_fw_node_open")] fn open(&self, path: &str) -> Result<(), glib::Error>; - fn get_property_bus_manager_node_id(&self) -> u32; + #[doc(alias = "bus-manager-node-id")] + fn bus_manager_node_id(&self) -> u32; - fn get_property_generation(&self) -> u32; + fn generation(&self) -> u32; - fn get_property_ir_manager_node_id(&self) -> u32; + #[doc(alias = "ir-manager-node-id")] + fn ir_manager_node_id(&self) -> u32; - fn get_property_local_node_id(&self) -> u32; + #[doc(alias = "local-node-id")] + fn local_node_id(&self) -> u32; - fn get_property_node_id(&self) -> u32; + #[doc(alias = "node-id")] + fn node_id(&self) -> u32; - fn get_property_root_node_id(&self) -> u32; + #[doc(alias = "root-node-id")] + fn root_node_id(&self) -> u32; + #[doc(alias = "bus-update")] fn connect_bus_update<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "disconnected")] fn connect_disconnected<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_bus_manager_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "bus-manager-node-id")] + fn connect_bus_manager_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_generation_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "generation")] + fn connect_generation_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_ir_manager_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "ir-manager-node-id")] + fn connect_ir_manager_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_local_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "local-node-id")] + fn connect_local_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "node-id")] + fn connect_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_root_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "root-node-id")] + fn connect_root_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; } impl<O: IsA<FwNode>> FwNodeExt for O { @@ -81,182 +91,245 @@ impl<O: IsA<FwNode>> FwNodeExt for O { unsafe { let mut gsrc = ptr::null_mut(); let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_fw_node_create_source(self.as_ref().to_glib_none().0, &mut gsrc, &mut error); - if error.is_null() { Ok(from_glib_full(gsrc)) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_fw_node_create_source( + self.as_ref().to_glib_none().0, + &mut gsrc, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(gsrc)) + } else { + Err(from_glib_full(error)) + } } } fn open(&self, path: &str) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_fw_node_open(self.as_ref().to_glib_none().0, path.to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_fw_node_open( + self.as_ref().to_glib_none().0, + path.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } - fn get_property_bus_manager_node_id(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"bus-manager-node-id\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `bus-manager-node-id` getter").unwrap() - } + fn bus_manager_node_id(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "bus-manager-node-id") } - fn get_property_generation(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"generation\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `generation` getter").unwrap() - } + fn generation(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "generation") } - fn get_property_ir_manager_node_id(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"ir-manager-node-id\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `ir-manager-node-id` getter").unwrap() - } + fn ir_manager_node_id(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "ir-manager-node-id") } - fn get_property_local_node_id(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"local-node-id\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `local-node-id` getter").unwrap() - } + fn local_node_id(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "local-node-id") } - fn get_property_node_id(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"node-id\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `node-id` getter").unwrap() - } + fn node_id(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "node-id") } - fn get_property_root_node_id(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"root-node-id\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `root-node-id` getter").unwrap() - } + fn root_node_id(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "root-node-id") } fn connect_bus_update<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn bus_update_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwNode, f: glib_sys::gpointer) - where P: IsA<FwNode> - { + unsafe extern "C" fn bus_update_trampoline<P: IsA<FwNode>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwNode, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwNode::from_glib_borrow(this).unsafe_cast_ref()) + f(FwNode::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"bus-update\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(bus_update_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"bus-update\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + bus_update_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } fn connect_disconnected<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn disconnected_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwNode, f: glib_sys::gpointer) - where P: IsA<FwNode> - { + unsafe extern "C" fn disconnected_trampoline<P: IsA<FwNode>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwNode, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwNode::from_glib_borrow(this).unsafe_cast_ref()) + f(FwNode::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"disconnected\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(disconnected_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"disconnected\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + disconnected_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_bus_manager_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_bus_manager_node_id_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwNode, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwNode> - { + fn connect_bus_manager_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_bus_manager_node_id_trampoline< + P: IsA<FwNode>, + F: Fn(&P) + 'static, + >( + this: *mut ffi::HinawaFwNode, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwNode::from_glib_borrow(this).unsafe_cast_ref()) + f(FwNode::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::bus-manager-node-id\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_bus_manager_node_id_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::bus-manager-node-id\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_bus_manager_node_id_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_generation_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_generation_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwNode, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwNode> - { + fn connect_generation_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_generation_trampoline<P: IsA<FwNode>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwNode, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwNode::from_glib_borrow(this).unsafe_cast_ref()) + f(FwNode::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::generation\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_generation_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::generation\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_generation_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_ir_manager_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_ir_manager_node_id_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwNode, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwNode> - { + fn connect_ir_manager_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_ir_manager_node_id_trampoline< + P: IsA<FwNode>, + F: Fn(&P) + 'static, + >( + this: *mut ffi::HinawaFwNode, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwNode::from_glib_borrow(this).unsafe_cast_ref()) + f(FwNode::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::ir-manager-node-id\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_ir_manager_node_id_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::ir-manager-node-id\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_ir_manager_node_id_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_local_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_local_node_id_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwNode, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwNode> - { + fn connect_local_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_local_node_id_trampoline< + P: IsA<FwNode>, + F: Fn(&P) + 'static, + >( + this: *mut ffi::HinawaFwNode, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwNode::from_glib_borrow(this).unsafe_cast_ref()) + f(FwNode::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::local-node-id\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_local_node_id_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::local-node-id\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_local_node_id_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_node_id_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwNode, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwNode> - { + fn connect_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_node_id_trampoline<P: IsA<FwNode>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwNode, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwNode::from_glib_borrow(this).unsafe_cast_ref()) + f(FwNode::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::node-id\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_node_id_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::node-id\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_node_id_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_root_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_root_node_id_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwNode, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwNode> - { + fn connect_root_node_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_root_node_id_trampoline<P: IsA<FwNode>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwNode, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwNode::from_glib_borrow(this).unsafe_cast_ref()) + f(FwNode::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::root-node-id\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_root_node_id_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::root-node-id\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_root_node_id_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for FwNode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwNode") + f.write_str("FwNode") } } diff --git a/hinawa/src/auto/fw_req.rs b/hinawa/src/auto/fw_req.rs index 1e73e83..738c1f6 100644 --- a/hinawa/src/auto/fw_req.rs +++ b/hinawa/src/auto/fw_req.rs @@ -1,4 +1,5 @@ // 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 @@ -7,28 +8,25 @@ use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib::StaticType; -use glib::Value; -use glib_sys; -use gobject_sys; -use hinawa_sys; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; -glib_wrapper! { - pub struct FwReq(Object<hinawa_sys::HinawaFwReq, hinawa_sys::HinawaFwReqClass, FwReqClass>); +glib::wrapper! { + #[doc(alias = "HinawaFwReq")] + pub struct FwReq(Object<ffi::HinawaFwReq, ffi::HinawaFwReqClass>); match fn { - get_type => || hinawa_sys::hinawa_fw_req_get_type(), + type_ => || ffi::hinawa_fw_req_get_type(), } } impl FwReq { + pub const NONE: Option<&'static FwReq> = None; + + #[doc(alias = "hinawa_fw_req_new")] pub fn new() -> FwReq { - unsafe { - from_glib_full(hinawa_sys::hinawa_fw_req_new()) - } + unsafe { from_glib_full(ffi::hinawa_fw_req_new()) } } } @@ -38,51 +36,52 @@ impl Default for FwReq { } } -pub const NONE_FW_REQ: Option<&FwReq> = None; - pub trait FwReqExt: 'static { - #[deprecated] - fn get_property_timeout(&self) -> u32; + #[cfg_attr(feature = "v2_1", deprecated = "Since 2.1")] + fn timeout(&self) -> u32; - #[deprecated] - fn set_property_timeout(&self, timeout: u32); + #[cfg_attr(feature = "v2_1", deprecated = "Since 2.1")] + fn set_timeout(&self, timeout: u32); - #[deprecated] - fn connect_property_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[deprecated = "Since 2.1"] + #[doc(alias = "timeout")] + fn connect_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; } impl<O: IsA<FwReq>> FwReqExt for O { - fn get_property_timeout(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"timeout\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `timeout` getter").unwrap() - } + fn timeout(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "timeout") } - fn set_property_timeout(&self, timeout: u32) { - unsafe { - gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"timeout\0".as_ptr() as *const _, Value::from(&timeout).to_glib_none().0); - } + fn set_timeout(&self, timeout: u32) { + glib::ObjectExt::set_property(self.as_ref(), "timeout", &timeout) } - fn connect_property_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwReq, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwReq> - { + fn connect_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_timeout_trampoline<P: IsA<FwReq>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwReq, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwReq::from_glib_borrow(this).unsafe_cast_ref()) + f(FwReq::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::timeout\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_timeout_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::timeout\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_timeout_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for FwReq { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwReq") + f.write_str("FwReq") } } diff --git a/hinawa/src/auto/fw_resp.rs b/hinawa/src/auto/fw_resp.rs index ca98b84..26229f1 100644 --- a/hinawa/src/auto/fw_resp.rs +++ b/hinawa/src/auto/fw_resp.rs @@ -1,39 +1,36 @@ // 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 glib; +use crate::FwNode; +use crate::FwRcode; +use crate::FwTcode; use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib::StaticType; -use glib::Value; -use glib_sys; -use gobject_sys; -use hinawa_sys; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; -use FwNode; -use FwRcode; -use FwTcode; -glib_wrapper! { - pub struct FwResp(Object<hinawa_sys::HinawaFwResp, hinawa_sys::HinawaFwRespClass, FwRespClass>); +glib::wrapper! { + #[doc(alias = "HinawaFwResp")] + pub struct FwResp(Object<ffi::HinawaFwResp, ffi::HinawaFwRespClass>); match fn { - get_type => || hinawa_sys::hinawa_fw_resp_get_type(), + type_ => || ffi::hinawa_fw_resp_get_type(), } } impl FwResp { + pub const NONE: Option<&'static FwResp> = None; + + #[doc(alias = "hinawa_fw_resp_new")] pub fn new() -> FwResp { - unsafe { - from_glib_full(hinawa_sys::hinawa_fw_resp_new()) - } + unsafe { from_glib_full(ffi::hinawa_fw_resp_new()) } } } @@ -43,146 +40,223 @@ impl Default for FwResp { } } -pub const NONE_FW_RESP: Option<&FwResp> = None; - pub trait FwRespExt: 'static { + #[doc(alias = "hinawa_fw_resp_release")] fn release(&self); - fn reserve<P: IsA<FwNode>>(&self, node: &P, addr: u64, width: u32) -> Result<(), glib::Error>; + #[doc(alias = "hinawa_fw_resp_reserve")] + fn reserve(&self, node: &impl IsA<FwNode>, addr: u64, width: u32) -> Result<(), glib::Error>; - fn reserve_within_region<P: IsA<FwNode>>(&self, node: &P, region_start: u64, region_end: u64, width: u32) -> Result<(), glib::Error>; + #[doc(alias = "hinawa_fw_resp_reserve_within_region")] + fn reserve_within_region( + &self, + node: &impl IsA<FwNode>, + region_start: u64, + region_end: u64, + width: u32, + ) -> Result<(), glib::Error>; + #[doc(alias = "hinawa_fw_resp_set_resp_frame")] fn set_resp_frame(&self, frame: &[u8]); - fn get_property_is_reserved(&self) -> bool; + #[doc(alias = "is-reserved")] + fn is_reserved(&self) -> bool; - fn get_property_offset(&self) -> u64; + fn offset(&self) -> u64; - fn get_property_width(&self) -> u32; + fn width(&self) -> u32; - #[deprecated] - fn connect_requested<F: Fn(&Self, FwTcode) -> FwRcode + 'static>(&self, f: F) -> SignalHandlerId; + #[deprecated = "Since 2.2"] + #[doc(alias = "requested")] + fn connect_requested<F: Fn(&Self, FwTcode) -> FwRcode + 'static>( + &self, + f: F, + ) -> SignalHandlerId; - fn connect_property_is_reserved_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "is-reserved")] + fn connect_is_reserved_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_offset_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "offset")] + fn connect_offset_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "width")] + fn connect_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; } impl<O: IsA<FwResp>> FwRespExt for O { fn release(&self) { unsafe { - hinawa_sys::hinawa_fw_resp_release(self.as_ref().to_glib_none().0); + ffi::hinawa_fw_resp_release(self.as_ref().to_glib_none().0); } } - fn reserve<P: IsA<FwNode>>(&self, node: &P, addr: u64, width: u32) -> Result<(), glib::Error> { + fn reserve(&self, node: &impl IsA<FwNode>, addr: u64, width: u32) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_fw_resp_reserve(self.as_ref().to_glib_none().0, node.as_ref().to_glib_none().0, addr, width, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_fw_resp_reserve( + self.as_ref().to_glib_none().0, + node.as_ref().to_glib_none().0, + addr, + width, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } - fn reserve_within_region<P: IsA<FwNode>>(&self, node: &P, region_start: u64, region_end: u64, width: u32) -> Result<(), glib::Error> { + fn reserve_within_region( + &self, + node: &impl IsA<FwNode>, + region_start: u64, + region_end: u64, + width: u32, + ) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_fw_resp_reserve_within_region(self.as_ref().to_glib_none().0, node.as_ref().to_glib_none().0, region_start, region_end, width, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_fw_resp_reserve_within_region( + self.as_ref().to_glib_none().0, + node.as_ref().to_glib_none().0, + region_start, + region_end, + width, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } fn set_resp_frame(&self, frame: &[u8]) { let length = frame.len() as usize; unsafe { - hinawa_sys::hinawa_fw_resp_set_resp_frame(self.as_ref().to_glib_none().0, frame.to_glib_none().0, length); + ffi::hinawa_fw_resp_set_resp_frame( + self.as_ref().to_glib_none().0, + frame.to_glib_none().0, + length, + ); } } - fn get_property_is_reserved(&self) -> bool { - unsafe { - let mut value = Value::from_type(<bool as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"is-reserved\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `is-reserved` getter").unwrap() - } + fn is_reserved(&self) -> bool { + glib::ObjectExt::property(self.as_ref(), "is-reserved") } - fn get_property_offset(&self) -> u64 { - unsafe { - let mut value = Value::from_type(<u64 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"offset\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `offset` getter").unwrap() - } + fn offset(&self) -> u64 { + glib::ObjectExt::property(self.as_ref(), "offset") } - fn get_property_width(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"width\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `width` getter").unwrap() - } + fn width(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "width") } - fn connect_requested<F: Fn(&Self, FwTcode) -> FwRcode + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn requested_trampoline<P, F: Fn(&P, FwTcode) -> FwRcode + 'static>(this: *mut hinawa_sys::HinawaFwResp, tcode: hinawa_sys::HinawaFwTcode, f: glib_sys::gpointer) -> hinawa_sys::HinawaFwRcode - where P: IsA<FwResp> - { + fn connect_requested<F: Fn(&Self, FwTcode) -> FwRcode + 'static>( + &self, + f: F, + ) -> SignalHandlerId { + unsafe extern "C" fn requested_trampoline< + P: IsA<FwResp>, + F: Fn(&P, FwTcode) -> FwRcode + 'static, + >( + this: *mut ffi::HinawaFwResp, + tcode: ffi::HinawaFwTcode, + f: glib::ffi::gpointer, + ) -> ffi::HinawaFwRcode { let f: &F = &*(f as *const F); - f(&FwResp::from_glib_borrow(this).unsafe_cast_ref(), from_glib(tcode)).to_glib() + f( + FwResp::from_glib_borrow(this).unsafe_cast_ref(), + from_glib(tcode), + ) + .into_glib() } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"requested\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(requested_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"requested\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + requested_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_is_reserved_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_is_reserved_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwResp, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwResp> - { + fn connect_is_reserved_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_is_reserved_trampoline<P: IsA<FwResp>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwResp, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwResp::from_glib_borrow(this).unsafe_cast_ref()) + f(FwResp::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::is-reserved\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_is_reserved_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::is-reserved\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_is_reserved_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_offset_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_offset_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwResp, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwResp> - { + fn connect_offset_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_offset_trampoline<P: IsA<FwResp>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwResp, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwResp::from_glib_borrow(this).unsafe_cast_ref()) + f(FwResp::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::offset\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_offset_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::offset\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_offset_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_width_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaFwResp, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<FwResp> - { + fn connect_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_width_trampoline<P: IsA<FwResp>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaFwResp, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&FwResp::from_glib_borrow(this).unsafe_cast_ref()) + f(FwResp::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::width\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_width_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::width\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_width_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for FwResp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "FwResp") + f.write_str("FwResp") } } diff --git a/hinawa/src/auto/mod.rs b/hinawa/src/auto/mod.rs index fd50688..6ad08fc 100644 --- a/hinawa/src/auto/mod.rs +++ b/hinawa/src/auto/mod.rs @@ -1,46 +1,37 @@ // 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 mod fw_fcp; -pub use self::fw_fcp::{FwFcp, FwFcpClass, NONE_FW_FCP}; -pub use self::fw_fcp::FwFcpExt; +pub use self::fw_fcp::FwFcp; mod fw_node; -pub use self::fw_node::{FwNode, FwNodeClass, NONE_FW_NODE}; -pub use self::fw_node::FwNodeExt; +pub use self::fw_node::FwNode; mod fw_req; -pub use self::fw_req::{FwReq, FwReqClass, NONE_FW_REQ}; -pub use self::fw_req::FwReqExt; +pub use self::fw_req::FwReq; mod fw_resp; -pub use self::fw_resp::{FwResp, FwRespClass, NONE_FW_RESP}; -pub use self::fw_resp::FwRespExt; +pub use self::fw_resp::FwResp; mod snd_dg00x; -pub use self::snd_dg00x::{SndDg00x, SndDg00xClass, NONE_SND_DG00X}; -pub use self::snd_dg00x::SndDg00xExt; +pub use self::snd_dg00x::SndDg00x; mod snd_dice; -pub use self::snd_dice::{SndDice, SndDiceClass, NONE_SND_DICE}; -pub use self::snd_dice::SndDiceExt; +pub use self::snd_dice::SndDice; mod snd_efw; -pub use self::snd_efw::{SndEfw, SndEfwClass, NONE_SND_EFW}; -pub use self::snd_efw::SndEfwExt; +pub use self::snd_efw::SndEfw; mod snd_motu; -pub use self::snd_motu::{SndMotu, SndMotuClass, NONE_SND_MOTU}; -pub use self::snd_motu::SndMotuExt; +pub use self::snd_motu::SndMotu; mod snd_tscm; -pub use self::snd_tscm::{SndTscm, SndTscmClass, NONE_SND_TSCM}; -pub use self::snd_tscm::SndTscmExt; +pub use self::snd_tscm::SndTscm; mod snd_unit; -pub use self::snd_unit::{SndUnit, SndUnitClass, NONE_SND_UNIT}; -pub use self::snd_unit::SndUnitExt; +pub use self::snd_unit::SndUnit; mod snd_motu_register_dsp_parameter; pub use self::snd_motu_register_dsp_parameter::SndMotuRegisterDspParameter; @@ -58,14 +49,14 @@ pub use self::enums::SndUnitType; #[doc(hidden)] pub mod traits { - pub use super::FwFcpExt; - pub use super::FwNodeExt; - pub use super::FwReqExt; - pub use super::FwRespExt; - pub use super::SndDg00xExt; - pub use super::SndDiceExt; - pub use super::SndEfwExt; - pub use super::SndMotuExt; - pub use super::SndTscmExt; - pub use super::SndUnitExt; + pub use super::fw_fcp::FwFcpExt; + pub use super::fw_node::FwNodeExt; + pub use super::fw_req::FwReqExt; + pub use super::fw_resp::FwRespExt; + pub use super::snd_dg00x::SndDg00xExt; + pub use super::snd_dice::SndDiceExt; + pub use super::snd_efw::SndEfwExt; + pub use super::snd_motu::SndMotuExt; + pub use super::snd_tscm::SndTscmExt; + pub use super::snd_unit::SndUnitExt; } diff --git a/hinawa/src/auto/snd_dg00x.rs b/hinawa/src/auto/snd_dg00x.rs index 368110d..a3e9ae9 100644 --- a/hinawa/src/auto/snd_dg00x.rs +++ b/hinawa/src/auto/snd_dg00x.rs @@ -1,35 +1,34 @@ // 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 glib; +use crate::SndUnit; use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib_sys; -use hinawa_sys; -use libc; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; -use SndUnit; -glib_wrapper! { - pub struct SndDg00x(Object<hinawa_sys::HinawaSndDg00x, hinawa_sys::HinawaSndDg00xClass, SndDg00xClass>) @extends SndUnit; +glib::wrapper! { + #[doc(alias = "HinawaSndDg00x")] + pub struct SndDg00x(Object<ffi::HinawaSndDg00x, ffi::HinawaSndDg00xClass>) @extends SndUnit; match fn { - get_type => || hinawa_sys::hinawa_snd_dg00x_get_type(), + type_ => || ffi::hinawa_snd_dg00x_get_type(), } } impl SndDg00x { + pub const NONE: Option<&'static SndDg00x> = None; + + #[doc(alias = "hinawa_snd_dg00x_new")] pub fn new() -> SndDg00x { - unsafe { - from_glib_full(hinawa_sys::hinawa_snd_dg00x_new()) - } + unsafe { from_glib_full(ffi::hinawa_snd_dg00x_new()) } } } @@ -39,11 +38,11 @@ impl Default for SndDg00x { } } -pub const NONE_SND_DG00X: Option<&SndDg00x> = None; - pub trait SndDg00xExt: 'static { + #[doc(alias = "hinawa_snd_dg00x_open")] fn open(&self, path: &str) -> Result<(), glib::Error>; + #[doc(alias = "message")] fn connect_message<F: Fn(&Self, u32) + 'static>(&self, f: F) -> SignalHandlerId; } @@ -51,28 +50,44 @@ impl<O: IsA<SndDg00x>> SndDg00xExt for O { fn open(&self, path: &str) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_dg00x_open(self.as_ref().to_glib_none().0, path.to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_dg00x_open( + self.as_ref().to_glib_none().0, + path.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } fn connect_message<F: Fn(&Self, u32) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn message_trampoline<P, F: Fn(&P, u32) + 'static>(this: *mut hinawa_sys::HinawaSndDg00x, message: libc::c_uint, f: glib_sys::gpointer) - where P: IsA<SndDg00x> - { + unsafe extern "C" fn message_trampoline<P: IsA<SndDg00x>, F: Fn(&P, u32) + 'static>( + this: *mut ffi::HinawaSndDg00x, + message: libc::c_uint, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndDg00x::from_glib_borrow(this).unsafe_cast_ref(), message) + f(SndDg00x::from_glib_borrow(this).unsafe_cast_ref(), message) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"message\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(message_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"message\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + message_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for SndDg00x { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndDg00x") + f.write_str("SndDg00x") } } diff --git a/hinawa/src/auto/snd_dice.rs b/hinawa/src/auto/snd_dice.rs index afa80d1..9009f4e 100644 --- a/hinawa/src/auto/snd_dice.rs +++ b/hinawa/src/auto/snd_dice.rs @@ -1,35 +1,34 @@ // 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 glib; +use crate::SndUnit; use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib_sys; -use hinawa_sys; -use libc; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; -use SndUnit; -glib_wrapper! { - pub struct SndDice(Object<hinawa_sys::HinawaSndDice, hinawa_sys::HinawaSndDiceClass, SndDiceClass>) @extends SndUnit; +glib::wrapper! { + #[doc(alias = "HinawaSndDice")] + pub struct SndDice(Object<ffi::HinawaSndDice, ffi::HinawaSndDiceClass>) @extends SndUnit; match fn { - get_type => || hinawa_sys::hinawa_snd_dice_get_type(), + type_ => || ffi::hinawa_snd_dice_get_type(), } } impl SndDice { + pub const NONE: Option<&'static SndDice> = None; + + #[doc(alias = "hinawa_snd_dice_new")] pub fn new() -> SndDice { - unsafe { - from_glib_full(hinawa_sys::hinawa_snd_dice_new()) - } + unsafe { from_glib_full(ffi::hinawa_snd_dice_new()) } } } @@ -39,13 +38,14 @@ impl Default for SndDice { } } -pub const NONE_SND_DICE: Option<&SndDice> = None; - pub trait SndDiceExt: 'static { + #[doc(alias = "hinawa_snd_dice_open")] fn open(&self, path: &str) -> Result<(), glib::Error>; + #[doc(alias = "hinawa_snd_dice_transaction")] fn transaction(&self, addr: u64, frame: &[u32], bit_flag: u32) -> Result<(), glib::Error>; + #[doc(alias = "notified")] fn connect_notified<F: Fn(&Self, u32) + 'static>(&self, f: F) -> SignalHandlerId; } @@ -53,8 +53,16 @@ impl<O: IsA<SndDice>> SndDiceExt for O { fn open(&self, path: &str) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_dice_open(self.as_ref().to_glib_none().0, path.to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_dice_open( + self.as_ref().to_glib_none().0, + path.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } @@ -62,28 +70,47 @@ impl<O: IsA<SndDice>> SndDiceExt for O { let frame_count = frame.len() as usize; unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_dice_transaction(self.as_ref().to_glib_none().0, addr, frame.to_glib_none().0, frame_count, bit_flag, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_dice_transaction( + self.as_ref().to_glib_none().0, + addr, + frame.to_glib_none().0, + frame_count, + bit_flag, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } fn connect_notified<F: Fn(&Self, u32) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notified_trampoline<P, F: Fn(&P, u32) + 'static>(this: *mut hinawa_sys::HinawaSndDice, message: libc::c_uint, f: glib_sys::gpointer) - where P: IsA<SndDice> - { + unsafe extern "C" fn notified_trampoline<P: IsA<SndDice>, F: Fn(&P, u32) + 'static>( + this: *mut ffi::HinawaSndDice, + message: libc::c_uint, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndDice::from_glib_borrow(this).unsafe_cast_ref(), message) + f(SndDice::from_glib_borrow(this).unsafe_cast_ref(), message) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notified\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notified_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notified\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notified_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for SndDice { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndDice") + f.write_str("SndDice") } } diff --git a/hinawa/src/auto/snd_efw.rs b/hinawa/src/auto/snd_efw.rs index d80458e..0baefb1 100644 --- a/hinawa/src/auto/snd_efw.rs +++ b/hinawa/src/auto/snd_efw.rs @@ -1,29 +1,30 @@ // 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 glib; +use crate::SndUnit; use glib::object::IsA; use glib::translate::*; -use hinawa_sys; use std::fmt; use std::mem; use std::ptr; -use SndUnit; -glib_wrapper! { - pub struct SndEfw(Object<hinawa_sys::HinawaSndEfw, hinawa_sys::HinawaSndEfwClass, SndEfwClass>) @extends SndUnit; +glib::wrapper! { + #[doc(alias = "HinawaSndEfw")] + pub struct SndEfw(Object<ffi::HinawaSndEfw, ffi::HinawaSndEfwClass>) @extends SndUnit; match fn { - get_type => || hinawa_sys::hinawa_snd_efw_get_type(), + type_ => || ffi::hinawa_snd_efw_get_type(), } } impl SndEfw { + pub const NONE: Option<&'static SndEfw> = None; + + #[doc(alias = "hinawa_snd_efw_new")] pub fn new() -> SndEfw { - unsafe { - from_glib_full(hinawa_sys::hinawa_snd_efw_new()) - } + unsafe { from_glib_full(ffi::hinawa_snd_efw_new()) } } } @@ -33,37 +34,67 @@ impl Default for SndEfw { } } -pub const NONE_SND_EFW: Option<&SndEfw> = None; - pub trait SndEfwExt: 'static { + #[doc(alias = "hinawa_snd_efw_open")] fn open(&self, path: &str) -> Result<(), glib::Error>; - fn transaction_async(&self, category: u32, command: u32, args: &[u32]) -> Result<u32, glib::Error>; + #[doc(alias = "hinawa_snd_efw_transaction_async")] + fn transaction_async( + &self, + category: u32, + command: u32, + args: &[u32], + ) -> Result<u32, glib::Error>; } impl<O: IsA<SndEfw>> SndEfwExt for O { fn open(&self, path: &str) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_efw_open(self.as_ref().to_glib_none().0, path.to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_efw_open( + self.as_ref().to_glib_none().0, + path.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } - fn transaction_async(&self, category: u32, command: u32, args: &[u32]) -> Result<u32, glib::Error> { + fn transaction_async( + &self, + category: u32, + command: u32, + args: &[u32], + ) -> Result<u32, glib::Error> { let arg_count = args.len() as usize; unsafe { let mut resp_seqnum = mem::MaybeUninit::uninit(); let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_efw_transaction_async(self.as_ref().to_glib_none().0, category, command, args.to_glib_none().0, arg_count, resp_seqnum.as_mut_ptr(), &mut error); + let _ = ffi::hinawa_snd_efw_transaction_async( + self.as_ref().to_glib_none().0, + category, + command, + args.to_glib_none().0, + arg_count, + resp_seqnum.as_mut_ptr(), + &mut error, + ); let resp_seqnum = resp_seqnum.assume_init(); - if error.is_null() { Ok(resp_seqnum) } else { Err(from_glib_full(error)) } + if error.is_null() { + Ok(resp_seqnum) + } else { + Err(from_glib_full(error)) + } } } } impl fmt::Display for SndEfw { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndEfw") + f.write_str("SndEfw") } } diff --git a/hinawa/src/auto/snd_motu.rs b/hinawa/src/auto/snd_motu.rs index 821e70b..48b7806 100644 --- a/hinawa/src/auto/snd_motu.rs +++ b/hinawa/src/auto/snd_motu.rs @@ -1,35 +1,34 @@ // 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 glib; +use crate::SndUnit; use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib_sys; -use hinawa_sys; -use libc; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; -use SndUnit; -glib_wrapper! { - pub struct SndMotu(Object<hinawa_sys::HinawaSndMotu, hinawa_sys::HinawaSndMotuClass, SndMotuClass>) @extends SndUnit; +glib::wrapper! { + #[doc(alias = "HinawaSndMotu")] + pub struct SndMotu(Object<ffi::HinawaSndMotu, ffi::HinawaSndMotuClass>) @extends SndUnit; match fn { - get_type => || hinawa_sys::hinawa_snd_motu_get_type(), + type_ => || ffi::hinawa_snd_motu_get_type(), } } impl SndMotu { + pub const NONE: Option<&'static SndMotu> = None; + + #[doc(alias = "hinawa_snd_motu_new")] pub fn new() -> SndMotu { - unsafe { - from_glib_full(hinawa_sys::hinawa_snd_motu_new()) - } + unsafe { from_glib_full(ffi::hinawa_snd_motu_new()) } } } @@ -39,11 +38,11 @@ impl Default for SndMotu { } } -pub const NONE_SND_MOTU: Option<&SndMotu> = None; - pub trait SndMotuExt: 'static { + #[doc(alias = "hinawa_snd_motu_open")] fn open(&self, path: &str) -> Result<(), glib::Error>; + #[doc(alias = "notified")] fn connect_notified<F: Fn(&Self, u32) + 'static>(&self, f: F) -> SignalHandlerId; } @@ -51,28 +50,44 @@ impl<O: IsA<SndMotu>> SndMotuExt for O { fn open(&self, path: &str) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_motu_open(self.as_ref().to_glib_none().0, path.to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_motu_open( + self.as_ref().to_glib_none().0, + path.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } fn connect_notified<F: Fn(&Self, u32) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notified_trampoline<P, F: Fn(&P, u32) + 'static>(this: *mut hinawa_sys::HinawaSndMotu, message: libc::c_uint, f: glib_sys::gpointer) - where P: IsA<SndMotu> - { + unsafe extern "C" fn notified_trampoline<P: IsA<SndMotu>, F: Fn(&P, u32) + 'static>( + this: *mut ffi::HinawaSndMotu, + message: libc::c_uint, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndMotu::from_glib_borrow(this).unsafe_cast_ref(), message) + f(SndMotu::from_glib_borrow(this).unsafe_cast_ref(), message) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notified\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notified_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notified\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notified_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for SndMotu { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndMotu") + f.write_str("SndMotu") } } diff --git a/hinawa/src/auto/snd_motu_register_dsp_parameter.rs b/hinawa/src/auto/snd_motu_register_dsp_parameter.rs index 6766b71..673c8ec 100644 --- a/hinawa/src/auto/snd_motu_register_dsp_parameter.rs +++ b/hinawa/src/auto/snd_motu_register_dsp_parameter.rs @@ -1,70 +1,93 @@ // 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 glib::translate::*; -use gobject_sys; -use hinawa_sys; use std::mem; -glib_wrapper! { +glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct SndMotuRegisterDspParameter(Boxed<hinawa_sys::HinawaSndMotuRegisterDspParameter>); + pub struct SndMotuRegisterDspParameter(Boxed<ffi::HinawaSndMotuRegisterDspParameter>); match fn { - copy => |ptr| gobject_sys::g_boxed_copy(hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_type(), ptr as *mut _) as *mut hinawa_sys::HinawaSndMotuRegisterDspParameter, - free => |ptr| gobject_sys::g_boxed_free(hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_type(), ptr as *mut _), - get_type => || hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_type(), + copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::hinawa_snd_motu_register_dsp_parameter_get_type(), ptr as *mut _) as *mut ffi::HinawaSndMotuRegisterDspParameter, + free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::hinawa_snd_motu_register_dsp_parameter_get_type(), ptr as *mut _), + type_ => || ffi::hinawa_snd_motu_register_dsp_parameter_get_type(), } } impl SndMotuRegisterDspParameter { + #[doc(alias = "hinawa_snd_motu_register_dsp_parameter_new")] pub fn new() -> SndMotuRegisterDspParameter { - unsafe { - from_glib_full(hinawa_sys::hinawa_snd_motu_register_dsp_parameter_new()) - } + unsafe { from_glib_full(ffi::hinawa_snd_motu_register_dsp_parameter_new()) } } - pub fn get_headphone_output_paired_assignment(&self) -> u8 { + #[doc(alias = "hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_assignment")] + #[doc(alias = "get_headphone_output_paired_assignment")] + pub fn headphone_output_paired_assignment(&self) -> u8 { unsafe { let mut assignment = mem::MaybeUninit::uninit(); - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_assignment(self.to_glib_none().0, assignment.as_mut_ptr()); + ffi::hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_assignment( + self.to_glib_none().0, + assignment.as_mut_ptr(), + ); let assignment = assignment.assume_init(); assignment } } - pub fn get_headphone_output_paired_volume(&self) -> u8 { + #[doc(alias = "hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_volume")] + #[doc(alias = "get_headphone_output_paired_volume")] + pub fn headphone_output_paired_volume(&self) -> u8 { unsafe { let mut volume = mem::MaybeUninit::uninit(); - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_volume(self.to_glib_none().0, volume.as_mut_ptr()); + ffi::hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_volume( + self.to_glib_none().0, + volume.as_mut_ptr(), + ); let volume = volume.assume_init(); volume } } - pub fn get_line_input_boost_flag(&self) -> u8 { + #[doc(alias = "hinawa_snd_motu_register_dsp_parameter_get_line_input_boost_flag")] + #[doc(alias = "get_line_input_boost_flag")] + pub fn line_input_boost_flag(&self) -> u8 { unsafe { let mut boost_flag = mem::MaybeUninit::uninit(); - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_line_input_boost_flag(self.to_glib_none().0, boost_flag.as_mut_ptr()); + ffi::hinawa_snd_motu_register_dsp_parameter_get_line_input_boost_flag( + self.to_glib_none().0, + boost_flag.as_mut_ptr(), + ); let boost_flag = boost_flag.assume_init(); boost_flag } } - pub fn get_line_input_nominal_level_flag(&self) -> u8 { + #[doc(alias = "hinawa_snd_motu_register_dsp_parameter_get_line_input_nominal_level_flag")] + #[doc(alias = "get_line_input_nominal_level_flag")] + pub fn line_input_nominal_level_flag(&self) -> u8 { unsafe { let mut nominal_level_flag = mem::MaybeUninit::uninit(); - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_line_input_nominal_level_flag(self.to_glib_none().0, nominal_level_flag.as_mut_ptr()); + ffi::hinawa_snd_motu_register_dsp_parameter_get_line_input_nominal_level_flag( + self.to_glib_none().0, + nominal_level_flag.as_mut_ptr(), + ); let nominal_level_flag = nominal_level_flag.assume_init(); nominal_level_flag } } - pub fn get_main_output_paired_volume(&self) -> u8 { + #[doc(alias = "hinawa_snd_motu_register_dsp_parameter_get_main_output_paired_volume")] + #[doc(alias = "get_main_output_paired_volume")] + pub fn main_output_paired_volume(&self) -> u8 { unsafe { let mut volume = mem::MaybeUninit::uninit(); - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_main_output_paired_volume(self.to_glib_none().0, volume.as_mut_ptr()); + ffi::hinawa_snd_motu_register_dsp_parameter_get_main_output_paired_volume( + self.to_glib_none().0, + volume.as_mut_ptr(), + ); let volume = volume.assume_init(); volume } diff --git a/hinawa/src/auto/snd_tscm.rs b/hinawa/src/auto/snd_tscm.rs index fb99b5c..140742b 100644 --- a/hinawa/src/auto/snd_tscm.rs +++ b/hinawa/src/auto/snd_tscm.rs @@ -1,35 +1,34 @@ // 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 glib; +use crate::SndUnit; use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib_sys; -use hinawa_sys; -use libc; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; -use SndUnit; -glib_wrapper! { - pub struct SndTscm(Object<hinawa_sys::HinawaSndTscm, hinawa_sys::HinawaSndTscmClass, SndTscmClass>) @extends SndUnit; +glib::wrapper! { + #[doc(alias = "HinawaSndTscm")] + pub struct SndTscm(Object<ffi::HinawaSndTscm, ffi::HinawaSndTscmClass>) @extends SndUnit; match fn { - get_type => || hinawa_sys::hinawa_snd_tscm_get_type(), + type_ => || ffi::hinawa_snd_tscm_get_type(), } } impl SndTscm { + pub const NONE: Option<&'static SndTscm> = None; + + #[doc(alias = "hinawa_snd_tscm_new")] pub fn new() -> SndTscm { - unsafe { - from_glib_full(hinawa_sys::hinawa_snd_tscm_new()) - } + unsafe { from_glib_full(ffi::hinawa_snd_tscm_new()) } } } @@ -39,11 +38,11 @@ impl Default for SndTscm { } } -pub const NONE_SND_TSCM: Option<&SndTscm> = None; - pub trait SndTscmExt: 'static { + #[doc(alias = "hinawa_snd_tscm_open")] fn open(&self, path: &str) -> Result<(), glib::Error>; + #[doc(alias = "control")] fn connect_control<F: Fn(&Self, u32, u32, u32) + 'static>(&self, f: F) -> SignalHandlerId; } @@ -51,28 +50,54 @@ impl<O: IsA<SndTscm>> SndTscmExt for O { fn open(&self, path: &str) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_tscm_open(self.as_ref().to_glib_none().0, path.to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_tscm_open( + self.as_ref().to_glib_none().0, + path.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } fn connect_control<F: Fn(&Self, u32, u32, u32) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn control_trampoline<P, F: Fn(&P, u32, u32, u32) + 'static>(this: *mut hinawa_sys::HinawaSndTscm, index: libc::c_uint, before: libc::c_uint, after: libc::c_uint, f: glib_sys::gpointer) - where P: IsA<SndTscm> - { + unsafe extern "C" fn control_trampoline< + P: IsA<SndTscm>, + F: Fn(&P, u32, u32, u32) + 'static, + >( + this: *mut ffi::HinawaSndTscm, + index: libc::c_uint, + before: libc::c_uint, + after: libc::c_uint, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndTscm::from_glib_borrow(this).unsafe_cast_ref(), index, before, after) + f( + SndTscm::from_glib_borrow(this).unsafe_cast_ref(), + index, + before, + after, + ) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"control\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(control_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"control\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + control_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for SndTscm { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndTscm") + f.write_str("SndTscm") } } diff --git a/hinawa/src/auto/snd_unit.rs b/hinawa/src/auto/snd_unit.rs index 8e2731b..ce3d671 100644 --- a/hinawa/src/auto/snd_unit.rs +++ b/hinawa/src/auto/snd_unit.rs @@ -1,39 +1,35 @@ // 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 glib; +use crate::FwNode; +use crate::SndUnitType; use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; -use glib::GString; -use glib::StaticType; -use glib::Value; -use glib_sys; -use gobject_sys; -use hinawa_sys; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; -use FwNode; -use SndUnitType; -glib_wrapper! { - pub struct SndUnit(Object<hinawa_sys::HinawaSndUnit, hinawa_sys::HinawaSndUnitClass, SndUnitClass>); +glib::wrapper! { + #[doc(alias = "HinawaSndUnit")] + pub struct SndUnit(Object<ffi::HinawaSndUnit, ffi::HinawaSndUnitClass>); match fn { - get_type => || hinawa_sys::hinawa_snd_unit_get_type(), + type_ => || ffi::hinawa_snd_unit_get_type(), } } impl SndUnit { + pub const NONE: Option<&'static SndUnit> = None; + + #[doc(alias = "hinawa_snd_unit_new")] pub fn new() -> SndUnit { - unsafe { - from_glib_full(hinawa_sys::hinawa_snd_unit_new()) - } + unsafe { from_glib_full(ffi::hinawa_snd_unit_new()) } } } @@ -43,40 +39,51 @@ impl Default for SndUnit { } } -pub const NONE_SND_UNIT: Option<&SndUnit> = None; - pub trait SndUnitExt: 'static { + #[doc(alias = "hinawa_snd_unit_create_source")] fn create_source(&self) -> Result<glib::Source, glib::Error>; - fn get_node(&self) -> FwNode; + #[doc(alias = "hinawa_snd_unit_get_node")] + #[doc(alias = "get_node")] + fn node(&self) -> FwNode; + #[doc(alias = "hinawa_snd_unit_lock")] fn lock(&self) -> Result<(), glib::Error>; + #[doc(alias = "hinawa_snd_unit_unlock")] fn unlock(&self) -> Result<(), glib::Error>; - fn get_property_card(&self) -> u32; + fn card(&self) -> u32; - fn get_property_device(&self) -> Option<GString>; + fn device(&self) -> Option<glib::GString>; - fn get_property_guid(&self) -> u64; + fn guid(&self) -> u64; - fn get_property_streaming(&self) -> bool; + fn is_streaming(&self) -> bool; - fn get_property_type(&self) -> SndUnitType; + #[doc(alias = "type")] + fn type_(&self) -> SndUnitType; + #[doc(alias = "disconnected")] fn connect_disconnected<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "lock-status")] fn connect_lock_status<F: Fn(&Self, bool) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_card_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "card")] + fn connect_card_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_device_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "device")] + fn connect_device_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_guid_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "guid")] + fn connect_guid_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_streaming_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "streaming")] + fn connect_streaming_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; - fn connect_property_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; + #[doc(alias = "type")] + fn connect_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; } impl<O: IsA<SndUnit>> SndUnitExt for O { @@ -84,15 +91,23 @@ impl<O: IsA<SndUnit>> SndUnitExt for O { unsafe { let mut gsrc = ptr::null_mut(); let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_unit_create_source(self.as_ref().to_glib_none().0, &mut gsrc, &mut error); - if error.is_null() { Ok(from_glib_full(gsrc)) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_unit_create_source( + self.as_ref().to_glib_none().0, + &mut gsrc, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(gsrc)) + } else { + Err(from_glib_full(error)) + } } } - fn get_node(&self) -> FwNode { + fn node(&self) -> FwNode { unsafe { let mut node = ptr::null_mut(); - hinawa_sys::hinawa_snd_unit_get_node(self.as_ref().to_glib_none().0, &mut node); + ffi::hinawa_snd_unit_get_node(self.as_ref().to_glib_none().0, &mut node); from_glib_none(node) } } @@ -100,160 +115,206 @@ impl<O: IsA<SndUnit>> SndUnitExt for O { fn lock(&self) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_unit_lock(self.as_ref().to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_unit_lock(self.as_ref().to_glib_none().0, &mut error); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } fn unlock(&self) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_unit_unlock(self.as_ref().to_glib_none().0, &mut error); - if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + let _ = ffi::hinawa_snd_unit_unlock(self.as_ref().to_glib_none().0, &mut error); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } } } - fn get_property_card(&self) -> u32 { - unsafe { - let mut value = Value::from_type(<u32 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"card\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `card` getter").unwrap() - } + fn card(&self) -> u32 { + glib::ObjectExt::property(self.as_ref(), "card") } - fn get_property_device(&self) -> Option<GString> { - unsafe { - let mut value = Value::from_type(<GString as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"device\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `device` getter") - } + fn device(&self) -> Option<glib::GString> { + glib::ObjectExt::property(self.as_ref(), "device") } - fn get_property_guid(&self) -> u64 { - unsafe { - let mut value = Value::from_type(<u64 as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"guid\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `guid` getter").unwrap() - } + fn guid(&self) -> u64 { + glib::ObjectExt::property(self.as_ref(), "guid") } - fn get_property_streaming(&self) -> bool { - unsafe { - let mut value = Value::from_type(<bool as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"streaming\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `streaming` getter").unwrap() - } + fn is_streaming(&self) -> bool { + glib::ObjectExt::property(self.as_ref(), "streaming") } - fn get_property_type(&self) -> SndUnitType { - unsafe { - let mut value = Value::from_type(<SndUnitType as StaticType>::static_type()); - gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"type\0".as_ptr() as *const _, value.to_glib_none_mut().0); - value.get().expect("Return Value for property `type` getter").unwrap() - } + fn type_(&self) -> SndUnitType { + glib::ObjectExt::property(self.as_ref(), "type") } fn connect_disconnected<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn disconnected_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaSndUnit, f: glib_sys::gpointer) - where P: IsA<SndUnit> - { + unsafe extern "C" fn disconnected_trampoline<P: IsA<SndUnit>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaSndUnit, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndUnit::from_glib_borrow(this).unsafe_cast_ref()) + f(SndUnit::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"disconnected\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(disconnected_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"disconnected\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + disconnected_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } fn connect_lock_status<F: Fn(&Self, bool) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn lock_status_trampoline<P, F: Fn(&P, bool) + 'static>(this: *mut hinawa_sys::HinawaSndUnit, state: glib_sys::gboolean, f: glib_sys::gpointer) - where P: IsA<SndUnit> - { + unsafe extern "C" fn lock_status_trampoline<P: IsA<SndUnit>, F: Fn(&P, bool) + 'static>( + this: *mut ffi::HinawaSndUnit, + state: glib::ffi::gboolean, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndUnit::from_glib_borrow(this).unsafe_cast_ref(), from_glib(state)) + f( + SndUnit::from_glib_borrow(this).unsafe_cast_ref(), + from_glib(state), + ) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"lock-status\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(lock_status_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"lock-status\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + lock_status_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_card_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_card_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaSndUnit, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<SndUnit> - { + fn connect_card_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_card_trampoline<P: IsA<SndUnit>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaSndUnit, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndUnit::from_glib_borrow(this).unsafe_cast_ref()) + f(SndUnit::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::card\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_card_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::card\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_card_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_device_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_device_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaSndUnit, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<SndUnit> - { + fn connect_device_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_device_trampoline<P: IsA<SndUnit>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaSndUnit, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndUnit::from_glib_borrow(this).unsafe_cast_ref()) + f(SndUnit::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::device\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_device_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::device\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_device_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_guid_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_guid_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaSndUnit, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<SndUnit> - { + fn connect_guid_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_guid_trampoline<P: IsA<SndUnit>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaSndUnit, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndUnit::from_glib_borrow(this).unsafe_cast_ref()) + f(SndUnit::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::guid\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_guid_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::guid\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_guid_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_streaming_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_streaming_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaSndUnit, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<SndUnit> - { + fn connect_streaming_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_streaming_trampoline<P: IsA<SndUnit>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaSndUnit, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndUnit::from_glib_borrow(this).unsafe_cast_ref()) + f(SndUnit::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::streaming\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_streaming_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::streaming\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_streaming_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } - fn connect_property_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { - unsafe extern "C" fn notify_type_trampoline<P, F: Fn(&P) + 'static>(this: *mut hinawa_sys::HinawaSndUnit, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) - where P: IsA<SndUnit> - { + fn connect_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_type_trampoline<P: IsA<SndUnit>, F: Fn(&P) + 'static>( + this: *mut ffi::HinawaSndUnit, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { let f: &F = &*(f as *const F); - f(&SndUnit::from_glib_borrow(this).unsafe_cast_ref()) + f(SndUnit::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_<F> = Box_::new(f); - connect_raw(self.as_ptr() as *mut _, b"notify::type\0".as_ptr() as *const _, - Some(transmute::<_, unsafe extern "C" fn()>(notify_type_trampoline::<Self, F> as *const ())), Box_::into_raw(f)) + connect_raw( + self.as_ptr() as *mut _, + b"notify::type\0".as_ptr() as *const _, + Some(transmute::<_, unsafe extern "C" fn()>( + notify_type_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) } } } impl fmt::Display for SndUnit { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SndUnit") + f.write_str("SndUnit") } } diff --git a/hinawa/src/auto/versions.txt b/hinawa/src/auto/versions.txt index 60d5c74..00e8a32 100644 --- a/hinawa/src/auto/versions.txt +++ b/hinawa/src/auto/versions.txt @@ -1,2 +1,3 @@ -Generated by gir (https://github.com/gtk-rs/gir @ a6737c7) -from gir-files (https://github.com/gtk-rs/gir-files @ c31e734) +Generated by gir (https://github.com/gtk-rs/gir @ 78e3d3c22343) +from +from gir-files (https://github.com/gtk-rs/gir-files @ 5ca60543e148) diff --git a/hinawa/src/fw_fcp.rs b/hinawa/src/fw_fcp.rs index a515456..a7f63ed 100644 --- a/hinawa/src/fw_fcp.rs +++ b/hinawa/src/fw_fcp.rs @@ -1,37 +1,39 @@ // SPDX-License-Identifier: MIT -use glib::object::IsA; -use glib::translate::*; -use glib::object::Cast; -use glib::signal::connect_raw; -use glib::signal::SignalHandlerId; - -use FwFcp; +use crate::*; pub trait FwFcpExtManual { - fn avc_transaction(&self, req_frame: &[u8], resp_frame: &mut [u8], timeout_ms: u32) - -> Result<usize, glib::Error>; - fn transaction(&self, req_frame: &[u8], resp_frame: &mut [u8]) - -> Result<usize, glib::Error>; + fn avc_transaction( + &self, + req_frame: &[u8], + resp_frame: &mut [u8], + timeout_ms: u32, + ) -> Result<usize, glib::Error>; + fn transaction(&self, req_frame: &[u8], resp_frame: &mut [u8]) -> Result<usize, glib::Error>; fn connect_responded<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, &[u8]) + 'static; + where + F: Fn(&Self, &[u8]) + 'static; } impl<O: IsA<FwFcp>> FwFcpExtManual for O { - fn avc_transaction(&self, req_frame: &[u8], resp_frame: &mut [u8], timeout_ms: u32) - -> Result<usize, glib::Error> - { + fn avc_transaction( + &self, + req_frame: &[u8], + resp_frame: &mut [u8], + timeout_ms: u32, + ) -> Result<usize, glib::Error> { unsafe { let mut resp_frame_size = resp_frame.len(); let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_fw_fcp_avc_transaction( - self.as_ref().to_glib_none().0, - req_frame.as_ptr(), - req_frame.len(), - &mut resp_frame.as_mut_ptr(), - &mut resp_frame_size, - timeout_ms, - &mut error); + ffi::hinawa_fw_fcp_avc_transaction( + self.as_ref().to_glib_none().0, + req_frame.as_ptr(), + req_frame.len(), + &mut resp_frame.as_mut_ptr(), + &mut resp_frame_size, + timeout_ms, + &mut error, + ); if error.is_null() { Ok(resp_frame_size) @@ -41,20 +43,19 @@ impl<O: IsA<FwFcp>> FwFcpExtManual for O { } } - fn transaction(&self, req_frame: &[u8], resp_frame: &mut [u8]) - -> Result<usize, glib::Error> - { + fn transaction(&self, req_frame: &[u8], resp_frame: &mut [u8]) -> Result<usize, glib::Error> { unsafe { let mut resp_frame_size = resp_frame.len(); let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_fw_fcp_transaction( - self.as_ref().to_glib_none().0, - req_frame.as_ptr(), - req_frame.len(), - &mut resp_frame.as_mut_ptr(), - &mut resp_frame_size, - &mut error); + ffi::hinawa_fw_fcp_transaction( + self.as_ref().to_glib_none().0, + req_frame.as_ptr(), + req_frame.len(), + &mut resp_frame.as_mut_ptr(), + &mut resp_frame_size, + &mut error, + ); if error.is_null() { Ok(resp_frame_size) @@ -65,13 +66,14 @@ impl<O: IsA<FwFcp>> FwFcpExtManual for O { } fn connect_responded<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, &[u8]) + 'static + where + F: Fn(&Self, &[u8]) + 'static, { unsafe extern "C" fn responded_trampoline<P, F>( - this: *mut hinawa_sys::HinawaFwFcp, + this: *mut ffi::HinawaFwFcp, frame: *const u8, length: libc::c_uint, - f: glib_sys::gpointer, + f: glib::ffi::gpointer, ) where P: IsA<FwFcp>, F: Fn(&P, &[u8]) + 'static, diff --git a/hinawa/src/fw_node.rs b/hinawa/src/fw_node.rs index 1dca4e9..9343d26 100644 --- a/hinawa/src/fw_node.rs +++ b/hinawa/src/fw_node.rs @@ -1,26 +1,23 @@ // SPDX-License-Identifier: MIT -use glib::object::IsA; -use glib::translate::*; - -use FwNode; +use crate::*; pub trait FwNodeExtManual { fn get_config_rom(&self) -> Result<&[u8], glib::Error>; } impl<O: IsA<FwNode>> FwNodeExtManual for O { - fn get_config_rom(&self) -> Result<&[u8], glib::Error> - { + fn get_config_rom(&self) -> Result<&[u8], glib::Error> { unsafe { let mut ptr = std::ptr::null_mut() as *const u8; let mut len = 0 as usize; let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_fw_node_get_config_rom( + ffi::hinawa_fw_node_get_config_rom( self.as_ref().to_glib_none().0, &mut ptr, &mut len, - &mut error); + &mut error, + ); if error.is_null() { Ok(std::slice::from_raw_parts(ptr, len)) diff --git a/hinawa/src/fw_req.rs b/hinawa/src/fw_req.rs index debd4fc..a486b36 100644 --- a/hinawa/src/fw_req.rs +++ b/hinawa/src/fw_req.rs @@ -1,45 +1,60 @@ // SPDX-License-Identifier: MIT -use glib::object::IsA; -use glib::translate::*; -use glib::object::Cast; -use glib::signal::connect_raw; -use glib::signal::SignalHandlerId; - -use FwReq; -use FwTcode; -use FwNode; -use FwRcode; +use crate::*; pub trait FwReqExtManual { - fn transaction_async<P: IsA<FwNode>>(&self, node: &P, tcode: FwTcode, - addr: u64, length: usize, frame: &mut [u8]) - ->Result<(), glib::Error>; - fn transaction_sync<P: IsA<FwNode>>(&self, node: &P, tcode: FwTcode, - addr: u64, length: usize, frame: &mut [u8], - timeout_ms: u32) - ->Result<(), glib::Error>; - fn transaction<P: IsA<FwNode>>(&self, node: &P, tcode: FwTcode, - addr: u64, length: usize, frame: &mut [u8]) - ->Result<(), glib::Error>; + fn transaction_async<P: IsA<FwNode>>( + &self, + node: &P, + tcode: FwTcode, + addr: u64, + length: usize, + frame: &mut [u8], + ) -> Result<(), glib::Error>; + fn transaction_sync<P: IsA<FwNode>>( + &self, + node: &P, + tcode: FwTcode, + addr: u64, + length: usize, + frame: &mut [u8], + timeout_ms: u32, + ) -> Result<(), glib::Error>; + fn transaction<P: IsA<FwNode>>( + &self, + node: &P, + tcode: FwTcode, + addr: u64, + length: usize, + frame: &mut [u8], + ) -> Result<(), glib::Error>; fn connect_responded<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, FwRcode, &[u8]) + 'static; + where + F: Fn(&Self, FwRcode, &[u8]) + 'static; } impl<O: IsA<FwReq>> FwReqExtManual for O { - fn transaction_async<P: IsA<FwNode>>(&self, node: &P, tcode: FwTcode, - addr: u64, length: usize, frame: &mut [u8]) - ->Result<(), glib::Error> - { + fn transaction_async<P: IsA<FwNode>>( + &self, + node: &P, + tcode: FwTcode, + addr: u64, + length: usize, + frame: &mut [u8], + ) -> Result<(), glib::Error> { unsafe { let mut frame_size = frame.len(); let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_fw_req_transaction_async( + ffi::hinawa_fw_req_transaction_async( self.as_ref().to_glib_none().0, node.as_ref().to_glib_none().0, - tcode.to_glib(), addr, length, - &mut frame.as_mut_ptr(), &mut frame_size, - &mut error); + tcode.into_glib(), + addr, + length, + &mut frame.as_mut_ptr(), + &mut frame_size, + &mut error, + ); if error.is_null() { Ok(()) @@ -49,21 +64,30 @@ impl<O: IsA<FwReq>> FwReqExtManual for O { } } - fn transaction_sync<P: IsA<FwNode>>(&self, node: &P, tcode: FwTcode, - addr: u64, length: usize, frame: &mut [u8], - timeout_ms: u32) - ->Result<(), glib::Error> - { + fn transaction_sync<P: IsA<FwNode>>( + &self, + node: &P, + tcode: FwTcode, + addr: u64, + length: usize, + frame: &mut [u8], + timeout_ms: u32, + ) -> Result<(), glib::Error> { unsafe { let mut frame_size = frame.len(); let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_fw_req_transaction_sync( + ffi::hinawa_fw_req_transaction_sync( self.as_ref().to_glib_none().0, node.as_ref().to_glib_none().0, - tcode.to_glib(), addr, length, - &mut frame.as_mut_ptr(), &mut frame_size, - timeout_ms, &mut error); + tcode.into_glib(), + addr, + length, + &mut frame.as_mut_ptr(), + &mut frame_size, + timeout_ms, + &mut error, + ); if error.is_null() { Ok(()) @@ -73,20 +97,28 @@ impl<O: IsA<FwReq>> FwReqExtManual for O { } } - fn transaction<P: IsA<FwNode>>(&self, node: &P, tcode: FwTcode, - addr: u64, length: usize, frame: &mut [u8]) - ->Result<(), glib::Error> - { + fn transaction<P: IsA<FwNode>>( + &self, + node: &P, + tcode: FwTcode, + addr: u64, + length: usize, + frame: &mut [u8], + ) -> Result<(), glib::Error> { unsafe { let mut frame_size = frame.len(); let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_fw_req_transaction( + ffi::hinawa_fw_req_transaction( self.as_ref().to_glib_none().0, node.as_ref().to_glib_none().0, - tcode.to_glib(), addr, length, - &mut frame.as_mut_ptr(), &mut frame_size, - &mut error); + tcode.into_glib(), + addr, + length, + &mut frame.as_mut_ptr(), + &mut frame_size, + &mut error, + ); if error.is_null() { Ok(()) @@ -97,14 +129,15 @@ impl<O: IsA<FwReq>> FwReqExtManual for O { } fn connect_responded<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, FwRcode, &[u8]) + 'static + where + F: Fn(&Self, FwRcode, &[u8]) + 'static, { unsafe extern "C" fn responded_trampoline<P, F>( - this: *mut hinawa_sys::HinawaFwReq, - rcode: hinawa_sys::HinawaFwRcode, + this: *mut ffi::HinawaFwReq, + rcode: ffi::HinawaFwRcode, frame: *const u8, length: libc::c_uint, - f: glib_sys::gpointer, + f: glib::ffi::gpointer, ) where P: IsA<FwReq>, F: Fn(&P, FwRcode, &[u8]) + 'static, diff --git a/hinawa/src/fw_resp.rs b/hinawa/src/fw_resp.rs index 0c60cf8..943b24f 100644 --- a/hinawa/src/fw_resp.rs +++ b/hinawa/src/fw_resp.rs @@ -1,18 +1,11 @@ // SPDX-License-Identifier: MIT -use glib::object::IsA; -use glib::translate::*; -use glib::object::Cast; -use glib::signal::connect_raw; -use glib::signal::SignalHandlerId; - -use FwResp; -use FwTcode; -use FwRcode; +use crate::*; pub trait FwRespExtManual { fn get_req_frames(&self) -> &[u8]; fn connect_requested2<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, FwTcode, u64, u32, u32, u32, u32, &[u8]) -> FwRcode + 'static; + where + F: Fn(&Self, FwTcode, u64, u32, u32, u32, u32, &[u8]) -> FwRcode + 'static; } impl<O: IsA<FwResp>> FwRespExtManual for O { @@ -21,21 +14,19 @@ impl<O: IsA<FwResp>> FwRespExtManual for O { let mut ptr = std::ptr::null_mut() as *const u8; let mut len = 0 as usize; - hinawa_sys::hinawa_fw_resp_get_req_frame( - self.as_ref().to_glib_none().0, - &mut ptr, - &mut len); + ffi::hinawa_fw_resp_get_req_frame(self.as_ref().to_glib_none().0, &mut ptr, &mut len); std::slice::from_raw_parts(ptr, len) } } fn connect_requested2<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, FwTcode, u64, u32, u32, u32, u32, &[u8]) -> FwRcode + 'static + where + F: Fn(&Self, FwTcode, u64, u32, u32, u32, u32, &[u8]) -> FwRcode + 'static, { unsafe extern "C" fn requested_trampoline<P, F>( - this: *mut hinawa_sys::HinawaFwResp, - tcode: hinawa_sys::HinawaFwTcode, + this: *mut ffi::HinawaFwResp, + tcode: ffi::HinawaFwTcode, offset: u64, src: u32, dst: u32, @@ -43,10 +34,11 @@ impl<O: IsA<FwResp>> FwRespExtManual for O { generation: u32, frame: *const u8, length: libc::c_uint, - f: glib_sys::gpointer, - ) -> hinawa_sys::HinawaFwRcode - where P: IsA<FwResp>, - F: Fn(&P, FwTcode, u64, u32, u32, u32, u32, &[u8]) -> FwRcode + 'static + f: glib::ffi::gpointer, + ) -> ffi::HinawaFwRcode + where + P: IsA<FwResp>, + F: Fn(&P, FwTcode, u64, u32, u32, u32, u32, &[u8]) -> FwRcode + 'static, { let f: &F = &*(f as *const F); f( @@ -58,7 +50,8 @@ impl<O: IsA<FwResp>> FwRespExtManual for O { card, generation, std::slice::from_raw_parts(frame, length as usize), - ).to_glib() + ) + .into_glib() } unsafe { let f: std::boxed::Box<F> = std::boxed::Box::new(f); @@ -66,7 +59,7 @@ impl<O: IsA<FwResp>> FwRespExtManual for O { self.as_ptr() as *mut _, b"requested2\0".as_ptr() as *const _, Some(std::mem::transmute::<_, unsafe extern "C" fn()>( - requested_trampoline::<Self, F> as *const () + requested_trampoline::<Self, F> as *const (), )), std::boxed::Box::into_raw(f), ) diff --git a/hinawa/src/lib.rs b/hinawa/src/lib.rs index fb0da0f..1acbb9b 100644 --- a/hinawa/src/lib.rs +++ b/hinawa/src/lib.rs @@ -1,41 +1,19 @@ -#[macro_use] -extern crate glib; -extern crate glib_sys; -extern crate gobject_sys; -extern crate libc; -extern crate hinawa_sys; - -pub use glib::Error; - +// SPDX-License-Identifier: MIT mod auto; -pub use auto::*; - +mod fw_fcp; mod fw_node; -pub use fw_node::*; - mod fw_req; -pub use fw_req::*; - mod fw_resp; -pub use fw_resp::*; - -mod fw_fcp; -pub use fw_fcp::*; - -mod snd_unit; -pub use snd_unit::*; - mod snd_efw; -pub use snd_efw::*; - +mod snd_motu; +mod snd_motu_register_dsp_parameter; mod snd_tscm; -pub use snd_tscm::*; - -mod enums; -pub use enums::*; +mod snd_unit; -mod snd_motu; -pub use snd_motu::*; +pub use crate::{ + auto::*, fw_node::*, fw_req::*, fw_resp::*, snd_efw::*, snd_motu::*, + snd_motu_register_dsp_parameter::*, snd_tscm::*, snd_unit::*, +}; +pub use ffi; -mod snd_motu_register_dsp_parameter; -pub use snd_motu_register_dsp_parameter::*; +use glib::{signal::*, translate::*, Cast, IsA, SignalHandlerId}; diff --git a/hinawa/src/snd_efw.rs b/hinawa/src/snd_efw.rs index e47c037..5a1fb7d 100644 --- a/hinawa/src/snd_efw.rs +++ b/hinawa/src/snd_efw.rs @@ -1,32 +1,40 @@ // SPDX-License-Identifier: MIT -use glib::object::IsA; -use glib::translate::*; -use glib::object::Cast; -use glib::signal::connect_raw; -use glib::signal::SignalHandlerId; - -use SndEfw; -use SndEfwStatus; +use crate::*; pub trait SndEfwExtManual { - fn transaction(&self, category: u32, command: u32, args: &[u32], - params: &mut [u32]) -> Result<usize, glib::Error>; - fn transaction_sync(&self, category: u32, command: u32, args: Option<&[u32]>, - params: Option<&mut [u32]>, timeout_ms: u32) - -> Result<usize, glib::Error>; + fn transaction( + &self, + category: u32, + command: u32, + args: &[u32], + params: &mut [u32], + ) -> Result<usize, glib::Error>; + fn transaction_sync( + &self, + category: u32, + command: u32, + args: Option<&[u32]>, + params: Option<&mut [u32]>, + timeout_ms: u32, + ) -> Result<usize, glib::Error>; fn connect_responded<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, SndEfwStatus, u32, u32, u32, &[u32]) + 'static; + where + F: Fn(&Self, SndEfwStatus, u32, u32, u32, &[u32]) + 'static; } impl<O: IsA<SndEfw>> SndEfwExtManual for O { - fn transaction(&self, category: u32, command: u32, args: &[u32], - params: &mut [u32]) - -> Result<usize, glib::Error> { + fn transaction( + &self, + category: u32, + command: u32, + args: &[u32], + params: &mut [u32], + ) -> Result<usize, glib::Error> { unsafe { let mut param_count = params.len(); let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_snd_efw_transaction( + ffi::hinawa_snd_efw_transaction( self.as_ref().to_glib_none().0, category, command, @@ -34,7 +42,8 @@ impl<O: IsA<SndEfw>> SndEfwExtManual for O { args.len() as usize, &mut params.as_mut_ptr(), &mut param_count, - &mut error); + &mut error, + ); if error.is_null() { Ok(param_count) @@ -44,9 +53,14 @@ impl<O: IsA<SndEfw>> SndEfwExtManual for O { } } - fn transaction_sync(&self, category: u32, command: u32, args: Option<&[u32]>, - params: Option<&mut [u32]>, timeout_ms: u32) - -> Result<usize, glib::Error> { + fn transaction_sync( + &self, + category: u32, + command: u32, + args: Option<&[u32]>, + params: Option<&mut [u32]>, + timeout_ms: u32, + ) -> Result<usize, glib::Error> { unsafe { let (arg_ptr, arg_count) = match args { Some(a) => (a.as_ptr(), a.len()), @@ -58,7 +72,7 @@ impl<O: IsA<SndEfw>> SndEfwExtManual for O { }; let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_snd_efw_transaction_sync( + ffi::hinawa_snd_efw_transaction_sync( self.as_ref().to_glib_none().0, category, command, @@ -67,7 +81,8 @@ impl<O: IsA<SndEfw>> SndEfwExtManual for O { &mut param_ptr, &mut param_count, timeout_ms, - &mut error); + &mut error, + ); if error.is_null() { Ok(param_count) @@ -78,17 +93,18 @@ impl<O: IsA<SndEfw>> SndEfwExtManual for O { } fn connect_responded<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, SndEfwStatus, u32, u32, u32, &[u32]) + 'static + where + F: Fn(&Self, SndEfwStatus, u32, u32, u32, &[u32]) + 'static, { unsafe extern "C" fn responded_trampoline<P, F>( - this: *mut hinawa_sys::HinawaSndEfw, - status: hinawa_sys::HinawaSndEfwStatus, + this: *mut ffi::HinawaSndEfw, + status: ffi::HinawaSndEfwStatus, seqnum: u32, command: u32, category: u32, frame: *const u32, length: libc::c_uint, - f: glib_sys::gpointer, + f: glib::ffi::gpointer, ) where P: IsA<SndEfw>, F: Fn(&P, SndEfwStatus, u32, u32, u32, &[u32]) + 'static, diff --git a/hinawa/src/snd_motu.rs b/hinawa/src/snd_motu.rs index b65d349..fd69acb 100644 --- a/hinawa/src/snd_motu.rs +++ b/hinawa/src/snd_motu.rs @@ -1,32 +1,29 @@ // SPDX-License-Identifier: MIT -use glib::object::IsA; -use glib::translate::*; -use glib::object::Cast; -use glib::signal::connect_raw; -use glib::signal::SignalHandlerId; - -use SndMotu; -use SndMotuRegisterDspParameter; +use crate::*; pub trait SndMotuExtManual { - fn read_register_dsp_parameter(&self, param: &mut SndMotuRegisterDspParameter) -> Result<(), glib::Error>; + fn read_register_dsp_parameter( + &self, + param: &mut SndMotuRegisterDspParameter, + ) -> Result<(), glib::Error>; fn read_register_dsp_meter(&self, meter: &mut [u8; 48]) -> Result<(), glib::Error>; fn read_command_dsp_meter(&self, meter: &mut [f32; 400]) -> Result<(), glib::Error>; - fn connect_register_dsp_changed<F: Fn(&Self, &[u32]) + 'static>(&self, f: F) -> SignalHandlerId; + fn connect_register_dsp_changed<F: Fn(&Self, &[u32]) + 'static>(&self, f: F) + -> SignalHandlerId; } impl<O: IsA<SndMotu>> SndMotuExtManual for O { fn read_register_dsp_parameter( &self, - param: &mut SndMotuRegisterDspParameter + param: &mut SndMotuRegisterDspParameter, ) -> Result<(), glib::Error> { unsafe { let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_snd_motu_read_register_dsp_parameter( + ffi::hinawa_snd_motu_read_register_dsp_parameter( self.as_ref().to_glib_none().0, ¶m.to_glib_none_mut().0, - &mut error + &mut error, ); if error.is_null() { @@ -42,10 +39,10 @@ impl<O: IsA<SndMotu>> SndMotuExtManual for O { let ptr: *mut [u8; 48] = meter; let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_snd_motu_read_register_dsp_meter( + ffi::hinawa_snd_motu_read_register_dsp_meter( self.as_ref().to_glib_none().0, &ptr, - &mut error + &mut error, ); if error.is_null() { @@ -61,10 +58,10 @@ impl<O: IsA<SndMotu>> SndMotuExtManual for O { let ptr: *mut [f32; 400] = meter; let mut error = std::ptr::null_mut(); - hinawa_sys::hinawa_snd_motu_read_command_dsp_meter( + ffi::hinawa_snd_motu_read_command_dsp_meter( self.as_ref().to_glib_none().0, &ptr, - &mut error + &mut error, ); if error.is_null() { @@ -76,21 +73,22 @@ impl<O: IsA<SndMotu>> SndMotuExtManual for O { } fn connect_register_dsp_changed<F>(&self, f: F) -> SignalHandlerId - where F: Fn(&Self, &[u32]) + 'static, + where + F: Fn(&Self, &[u32]) + 'static, { unsafe extern "C" fn register_dsp_changed_trampoline<P, F>( - this: *mut hinawa_sys::HinawaSndMotu, + this: *mut ffi::HinawaSndMotu, events: *const u32, length: libc::c_uint, - f: glib_sys::gpointer - ) - where P: IsA<SndMotu>, - F: Fn(&P, &[u32]) + 'static, + f: glib::ffi::gpointer, + ) where + P: IsA<SndMotu>, + F: Fn(&P, &[u32]) + 'static, { let f: &F = &*(f as *const F); f( &SndMotu::from_glib_borrow(this).unsafe_cast_ref(), - std::slice::from_raw_parts(events, length as usize) + std::slice::from_raw_parts(events, length as usize), ) } unsafe { @@ -98,12 +96,11 @@ impl<O: IsA<SndMotu>> SndMotuExtManual for O { connect_raw( self.as_ptr() as *mut _, b"register-dsp-changed\0".as_ptr() as *const _, - Some( - std::mem::transmute::<_, unsafe extern "C" fn()>( - register_dsp_changed_trampoline::<Self, F> as *const () - )), - std::boxed::Box::into_raw(f) - ) + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + register_dsp_changed_trampoline::<Self, F> as *const (), + )), + std::boxed::Box::into_raw(f), + ) } } } diff --git a/hinawa/src/snd_motu_register_dsp_parameter.rs b/hinawa/src/snd_motu_register_dsp_parameter.rs index 4190b0f..1c1ab38 100644 --- a/hinawa/src/snd_motu_register_dsp_parameter.rs +++ b/hinawa/src/snd_motu_register_dsp_parameter.rs @@ -1,12 +1,11 @@ -use glib::translate::*; - -use SndMotuRegisterDspParameter; +// SPDX-License-Identifier: MIT +use crate::*; impl SndMotuRegisterDspParameter { pub fn get_input_flag(&self) -> &[u8; 10] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 10]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_input_flag( + ffi::hinawa_snd_motu_register_dsp_parameter_get_input_flag( self.to_glib_none().0, &mut ptr, ); @@ -17,7 +16,7 @@ impl SndMotuRegisterDspParameter { pub fn get_input_gain_and_invert(&self) -> &[u8; 10] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 10]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_input_gain_and_invert( + ffi::hinawa_snd_motu_register_dsp_parameter_get_input_gain_and_invert( self.to_glib_none().0, &mut ptr, ); @@ -28,7 +27,7 @@ impl SndMotuRegisterDspParameter { pub fn get_mixer_output_paired_flag(&self) -> &[u8; 4] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 4]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_mixer_output_paired_flag( + ffi::hinawa_snd_motu_register_dsp_parameter_get_mixer_output_paired_flag( self.to_glib_none().0, &mut ptr, ); @@ -39,7 +38,7 @@ impl SndMotuRegisterDspParameter { pub fn get_mixer_output_paired_volume(&self) -> &[u8; 4] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 4]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_mixer_output_paired_volume( + ffi::hinawa_snd_motu_register_dsp_parameter_get_mixer_output_paired_volume( self.to_glib_none().0, &mut ptr, ); @@ -50,7 +49,7 @@ impl SndMotuRegisterDspParameter { pub fn get_mixer_source_flag(&self, mixer: usize) -> &[u8; 20] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 20]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_flag( + ffi::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_flag( self.to_glib_none().0, mixer, &mut ptr, @@ -62,7 +61,7 @@ impl SndMotuRegisterDspParameter { pub fn get_mixer_source_gain(&self, mixer: usize) -> &[u8; 20] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 20]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_gain( + ffi::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_gain( self.to_glib_none().0, mixer, &mut ptr, @@ -74,7 +73,7 @@ impl SndMotuRegisterDspParameter { pub fn get_mixer_source_paired_balance(&self, mixer: usize) -> &[u8; 20] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 20]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_paired_balance( + ffi::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_paired_balance( self.to_glib_none().0, mixer, &mut ptr, @@ -86,7 +85,7 @@ impl SndMotuRegisterDspParameter { pub fn get_mixer_source_paired_width(&self, mixer: usize) -> &[u8; 20] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 20]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_paired_width( + ffi::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_paired_width( self.to_glib_none().0, mixer, &mut ptr, @@ -95,10 +94,10 @@ impl SndMotuRegisterDspParameter { } } - pub fn get_mixer_source_pan(&self, mixer: usize) -> &[u8; 20]{ + pub fn get_mixer_source_pan(&self, mixer: usize) -> &[u8; 20] { unsafe { let mut ptr = std::ptr::null_mut() as *const [u8; 20]; - hinawa_sys::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_pan( + ffi::hinawa_snd_motu_register_dsp_parameter_get_mixer_source_pan( self.to_glib_none().0, mixer, &mut ptr, diff --git a/hinawa/src/snd_tscm.rs b/hinawa/src/snd_tscm.rs index 87ae9a0..7097c13 100644 --- a/hinawa/src/snd_tscm.rs +++ b/hinawa/src/snd_tscm.rs @@ -1,23 +1,16 @@ // SPDX-License-Identifier: MIT -use glib::object::IsA; -use glib::translate::*; - -use SndTscm; +use crate::*; pub trait SndTscmExtManual { - fn get_state(&self) -> Result<&[u32;64], glib::Error>; + fn get_state(&self) -> Result<&[u32; 64], glib::Error>; } impl<O: IsA<SndTscm>> SndTscmExtManual for O { - fn get_state(&self) - -> Result<&[u32;64], glib::Error> - { + fn get_state(&self) -> Result<&[u32; 64], glib::Error> { unsafe { let mut error = std::ptr::null_mut(); - let image = hinawa_sys::hinawa_snd_tscm_get_state( - self.as_ref().to_glib_none().0, - &mut error); + let image = ffi::hinawa_snd_tscm_get_state(self.as_ref().to_glib_none().0, &mut error); if error.is_null() { Ok(&*image) diff --git a/hinawa/src/snd_unit.rs b/hinawa/src/snd_unit.rs index f0c6c3c..373367a 100644 --- a/hinawa/src/snd_unit.rs +++ b/hinawa/src/snd_unit.rs @@ -1,8 +1,5 @@ // SPDX-License-Identifier: MIT -use glib::object::IsA; -use glib::translate::*; - -use SndUnit; +use crate::*; pub trait SndUnitExtManual { fn open(&self, path: &str) -> Result<(), glib::Error>; @@ -13,7 +10,7 @@ impl<O: IsA<SndUnit>> SndUnitExtManual for O { unsafe { let mut error = std::ptr::null_mut(); - let _ = hinawa_sys::hinawa_snd_unit_open( + let _ = ffi::hinawa_snd_unit_open( self.as_ref().to_glib_none().0, path.to_glib_none().0, &mut error, |