papyri 0.1.0

Data visualization based on Cairo
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

/*Copyright (c) 2022 Diego da Silva Lima. All rights reserved.

This work is licensed under the terms of the MIT license.  
For a copy, see <https://opensource.org/licenses/MIT>.*/

// Perhaps rename to spec?
pub mod model;

#[cfg(feature="gdk4")]
#[cfg(feature="gdk-pixbuf")]
#[cfg(feature="cairo-rs")]
pub mod render;

#[cfg(feature="gdk4")]
#[cfg(feature="gdk-pixbuf")]
#[cfg(feature="cairo-rs")]
pub mod ffi {

    // use std::os::raw::c_char;

    const INVALID_UTF8 : i64 = 1;

    const INSUFFICIENT_LEN : i64 = 2;

    const INVALID_DEFINITION : i64 = 3;

    #[no_mangle]
    pub extern "C" fn papyri_error(code : i64, out : *mut u8, out_len : &mut usize) -> i64 {
        let out = unsafe { std::slice::from_raw_parts_mut(out, *out_len) };
        let msg = match code {
            INVALID_UTF8 => "Invalid UTF-8",
            INSUFFICIENT_LEN => "Insufficient length",
            _ => "Unknown error"
        };
        if let Some(s) = out.get_mut(..msg.len()) {
            s.copy_from_slice(msg.as_bytes());
            *out_len = s.len();
            0
        } else {
            -1
        }
    }

    #[no_mangle]
    pub extern "C" fn papyri_svg(model : *const u8, model_len : usize, out : *mut u8, out_len : &mut usize) -> i64 {
        let model = unsafe { std::slice::from_raw_parts(model, model_len) };
        match std::str::from_utf8(model) {
            Ok(s) => {
                match crate::render::Panel::new_from_json(s) {
                    Ok(mut pl) => {
                        match pl.svg() {
                            Ok(svg) => {
                                let out = unsafe { std::slice::from_raw_parts_mut(out, *out_len) };
                                match out.get_mut(..svg.len()) {
                                    Some(s) => {
                                        s.copy_from_slice(svg.as_bytes());
                                        *out_len = s.len();
                                        0
                                    },
                                    None => {
                                        INSUFFICIENT_LEN
                                    }
                                }
                            },
                            Err(_) => {
                                INVALID_DEFINITION
                            }
                        }
                    },
                    Err(_) => {
                        INVALID_DEFINITION
                    }
                }
            },
            Err(_) => {
                INVALID_UTF8
            }
        }
    }

}