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, 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::init() }; } wayland_env!(InnerEnv, compositor: WlCompositor, seat: WlSeat, shell: WlShell, shm: WlShm, subcompositor: WlSubcompositor ); pub struct WaylandContext { inner: InnerEnv, iterator: Mutex, monitors: Vec, queues: Mutex>>>> } impl WaylandContext { fn init() -> Option { let display = match get_display() { Some(display) => display, None => return None }; let (mut inner_env, iterator) = InnerEnv::init(display); let monitors = inner_env.globals.iter() .flat_map(|&(id, _, _)| inner_env.rebind_id::(id)) .map(|(monitor, _)| monitor) .collect(); inner_env.display.sync_roundtrip().unwrap(); Some(WaylandContext { inner: inner_env, iterator: Mutex::new(iterator), monitors: monitors, queues: Mutex::new(HashMap::new()) }) } pub fn new_surface(&self) -> Option<(WlSurface, Arc>>)> { 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 { 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::().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 { self.inner.display.flush() } pub fn read_events(&self) -> ::std::io::Result> { let guard = match self.inner.display.prepare_read() { Some(g) => g, None => return Ok(None) }; return guard.read_events().map(|i| Some(i)); } }