lv_bevy_ecs 0.9.3

Safe Rust bindings to the LVGL graphics library using Bevy's ECS framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use ::core::{alloc::Layout, ffi::c_void};

use ::alloc::alloc::{alloc, dealloc, realloc};

use lightvgl_sys::{lv_mem_monitor_t, lv_result_t, lv_result_t_LV_RESULT_OK};

// void lv_mem_init(void);
// void * lv_malloc_core(size_t size);
// void * lv_realloc_core(void * p, size_t new_size);
// void lv_free_core(void * p);
// void lv_mem_monitor_core(lv_mem_monitor_t * mon_p);
// lv_result_t lv_mem_test_core(void);

#[cfg(not(LV_USE_STDLIB_MALLOC = "CUSTOM"))]
compile_error!("`rust-alloc` feature requires `LV_USE_STDLIB_MALLOC = CUSTOM`");

#[cfg(feature = "lvgl-alloc")]
compile_error!("`rust-alloc` feature must not be used together with `lvgl-alloc`");

#[unsafe(no_mangle)]
pub unsafe extern "C" fn lv_mem_init() {}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn lv_malloc_core(size: usize) -> *mut c_void {
    unsafe {
        const USIZE_BYTES: usize = (usize::BITS / u8::BITS) as usize;

        let new_size = size + USIZE_BYTES;
        let layout = Layout::array::<u8>(new_size).unwrap();

        let raw = alloc(layout);
        let raw_shifted = raw.add(USIZE_BYTES);
        *((raw_shifted.cast::<usize>()).sub(1)) = new_size;
        raw_shifted.cast::<c_void>()
    }
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn lv_realloc_core(ptr: *mut c_void, new_size: usize) -> *mut c_void {
    unsafe {
        const USIZE_BYTES: usize = (usize::BITS / u8::BITS) as usize;
        let ptr = ptr.cast::<u8>();

        if ptr.is_null() {
            return lv_malloc_core(new_size);
        }

        let old_size = *(ptr.cast::<usize>()).sub(1);
        let old_raw = ptr.sub(USIZE_BYTES);
        let old_layout = Layout::array::<u8>(old_size).unwrap();

        let new_size = new_size + USIZE_BYTES;

        let raw = realloc(old_raw, old_layout, new_size);
        let raw_shifted = raw.add(USIZE_BYTES);
        *((raw_shifted.cast::<usize>()).sub(1)) = new_size;
        raw_shifted.cast::<c_void>()
    }
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn lv_free_core(ptr: *mut c_void) {
    unsafe {
        const USIZE_BYTES: usize = (usize::BITS / u8::BITS) as usize;
        let ptr = ptr.cast::<u8>();

        let old_size = *(ptr.cast::<usize>()).sub(1);
        let old_raw = ptr.sub(USIZE_BYTES);
        let old_layout = Layout::array::<u8>(old_size).unwrap();

        dealloc(old_raw, old_layout);
    }
}

pub trait MemoryStats {
    fn get_memory_stats(monitor: &mut lv_mem_monitor_t);
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn lv_mem_monitor_core(monitor: *mut lv_mem_monitor_t) {
    unsafe extern "Rust" {
        fn get_memory_stats(monitor: &mut lv_mem_monitor_t);
    }

    unsafe {
        get_memory_stats(monitor.as_mut().unwrap());
    }
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn lv_mem_test_core() -> lv_result_t {
    lv_result_t_LV_RESULT_OK
}