use crate::{Contextual, MediumType, Object, Sector, Session, Track, ffi};
use glib::{
object::ObjectType as _,
prelude::*,
signal::{SignalHandlerId, connect_raw},
translate::*,
};
use std::boxed::Box as Box_;
glib::wrapper! {
#[doc(alias = "MirageDisc")]
pub struct Disc(Object<ffi::MirageDisc, ffi::MirageDiscClass>) @extends Object, @implements Contextual;
match fn {
type_ => || ffi::mirage_disc_get_type(),
}
}
impl Disc {
pub const NONE: Option<&'static Disc> = None;
}
pub trait DiscExt: IsA<Disc> + 'static {
#[doc(alias = "mirage_disc_add_session_by_index")]
fn add_session_by_index(&self, index: i32, session: impl IsA<Session>) {
unsafe {
ffi::mirage_disc_add_session_by_index(
self.as_ref().to_glib_none().0,
index,
session.upcast().into_glib_ptr(),
);
}
}
#[doc(alias = "mirage_disc_add_session_by_number")]
fn add_session_by_number(
&self,
number: i32,
session: impl IsA<Session>,
) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_add_session_by_number(
self.as_ref().to_glib_none().0,
number,
session.upcast().into_glib_ptr(),
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_add_track_by_index")]
fn add_track_by_index(&self, index: i32, track: impl IsA<Track>) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_add_track_by_index(
self.as_ref().to_glib_none().0,
index,
track.upcast().into_glib_ptr(),
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_add_track_by_number")]
fn add_track_by_number(&self, number: i32, track: impl IsA<Track>) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_add_track_by_number(
self.as_ref().to_glib_none().0,
number,
track.upcast().into_glib_ptr(),
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_enumerate_sessions")]
fn enumerate_sessions<P: FnMut(&Session) -> bool>(&self, func: P) -> bool {
let mut func_data: P = func;
unsafe extern "C" fn func_func<P: FnMut(&Session) -> bool>(
session: *mut ffi::MirageSession,
user_data: glib::ffi::gpointer,
) -> glib::ffi::gboolean {
unsafe {
let session = from_glib_borrow(session);
let callback = user_data as *mut P;
(*callback)(&session).into_glib()
}
}
let func = Some(func_func::<P> as _);
let super_callback0: &mut P = &mut func_data;
unsafe {
from_glib(ffi::mirage_disc_enumerate_sessions(
self.as_ref().to_glib_none().0,
func,
super_callback0 as *mut _ as *mut _,
))
}
}
#[doc(alias = "mirage_disc_get_dpm_data_for_sector")]
#[doc(alias = "get_dpm_data_for_sector")]
fn dpm_data_for_sector(&self, address: i32) -> Result<(f64, f64), glib::Error> {
unsafe {
let mut angle = std::mem::MaybeUninit::uninit();
let mut density = std::mem::MaybeUninit::uninit();
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_get_dpm_data_for_sector(
self.as_ref().to_glib_none().0,
address,
angle.as_mut_ptr(),
density.as_mut_ptr(),
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok((angle.assume_init(), density.assume_init()))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_filenames")]
#[doc(alias = "get_filenames")]
fn filenames(&self) -> Vec<glib::GString> {
unsafe {
FromGlibPtrContainer::from_glib_none(ffi::mirage_disc_get_filenames(
self.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "mirage_disc_get_medium_type")]
#[doc(alias = "get_medium_type")]
fn medium_type(&self) -> MediumType {
unsafe {
from_glib(ffi::mirage_disc_get_medium_type(
self.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "mirage_disc_get_number_of_sessions")]
#[doc(alias = "get_number_of_sessions")]
fn number_of_sessions(&self) -> i32 {
unsafe { ffi::mirage_disc_get_number_of_sessions(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_disc_get_number_of_tracks")]
#[doc(alias = "get_number_of_tracks")]
fn number_of_tracks(&self) -> i32 {
unsafe { ffi::mirage_disc_get_number_of_tracks(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_disc_get_sector")]
#[doc(alias = "get_sector")]
fn sector(&self, address: i32) -> Result<Sector, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret =
ffi::mirage_disc_get_sector(self.as_ref().to_glib_none().0, address, &mut error);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_session_after")]
#[doc(alias = "get_session_after")]
fn session_after(&self, session: &impl IsA<Session>) -> Result<Session, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_session_after(
self.as_ref().to_glib_none().0,
session.as_ref().to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_session_before")]
#[doc(alias = "get_session_before")]
fn session_before(&self, session: &impl IsA<Session>) -> Result<Session, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_session_before(
self.as_ref().to_glib_none().0,
session.as_ref().to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_session_by_address")]
#[doc(alias = "get_session_by_address")]
fn session_by_address(&self, address: i32) -> Result<Session, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_session_by_address(
self.as_ref().to_glib_none().0,
address,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_session_by_index")]
#[doc(alias = "get_session_by_index")]
fn session_by_index(&self, index: i32) -> Result<Session, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_session_by_index(
self.as_ref().to_glib_none().0,
index,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_session_by_number")]
#[doc(alias = "get_session_by_number")]
fn session_by_number(&self, number: i32) -> Result<Session, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_session_by_number(
self.as_ref().to_glib_none().0,
number,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_session_by_track")]
#[doc(alias = "get_session_by_track")]
fn session_by_track(&self, track: i32) -> Result<Session, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_session_by_track(
self.as_ref().to_glib_none().0,
track,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_track_by_address")]
#[doc(alias = "get_track_by_address")]
fn track_by_address(&self, address: i32) -> Result<Track, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_track_by_address(
self.as_ref().to_glib_none().0,
address,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_track_by_index")]
#[doc(alias = "get_track_by_index")]
fn track_by_index(&self, index: i32) -> Result<Track, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_track_by_index(
self.as_ref().to_glib_none().0,
index,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_get_track_by_number")]
#[doc(alias = "get_track_by_number")]
fn track_by_number(&self, number: i32) -> Result<Track, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_disc_get_track_by_number(
self.as_ref().to_glib_none().0,
number,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_layout_contains_address")]
fn layout_contains_address(&self, address: i32) -> bool {
unsafe {
from_glib(ffi::mirage_disc_layout_contains_address(
self.as_ref().to_glib_none().0,
address,
))
}
}
#[doc(alias = "mirage_disc_layout_get_first_session")]
fn layout_get_first_session(&self) -> i32 {
unsafe { ffi::mirage_disc_layout_get_first_session(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_disc_layout_get_first_track")]
fn layout_get_first_track(&self) -> i32 {
unsafe { ffi::mirage_disc_layout_get_first_track(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_disc_layout_get_length")]
fn layout_get_length(&self) -> i32 {
unsafe { ffi::mirage_disc_layout_get_length(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_disc_layout_get_start_sector")]
fn layout_get_start_sector(&self) -> i32 {
unsafe { ffi::mirage_disc_layout_get_start_sector(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_disc_layout_set_first_session")]
fn layout_set_first_session(&self, first_session: i32) {
unsafe {
ffi::mirage_disc_layout_set_first_session(
self.as_ref().to_glib_none().0,
first_session,
);
}
}
#[doc(alias = "mirage_disc_layout_set_first_track")]
fn layout_set_first_track(&self, first_track: i32) {
unsafe {
ffi::mirage_disc_layout_set_first_track(self.as_ref().to_glib_none().0, first_track);
}
}
#[doc(alias = "mirage_disc_layout_set_start_sector")]
fn layout_set_start_sector(&self, start_sector: i32) {
unsafe {
ffi::mirage_disc_layout_set_start_sector(self.as_ref().to_glib_none().0, start_sector);
}
}
#[doc(alias = "mirage_disc_put_sector")]
fn put_sector(&self, sector: &impl IsA<Sector>) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_put_sector(
self.as_ref().to_glib_none().0,
sector.as_ref().to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[cfg(feature = "v3_3_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v3_3_2")))]
#[doc(alias = "mirage_disc_read_sector")]
fn read_sector(&self, address: i32, sector: &impl IsA<Sector>) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_read_sector(
self.as_ref().to_glib_none().0,
address,
sector.as_ref().to_glib_none().0,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_remove_session_by_index")]
fn remove_session_by_index(&self, index: i32) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_remove_session_by_index(
self.as_ref().to_glib_none().0,
index,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_remove_session_by_number")]
fn remove_session_by_number(&self, number: i32) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_remove_session_by_number(
self.as_ref().to_glib_none().0,
number,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_remove_session_by_object")]
fn remove_session_by_object(&self, session: &impl IsA<Session>) {
unsafe {
ffi::mirage_disc_remove_session_by_object(
self.as_ref().to_glib_none().0,
session.as_ref().to_glib_none().0,
);
}
}
#[doc(alias = "mirage_disc_remove_track_by_index")]
fn remove_track_by_index(&self, index: i32) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_remove_track_by_index(
self.as_ref().to_glib_none().0,
index,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_remove_track_by_number")]
fn remove_track_by_number(&self, number: i32) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_disc_remove_track_by_number(
self.as_ref().to_glib_none().0,
number,
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_disc_set_disc_structure")]
fn set_disc_structure(&self, layer: i32, type_: i32, data: &[u8]) {
let len = data.len() as _;
unsafe {
ffi::mirage_disc_set_disc_structure(
self.as_ref().to_glib_none().0,
layer,
type_,
data.to_glib_none().0,
len,
);
}
}
#[doc(alias = "mirage_disc_set_dpm_data")]
fn set_dpm_data(&self, start: i32, resolution: i32, data: &[u32]) {
let num_entries = data.len() as _;
unsafe {
ffi::mirage_disc_set_dpm_data(
self.as_ref().to_glib_none().0,
start,
resolution,
num_entries,
data.to_glib_none().0,
);
}
}
#[doc(alias = "mirage_disc_set_filename")]
fn set_filename(&self, filename: &str) {
unsafe {
ffi::mirage_disc_set_filename(
self.as_ref().to_glib_none().0,
filename.to_glib_none().0,
);
}
}
#[doc(alias = "mirage_disc_set_filenames")]
fn set_filenames(&self, filenames: &[&str]) {
unsafe {
ffi::mirage_disc_set_filenames(
self.as_ref().to_glib_none().0,
filenames.to_glib_none().0,
);
}
}
#[doc(alias = "mirage_disc_set_medium_type")]
fn set_medium_type(&self, medium_type: MediumType) {
unsafe {
ffi::mirage_disc_set_medium_type(
self.as_ref().to_glib_none().0,
medium_type.into_glib(),
);
}
}
#[doc(alias = "layout-changed")]
fn connect_layout_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn layout_changed_trampoline<P: IsA<Disc>, F: Fn(&P) + 'static>(
this: *mut ffi::MirageDisc,
f: glib::ffi::gpointer,
) {
unsafe {
let f: &F = &*(f as *const F);
f(Disc::from_glib_borrow(this).unsafe_cast_ref())
}
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
c"layout-changed".as_ptr(),
Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
layout_changed_trampoline::<Self, F> as *const (),
)),
Box_::into_raw(f),
)
}
}
}
impl<O: IsA<Disc>> DiscExt for O {}