daxvena/elemeld - Change LKAUS67VU5SLG5O5MTSO6N4VVT5OB2X4VNR6HYLIJ3ZOAXRQ4Q2QC

Send and receive events over the network interface

Created by daxvena on February 11, 2016

LKAUS67VU5SLG5O5MTSO6N4VVT5OB2X4VNR6HYLIJ3ZOAXRQ4Q2QC

Dependencies

In channels

main

Change contents

Insertion in Cargo.toml at line 8 [3.18912]
[3.19031]
[3.19031]
```
serde = "*"
serde_json = "*"
serde_macros = "*"
```

Insertion in src/event.rs at line 5 [4.11]

[4.153]


#[derive(Serialize, Deserialize, Debug)]
pub enum Server {
    CursorMotion(CursorMotion),
    CursorClick(CursorClick),
    Keyboard(Keyboard),
}
#[derive(Serialize, Deserialize, Debug)]
pub struct CursorMotion {
    pub x: i32,
    pub y: i32,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct CursorClick {
    pub button: CursorButton,
    pub state: bool,
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone, Copy)]
pub enum CursorButton { Left, Right, Middle }

Insertion in src/event.rs at line 28 [4.11]

[4.154]

#[derive(Serialize, Deserialize, Debug)]
pub struct Keyboard {
    pub key: Key,
    pub state: bool,
}

Replacement in src/event.rs at line 35 [4.11]

B:BD[4.174] → [4.174:204]

#[derive(Debug, Clone, Copy)]

[4.174]

[4.204]

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone, Copy)]

Insertion in src/main.rs at line 2 [3.10002]

[4.670]

[3.10058]

#![feature(custom_derive, plugin)]
#![plugin(serde_macros)]

Insertion in src/main.rs at line 6 [3.10002]
[3.10077]
[3.10077]
```
extern crate serde;
extern crate serde_json;
```
Deletion in src/main.rs at line 16 [3.10002]
B:BD[3.10164] → [4.692:708]
```
use event::Key;
```
Deletion in src/main.rs at line 17 [3.10002]
B:BD[3.10176] → [4.709:710]

Replacement in src/main.rs at line 22 [3.10002]

B:BD[3.10270] → [3.10270:10340]

const X11_TOKEN: Token = Token(0);
const NET_TOKEN: Token = Token(1);

[3.10270]

[3.10340]

use std::cell::Cell;
const X11_EVENT: Token = Token(0);
const NET_EVENT: Token = Token(1);

Insertion in src/main.rs at line 49 [3.10002]

[5.49]

[3.10835]


    // Debug
    bytes: Cell<usize>,
    packets: Cell<usize>,

Replacement in src/main.rs at line 79 [3.10002]

B:BD[3.11509] → [3.11509:11548]

                            X11_TOKEN,

[3.11509]

[3.11548]

                            X11_EVENT,

Insertion in src/main.rs at line 85 [3.10002]

[3.11800]

[2.283]

        udp_socket.set_multicast_loop(false).unwrap();

Replacement in src/main.rs at line 93 [3.10002]

B:BD[3.12076] → [3.12076:12115]

                            NET_TOKEN,

[3.12076]

[3.12115]

                            NET_EVENT,

Insertion in src/main.rs at line 112 [3.10002]

[5.268]

[3.12562]


            bytes: Cell::new(0),
            packets: Cell::new(0),

Replacement in src/main.rs at line 129 [3.10002]

B:BD[3.12901] → [6.26:94]

        self.send_to_all(&format!("cursor {} {}", self.x, self.y));

[3.12901]


        self.send_to_all(&[event::Server::CursorMotion(event::CursorMotion {
            x: self.x,
            y: self.y,
        })]);

Deletion in src/main.rs at line 171 [3.10002]
B:BD[4.1092] → [4.1092:1150]
```
        self.display.next_event(); // consume mouse event
```
Deletion in src/main.rs at line 177 [3.10002]
B:BD[4.1211] → [4.1211:1269]
```
        self.display.next_event(); // consume mouse event
```

Replacement in src/main.rs at line 180 [3.10002]

B:BD[6.127] → [6.127:262]

    fn send_to(&self, buf: &str, addr: &SocketAddr) -> Option<usize> {
        self.udp_socket.send_to(buf.as_bytes(), &addr).unwrap()

[6.127]

[6.262]

    fn send_to(&self, events: &[event::Server], addr: &SocketAddr) -> Option<usize> {
        let msg = serde_json::to_string(&events).unwrap();
        // Debug
        self.bytes.set(self.bytes.get() + msg.len() + 28);
        self.packets.set(self.packets.get() + 1);
        println!("message: {}", msg);
        println!("bytes: {} | packets: {}", self.bytes.get(), self.packets.get());
        self.udp_socket.send_to(msg.as_bytes(), &addr).unwrap()

Replacement in src/main.rs at line 192 [3.10002]

B:BD[6.269] → [6.269:325]

    fn send_to_all(&self, buf: &str) -> Option<usize> {

[6.269]

[2.425]

    fn send_to_all(&self, events: &[event::Server]) -> Option<usize> {

Replacement in src/main.rs at line 194 [3.10002]
∅:D[2.525] → [6.419:462]
B:BD[6.419] → [6.419:462]
```
        self.send_to(buf, &multicast_addr)
```
[2.525]
[6.462]
```
        self.send_to(events, &multicast_addr)
```

Replacement in src/main.rs at line 197 [3.10002]

B:BD[6.469] → [6.469:527]

    fn recv_from(&self) -> Option<(String, SocketAddr)> {

[6.469]

[6.527]

    fn recv_from(&self) -> Option<(Vec<event::Server>, SocketAddr)> {

Replacement in src/main.rs at line 200 [3.10002]

B:BD[6.620] → [6.620:735]

            Some((len, addr)) =>
                Some((String::from(str::from_utf8(&buf[..len]).unwrap()), addr)),

[6.620]

[6.735]

            Some((len, addr)) => {
                let buf = &buf[..len];
                Some((match serde_json::from_slice(buf) {
                    Ok(event) => event,
                    Err(e) => {
                        println!("{:?}: {}", e, String::from_utf8_lossy(buf));
                        return None;
                    },
                }, addr))
            },

Replacement in src/main.rs at line 222 [3.10002]
B:BD[3.14819] → [3.14819:14846]
```
            X11_TOKEN => {
```
[3.14819]
[3.14982]
```
            X11_EVENT => {
```

Replacement in src/main.rs at line 224 [3.10002]

B:BD[3.15032] → [7.629:683]

∅:D[7.683] → [3.15080:15167]

B:BD[3.15080] → [3.15080:15167]

B:BD[3.15167] → [7.684:734]

B:BD[7.734] → [8.249:338]

                    Some(Event::MotionNotify(e)) => {
                        self.update_cursor(e.x_root, e.y_root);
                    },
                    Some(Event::KeyPress(e)) => {
                        let keysym = self.display.keycode_to_keysym(e.keycode as u8, 0);

[3.15032]

[4.1270]

                    Some(Event::MotionNotify(event)) =>
                        self.update_cursor(event.x_root, event.y_root),
                    Some(Event::KeyPress(event)) => {
                        let keysym = self.display.keycode_to_keysym(event.keycode as u8, 0);

Replacement in src/main.rs at line 229 [3.10002]

B:BD[4.1316] → [4.1316:1384]

                            XK_Escape => { if e.state == AltLMask {

[4.1316]

[4.1384]

                            XK_Escape => { if event.state == AltLMask {

Replacement in src/main.rs at line 233 [3.10002]

B:BD[6.812] → [6.812:895]

                                self.send_to_all(&format!("key_down {}", keysym));

[6.812]

[6.895]

                                let keysym = self.display.keycode_to_keysym(event.keycode as u8, 0);
                                self.send_to_all(&[event::Server::Keyboard(event::Keyboard {
                                    key: match keysym {
                                        _ => event::Key::Space,
                                    },
                                    state: true,
                                })]);

Replacement in src/main.rs at line 243 [3.10002]

B:BD[3.15234] → [8.418:559]

B:BD[8.559] → [6.927:1000]

                    Some(Event::KeyRelease(e)) => {
                        let keysym = self.display.keycode_to_keysym(e.keycode as u8, 0);
                        self.send_to_all(&format!("key_up {}", keysym));

[3.15234]

[8.638]

                    Some(Event::KeyRelease(event)) => {
                        let keysym = self.display.keycode_to_keysym(event.keycode as u8, 0);
                        self.send_to_all(&[event::Server::Keyboard(event::Keyboard {
                            key: match keysym {
                                _ => event::Key::Space,
                            },
                            state: false,
                        })]);

Replacement in src/main.rs at line 252 [3.10002]

∅:D[8.718] → [7.735:788]

B:BD[3.15234] → [7.735:788]

B:BD[7.788] → [6.1001:1079]

                    Some(Event::ButtonPress(e)) => {
                        self.send_to_all(&format!("button_up {}", e.button));

[8.661]

[3.15465]

                    Some(Event::ButtonPress(event)) => {
                        self.send_to_all(&[event::Server::CursorClick(event::CursorClick {
                            button: match event.button {
                                _ => event::CursorButton::Left,
                            },
                            state: true,
                        })]);

Replacement in src/main.rs at line 260 [3.10002]

B:BD[3.15488] → [7.872:927]

B:BD[7.927] → [6.1080:1158]

                    Some(Event::ButtonRelease(e)) => {
                        self.send_to_all(&format!("button_up {}", e.button));

[3.15488]

[3.15723]

                    Some(Event::ButtonRelease(event)) => {
                        self.send_to_all(&[event::Server::CursorClick(event::CursorClick {
                            button: match event.button {
                                _ => event::CursorButton::Left,
                            },
                            state: false,
                        })]);

Replacement in src/main.rs at line 268 [3.10002]

B:BD[3.15746] → [4.1588:1672]

                    Some(Event::GenericEvent(e)) => { if e.evtype == XI_RawMotion {

[3.15746]

[4.1672]

                    Some(Event::GenericEvent(event)) => { if event.evtype == XI_RawMotion {

Replacement in src/main.rs at line 275 [3.10002]
B:BD[3.16023] → [3.16023:16050]
```
            NET_TOKEN => {
```
[3.16023]
[6.1189]
```
            NET_EVENT => {
```

Replacement in src/main.rs at line 277 [3.10002]

B:BD[6.1230] → [6.1230:1292]

                    Some((msg, addr)) => println!("{}", msg),

[6.1230]

[3.16313]

                    Some((events, addr)) => for event in events { match event {
                        event::Server::CursorMotion(event) =>
                            self.display.move_cursor(event.x, event.y),
                        event::Server::CursorClick(event) =>
                            self.display.set_button(event.button, event.state),
                        event::Server::Keyboard(event) =>
                            self.display.set_key(event.key, event.state),
                    } },

Replacement in src/x11.rs at line 1 [3.308]
B:BD[3.308] → [4.1820:1836]
```
use event::Key;
```
[3.308]
[4.1836]
```
use event::{Key, CursorButton};
```
Replacement in src/x11.rs at line 86 [3.308]
B:BD[8.927] → [8.927:948]
```
    // Mouse buttons
```
[8.927]
[8.948]
```
    // Cursor buttons
```

Replacement in src/x11.rs at line 329 [3.308]

B:BD[4.3295] → [4.3295:3460]

    pub fn move_cursor(&mut self, x: i32, y: i32) {
        unsafe { (self.xlib.XWarpPointer)(
            self.display, 0, self.root, 0, 0, 0, 0, x, y
        ) };

[4.3295]

[4.3460]

    unsafe fn consume_event(&self) {
        let mut event = mem::uninitialized();
        (self.xlib.XNextEvent)(self.display, &mut event);
    }
    pub fn move_cursor(&self, x: i32, y: i32) {
        unsafe {
            (self.xlib.XWarpPointer)(self.display, 0, self.root, 0, 0, 0, 0, x, y);
            self.consume_event();
        };

Replacement in src/x11.rs at line 341 [3.308]

B:BD[4.3467] → [4.3467:3525]

    pub fn set_key(&mut self, key: Key, is_press: bool) {

[4.3467]

[4.3525]

    pub fn set_button(&self, button: CursorButton, state: bool) {
        println!("Fake click");
        let button = match button {
            CursorButton::Left => Button1,
            CursorButton::Middle => Button3, // guessing
            CursorButton::Right => Button2, // guessing
        };

Replacement in src/x11.rs at line 350 [3.308]

B:BD[4.3542] → [4.3542:5788]

            let keysym = match key {
                Key::ControlL => XK_Control_L,
                Key::ControlR => XK_Control_R,
                Key::AltL => XK_Alt_L,
                Key::AltR => XK_Alt_R,
                Key::ShiftL => XK_Shift_L,
                Key::ShiftR => XK_Shift_R,
                Key::SuperL => XK_Super_L,
                Key::SuperR => XK_Super_L,
                Key::CapsLock => XK_Caps_Lock,
                Key::Space => XK_space,
                Key::Enter => XK_Return,
                Key::Tab => XK_Tab,
                Key::Backspace => XK_BackSpace,
                Key::Delete => XK_Delete,
                Key::Num0 => XK_0,
                Key::Num1 => XK_1,
                Key::Num2 => XK_2,
                Key::Num3 => XK_3,
                Key::Num4 => XK_4,
                Key::Num5 => XK_5,
                Key::Num6 => XK_6,
                Key::Num7 => XK_7,
                Key::Num8 => XK_8,
                Key::Num9 => XK_9,
                Key::A => XK_A,
                Key::B => XK_B,
                Key::C => XK_C,
                Key::D => XK_D,
                Key::E => XK_E,
                Key::F => XK_F,
                Key::G => XK_G,
                Key::H => XK_H,
                Key::I => XK_I,
                Key::J => XK_J,
                Key::K => XK_K,
                Key::L => XK_L,
                Key::M => XK_M,
                Key::N => XK_N,
                Key::O => XK_O,
                Key::P => XK_P,
                Key::Q => XK_Q,
                Key::R => XK_R,
                Key::S => XK_S,
                Key::T => XK_T,
                Key::U => XK_U,
                Key::V => XK_V,
                Key::W => XK_W,
                Key::Y => XK_Y,
                Key::X => XK_X,
                Key::Z => XK_Z,
                Key::F1 => XK_F1,
                Key::F2 => XK_F2,
                Key::F3 => XK_F3,
                Key::F4 => XK_F4,
                Key::F5 => XK_F5,
                Key::F6 => XK_F6,
                Key::F7 => XK_F7,
                Key::F8 => XK_F8,
                Key::F9 => XK_F9,
                Key::F10 => XK_F10,
                Key::F11 => XK_F11,
                Key::F12 => XK_F12,
            };

[4.3542]

[4.5788]

            (self.xtest.XTestFakeButtonEvent)(self.display, button, state as i32, xlib::CurrentTime);
            self.consume_event();
        };
    }
    pub fn set_key(&self, key: Key, state: bool) {
        let keysym = match key {
            Key::ControlL => XK_Control_L,
            Key::ControlR => XK_Control_R,
            Key::AltL => XK_Alt_L,
            Key::AltR => XK_Alt_R,
            Key::ShiftL => XK_Shift_L,
            Key::ShiftR => XK_Shift_R,
            Key::SuperL => XK_Super_L,
            Key::SuperR => XK_Super_L,
            Key::CapsLock => XK_Caps_Lock,
            Key::Space => XK_space,
            Key::Enter => XK_Return,
            Key::Tab => XK_Tab,
            Key::Backspace => XK_BackSpace,
            Key::Delete => XK_Delete,
            Key::Num0 => XK_0,
            Key::Num1 => XK_1,
            Key::Num2 => XK_2,
            Key::Num3 => XK_3,
            Key::Num4 => XK_4,
            Key::Num5 => XK_5,
            Key::Num6 => XK_6,
            Key::Num7 => XK_7,
            Key::Num8 => XK_8,
            Key::Num9 => XK_9,
            Key::A => XK_A,
            Key::B => XK_B,
            Key::C => XK_C,
            Key::D => XK_D,
            Key::E => XK_E,
            Key::F => XK_F,
            Key::G => XK_G,
            Key::H => XK_H,
            Key::I => XK_I,
            Key::J => XK_J,
            Key::K => XK_K,
            Key::L => XK_L,
            Key::M => XK_M,
            Key::N => XK_N,
            Key::O => XK_O,
            Key::P => XK_P,
            Key::Q => XK_Q,
            Key::R => XK_R,
            Key::S => XK_S,
            Key::T => XK_T,
            Key::U => XK_U,
            Key::V => XK_V,
            Key::W => XK_W,
            Key::Y => XK_Y,
            Key::X => XK_X,
            Key::Z => XK_Z,
            Key::F1 => XK_F1,
            Key::F2 => XK_F2,
            Key::F3 => XK_F3,
            Key::F4 => XK_F4,
            Key::F5 => XK_F5,
            Key::F6 => XK_F6,
            Key::F7 => XK_F7,
            Key::F8 => XK_F8,
            Key::F9 => XK_F9,
            Key::F10 => XK_F10,
            Key::F11 => XK_F11,
            Key::F12 => XK_F12,
        };

Insertion in src/x11.rs at line 421 [3.308]
[4.5789]
[4.5789]
```
        unsafe {
```

Replacement in src/x11.rs at line 423 [3.308]

B:BD[4.5874] → [4.5874:5968]

            (self.xtest.XTestFakeKeyEvent)(self.display, keycode as u32, is_press as i32, 0);

[4.5874]

[4.5968]

            (self.xtest.XTestFakeKeyEvent)(self.display, keycode as u32, state as i32, 0);
            self.consume_event();