ventana-hal 0.0.4

A cross-platform, iterator-based windowing library
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

pub mod key;

use {
  keyboard_types::{
    Code,
    KeyState,
  },
  pointer_types::{
    ButtonState,
    PointerButton,
  },
  std::collections::HashMap,
};

#[derive(Debug)]
pub struct Input {
  pub pointer_buttons: HashMap<PointerButton, ButtonState>,
  pub keys: HashMap<Code, KeyState>,
  pub shift_key: KeyState,
  pub ctrl_key: KeyState,
  pub alt_key: KeyState,
  pub meta_key: KeyState,
}

impl Default for Input {
  fn default() -> Self {
    Self {
      pointer_buttons: Default::default(),
      keys: Default::default(),
      shift_key: KeyState::Up,
      ctrl_key: KeyState::Up,
      alt_key: KeyState::Up,
      meta_key: KeyState::Up,
    }
  }
}

impl Input {
  pub fn update_key(&mut self, code: Code, state: KeyState) {
    match code {
      Code::ShiftLeft | Code::ShiftRight => {
        self.shift_key = state;
      },
      Code::ControlLeft | Code::ControlRight => {
        self.ctrl_key = state;
      },
      Code::AltLeft | Code::AltRight => {
        self.alt_key = state;
      },
      Code::MetaLeft | Code::MetaRight => {
        self.meta_key = state;
      },
      _ => {
        self.keys.insert(code, state);
      },
    }
  }

  pub fn update_pointer(&mut self, button: PointerButton, state: ButtonState) {
    self.pointer_buttons.insert(button, state);
  }

  pub fn key(&self, code: Code) -> KeyState {
    *self.keys.get(&code).unwrap_or(&KeyState::Up)
  }

  pub fn pointer(&self, button: PointerButton) -> ButtonState {
    *self.pointer_buttons.get(&button).unwrap_or(&ButtonState::Up)
  }

  pub fn shift_key(&self) -> KeyState {
    self.shift_key
  }

  pub fn ctrl_key(&self) -> KeyState {
    self.ctrl_key
  }

  pub fn alt_key(&self) -> KeyState {
    self.alt_key
  }

  pub fn meta_key(&self) -> KeyState {
    self.meta_key
  }
}