api/wayland: core windows and events structure.

src/api/wayland/context.rs

@@ -1,11 +1,21 @@
-use wayland_client::EventIterator;
+use Event as GlutinEvent;
+
+use std::collections::{HashMap, VecDeque};
+use std::sync::{Arc, Mutex};
+
+use libc::c_void;
+
+use wayland_client::{EventIterator, Proxy, ProxyId};
 use wayland_client::wayland::get_display;
-use wayland_client::wayland::compositor::WlCompositor;
+use wayland_client::wayland::compositor::{WlCompositor, WlSurface};
+use wayland_client::wayland::output::WlOutput;
 use wayland_client::wayland::seat::WlSeat;
 use wayland_client::wayland::shell::WlShell;
 use wayland_client::wayland::shm::WlShm;
 use wayland_client::wayland::subcompositor::WlSubcompositor;
 
+use super::wayland_window::DecoratedSurface;
+
 lazy_static! {
     pub static ref WAYLAND_CONTEXT: Option<WaylandContext> = {
         WaylandContext::init()
@@ -22,7 +32,9 @@ wayland_env!(InnerEnv,
 
 pub struct WaylandContext {
     inner: InnerEnv,
-    iterator: EventIterator
+    iterator: Mutex<EventIterator>,
+    monitors: Vec<WlOutput>,
+    queues: Mutex<HashMap<ProxyId, Arc<Mutex<VecDeque<GlutinEvent>>>>>
 }
 
 impl WaylandContext {
@@ -32,11 +44,81 @@ impl WaylandContext {
             None => return None
         };
 
-        let (inner_env, iterator) = InnerEnv::init(display);
+        let (mut inner_env, iterator) = InnerEnv::init(display);
+
+        let monitors = inner_env.globals.iter()
+            .flat_map(|&(id, _, _)| inner_env.rebind_id::<WlOutput>(id))
+            .map(|(monitor, _)| monitor)
+            .collect();
+
+        inner_env.display.sync_roundtrip().unwrap();
 
         Some(WaylandContext {
             inner: inner_env,
-            iterator: iterator
+            iterator: Mutex::new(iterator),
+            monitors: monitors,
+            queues: Mutex::new(HashMap::new())
         })
     }
-}
+
+    pub fn new_surface(&self) -> Option<(WlSurface, Arc<Mutex<VecDeque<GlutinEvent>>>)> {
+        self.inner.compositor.as_ref().map(|c| {
+            let s = c.0.create_surface();
+            let id = s.id();
+            let queue = {
+                let mut q = VecDeque::new();
+                q.push_back(GlutinEvent::Refresh);
+                Arc::new(Mutex::new(q))
+            };
+            self.queues.lock().unwrap().insert(id, queue.clone());
+            (s, queue)
+        })
+    }
+
+    pub fn dropped_surface(&self, id: ProxyId) {
+        self.queues.lock().unwrap().remove(&id);
+    }
+
+    pub fn decorated_from(&self, surface: &WlSurface, width: i32, height: i32) -> Option<DecoratedSurface> {
+        let inner = &self.inner;
+        match (&inner.compositor, &inner.subcompositor, &inner.shm, &inner.shell) {
+            (&Some(ref compositor), &Some(ref subcompositor), &Some(ref shm), &Some(ref shell)) => {
+                DecoratedSurface::new(
+                    surface, width, height,
+                    &compositor.0, &subcompositor.0, &shm.0, &shell.0,
+                    self.inner.rebind::<WlSeat>().map(|(seat, _)| seat)
+                ).ok()
+            }
+            _ => None
+        }
+    }
+
+    pub fn display_ptr(&self) -> *const c_void {
+        self.inner.display.ptr() as *const _
+    }
+
+    pub fn dispatch_events(&self) {
+        self.inner.display.dispatch_pending().unwrap();
+        let mut iterator = self.iterator.lock().unwrap();
+        let queues = self.queues.lock().unwrap();
+        for evt in &mut *iterator {
+            if let Some((evt, id)) = super::events::translate_event(evt) {
+                if let Some(q) = queues.get(&id) {
+                    q.lock().unwrap().push_back(evt);
+                }
+            }
+        }
+    }
+
+    pub fn flush_events(&self) -> ::std::io::Result<i32> {
+        self.inner.display.flush()
+    }
+
+    pub fn read_events(&self) -> ::std::io::Result<Option<i32>> {
+        let guard = match self.inner.display.prepare_read() {
+            Some(g) => g,
+            None => return Ok(None)
+        };
+        return guard.read_events().map(|i| Some(i));
+    }
+}

src/api/wayland/events.rs

@@ -0,0 +1,10 @@
+use Event as GlutinEvent;
+
+use wayland_client::Event as WaylandEvent;
+use wayland_client::ProxyId;
+
+pub fn translate_event(evt: WaylandEvent) -> Option<(GlutinEvent, ProxyId)> {
+    match evt {
+        _ => None
+    }
+}

src/api/wayland/mod.rs

@@ -7,6 +7,7 @@ extern crate wayland_kbd;
 extern crate wayland_window;
 
 mod context;
+mod events;
 mod monitor;
 mod window;
 

src/api/wayland/window.rs

@@ -1,10 +1,19 @@
-use {ContextError, CreationError, CursorState, Event, GlAttributes, GlContext,
-     MouseCursor, PixelFormat, PixelFormatRequirements, WindowAttributes};
-
-use api::egl::Context as EglContext;
+use std::collections::VecDeque;
+use std::ffi::CString;
+use std::sync::{Arc, Mutex};
 
 use libc;
 
+use {ContextError, CreationError, CursorState, Event, GlAttributes, GlContext,
+     MouseCursor, PixelFormat, PixelFormatRequirements, WindowAttributes};
+use api::dlopen;
+use api::egl;
+use api::egl::Context as EglContext;
+
+use wayland_client::egl as wegl;
+use super::wayland_window::{DecoratedSurface, add_borders, substract_borders};
+use super::context::{WaylandContext, WAYLAND_CONTEXT};
+
 #[derive(Clone)]
 pub struct WindowProxy;
 
@@ -16,9 +25,36 @@ impl WindowProxy {
 }
 
 pub struct Window {
+    wayland_context: &'static WaylandContext,
+    egl_surface: wegl::WlEglSurface,
+    decorated_surface: Mutex<DecoratedSurface>,
+    evt_queue: Arc<Mutex<VecDeque<Event>>>,
+    inner_size: Mutex<(i32, i32)>,
+    resize_callback: Option<fn(u32, u32)>,
     pub context: EglContext,
 }
 
+impl Window {
+    fn next_event(&self) -> Option<Event> {
+        let mut newsize = None;
+        for (_, w, h) in &mut *self.decorated_surface.lock().unwrap() {
+            newsize = Some((w, h));
+        }
+        if let Some((w, h)) = newsize {
+            let (w, h) = substract_borders(w, h);
+            *self.inner_size.lock().unwrap() = (w, h);
+            self.decorated_surface.lock().unwrap().resize(w, h);
+            self.egl_surface.resize(w, h, 0, 0);
+            if let Some(f) = self.resize_callback {
+                f(w as u32, h as u32);
+            }
+            Some(Event::Resized(w as u32, h as u32))
+        } else {
+            self.evt_queue.lock().unwrap().pop_front()
+        }
+    }
+}
+
 pub struct PollEventsIterator<'a> {
     window: &'a Window,
 }
@@ -27,7 +63,13 @@ impl<'a> Iterator for PollEventsIterator<'a> {
     type Item = Event;
 
     fn next(&mut self) -> Option<Event> {
-        unimplemented!()
+        match self.window.next_event() {
+            Some(evt) => return Some(evt),
+            None => {}
+        }
+        // the queue was empty, try a dispatch and see the result
+        self.window.wayland_context.dispatch_events();
+        return self.window.next_event();
     }
 }
 
@@ -39,7 +81,21 @@ impl<'a> Iterator for WaitEventsIterator<'a> {
     type Item = Event;
 
     fn next(&mut self) -> Option<Event> {
-        unimplemented!()
+        loop {
+            match self.window.next_event() {
+                Some(evt) => return Some(evt),
+                None => {}
+            }
+            // the queue was empty, try a dispatch & read and see the result
+            self.window.wayland_context.flush_events().expect("Connexion with the wayland compositor lost.");
+            match self.window.wayland_context.read_events() {
+                Ok(_) => {
+                    // events were read or dispatch is needed, in both cases, we dispatch
+                    self.window.wayland_context.dispatch_events()
+                }
+                Err(_) => panic!("Connexion with the wayland compositor lost.")
+            }
+        }
     }
 }
 
@@ -51,45 +107,97 @@ impl Window {
         assert!(window.min_dimensions.is_none());
         assert!(window.max_dimensions.is_none());
 
-        unimplemented!()
+        let wayland_context = match *WAYLAND_CONTEXT {
+            Some(ref c) => c,
+            None => return Err(CreationError::NotSupported),
+        };
+
+        if !wegl::is_available() {
+            return Err(CreationError::NotSupported)
+        }
+
+        let (w, h) = window.dimensions.unwrap_or((800, 600));
+
+        let (surface, evt_queue) = match wayland_context.new_surface() {
+            Some(t) => t,
+            None => return Err(CreationError::NotSupported)
+        };
+
+        let egl_surface = wegl::WlEglSurface::new(surface, w as i32, h as i32);
+
+        let context = {
+            let libegl = unsafe { dlopen::dlopen(b"libEGL.so\0".as_ptr() as *const _, dlopen::RTLD_NOW) };
+            if libegl.is_null() {
+                return Err(CreationError::NotSupported);
+            }
+            let egl = ::api::egl::ffi::egl::Egl::load_with(|sym| {
+                let sym = CString::new(sym).unwrap();
+                unsafe { dlopen::dlsym(libegl, sym.as_ptr()) }
+            });
+            try!(EglContext::new(
+                egl,
+                pf_reqs, &opengl.clone().map_sharing(|_| unimplemented!()),        // TODO: 
+                egl::NativeDisplay::Wayland(Some(wayland_context.display_ptr() as *const _)))
+                .and_then(|p| p.finish(unsafe { egl_surface.egl_surfaceptr() } as *const _))
+            )
+        };
+
+        let decorated_surface = match wayland_context.decorated_from(&egl_surface, w as i32, h as i32) {
+            Some(s) => s,
+            None => return Err(CreationError::NotSupported)
+        };
+
+        Ok(Window {
+            wayland_context: wayland_context,
+            egl_surface: egl_surface,
+            decorated_surface: Mutex::new(decorated_surface),
+            evt_queue: evt_queue,
+            inner_size: Mutex::new((w as i32, h as i32)),
+            resize_callback: None,
+            context: context
+        })
     }
 
     pub fn set_title(&self, title: &str) {
-        unimplemented!()
+        self.decorated_surface.lock().unwrap().set_title(title.into())
     }
 
     #[inline]
     pub fn show(&self) {
-        unimplemented!()
+        // TODO
     }
 
     #[inline]
     pub fn hide(&self) {
-        unimplemented!()
+        // TODO
     }
 
     #[inline]
     pub fn get_position(&self) -> Option<(i32, i32)> {
-        unimplemented!()
+        // Not possible with wayland
+        None
     }
 
     #[inline]
     pub fn set_position(&self, _x: i32, _y: i32) {
-        unimplemented!()
+        // Not possible with wayland
     }
 
     pub fn get_inner_size(&self) -> Option<(u32, u32)> {
-        unimplemented!()
+        let (w, h) = *self.inner_size.lock().unwrap();
+        Some((w as u32, h as u32))
     }
 
     #[inline]
     pub fn get_outer_size(&self) -> Option<(u32, u32)> {
-        unimplemented!()
+        let (w, h) = *self.inner_size.lock().unwrap();
+        let (w, h) = add_borders(w, h);
+        Some((w as u32, h as u32))
     }
 
     #[inline]
     pub fn set_inner_size(&self, x: u32, y: u32) {
-        unimplemented!()
+        self.decorated_surface.lock().unwrap().resize(x as i32, y as i32)
     }
 
     #[inline]
@@ -113,17 +221,18 @@ impl Window {
 
     #[inline]
     pub fn set_window_resize_callback(&mut self, callback: Option<fn(u32, u32)>) {
-        unimplemented!()
+        self.resize_callback = callback;
     }
 
     #[inline]
     pub fn set_cursor(&self, cursor: MouseCursor) {
-        unimplemented!()
+        // TODO
     }
 
     #[inline]
     pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
-        unimplemented!()
+        // TODO
+        Ok(())
     }
 
     #[inline]
@@ -132,8 +241,9 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_cursor_position(&self, x: i32, y: i32) -> Result<(), ()> {
-        unimplemented!()
+    pub fn set_cursor_position(&self, _x: i32, _y: i32) -> Result<(), ()> {
+        // TODO: not yet possible on wayland
+        Ok(())
     }
 
     #[inline]
@@ -178,3 +288,10 @@ impl GlContext for Window {
         self.context.get_pixel_format().clone()
     }
 }
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        use wayland_client::Proxy;
+        self.wayland_context.dropped_surface((*self.egl_surface).id())
+    }
+}