gegl 0.4.0

// Generated by gir (https://github.com/gtk-rs/gir @ 36917718ae60)
// from
// from gir-files (https://github.com/gtk-rs/gir-files @ 4488813a3fc3)
// DO NOT EDIT

use crate::{ffi, Config, Node, Path, Rectangle, SerializeFlag, SplitStrategy, Stats};
use glib::translate::*;

//#[doc(alias = "gegl_apply_op")]
//pub fn apply_op(buffer: &Buffer, operation_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
//    unsafe { TODO: call ffi:gegl_apply_op() }
//}

//#[doc(alias = "gegl_apply_op_valist")]
//pub fn apply_op_valist(buffer: &Buffer, operation_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
//    unsafe { TODO: call ffi:gegl_apply_op_valist() }
//}

//#[doc(alias = "gegl_calloc")]
//pub fn calloc(size: usize, n_memb: i32) -> /*Unimplemented*/Option<Basic: Pointer> {
//    unsafe { TODO: call ffi:gegl_calloc() }
//}

#[doc(alias = "gegl_cl_disable")]
pub fn cl_disable() {
    unsafe {
        ffi::gegl_cl_disable();
    }
}

#[doc(alias = "gegl_cl_init")]
pub fn cl_init() -> Result<(), glib::Error> {
    unsafe {
        let mut error = std::ptr::null_mut();
        let is_ok = ffi::gegl_cl_init(&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 = "gegl_cl_is_accelerated")]
pub fn cl_is_accelerated() -> bool {
    unsafe { from_glib(ffi::gegl_cl_is_accelerated()) }
}

#[doc(alias = "gegl_config")]
pub fn config() -> Config {
    unsafe { from_glib_none(ffi::gegl_config()) }
}

#[doc(alias = "gegl_create_chain")]
pub fn create_chain(
    ops: &str,
    op_start: &Node,
    op_end: &Node,
    time: f64,
    rel_dim: i32,
    path_root: &str,
) -> Result<(), glib::Error> {
    unsafe {
        let mut error = std::ptr::null_mut();
        let _ = ffi::gegl_create_chain(
            ops.to_glib_none().0,
            op_start.to_glib_none().0,
            op_end.to_glib_none().0,
            time,
            rel_dim,
            path_root.to_glib_none().0,
            &mut error,
        );
        if error.is_null() {
            Ok(())
        } else {
            Err(from_glib_full(error))
        }
    }
}

#[doc(alias = "gegl_exit")]
pub fn exit() {
    unsafe {
        ffi::gegl_exit();
    }
}

//#[doc(alias = "gegl_filter_op")]
//pub fn filter_op(source_buffer: &Buffer, operation_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Buffer> {
//    unsafe { TODO: call ffi:gegl_filter_op() }
//}

//#[doc(alias = "gegl_filter_op_valist")]
//pub fn filter_op_valist(source_buffer: &Buffer, operation_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) -> Option<Buffer> {
//    unsafe { TODO: call ffi:gegl_filter_op_valist() }
//}

#[doc(alias = "gegl_format")]
pub fn format(format_name: &str) -> Option<glib::Value> {
    unsafe { from_glib_full(ffi::gegl_format(format_name.to_glib_none().0)) }
}

#[doc(alias = "gegl_format_get_name")]
pub fn format_get_name(format: &mut glib::Value) -> Option<glib::GString> {
    unsafe { from_glib_none(ffi::gegl_format_get_name(format.to_glib_none_mut().0)) }
}

//#[doc(alias = "gegl_free")]
//pub fn free(mem: /*Unimplemented*/Option<Basic: Pointer>) {
//    unsafe { TODO: call ffi:gegl_free() }
//}

#[doc(alias = "gegl_get_version")]
#[doc(alias = "get_version")]
pub fn version() -> (i32, i32, i32) {
    unsafe {
        let mut major = std::mem::MaybeUninit::uninit();
        let mut minor = std::mem::MaybeUninit::uninit();
        let mut micro = std::mem::MaybeUninit::uninit();
        ffi::gegl_get_version(major.as_mut_ptr(), minor.as_mut_ptr(), micro.as_mut_ptr());
        (
            major.assume_init(),
            minor.assume_init(),
            micro.assume_init(),
        )
    }
}

#[doc(alias = "gegl_graph_dump_outputs")]
pub fn graph_dump_outputs(node: &Node) {
    unsafe {
        ffi::gegl_graph_dump_outputs(node.to_glib_none().0);
    }
}

#[doc(alias = "gegl_graph_dump_request")]
pub fn graph_dump_request(node: &Node, roi: &Rectangle) {
    unsafe {
        ffi::gegl_graph_dump_request(node.to_glib_none().0, roi.to_glib_none().0);
    }
}

#[doc(alias = "gegl_has_operation")]
pub fn has_operation(operation_type: &str) -> bool {
    unsafe { from_glib(ffi::gegl_has_operation(operation_type.to_glib_none().0)) }
}

//#[doc(alias = "gegl_init")]
//pub fn init(argv: /*Unimplemented*/Vec<glib::GString>) {
//    unsafe { TODO: call ffi:gegl_init() }
//}

#[doc(alias = "gegl_is_main_thread")]
pub fn is_main_thread() -> bool {
    unsafe { from_glib(ffi::gegl_is_main_thread()) }
}

#[doc(alias = "gegl_list_operations")]
pub fn list_operations() -> Vec<glib::GString> {
    unsafe {
        let mut n_operations_p = std::mem::MaybeUninit::uninit();
        let ret = FromGlibContainer::from_glib_container_num(
            ffi::gegl_list_operations(n_operations_p.as_mut_ptr()),
            n_operations_p.assume_init() as _,
        );
        ret
    }
}

#[doc(alias = "gegl_load_module_directory")]
pub fn load_module_directory(path: &str) {
    unsafe {
        ffi::gegl_load_module_directory(path.to_glib_none().0);
    }
}

//#[doc(alias = "gegl_malloc")]
//pub fn malloc(n_bytes: usize) -> /*Unimplemented*/Option<Basic: Pointer> {
//    unsafe { TODO: call ffi:gegl_malloc() }
//}

//#[doc(alias = "gegl_memeq_zero")]
//pub fn memeq_zero(ptr: /*Unimplemented*/Option<Basic: Pointer>, size: usize) -> bool {
//    unsafe { TODO: call ffi:gegl_memeq_zero() }
//}

//#[doc(alias = "gegl_memset_pattern")]
//pub fn memset_pattern(dst_ptr: /*Unimplemented*/Option<Basic: Pointer>, src_ptr: /*Unimplemented*/Option<Basic: Pointer>, pattern_size: i32, count: i32) {
//    unsafe { TODO: call ffi:gegl_memset_pattern() }
//}

#[doc(alias = "gegl_parallel_distribute")]
pub fn parallel_distribute<P: FnMut(i32, i32)>(max_n: i32, func: P) {
    let mut func_data: P = func;
    unsafe extern "C" fn func_func<P: FnMut(i32, i32)>(
        i: std::ffi::c_int,
        n: std::ffi::c_int,
        user_data: glib::ffi::gpointer,
    ) {
        unsafe {
            let callback = user_data as *mut P;
            (*callback)(i, n)
        }
    }
    let func = Some(func_func::<P> as _);
    let super_callback0: &mut P = &mut func_data;
    unsafe {
        ffi::gegl_parallel_distribute(max_n, func, super_callback0 as *mut _ as *mut _);
    }
}

#[doc(alias = "gegl_parallel_distribute_area")]
pub fn parallel_distribute_area<P: FnMut(&Rectangle)>(
    area: &Rectangle,
    thread_cost: f64,
    split_strategy: SplitStrategy,
    func: P,
) {
    let mut func_data: P = func;
    unsafe extern "C" fn func_func<P: FnMut(&Rectangle)>(
        area: *const ffi::GeglRectangle,
        user_data: glib::ffi::gpointer,
    ) {
        unsafe {
            let area = from_glib_borrow(area);
            let callback = user_data as *mut P;
            (*callback)(&area)
        }
    }
    let func = Some(func_func::<P> as _);
    let super_callback0: &mut P = &mut func_data;
    unsafe {
        ffi::gegl_parallel_distribute_area(
            area.to_glib_none().0,
            thread_cost,
            split_strategy.into_glib(),
            func,
            super_callback0 as *mut _ as *mut _,
        );
    }
}

#[doc(alias = "gegl_parallel_distribute_range")]
pub fn parallel_distribute_range<P: FnMut(usize, usize)>(size: usize, thread_cost: f64, func: P) {
    let mut func_data: P = func;
    unsafe extern "C" fn func_func<P: FnMut(usize, usize)>(
        offset: libc::size_t,
        size: libc::size_t,
        user_data: glib::ffi::gpointer,
    ) {
        unsafe {
            let callback = user_data as *mut P;
            (*callback)(offset, size)
        }
    }
    let func = Some(func_func::<P> as _);
    let super_callback0: &mut P = &mut func_data;
    unsafe {
        ffi::gegl_parallel_distribute_range(
            size,
            thread_cost,
            func,
            super_callback0 as *mut _ as *mut _,
        );
    }
}

#[doc(alias = "gegl_param_spec_audio_fragment")]
pub fn param_spec_audio_fragment(
    name: &str,
    nick: &str,
    blurb: &str,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_audio_fragment(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_color_from_string")]
pub fn param_spec_color_from_string(
    name: &str,
    nick: &str,
    blurb: &str,
    default_color_string: &str,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_color_from_string(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            default_color_string.to_glib_none().0,
            flags.into_glib(),
        ))
    }
}

//#[doc(alias = "gegl_param_spec_curve")]
//pub fn param_spec_curve(name: &str, nick: &str, blurb: &str, default_curve: /*Ignored*/&Curve, flags: glib::ParamFlags) -> Option<glib::ParamSpec> {
//    unsafe { TODO: call ffi:gegl_param_spec_curve() }
//}

#[doc(alias = "gegl_param_spec_double")]
pub fn param_spec_double(
    name: &str,
    nick: &str,
    blurb: &str,
    minimum: f64,
    maximum: f64,
    default_value: f64,
    ui_minimum: f64,
    ui_maximum: f64,
    ui_gamma: f64,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_double(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            minimum,
            maximum,
            default_value,
            ui_minimum,
            ui_maximum,
            ui_gamma,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_enum")]
pub fn param_spec_enum(
    name: &str,
    nick: &str,
    blurb: &str,
    enum_type: glib::types::Type,
    default_value: i32,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_enum(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            enum_type.into_glib(),
            default_value,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_file_path")]
pub fn param_spec_file_path(
    name: &str,
    nick: &str,
    blurb: &str,
    no_validate: bool,
    null_ok: bool,
    default_value: &str,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_file_path(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            no_validate.into_glib(),
            null_ok.into_glib(),
            default_value.to_glib_none().0,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_format")]
pub fn param_spec_format(
    name: &str,
    nick: &str,
    blurb: &str,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_format(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_int")]
pub fn param_spec_int(
    name: &str,
    nick: &str,
    blurb: &str,
    minimum: i32,
    maximum: i32,
    default_value: i32,
    ui_minimum: i32,
    ui_maximum: i32,
    ui_gamma: f64,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_int(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            minimum,
            maximum,
            default_value,
            ui_minimum,
            ui_maximum,
            ui_gamma,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_path")]
pub fn param_spec_path(
    name: &str,
    nick: &str,
    blurb: &str,
    default_path: &Path,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_path(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            default_path.to_glib_none().0,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_seed")]
pub fn param_spec_seed(
    name: &str,
    nick: &str,
    blurb: &str,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_seed(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_string")]
pub fn param_spec_string(
    name: &str,
    nick: &str,
    blurb: &str,
    no_validate: bool,
    null_ok: bool,
    default_value: &str,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_string(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            no_validate.into_glib(),
            null_ok.into_glib(),
            default_value.to_glib_none().0,
            flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_param_spec_uri")]
pub fn param_spec_uri(
    name: &str,
    nick: &str,
    blurb: &str,
    no_validate: bool,
    null_ok: bool,
    default_value: &str,
    flags: glib::ParamFlags,
) -> Option<glib::ParamSpec> {
    unsafe {
        from_glib_full(ffi::gegl_param_spec_uri(
            name.to_glib_none().0,
            nick.to_glib_none().0,
            blurb.to_glib_none().0,
            no_validate.into_glib(),
            null_ok.into_glib(),
            default_value.to_glib_none().0,
            flags.into_glib(),
        ))
    }
}

//#[doc(alias = "gegl_render_op")]
//pub fn render_op(source_buffer: &Buffer, target_buffer: &Buffer, operation_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
//    unsafe { TODO: call ffi:gegl_render_op() }
//}

//#[doc(alias = "gegl_render_op_valist")]
//pub fn render_op_valist(source_buffer: &Buffer, target_buffer: &Buffer, operation_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
//    unsafe { TODO: call ffi:gegl_render_op_valist() }
//}

#[doc(alias = "gegl_reset_stats")]
pub fn reset_stats() {
    unsafe {
        ffi::gegl_reset_stats();
    }
}

//#[doc(alias = "gegl_scratch_alloc")]
//pub fn scratch_alloc(size: usize) -> /*Unimplemented*/Option<Basic: Pointer> {
//    unsafe { TODO: call ffi:gegl_scratch_alloc() }
//}

//#[doc(alias = "gegl_scratch_alloc0")]
//pub fn scratch_alloc0(size: usize) -> /*Unimplemented*/Option<Basic: Pointer> {
//    unsafe { TODO: call ffi:gegl_scratch_alloc0() }
//}

//#[doc(alias = "gegl_scratch_free")]
//pub fn scratch_free(ptr: /*Unimplemented*/Option<Basic: Pointer>) {
//    unsafe { TODO: call ffi:gegl_scratch_free() }
//}

#[doc(alias = "gegl_serialize")]
pub fn serialize(
    start: &Node,
    end: &Node,
    basepath: &str,
    serialize_flags: SerializeFlag,
) -> Option<glib::GString> {
    unsafe {
        from_glib_full(ffi::gegl_serialize(
            start.to_glib_none().0,
            end.to_glib_none().0,
            basepath.to_glib_none().0,
            serialize_flags.into_glib(),
        ))
    }
}

#[doc(alias = "gegl_stats")]
pub fn stats() -> Option<Stats> {
    unsafe { from_glib_none(ffi::gegl_stats()) }
}

//#[doc(alias = "gegl_try_malloc")]
//pub fn try_malloc(n_bytes: usize) -> /*Unimplemented*/Option<Basic: Pointer> {
//    unsafe { TODO: call ffi:gegl_try_malloc() }
//}