libmirage 0.1.1

// 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 crate::{Contextual, Fragment, Index, Language, Object, Sector, SectorType, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    #[doc(alias = "MirageTrack")]
    pub struct Track(Object<ffi::MirageTrack, ffi::MirageTrackClass>) @extends Object, @implements Contextual;

    match fn {
        type_ => || ffi::mirage_track_get_type(),
    }
}

impl Track {
    pub const NONE: Option<&'static Track> = None;
}

pub trait TrackExt: IsA<Track> + 'static {
    #[doc(alias = "mirage_track_add_fragment")]
    fn add_fragment(&self, index: i32, fragment: &impl IsA<Fragment>) {
        unsafe {
            ffi::mirage_track_add_fragment(
                self.as_ref().to_glib_none().0,
                index,
                fragment.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "mirage_track_add_index")]
    fn add_index(&self, address: i32) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok =
                ffi::mirage_track_add_index(self.as_ref().to_glib_none().0, address, &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_track_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_track_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_track_enumerate_fragments")]
    fn enumerate_fragments<P: FnMut(&Fragment) -> bool>(&self, func: P) -> bool {
        let mut func_data: P = func;
        unsafe extern "C" fn func_func<P: FnMut(&Fragment) -> bool>(
            fragment: *mut ffi::MirageFragment,
            user_data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let fragment = from_glib_borrow(fragment);
                let callback = user_data as *mut P;
                (*callback)(&fragment).into_glib()
            }
        }
        let func = Some(func_func::<P> as _);
        let super_callback0: &mut P = &mut func_data;
        unsafe {
            from_glib(ffi::mirage_track_enumerate_fragments(
                self.as_ref().to_glib_none().0,
                func,
                super_callback0 as *mut _ as *mut _,
            ))
        }
    }

    #[doc(alias = "mirage_track_enumerate_indices")]
    fn enumerate_indices<P: FnMut(&Index) -> bool>(&self, func: P) -> bool {
        let mut func_data: P = func;
        unsafe extern "C" fn func_func<P: FnMut(&Index) -> bool>(
            index: *mut ffi::MirageIndex,
            user_data: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let index = from_glib_borrow(index);
                let callback = user_data as *mut P;
                (*callback)(&index).into_glib()
            }
        }
        let func = Some(func_func::<P> as _);
        let super_callback0: &mut P = &mut func_data;
        unsafe {
            from_glib(ffi::mirage_track_enumerate_indices(
                self.as_ref().to_glib_none().0,
                func,
                super_callback0 as *mut _ as *mut _,
            ))
        }
    }

    #[doc(alias = "mirage_track_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_track_enumerate_languages(
                self.as_ref().to_glib_none().0,
                func,
                super_callback0 as *mut _ as *mut _,
            ))
        }
    }

    #[doc(alias = "mirage_track_find_fragment_with_subchannel")]
    fn find_fragment_with_subchannel(&self) -> Result<Fragment, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::mirage_track_find_fragment_with_subchannel(
                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_track_get_adr")]
    #[doc(alias = "get_adr")]
    fn adr(&self) -> i32 {
        unsafe { ffi::mirage_track_get_adr(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_get_ctl")]
    #[doc(alias = "get_ctl")]
    fn ctl(&self) -> i32 {
        unsafe { ffi::mirage_track_get_ctl(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_get_flags")]
    #[doc(alias = "get_flags")]
    fn flags(&self) -> i32 {
        unsafe { ffi::mirage_track_get_flags(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_get_fragment_by_address")]
    #[doc(alias = "get_fragment_by_address")]
    fn fragment_by_address(&self, address: i32) -> Result<Fragment, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::mirage_track_get_fragment_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_track_get_fragment_by_index")]
    #[doc(alias = "get_fragment_by_index")]
    fn fragment_by_index(&self, index: i32) -> Result<Fragment, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::mirage_track_get_fragment_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_track_get_index_by_address")]
    #[doc(alias = "get_index_by_address")]
    fn index_by_address(&self, address: i32) -> Result<Index, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::mirage_track_get_index_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_track_get_index_by_number")]
    #[doc(alias = "get_index_by_number")]
    fn index_by_number(&self, number: i32) -> Result<Index, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::mirage_track_get_index_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_track_get_isrc")]
    #[doc(alias = "get_isrc")]
    fn isrc(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::mirage_track_get_isrc(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "mirage_track_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_track_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_track_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_track_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_track_get_next")]
    #[doc(alias = "get_next")]
    fn next(&self) -> Result<Track, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::mirage_track_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_track_get_number_of_fragments")]
    #[doc(alias = "get_number_of_fragments")]
    fn number_of_fragments(&self) -> i32 {
        unsafe { ffi::mirage_track_get_number_of_fragments(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_get_number_of_indices")]
    #[doc(alias = "get_number_of_indices")]
    fn number_of_indices(&self) -> i32 {
        unsafe { ffi::mirage_track_get_number_of_indices(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_get_number_of_languages")]
    #[doc(alias = "get_number_of_languages")]
    fn number_of_languages(&self) -> i32 {
        unsafe { ffi::mirage_track_get_number_of_languages(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_get_prev")]
    #[doc(alias = "get_prev")]
    fn prev(&self) -> Result<Track, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::mirage_track_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_track_get_sector")]
    #[doc(alias = "get_sector")]
    fn sector(&self, address: i32, abs: bool) -> Result<Sector, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::mirage_track_get_sector(
                self.as_ref().to_glib_none().0,
                address,
                abs.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "mirage_track_get_sector_type")]
    #[doc(alias = "get_sector_type")]
    fn sector_type(&self) -> SectorType {
        unsafe {
            from_glib(ffi::mirage_track_get_sector_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "mirage_track_get_track_start")]
    #[doc(alias = "get_track_start")]
    fn track_start(&self) -> i32 {
        unsafe { ffi::mirage_track_get_track_start(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_layout_contains_address")]
    fn layout_contains_address(&self, address: i32) -> bool {
        unsafe {
            from_glib(ffi::mirage_track_layout_contains_address(
                self.as_ref().to_glib_none().0,
                address,
            ))
        }
    }

    #[doc(alias = "mirage_track_layout_get_length")]
    fn layout_get_length(&self) -> i32 {
        unsafe { ffi::mirage_track_layout_get_length(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_layout_get_session_number")]
    fn layout_get_session_number(&self) -> i32 {
        unsafe { ffi::mirage_track_layout_get_session_number(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_layout_get_start_sector")]
    fn layout_get_start_sector(&self) -> i32 {
        unsafe { ffi::mirage_track_layout_get_start_sector(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_layout_get_track_number")]
    fn layout_get_track_number(&self) -> i32 {
        unsafe { ffi::mirage_track_layout_get_track_number(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "mirage_track_layout_set_start_sector")]
    fn layout_set_start_sector(&self, start_sector: i32) {
        unsafe {
            ffi::mirage_track_layout_set_start_sector(self.as_ref().to_glib_none().0, start_sector);
        }
    }

    #[doc(alias = "mirage_track_layout_set_track_number")]
    fn layout_set_track_number(&self, track_number: i32) {
        unsafe {
            ffi::mirage_track_layout_set_track_number(self.as_ref().to_glib_none().0, track_number);
        }
    }

    #[doc(alias = "mirage_track_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_track_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_track_read_sector")]
    fn read_sector(
        &self,
        address: i32,
        abs: bool,
        sector: &impl IsA<Sector>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::mirage_track_read_sector(
                self.as_ref().to_glib_none().0,
                address,
                abs.into_glib(),
                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_track_remove_fragment_by_index")]
    fn remove_fragment_by_index(&self, index: i32) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::mirage_track_remove_fragment_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_track_remove_fragment_by_object")]
    fn remove_fragment_by_object(&self, fragment: &impl IsA<Fragment>) {
        unsafe {
            ffi::mirage_track_remove_fragment_by_object(
                self.as_ref().to_glib_none().0,
                fragment.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "mirage_track_remove_index_by_number")]
    fn remove_index_by_number(&self, number: i32) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::mirage_track_remove_index_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_track_remove_index_by_object")]
    fn remove_index_by_object(&self, index: &impl IsA<Index>) {
        unsafe {
            ffi::mirage_track_remove_index_by_object(
                self.as_ref().to_glib_none().0,
                index.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "mirage_track_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_track_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_track_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_track_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_track_remove_language_by_object")]
    fn remove_language_by_object(&self, language: &impl IsA<Language>) {
        unsafe {
            ffi::mirage_track_remove_language_by_object(
                self.as_ref().to_glib_none().0,
                language.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "mirage_track_set_ctl")]
    fn set_ctl(&self, ctl: i32) {
        unsafe {
            ffi::mirage_track_set_ctl(self.as_ref().to_glib_none().0, ctl);
        }
    }

    #[doc(alias = "mirage_track_set_flags")]
    fn set_flags(&self, flags: i32) {
        unsafe {
            ffi::mirage_track_set_flags(self.as_ref().to_glib_none().0, flags);
        }
    }

    #[doc(alias = "mirage_track_set_isrc")]
    fn set_isrc(&self, isrc: &str) {
        unsafe {
            ffi::mirage_track_set_isrc(self.as_ref().to_glib_none().0, isrc.to_glib_none().0);
        }
    }

    #[doc(alias = "mirage_track_set_sector_type")]
    fn set_sector_type(&self, sector_type: SectorType) {
        unsafe {
            ffi::mirage_track_set_sector_type(
                self.as_ref().to_glib_none().0,
                sector_type.into_glib(),
            );
        }
    }

    #[doc(alias = "mirage_track_set_track_start")]
    fn set_track_start(&self, track_start: i32) {
        unsafe {
            ffi::mirage_track_set_track_start(self.as_ref().to_glib_none().0, track_start);
        }
    }

    #[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<Track>, F: Fn(&P) + 'static>(
            this: *mut ffi::MirageTrack,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Track::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<Track>> TrackExt for O {}