libccanvas 0.2.0

Utility for creating ccanvas components.
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
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Improved serde structs.

use serde::{Deserialize, Serialize};

use crate::bindings::{KeyCode, KeyEvent, KeyModifier};

/// A keyboard event
#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, Hash)]
pub struct KeyEventBetterSerde {
    /// The keycode represented by the key pressed.
    #[serde(flatten)]
    pub code: KeyCodeBetterSerde,
    /// Key modifiers (e.g. ctrl).
    ///
    /// Note that key modifiers are modifiers. They cannot exist on their own.
    pub modifier: KeyModifier,
}

/// A single key code
#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, Hash)]
#[serde(tag = "type")]
pub enum KeyCodeBetterSerde {
    /// Backspace.
    #[serde(rename = "backspace")]
    Backspace,
    /// Left arrow.
    #[serde(rename = "left")]
    Left,
    /// Right arrow.
    #[serde(rename = "right")]
    Right,
    /// Up arrow.
    #[serde(rename = "up")]
    Up,
    /// Down arrow.
    #[serde(rename = "down")]
    Down,
    /// Home key.
    #[serde(rename = "home")]
    Home,
    /// End key.
    #[serde(rename = "end")]
    End,
    /// Page Up key.
    #[serde(rename = "pageup")]
    PageUp,
    /// Page Down key.
    #[serde(rename = "pagedown")]
    PageDown,
    /// Backward Tab key.
    #[serde(rename = "backtab")]
    BackTab,
    /// Delete key.
    #[serde(rename = "delete")]
    Delete,
    /// Insert key.
    #[serde(rename = "insert")]
    Insert,
    /// Function keys.
    ///
    /// Only function keys 1 through 12 are supported.
    #[serde(rename = "f")]
    F { value: u8 },
    /// Normal character.
    #[serde(rename = "char")]
    Char { value: char },
    /// Null byte.
    #[serde(rename = "null")]
    Null,
    /// Esc key.
    #[serde(rename = "esc")]
    Esc,
}

impl From<KeyEventBetterSerde> for KeyEvent {
    fn from(value: KeyEventBetterSerde) -> Self {
        Self {
            code: value.code.into(),
            modifier: value.modifier,
        }
    }
}

impl From<KeyCodeBetterSerde> for KeyCode {
    fn from(value: KeyCodeBetterSerde) -> Self {
        match value {
            KeyCodeBetterSerde::Backspace => Self::Backspace,
            KeyCodeBetterSerde::Left => Self::Left,
            KeyCodeBetterSerde::Right => Self::Right,
            KeyCodeBetterSerde::Up => Self::Up,
            KeyCodeBetterSerde::Down => Self::Down,
            KeyCodeBetterSerde::Home => Self::Home,
            KeyCodeBetterSerde::End => Self::End,
            KeyCodeBetterSerde::PageUp => Self::PageUp,
            KeyCodeBetterSerde::PageDown => Self::PageDown,
            KeyCodeBetterSerde::BackTab => Self::BackTab,
            KeyCodeBetterSerde::Delete => Self::Delete,
            KeyCodeBetterSerde::Insert => Self::Insert,
            KeyCodeBetterSerde::F { value } => Self::F(value),
            KeyCodeBetterSerde::Char { value } => Self::Char(value),
            KeyCodeBetterSerde::Null => Self::Null,
            KeyCodeBetterSerde::Esc => Self::Esc,
        }
    }
}

impl From<KeyEvent> for KeyEventBetterSerde {
    fn from(value: KeyEvent) -> Self {
        Self {
            code: value.code.into(),
            modifier: value.modifier,
        }
    }
}

impl From<KeyCode> for KeyCodeBetterSerde {
    fn from(value: KeyCode) -> Self {
        match value {
            KeyCode::Backspace => Self::Backspace,
            KeyCode::Left => Self::Left,
            KeyCode::Right => Self::Right,
            KeyCode::Up => Self::Up,
            KeyCode::Down => Self::Down,
            KeyCode::Home => Self::Home,
            KeyCode::End => Self::End,
            KeyCode::PageUp => Self::PageUp,
            KeyCode::PageDown => Self::PageDown,
            KeyCode::BackTab => Self::BackTab,
            KeyCode::Delete => Self::Delete,
            KeyCode::Insert => Self::Insert,
            KeyCode::F(value) => Self::F { value },
            KeyCode::Char(value) => Self::Char { value },
            KeyCode::Null => Self::Null,
            KeyCode::Esc => Self::Esc,
        }
    }
}