#[cfg(any(feature = "v0_8_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_22")))]
use crate::AccessCheckPolicy;
use crate::ChunkParser;
use crate::Gc;
#[cfg(any(feature = "v0_8_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_22")))]
use crate::GcAccessMode;
use crate::GcNode;
#[cfg(any(feature = "v0_8_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_6")))]
use crate::RangeCheckPolicy;
use crate::RegisterCachePolicy;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem;
use std::mem::transmute;
use std::ptr;
glib::wrapper! {
#[doc(alias = "ArvDevice")]
pub struct Device(Object<ffi::ArvDevice, ffi::ArvDeviceClass>);
match fn {
type_ => || ffi::arv_device_get_type(),
}
}
unsafe impl Send for Device {}
pub const NONE_DEVICE: Option<&Device> = None;
pub trait DeviceExt: 'static {
#[doc(alias = "arv_device_create_chunk_parser")]
fn create_chunk_parser(&self) -> Option<ChunkParser>;
#[doc(alias = "arv_device_dup_available_enumeration_feature_values")]
fn dup_available_enumeration_feature_values(
&self,
feature: &str,
) -> Result<Vec<i64>, glib::Error>;
#[doc(alias = "arv_device_dup_available_enumeration_feature_values_as_display_names")]
fn dup_available_enumeration_feature_values_as_display_names(
&self,
feature: &str,
) -> Result<Vec<glib::GString>, glib::Error>;
#[doc(alias = "arv_device_dup_available_enumeration_feature_values_as_strings")]
fn dup_available_enumeration_feature_values_as_strings(
&self,
feature: &str,
) -> Result<Vec<glib::GString>, glib::Error>;
#[doc(alias = "arv_device_execute_command")]
fn execute_command(&self, feature: &str) -> Result<(), glib::Error>;
#[doc(alias = "arv_device_get_boolean_feature_value")]
#[doc(alias = "get_boolean_feature_value")]
fn boolean_feature_value(&self, feature: &str) -> Result<bool, glib::Error>;
#[doc(alias = "arv_device_get_feature")]
#[doc(alias = "get_feature")]
fn feature(&self, feature: &str) -> Option<GcNode>;
#[cfg(any(feature = "v0_8_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_22")))]
#[doc(alias = "arv_device_get_feature_access_mode")]
#[doc(alias = "get_feature_access_mode")]
fn feature_access_mode(&self, feature: &str) -> GcAccessMode;
#[doc(alias = "arv_device_get_float_feature_bounds")]
#[doc(alias = "get_float_feature_bounds")]
fn float_feature_bounds(&self, feature: &str) -> Result<(f64, f64), glib::Error>;
#[cfg(any(feature = "v0_8_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_16")))]
#[doc(alias = "arv_device_get_float_feature_increment")]
#[doc(alias = "get_float_feature_increment")]
fn float_feature_increment(&self, feature: &str) -> Result<f64, glib::Error>;
#[doc(alias = "arv_device_get_float_feature_value")]
#[doc(alias = "get_float_feature_value")]
fn float_feature_value(&self, feature: &str) -> Result<f64, glib::Error>;
#[doc(alias = "arv_device_get_genicam")]
#[doc(alias = "get_genicam")]
fn genicam(&self) -> Option<Gc>;
#[doc(alias = "arv_device_get_genicam_xml")]
#[doc(alias = "get_genicam_xml")]
fn genicam_xml(&self) -> (glib::GString, usize);
#[doc(alias = "arv_device_get_integer_feature_bounds")]
#[doc(alias = "get_integer_feature_bounds")]
fn integer_feature_bounds(&self, feature: &str) -> Result<(i64, i64), glib::Error>;
#[doc(alias = "arv_device_get_integer_feature_increment")]
#[doc(alias = "get_integer_feature_increment")]
fn integer_feature_increment(&self, feature: &str) -> Result<i64, glib::Error>;
#[doc(alias = "arv_device_get_integer_feature_value")]
#[doc(alias = "get_integer_feature_value")]
fn integer_feature_value(&self, feature: &str) -> Result<i64, glib::Error>;
#[doc(alias = "arv_device_get_string_feature_value")]
#[doc(alias = "get_string_feature_value")]
fn string_feature_value(&self, feature: &str) -> Result<glib::GString, glib::Error>;
#[cfg(any(feature = "v0_8_17", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_17")))]
#[doc(alias = "arv_device_is_enumeration_entry_available")]
fn is_enumeration_entry_available(&self, feature: &str, entry: &str)
-> Result<(), glib::Error>;
#[doc(alias = "arv_device_is_feature_available")]
fn is_feature_available(&self, feature: &str) -> Result<bool, glib::Error>;
#[doc(alias = "arv_device_read_register")]
fn read_register(&self, address: u64) -> Result<(bool, u32), glib::Error>;
#[cfg(any(feature = "v0_8_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_22")))]
#[doc(alias = "arv_device_set_access_check_policy")]
fn set_access_check_policy(&self, policy: AccessCheckPolicy);
#[doc(alias = "arv_device_set_boolean_feature_value")]
fn set_boolean_feature_value(&self, feature: &str, value: bool) -> Result<(), glib::Error>;
#[doc(alias = "arv_device_set_features_from_string")]
fn set_features_from_string(&self, string: &str) -> Result<(), glib::Error>;
#[doc(alias = "arv_device_set_float_feature_value")]
fn set_float_feature_value(&self, feature: &str, value: f64) -> Result<(), glib::Error>;
#[doc(alias = "arv_device_set_integer_feature_value")]
fn set_integer_feature_value(&self, feature: &str, value: i64) -> Result<(), glib::Error>;
#[cfg(any(feature = "v0_8_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_6")))]
#[doc(alias = "arv_device_set_range_check_policy")]
fn set_range_check_policy(&self, policy: RangeCheckPolicy);
#[doc(alias = "arv_device_set_register_cache_policy")]
fn set_register_cache_policy(&self, policy: RegisterCachePolicy);
#[doc(alias = "arv_device_set_string_feature_value")]
fn set_string_feature_value(&self, feature: &str, value: &str) -> Result<(), glib::Error>;
#[doc(alias = "arv_device_write_register")]
fn write_register(&self, address: u64, value: u32) -> Result<bool, glib::Error>;
#[doc(alias = "control-lost")]
fn connect_control_lost<F: Fn(&Self) + Send + 'static>(&self, f: F) -> SignalHandlerId;
}
impl<O: IsA<Device>> DeviceExt for O {
fn create_chunk_parser(&self) -> Option<ChunkParser> {
unsafe {
from_glib_full(ffi::arv_device_create_chunk_parser(
self.as_ref().to_glib_none().0,
))
}
}
fn dup_available_enumeration_feature_values(
&self,
feature: &str,
) -> Result<Vec<i64>, glib::Error> {
unsafe {
let mut n_values = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
let ret = ffi::arv_device_dup_available_enumeration_feature_values(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
n_values.as_mut_ptr(),
&mut error,
);
if error.is_null() {
Ok(FromGlibContainer::from_glib_container_num(
ret,
n_values.assume_init() as usize,
))
} else {
Err(from_glib_full(error))
}
}
}
fn dup_available_enumeration_feature_values_as_display_names(
&self,
feature: &str,
) -> Result<Vec<glib::GString>, glib::Error> {
unsafe {
let mut n_values = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
let ret = ffi::arv_device_dup_available_enumeration_feature_values_as_display_names(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
n_values.as_mut_ptr(),
&mut error,
);
if error.is_null() {
Ok(FromGlibContainer::from_glib_container_num(
ret,
n_values.assume_init() as usize,
))
} else {
Err(from_glib_full(error))
}
}
}
fn dup_available_enumeration_feature_values_as_strings(
&self,
feature: &str,
) -> Result<Vec<glib::GString>, glib::Error> {
unsafe {
let mut n_values = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
let ret = ffi::arv_device_dup_available_enumeration_feature_values_as_strings(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
n_values.as_mut_ptr(),
&mut error,
);
if error.is_null() {
Ok(FromGlibContainer::from_glib_container_num(
ret,
n_values.assume_init() as usize,
))
} else {
Err(from_glib_full(error))
}
}
}
fn execute_command(&self, feature: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::arv_device_execute_command(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
fn boolean_feature_value(&self, feature: &str) -> Result<bool, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::arv_device_get_boolean_feature_value(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib(ret))
} else {
Err(from_glib_full(error))
}
}
}
fn feature(&self, feature: &str) -> Option<GcNode> {
unsafe {
from_glib_none(ffi::arv_device_get_feature(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
))
}
}
#[cfg(any(feature = "v0_8_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_22")))]
fn feature_access_mode(&self, feature: &str) -> GcAccessMode {
unsafe {
from_glib(ffi::arv_device_get_feature_access_mode(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
))
}
}
fn float_feature_bounds(&self, feature: &str) -> Result<(f64, f64), glib::Error> {
unsafe {
let mut min = mem::MaybeUninit::uninit();
let mut max = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
let _ = ffi::arv_device_get_float_feature_bounds(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
min.as_mut_ptr(),
max.as_mut_ptr(),
&mut error,
);
let min = min.assume_init();
let max = max.assume_init();
if error.is_null() {
Ok((min, max))
} else {
Err(from_glib_full(error))
}
}
}
#[cfg(any(feature = "v0_8_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_16")))]
fn float_feature_increment(&self, feature: &str) -> Result<f64, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::arv_device_get_float_feature_increment(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(ret)
} else {
Err(from_glib_full(error))
}
}
}
fn float_feature_value(&self, feature: &str) -> Result<f64, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::arv_device_get_float_feature_value(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(ret)
} else {
Err(from_glib_full(error))
}
}
}
fn genicam(&self) -> Option<Gc> {
unsafe { from_glib_none(ffi::arv_device_get_genicam(self.as_ref().to_glib_none().0)) }
}
fn genicam_xml(&self) -> (glib::GString, usize) {
unsafe {
let mut size = mem::MaybeUninit::uninit();
let ret = from_glib_none(ffi::arv_device_get_genicam_xml(
self.as_ref().to_glib_none().0,
size.as_mut_ptr(),
));
let size = size.assume_init();
(ret, size)
}
}
fn integer_feature_bounds(&self, feature: &str) -> Result<(i64, i64), glib::Error> {
unsafe {
let mut min = mem::MaybeUninit::uninit();
let mut max = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
let _ = ffi::arv_device_get_integer_feature_bounds(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
min.as_mut_ptr(),
max.as_mut_ptr(),
&mut error,
);
let min = min.assume_init();
let max = max.assume_init();
if error.is_null() {
Ok((min, max))
} else {
Err(from_glib_full(error))
}
}
}
fn integer_feature_increment(&self, feature: &str) -> Result<i64, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::arv_device_get_integer_feature_increment(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(ret)
} else {
Err(from_glib_full(error))
}
}
}
fn integer_feature_value(&self, feature: &str) -> Result<i64, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::arv_device_get_integer_feature_value(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(ret)
} else {
Err(from_glib_full(error))
}
}
}
fn string_feature_value(&self, feature: &str) -> Result<glib::GString, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::arv_device_get_string_feature_value(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_none(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[cfg(any(feature = "v0_8_17", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_17")))]
fn is_enumeration_entry_available(
&self,
feature: &str,
entry: &str,
) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::arv_device_is_enumeration_entry_available(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
entry.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
fn is_feature_available(&self, feature: &str) -> Result<bool, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::arv_device_is_feature_available(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib(ret))
} else {
Err(from_glib_full(error))
}
}
}
fn read_register(&self, address: u64) -> Result<(bool, u32), glib::Error> {
unsafe {
let mut value = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
let ret = ffi::arv_device_read_register(
self.as_ref().to_glib_none().0,
address,
value.as_mut_ptr(),
&mut error,
);
let value = value.assume_init();
if error.is_null() {
Ok((from_glib(ret), value))
} else {
Err(from_glib_full(error))
}
}
}
#[cfg(any(feature = "v0_8_22", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_22")))]
fn set_access_check_policy(&self, policy: AccessCheckPolicy) {
unsafe {
ffi::arv_device_set_access_check_policy(
self.as_ref().to_glib_none().0,
policy.into_glib(),
);
}
}
fn set_boolean_feature_value(&self, feature: &str, value: bool) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::arv_device_set_boolean_feature_value(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
value.into_glib(),
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
fn set_features_from_string(&self, string: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::arv_device_set_features_from_string(
self.as_ref().to_glib_none().0,
string.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
fn set_float_feature_value(&self, feature: &str, value: f64) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::arv_device_set_float_feature_value(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
value,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
fn set_integer_feature_value(&self, feature: &str, value: i64) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::arv_device_set_integer_feature_value(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
value,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[cfg(any(feature = "v0_8_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8_6")))]
fn set_range_check_policy(&self, policy: RangeCheckPolicy) {
unsafe {
ffi::arv_device_set_range_check_policy(
self.as_ref().to_glib_none().0,
policy.into_glib(),
);
}
}
fn set_register_cache_policy(&self, policy: RegisterCachePolicy) {
unsafe {
ffi::arv_device_set_register_cache_policy(
self.as_ref().to_glib_none().0,
policy.into_glib(),
);
}
}
fn set_string_feature_value(&self, feature: &str, value: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::arv_device_set_string_feature_value(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
value.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
fn write_register(&self, address: u64, value: u32) -> Result<bool, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::arv_device_write_register(
self.as_ref().to_glib_none().0,
address,
value,
&mut error,
);
if error.is_null() {
Ok(from_glib(ret))
} else {
Err(from_glib_full(error))
}
}
}
fn connect_control_lost<F: Fn(&Self) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn control_lost_trampoline<P: IsA<Device>, F: Fn(&P) + Send + 'static>(
this: *mut ffi::ArvDevice,
f: glib::ffi::gpointer,
) {
let f: &F = &*(f as *const F);
f(Device::from_glib_borrow(this).unsafe_cast_ref())
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
b"control-lost\0".as_ptr() as *const _,
Some(transmute::<_, unsafe extern "C" fn()>(
control_lost_trampoline::<Self, F> as *const (),
)),
Box_::into_raw(f),
)
}
}
}
impl fmt::Display for Device {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("Device")
}
}