rust-qt-binding-generator/demo/rust/src/interface.rs

/* generated by rust_qt_binding_generator */
#![allow(unknown_lints)]
#![allow(mutex_atomic, needless_pass_by_value)]
use libc::{c_int, c_void, uint8_t, uint16_t};
use std::slice;

use std::sync::{Arc, Mutex};
use std::ptr::null;

use implementation::*;


#[repr(C)]
pub struct COption<T> {
    data: T,
    some: bool,
}

impl<T> From<Option<T>> for COption<T>
where
    T: Default,
{
    fn from(t: Option<T>) -> COption<T> {
        if let Some(v) = t {
            COption {
                data: v,
                some: true,
            }
        } else {
            COption {
                data: T::default(),
                some: false,
            }
        }
    }
}


#[repr(C)]
pub struct QString {
    data: *const uint8_t,
    len: c_int,
}

#[repr(C)]
pub struct QStringIn {
    data: *const uint16_t,
    len: c_int,
}

impl QStringIn {
    fn convert(&self) -> String {
        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
        String::from_utf16_lossy(data)
    }
}

impl<'a> From<&'a str> for QString {
    fn from(string: &'a str) -> QString {
        QString {
            len: string.len() as c_int,
            data: string.as_ptr(),
        }
    }
}

impl<'a> From<&'a String> for QString {
    fn from(string: &'a String) -> QString {
        QString {
            len: string.len() as c_int,
            data: string.as_ptr(),
        }
    }
}


#[repr(C)]
pub struct QByteArray {
    data: *const uint8_t,
    len: c_int,
}

impl QByteArray {
    fn convert(&self) -> Vec<u8> {
        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
        Vec::from(data)
    }
}

impl<'a> From<&'a [u8]> for QByteArray {
    fn from(value: &'a [u8]) -> QByteArray {
        QByteArray {
            len: value.len() as c_int,
            data: value.as_ptr(),
        }
    }
}


#[repr(C)]
pub enum SortOrder {
    Ascending = 0,
    Descending = 1,
}

#[repr(C)]
pub struct QModelIndex {
    row: c_int,
    internal_id: usize,
}

pub struct TreeQObject {}

#[derive(Clone)]
pub struct TreeEmitter {
    qobject: Arc<Mutex<*const TreeQObject>>,
    path_changed: fn(*const TreeQObject),
    new_data_ready: fn(*const TreeQObject, item: usize, valid: bool),
}

unsafe impl Send for TreeEmitter {}

impl TreeEmitter {
    fn clear(&self) {
        *self.qobject.lock().unwrap() = null();
    }
    pub fn path_changed(&self) {
        let ptr = *self.qobject.lock().unwrap();
        if !ptr.is_null() {
            (self.path_changed)(ptr);
        }
    }
    pub fn new_data_ready(&self, item: Option<usize>) {
        let ptr = *self.qobject.lock().unwrap();
        if !ptr.is_null() {
            (self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some());
        }
    }
}

pub struct TreeUniformTree {
    qobject: *const TreeQObject,
    data_changed: fn(*const TreeQObject, usize, usize),
    begin_reset_model: fn(*const TreeQObject),
    end_reset_model: fn(*const TreeQObject),
    begin_insert_rows: fn(*const TreeQObject, item: usize, valid: bool, usize, usize),
    end_insert_rows: fn(*const TreeQObject),
    begin_remove_rows: fn(*const TreeQObject, item: usize, valid: bool, usize, usize),
    end_remove_rows: fn(*const TreeQObject),
}

impl TreeUniformTree {
    pub fn data_changed(&self, first: usize, last: usize) {
        (self.data_changed)(self.qobject, first, last);
    }
    pub fn begin_reset_model(&self) {
        (self.begin_reset_model)(self.qobject);
    }
    pub fn end_reset_model(&self) {
        (self.end_reset_model)(self.qobject);
    }
    pub fn begin_insert_rows(&self, item: Option<usize>, first: usize, last: usize) {
        (self.begin_insert_rows)(self.qobject, item.unwrap_or(13), item.is_some(), first, last);
    }
    pub fn end_insert_rows(&self) {
        (self.end_insert_rows)(self.qobject);
    }
    pub fn begin_remove_rows(&self, item: Option<usize>, first: usize, last: usize) {
        (self.begin_remove_rows)(self.qobject, item.unwrap_or(13), item.is_some(), first, last);
    }
    pub fn end_remove_rows(&self) {
        (self.end_remove_rows)(self.qobject);
    }
}

pub trait TreeTrait {
    fn create(emit: TreeEmitter, model: TreeUniformTree) -> Self;
    fn emit(&self) -> &TreeEmitter;
    fn get_path(&self) -> Option<&str>;
    fn set_path(&mut self, value: Option<String>);
    fn row_count(&self, Option<usize>) -> usize;
    fn can_fetch_more(&self, Option<usize>) -> bool {
        false
    }
    fn fetch_more(&mut self, Option<usize>) {}
    fn sort(&mut self, u8, SortOrder) {}
    fn index(&self, item: Option<usize>, row: usize) -> usize;
    fn parent(&self, item: usize) -> Option<usize>;
    fn row(&self, item: usize) -> usize;
    fn file_icon(&self, item: usize) -> &[u8];
    fn file_name(&self, item: usize) -> String;
    fn file_path(&self, item: usize) -> Option<String>;
    fn file_permissions(&self, item: usize) -> i32;
    fn file_size(&self, item: usize) -> Option<u64>;
    fn file_type(&self, item: usize) -> i32;
}

#[no_mangle]
pub extern "C" fn tree_new(
    tree: *mut TreeQObject,
    path_changed: fn(*const TreeQObject),
    new_data_ready: fn(*const TreeQObject, item: usize, valid: bool),
    data_changed: fn(*const TreeQObject, usize, usize),
    begin_reset_model: fn(*const TreeQObject),
    end_reset_model: fn(*const TreeQObject),
    begin_insert_rows: fn(*const TreeQObject, item: usize, valid: bool, usize, usize),
    end_insert_rows: fn(*const TreeQObject),
    begin_remove_rows: fn(*const TreeQObject, item: usize, valid: bool, usize, usize),
    end_remove_rows: fn(*const TreeQObject),
) -> *mut Tree {
    let tree_emit = TreeEmitter {
        qobject: Arc::new(Mutex::new(tree)),
        path_changed: path_changed,
        new_data_ready: new_data_ready,
    };
    let model = TreeUniformTree {
        qobject: tree,
        data_changed: data_changed,
        begin_reset_model: begin_reset_model,
        end_reset_model: end_reset_model,
        begin_insert_rows: begin_insert_rows,
        end_insert_rows: end_insert_rows,
        begin_remove_rows: begin_remove_rows,
        end_remove_rows: end_remove_rows,
    };
    let d_tree = Tree::create(tree_emit, model);
    Box::into_raw(Box::new(d_tree))
}

#[no_mangle]
pub unsafe extern "C" fn tree_free(ptr: *mut Tree) {
    Box::from_raw(ptr).emit().clear();
}

#[no_mangle]
pub unsafe extern "C" fn tree_path_get(
    ptr: *const Tree,
    p: *mut c_void,
    set: fn(*mut c_void, QString),
) {
    let data = (&*ptr).get_path();
    if let Some(data) = data {
        set(p, data.into());
    }
}

#[no_mangle]
pub unsafe extern "C" fn tree_path_set(ptr: *mut Tree, v: QStringIn) {
    (&mut *ptr).set_path(Some(v.convert()));
}
#[no_mangle]
pub unsafe extern "C" fn tree_path_set_none(ptr: *mut Tree) {
    (&mut *ptr).set_path(None);
}

#[no_mangle]
pub unsafe extern "C" fn tree_row_count(
    ptr: *const Tree,
    item: usize,
    valid: bool,
) -> c_int {
    if valid {
        (&*ptr).row_count(Some(item)) as c_int
    } else {
        (&*ptr).row_count(None) as c_int
    }
}
#[no_mangle]
pub unsafe extern "C" fn tree_can_fetch_more(
    ptr: *const Tree,
    item: usize,
    valid: bool,
) -> bool {
    if valid {
        (&*ptr).can_fetch_more(Some(item))
    } else {
        (&*ptr).can_fetch_more(None)
    }
}
#[no_mangle]
pub unsafe extern "C" fn tree_fetch_more(ptr: *mut Tree, item: usize, valid: bool) {
    if valid {
        (&mut *ptr).fetch_more(Some(item))
    } else {
        (&mut *ptr).fetch_more(None)
    }
}
#[no_mangle]
pub unsafe extern "C" fn tree_sort(
    ptr: *mut Tree,
    column: u8,
    order: SortOrder
) {
    (&mut *ptr).sort(column, order)
}
#[no_mangle]
pub unsafe extern "C" fn tree_index(
    ptr: *const Tree,
    item: usize,
    valid: bool,
    row: c_int,
) -> usize {
    if !valid {
        (&*ptr).index(None, row as usize)
    } else {
        (&*ptr).index(Some(item), row as usize)
    }
}
#[no_mangle]
pub unsafe extern "C" fn tree_parent(ptr: *const Tree, index: usize) -> QModelIndex {
    if let Some(parent) = (&*ptr).parent(index) {
        QModelIndex {
            row: (&*ptr).row(parent) as c_int,
            internal_id: parent,
        }
    } else {
        QModelIndex {
            row: -1,
            internal_id: 0,
        }
    }
}
#[no_mangle]
pub unsafe extern "C" fn tree_row(ptr: *const Tree, item: usize) -> c_int {
    (&*ptr).row(item) as c_int
}

#[no_mangle]
pub unsafe extern "C" fn tree_data_file_icon(
    ptr: *const Tree, item: usize,
    d: *mut c_void,
    set: fn(*mut c_void, QByteArray),
) {
    let data = (&*ptr).file_icon(item);
    set(d, (data).into());
}

#[no_mangle]
pub unsafe extern "C" fn tree_data_file_name(
    ptr: *const Tree, item: usize,
    d: *mut c_void,
    set: fn(*mut c_void, QString),
) {
    let data = (&*ptr).file_name(item);
    set(d, (&data).into());
}

#[no_mangle]
pub unsafe extern "C" fn tree_data_file_path(
    ptr: *const Tree, item: usize,
    d: *mut c_void,
    set: fn(*mut c_void, QString),
) {
    let data = (&*ptr).file_path(item);
    if let Some(data) = data {
        set(d, QString::from(&data));
    }
}

#[no_mangle]
pub unsafe extern "C" fn tree_data_file_permissions(ptr: *const Tree, item: usize) -> i32 {
    (&*ptr).file_permissions(item).into()
}

#[no_mangle]
pub unsafe extern "C" fn tree_data_file_size(ptr: *const Tree, item: usize) -> COption<u64> {
    (&*ptr).file_size(item).into()
}

#[no_mangle]
pub unsafe extern "C" fn tree_data_file_type(ptr: *const Tree, item: usize) -> i32 {
    (&*ptr).file_type(item).into()
}