dcpu 0.5.0

An assembler, debugger and emulator for the DCPU-16
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

use std::any::Any;
use std::collections::VecDeque;
use std::fmt;
use std::sync::{Arc, Mutex, mpsc};

use emulator::device::{Result, ErrorKind, keyboard};

#[cfg_attr(feature = "serde_derive", derive(Serialize, Deserialize))]
#[derive(Debug, Copy, Clone)]
pub enum KeyboardEvent {
    KeyPressed(keyboard::Key),
    KeyReleased(keyboard::Key),
}

pub struct KeyboardBackend {
    // used for Drop
    #[allow(dead_code)]
    common: Arc<Mutex<Any + Send>>,
    receiver: mpsc::Receiver<KeyboardEvent>,
    key_pressed: [bool; 0x92],
}

impl KeyboardBackend {
    pub fn new(common: Arc<Mutex<Any + Send>>,
               receiver: mpsc::Receiver<KeyboardEvent>)
        -> KeyboardBackend {
        KeyboardBackend {
            common: common,
            receiver: receiver,
            key_pressed: [false; 0x92],
        }
    }
}

impl fmt::Debug for KeyboardBackend {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Generic keyboard backend using mpsc")
    }
}

impl keyboard::Backend for KeyboardBackend {
    fn is_key_pressed(&mut self, key: keyboard::Key) -> Result<bool> {
        Ok(self.key_pressed[key.encode() as usize])
    }

    fn push_typed_keys(&mut self,
                       queue: &mut VecDeque<keyboard::Key>) -> Result<bool> {
        let mut new_keys = false;
        loop {
            match self.receiver.try_recv() {
                Ok(KeyboardEvent::KeyPressed(k)) => {
                    new_keys = true;
                    self.key_pressed[k.encode() as usize] = true;
                    queue.push_back(k);
                    if queue.len() > 8 {
                        queue.pop_front();
                    }
                }
                Ok(KeyboardEvent::KeyReleased(k)) => {
                    new_keys = true;
                    self.key_pressed[k.encode() as usize] = false;
                }
                Err(mpsc::TryRecvError::Empty) => return Ok(new_keys),
                Err(mpsc::TryRecvError::Disconnected) =>
                    try!(Err(ErrorKind::BackendStopped("keyboard".into()))),
            }
        }
    }
}