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

diff --git a/README.rst b/README.rst
index 4bad9a8..bb2d175 100644
--- a/README.rst
+++ b/README.rst
@@ -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,
                 &param.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,