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
138
139
140
141
142
143
144
145
146

/// A container for generic event and the common values
/// needed for the user.

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Event {
    MouseEvent(MouseEvent),
    KeyEvent(KeyEvent),
    InputEvent(InputEvent),
}

impl From<MouseEvent> for Event {
    fn from(me: MouseEvent) -> Self {
        Event::MouseEvent(me)
    }
}

impl From<InputEvent> for Event {
    fn from(ie: InputEvent) -> Self {
        Event::InputEvent(ie)
    }
}

impl From<KeyEvent> for Event {
    fn from(ke: KeyEvent) -> Self {
        Event::KeyEvent(ke)
    }
}

/// A mouse event contains the (x,y) coordinates, buttons and modifier keys
#[derive(Default, Debug, Clone, PartialEq, Eq)]
pub struct MouseEvent {
    pub r#type: &'static str,
    pub coordinate: Coordinate,
    pub modifier: Modifier,
    pub buttons: MouseButton,
}
impl MouseEvent {
    pub fn click(x: i32, y: i32) -> Self {
        MouseEvent {
            r#type: "click",
            coordinate: Coordinate::new(x, y),
            //TODO: specify the buttons
            ..Default::default()
        }
    }

    pub fn x(&self) -> i32 {
        self.coordinate.x()
    }

    pub fn y(&self) -> i32 {
        self.coordinate.y()
    }
}

#[derive(Default, Debug, Clone, PartialEq, Eq)]
pub struct KeyEvent {
    pub key: String,
    pub modifier: Modifier,
    pub repeat: bool,
    pub location: u32,
}

impl KeyEvent {
    pub fn new(key: String) -> Self {
        KeyEvent {
            key,
            ..Default::default()
        }
    }
}

#[derive(Default, Debug, Clone, PartialEq, Eq)]
pub struct InputEvent {
    pub value: String,
}

impl InputEvent {
    pub fn new(value: String) -> Self {
        InputEvent { value }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MouseButton {
    Left,
    Right,
    Middle,
    WheelUp,
    WheelDown,
}

impl Default for MouseButton {
    fn default() -> Self {
        MouseButton::Left
    }
}

#[derive(Default, Debug, Clone, PartialEq, Eq)]
pub struct Coordinate {
    pub client_x: i32,
    pub client_y: i32,
    pub movement_x: i32,
    pub movement_y: i32,
    pub offset_x: i32,
    pub offset_y: i32,
    pub screen_x: i32,
    pub screen_y: i32,
    pub x: i32,
    pub y: i32,
}

impl Coordinate {
    pub fn new(x: i32, y: i32) -> Self {
        Coordinate {
            x,
            y,
            ..Default::default()
        }
    }

    pub fn x(&self) -> i32 {
        self.x
    }

    pub fn y(&self) -> i32 {
        self.y
    }
}

#[derive(Default, Debug, Clone, PartialEq, Eq)]
pub struct Modifier {
    pub alt_key: bool,
    pub ctrl_key: bool,
    pub meta_key: bool,
    pub shift_key: bool,
}

impl Modifier {
    pub fn ctrl() -> Self {
        Modifier {
            ctrl_key: true,
            ..Default::default()
        }
    }
}