Move api module into platform::linux

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;
+    }
+}