use crate::{Contextual, Language, Object, SessionType, Track, ffi};
use glib::{
object::ObjectType as _,
prelude::*,
signal::{SignalHandlerId, connect_raw},
translate::*,
};
use std::boxed::Box as Box_;
glib::wrapper! {
#[doc(alias = "MirageSession")]
pub struct Session(Object<ffi::MirageSession, ffi::MirageSessionClass>) @extends Object, @implements Contextual;
match fn {
type_ => || ffi::mirage_session_get_type(),
}
}
impl Session {
pub const NONE: Option<&'static Session> = None;
}
pub trait SessionExt: IsA<Session> + 'static {
#[doc(alias = "mirage_session_add_language")]
fn add_language(&self, code: i32, language: impl IsA<Language>) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_session_add_language(
self.as_ref().to_glib_none().0,
code,
language.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_session_add_track_by_index")]
fn add_track_by_index(&self, index: i32, track: impl IsA<Track>) {
unsafe {
ffi::mirage_session_add_track_by_index(
self.as_ref().to_glib_none().0,
index,
track.upcast().into_glib_ptr(),
);
}
}
#[doc(alias = "mirage_session_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_session_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_session_enumerate_languages")]
fn enumerate_languages<P: FnMut(&Language) -> bool>(&self, func: P) -> bool {
let mut func_data: P = func;
unsafe extern "C" fn func_func<P: FnMut(&Language) -> bool>(
language: *mut ffi::MirageLanguage,
user_data: glib::ffi::gpointer,
) -> glib::ffi::gboolean {
unsafe {
let language = from_glib_borrow(language);
let callback = user_data as *mut P;
(*callback)(&language).into_glib()
}
}
let func = Some(func_func::<P> as _);
let super_callback0: &mut P = &mut func_data;
unsafe {
from_glib(ffi::mirage_session_enumerate_languages(
self.as_ref().to_glib_none().0,
func,
super_callback0 as *mut _ as *mut _,
))
}
}
#[doc(alias = "mirage_session_enumerate_tracks")]
fn enumerate_tracks<P: FnMut(&Track) -> bool>(&self, func: P) -> bool {
let mut func_data: P = func;
unsafe extern "C" fn func_func<P: FnMut(&Track) -> bool>(
track: *mut ffi::MirageTrack,
user_data: glib::ffi::gpointer,
) -> glib::ffi::gboolean {
unsafe {
let track = from_glib_borrow(track);
let callback = user_data as *mut P;
(*callback)(&track).into_glib()
}
}
let func = Some(func_func::<P> as _);
let super_callback0: &mut P = &mut func_data;
unsafe {
from_glib(ffi::mirage_session_enumerate_tracks(
self.as_ref().to_glib_none().0,
func,
super_callback0 as *mut _ as *mut _,
))
}
}
#[doc(alias = "mirage_session_get_cdtext_data")]
#[doc(alias = "get_cdtext_data")]
fn cdtext_data(&self) -> Result<Vec<u8>, glib::Error> {
unsafe {
let mut data = std::ptr::null_mut();
let mut len = std::mem::MaybeUninit::uninit();
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_session_get_cdtext_data(
self.as_ref().to_glib_none().0,
&mut data,
len.as_mut_ptr(),
&mut error,
);
debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(FromGlibContainer::from_glib_full_num(
data,
len.assume_init() as _,
))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_session_get_language_by_code")]
#[doc(alias = "get_language_by_code")]
fn language_by_code(&self, code: i32) -> Result<Language, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_session_get_language_by_code(
self.as_ref().to_glib_none().0,
code,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "mirage_session_get_language_by_index")]
#[doc(alias = "get_language_by_index")]
fn language_by_index(&self, index: i32) -> Result<Language, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_session_get_language_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_session_get_leadout_length")]
#[doc(alias = "get_leadout_length")]
fn leadout_length(&self) -> i32 {
unsafe { ffi::mirage_session_get_leadout_length(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_session_get_mcn")]
#[doc(alias = "get_mcn")]
fn mcn(&self) -> Option<glib::GString> {
unsafe { from_glib_none(ffi::mirage_session_get_mcn(self.as_ref().to_glib_none().0)) }
}
#[doc(alias = "mirage_session_get_next")]
#[doc(alias = "get_next")]
fn next(&self) -> Result<Session, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_session_get_next(self.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_session_get_number_of_languages")]
#[doc(alias = "get_number_of_languages")]
fn number_of_languages(&self) -> i32 {
unsafe { ffi::mirage_session_get_number_of_languages(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_session_get_number_of_tracks")]
#[doc(alias = "get_number_of_tracks")]
fn number_of_tracks(&self) -> i32 {
unsafe { ffi::mirage_session_get_number_of_tracks(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_session_get_prev")]
#[doc(alias = "get_prev")]
fn prev(&self) -> Result<Session, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_session_get_prev(self.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_session_get_session_type")]
#[doc(alias = "get_session_type")]
fn session_type(&self) -> SessionType {
unsafe {
from_glib(ffi::mirage_session_get_session_type(
self.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "mirage_session_get_track_after")]
#[doc(alias = "get_track_after")]
fn track_after(&self, track: &impl IsA<Track>) -> Result<Track, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_session_get_track_after(
self.as_ref().to_glib_none().0,
track.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_session_get_track_before")]
#[doc(alias = "get_track_before")]
fn track_before(&self, track: &impl IsA<Track>) -> Result<Track, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::mirage_session_get_track_before(
self.as_ref().to_glib_none().0,
track.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_session_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_session_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_session_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_session_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_session_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_session_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_session_layout_contains_address")]
fn layout_contains_address(&self, address: i32) -> bool {
unsafe {
from_glib(ffi::mirage_session_layout_contains_address(
self.as_ref().to_glib_none().0,
address,
))
}
}
#[doc(alias = "mirage_session_layout_get_first_track")]
fn layout_get_first_track(&self) -> i32 {
unsafe { ffi::mirage_session_layout_get_first_track(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_session_layout_get_length")]
fn layout_get_length(&self) -> i32 {
unsafe { ffi::mirage_session_layout_get_length(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_session_layout_get_session_number")]
fn layout_get_session_number(&self) -> i32 {
unsafe { ffi::mirage_session_layout_get_session_number(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_session_layout_get_start_sector")]
fn layout_get_start_sector(&self) -> i32 {
unsafe { ffi::mirage_session_layout_get_start_sector(self.as_ref().to_glib_none().0) }
}
#[doc(alias = "mirage_session_layout_set_first_track")]
fn layout_set_first_track(&self, first_track: i32) {
unsafe {
ffi::mirage_session_layout_set_first_track(self.as_ref().to_glib_none().0, first_track);
}
}
#[doc(alias = "mirage_session_layout_set_session_number")]
fn layout_set_session_number(&self, number: i32) {
unsafe {
ffi::mirage_session_layout_set_session_number(self.as_ref().to_glib_none().0, number);
}
}
#[doc(alias = "mirage_session_layout_set_start_sector")]
fn layout_set_start_sector(&self, start_sector: i32) {
unsafe {
ffi::mirage_session_layout_set_start_sector(
self.as_ref().to_glib_none().0,
start_sector,
);
}
}
#[doc(alias = "mirage_session_remove_language_by_code")]
fn remove_language_by_code(&self, code: i32) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_session_remove_language_by_code(
self.as_ref().to_glib_none().0,
code,
&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_session_remove_language_by_index")]
fn remove_language_by_index(&self, index: i32) -> Result<(), glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_session_remove_language_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_session_remove_language_by_object")]
fn remove_language_by_object(&self, language: &impl IsA<Language>) {
unsafe {
ffi::mirage_session_remove_language_by_object(
self.as_ref().to_glib_none().0,
language.as_ref().to_glib_none().0,
);
}
}
#[doc(alias = "mirage_session_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_session_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_session_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_session_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_session_remove_track_by_object")]
fn remove_track_by_object(&self, track: &impl IsA<Track>) {
unsafe {
ffi::mirage_session_remove_track_by_object(
self.as_ref().to_glib_none().0,
track.as_ref().to_glib_none().0,
);
}
}
#[doc(alias = "mirage_session_set_cdtext_data")]
fn set_cdtext_data(&self, data: &[u8]) -> Result<(), glib::Error> {
let len = data.len() as _;
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::mirage_session_set_cdtext_data(
self.as_ref().to_glib_none().0,
data.to_glib_none().0,
len,
&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_session_set_leadout_length")]
fn set_leadout_length(&self, length: i32) {
unsafe {
ffi::mirage_session_set_leadout_length(self.as_ref().to_glib_none().0, length);
}
}
#[doc(alias = "mirage_session_set_mcn")]
fn set_mcn(&self, mcn: &str) {
unsafe {
ffi::mirage_session_set_mcn(self.as_ref().to_glib_none().0, mcn.to_glib_none().0);
}
}
#[doc(alias = "mirage_session_set_session_type")]
fn set_session_type(&self, type_: SessionType) {
unsafe {
ffi::mirage_session_set_session_type(self.as_ref().to_glib_none().0, 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<Session>, F: Fn(&P) + 'static>(
this: *mut ffi::MirageSession,
f: glib::ffi::gpointer,
) {
unsafe {
let f: &F = &*(f as *const F);
f(Session::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<Session>> SessionExt for O {}