version = "0.1.39"

version = "0.1.40"

checksum = "a973ceb857cff7575b825fe4c5fae998a797bc51be8bff06922e4762ac80ab46"

checksum = "687c230d85c0a52504709705fc8a53e4a692b83a2184f03dae73e38e1e93a783"

version = "0.11.0"

version = "0.12.3"

checksum = "b41b7ea54a0c9d92199de89e20e58d49f02f8e699814ef3fdf266f6f748d15c7"

checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"

 "futures",

 "mio",

[[package]]
name = "futures"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e05b85ec287aac0dc34db7d4a569323df697f9c55b99b15d6b4ef8cde49f613"
dependencies = [
 "futures-channel",
 "futures-core",
 "futures-executor",
 "futures-io",
 "futures-sink",
 "futures-task",
 "futures-util",
]

name = "futures-channel"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f366ad74c28cca6ba456d95e6422883cfb4b252a83bed929c83abfdbbf2967d5"
dependencies = [
 "futures-core",
 "futures-sink",
]
[[package]]

[[package]]
name = "futures-executor"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "10d6bb888be1153d3abeb9006b11b02cf5e9b209fda28693c31ae1e4e012e314"
dependencies = [
 "futures-core",
 "futures-task",
 "futures-util",
]
[[package]]
name = "futures-io"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "de27142b013a8e869c14957e6d2edeef89e97c289e69d042ee3a49acd8b51789"
[[package]]
name = "futures-macro"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d0b5a30a4328ab5473878237c447333c093297bded83a4983d10f4deea240d39"
dependencies = [
 "proc-macro-hack",
 "proc-macro2",
 "quote",
 "syn",
]

name = "futures-sink"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f2032893cb734c7a05d85ce0cc8b8c4075278e93b24b66f9de99d6eb0fa8acc"
[[package]]
name = "futures-task"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bdb66b5f09e22019b1ab0830f7785bcea8e7a42148683f99214f73f8ec21a626"
dependencies = [
 "once_cell",
]
[[package]]
name = "futures-util"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8764574ff08b701a084482c3c7031349104b07ac897393010494beaa18ce32c6"
dependencies = [
 "futures-channel",
 "futures-core",
 "futures-io",
 "futures-macro",
 "futures-sink",
 "futures-task",
 "memchr",
 "pin-project",
 "pin-utils",
 "proc-macro-hack",
 "proc-macro-nested",
 "slab",
]
[[package]]

[[package]]
name = "once_cell"
version = "1.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad"

name = "pin-project"
version = "0.4.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca4433fff2ae79342e497d9f8ee990d174071408f28f726d6d83af93e58e48aa"
dependencies = [
 "pin-project-internal",
]
[[package]]
name = "pin-project-internal"
version = "0.4.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c0e815c3ee9a031fdf5af21c10aa17c573c9c6a566328d99e3936c34e36461f"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]

name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "proc-macro-hack"
version = "0.5.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598"
[[package]]
name = "proc-macro-nested"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"
[[package]]

version = "0.3.4"

version = "0.3.5"

checksum = "09b23093265f8d200fa7b4c2c76297f47e681c655f6f1285a8780d6a022f7431"

checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d"

version = "0.7.0"

version = "0.8.2"

checksum = "2bc8af4bda8e1ff4932523b94d3dd20ee30a87232323eda55903ffd71d2fb017"

checksum = "9dab61250775933275e84053ac235621dfb739556d5c54a2f2e9313b7cf43a19"

futures = "0.3"

mio = "0.6"

tokio = { version = "0.2", features = ["udp", "stream"] }

tokio = { version = "0.2", features = ["stream", "udp"] }

                    self.refocus(host, focus);

                    // self.refocus(host, focus);

    pub fn refocus<H>(&mut self, host: &H, focus: Focus) where
        H: HostInterface
    {
        let was_focused = self.locally_focused();
        self.private_refocus(host, focus, was_focused);
    }

    // pub fn refocus<H>(&mut self, host: &H, focus: Focus) where
    //     H: HostInterface
    // {
    //     let was_focused = self.locally_focused();
    //     self.private_refocus(host, focus, was_focused);
    // }

    fn private_refocus<H>(&mut self, host: &H, focus: Focus, was_focused: bool) where
        H: HostInterface
    {
        self.focus = self.normalize_focus(focus);
        if self.locally_focused() {
            if !was_focused {
                host.ungrab_cursor();
                host.ungrab_keyboard();
            }

    // fn private_refocus<H>(&mut self, host: &H, focus: Focus, was_focused: bool) where
    //     H: HostInterface
    // {
    //     self.focus = self.normalize_focus(focus);
    //     if self.locally_focused() {
    //         if !was_focused {
    //             host.ungrab_cursor();
    //             host.ungrab_keyboard();
    //         }

            host.send_event(HostEvent::Position(PositionEvent {
                x: self.focus.pos.x, y: self.focus.pos.y,
            }));
        } else {
            if was_focused {
                host.grab_cursor();
                host.grab_keyboard();
            }
        }
    }

    //         host.send_event(HostEvent::Position(PositionEvent {
    //             x: self.focus.pos.x, y: self.focus.pos.y,
    //         }));
    //     } else {
    //         if was_focused {
    //             host.grab_cursor();
    //             host.grab_keyboard();
    //         }
    //     }
    // }

        other.private_refocus(host, focus, was_focused);

        // other.private_refocus(host, focus, was_focused);

use futures::{Sink, Stream};

pub trait HostInterface {

pub trait HostInterface: Stream<Item=HostEvent> + Sink<HostEvent> {

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

#![allow(non_upper_case_globals)]

use futures::{Sink, Stream};

use x11_dl::xfixes;
use x11_dl::xinput2;
use x11_dl::xlib;
use x11_dl::xtest;

use tokio::io::PollEvented;
use x11_dl::{
    xfixes,
    xinput2,
    xlib,
    xtest,
};

use std::io;

use std::os::unix::io::RawFd;
use std::pin::Pin;

use std::task::{Context, Poll};

pub struct X11Interface {

pub struct Host {

    xinput2: xinput2::XInput2,
    xtest: xtest::Xf86vmode,
    xfixes: xfixes::XFixes,
    xfixes_event_base: i32,

    io: PollEvented<Connection>,

    xfixes: xfixes::XFixes,
    xfixes_event_base: i32,

    xtest: xtest::Xf86vmode,

impl X11Interface {

impl Host {

        let xlib = xlib::Xlib::open().unwrap();
        let xtest = xtest::Xf86vmode::open().unwrap();
        let xinput2 = xinput2::XInput2::open().unwrap();
        let xfixes = xfixes::XFixes::open().unwrap();

        unsafe {
            let xlib = xlib::Xlib::open().unwrap();
            let display = (xlib.XOpenDisplay)(ptr::null());
            if display.is_null() {
                panic!("Failed to open display");
            }
            let io = PollEvented::new(Connection {
                fd: (xlib.XConnectionNumber)(display)
            }).unwrap();
            let root = (xlib.XDefaultRootWindow)(display);

        let display = unsafe { (xlib.XOpenDisplay)(ptr::null()) };
        if display.is_null() {
            panic!("Failed to open display");
        }

            // Query X
            let xfixes = xfixes::XFixes::open().unwrap();
            let xfixes_event_base = {
                let mut event_base = MaybeUninit::uninit();
                if (xfixes.XFixesQueryExtension)(
                    display,
                    event_base.as_mut_ptr(),
                    ptr::null_mut(),
                ) == xlib::False {
                    panic!("Failed to query XFixes");
                }

        // Query XInput2
        unsafe {
            let mut major_opcode = MaybeUninit::uninit();
            let mut first_event = MaybeUninit::uninit();
            let mut first_error = MaybeUninit::uninit();
            if (xlib.XQueryExtension)(display,
                CString::new("XInputExtension").unwrap().as_ptr(),
                major_opcode.as_mut_ptr(),
                first_event.as_mut_ptr(),
                first_error.as_mut_ptr(),
            ) == xlib::False {
                panic!("Failed to query XInputExtension");

                event_base.assume_init()

        }

        // Query XFixes
        let xfixes_event_base = unsafe {
            let mut event_base = MaybeUninit::uninit();
            let mut error_base = MaybeUninit::uninit();
            if (xfixes.XFixesQueryExtension)(display,
                event_base.as_mut_ptr(),
                error_base.as_mut_ptr(),
            ) == xlib::False {
                panic!("Failed to query XFixes");
            }

            // Setup selection events
            (xfixes.XFixesSelectSelectionInput)(
                display,
                root,
                xlib::XA_PRIMARY,
                xfixes::XFixesSetSelectionOwnerNotifyMask);

            event_base.assume_init()
        };

            let clipboard = (xlib.XInternAtom)(
                display,
                CString::new("CLIPBOARD").unwrap().as_ptr(),
                0);

        let root = unsafe { (xlib.XDefaultRootWindow)(display) };
        let clipboard = unsafe { (xlib.XInternAtom)(
            display, CString::new("CLIPBOARD").unwrap().as_ptr(), 0
        ) };

            (xfixes.XFixesSelectSelectionInput)(
                display,
                root,
                clipboard,
                xfixes::XFixesSetSelectionOwnerNotifyMask);

        let host = Self {
            xlib,
            xtest,
            xinput2,
            xfixes,
            xfixes_event_base,

            // Query XInput2
            let xinput2 = xinput2::XInput2::open().unwrap();
            if (xlib.XQueryExtension)(
                display,
                CString::new("XInputExtension").unwrap().as_ptr(),
                ptr::null_mut(),
                ptr::null_mut(),
                ptr::null_mut(),
            ) == xlib::False {
                panic!("Failed to query XInputExtension");
            };

            display,
            root,
            clipboard,

            // Setup raw motion events
            let mut mask = [0u8; (xinput2::XI_LASTEVENT as usize + 7) / 8];
            xinput2::XISetMask(&mut mask, xinput2::XI_RawMotion);

            last_pos: Cell::new((0, 0)),
            cursor_grabbed: Cell::new(false),
        };

            let mut events = [xinput2::XIEventMask {
                deviceid: xinput2::XIAllMasterDevices,
                mask_len: mask.len() as i32,
                mask: &mut mask[0] as *mut u8,
            }];

        host.init();
        host
    }

            (xinput2.XISelectEvents)(
                display, root,
                &mut events[0] as *mut xinput2::XIEventMask, events.len() as i32);

    fn init(&self) {
        // Initialize last_pos for computing cursor deltas
        self.last_pos.set(self.cursor_pos());

            let xtest = xtest::Xf86vmode::open().unwrap();

        // Setup selection events
        self.select_selection_input(self.root, xlib::XA_PRIMARY, xfixes::XFixesSetSelectionOwnerNotifyMask);
        self.select_selection_input(self.root, self.clipboard, xfixes::XFixesSetSelectionOwnerNotifyMask);

            let host = Self {
                xlib,
                display,
                io,
                root,
                clipboard,

        // Setup raw motion events
        let mut mask = [0u8; (xinput2::XI_LASTEVENT as usize + 7) / 8];
        xinput2::XISetMask(&mut mask, xinput2::XI_RawMotion);

                xfixes,
                xfixes_event_base,

        let mut events = [xinput2::XIEventMask {
            deviceid: xinput2::XIAllMasterDevices,
            mask_len: mask.len() as i32,
            mask: &mut mask[0] as *mut u8,
        }];

                xtest,

        self.select_events(self.root, &mut events);
    }

                last_pos: Cell::new((0, 0)),
                cursor_grabbed: Cell::new(false),
            };

    // xlib interface
    fn connection_number(&self) -> i32 {
        unsafe { (self.xlib.XConnectionNumber)(self.display) }

            host.last_pos.set(host.cursor_pos());
            host
        }

    fn next_event(&self) -> xlib::XEvent {
        unsafe {
            let mut event = MaybeUninit::uninit();
            (self.xlib.XNextEvent)(self.display, event.as_mut_ptr());
            event.assume_init()

    fn map_button_event(event: xlib::XButtonEvent, state: bool) -> ButtonEvent {
        ButtonEvent {
            button: event.button,
            state,

    // xfixes
    fn select_selection_input(&self, window: xlib::Window, atom: xlib::Atom, event_mask: u64) {
        unsafe { (self.xfixes.XFixesSelectSelectionInput)(
            self.display, window, atom, event_mask
        ) };

    fn map_key_event(&self, event: xlib::XKeyEvent, state: bool) -> KeyEvent {
        let key = unsafe {
            (self.xlib.XKeycodeToKeysym)(self.display, event.keycode as u8, 0)
        };
        KeyEvent {
            key,
            state,
        }

    // xinput2
    fn select_events(&self, window: xlib::Window, mask: &mut [xinput2::XIEventMask]) {
        unsafe { (self.xinput2.XISelectEvents)(
            self.display, window,
            &mut mask[0] as *mut xinput2::XIEventMask, mask.len() as i32
        ) };

    fn map_generic_event(&self, cookie: xlib::XGenericEventCookie) -> Option<HostEvent> {
        // FIXME: Check XInput2 extension in cookie.extension
        match cookie.evtype {
            xinput2::XI_RawMotion => Some(HostEvent::Motion(self.map_raw_motion())),
            _ => None,
        }

    fn recv_generic_event(&self, cookie: xlib::XGenericEventCookie) -> Option<HostEvent> {
        // FIXME: Assert XInput2 extension in cookie.extension
        assert_eq!(cookie.evtype, xinput2::XI_RawMotion);

    fn map_raw_motion(&self) -> MotionEvent {

        Some(HostEvent::Motion(MotionEvent { dx, dy }))
    }
    fn recv_button_event(&self, event: xlib::XButtonEvent, state: bool) -> Option<HostEvent> {
        Some(HostEvent::Button(ButtonEvent {
            button: event.button,
            state,
        }))
    }

    fn recv_key_event(&self, event: xlib::XKeyEvent, state: bool) -> Option<HostEvent> {
        let key = unsafe { (self.xlib.XKeycodeToKeysym)(self.display, event.keycode as u8, 0) };
        Some(HostEvent::Key(KeyEvent {
            key,
            state,
        }))

        MotionEvent { dx, dy }

    fn recv_selection_event(&self, event: xfixes::XFixesSelectionNotifyEvent) -> Option<HostEvent> {

    fn map_selection_event(&self, event: xfixes::XFixesSelectionNotifyEvent) -> Option<HostEvent> {

        self.last_pos.set((event.x, event.y));

            self.last_pos.set((event.x, event.y));

            (self.xlib.XFlush)(self.display);
        };

        }

        let (last_x, last_y) = self.last_pos.get();
        self.last_pos.set((last_x + event.dx, last_y + event.dy));

            let (last_x, last_y) = self.last_pos.get();
            self.last_pos.set((last_x + event.dx, last_y + event.dy));

            (self.xlib.XFlush)(self.display);
        };

        }

            (self.xlib.XFlush)(self.display);
        };

        }

            (self.xlib.XFlush)(self.display);
        };

        }

impl HostInterface for X11Interface {
    fn screen_size(&self) -> (i32, i32) {

impl Drop for Host {
    fn drop(&mut self) {

            let screen = &*(self.xlib.XDefaultScreenOfDisplay)(self.display);
            assert!(screen.width > 0 && screen.height > 0);
            (screen.width, screen.height)

            (self.xlib.XCloseDisplay)(self.display);

    }
}
impl HostInterface for Host {
    fn screen_size(&self) -> (i32, i32) {
        let screen = unsafe {
            &*(self.xlib.XDefaultScreenOfDisplay)(self.display)
        };
        assert!(screen.width > 0 && screen.height > 0);
        (screen.width, screen.height)

            let mut root = MaybeUninit::uninit();
            let mut child = MaybeUninit::uninit();

            let mut child_x = MaybeUninit::uninit();
            let mut child_y = MaybeUninit::uninit();
            let mut mask = MaybeUninit::uninit();

            (self.xlib.XQueryPointer)(self.display, self.root,
                                      root.as_mut_ptr(), child.as_mut_ptr(),
                                      root_x.as_mut_ptr(), root_y.as_mut_ptr(),
                                      child_x.as_mut_ptr(), child_y.as_mut_ptr(),
                                      mask.as_mut_ptr());

            (self.xlib.XQueryPointer)(
                self.display, self.root,
                ptr::null_mut(), ptr::null_mut(),
                root_x.as_mut_ptr(), root_y.as_mut_ptr(),
                ptr::null_mut(), ptr::null_mut(),
                ptr::null_mut());

        let mask = (xlib::ButtonPressMask | xlib::ButtonReleaseMask) as u32;

            let mask = xlib::ButtonPressMask | xlib::ButtonReleaseMask;

                self.display, self.root, xlib::True, mask as u32,
                xlib::GrabModeAsync, xlib::GrabModeAsync, 0, 0, xlib::CurrentTime

                self.display,
                self.root,
                xlib::True,
                mask,
                xlib::GrabModeAsync,
                xlib::GrabModeAsync,
                0,
                0,
                xlib::CurrentTime

        };

        }

        unsafe { (self.xlib.XGrabKeyboard)(
            self.display, self.root, xlib::True,
            xlib::GrabModeAsync, xlib::GrabModeAsync, xlib::CurrentTime
        ) };

        unsafe {
            (self.xlib.XGrabKeyboard)(
                self.display, self.root, xlib::True,
                xlib::GrabModeAsync, xlib::GrabModeAsync, xlib::CurrentTime);
        }

        unsafe { (self.xlib.XUngrabKeyboard)(self.display, xlib::CurrentTime) };

        unsafe {
            (self.xlib.XUngrabKeyboard)(self.display, xlib::CurrentTime);
        }

}

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

impl Stream for Host {
    type Item = HostEvent;
    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
        match self.io.poll_read_ready(cx, mio::Ready::readable()) {
            Poll::Ready(result) => result.unwrap(),
            Poll::Pending => return Poll::Pending,
        };

            return None;

            self.io.clear_read_ready(cx, mio::Ready::readable()).unwrap();
            return Poll::Pending;

        let event = self.next_event();
        let event_type = event.get_type();

        // Standard events
        match event_type {
            xlib::GenericEvent => return self.recv_generic_event(From::from(event)),
            xlib::ButtonPress => return self.recv_button_event(From::from(event), true),
            xlib::ButtonRelease => return self.recv_button_event(From::from(event), false),
            xlib::KeyPress => return self.recv_key_event(From::from(event), true),
            xlib::KeyRelease => return self.recv_key_event(From::from(event), false),
            xlib::MappingNotify => return None,
            _ => (),

        let event = unsafe {
            let mut event = MaybeUninit::uninit();
            (self.xlib.XNextEvent)(self.display, event.as_mut_ptr());
            event.assume_init()

        // XFixes selection events
        match event_type - self.xfixes_event_base {
            xfixes::XFixesSelectionNotify => return self.recv_selection_event(From::from(event)),
            _ => (),

        let host_event = match event.get_type() {
            // Standard events
            xlib::ButtonPress => Some(HostEvent::Button(Self::map_button_event(event.into(), true))),
            xlib::ButtonRelease => Some(HostEvent::Button(Self::map_button_event(event.into(), false))),
            xlib::KeyPress => Some(HostEvent::Key(self.map_key_event(event.into(), true))),
            xlib::KeyRelease => Some(HostEvent::Key(self.map_key_event(event.into(), false))),
            xlib::MappingNotify => None,
            xlib::GenericEvent => self.map_generic_event(event.into()),
            // XFixes selection events
            event_type if event_type - self.xfixes_event_base == xfixes::XFixesSelectionNotify =>
                self.map_selection_event(event.into()),
            event_type => {
                warn!("Unexpected X11 event: {}", event_type);
                None
            }

        match host_event {
            Some(host_event) => Poll::Ready(Some(host_event)),
            None => self.poll_next(cx),
        }
    }
}
impl Sink<HostEvent> for Host {
    type Error = io::Error;

        warn!("Unexpected X11 event: {}", event_type);
        None

    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        match self.io.poll_write_ready(cx) {
            Poll::Ready(result) => Poll::Ready(result.map(|_| ())),
            Poll::Pending => Poll::Pending,
        }

    fn send_event(&self, event: HostEvent) {

    fn start_send(self: Pin<&mut Self>, event: HostEvent) -> Result<(), Self::Error> {

            event => warn!("Unexpected host event: {:?}", event),

            HostEvent::Selection(_event) => todo!(),
        }
        Ok(())
    }
    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        match self.io.poll_write_ready(cx) {
            Poll::Ready(result) => Poll::Ready(result.map(|_| unsafe {
                (self.xlib.XFlush)(self.display);
            })),
            Poll::Pending => Poll::Pending,

    }
    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
        self.poll_flush(cx)

// /*
//  * FIXME(Future):
//  * Method delegation: https://github.com/rust-lang/rfcs/pull/1406
//  */
// impl Evented for X11Interface {
//     fn register(&self, selector: &mut Selector, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
//         selector.register(self.connection_number(), token, interest, opts)
//     }

struct Connection {
    fd: RawFd,
}

//     fn reregister(&self, selector: &mut Selector, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {
//         selector.reregister(self.connection_number(), token, interest, opts)
//     }

impl mio::Evented for Connection {
    fn register(&self, poll: &mio::Poll, token: mio::Token, interest: mio::Ready, opts: mio::PollOpt)
        -> io::Result<()>
    {
        mio::unix::EventedFd(&self.fd).register(poll, token, interest, opts)
    }

//     fn deregister(&self, selector: &mut Selector) -> io::Result<()> {
//         selector.deregister(self.connection_number())
//     }
// }

    fn reregister(&self, poll: &mio::Poll, token: mio::Token, interest: mio::Ready, opts: mio::PollOpt)
        -> io::Result<()>
    {
        mio::unix::EventedFd(&self.fd).reregister(poll, token, interest, opts)
    }

impl Drop for X11Interface {
    fn drop(&mut self) {
        unsafe { (self.xlib.XCloseDisplay)(self.display) };

    fn deregister(&self, poll: &mio::Poll) -> io::Result<()> {
        mio::unix::EventedFd(&self.fd).deregister(poll)