uu 0.1.1

A simple graphic library only works on X11
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#![feature(proc_macro_hygiene)]
mod x11;
use std::sync::Arc;

#[derive(Copy, Clone)]
pub struct Color {
    pub r: f64,
    pub g: f64,
    pub b: f64,
}

#[derive(Copy, Clone)]
pub struct Position {
    pub x: i16,
    pub y: i16,
}

pub enum Backend {
    X11,
    WAYLAND,
}

#[derive(Copy, Clone)]
pub struct Expose<WindowIdentifier> {
    pub window_id: WindowIdentifier,
    pub width: u16,
    pub height: u16,
    pub position: Position,
}

#[derive(Copy, Clone)]
pub struct KeyPress<WindowIdentifier> {
    pub window_id: WindowIdentifier,
    pub cursor_position: Position,
    pub detail: u8,
}

#[derive(Copy, Clone)]
pub struct KeyRelease {}

#[derive(Copy, Clone)]
pub struct ButtonPress<WindowIdentifier> {
    pub window_id: WindowIdentifier,
    pub cursor_position: Position,
    pub detail: u8,
}

#[derive(Copy, Clone)]
pub struct ButtonRelease {}

#[derive(Copy, Clone)]
pub struct MotionNotify {}

#[derive(Copy, Clone)]
pub struct EnterNotify {}

#[derive(Copy, Clone)]
pub struct LeaveNotify {}

#[derive(Copy, Clone)]
pub struct CloseNotify<WindowIdentifier> {
    pub window_id: WindowIdentifier,
}

#[derive(Copy, Clone)]
pub enum Event<WindowIdentifier> {
    Expose(Expose<WindowIdentifier>),
    KeyPress(KeyPress<WindowIdentifier>),
    KeyRelease(KeyRelease),
    ButtonPress(ButtonPress<WindowIdentifier>),
    ButtonRelease(ButtonRelease),
    MotionNotify(MotionNotify),
    EnterNotify(EnterNotify),
    LeaveNotify(LeaveNotify),
    CloseNotify(CloseNotify<WindowIdentifier>),
}

pub fn init() {
    env_logger::init();
}

pub fn create_application(backend: Backend) -> impl Application {
    match backend {
        Backend::X11 => {
            return x11::X11Application::new();
        }
        _ => panic!("Unsupported Backend"),
    }
}

pub trait Application {
    type Window: Window;
    type WindowIdentifier;
    fn new() -> Self;
    fn create_window(&self, width: u16, height: u16) -> Self::WindowIdentifier;
    fn main_loop(&self);
    fn get_window(&self, id: Self::WindowIdentifier) -> Arc<Box<Self::Window>>;
    fn windows_len(&self) -> usize;
    fn quit(&self) {
        self.set_should_quit(true);
    }
    fn set_should_quit(&self, should_quit: bool);
    fn flush(&self) -> bool;
    fn add_event_listener(&self, handler: Box<Fn(&Self, Event<Self::WindowIdentifier>) -> ()>);
    fn trigger_event(&self, event: Event<Self::WindowIdentifier>);
    fn destroy_window(&self, window_id: Self::WindowIdentifier);
}

pub trait Window {
    fn polygon(&self, points: &[Position], color: Color);
    fn resize(&self, width: u16, height: u16);
    fn draw_text(
        &self,
        position: Position,
        color: Color,
        font_size: i32,
        font_family: &str,
        content: &str,
    );
    fn flush(&self);
}