daxvena/elemeld - Change LSQ7OPL7Z5WJDO7ZZS3D4UPMEEWUUF2LNQ3FZUWWFUVZEXA7CIOAC

Refactored server into multiple modules

Created by daxvena on February 26, 2016

LSQ7OPL7Z5WJDO7ZZS3D4UPMEEWUUF2LNQ3FZUWWFUVZEXA7CIOAC

Dependencies

In channels

main

Change contents

File addition: cluster.rs (-rw-r--r--)

[4.6]

use io;
use elemeld::Elemeld;
use serde;
use std::net;
pub type Index = u8;
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct Cluster {
    screens: Vec<Screen>,
    focus: Index,
    pos: Dimensions,
}
impl Cluster {
    pub fn new(width: i32, height: i32, x: i32, y: i32) -> Self {
        Cluster {
            screens: vec![Screen::new(width, height)],
            focus: 0,
            pos: Dimensions { x: x , y: y },
        }
    }
    
    pub fn filter_host_event<H>(&mut self, host: &H) -> Option<io::NetEvent>
        where H: io::HostInterface
    {
        match host.recv_event() {
            Some(io::HostEvent::Motion(event)) => {
                if event.dx != 0 || event.dy != 0 {
                    let (focus, x, y) = (self.focus, self.pos.x + event.dx, self.pos.y + event.dy);
                    self.refocus(host, focus, x, y);
                    Some(io::NetEvent::Focus(self.focus, io::PositionEvent {
                        x: self.pos.x, y: self.pos.y,
                    }))
                } else {
                    None
                }
            },
            Some(event) => {
                if !self.locally_focused() {
                    match event {
                        io::HostEvent::Button(event) => Some(io::NetEvent::Button(event)),
                        io::HostEvent::Key(event) => Some(io::NetEvent::Key(event)),
                        _ => None,
                    }
                } else {
                    None
                }
            }
            None => None,
        }
    }
    pub fn filter_net_event(&mut self, event: io::NetEvent) -> Option<io::HostEvent> {
        if self.locally_focused() {
            match event {
                io::NetEvent::Button(event) => Some(io::HostEvent::Button(event)),
                io::NetEvent::Key(event) => Some(io::HostEvent::Key(event)),
                _ => None,
            }
        } else {
            return None
        }
    }
    fn locally_focused(&self) -> bool {
        self.screens[self.focus as usize].is_local()
    }
    
    pub fn refocus<H>(&mut self, host: &H, focus: Index, x: i32, y: i32) where
        H: io::HostInterface
    {
        let (focus, x, y) = self.normalize_focus(focus, x, y);
        let was_focused = self.locally_focused();
        
        self.focus = focus;
        self.pos.x = x;
        self.pos.y = y;
        
        if self.locally_focused() {
            if !was_focused {
                host.send_event(io::HostEvent::Position(io::PositionEvent {
                    x: self.pos.x, y: self.pos.y,
                }));
                host.ungrab_cursor();
                host.ungrab_keyboard();
            }
        } else {
            if was_focused {
                host.grab_cursor();
                host.grab_keyboard();
            }
        }
    }
    /*
     * Walk through the screens untill the x and y are contained within a screen
     */
    fn normalize_focus(&self, focus: Index, x: i32, y: i32) -> (Index, i32, i32) {
        let (focus, x) = self.normalize_x(focus, x);
        let (focus, y) = self.normalize_y(focus, y);
        (focus, x, y)
    }
    fn normalize_x(&self, focus: Index, x: i32) -> (Index, i32) {
        let screen = self.screens[focus as usize];
        if self.pos.x < 20 {
            match screen.edges.left {
                Some(focus) => return self.normalize_x(focus, x + screen.size.x - 40),
                None => (),
            }
        } else if self.pos.x >= screen.size.x - 20 {
            match screen.edges.right {
                Some(focus) => return self.normalize_x(focus, x - screen.size.x + 40),
                None => (),
            }
        }
        (focus, x)
    }
    fn normalize_y(&self, focus: Index, y: i32) -> (Index, i32) {
        let screen = self.screens[focus as usize];
        if self.pos.y < 20 {
            match screen.edges.left {
                Some(focus) => return self.normalize_y(focus, y + screen.size.y - 40),
                None => (),
            }
        } else if self.pos.y >= screen.size.y - 20 {
            match screen.edges.right {
                Some(focus) => return self.normalize_y(focus, y - screen.size.y + 40),
                None => (),
            }
        }
        (focus, y)
    }
    /**
     * Add a new screen to the far right of the cluster
     */
    fn add(&mut self, mut new_screen: Screen) {
        let new_index = self.screens.len() as Index;
        let mut index = 0 as Index;
        
        loop {
            let screen = &mut self.screens[index as usize];
            index = match screen.edges.right {
                Some(index) => index,
                None => {
                    screen.edges.right = Some(new_index);
                    new_screen.edges.left = Some(index);
                    break;
                }
            }
        }
        
        self.screens.push(new_screen);
    }
    /**
     * Attempt to merge two clusters together
     */
    pub fn merge(&mut self, other: &Self, src: net::SocketAddr) {
        'outer: for other_screen in &other.screens {
            // Interpret other's None addresses as the src address
            let other_addr = match other_screen.addr {
                Some(addr) => addr.0,
                None => src,
            };
            for screen in &mut self.screens {
                // Interpret self's None addresses as a null address
                // TODO: Use getifaddrs to lookup matching interface address
                let screen_addr = match screen.addr {
                    Some(addr) => addr.0,
                    None => net::SocketAddr::V4(net::SocketAddrV4::new(net::Ipv4Addr::new(0, 0, 0, 0), 0)),
                };
                // If same address, replace screen with other_screen
                if screen_addr == other_addr {
                    // TODO: Merge screen properties
                    // *screen = *other_screen;
                    continue 'outer;
                }
            }
            // If new address, add new screen 
            let mut new_screen = *other_screen;
            new_screen.addr = Some(SocketAddr(src));
            self.add(new_screen);
        }
    }
    /**
     * Replace an existing cluster with a new cluster
     */
    pub fn replace(&mut self, other: &Self) {
        *self = other.clone();
    }
}
#[derive(Copy, Clone, Serialize, Deserialize, Debug)]
struct Screen {
    size: Dimensions,
    edges: Edges,
    addr: Option<SocketAddr>,
}
impl Screen {
    pub fn new(width: i32, height: i32) -> Self {
        Screen {
            addr: None, // None implies local machine
            size: Dimensions { x: width, y: height },
            edges: Edges {
                top: None,
                right: None,
                bottom: None,
                left: None
            }
        }
    }
    pub fn is_local(&self) -> bool {
        self.addr.is_none()
    }
}
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
struct SocketAddr(net::SocketAddr);
impl serde::Serialize for SocketAddr {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: serde::Serializer
    {
        serializer.visit_str(&format!("{}", self.0))
    }
}
impl serde::Deserialize for SocketAddr {
    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
        where D: serde::Deserializer
    {
        struct SocketAddrVisitor;
        impl serde::de::Visitor for SocketAddrVisitor {
            type Value = SocketAddr;
            fn visit_str<E>(&mut self, val: &str) -> Result<Self::Value, E>
                where E: serde::de::Error,
            {
                match val.parse::<net::SocketAddr>() {
                    Ok(addr) => Ok(SocketAddr(addr)),
                    Err(_) => Err(serde::de::Error::syntax("expected socket address")),
                }
            }
        }
        deserializer.visit(SocketAddrVisitor)
    }
}
#[derive(Copy, Clone, Serialize, Deserialize, Debug)]
struct Dimensions {
    x: i32,
    y: i32,
}
#[derive(Copy, Clone, Serialize, Deserialize, Debug)]
struct Edges {
    top: Option<Index>,
    right: Option<Index>,
    bottom: Option<Index>,
    left: Option<Index>,
}

File addition: elemeld.rs (-rw-r--r--)

[4.6]

use io;
use cluster::Cluster;
pub struct Elemeld<H, N> where
    H: io::HostInterface,
    N: io::NetInterface,
{
    host: H,
    net: N,
    state: State,
    cluster: Cluster,
}
#[derive(Debug, Copy, Clone)]
enum State {
    Connecting,
    Ready,
    Connected,
}
impl<H, N> Elemeld<H, N> where
    H: io::HostInterface,
    N: io::NetInterface,
{
    pub fn new(host: H, net: N) -> Self {
        let (width, height) = host.screen_size();
        let (x, y) = host.cursor_pos();
        Elemeld {
            host: host,
            net: net,
            state: State::Connecting,
            cluster: Cluster::new(width, height, x, y),
        }
    }
    pub fn host_event(&mut self) {
        match self.state {
            State::Connected => match self.cluster.filter_host_event(&self.host) {
                Some(event) => { self.net.send_to_all(&[event]); },
                None => (),
            },
            _ => (),
        }
    }
    pub fn net_event(&mut self) {
        match self.net.recv_from() {
            Some((events, addr)) => for event in events {
                match event {
                    // Initialization events
                    io::NetEvent::Connect(cluster) => {
                        self.cluster.merge(&cluster, addr);
                        self.net.send_to_all(&[io::NetEvent::Cluster(self.cluster.clone())]);
                        self.state = State::Connected;
                    },
                    io::NetEvent::Cluster(cluster) => {
                        self.cluster.replace(&cluster);
                        self.state = State::Connected;
                    },
                    // Global events
                    io::NetEvent::Focus(focus, pos) => {
                        self.cluster.refocus(&self.host, focus, pos.x, pos.y);
                        self.host.send_event(io::HostEvent::Position(io::PositionEvent {
                            x: pos.x,
                            y: pos.y,
                        }));
                    },
                    // event => match self.cluster.filter_net_event(event) {
                    //     Some(event) => { self.host.send_event(event); },
                    //     None => (),
                    // },
                    _ => (),
                }
            },
            None => (),
        }
        match self.state {
            State::Connecting => {
                self.net.send_to_all(&[io::NetEvent::Connect(self.cluster.clone())]);
                self.state = State::Ready;
            },
            _ => ()
        }
    }
}

Insertion in src/io.rs at line 1 [5.11]
[5.11]
[6.8]
```
use cluster;
use std::net::SocketAddr;
```

Replacement in src/io.rs at line 11 [5.11]

B:BD[6.231] → [6.231:314]

    fn recv_event(&self) -> Option<Event>;
    fn send_event(&self, event: Event);

[6.231]

[7.417]

    fn recv_event(&self) -> Option<HostEvent>;
    fn send_event(&self, event: HostEvent);

Deletion in src/io.rs at line 14 [5.11]

B:BD[7.419] → [7.419:489]

B:BD[7.489] → [6.315:355]

∅:D[6.355] → [5.153:154]

∅:D[7.535] → [5.153:154]

B:BD[5.153] → [5.153:154]

∅:D[7.641] → [5.154:174]

B:BD[5.154] → [5.154:174]

B:BD[5.174] → [7.642:711]

∅:D[7.711] → [5.204:313]

B:BD[5.204] → [5.204:313]


#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone, Copy)]
pub enum Button { Left, Right, Middle }
#[allow(dead_code)]
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone, Copy)]
pub enum Key {
    ControlL, ControlR,
    AltL, AltR,
    ShiftL, ShiftR,
    SuperL, SuperR,
    CapsLock,

Replacement in src/io.rs at line 15 [5.11]

B:BD[5.314] → [5.314:588]

    Space, Enter, Tab,
    Backspace, Delete,
    Num0, Num1, Num2, Num3, Num4,
    Num5, Num6, Num7, Num8, Num9,
    A, B, C, D, E, F, G, H,
    I, J, K, L, M, N, O, P,
    Q, R, S, T, U, V, W, X,
    Y, Z,
    F1, F2, F3, F4,
    F5, F6, F7, F8,
    F9, F10, F11, F12,

[5.314]

[6.356]

pub trait NetInterface {
    fn send_to(&self, events: &[NetEvent], addr: &SocketAddr) -> Option<usize>;
    fn send_to_all(&self, events: &[NetEvent]) -> Option<usize>;
    fn recv_from(&self) -> Option<(Vec<NetEvent>, SocketAddr)>;

Replacement in src/io.rs at line 22 [5.11]
B:BD[6.400] → [6.400:417]
```
pub enum Event {
```
[6.400]
[6.417]
```
pub enum HostEvent {
```

Insertion in src/io.rs at line 30 [5.11]

[6.558]

pub enum NetEvent {
    Connect(cluster::Cluster),
    Cluster(cluster::Cluster),
    Focus(cluster::Index, PositionEvent),
    Button(ButtonEvent),
    Key(KeyEvent),
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Copy, Clone)]
pub enum Button { Left, Right, Middle }
#[derive(Serialize, Deserialize, Debug)]

File addition: ip.rs (-rw-r--r--)

[4.6]

use io::{self, NetInterface};
use mio;
use serde_json;
use std::str;
use std::net::{SocketAddr, SocketAddrV4, Ipv4Addr};
use std::cell::Cell;
pub struct IpInterface {
    config: Config,
    socket: mio::udp::UdpSocket,
    out_packets: Cell<usize>,
    in_packets: Cell<usize>,
}
pub struct Config {
    pub server_addr: Ipv4Addr,
    pub multicast_addr: Ipv4Addr,
    pub port: u16
}
impl IpInterface {
    pub fn open(config: Config) -> Self {
        let socket = mio::udp::UdpSocket::v4().unwrap();
        socket.set_multicast_loop(false).unwrap();
        socket.join_multicast(&mio::IpAddr::V4(config.multicast_addr)).unwrap();
        socket.bind(&SocketAddr::V4(
            SocketAddrV4::new(config.server_addr, config.port)
        )).unwrap();
        IpInterface {
            config: config,
            socket: socket,
            out_packets: Cell::new(0),
            in_packets: Cell::new(0),
        }
    }
}
impl NetInterface for IpInterface {
    fn send_to(&self, events: &[io::NetEvent], addr: &SocketAddr) -> Option<usize> {
        let id = self.out_packets.get();
        let msg = serde_json::to_string(&(id, events)).unwrap();
        println!("=> {}", msg);
        match self.socket.send_to(msg.as_bytes(), &addr).unwrap() {
            Some(size) => {
                self.out_packets.set(id + 1);
                Some(size)
            },
            None => {
                println!("Failed to send: {}", msg);
                None
            },
        }
    }
    fn send_to_all(&self, events: &[io::NetEvent]) -> Option<usize> {
        let multicast_addr = SocketAddr::V4(SocketAddrV4::new(self.config.multicast_addr, self.config.port));
        self.send_to(events, &multicast_addr)
    }
    fn recv_from(&self) -> Option<(Vec<io::NetEvent>, SocketAddr)> {
        let mut buf = [0; 1024];
        match self.socket.recv_from(&mut buf).unwrap() {
            Some((len, addr)) => {
                let msg = str::from_utf8(&buf[..len]).unwrap();
                println!("<= {}", msg);
                
                let (id, events): (usize, Vec<io::NetEvent>) = serde_json::from_str(msg).unwrap();
                let expected_id = self.in_packets.get();
                if id < expected_id {
                    println!("^ out of sync packet");
                } else {
                    if id > expected_id {
                        println!("^ lost {} packets", id - expected_id)
                    }
                    self.in_packets.set(id + 1);
                }
                Some((events, addr))
            },
            None => None,
        }
    }
}
/*
 * FIXME(Future):
 * Method delegation: https://github.com/rust-lang/rfcs/pull/1406
 */
impl mio::Evented for IpInterface {
    fn register(&self, selector: &mut mio::Selector, token: mio::Token, interest: mio::EventSet, opts: mio::PollOpt) -> ::std::io::Result<()> {
        self.socket.register(selector, token, interest, opts)
    }
    fn reregister(&self, selector: &mut mio::Selector, token: mio::Token, interest: mio::EventSet, opts: mio::PollOpt) -> ::std::io::Result<()> {
        self.socket.reregister(selector, token, interest, opts)
    }
    fn deregister(&self, selector: &mut mio::Selector) -> ::std::io::Result<()> {
        self.socket.deregister(selector)
    }
}

Insertion in src/main.rs at line 11 [4.10002]
[4.10119]
[6.998]
```
mod elemeld;
mod cluster;
```
Insertion in src/main.rs at line 15 [4.10002]
[5.691]
[4.10119]
```
mod ip;
// Hacky work around for Xfixes
```
Replacement in src/main.rs at line 21 [4.10002]
B:BD[4.10164] → [6.1007:1030]
∅:D[5.708] → [4.10164:10176]
∅:D[6.1030] → [4.10164:10176]
B:BD[4.10164] → [4.10164:10176]
```
use io::HostInterface;
use x11::*;
```
[4.10164]
[4.10176]
```
use elemeld::Elemeld;
use x11::X11Interface;
use ip::{IpInterface, Config};
```
Deletion in src/main.rs at line 26 [4.10002]
B:BD[4.10188] → [4.10188:10270]
B:BD[4.10270] → [7.819:840]
```
use mio::udp::UdpSocket;
use std::net::{SocketAddr, SocketAddrV4};
use std::str;
use std::cell::Cell;
```
Replacement in src/main.rs at line 27 [4.10002]
B:BD[7.841] → [7.841:876]
```
const X11_EVENT: Token = Token(0);
```
[7.841]
[7.876]
```
const HOST_EVENT: Token = Token(0);
```

Replacement in src/main.rs at line 32 [4.10002]

B:BD[4.10469] → [8.0:106]

    let mut server = Server::new(&mut event_loop, Config {
        addr: Ipv4Addr::new(239, 255, 80, 80),

[4.10469]

[8.106]

    let mut manager = EventManager::new(&mut event_loop, Config {
        server_addr: Ipv4Addr::new(0, 0, 0, 0),
        multicast_addr: Ipv4Addr::new(239, 255, 80, 80),

Deletion in src/main.rs at line 37 [4.10002]
∅:D[8.134] → [4.10528:10572]
B:BD[4.10528] → [4.10528:10572]
```
    event_loop.run(&mut server).unwrap();
}
```
Replacement in src/main.rs at line 38 [4.10002]
B:BD[4.10573] → [4.10573:10589]
B:BD[4.10589] → [8.135:155]
B:BD[8.155] → [6.1031:1070]
∅:D[6.1070] → [4.10752:10753]
B:BD[4.10752] → [4.10752:10753]
B:BD[4.10753] → [6.1071:1085]
∅:D[6.1085] → [9.0:19]
B:BD[4.10766] → [9.0:19]
∅:D[9.19] → [4.10766:10786]
B:BD[4.10766] → [4.10766:10786]
B:BD[4.10816] → [9.20:49]
B:BD[9.49] → [7.912:926]
B:BD[7.926] → [3.0:59]
```
struct Server {
    config: Config,
    host: X11Host,
    net: UdpSocket,
    // Screen
    focused: bool,
    x: i32, y: i32,
    width: i32, height: i32,
    // Debug
    out_packets: Cell<usize>,
    in_packets: Cell<usize>,
```
[4.10573]
[4.10835]
```
    event_loop.run(&mut manager).unwrap();
```

Replacement in src/main.rs at line 41 [4.10002]

B:BD[4.10838] → [8.156:207]

struct Config {
    addr: Ipv4Addr,
    port: u16,

[4.10838]

[8.207]

struct EventManager {
    elemeld: Elemeld<X11Interface, IpInterface>,

Replacement in src/main.rs at line 45 [4.10002]
∅:D[8.210] → [4.10838:10852]
B:BD[4.10838] → [4.10838:10852]
```
impl Server {
```
[8.210]
[8.211]
```
impl EventManager {
```

Replacement in src/main.rs at line 47 [4.10002]

B:BD[8.282] → [6.1086:1148]

        // Setup X11 host
        let host = X11Host::open();

[8.282]

[6.1148]

        // Setup host interface
        let host = X11Interface::open();

Replacement in src/main.rs at line 50 [4.10002]

∅:D[6.1183] → [7.977:1016]

B:BD[4.11509] → [7.977:1016]

                            X11_EVENT,

[6.1183]

[4.11548]

                            HOST_EVENT,

Replacement in src/main.rs at line 54 [4.10002]

B:BD[4.11721] → [4.11721:11749]

B:BD[4.11749] → [6.1184:1373]

∅:D[6.1373] → [8.354:424]

B:BD[4.11908] → [8.354:424]

∅:D[8.424] → [4.11975:12035]

B:BD[4.11975] → [4.11975:12035]

        // Setup UDP socket
        let net = UdpSocket::v4().unwrap();
        net.set_multicast_loop(false).unwrap();
        net.join_multicast(&IpAddr::V4(config.addr)).unwrap();
        net.bind(&SocketAddr::V4(
            SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), config.port)
        )).unwrap();
        // Listen for UDP connections

[4.11721]

[6.1374]

        // Setup net interface
        let net = IpInterface::open(config);

Replacement in src/main.rs at line 58 [4.10002]

∅:D[7.1112] → [4.12115:12165]

B:BD[4.12115] → [4.12115:12165]

                            EventSet::readable(),

[7.1112]

[6.1409]

                            EventSet::readable() | EventSet::writable(),

Deletion in src/main.rs at line 60 [4.10002]

∅:D[6.1465] → [4.12220:12221]

B:BD[4.12220] → [4.12220:12221]

B:BD[4.12221] → [6.1466:1602]

∅:D[10.148] → [4.12327:12373]

∅:D[5.892] → [4.12327:12373]

∅:D[6.1602] → [4.12327:12373]

∅:D[9.197] → [4.12327:12373]

B:BD[4.12327] → [4.12327:12373]

B:BD[4.12373] → [6.1603:1649]

∅:D[6.1649] → [4.12373:12374]

B:BD[4.12373] → [4.12373:12374]

B:BD[4.12477] → [9.198:225]

∅:D[9.225] → [4.12477:12501]

B:BD[4.12477] → [4.12477:12501]

B:BD[4.12535] → [9.226:268]

B:BD[9.268] → [7.1113:1114]

B:BD[7.1114] → [3.60:137]

∅:D[3.137] → [4.12562:12579]

∅:D[9.268] → [4.12562:12579]

∅:D[7.1182] → [4.12562:12579]

B:BD[4.12562] → [4.12562:12579]

B:BD[4.12579] → [6.1650:1672]

∅:D[6.1672] → [4.13230:13284]

B:BD[4.13230] → [4.13230:13284]

B:BD[4.13284] → [6.1673:1749]

∅:D[10.420] → [4.13620:13664]

∅:D[6.1749] → [4.13620:13664]

∅:D[11.160] → [4.13620:13664]

B:BD[4.13620] → [4.13620:13664]

B:BD[4.13695] → [4.13695:13755]

B:BD[4.13755] → [6.1750:1963]

∅:D[10.504] → [4.13918:13961]

∅:D[6.1963] → [4.13918:13961]

B:BD[4.13918] → [4.13918:13961]

∅:D[5.1150] → [4.14318:14325]

B:BD[4.14318] → [4.14318:14325]

B:BD[4.14325] → [6.1964:2067]

B:BD[6.2067] → [3.138:244]

∅:D[3.244] → [7.1467:1485]

B:BD[7.1467] → [7.1467:1485]

B:BD[7.1485] → [3.245:335]

∅:D[3.335] → [7.1715:1716]

B:BD[7.1715] → [7.1715:1716]

B:BD[7.1716] → [6.2068:2125]

∅:D[6.2125] → [12.262:269]

∅:D[7.1780] → [12.262:269]

B:BD[12.262] → [12.262:269]

B:BD[12.269] → [6.2126:2193]

∅:D[6.2193] → [8.425:525]

∅:D[7.1852] → [8.425:525]

B:BD[12.325] → [8.425:525]

B:BD[8.525] → [7.1853:1899]

∅:D[7.1899] → [12.462:469]

B:BD[12.462] → [12.462:469]

B:BD[12.469] → [6.2194:2260]

∅:D[6.2260] → [12.527:559]

∅:D[7.1970] → [12.527:559]

B:BD[12.527] → [12.527:559]

B:BD[12.559] → [6.2261:2315]

∅:D[6.2315] → [7.1971:2006]

B:BD[12.620] → [7.1971:2006]

B:BD[7.2006] → [3.336:496]


        // Query information for local screen
        let (x, y) = host.cursor_pos();
        let (width, height) = host.screen_size();
        Server {
            config: config,
            host: host,
            net: net,
            focused: true,
            x: x, y: y,
            width: width, height: height,
            out_packets: Cell::new(0),
            in_packets: Cell::new(0),
        }
    }
    // Host functions
    fn unfocus(&mut self) {
        if self.focused {
            self.host.grab_cursor();
            self.host.grab_keyboard();
            self.focused = false;
        }
    }
    fn focus(&mut self) {
        if !self.focused {
            self.host.send_position_event(io::PositionEvent {
                x: self.x,
                y: self.y,
            });
            self.host.ungrab_cursor();
            self.host.ungrab_keyboard();
            self.focused = true;
        }
    }
    // Net functions
    fn send_to(&self, events: &[io::Event], addr: &SocketAddr) -> Option<usize> {
        let id = self.out_packets.get();
        let msg = serde_json::to_string(&(id, events)).unwrap();
        // Debug
        println!("=> {}", msg);
        self.out_packets.set(self.out_packets.get() + 1);
        self.net.send_to(msg.as_bytes(), &addr).unwrap()
    }
    fn send_to_all(&self, events: &[io::Event]) -> Option<usize> {
        let multicast_addr = SocketAddr::V4(SocketAddrV4::new(self.config.addr, self.config.port));
        self.send_to(events, &multicast_addr)
    }
    fn recv_from(&self) -> Option<(Vec<io::Event>, SocketAddr)> {
        let mut buf = [0; 256];
        match self.net.recv_from(&mut buf).unwrap() {
            Some((len, addr)) => {
                let msg = str::from_utf8(&buf[..len]).unwrap();
                let (id, events): (usize, Vec<io::Event>) = serde_json::from_str(msg).unwrap();

Replacement in src/main.rs at line 61 [4.10002]

B:BD[3.497] → [3.497:980]

∅:D[3.980] → [6.2573:2591]

B:BD[7.2314] → [6.2573:2591]

∅:D[6.2591] → [7.2340:2355]

B:BD[7.2340] → [7.2340:2355]

∅:D[7.2355] → [12.735:771]

B:BD[12.735] → [12.735:771]

                // Debug
                println!("<= {}", msg);
                let expected_id = self.in_packets.get();
                if id < expected_id {
                    println!("^ old packet");
                    None
                } else {
                    if id > expected_id {
                        println!("^ lost {} packets", id - expected_id)
                    }
                    self.in_packets.set(id + 1);
                    Some((events, addr))
                }
            },
            None => None,
        }

[3.497]

[4.14592]

        EventManager { elemeld: Elemeld::new(host, net) }

Replacement in src/main.rs at line 65 [4.10002]
B:BD[4.14601] → [4.14601:14627]
```
impl Handler for Server {
```
[4.14601]
[4.14627]
```
impl Handler for EventManager {
```
Deletion in src/main.rs at line 69 [4.10002]
B:BD[4.14674] → [4.14674:14705]
```
    #[allow(unused_variables)]
```

Replacement in src/main.rs at line 71 [4.10002]

B:BD[4.14819] → [6.2592:3489]

∅:D[12.926] → [5.1561:1587]

∅:D[6.3489] → [5.1561:1587]

B:BD[5.1561] → [5.1561:1587]

B:BD[5.1587] → [6.3490:3652]

∅:D[6.3652] → [7.3585:3615]

B:BD[7.3585] → [7.3585:3615]

∅:D[12.1000] → [11.638:661]

∅:D[7.3615] → [11.638:661]

B:BD[11.638] → [11.638:661]

B:BD[11.661] → [6.3653:3753]

∅:D[12.1079] → [4.15465:15488]

∅:D[10.871] → [4.15465:15488]

∅:D[6.3753] → [4.15465:15488]

∅:D[7.3987] → [4.15465:15488]

B:BD[4.15465] → [4.15465:15488]

B:BD[4.15488] → [6.3754:3801]

∅:D[6.3801] → [4.16008:16023]

B:BD[4.16008] → [4.16008:16023]

B:BD[4.16023] → [6.3802:3914]

B:BD[6.3959] → [6.3959:4438]

∅:D[6.4438] → [4.16363:16378]

B:BD[4.16363] → [4.16363:16378]

            X11_EVENT => match self.host.recv_event() {
                Some(event) => match event {
                    io::Event::Motion(event) => {
                        self.x += event.dx;
                        self.y += event.dy;
                        if self.x <= 0 {
                            // TODO: Check left
                            self.unfocus();
                        } else if self.x >= self.width - 1 {
                            // TODO: Check right
                            self.unfocus();
                        } else if self.y <= 0 {
                            // TODO: Check top
                            self.unfocus();
                        } else if self.y >= self.height - 1 {
                            // TODO: Check bottom
                            self.unfocus();
                        } else {
                            self.focus();
                        }
                        self.send_to_all(&[io::Event::Position(io::PositionEvent {
                            x: self.x,
                            y: self.y,
                        })]);
                    },
                    event => if !self.focused {
                        self.send_to_all(&[event]);
                    },
                },
                None => (),
            },
            NET_EVENT => match self.recv_from() {
                Some((events, addr)) => for event in events {
                    match event {
                        io::Event::Position(event) => {
                            self.x = event.x;
                            self.y = event.y;
                            self.host.send_position_event(event);
                        },
                        event => if self.focused {
                            self.host.send_event(event);
                        },
                    }
                },
                None => (),
            },

[4.14819]

[4.16378]

            HOST_EVENT => self.elemeld.host_event(),
            NET_EVENT => self.elemeld.net_event(),

Replacement in src/x11.rs at line 12 [4.308]
B:BD[4.2000] → [6.4552:4601]
```
use std::{ptr, mem, str};
use std::ffi::CString;
```
[4.2000]
[6.4601]
```
use std::{ptr, mem};
```
Replacement in src/x11.rs at line 15 [4.308]
B:BD[10.2695] → [6.4623:4644]
```
pub struct X11Host {
```
[10.2695]
[4.2021]
```
pub struct X11Interface {
```
Replacement in src/x11.rs at line 26 [4.308]
B:BD[4.2138] → [6.4710:4725]
```
impl X11Host {
```
[4.2138]
[4.2153]
```
impl X11Interface {
```
Replacement in src/x11.rs at line 42 [4.308]
B:BD[10.2787] → [6.4828:4857]
```
        let host = X11Host {
```
[10.2787]
[4.2514]
```
        let host = X11Interface {
```

Replacement in src/x11.rs at line 91 [4.308]

B:BD[4.3118] → [6.5963:6054]

    fn recv_generic_event(&self, cookie: xlib::XGenericEventCookie) -> Option<io::Event> {

[4.3118]

[6.6054]

    fn recv_generic_event(&self, cookie: xlib::XGenericEventCookie) -> Option<io::HostEvent> {

Replacement in src/x11.rs at line 107 [4.308]

B:BD[11.1621] → [6.6625:6693]

        Some(io::Event::Motion(io::MotionEvent { dx: dx, dy: dy }))

[11.1621]

[11.1793]

        Some(io::HostEvent::Motion(io::MotionEvent { dx: dx, dy: dy }))

Replacement in src/x11.rs at line 110 [4.308]

B:BD[11.1800] → [6.6694:6789]

    fn recv_button_event(&self, event: xlib::XButtonEvent, state: bool) -> Option<io::Event> {

[11.1800]

[6.6789]

    fn recv_button_event(&self, event: xlib::XButtonEvent, state: bool) -> Option<io::HostEvent> {

Replacement in src/x11.rs at line 121 [4.308]

B:BD[4.3737] → [6.7108:7157]

        Some(io::Event::Button(io::ButtonEvent {

[4.3737]

[6.7157]

        Some(io::HostEvent::Button(io::ButtonEvent {

Replacement in src/x11.rs at line 127 [4.308]

B:BD[4.6446] → [6.7224:7313]

    fn recv_key_event(&self, event: xlib::XKeyEvent, state: bool) -> Option<io::Event> {

[4.6446]

[6.7313]

    fn recv_key_event(&self, event: xlib::XKeyEvent, state: bool) -> Option<io::HostEvent> {

Replacement in src/x11.rs at line 129 [4.308]

B:BD[4.7449] → [6.9936:9979]

        Some(io::Event::Key(io::KeyEvent {

[6.7413]

[2.19]

        Some(io::HostEvent::Key(io::KeyEvent {

Replacement in src/x11.rs at line 135 [4.308]

B:BD[11.1808] → [6.10040:10106]

    pub fn send_position_event(&self, event: io::PositionEvent) {

[11.1808]

[6.10106]

    fn send_position_event(&self, event: io::PositionEvent) {

Replacement in src/x11.rs at line 143 [4.308]

B:BD[11.1932] → [6.10328:10390]

    pub fn send_motion_event(&self, event: io::MotionEvent) {

[11.1932]

[6.10390]

    fn send_motion_event(&self, event: io::MotionEvent) {

Replacement in src/x11.rs at line 152 [4.308]

B:BD[4.7570] → [6.10682:10744]

    pub fn send_button_event(&self, event: io::ButtonEvent) {

[4.7570]

[6.10744]

    fn send_button_event(&self, event: io::ButtonEvent) {

Replacement in src/x11.rs at line 165 [4.308]

B:BD[4.8295] → [6.11125:11181]

    pub fn send_key_event(&self, event: io::KeyEvent) {

[4.8295]

[6.13426]

    fn send_key_event(&self, event: io::KeyEvent) {

Replacement in src/x11.rs at line 174 [4.308]
B:BD[5.2634] → [6.13675:13708]
```
impl HostInterface for X11Host {
```
[5.2634]
[6.13708]
```
impl HostInterface for X11Interface {
```

Insertion in src/x11.rs at line 178 [4.308]

[6.13845]

            assert!(screen.width > 0 && screen.height > 0);

Replacement in src/x11.rs at line 243 [4.308]

B:BD[6.15058] → [6.15058:15106]

    fn recv_event(&self) -> Option<io::Event> {

[6.15058]

[6.15106]

    fn recv_event(&self) -> Option<io::HostEvent> {

Replacement in src/x11.rs at line 264 [4.308]

B:BD[6.15893] → [6.15893:15938]

    fn send_event(&self, event: io::Event) {

[6.15893]

[6.15938]

    fn send_event(&self, event: io::HostEvent) {

Replacement in src/x11.rs at line 266 [4.308]

B:BD[6.15960] → [6.15960:16242]

            io::Event::Position(event) => self.send_position_event(event),
            io::Event::Motion(event) => self.send_motion_event(event),
            io::Event::Button(event) => self.send_button_event(event),
            io::Event::Key(event) => self.send_key_event(event),

[6.15960]

[5.5968]

            io::HostEvent::Position(event) => self.send_position_event(event),
            io::HostEvent::Motion(event) => self.send_motion_event(event),
            io::HostEvent::Button(event) => self.send_button_event(event),
            io::HostEvent::Key(event) => self.send_key_event(event),

Replacement in src/x11.rs at line 278 [4.308]
B:BD[6.16335] → [6.16335:16367]
```
impl mio::Evented for X11Host {
```
[6.16335]
[6.16367]
```
impl mio::Evented for X11Interface {
```
Replacement in src/x11.rs at line 292 [4.308]
B:BD[6.16968] → [6.16968:16992]
```
impl Drop for X11Host {
```
[6.16968]
[4.8439]
```
impl Drop for X11Interface {
```

Refactored server into multiple modules

Dependencies

In channels

Change contents

File addition: cluster.rs (-rw-r--r--)

File addition: elemeld.rs (-rw-r--r--)

Insertion in src/io.rs at line 1 [5.11]

Replacement in src/io.rs at line 11 [5.11]

Deletion in src/io.rs at line 14 [5.11]

Replacement in src/io.rs at line 15 [5.11]

Replacement in src/io.rs at line 22 [5.11]

Insertion in src/io.rs at line 30 [5.11]

File addition: ip.rs (-rw-r--r--)

Insertion in src/main.rs at line 11 [4.10002]

Insertion in src/main.rs at line 15 [4.10002]

Replacement in src/main.rs at line 21 [4.10002]

Deletion in src/main.rs at line 26 [4.10002]

Replacement in src/main.rs at line 27 [4.10002]

Replacement in src/main.rs at line 32 [4.10002]

Deletion in src/main.rs at line 37 [4.10002]

Replacement in src/main.rs at line 38 [4.10002]

Replacement in src/main.rs at line 41 [4.10002]

Replacement in src/main.rs at line 45 [4.10002]

Replacement in src/main.rs at line 47 [4.10002]

Replacement in src/main.rs at line 50 [4.10002]

Replacement in src/main.rs at line 54 [4.10002]

Replacement in src/main.rs at line 58 [4.10002]

Deletion in src/main.rs at line 60 [4.10002]

Replacement in src/main.rs at line 61 [4.10002]

Replacement in src/main.rs at line 65 [4.10002]

Deletion in src/main.rs at line 69 [4.10002]

Replacement in src/main.rs at line 71 [4.10002]

Replacement in src/x11.rs at line 12 [4.308]

Replacement in src/x11.rs at line 15 [4.308]

Replacement in src/x11.rs at line 26 [4.308]

Replacement in src/x11.rs at line 42 [4.308]

Replacement in src/x11.rs at line 91 [4.308]

Replacement in src/x11.rs at line 107 [4.308]

Replacement in src/x11.rs at line 110 [4.308]

Replacement in src/x11.rs at line 121 [4.308]

Replacement in src/x11.rs at line 127 [4.308]

Replacement in src/x11.rs at line 129 [4.308]

Replacement in src/x11.rs at line 135 [4.308]

Replacement in src/x11.rs at line 143 [4.308]

Replacement in src/x11.rs at line 152 [4.308]

Replacement in src/x11.rs at line 165 [4.308]

Replacement in src/x11.rs at line 174 [4.308]

Insertion in src/x11.rs at line 178 [4.308]

Replacement in src/x11.rs at line 243 [4.308]

Replacement in src/x11.rs at line 264 [4.308]

Replacement in src/x11.rs at line 266 [4.308]

Replacement in src/x11.rs at line 278 [4.308]

Replacement in src/x11.rs at line 292 [4.308]