Move api module into platform::linux

src/platform/linux/dlopen.rs

@@ -0,0 +1,15 @@
+#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+#![allow(dead_code)]
+
+use std::os::raw::{c_void, c_char, c_int};
+
+pub const RTLD_LAZY: c_int = 0x001;
+pub const RTLD_NOW: c_int = 0x002;
+
+#[link="dl"]
+extern {
+    pub fn dlopen(filename: *const c_char, flag: c_int) -> *mut c_void;
+    pub fn dlerror() -> *mut c_char;
+    pub fn dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void;
+    pub fn dlclose(handle: *mut c_void) -> c_int;
+}

src/platform/linux/mod.rs

@@ -10,12 +10,15 @@ use MouseCursor;
 use WindowAttributes;
 use libc;
 
-use api::wayland;
-use api::x11;
-use api::x11::XConnection;
-use api::x11::XError;
-use api::x11::XNotSupported;
-use api::x11::ffi::XVisualInfo;
+use self::x11::XConnection;
+use self::x11::XError;
+use self::x11::XNotSupported;
+use self::x11::ffi::XVisualInfo;
+
+mod dlopen;
+pub mod wayland;
+pub mod x11;
+
 
 gen_api_transition!();
 

src/platform/linux/wayland/context.rs

@@ -0,0 +1,679 @@
+use {WindowEvent as Event, ElementState, MouseButton, MouseScrollDelta, TouchPhase};
+
+use events::ModifiersState;
+
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+use wayland_client::{EnvHandler, default_connect, EventQueue, EventQueueHandle, Init, Proxy};
+use wayland_client::protocol::{wl_compositor, wl_seat, wl_shell, wl_shm, wl_subcompositor,
+                               wl_display, wl_registry, wl_output, wl_surface, wl_pointer,
+                               wl_keyboard};
+
+use super::wayland_window;
+use super::wayland_kbd::MappedKeyboard;
+use super::keyboard::KbdHandler;
+
+/*
+ * Registry and globals handling
+ */
+
+wayland_env!(InnerEnv,
+    compositor: wl_compositor::WlCompositor,
+    shell: wl_shell::WlShell,
+    shm: wl_shm::WlShm,
+    subcompositor: wl_subcompositor::WlSubcompositor
+);
+
+enum KbdType {
+    Mapped(MappedKeyboard<KbdHandler>),
+    Plain(Option<Arc<Mutex<VecDeque<Event>>>>)
+}
+
+struct WaylandEnv {
+    registry: wl_registry::WlRegistry,
+    inner: EnvHandler<InnerEnv>,
+    monitors: Vec<OutputInfo>,
+    my_id: usize,
+    windows: Vec<(Arc<wl_surface::WlSurface>,Arc<Mutex<VecDeque<Event>>>)>,
+    seat: Option<wl_seat::WlSeat>,
+    mouse: Option<wl_pointer::WlPointer>,
+    mouse_focus: Option<Arc<Mutex<VecDeque<Event>>>>,
+    mouse_location: (i32, i32),
+    axis_buffer: Option<(f32, f32)>,
+    axis_discrete_buffer: Option<(i32, i32)>,
+    axis_state: TouchPhase,
+    kbd: Option<wl_keyboard::WlKeyboard>,
+    kbd_handler: KbdType
+}
+
+struct OutputInfo {
+    output: wl_output::WlOutput,
+    id: u32,
+    scale: f32,
+    pix_size: (u32, u32),
+    name: String
+}
+
+impl OutputInfo {
+    fn new(output: wl_output::WlOutput, id: u32) -> OutputInfo {
+        OutputInfo {
+            output: output,
+            id: id,
+            scale: 1.0,
+            pix_size: (0, 0),
+            name: "".into()
+        }
+    }
+}
+
+impl WaylandEnv {
+    fn new(registry: wl_registry::WlRegistry) -> WaylandEnv {
+        let kbd_handler = match MappedKeyboard::new(KbdHandler::new()) {
+            Ok(h) => KbdType::Mapped(h),
+            Err(_) => KbdType::Plain(None)
+        };
+        WaylandEnv {
+            registry: registry,
+            inner: EnvHandler::new(),
+            monitors: Vec::new(),
+            my_id: 0,
+            windows: Vec::new(),
+            seat: None,
+            mouse: None,
+            mouse_focus: None,
+            mouse_location: (0,0),
+            axis_buffer: None,
+            axis_discrete_buffer: None,
+            axis_state: TouchPhase::Started,
+            kbd: None,
+            kbd_handler: kbd_handler
+        }
+    }
+
+    fn get_seat(&self) -> Option<wl_seat::WlSeat> {
+        for &(name, ref interface, version) in self.inner.globals() {
+            if interface == "wl_seat" {
+                // this "expect" cannot trigger (see https://github.com/vberger/wayland-client-rs/issues/69)
+                let seat = self.registry.bind::<wl_seat::WlSeat>(5, name).expect("Seat cannot be destroyed");
+                return Some(seat)
+            }
+        }
+        None
+    }
+}
+
+impl Init for WaylandEnv {
+    fn init(&mut self, evqh: &mut EventQueueHandle, index: usize) {
+        evqh.register::<_, WaylandEnv>(&self.registry, index);
+        self.my_id = index
+    }
+}
+
+impl wl_registry::Handler for WaylandEnv {
+    fn global(&mut self,
+              evqh: &mut EventQueueHandle,
+              registry: &wl_registry::WlRegistry,
+              name: u32,
+              interface: String,
+              version: u32)
+    {
+        if interface == "wl_output" {
+            // intercept outputs
+            // this "expect" cannot trigger (see https://github.com/vberger/wayland-client-rs/issues/69)
+            let output = self.registry.bind::<wl_output::WlOutput>(1, name)
+                             .expect("Registry cannot be dead");
+            evqh.register::<_, WaylandEnv>(&output, self.my_id);
+            self.monitors.push(OutputInfo::new(output, name));
+        } else if interface == "wl_seat" && self.seat.is_none() {
+            // Only grab the first seat
+            // TODO: Handle multi-seat-setup?
+            assert!(version >= 5, "Version 5 of seat interface is needed by glutin.");
+            let seat = self.registry.bind::<wl_seat::WlSeat>(5, name)
+                           .expect("Registry cannot be dead");
+            evqh.register::<_, WaylandEnv>(&seat, self.my_id);
+            self.seat = Some(seat);
+        }
+        self.inner.global(evqh, registry, name, interface, version);
+    }
+
+    fn global_remove(&mut self,
+                     evqh: &mut EventQueueHandle,
+                     registry: &wl_registry::WlRegistry,
+                     name: u32)
+    {
+        // prune old monitors
+        self.monitors.retain(|m| m.id != name);
+        self.inner.global_remove(evqh, registry, name);
+    }
+}
+
+declare_handler!(WaylandEnv, wl_registry::Handler, wl_registry::WlRegistry);
+
+impl wl_output::Handler for WaylandEnv {
+    fn geometry(&mut self,
+                _: &mut EventQueueHandle,
+                proxy: &wl_output::WlOutput,
+                _x: i32, _y: i32,
+                _physical_width: i32, _physical_height: i32,
+                _subpixel: wl_output::Subpixel,
+                make: String, model: String,
+                _transform: wl_output::Transform)
+    {
+        for m in self.monitors.iter_mut().filter(|m| m.output.equals(proxy)) {
+            m.name = format!("{} ({})", model, make);
+            break;
+        }
+    }
+    fn mode(&mut self,
+            _: &mut EventQueueHandle,
+            proxy: &wl_output::WlOutput,
+            flags: wl_output::Mode,
+            width: i32, height: i32,
+            _refresh: i32)
+    {
+        if flags.contains(wl_output::Current) {
+            for m in self.monitors.iter_mut().filter(|m| m.output.equals(proxy)) {
+                m.pix_size = (width as u32, height as u32);
+                break;
+            }
+        }
+    }
+    fn scale(&mut self,
+             _: &mut EventQueueHandle,
+             proxy: &wl_output::WlOutput,
+             factor: i32)
+    {
+        for m in self.monitors.iter_mut().filter(|m| m.output.equals(proxy)) {
+            m.scale = factor as f32;
+            break;
+        }
+    }
+}
+
+declare_handler!(WaylandEnv, wl_output::Handler, wl_output::WlOutput);
+
+/*
+ * Main context struct
+ */
+
+pub struct WaylandContext {
+    pub display: wl_display::WlDisplay,
+    evq: Mutex<EventQueue>,
+    env_id: usize,
+}
+
+impl WaylandContext {
+    pub fn init() -> Option<WaylandContext> {
+        // attempt to connect to the wayland server
+        // this handles both "no libwayland" and "no compositor" cases
+        let (display, mut event_queue) = match default_connect() {
+            Ok(ret) => ret,
+            Err(e) => return None
+        };
+
+        // this "expect" cannot trigger (see https://github.com/vberger/wayland-client-rs/issues/69)
+        let registry = display.get_registry().expect("Display cannot be already destroyed.");
+        let env_id = event_queue.add_handler_with_init(WaylandEnv::new(registry));
+        // two syncs fully initialize
+        event_queue.sync_roundtrip().expect("Wayland connection unexpectedly lost");
+        event_queue.sync_roundtrip().expect("Wayland connection unexpectedly lost");
+
+        Some(WaylandContext {
+            evq: Mutex::new(event_queue),
+            display: display,
+            env_id: env_id
+        })
+    }
+
+    pub fn dispatch_pending(&self) {
+        let mut guard = self.evq.lock().unwrap();
+        guard.dispatch_pending().expect("Wayland connection unexpectedly lost");
+    }
+
+    pub fn dispatch(&self) {
+        let mut guard = self.evq.lock().unwrap();
+        guard.dispatch().expect("Wayland connection unexpectedly lost");
+    }
+
+    pub fn flush(&self) {
+        self.display.flush();
+    }
+
+    pub fn with_output<F>(&self, id: MonitorId, f: F) where F: FnOnce(&wl_output::WlOutput) {
+        let mut guard = self.evq.lock().unwrap();
+        let state = guard.state();
+        let env = state.get_handler::<WaylandEnv>(self.env_id);
+        for m in env.monitors.iter().filter(|m| m.id == id.id) {
+            f(&m.output);
+            break
+        }
+    }
+
+    pub fn create_window<H: wayland_window::Handler>(&self)
+        -> (Arc<wl_surface::WlSurface>, Arc<Mutex<VecDeque<Event>>>, wayland_window::DecoratedSurface<H>)
+    {
+        let mut guard = self.evq.lock().unwrap();
+        let mut state = guard.state();
+        let env = state.get_mut_handler::<WaylandEnv>(self.env_id);
+        // this "expect" cannot trigger (see https://github.com/vberger/wayland-client-rs/issues/69)
+        let surface = Arc::new(env.inner.compositor.create_surface().expect("Compositor cannot be dead"));
+        let eventiter = Arc::new(Mutex::new(VecDeque::new()));
+        env.windows.push((surface.clone(), eventiter.clone()));
+        let decorated = wayland_window::DecoratedSurface::new(
+            &*surface, 800, 600,
+            &env.inner.compositor,
+            &env.inner.subcompositor,
+            &env.inner.shm,
+            &env.inner.shell,
+            env.get_seat(),
+            false
+        ).expect("Failed to create a tmpfile buffer.");
+        (surface, eventiter, decorated)
+    }
+
+    pub fn prune_dead_windows(&self) {
+        let mut guard = self.evq.lock().unwrap();
+        let mut state = guard.state();
+        let env = state.get_mut_handler::<WaylandEnv>(self.env_id);
+        env.windows.retain(|w| w.0.is_alive());
+    }
+}
+
+/*
+ * Monitors API
+ */
+
+pub fn get_primary_monitor(ctxt: &Arc<WaylandContext>) -> MonitorId {
+    let mut guard = ctxt.evq.lock().unwrap();
+    let state = guard.state();
+    let env = state.get_handler::<WaylandEnv>(ctxt.env_id);
+    if let Some(ref monitor) = env.monitors.iter().next() {
+        MonitorId {
+            id: monitor.id,
+            ctxt: ctxt.clone()
+        }
+    } else {
+        panic!("No monitor is available.")
+    }
+}
+
+pub fn get_available_monitors(ctxt: &Arc<WaylandContext>) -> VecDeque<MonitorId> {
+    let mut guard = ctxt.evq.lock().unwrap();
+    let state = guard.state();
+    let env = state.get_handler::<WaylandEnv>(ctxt.env_id);
+    env.monitors.iter()
+       .map(|m| MonitorId { id: m.id, ctxt: ctxt.clone() })
+       .collect()
+}
+
+#[derive(Clone)]
+pub struct MonitorId {
+    id: u32,
+    ctxt: Arc<WaylandContext>
+}
+
+impl MonitorId {
+    pub fn get_name(&self) -> Option<String> {
+        let mut guard = self.ctxt.evq.lock().unwrap();
+        let state = guard.state();
+        let env = state.get_handler::<WaylandEnv>(self.ctxt.env_id);
+        for m in env.monitors.iter().filter(|m| m.id == self.id) {
+            return Some(m.name.clone())
+        }
+        // if we reach here, this monitor does not exist any more
+        None
+    }
+
+    #[inline]
+    pub fn get_native_identifier(&self) -> ::native_monitor::NativeMonitorId {
+        ::native_monitor::NativeMonitorId::Unavailable
+    }
+
+    pub fn get_dimensions(&self) -> (u32, u32) {
+        let mut guard = self.ctxt.evq.lock().unwrap();
+        let state = guard.state();
+        let env = state.get_handler::<WaylandEnv>(self.ctxt.env_id);
+        for m in env.monitors.iter().filter(|m| m.id == self.id) {
+            return m.pix_size
+        }
+        // if we reach here, this monitor does not exist any more
+        (0,0)
+    }
+}
+
+/*
+ * Input Handling
+ */
+
+impl wl_seat::Handler for WaylandEnv {
+    fn capabilities(&mut self,
+                    evqh: &mut EventQueueHandle,
+                    seat: &wl_seat::WlSeat,
+                    capabilities: wl_seat::Capability)
+    {
+        // create pointer if applicable
+        if capabilities.contains(wl_seat::Pointer) && self.mouse.is_none() {
+            let pointer = seat.get_pointer().expect("Seat is not dead");
+            evqh.register::<_, WaylandEnv>(&pointer, self.my_id);
+            self.mouse = Some(pointer);
+        }
+        // destroy pointer if applicable
+        if !capabilities.contains(wl_seat::Pointer) {
+            if let Some(pointer) = self.mouse.take() {
+                pointer.release();
+            }
+        }
+        // create keyboard if applicable
+        if capabilities.contains(wl_seat::Keyboard) && self.kbd.is_none() {
+            let kbd = seat.get_keyboard().expect("Seat is not dead");
+            evqh.register::<_, WaylandEnv>(&kbd, self.my_id);
+            self.kbd = Some(kbd);
+        }
+        // destroy keyboard if applicable
+        if !capabilities.contains(wl_seat::Keyboard) {
+            if let Some(kbd) = self.kbd.take() {
+                kbd.release();
+            }
+        }
+    }
+}
+
+declare_handler!(WaylandEnv, wl_seat::Handler, wl_seat::WlSeat);
+
+/*
+ * Pointer Handling
+ */
+
+impl wl_pointer::Handler for WaylandEnv {
+    fn enter(&mut self,
+             _evqh: &mut EventQueueHandle,
+             _proxy: &wl_pointer::WlPointer,
+             _serial: u32,
+             surface: &wl_surface::WlSurface,
+             surface_x: f64,
+             surface_y: f64)
+    {
+        self.mouse_location = (surface_x as i32, surface_y as i32);
+        for &(ref window, ref eviter) in &self.windows {
+            if window.equals(surface) {
+                self.mouse_focus = Some(eviter.clone());
+                let (w, h) = self.mouse_location;
+                let mut event_queue = eviter.lock().unwrap();
+                event_queue.push_back(Event::MouseEntered);
+                event_queue.push_back(Event::MouseMoved(w, h));
+                break;
+            }
+        }
+    }
+
+    fn leave(&mut self,
+             _evqh: &mut EventQueueHandle,
+             _proxy: &wl_pointer::WlPointer,
+             _serial: u32,
+             surface: &wl_surface::WlSurface)
+    {
+        self.mouse_focus = None;
+        for &(ref window, ref eviter) in &self.windows {
+            if window.equals(surface) {
+                let mut event_queue = eviter.lock().unwrap();
+                event_queue.push_back(Event::MouseLeft);
+                break;
+            }
+        }
+    }
+
+    fn motion(&mut self,
+              _evqh: &mut EventQueueHandle,
+              _proxy: &wl_pointer::WlPointer,
+              _time: u32,
+              surface_x: f64,
+              surface_y: f64)
+    {
+        self.mouse_location = (surface_x as i32, surface_y as i32);
+        if let Some(ref eviter) = self.mouse_focus {
+            let (w,h) = self.mouse_location;
+            eviter.lock().unwrap().push_back(
+                Event::MouseMoved(w, h)
+            );
+        }
+    }
+
+    fn button(&mut self,
+              _evqh: &mut EventQueueHandle,
+              _proxy: &wl_pointer::WlPointer,
+              _serial: u32,
+              _time: u32,
+              button: u32,
+              state: wl_pointer::ButtonState)
+    {
+        if let Some(ref eviter) = self.mouse_focus {
+            let state = match state {
+                wl_pointer::ButtonState::Pressed => ElementState::Pressed,
+                wl_pointer::ButtonState::Released => ElementState::Released
+            };
+            let button = match button {
+                0x110 => MouseButton::Left,
+                0x111 => MouseButton::Right,
+                0x112 => MouseButton::Middle,
+                // TODO figure out the translation ?
+                _ => return
+            };
+            eviter.lock().unwrap().push_back(
+                Event::MouseInput(state, button)
+            );
+        }
+    }
+
+    fn axis(&mut self,
+            _evqh: &mut EventQueueHandle,
+            _proxy: &wl_pointer::WlPointer,
+            _time: u32,
+            axis: wl_pointer::Axis,
+            value: f64)
+    {
+        let (mut x, mut y) = self.axis_buffer.unwrap_or((0.0, 0.0));
+        match axis {
+            wl_pointer::Axis::VerticalScroll => y += value as f32,
+            wl_pointer::Axis::HorizontalScroll => x += value as f32
+        }
+        self.axis_buffer = Some((x,y));
+        self.axis_state = match self.axis_state {
+            TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
+            _ => TouchPhase::Started
+        }
+    }
+
+    fn frame(&mut self,
+             _evqh: &mut EventQueueHandle,
+             _proxy: &wl_pointer::WlPointer)
+    {
+        let axis_buffer = self.axis_buffer.take();
+        let axis_discrete_buffer = self.axis_discrete_buffer.take();
+        if let Some(ref eviter) = self.mouse_focus {
+            if let Some((x, y)) = axis_discrete_buffer {
+                eviter.lock().unwrap().push_back(
+                    Event::MouseWheel(
+                        MouseScrollDelta::LineDelta(x as f32, y as f32),
+                        self.axis_state
+                    )
+                );
+            } else if let Some((x, y)) = axis_buffer {
+                eviter.lock().unwrap().push_back(
+                    Event::MouseWheel(
+                        MouseScrollDelta::PixelDelta(x as f32, y as f32),
+                        self.axis_state
+                    )
+                );
+            }
+        }
+    }
+
+    fn axis_source(&mut self,
+                   _evqh: &mut EventQueueHandle,
+                   _proxy: &wl_pointer::WlPointer,
+                   axis_source: wl_pointer::AxisSource)
+    {
+    }
+
+    fn axis_stop(&mut self,
+                 _evqh: &mut EventQueueHandle,
+                 _proxy: &wl_pointer::WlPointer,
+                 _time: u32,
+                 axis: wl_pointer::Axis)
+    {
+        self.axis_state = TouchPhase::Ended;
+    }
+
+    fn axis_discrete(&mut self,
+                     _evqh: &mut EventQueueHandle,
+                     _proxy: &wl_pointer::WlPointer,
+                     axis: wl_pointer::Axis,
+                     discrete: i32)
+    {
+        let (mut x, mut y) = self.axis_discrete_buffer.unwrap_or((0,0));
+        match axis {
+            wl_pointer::Axis::VerticalScroll => y += discrete,
+            wl_pointer::Axis::HorizontalScroll => x += discrete
+        }
+        self.axis_discrete_buffer = Some((x,y));
+                self.axis_state = match self.axis_state {
+            TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
+            _ => TouchPhase::Started
+        }
+    }
+}
+
+declare_handler!(WaylandEnv, wl_pointer::Handler, wl_pointer::WlPointer);
+
+/*
+ * Keyboard Handling
+ */
+
+impl wl_keyboard::Handler for WaylandEnv {
+    // mostly pass-through
+    fn keymap(&mut self,
+              evqh: &mut EventQueueHandle,
+              proxy: &wl_keyboard::WlKeyboard,
+              format: wl_keyboard::KeymapFormat,
+              fd: ::std::os::unix::io::RawFd,
+              size: u32)
+    {
+        match self.kbd_handler {
+            KbdType::Mapped(ref mut h) => h.keymap(evqh, proxy, format, fd, size),
+            _ => ()
+        }
+    }
+
+    fn enter(&mut self,
+             evqh: &mut EventQueueHandle,
+             proxy: &wl_keyboard::WlKeyboard,
+             serial: u32,
+             surface: &wl_surface::WlSurface,
+             keys: Vec<u8>)
+    {
+        let mut opt_eviter = None;
+        for &(ref window, ref eviter) in &self.windows {
+            if window.equals(surface) {
+                opt_eviter = Some(eviter.clone());
+                break;
+            }
+        }
+        if let Some(ref eviter) = opt_eviter {
+            // send focused event
+            let mut guard = eviter.lock().unwrap();
+            guard.push_back(Event::Focused(true));
+        }
+        match self.kbd_handler {
+            KbdType::Mapped(ref mut h) => {
+                h.handler().target = opt_eviter;
+                h.enter(evqh, proxy, serial, surface, keys);
+            },
+            KbdType::Plain(ref mut opt) => { *opt = opt_eviter; }
+        }
+    }
+
+    fn leave(&mut self,
+             evqh: &mut EventQueueHandle,
+             proxy: &wl_keyboard::WlKeyboard,
+             serial: u32,
+             surface: &wl_surface::WlSurface)
+    {
+        let opt_eviter = match self.kbd_handler {
+            KbdType::Mapped(ref mut h) => {
+                let eviter = h.handler().target.take();
+                h.leave(evqh, proxy, serial, surface);
+                eviter
+            },
+            KbdType::Plain(ref mut opt) => opt.take()
+        };
+        if let Some(eviter) = opt_eviter {
+            let mut guard = eviter.lock().unwrap();
+            guard.push_back(Event::Focused(false));
+        }
+    }
+
+    fn key(&mut self,
+           evqh: &mut EventQueueHandle,
+           proxy: &wl_keyboard::WlKeyboard,
+           serial: u32,
+           time: u32,
+           key: u32,
+           state: wl_keyboard::KeyState)
+    {
+        match self.kbd_handler {
+            KbdType::Mapped(ref mut h) => h.key(evqh, proxy, serial, time, key, state),
+            KbdType::Plain(Some(ref eviter)) => {
+                let state = match state {
+                    wl_keyboard::KeyState::Pressed => ElementState::Pressed,
+                    wl_keyboard::KeyState::Released => ElementState::Released,
+                };
+                let mut guard = eviter.lock().unwrap();
+                // This is fallback impl if libxkbcommon was not available
+                // This case should probably never happen, as most wayland
+                // compositors _need_ libxkbcommon anyway...
+                //
+                // In this case, we don't have the modifiers state information
+                // anyway, as we need libxkbcommon to interpret it (it is
+                // supposed to be serialized by the compositor using libxkbcommon)
+                guard.push_back(Event::KeyboardInput(
+                    state,
+                    key as u8,
+                    None,
+                    ModifiersState::default()
+                ));
+            },
+            KbdType::Plain(None) => ()
+        }
+    }
+
+    fn modifiers(&mut self,
+                 evqh: &mut EventQueueHandle,
+                 proxy: &wl_keyboard::WlKeyboard,
+                 serial: u32,
+                 mods_depressed: u32,
+                 mods_latched: u32,
+                 mods_locked: u32,
+                 group: u32)
+    {
+        match self.kbd_handler {
+            KbdType::Mapped(ref mut h) => h.modifiers(evqh, proxy, serial, mods_depressed,
+                                                      mods_latched, mods_locked, group),
+            _ => ()
+        }
+    }
+
+    fn repeat_info(&mut self,
+                   evqh: &mut EventQueueHandle,
+                   proxy: &wl_keyboard::WlKeyboard,
+                   rate: i32,
+                   delay: i32)
+    {
+        match self.kbd_handler {
+            KbdType::Mapped(ref mut h) => h.repeat_info(evqh, proxy, rate, delay),
+            _ => ()
+        }
+    }
+}
+
+declare_handler!(WaylandEnv, wl_keyboard::Handler, wl_keyboard::WlKeyboard);

src/platform/linux/wayland/keyboard.rs

@@ -0,0 +1,231 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+use {VirtualKeyCode, ElementState, WindowEvent as Event};
+
+use events::ModifiersState;
+
+use super::wayland_kbd;
+use wayland_client::EventQueueHandle;
+use wayland_client::protocol::wl_keyboard;
+
+pub struct KbdHandler {
+    pub target: Option<Arc<Mutex<VecDeque<Event>>>>
+}
+
+impl KbdHandler {
+    pub fn new() -> KbdHandler {
+        KbdHandler { target: None }
+    }
+}
+
+impl wayland_kbd::Handler for KbdHandler {
+    fn key(&mut self,
+           _evqh: &mut EventQueueHandle,
+           _proxy: &wl_keyboard::WlKeyboard,
+           _serial: u32,
+           _time: u32,
+           mods: &wayland_kbd::ModifiersState,
+           rawkey: u32,
+           keysym: u32,
+           state: wl_keyboard::KeyState,
+           utf8: Option<String>)
+    {
+        if let Some(ref eviter) = self.target {
+            let state = match state {
+                wl_keyboard::KeyState::Pressed => ElementState::Pressed,
+                wl_keyboard::KeyState::Released => ElementState::Released,
+            };
+            let vkcode = key_to_vkey(rawkey, keysym);
+            let mut guard = eviter.lock().unwrap();
+            guard.push_back(
+                Event::KeyboardInput(
+                    state,
+                    rawkey as u8,
+                    vkcode,
+                    ModifiersState {
+                        shift: mods.shift,
+                        ctrl: mods.ctrl,
+                        alt: mods.alt,
+                        logo: mods.logo
+                    }
+                )
+            );
+            // send char event only on key press, not release
+            if let ElementState::Released = state { return }
+            if let Some(txt) = utf8 {
+                for chr in txt.chars() {
+                    guard.push_back(Event::ReceivedCharacter(chr));
+                }
+            }
+        }
+    }
+}
+
+fn key_to_vkey(rawkey: u32, keysym: u32) -> Option<VirtualKeyCode> {
+    match rawkey {
+         1 => Some(VirtualKeyCode::Escape),
+         2 => Some(VirtualKeyCode::Key1),
+         3 => Some(VirtualKeyCode::Key2),
+         4 => Some(VirtualKeyCode::Key3),
+         5 => Some(VirtualKeyCode::Key4),
+         6 => Some(VirtualKeyCode::Key5),
+         7 => Some(VirtualKeyCode::Key6),
+         8 => Some(VirtualKeyCode::Key7),
+         9 => Some(VirtualKeyCode::Key8),
+        10 => Some(VirtualKeyCode::Key9),
+        11 => Some(VirtualKeyCode::Key0),
+        _  => keysym_to_vkey(keysym)
+    }
+}
+
+fn keysym_to_vkey(keysym: u32) -> Option<VirtualKeyCode> {
+    use super::wayland_kbd::keysyms;
+    match keysym {
+        // letters
+        keysyms::XKB_KEY_A | keysyms::XKB_KEY_a => Some(VirtualKeyCode::A),
+        keysyms::XKB_KEY_B | keysyms::XKB_KEY_b => Some(VirtualKeyCode::B),
+        keysyms::XKB_KEY_C | keysyms::XKB_KEY_c => Some(VirtualKeyCode::C),
+        keysyms::XKB_KEY_D | keysyms::XKB_KEY_d => Some(VirtualKeyCode::D),
+        keysyms::XKB_KEY_E | keysyms::XKB_KEY_e => Some(VirtualKeyCode::E),
+        keysyms::XKB_KEY_F | keysyms::XKB_KEY_f => Some(VirtualKeyCode::F),
+        keysyms::XKB_KEY_G | keysyms::XKB_KEY_g => Some(VirtualKeyCode::G),
+        keysyms::XKB_KEY_H | keysyms::XKB_KEY_h => Some(VirtualKeyCode::H),
+        keysyms::XKB_KEY_I | keysyms::XKB_KEY_i => Some(VirtualKeyCode::I),
+        keysyms::XKB_KEY_J | keysyms::XKB_KEY_j => Some(VirtualKeyCode::J),
+        keysyms::XKB_KEY_K | keysyms::XKB_KEY_k => Some(VirtualKeyCode::K),
+        keysyms::XKB_KEY_L | keysyms::XKB_KEY_l => Some(VirtualKeyCode::L),
+        keysyms::XKB_KEY_M | keysyms::XKB_KEY_m => Some(VirtualKeyCode::M),
+        keysyms::XKB_KEY_N | keysyms::XKB_KEY_n => Some(VirtualKeyCode::N),
+        keysyms::XKB_KEY_O | keysyms::XKB_KEY_o => Some(VirtualKeyCode::O),
+        keysyms::XKB_KEY_P | keysyms::XKB_KEY_p => Some(VirtualKeyCode::P),
+        keysyms::XKB_KEY_Q | keysyms::XKB_KEY_q => Some(VirtualKeyCode::Q),
+        keysyms::XKB_KEY_R | keysyms::XKB_KEY_r => Some(VirtualKeyCode::R),
+        keysyms::XKB_KEY_S | keysyms::XKB_KEY_s => Some(VirtualKeyCode::S),
+        keysyms::XKB_KEY_T | keysyms::XKB_KEY_t => Some(VirtualKeyCode::T),
+        keysyms::XKB_KEY_U | keysyms::XKB_KEY_u => Some(VirtualKeyCode::U),
+        keysyms::XKB_KEY_V | keysyms::XKB_KEY_v => Some(VirtualKeyCode::V),
+        keysyms::XKB_KEY_W | keysyms::XKB_KEY_w => Some(VirtualKeyCode::W),
+        keysyms::XKB_KEY_X | keysyms::XKB_KEY_x => Some(VirtualKeyCode::X),
+        keysyms::XKB_KEY_Y | keysyms::XKB_KEY_y => Some(VirtualKeyCode::Y),
+        keysyms::XKB_KEY_Z | keysyms::XKB_KEY_z => Some(VirtualKeyCode::Z),
+        // F--
+        keysyms::XKB_KEY_F1  => Some(VirtualKeyCode::F1),
+        keysyms::XKB_KEY_F2  => Some(VirtualKeyCode::F2),
+        keysyms::XKB_KEY_F3  => Some(VirtualKeyCode::F3),
+        keysyms::XKB_KEY_F4  => Some(VirtualKeyCode::F4),
+        keysyms::XKB_KEY_F5  => Some(VirtualKeyCode::F5),
+        keysyms::XKB_KEY_F6  => Some(VirtualKeyCode::F6),
+        keysyms::XKB_KEY_F7  => Some(VirtualKeyCode::F7),
+        keysyms::XKB_KEY_F8  => Some(VirtualKeyCode::F8),
+        keysyms::XKB_KEY_F9  => Some(VirtualKeyCode::F9),
+        keysyms::XKB_KEY_F10 => Some(VirtualKeyCode::F10),
+        keysyms::XKB_KEY_F11 => Some(VirtualKeyCode::F11),
+        keysyms::XKB_KEY_F12 => Some(VirtualKeyCode::F12),
+        keysyms::XKB_KEY_F13 => Some(VirtualKeyCode::F13),
+        keysyms::XKB_KEY_F14 => Some(VirtualKeyCode::F14),
+        keysyms::XKB_KEY_F15 => Some(VirtualKeyCode::F15),
+        // flow control
+        keysyms::XKB_KEY_Print => Some(VirtualKeyCode::Snapshot),
+        keysyms::XKB_KEY_Scroll_Lock => Some(VirtualKeyCode::Scroll),
+        keysyms::XKB_KEY_Pause => Some(VirtualKeyCode::Pause),
+        keysyms::XKB_KEY_Insert => Some(VirtualKeyCode::Insert),
+        keysyms::XKB_KEY_Home => Some(VirtualKeyCode::Home),
+        keysyms::XKB_KEY_Delete => Some(VirtualKeyCode::Delete),
+        keysyms::XKB_KEY_End => Some(VirtualKeyCode::End),
+        keysyms::XKB_KEY_Page_Down => Some(VirtualKeyCode::PageDown),
+        keysyms::XKB_KEY_Page_Up => Some(VirtualKeyCode::PageUp),
+        // arrows
+        keysyms::XKB_KEY_Left => Some(VirtualKeyCode::Left),
+        keysyms::XKB_KEY_Up => Some(VirtualKeyCode::Up),
+        keysyms::XKB_KEY_Right => Some(VirtualKeyCode::Right),
+        keysyms::XKB_KEY_Down => Some(VirtualKeyCode::Down),
+        //
+        keysyms::XKB_KEY_BackSpace => Some(VirtualKeyCode::Back),
+        keysyms::XKB_KEY_Return => Some(VirtualKeyCode::Return),
+        keysyms::XKB_KEY_space => Some(VirtualKeyCode::Space),
+        // keypad
+        keysyms::XKB_KEY_Num_Lock => Some(VirtualKeyCode::Numlock),
+        keysyms::XKB_KEY_KP_0 => Some(VirtualKeyCode::Numpad0),
+        keysyms::XKB_KEY_KP_1 => Some(VirtualKeyCode::Numpad1),
+        keysyms::XKB_KEY_KP_2 => Some(VirtualKeyCode::Numpad2),
+        keysyms::XKB_KEY_KP_3 => Some(VirtualKeyCode::Numpad3),
+        keysyms::XKB_KEY_KP_4 => Some(VirtualKeyCode::Numpad4),
+        keysyms::XKB_KEY_KP_5 => Some(VirtualKeyCode::Numpad5),
+        keysyms::XKB_KEY_KP_6 => Some(VirtualKeyCode::Numpad6),
+        keysyms::XKB_KEY_KP_7 => Some(VirtualKeyCode::Numpad7),
+        keysyms::XKB_KEY_KP_8 => Some(VirtualKeyCode::Numpad8),
+        keysyms::XKB_KEY_KP_9 => Some(VirtualKeyCode::Numpad9),
+        // misc
+        // => Some(VirtualKeyCode::AbntC1),
+        // => Some(VirtualKeyCode::AbntC2),
+        keysyms::XKB_KEY_plus => Some(VirtualKeyCode::Add),
+        keysyms::XKB_KEY_apostrophe => Some(VirtualKeyCode::Apostrophe),
+        // => Some(VirtualKeyCode::Apps),
+        // => Some(VirtualKeyCode::At),
+        // => Some(VirtualKeyCode::Ax),
+        keysyms::XKB_KEY_backslash => Some(VirtualKeyCode::Backslash),
+        // => Some(VirtualKeyCode::Calculator),
+        // => Some(VirtualKeyCode::Capital),
+        keysyms::XKB_KEY_colon => Some(VirtualKeyCode::Colon),
+        keysyms::XKB_KEY_comma => Some(VirtualKeyCode::Comma),
+        // => Some(VirtualKeyCode::Convert),
+        // => Some(VirtualKeyCode::Decimal),
+        // => Some(VirtualKeyCode::Divide),
+        keysyms::XKB_KEY_equal => Some(VirtualKeyCode::Equals),
+        // => Some(VirtualKeyCode::Grave),
+        // => Some(VirtualKeyCode::Kana),
+        // => Some(VirtualKeyCode::Kanji),
+        keysyms::XKB_KEY_Alt_L => Some(VirtualKeyCode::LAlt),
+        // => Some(VirtualKeyCode::LBracket),
+        keysyms::XKB_KEY_Control_L => Some(VirtualKeyCode::LControl),
+        // => Some(VirtualKeyCode::LMenu),
+        keysyms::XKB_KEY_Shift_L => Some(VirtualKeyCode::LShift),
+        // => Some(VirtualKeyCode::LWin),
+        // => Some(VirtualKeyCode::Mail),
+        // => Some(VirtualKeyCode::MediaSelect),
+        // => Some(VirtualKeyCode::MediaStop),
+        keysyms::XKB_KEY_minus => Some(VirtualKeyCode::Minus),
+        keysyms::XKB_KEY_asterisk => Some(VirtualKeyCode::Multiply),
+        // => Some(VirtualKeyCode::Mute),
+        // => Some(VirtualKeyCode::MyComputer),
+        // => Some(VirtualKeyCode::NextTrack),
+        // => Some(VirtualKeyCode::NoConvert),
+        keysyms::XKB_KEY_KP_Separator => Some(VirtualKeyCode::NumpadComma),
+        keysyms::XKB_KEY_KP_Enter => Some(VirtualKeyCode::NumpadEnter),
+        keysyms::XKB_KEY_KP_Equal => Some(VirtualKeyCode::NumpadEquals),
+        // => Some(VirtualKeyCode::OEM102),
+        // => Some(VirtualKeyCode::Period),
+        // => Some(VirtualKeyCode::Playpause),
+        // => Some(VirtualKeyCode::Power),
+        // => Some(VirtualKeyCode::Prevtrack),
+        keysyms::XKB_KEY_Alt_R => Some(VirtualKeyCode::RAlt),
+        // => Some(VirtualKeyCode::RBracket),
+        keysyms::XKB_KEY_Control_R => Some(VirtualKeyCode::RControl),
+        // => Some(VirtualKeyCode::RMenu),
+        keysyms::XKB_KEY_Shift_R => Some(VirtualKeyCode::RShift),
+        // => Some(VirtualKeyCode::RWin),
+        keysyms::XKB_KEY_semicolon => Some(VirtualKeyCode::Semicolon),
+        keysyms::XKB_KEY_slash => Some(VirtualKeyCode::Slash),
+        // => Some(VirtualKeyCode::Sleep),
+        // => Some(VirtualKeyCode::Stop),
+        // => Some(VirtualKeyCode::Subtract),
+        // => Some(VirtualKeyCode::Sysrq),
+        keysyms::XKB_KEY_Tab => Some(VirtualKeyCode::Tab),
+        // => Some(VirtualKeyCode::Underline),
+        // => Some(VirtualKeyCode::Unlabeled),
+        keysyms::XKB_KEY_XF86AudioLowerVolume => Some(VirtualKeyCode::VolumeDown),
+        keysyms::XKB_KEY_XF86AudioRaiseVolume => Some(VirtualKeyCode::VolumeUp),
+        // => Some(VirtualKeyCode::Wake),
+        // => Some(VirtualKeyCode::Webback),
+        // => Some(VirtualKeyCode::WebFavorites),
+        // => Some(VirtualKeyCode::WebForward),
+        // => Some(VirtualKeyCode::WebHome),
+        // => Some(VirtualKeyCode::WebRefresh),
+        // => Some(VirtualKeyCode::WebSearch),
+        // => Some(VirtualKeyCode::WebStop),
+        // => Some(VirtualKeyCode::Yen),
+        // fallback
+        _ => None
+    }
+}

src/platform/linux/wayland/mod.rs

@@ -0,0 +1,12 @@
+#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+
+pub use self::window::{PollEventsIterator, WaitEventsIterator, Window, WindowProxy};
+pub use self::context::{WaylandContext, MonitorId, get_available_monitors,
+                        get_primary_monitor};
+
+extern crate wayland_kbd;
+extern crate wayland_window;
+
+mod context;
+mod keyboard;
+mod window;

src/platform/linux/wayland/window.rs

@@ -0,0 +1,340 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+use wayland_client::{EventQueue, EventQueueHandle, Init};
+use wayland_client::protocol::{wl_display,wl_surface,wl_shell_surface};
+
+use {CreationError, MouseCursor, CursorState, WindowEvent as Event, WindowAttributes};
+use platform::MonitorId as PlatformMonitorId;
+
+use super::WaylandContext;
+use super::wayland_window;
+use super::wayland_window::DecoratedSurface;
+
+#[derive(Clone)]
+pub struct WindowProxy {
+    ctxt: Arc<WaylandContext>,
+    eviter: Arc<Mutex<VecDeque<Event>>>,
+}
+
+impl WindowProxy {
+    #[inline]
+    pub fn wakeup_event_loop(&self) {
+        // Send a sync event, so that any waiting "dispatch" will return
+        self.ctxt.display.sync();
+        self.eviter.lock().unwrap().push_back(Event::Awakened);
+    }
+}
+
+pub struct Window {
+    ctxt: Arc<WaylandContext>,
+    evq: Mutex<EventQueue>,
+    eviter: Arc<Mutex<VecDeque<Event>>>,
+    surface: Arc<wl_surface::WlSurface>,
+    size: Mutex<(u32, u32)>,
+    handler_id: usize,
+    decorated_id: usize
+}
+
+pub struct PollEventsIterator<'a> {
+    window: &'a Window,
+}
+
+impl<'a> Iterator for PollEventsIterator<'a> {
+    type Item = Event;
+
+    fn next(&mut self) -> Option<Event> {
+        self.window.next_event(false)
+    }
+}
+
+pub struct WaitEventsIterator<'a> {
+    window: &'a Window,
+}
+
+impl<'a> Iterator for WaitEventsIterator<'a> {
+    type Item = Event;
+
+    fn next(&mut self) -> Option<Event> {
+        self.window.next_event(true)
+    }
+}
+
+impl Window {
+    pub fn new(ctxt: Arc<WaylandContext>, attributes: &WindowAttributes)  -> Result<Window, CreationError>
+    {
+        let (width, height) = attributes.dimensions.unwrap_or((800,600));
+
+        let mut evq = ctxt.display.create_event_queue();
+
+        let (surface, eviter, decorated) = ctxt.create_window::<DecoratedHandler>();
+
+        // init DecoratedSurface
+        let decorated_id = evq.add_handler_with_init(decorated);
+        {
+            let mut state = evq.state();
+            let decorated = state.get_mut_handler::<DecoratedSurface<DecoratedHandler>>(decorated_id);
+            *(decorated.handler()) = Some(DecoratedHandler::new());
+
+            if let Some(PlatformMonitorId::Wayland(ref monitor_id)) = attributes.monitor {
+                ctxt.with_output(monitor_id.clone(), |output| {
+                    decorated.set_fullscreen(
+                        wl_shell_surface::FullscreenMethod::Default,
+                        0,
+                        Some(output)
+                    )
+                });
+            } else if attributes.decorations {
+                decorated.set_decorate(true);
+            }
+            // Finally, set the decorations size
+            decorated.resize(width as i32, height as i32);
+        }
+
+        // init general handler
+        let handler = WindowHandler::new();
+        let handler_id = evq.add_handler_with_init(handler);
+
+        Ok(Window {
+            ctxt: ctxt,
+            evq: Mutex::new(evq),
+            eviter: eviter,
+            surface: surface,
+            size: Mutex::new((width, height)),
+            handler_id: handler_id,
+            decorated_id: decorated_id
+        })
+    }
+
+    fn process_resize(&self) {
+        use std::cmp::max;
+        let mut evq_guard = self.evq.lock().unwrap();
+        let mut state = evq_guard.state();
+        let newsize = {
+            let decorated = state.get_mut_handler::<DecoratedSurface<DecoratedHandler>>(self.decorated_id);
+            let newsize = decorated.handler().as_mut().and_then(|h| h.take_newsize());
+            if let Some((w, h)) = newsize {
+                decorated.resize(w as i32, h as i32);
+                *self.size.lock().unwrap() = (w, h);
+            }
+            newsize
+        };
+        // callback_resize if any
+        if let Some((w, h)) = newsize {
+            let mut handler = state.get_mut_handler::<WindowHandler>(self.handler_id);
+            if let Some(ref callback) = handler.resize_callback {
+                callback(w, h);
+            }
+            self.eviter.lock().unwrap().push_back(Event::Resized(w,h));
+        }
+    }
+
+    fn next_event(&self, block: bool) -> Option<Event> {
+        let mut evt = {
+            let mut guard = self.eviter.lock().unwrap();
+            guard.pop_front()
+        };
+        if evt.is_some() { return evt }
+
+        // There is no event in the queue, we need to fetch more
+
+        // flush the display
+        self.ctxt.flush();
+
+        // read some events if some are waiting & queue is empty
+        if let Some(guard) = self.evq.lock().unwrap().prepare_read() {
+            guard.read_events();
+        }
+
+        // try a pending dispatch
+        {
+            self.ctxt.dispatch_pending();
+            self.evq.lock().unwrap().dispatch_pending();
+            // some events were dispatched, need to process a potential resising
+            self.process_resize();
+        }
+
+        let mut evt = {
+            let mut guard = self.eviter.lock().unwrap();
+            guard.pop_front()
+        };
+
+        while block && evt.is_none() {
+            // no event waiting, need to repopulate!
+            {
+                self.ctxt.flush();
+                self.ctxt.dispatch();
+                self.evq.lock().unwrap().dispatch_pending();
+                // some events were dispatched, need to process a potential resising
+                self.process_resize();
+            }
+            // try again
+            let mut guard = self.eviter.lock().unwrap();
+            evt = guard.pop_front();
+        }
+        evt
+    }
+
+    pub fn set_title(&self, title: &str) {
+        let mut guard = self.evq.lock().unwrap();
+        let mut state = guard.state();
+        let mut decorated = state.get_mut_handler::<DecoratedSurface<DecoratedHandler>>(self.decorated_id);
+        decorated.set_title(title.into())
+    }
+
+    #[inline]
+    pub fn show(&self) {
+        // TODO
+    }
+
+    #[inline]
+    pub fn hide(&self) {
+        // TODO
+    }
+
+    #[inline]
+    pub fn get_position(&self) -> Option<(i32, i32)> {
+        // Not possible with wayland
+        None
+    }
+
+    #[inline]
+    pub fn set_position(&self, _x: i32, _y: i32) {
+        // Not possible with wayland
+    }
+
+    pub fn get_inner_size(&self) -> Option<(u32, u32)> {
+        Some(self.size.lock().unwrap().clone())
+    }
+
+    #[inline]
+    pub fn get_outer_size(&self) -> Option<(u32, u32)> {
+        let (w, h) = self.size.lock().unwrap().clone();
+        let (w, h) = super::wayland_window::add_borders(w as i32, h as i32);
+        Some((w as u32, h as u32))
+    }
+
+    #[inline]
+    // NOTE: This will only resize the borders, the contents must be updated by the user
+    pub fn set_inner_size(&self, x: u32, y: u32) {
+        let mut guard = self.evq.lock().unwrap();
+        let mut state = guard.state();
+        let mut decorated = state.get_mut_handler::<DecoratedSurface<DecoratedHandler>>(self.decorated_id);
+        decorated.resize(x as i32, y as i32);
+    }
+
+    #[inline]
+    pub fn create_window_proxy(&self) -> WindowProxy {
+        WindowProxy {
+            ctxt: self.ctxt.clone(),
+            eviter: self.eviter.clone()
+        }
+    }
+
+    #[inline]
+    pub fn poll_events(&self) -> PollEventsIterator {
+        PollEventsIterator {
+            window: self
+        }
+    }
+
+    #[inline]
+    pub fn wait_events(&self) -> WaitEventsIterator {
+        WaitEventsIterator {
+            window: self
+        }
+    }
+
+    #[inline]
+    pub fn set_window_resize_callback(&mut self, callback: Option<fn(u32, u32)>) {
+        let mut guard = self.evq.lock().unwrap();
+        let mut state = guard.state();
+        let mut handler = state.get_mut_handler::<WindowHandler>(self.handler_id);
+        handler.resize_callback = callback;
+    }
+
+    #[inline]
+    pub fn set_cursor(&self, _cursor: MouseCursor) {
+        // TODO
+    }
+
+    #[inline]
+    pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
+        use CursorState::{Grab, Normal, Hide};
+        // TODO : not yet possible on wayland to grab cursor
+        match state {
+            Grab => Err("Cursor cannot be grabbed on wayland yet.".to_string()),
+            Hide => Err("Cursor cannot be hidden on wayland yet.".to_string()),
+            Normal => Ok(())
+        }
+    }
+
+    #[inline]
+    pub fn hidpi_factor(&self) -> f32 {
+        // TODO
+        1.0
+    }
+
+    #[inline]
+    pub fn set_cursor_position(&self, _x: i32, _y: i32) -> Result<(), ()> {
+        // TODO: not yet possible on wayland
+        Err(())
+    }
+    
+    pub fn get_display(&self) -> &wl_display::WlDisplay {
+        &self.ctxt.display
+    }
+    
+    pub fn get_surface(&self) -> &wl_surface::WlSurface {
+        &self.surface
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        self.surface.destroy();
+        self.ctxt.prune_dead_windows();
+    }
+}
+
+struct DecoratedHandler {
+    newsize: Option<(u32, u32)>
+}
+
+impl DecoratedHandler {
+    fn new() -> DecoratedHandler { DecoratedHandler { newsize: None }}
+    fn take_newsize(&mut self) -> Option<(u32, u32)> {
+        self.newsize.take()
+    }
+}
+
+impl wayland_window::Handler for DecoratedHandler {
+    fn configure(&mut self,
+                 _: &mut EventQueueHandle,
+                 _: wl_shell_surface::Resize,
+                 width: i32, height: i32)
+    {
+        use std::cmp::max;
+        self.newsize = Some((max(width,1) as u32, max(height,1) as u32));
+    }
+}
+
+struct WindowHandler {
+    my_id: usize,
+    resize_callback: Option<fn(u32,u32)>,
+}
+
+impl WindowHandler {
+    fn new() -> WindowHandler {
+        WindowHandler {
+            my_id: 0,
+            resize_callback: None
+        }
+    }
+}
+
+impl Init for WindowHandler {
+    fn init(&mut self, evqh: &mut EventQueueHandle, index: usize) {
+        self.my_id = index;
+    }
+}

src/platform/linux/x11/ffi.rs

@@ -0,0 +1,8 @@
+pub use x11_dl::keysym::*;
+pub use x11_dl::xcursor::*;
+pub use x11_dl::xf86vmode::*;
+pub use x11_dl::xlib::*;
+pub use x11_dl::xinput::*;
+pub use x11_dl::xinput2::*;
+pub use x11_dl::xlib_xcb::*;
+pub use x11_dl::error::OpenError;

src/platform/linux/x11/input.rs

@@ -0,0 +1,391 @@
+use std::sync::Arc;
+
+use libc;
+use std::{mem, ptr};
+use std::ffi::CString;
+use std::slice::from_raw_parts;
+
+use WindowAttributes;
+
+use events::WindowEvent as Event;
+use events::ModifiersState;
+
+use super::{events, ffi};
+use super::XConnection;
+
+#[derive(Debug)]
+enum AxisType {
+    HorizontalScroll,
+    VerticalScroll
+}
+
+#[derive(Debug)]
+struct Axis {
+    id: i32,
+    device_id: i32,
+    axis_number: i32,
+    axis_type: AxisType,
+    scroll_increment: f64,
+}
+
+#[derive(Debug)]
+struct AxisValue {
+    device_id: i32,
+    axis_number: i32,
+    value: f64
+}
+
+struct InputState {
+    /// Last-seen cursor position within a window in (x, y)
+    /// coordinates
+    cursor_pos: (f64, f64),
+    /// Last-seen positions of axes, used to report delta
+    /// movements when a new absolute axis value is received
+    axis_values: Vec<AxisValue>
+}
+
+pub struct XInputEventHandler {
+    display: Arc<XConnection>,
+    window: ffi::Window,
+    ic: ffi::XIC,
+    axis_list: Vec<Axis>,
+    current_state: InputState,
+    multitouch: bool,
+}
+
+impl XInputEventHandler {
+    pub fn new(display: &Arc<XConnection>, window: ffi::Window, ic: ffi::XIC,
+               window_attrs: &WindowAttributes) -> XInputEventHandler {
+        // query XInput support
+        let mut opcode: libc::c_int = 0;
+        let mut event: libc::c_int = 0;
+        let mut error: libc::c_int = 0;
+        let xinput_str = CString::new("XInputExtension").unwrap();
+
+        unsafe {
+            if (display.xlib.XQueryExtension)(display.display, xinput_str.as_ptr(), &mut opcode, &mut event, &mut error) == ffi::False {
+                panic!("XInput not available")
+            }
+        }
+
+        let mut xinput_major_ver = ffi::XI_2_Major;
+        let mut xinput_minor_ver = ffi::XI_2_Minor;
+
+        unsafe {
+            if (display.xinput2.XIQueryVersion)(display.display, &mut xinput_major_ver, &mut xinput_minor_ver) != ffi::Success as libc::c_int {
+                panic!("Unable to determine XInput version");
+            }
+        }
+
+        // specify the XInput events we want to receive.
+        // Button clicks and mouse events are handled via XInput
+        // events. Key presses are still handled via plain core
+        // X11 events.
+        let mut mask: [libc::c_uchar; 3] = [0; 3];
+        let mut input_event_mask = ffi::XIEventMask {
+            deviceid: ffi::XIAllMasterDevices,
+            mask_len: mask.len() as i32,
+            mask: mask.as_mut_ptr()
+        };
+        let events = &[
+            ffi::XI_ButtonPress,
+            ffi::XI_ButtonRelease,
+            ffi::XI_Motion,
+            ffi::XI_Enter,
+            ffi::XI_Leave,
+            ffi::XI_FocusIn,
+            ffi::XI_FocusOut,
+            ffi::XI_TouchBegin,
+            ffi::XI_TouchUpdate,
+            ffi::XI_TouchEnd,
+        ];
+        for event in events {
+            ffi::XISetMask(&mut mask, *event);
+        }
+
+        unsafe {
+            match (display.xinput2.XISelectEvents)(display.display, window, &mut input_event_mask, 1) {
+                status if status as u8 == ffi::Success => (),
+                err => panic!("Failed to select events {:?}", err)
+            }
+        }
+
+        XInputEventHandler {
+            display: display.clone(),
+            window: window,
+            ic: ic,
+            axis_list: read_input_axis_info(display),
+            current_state: InputState {
+                cursor_pos: (0.0, 0.0),
+                axis_values: Vec::new()
+            },
+            multitouch: window_attrs.multitouch,
+        }
+    }
+
+    pub fn translate_key_event(&self, event: &mut ffi::XKeyEvent) -> Vec<Event> {
+        use events::WindowEvent::{KeyboardInput, ReceivedCharacter};
+        use events::ElementState::{Pressed, Released};
+
+        let mut translated_events = Vec::new();
+
+        let state;
+        if event.type_ == ffi::KeyPress {
+            let raw_ev: *mut ffi::XKeyEvent = event;
+            unsafe { (self.display.xlib.XFilterEvent)(mem::transmute(raw_ev), self.window) };
+            state = Pressed;
+        } else {
+            state = Released;
+        }
+
+        let mut kp_keysym = 0;
+
+        let mut ev_mods = ModifiersState::default();
+
+        let written = unsafe {
+            use std::str;
+
+            let mut buffer: [u8; 16] = [mem::uninitialized(); 16];
+            let raw_ev: *mut ffi::XKeyEvent = event;
+            let count = (self.display.xlib.Xutf8LookupString)(self.ic, mem::transmute(raw_ev),
+            mem::transmute(buffer.as_mut_ptr()),
+            buffer.len() as libc::c_int, &mut kp_keysym, ptr::null_mut());
+
+            {
+                // Translate x event state to mods
+                let state = event.state;
+                if (state & ffi::Mod1Mask) != 0 {
+                    ev_mods.alt = true;
+                }
+
+                if (state & ffi::ShiftMask) != 0 {
+                    ev_mods.shift = true;
+                }
+
+                if (state & ffi::ControlMask) != 0 {
+                    ev_mods.ctrl = true;
+                }
+
+                if (state & ffi::Mod4Mask) != 0 {
+                    ev_mods.logo = true;
+                }
+            }
+
+            str::from_utf8(&buffer[..count as usize]).unwrap_or("").to_string()
+        };
+
+        for chr in written.chars() {
+            translated_events.push(ReceivedCharacter(chr));
+        }
+
+        let mut keysym = unsafe {
+            (self.display.xlib.XKeycodeToKeysym)(self.display.display, event.keycode as ffi::KeyCode, 0)
+        };
+
+        if (ffi::XK_KP_Space as libc::c_ulong <= keysym) && (keysym <= ffi::XK_KP_9 as libc::c_ulong) {
+            keysym = kp_keysym
+        };
+
+        let vkey = events::keycode_to_element(keysym as libc::c_uint);
+
+        translated_events.push(KeyboardInput(state, event.keycode as u8, vkey, ev_mods));
+        translated_events
+    }
+
+    pub fn translate_event(&mut self, cookie: &ffi::XGenericEventCookie) -> Option<Event> {
+        use events::WindowEvent::{Focused, MouseEntered, MouseInput, MouseLeft, MouseMoved, MouseWheel};
+        use events::ElementState::{Pressed, Released};
+        use events::MouseButton::{Left, Right, Middle};
+        use events::MouseScrollDelta::LineDelta;
+        use events::{Touch, TouchPhase};
+
+        match cookie.evtype {
+            ffi::XI_ButtonPress | ffi::XI_ButtonRelease => {
+                let event_data: &ffi::XIDeviceEvent = unsafe{mem::transmute(cookie.data)};
+                if self.multitouch && (event_data.flags & ffi::XIPointerEmulated) != 0 {
+                    // Deliver multi-touch events instead of emulated mouse events.
+                    return None
+                }
+                let state = if cookie.evtype == ffi::XI_ButtonPress {
+                    Pressed
+                } else {
+                    Released
+                };
+                match event_data.detail as u32 {
+                    ffi::Button1 => Some(MouseInput(state, Left)),
+                    ffi::Button2 => Some(MouseInput(state, Middle)),
+                    ffi::Button3 => Some(MouseInput(state, Right)),
+                    ffi::Button4 | ffi::Button5 => {
+                        if event_data.flags & ffi::XIPointerEmulated == 0 {
+                            // scroll event from a traditional wheel with
+                            // distinct 'clicks'
+                            let delta = if event_data.detail as u32 == ffi::Button4 {
+                                1.0
+                            } else {
+                                -1.0
+                            };
+                            Some(MouseWheel(LineDelta(0.0, delta), TouchPhase::Moved))
+                        } else {
+                            // emulated button event from a touch/smooth-scroll
+                            // event. Ignore these events and handle scrolling
+                            // via XI_Motion event handler instead
+                            None
+                        }
+                    }
+                    _ => None
+                }
+            },
+            ffi::XI_Motion => {
+                let event_data: &ffi::XIDeviceEvent = unsafe{mem::transmute(cookie.data)};
+                if self.multitouch && (event_data.flags & ffi::XIPointerEmulated) != 0 {
+                    // Deliver multi-touch events instead of emulated mouse events.
+                    return None
+                }
+                let axis_state = event_data.valuators;
+                let mask = unsafe{ from_raw_parts(axis_state.mask, axis_state.mask_len as usize) };
+                let mut axis_count = 0;
+
+                let mut scroll_delta = (0.0, 0.0);
+                for axis_id in 0..axis_state.mask_len {
+                    if ffi::XIMaskIsSet(&mask, axis_id) {
+                        let axis_value = unsafe{*axis_state.values.offset(axis_count)};
+                        let delta = calc_scroll_deltas(event_data, axis_id, axis_value, &self.axis_list,
+                                                       &mut self.current_state.axis_values);
+                        scroll_delta.0 += delta.0;
+                        scroll_delta.1 += delta.1;
+                        axis_count += 1;
+                    }
+                }
+
+                if scroll_delta.0.abs() > 0.0 || scroll_delta.1.abs() > 0.0 {
+                    Some(MouseWheel(LineDelta(scroll_delta.0 as f32, scroll_delta.1 as f32),
+                                    TouchPhase::Moved))
+                } else {
+                    let new_cursor_pos = (event_data.event_x, event_data.event_y);
+                    if new_cursor_pos != self.current_state.cursor_pos {
+                        self.current_state.cursor_pos = new_cursor_pos;
+                        Some(MouseMoved(new_cursor_pos.0 as i32, new_cursor_pos.1 as i32))
+                    } else {
+                        None
+                    }
+                }
+            },
+            ffi::XI_Enter => {
+                // axis movements whilst the cursor is outside the window
+                // will alter the absolute value of the axes. We only want to
+                // report changes in the axis value whilst the cursor is above
+                // our window however, so clear the previous axis state whenever
+                // the cursor re-enters the window
+                self.current_state.axis_values.clear();
+                Some(MouseEntered)
+            },
+            ffi::XI_Leave => Some(MouseLeft),
+            ffi::XI_FocusIn => Some(Focused(true)),
+            ffi::XI_FocusOut => Some(Focused(false)),
+            ffi::XI_TouchBegin | ffi::XI_TouchUpdate | ffi::XI_TouchEnd => {
+                if !self.multitouch {
+                    return None
+                }
+                let event_data: &ffi::XIDeviceEvent = unsafe{mem::transmute(cookie.data)};
+                let phase = match cookie.evtype {
+                    ffi::XI_TouchBegin => TouchPhase::Started,
+                    ffi::XI_TouchUpdate => TouchPhase::Moved,
+                    ffi::XI_TouchEnd => TouchPhase::Ended,
+                    _ => unreachable!()
+                };
+                Some(Event::Touch(Touch {
+                    phase: phase,
+                    location: (event_data.event_x, event_data.event_y),
+                    id: event_data.detail as u64,
+                }))
+            }
+            _ => None
+        }
+    }
+}
+
+fn read_input_axis_info(display: &Arc<XConnection>) -> Vec<Axis> {
+    let mut axis_list = Vec::new();
+    let mut device_count = 0;
+
+    // Check all input devices for scroll axes.
+    let devices = unsafe{
+        (display.xinput2.XIQueryDevice)(display.display, ffi::XIAllDevices, &mut device_count)
+    };
+    for i in 0..device_count {
+        let device = unsafe { *(devices.offset(i as isize)) };
+        for k in 0..device.num_classes {
+            let class = unsafe { *(device.classes.offset(k as isize)) };
+            match unsafe { (*class)._type } {
+                // Note that scroll axis
+                // are reported both as 'XIScrollClass' and 'XIValuatorClass'
+                // axes. For the moment we only care about scrolling axes.
+                ffi::XIScrollClass => {
+                    let scroll_class: &ffi::XIScrollClassInfo = unsafe{mem::transmute(class)};
+                    axis_list.push(Axis{
+                        id: scroll_class.sourceid,
+                        device_id: device.deviceid,
+                        axis_number: scroll_class.number,
+                        axis_type: match scroll_class.scroll_type {
+                            ffi::XIScrollTypeHorizontal => AxisType::HorizontalScroll,
+                            ffi::XIScrollTypeVertical => AxisType::VerticalScroll,
+                            _ => { unreachable!() }
+                        },
+                        scroll_increment: scroll_class.increment,
+                    })
+                },
+                _ => {}
+            }
+        }
+    }
+
+    unsafe {
+        (display.xinput2.XIFreeDeviceInfo)(devices);
+    }
+
+    axis_list
+}
+
+/// Given an input motion event for an axis and the previous
+/// state of the axes, return the horizontal/vertical
+/// scroll deltas
+fn calc_scroll_deltas(event: &ffi::XIDeviceEvent,
+                     axis_id: i32,
+                     axis_value: f64,
+                     axis_list: &[Axis],
+                     prev_axis_values: &mut Vec<AxisValue>) -> (f64, f64) {
+    let prev_value_pos = prev_axis_values.iter().position(|prev_axis| {
+        prev_axis.device_id == event.sourceid &&
+            prev_axis.axis_number == axis_id
+    });
+    let delta = match prev_value_pos {
+        Some(idx) => prev_axis_values[idx].value - axis_value,
+        None => 0.0
+    };
+
+    let new_axis_value = AxisValue{
+        device_id: event.sourceid,
+        axis_number: axis_id,
+        value: axis_value
+    };
+
+    match prev_value_pos {
+        Some(idx) => prev_axis_values[idx] = new_axis_value,
+        None => prev_axis_values.push(new_axis_value)
+    }
+
+    let mut scroll_delta = (0.0, 0.0);
+
+    for axis in axis_list.iter() {
+        if axis.id == event.sourceid &&
+            axis.axis_number == axis_id {
+                match axis.axis_type {
+                    AxisType::HorizontalScroll => scroll_delta.0 = delta / axis.scroll_increment,
+                    AxisType::VerticalScroll => scroll_delta.1 = delta / axis.scroll_increment
+                }
+            }
+    }
+
+    scroll_delta
+}
+

src/platform/linux/x11/mod.rs

@@ -0,0 +1,13 @@
+#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+
+pub use self::monitor::{MonitorId, get_available_monitors, get_primary_monitor};
+pub use self::window::{Window, XWindow, PollEventsIterator, WaitEventsIterator, WindowProxy};
+pub use self::xdisplay::{XConnection, XNotSupported, XError};
+
+pub mod ffi;
+
+mod events;
+mod input;
+mod monitor;
+mod window;
+mod xdisplay;

src/platform/linux/x11/monitor.rs

@@ -0,0 +1,44 @@
+use std::collections::VecDeque;
+use std::sync::Arc;
+
+use super::XConnection;
+use native_monitor::NativeMonitorId;
+
+#[derive(Clone)]
+pub struct MonitorId(pub Arc<XConnection>, pub u32);
+
+pub fn get_available_monitors(x: &Arc<XConnection>) -> VecDeque<MonitorId> {
+    let nb_monitors = unsafe { (x.xlib.XScreenCount)(x.display) };
+    x.check_errors().expect("Failed to call XScreenCount");
+
+    let mut monitors = VecDeque::new();
+    monitors.extend((0 .. nb_monitors).map(|i| MonitorId(x.clone(), i as u32)));
+    monitors
+}
+
+#[inline]
+pub fn get_primary_monitor(x: &Arc<XConnection>) -> MonitorId {
+    let primary_monitor = unsafe { (x.xlib.XDefaultScreen)(x.display) };
+    x.check_errors().expect("Failed to call XDefaultScreen");
+    MonitorId(x.clone(), primary_monitor as u32)
+}
+
+impl MonitorId {
+    pub fn get_name(&self) -> Option<String> {
+        let MonitorId(_, screen_num) = *self;
+        Some(format!("Monitor #{}", screen_num))
+    }
+
+    #[inline]
+    pub fn get_native_identifier(&self) -> NativeMonitorId {
+        NativeMonitorId::Numeric(self.1)
+    }
+
+    pub fn get_dimensions(&self) -> (u32, u32) {
+        let screen = unsafe { (self.0.xlib.XScreenOfDisplay)(self.0.display, self.1 as i32) };
+        let width = unsafe { (self.0.xlib.XWidthOfScreen)(screen) };
+        let height = unsafe { (self.0.xlib.XHeightOfScreen)(screen) };
+        self.0.check_errors().expect("Failed to get monitor dimensions");
+        (width as u32, height as u32)
+    }
+}

src/platform/linux/x11/window.rs

@@ -0,0 +1,976 @@
+use {WindowEvent as Event, MouseCursor};
+use CreationError;
+use CreationError::OsError;
+use libc;
+use std::borrow::Borrow;
+use std::{mem, ptr, cmp};
+use std::cell::Cell;
+use std::sync::atomic::AtomicBool;
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+use std::os::raw::c_long;
+use std::thread;
+use std::time::Duration;
+
+use CursorState;
+use WindowAttributes;
+use platform::PlatformSpecificWindowBuilderAttributes;
+
+use platform::MonitorId as PlatformMonitorId;
+
+use super::input::XInputEventHandler;
+use super::{ffi};
+use super::{MonitorId, XConnection};
+
+// XOpenIM doesn't seem to be thread-safe
+lazy_static! {      // TODO: use a static mutex when that's possible, and put me back in my function
+    static ref GLOBAL_XOPENIM_LOCK: Mutex<()> = Mutex::new(());
+}
+
+// TODO: remove me
+fn with_c_str<F, T>(s: &str, f: F) -> T where F: FnOnce(*const libc::c_char) -> T {
+    use std::ffi::CString;
+    let c_str = CString::new(s.as_bytes().to_vec()).unwrap();
+    f(c_str.as_ptr())
+}
+
+struct WindowProxyData {
+    display: Arc<XConnection>,
+    window: ffi::Window,
+}
+
+unsafe impl Send for WindowProxyData {}
+
+pub struct XWindow {
+    display: Arc<XConnection>,
+    window: ffi::Window,
+    is_fullscreen: bool,
+    screen_id: libc::c_int,
+    xf86_desk_mode: Option<ffi::XF86VidModeModeInfo>,
+    ic: ffi::XIC,
+    im: ffi::XIM,
+    window_proxy_data: Arc<Mutex<Option<WindowProxyData>>>,
+}
+
+unsafe impl Send for XWindow {}
+unsafe impl Sync for XWindow {}
+
+unsafe impl Send for Window {}
+unsafe impl Sync for Window {}
+
+impl Drop for XWindow {
+    fn drop(&mut self) {
+        unsafe {
+            // Clear out the window proxy data arc, so that any window proxy objects
+            // are no longer able to send messages to this window.
+            *self.window_proxy_data.lock().unwrap() = None;
+
+            let _lock = GLOBAL_XOPENIM_LOCK.lock().unwrap();
+
+            if self.is_fullscreen {
+                if let Some(mut xf86_desk_mode) = self.xf86_desk_mode {
+                    (self.display.xf86vmode.XF86VidModeSwitchToMode)(self.display.display, self.screen_id, &mut xf86_desk_mode);
+                }
+                (self.display.xf86vmode.XF86VidModeSetViewPort)(self.display.display, self.screen_id, 0, 0);
+            }
+
+            (self.display.xlib.XDestroyIC)(self.ic);
+            (self.display.xlib.XCloseIM)(self.im);
+            (self.display.xlib.XDestroyWindow)(self.display.display, self.window);
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct WindowProxy {
+    data: Arc<Mutex<Option<WindowProxyData>>>,
+}
+
+impl WindowProxy {
+    pub fn wakeup_event_loop(&self) {
+        let window_proxy_data = self.data.lock().unwrap();
+
+        if let Some(ref data) = *window_proxy_data {
+            let mut xev = ffi::XClientMessageEvent {
+                type_: ffi::ClientMessage,
+                window: data.window,
+                format: 32,
+                message_type: 0,
+                serial: 0,
+                send_event: 0,
+                display: data.display.display,
+                data: unsafe { mem::zeroed() },
+            };
+
+            unsafe {
+                (data.display.xlib.XSendEvent)(data.display.display, data.window, 0, 0, mem::transmute(&mut xev));
+                (data.display.xlib.XFlush)(data.display.display);
+                data.display.check_errors().expect("Failed to call XSendEvent after wakeup");
+            }
+        }
+    }
+}
+
+// XEvents of type GenericEvent store their actual data
+// in an XGenericEventCookie data structure. This is a wrapper
+// to extract the cookie from a GenericEvent XEvent and release
+// the cookie data once it has been processed
+struct GenericEventCookie<'a> {
+    display: &'a XConnection,
+    cookie: ffi::XGenericEventCookie
+}
+
+impl<'a> GenericEventCookie<'a> {
+    fn from_event<'b>(display: &'b XConnection, event: ffi::XEvent) -> Option<GenericEventCookie<'b>> {
+        unsafe {
+            let mut cookie: ffi::XGenericEventCookie = From::from(event);
+            if (display.xlib.XGetEventData)(display.display, &mut cookie) == ffi::True {
+                Some(GenericEventCookie{display: display, cookie: cookie})
+            } else {
+                None
+            }
+        }
+    }
+}
+
+impl<'a> Drop for GenericEventCookie<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            let xlib = &self.display.xlib;
+            (xlib.XFreeEventData)(self.display.display, &mut self.cookie);
+        }
+    }
+}
+
+pub struct PollEventsIterator<'a> {
+    window: &'a Window
+}
+
+impl<'a> Iterator for PollEventsIterator<'a> {
+    type Item = Event;
+
+    fn next(&mut self) -> Option<Event> {
+        let xlib = &self.window.x.display.xlib;
+
+        loop {
+            if let Some(ev) = self.window.pending_events.lock().unwrap().pop_front() {
+                return Some(ev);
+            }
+
+            let mut xev = unsafe { mem::uninitialized() };
+
+            // Get the next X11 event. XNextEvent will block if there's no
+            // events available; checking the count first ensures an event will
+            // be returned without blocking.
+            //
+            // Functions like XCheckTypedEvent can prevent events from being
+            // popped if they are of the wrong type in which case winit would
+            // enter a busy loop. To avoid that, XNextEvent is used to pop
+            // events off the queue since it will accept any event type.
+            unsafe {
+                let count = (xlib.XPending)(self.window.x.display.display);
+                if count == 0 {
+                    return None;
+                }
+
+                let res = (xlib.XNextEvent)(self.window.x.display.display, &mut xev);
+
+                // Can res ever be none zero if count is > 0?
+                assert!(res == 0);
+            };
+
+            match xev.get_type() {
+                ffi::MappingNotify => {
+                    unsafe { (xlib.XRefreshKeyboardMapping)(mem::transmute(&xev)); }
+                    self.window.x.display.check_errors().expect("Failed to call XRefreshKeyboardMapping");
+                },
+
+                ffi::ClientMessage => {
+                    use events::WindowEvent::{Closed, Awakened};
+                    use std::sync::atomic::Ordering::Relaxed;
+
+                    let client_msg: &ffi::XClientMessageEvent = unsafe { mem::transmute(&xev) };
+
+                    if client_msg.data.get_long(0) == self.window.wm_delete_window as libc::c_long {
+                        self.window.is_closed.store(true, Relaxed);
+                        return Some(Closed);
+                    } else {
+                        return Some(Awakened);
+                    }
+                },
+
+                ffi::ConfigureNotify => {
+                    use events::WindowEvent::Resized;
+                    let cfg_event: &ffi::XConfigureEvent = unsafe { mem::transmute(&xev) };
+                    let (current_width, current_height) = self.window.current_size.get();
+                    if current_width != cfg_event.width || current_height != cfg_event.height {
+                        self.window.current_size.set((cfg_event.width, cfg_event.height));
+                        return Some(Resized(cfg_event.width as u32, cfg_event.height as u32));
+                    }
+                },
+
+                ffi::Expose => {
+                    use events::WindowEvent::Refresh;
+                    return Some(Refresh);
+                },
+
+                ffi::KeyPress | ffi::KeyRelease => {
+                    let mut event: &mut ffi::XKeyEvent = unsafe { mem::transmute(&mut xev) };
+                    let events = self.window.input_handler.lock().unwrap().translate_key_event(&mut event);
+                    for event in events {
+                        self.window.pending_events.lock().unwrap().push_back(event);
+                    }
+                },
+
+                ffi::GenericEvent => {
+                    if let Some(cookie) = GenericEventCookie::from_event(self.window.x.display.borrow(), xev) {
+                        match cookie.cookie.evtype {
+                            ffi::XI_DeviceChanged...ffi::XI_LASTEVENT => {
+                                match self.window.input_handler.lock() {
+                                    Ok(mut handler) => {
+                                        match handler.translate_event(&cookie.cookie) {
+                                            Some(event) => self.window.pending_events.lock().unwrap().push_back(event),
+                                            None => {}
+                                        }
+                                    },
+                                    Err(_) => {}
+                                }
+                            },
+                            _ => {}
+                        }
+                    }
+                }
+
+                _ => {}
+            };
+        }
+    }
+}
+
+pub struct WaitEventsIterator<'a> {
+    window: &'a Window,
+}
+
+impl<'a> Iterator for WaitEventsIterator<'a> {
+    type Item = Event;
+
+    fn next(&mut self) -> Option<Event> {
+        use std::sync::atomic::Ordering::Relaxed;
+        use std::mem;
+
+        while !self.window.is_closed.load(Relaxed) {
+            if let Some(ev) = self.window.pending_events.lock().unwrap().pop_front() {
+                return Some(ev);
+            }
+
+            // this will block until an event arrives, but doesn't remove
+            // it from the queue
+            let mut xev = unsafe { mem::uninitialized() };
+            unsafe { (self.window.x.display.xlib.XPeekEvent)(self.window.x.display.display, &mut xev) };
+            self.window.x.display.check_errors().expect("Failed to call XPeekEvent");
+
+            // calling poll_events()
+            if let Some(ev) = self.window.poll_events().next() {
+                return Some(ev);
+            }
+        }
+
+        None
+    }
+}
+
+pub struct Window {
+    pub x: Arc<XWindow>,
+    is_closed: AtomicBool,
+    wm_delete_window: ffi::Atom,
+    current_size: Cell<(libc::c_int, libc::c_int)>,
+    /// Events that have been retreived with XLib but not dispatched with iterators yet
+    pending_events: Mutex<VecDeque<Event>>,
+    cursor_state: Mutex<CursorState>,
+    input_handler: Mutex<XInputEventHandler>
+}
+
+impl Window {
+    pub fn new(display: &Arc<XConnection>, window_attrs: &WindowAttributes,
+               pl_attribs: &PlatformSpecificWindowBuilderAttributes)
+               -> Result<Window, CreationError>
+    {
+        let dimensions = {
+
+            // x11 only applies constraints when the window is actively resized
+            // by the user, so we have to manually apply the initial constraints
+            let mut dimensions = window_attrs.dimensions.unwrap_or((800, 600));
+            if let Some(max) = window_attrs.max_dimensions {
+                dimensions.0 = cmp::min(dimensions.0, max.0);
+                dimensions.1 = cmp::min(dimensions.1, max.1);
+            }
+
+            if let Some(min) = window_attrs.min_dimensions {
+                dimensions.0 = cmp::max(dimensions.0, min.0);
+                dimensions.1 = cmp::max(dimensions.1, min.1);
+            }
+            dimensions
+
+        };
+
+        let screen_id = match pl_attribs.screen_id {
+            Some(id) => id,
+            None => match window_attrs.monitor {
+                Some(PlatformMonitorId::X(MonitorId(_, monitor))) => monitor as i32,
+                _ => unsafe { (display.xlib.XDefaultScreen)(display.display) },
+            }
+        };
+
+        // finding the mode to switch to if necessary
+        let (mode_to_switch_to, xf86_desk_mode) = unsafe {
+            let mut mode_num: libc::c_int = mem::uninitialized();
+            let mut modes: *mut *mut ffi::XF86VidModeModeInfo = mem::uninitialized();
+            if (display.xf86vmode.XF86VidModeGetAllModeLines)(display.display, screen_id, &mut mode_num, &mut modes) == 0 {
+                (None, None)
+            } else {
+                let xf86_desk_mode: ffi::XF86VidModeModeInfo = ptr::read(*modes.offset(0));
+                let mode_to_switch_to = if window_attrs.monitor.is_some() {
+                    let matching_mode = (0 .. mode_num).map(|i| {
+                        let m: ffi::XF86VidModeModeInfo = ptr::read(*modes.offset(i as isize) as *const _); m
+                    }).find(|m| m.hdisplay == dimensions.0 as u16 && m.vdisplay == dimensions.1 as u16);
+                    if let Some(matching_mode) = matching_mode {
+                        Some(matching_mode)
+                    } else {
+                        let m = (0 .. mode_num).map(|i| {
+                            let m: ffi::XF86VidModeModeInfo = ptr::read(*modes.offset(i as isize) as *const _); m
+                        }).find(|m| m.hdisplay >= dimensions.0 as u16 && m.vdisplay >= dimensions.1 as u16);
+
+                        match m {
+                            Some(m) => Some(m),
+                            None => return Err(OsError(format!("Could not find a suitable graphics mode")))
+                        }
+                    }
+                } else {
+                    None
+                };
+                (display.xlib.XFree)(modes as *mut _);
+                (mode_to_switch_to, Some(xf86_desk_mode))
+            }
+        };
+
+        // getting the root window
+        let root = unsafe { (display.xlib.XDefaultRootWindow)(display.display) };
+        display.check_errors().expect("Failed to get root window");
+
+        // creating
+        let mut set_win_attr = {
+            let mut swa: ffi::XSetWindowAttributes = unsafe { mem::zeroed() };
+            swa.colormap = if let Some(vi) = pl_attribs.visual_infos {
+                unsafe {
+                    let visual = vi.visual;
+                    (display.xlib.XCreateColormap)(display.display, root, visual, ffi::AllocNone)
+                }
+            } else { 0 };
+            swa.event_mask = ffi::ExposureMask | ffi::StructureNotifyMask |
+                ffi::VisibilityChangeMask | ffi::KeyPressMask | ffi::PointerMotionMask |
+                ffi::KeyReleaseMask | ffi::ButtonPressMask |
+                ffi::ButtonReleaseMask | ffi::KeymapStateMask;
+            swa.border_pixel = 0;
+            if window_attrs.transparent {
+                swa.background_pixel = 0;
+            }
+            swa.override_redirect = 0;
+            swa
+        };
+
+        let mut window_attributes = ffi::CWBorderPixel | ffi::CWColormap | ffi::CWEventMask;
+
+        if window_attrs.transparent {
+            window_attributes |= ffi::CWBackPixel;
+        }
+
+        // finally creating the window
+        let window = unsafe {
+            let win = (display.xlib.XCreateWindow)(display.display, root, 0, 0, dimensions.0 as libc::c_uint,
+                dimensions.1 as libc::c_uint, 0,
+                match pl_attribs.visual_infos {
+                    Some(vi) => vi.depth,
+                    None => ffi::CopyFromParent
+                },
+                ffi::InputOutput as libc::c_uint,
+                match pl_attribs.visual_infos {
+                    Some(vi) => vi.visual,
+                    None => ffi::CopyFromParent as *mut _
+                },
+                window_attributes,
+                &mut set_win_attr);
+            display.check_errors().expect("Failed to call XCreateWindow");
+            win
+        };
+
+        // set visibility
+        if window_attrs.visible {
+            unsafe {
+                (display.xlib.XMapRaised)(display.display, window);
+                (display.xlib.XFlush)(display.display);
+            }
+
+            display.check_errors().expect("Failed to set window visibility");
+        }
+
+        // creating window, step 2
+        let wm_delete_window = unsafe {
+            let mut wm_delete_window = with_c_str("WM_DELETE_WINDOW", |delete_window|
+                (display.xlib.XInternAtom)(display.display, delete_window, 0)
+            );
+            display.check_errors().expect("Failed to call XInternAtom");
+            (display.xlib.XSetWMProtocols)(display.display, window, &mut wm_delete_window, 1);
+            display.check_errors().expect("Failed to call XSetWMProtocols");
+            (display.xlib.XFlush)(display.display);
+            display.check_errors().expect("Failed to call XFlush");
+
+            wm_delete_window
+        };
+
+        // creating IM
+        let im = unsafe {
+            let _lock = GLOBAL_XOPENIM_LOCK.lock().unwrap();
+
+            let im = (display.xlib.XOpenIM)(display.display, ptr::null_mut(), ptr::null_mut(), ptr::null_mut());
+            if im.is_null() {
+                return Err(OsError(format!("XOpenIM failed")));
+            }
+            im
+        };
+
+        // creating input context
+        let ic = unsafe {
+            let ic = with_c_str("inputStyle", |input_style|
+                with_c_str("clientWindow", |client_window|
+                    (display.xlib.XCreateIC)(
+                        im, input_style,
+                        ffi::XIMPreeditNothing | ffi::XIMStatusNothing, client_window,
+                        window, ptr::null::<()>()
+                    )
+                )
+            );
+            if ic.is_null() {
+                return Err(OsError(format!("XCreateIC failed")));
+            }
+            (display.xlib.XSetICFocus)(ic);
+            display.check_errors().expect("Failed to call XSetICFocus");
+            ic
+        };
+
+        // Attempt to make keyboard input repeat detectable
+        unsafe {
+            let mut supported_ptr = ffi::False;
+            (display.xlib.XkbSetDetectableAutoRepeat)(display.display, ffi::True, &mut supported_ptr);
+            if supported_ptr == ffi::False {
+                return Err(OsError(format!("XkbSetDetectableAutoRepeat failed")));
+            }
+        }
+
+        // Set ICCCM WM_CLASS property based on initial window title
+        unsafe {
+            with_c_str(&*window_attrs.title, |c_name| {
+                let hint = (display.xlib.XAllocClassHint)();
+                (*hint).res_name = c_name as *mut libc::c_char;
+                (*hint).res_class = c_name as *mut libc::c_char;
+                (display.xlib.XSetClassHint)(display.display, window, hint);
+                display.check_errors().expect("Failed to call XSetClassHint");
+                (display.xlib.XFree)(hint as *mut _);
+            });
+        }
+
+        let is_fullscreen = window_attrs.monitor.is_some();
+
+        if is_fullscreen {
+            let state_atom = unsafe {
+                with_c_str("_NET_WM_STATE", |state|
+                    (display.xlib.XInternAtom)(display.display, state, 0)
+                )
+            };
+            display.check_errors().expect("Failed to call XInternAtom");
+            let fullscreen_atom = unsafe {
+                with_c_str("_NET_WM_STATE_FULLSCREEN", |state_fullscreen|
+                    (display.xlib.XInternAtom)(display.display, state_fullscreen, 0)
+                )
+            };
+            display.check_errors().expect("Failed to call XInternAtom");
+
+            let client_message_event = ffi::XClientMessageEvent {
+                type_: ffi::ClientMessage,
+                serial: 0,
+                send_event: 1,            // true because we are sending this through `XSendEvent`
+                display: display.display,
+                window: window,
+                message_type: state_atom, // the _NET_WM_STATE atom is sent to change the state of a window
+                format: 32,               // view `data` as `c_long`s
+                data: {
+                    let mut data = ffi::ClientMessageData::new();
+                    // This first `long` is the action; `1` means add/set following property.
+                    data.set_long(0, 1);
+                    // This second `long` is the property to set (fullscreen)
+                    data.set_long(1, fullscreen_atom as c_long);
+                    data
+                }
+            };
+            let mut x_event = ffi::XEvent::from(client_message_event);
+
+            unsafe {
+                (display.xlib.XSendEvent)(
+                    display.display,
+                    root,
+                    0,
+                    ffi::SubstructureRedirectMask | ffi::SubstructureNotifyMask,
+                    &mut x_event as *mut _
+                );
+                display.check_errors().expect("Failed to call XSendEvent");
+            }
+
+            if let Some(mut mode_to_switch_to) = mode_to_switch_to {
+                unsafe {
+                    (display.xf86vmode.XF86VidModeSwitchToMode)(
+                        display.display,
+                        screen_id,
+                        &mut mode_to_switch_to
+                    );
+                    display.check_errors().expect("Failed to call XF86VidModeSwitchToMode");
+                }
+            }
+            else {
+                println!("[glutin] Unexpected state: `mode` is None creating fullscreen window");
+            }
+            unsafe {
+                (display.xf86vmode.XF86VidModeSetViewPort)(display.display, screen_id, 0, 0);
+                display.check_errors().expect("Failed to call XF86VidModeSetViewPort");
+            }
+
+        } else {
+
+            // set size hints
+            let mut size_hints: ffi::XSizeHints = unsafe { mem::zeroed() };
+            size_hints.flags = ffi::PSize;
+            size_hints.width = dimensions.0 as i32;
+            size_hints.height = dimensions.1 as i32;
+
+            if let Some(dimensions) = window_attrs.min_dimensions {
+                size_hints.flags |= ffi::PMinSize;
+                size_hints.min_width = dimensions.0 as i32;
+                size_hints.min_height = dimensions.1 as i32;
+            }
+
+            if let Some(dimensions) = window_attrs.max_dimensions {
+                size_hints.flags |= ffi::PMaxSize;
+                size_hints.max_width = dimensions.0 as i32;
+                size_hints.max_height = dimensions.1 as i32;
+            }
+
+            unsafe {
+                (display.xlib.XSetNormalHints)(display.display, window, &mut size_hints);
+                display.check_errors().expect("Failed to call XSetNormalHints");
+            }
+
+        }
+
+        // creating the window object
+        let window_proxy_data = WindowProxyData {
+            display: display.clone(),
+            window: window,
+        };
+        let window_proxy_data = Arc::new(Mutex::new(Some(window_proxy_data)));
+
+        let window = Window {
+            x: Arc::new(XWindow {
+                display: display.clone(),
+                window: window,
+                im: im,
+                ic: ic,
+                screen_id: screen_id,
+                is_fullscreen: is_fullscreen,
+                xf86_desk_mode: xf86_desk_mode,
+                window_proxy_data: window_proxy_data,
+            }),
+            is_closed: AtomicBool::new(false),
+            wm_delete_window: wm_delete_window,
+            current_size: Cell::new((0, 0)),
+            pending_events: Mutex::new(VecDeque::new()),
+            cursor_state: Mutex::new(CursorState::Normal),
+            input_handler: Mutex::new(XInputEventHandler::new(display, window, ic, window_attrs))
+        };
+
+        window.set_title(&window_attrs.title);
+
+        if window_attrs.visible {
+            unsafe {
+                let ref x_window: &XWindow = window.x.borrow();
+
+                // XSetInputFocus generates an error if the window is not visible,
+                // therefore we wait until it's the case.
+                loop {
+                    let mut window_attributes = mem::uninitialized();
+                    (display.xlib.XGetWindowAttributes)(display.display, x_window.window, &mut window_attributes);
+                    display.check_errors().expect("Failed to call XGetWindowAttributes");
+
+                    if window_attributes.map_state == ffi::IsViewable {
+                        (display.xlib.XSetInputFocus)(
+                            display.display,
+                            x_window.window,
+                            ffi::RevertToParent,
+                            ffi::CurrentTime
+                        );
+                        display.check_errors().expect("Failed to call XSetInputFocus");
+                        break;
+                    }
+
+                    // Wait about a frame to avoid too-busy waiting
+                    thread::sleep(Duration::from_millis(16));
+                }
+            }
+        }
+
+        // returning
+        Ok(window)
+    }
+
+    pub fn set_title(&self, title: &str) {
+        let wm_name = unsafe {
+            (self.x.display.xlib.XInternAtom)(self.x.display.display, b"_NET_WM_NAME\0".as_ptr() as *const _, 0)
+        };
+        self.x.display.check_errors().expect("Failed to call XInternAtom");
+
+        let wm_utf8_string = unsafe {
+            (self.x.display.xlib.XInternAtom)(self.x.display.display, b"UTF8_STRING\0".as_ptr() as *const _, 0)
+        };
+        self.x.display.check_errors().expect("Failed to call XInternAtom");
+
+        with_c_str(title, |c_title| unsafe {
+            (self.x.display.xlib.XStoreName)(self.x.display.display, self.x.window, c_title);
+
+            let len = title.as_bytes().len();
+            (self.x.display.xlib.XChangeProperty)(self.x.display.display, self.x.window,
+                                            wm_name, wm_utf8_string, 8, ffi::PropModeReplace,
+                                            c_title as *const u8, len as libc::c_int);
+            (self.x.display.xlib.XFlush)(self.x.display.display);
+        });
+        self.x.display.check_errors().expect("Failed to set window title");
+
+    }
+
+    pub fn show(&self) {
+        unsafe {
+            (self.x.display.xlib.XMapRaised)(self.x.display.display, self.x.window);
+            (self.x.display.xlib.XFlush)(self.x.display.display);
+            self.x.display.check_errors().expect("Failed to call XMapRaised");
+        }
+    }
+
+    pub fn hide(&self) {
+        unsafe {
+            (self.x.display.xlib.XUnmapWindow)(self.x.display.display, self.x.window);
+            (self.x.display.xlib.XFlush)(self.x.display.display);
+            self.x.display.check_errors().expect("Failed to call XUnmapWindow");
+        }
+    }
+
+    fn get_geometry(&self) -> Option<(i32, i32, u32, u32, u32)> {
+        unsafe {
+            use std::mem;
+
+            let mut root: ffi::Window = mem::uninitialized();
+            let mut x: libc::c_int = mem::uninitialized();
+            let mut y: libc::c_int = mem::uninitialized();
+            let mut width: libc::c_uint = mem::uninitialized();
+            let mut height: libc::c_uint = mem::uninitialized();
+            let mut border: libc::c_uint = mem::uninitialized();
+            let mut depth: libc::c_uint = mem::uninitialized();
+
+            if (self.x.display.xlib.XGetGeometry)(self.x.display.display, self.x.window,
+                &mut root, &mut x, &mut y, &mut width, &mut height,
+                &mut border, &mut depth) == 0
+            {
+                return None;
+            }
+
+            Some((x as i32, y as i32, width as u32, height as u32, border as u32))
+        }
+    }
+
+    #[inline]
+    pub fn get_position(&self) -> Option<(i32, i32)> {
+        self.get_geometry().map(|(x, y, _, _, _)| (x, y))
+    }
+
+    pub fn set_position(&self, x: i32, y: i32) {
+        unsafe { (self.x.display.xlib.XMoveWindow)(self.x.display.display, self.x.window, x as libc::c_int, y as libc::c_int); }
+        self.x.display.check_errors().expect("Failed to call XMoveWindow");
+    }
+
+    #[inline]
+    pub fn get_inner_size(&self) -> Option<(u32, u32)> {
+        self.get_geometry().map(|(_, _, w, h, _)| (w, h))
+    }
+
+    #[inline]
+    pub fn get_outer_size(&self) -> Option<(u32, u32)> {
+        self.get_geometry().map(|(_, _, w, h, b)| (w + b, h + b))       // TODO: is this really outside?
+    }
+
+    #[inline]
+    pub fn set_inner_size(&self, x: u32, y: u32) {
+        unsafe { (self.x.display.xlib.XResizeWindow)(self.x.display.display, self.x.window, x as libc::c_uint, y as libc::c_uint); }
+        self.x.display.check_errors().expect("Failed to call XResizeWindow");
+    }
+
+    #[inline]
+    pub fn create_window_proxy(&self) -> WindowProxy {
+        WindowProxy {
+            data: self.x.window_proxy_data.clone()
+        }
+    }
+
+    #[inline]
+    pub fn poll_events(&self) -> PollEventsIterator {
+        PollEventsIterator {
+            window: self
+        }
+    }
+
+    #[inline]
+    pub fn wait_events(&self) -> WaitEventsIterator {
+        WaitEventsIterator {
+            window: self
+        }
+    }
+
+    #[inline]
+    pub fn get_xlib_display(&self) -> *mut libc::c_void {
+        self.x.display.display as *mut libc::c_void
+    }
+
+    #[inline]
+    pub fn get_xlib_screen_id(&self) -> *mut libc::c_void {
+        self.x.screen_id as *mut libc::c_void
+    }
+
+    #[inline]
+    pub fn get_xlib_xconnection(&self) -> Arc<XConnection> {
+        self.x.display.clone()
+    }
+
+    #[inline]
+    pub fn platform_display(&self) -> *mut libc::c_void {
+        self.x.display.display as *mut libc::c_void
+    }
+
+    #[inline]
+    pub fn get_xlib_window(&self) -> *mut libc::c_void {
+        self.x.window as *mut libc::c_void
+    }
+
+    #[inline]
+    pub fn platform_window(&self) -> *mut libc::c_void {
+        self.x.window as *mut libc::c_void
+    }
+
+    pub fn get_xcb_connection(&self) -> *mut libc::c_void {
+        unsafe {
+            (self.x.display.xlib_xcb.XGetXCBConnection)(self.get_xlib_display() as *mut _) as *mut _
+        }
+    }
+
+    #[inline]
+    pub fn set_window_resize_callback(&mut self, _: Option<fn(u32, u32)>) {
+    }
+
+    pub fn set_cursor(&self, cursor: MouseCursor) {
+        unsafe {
+            let load = |name: &str| {
+                self.load_cursor(name)
+            };
+
+            let loadn = |names: &[&str]| {
+                self.load_first_existing_cursor(names)
+            };
+
+            // Try multiple names in some cases where the name
+            // differs on the desktop environments or themes.
+            //
+            // Try the better looking (or more suiting) names first.
+            let mut xcursor = match cursor {
+                MouseCursor::Alias => load("link"),
+                MouseCursor::Arrow => load("arrow"),
+                MouseCursor::Cell => load("plus"),
+                MouseCursor::Copy => load("copy"),
+                MouseCursor::Crosshair => load("crosshair"),
+                MouseCursor::Default => load("left_ptr"),
+                MouseCursor::Hand => loadn(&["hand2", "hand1"]),
+                MouseCursor::Help => load("question_arrow"),
+                MouseCursor::Move => load("move"),
+                MouseCursor::Grab => loadn(&["openhand", "grab"]),
+                MouseCursor::Grabbing => loadn(&["closedhand", "grabbing"]),
+                MouseCursor::Progress => load("left_ptr_watch"),
+                MouseCursor::AllScroll => load("all-scroll"),
+                MouseCursor::ContextMenu => load("context-menu"),
+
+                MouseCursor::NoDrop => loadn(&["no-drop", "circle"]),
+                MouseCursor::NotAllowed => load("crossed_circle"),
+
+
+                /// Resize cursors
+                MouseCursor::EResize => load("right_side"),
+                MouseCursor::NResize => load("top_side"),
+                MouseCursor::NeResize => load("top_right_corner"),
+                MouseCursor::NwResize => load("top_left_corner"),
+                MouseCursor::SResize => load("bottom_side"),
+                MouseCursor::SeResize => load("bottom_right_corner"),
+                MouseCursor::SwResize => load("bottom_left_corner"),
+                MouseCursor::WResize => load("left_side"),
+                MouseCursor::EwResize => load("h_double_arrow"),
+                MouseCursor::NsResize => load("v_double_arrow"),
+                MouseCursor::NwseResize => loadn(&["bd_double_arrow", "size_bdiag"]),
+                MouseCursor::NeswResize => loadn(&["fd_double_arrow", "size_fdiag"]),
+                MouseCursor::ColResize => loadn(&["split_h", "h_double_arrow"]),
+                MouseCursor::RowResize => loadn(&["split_v", "v_double_arrow"]),
+
+                MouseCursor::Text => loadn(&["text", "xterm"]),
+                MouseCursor::VerticalText => load("vertical-text"),
+
+                MouseCursor::Wait => load("watch"),
+
+                MouseCursor::ZoomIn => load("zoom-in"),
+                MouseCursor::ZoomOut => load("zoom-out"),
+
+                MouseCursor::NoneCursor => self.create_empty_cursor(),
+            };
+
+            (self.x.display.xlib.XDefineCursor)(self.x.display.display, self.x.window, xcursor);
+            if xcursor != 0 {
+                (self.x.display.xlib.XFreeCursor)(self.x.display.display, xcursor);
+            }
+            self.x.display.check_errors().expect("Failed to set or free the cursor");
+        }
+    }
+
+    fn load_cursor(&self, name: &str) -> ffi::Cursor {
+        use std::ffi::CString;
+        unsafe {
+            let c_string = CString::new(name.as_bytes()).unwrap();
+            (self.x.display.xcursor.XcursorLibraryLoadCursor)(self.x.display.display, c_string.as_ptr())
+        }
+    }
+
+    fn load_first_existing_cursor(&self, names :&[&str]) -> ffi::Cursor {
+        for name in names.iter() {
+            let xcursor = self.load_cursor(name);
+            if xcursor != 0 {
+                return xcursor;
+            }
+        }
+        0
+    }
+
+    // TODO: This could maybe be cached. I don't think it's worth
+    // the complexity, since cursor changes are not so common,
+    // and this is just allocating a 1x1 pixmap...
+    fn create_empty_cursor(&self) -> ffi::Cursor {
+        use std::mem;
+
+        let data = 0;
+        unsafe {
+            let pixmap = (self.x.display.xlib.XCreateBitmapFromData)(self.x.display.display, self.x.window, &data, 1, 1);
+            if pixmap == 0 {
+                // Failed to allocate
+                return 0;
+            }
+
+            // We don't care about this color, since it only fills bytes
+            // in the pixmap which are not 0 in the mask.
+            let dummy_color: ffi::XColor = mem::uninitialized();
+            let cursor = (self.x.display.xlib.XCreatePixmapCursor)(self.x.display.display,
+                                                                   pixmap,
+                                                                   pixmap,
+                                                                   &dummy_color as *const _ as *mut _,
+                                                                   &dummy_color as *const _ as *mut _, 0, 0);
+            (self.x.display.xlib.XFreePixmap)(self.x.display.display, pixmap);
+            cursor
+        }
+    }
+
+    pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
+        use CursorState::{ Grab, Normal, Hide };
+
+        let mut cursor_state = self.cursor_state.lock().unwrap();
+        match (state, *cursor_state) {
+            (Normal, Normal) | (Hide, Hide) | (Grab, Grab) => return Ok(()),
+            _ => {},
+        }
+
+        match *cursor_state {
+            Grab => {
+                unsafe {
+                    (self.x.display.xlib.XUngrabPointer)(self.x.display.display, ffi::CurrentTime);
+                    self.x.display.check_errors().expect("Failed to call XUngrabPointer");
+                }
+            },
+            Normal => {},
+            Hide => {
+                // NB: Calling XDefineCursor with None (aka 0)
+                // as a value resets the cursor to the default.
+                unsafe {
+                    (self.x.display.xlib.XDefineCursor)(self.x.display.display, self.x.window, 0);
+                }
+            },
+        }
+
+        *cursor_state = state;
+        match state {
+            Normal => Ok(()),
+            Hide => {
+                unsafe {
+                    let cursor = self.create_empty_cursor();
+                    (self.x.display.xlib.XDefineCursor)(self.x.display.display, self.x.window, cursor);
+                    if cursor != 0 {
+                        (self.x.display.xlib.XFreeCursor)(self.x.display.display, cursor);
+                    }
+                    self.x.display.check_errors().expect("Failed to call XDefineCursor or free the empty cursor");
+                }
+                Ok(())
+            },
+            Grab => {
+                unsafe {
+                    match (self.x.display.xlib.XGrabPointer)(
+                        self.x.display.display, self.x.window, ffi::True,
+                        (ffi::ButtonPressMask | ffi::ButtonReleaseMask | ffi::EnterWindowMask |
+                        ffi::LeaveWindowMask | ffi::PointerMotionMask | ffi::PointerMotionHintMask |
+                        ffi::Button1MotionMask | ffi::Button2MotionMask | ffi::Button3MotionMask |
+                        ffi::Button4MotionMask | ffi::Button5MotionMask | ffi::ButtonMotionMask |
+                        ffi::KeymapStateMask) as libc::c_uint,
+                        ffi::GrabModeAsync, ffi::GrabModeAsync,
+                        self.x.window, 0, ffi::CurrentTime
+                    ) {
+                        ffi::GrabSuccess => Ok(()),
+                        ffi::AlreadyGrabbed | ffi::GrabInvalidTime |
+                        ffi::GrabNotViewable | ffi::GrabFrozen
+                            => Err("cursor could not be grabbed".to_string()),
+                        _ => unreachable!(),
+                    }
+                }
+            },
+        }
+    }
+
+    pub fn hidpi_factor(&self) -> f32 {
+        unsafe {
+            let x_px = (self.x.display.xlib.XDisplayWidth)(self.x.display.display, self.x.screen_id);
+            let y_px = (self.x.display.xlib.XDisplayHeight)(self.x.display.display, self.x.screen_id);
+            let x_mm = (self.x.display.xlib.XDisplayWidthMM)(self.x.display.display, self.x.screen_id);
+            let y_mm = (self.x.display.xlib.XDisplayHeightMM)(self.x.display.display, self.x.screen_id);
+            let ppmm = ((x_px as f32 * y_px as f32) / (x_mm as f32 * y_mm as f32)).sqrt();
+            ((ppmm * (12.0 * 25.4 / 96.0)).round() / 12.0).max(1.0) // quantize with 1/12 step size.
+        }
+    }
+
+    pub fn set_cursor_position(&self, x: i32, y: i32) -> Result<(), ()> {
+        unsafe {
+            (self.x.display.xlib.XWarpPointer)(self.x.display.display, 0, self.x.window, 0, 0, 0, 0, x, y);
+            self.x.display.check_errors().map_err(|_| ())
+        }
+    }
+}

src/platform/linux/x11/xdisplay.rs

@@ -0,0 +1,147 @@
+use std::ptr;
+use std::fmt;
+use std::error::Error;
+use std::ffi::CString;
+use std::sync::Mutex;
+
+use libc;
+
+use super::ffi;
+use super::super::dlopen;
+
+/// A connection to an X server.
+pub struct XConnection {
+    pub xlib: ffi::Xlib,
+    pub xf86vmode: ffi::Xf86vmode,
+    pub xcursor: ffi::Xcursor,
+    pub xinput2: ffi::XInput2,
+    pub xlib_xcb: ffi::Xlib_xcb,
+    pub display: *mut ffi::Display,
+    pub latest_error: Mutex<Option<XError>>,
+}
+
+unsafe impl Send for XConnection {}
+unsafe impl Sync for XConnection {}
+
+pub type XErrorHandler = Option<unsafe extern fn(*mut ffi::Display, *mut ffi::XErrorEvent) -> libc::c_int>;
+
+impl XConnection {
+    pub fn new(error_handler: XErrorHandler) -> Result<XConnection, XNotSupported> {
+        // opening the libraries
+        let xlib = try!(ffi::Xlib::open());
+        let xcursor = try!(ffi::Xcursor::open());
+        let xf86vmode = try!(ffi::Xf86vmode::open());
+        let xinput2 = try!(ffi::XInput2::open());
+        let xlib_xcb = try!(ffi::Xlib_xcb::open());
+
+        unsafe { (xlib.XInitThreads)() };
+        unsafe { (xlib.XSetErrorHandler)(error_handler) };
+
+        // calling XOpenDisplay
+        let display = unsafe {
+            let display = (xlib.XOpenDisplay)(ptr::null());
+            if display.is_null() {
+                return Err(XNotSupported::XOpenDisplayFailed);
+            }
+            display
+        };
+
+        Ok(XConnection {
+            xlib: xlib,
+            xf86vmode: xf86vmode,
+            xcursor: xcursor,
+            xinput2: xinput2,
+            xlib_xcb: xlib_xcb,
+            display: display,
+            latest_error: Mutex::new(None),
+        })
+    }
+
+    /// Checks whether an error has been triggered by the previous function calls.
+    #[inline]
+    pub fn check_errors(&self) -> Result<(), XError> {
+        let error = self.latest_error.lock().unwrap().take();
+
+        if let Some(error) = error {
+            Err(error)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Ignores any previous error.
+    #[inline]
+    pub fn ignore_error(&self) {
+        *self.latest_error.lock().unwrap() = None;
+    }
+}
+
+impl Drop for XConnection {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe { (self.xlib.XCloseDisplay)(self.display) };
+    }
+}
+
+/// Error triggered by xlib.
+#[derive(Debug, Clone)]
+pub struct XError {
+    pub description: String,
+    pub error_code: u8,
+    pub request_code: u8,
+    pub minor_code: u8,
+}
+
+impl Error for XError {
+    #[inline]
+    fn description(&self) -> &str {
+        &self.description
+    }
+}
+
+impl fmt::Display for XError {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write!(formatter, "X error: {} (code: {}, request code: {}, minor code: {})",
+               self.description, self.error_code, self.request_code, self.minor_code)
+    }
+}
+
+/// Error returned if this system doesn't have XLib or can't create an X connection.
+#[derive(Clone, Debug)]
+pub enum XNotSupported {
+    /// Failed to load one or several shared libraries.
+    LibraryOpenError(ffi::OpenError),
+    /// Connecting to the X server with `XOpenDisplay` failed.
+    XOpenDisplayFailed,     // TODO: add better message
+}
+
+impl From<ffi::OpenError> for XNotSupported {
+    #[inline]
+    fn from(err: ffi::OpenError) -> XNotSupported {
+        XNotSupported::LibraryOpenError(err)
+    }
+}
+
+impl Error for XNotSupported {
+    #[inline]
+    fn description(&self) -> &str {
+        match *self {
+            XNotSupported::LibraryOpenError(_) => "Failed to load one of xlib's shared libraries",
+            XNotSupported::XOpenDisplayFailed => "Failed to open connection to X server",
+        }
+    }
+
+    #[inline]
+    fn cause(&self) -> Option<&Error> {
+        match *self {
+            XNotSupported::LibraryOpenError(ref err) => Some(err),
+            _ => None
+        }
+    }
+}
+
+impl fmt::Display for XNotSupported {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(self.description())
+    }
+}