aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/api/wayland/context.rs383
-rw-r--r--src/api/wayland/events.rs110
-rw-r--r--src/api/wayland/keyboard.rs97
-rw-r--r--src/api/wayland/mod.rs489
-rw-r--r--src/api/wayland/monitor.rs75
-rw-r--r--src/api/wayland/window.rs370
-rw-r--r--src/lib.rs3
-rw-r--r--src/platform/linux/api_dispatch.rs2
8 files changed, 826 insertions, 703 deletions
diff --git a/src/api/wayland/context.rs b/src/api/wayland/context.rs
index ad0977c..f303b54 100644
--- a/src/api/wayland/context.rs
+++ b/src/api/wayland/context.rs
@@ -1,228 +1,211 @@
-use super::wayland::core::{default_display, Display, Registry};
-use super::wayland::core::compositor::{Compositor, SurfaceId, WSurface};
-use super::wayland::core::output::Output;
-use super::wayland::core::seat::{ButtonState, Seat, Pointer, Keyboard, KeyState};
-use super::wayland::core::shell::Shell;
-use super::wayland_kbd::MappedKeyboard;
-use super::keyboard::keycode_to_vkey;
-
+use Event as GlutinEvent;
-use std::collections::{VecDeque, HashMap};
+use std::collections::{HashMap, VecDeque, HashSet};
use std::sync::{Arc, Mutex};
-use Event;
-use MouseButton;
-use ElementState;
+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, WlPointer};
+use wayland_client::wayland::shell::{WlShell, WlShellSurface};
+use wayland_client::wayland::shm::WlShm;
+use wayland_client::wayland::subcompositor::WlSubcompositor;
-enum AnyKeyboard {
- RawKeyBoard(Keyboard),
- XKB(MappedKeyboard)
+use super::wayland_kbd::MappedKeyboard;
+use super::wayland_window::DecoratedSurface;
+
+lazy_static! {
+ pub static ref WAYLAND_CONTEXT: Option<WaylandContext> = {
+ WaylandContext::init()
+ };
+}
+
+wayland_env!(InnerEnv,
+ compositor: WlCompositor,
+ seat: WlSeat,
+ shell: WlShell,
+ shm: WlShm,
+ subcompositor: WlSubcompositor
+);
+
+pub struct WaylandFocuses {
+ pub pointer: Option<WlPointer>,
+ pub pointer_on: Option<ProxyId>,
+ pub pointer_at: Option<(f64, f64)>,
+ pub keyboard: Option<MappedKeyboard>,
+ pub keyboard_on: Option<ProxyId>
}
pub struct WaylandContext {
- pub display: Display,
- pub registry: Registry,
- pub compositor: Compositor,
- pub shell: Shell,
- pub seat: Seat,
- pointer: Option<Mutex<Pointer<WSurface>>>,
- keyboard: Option<AnyKeyboard>,
- windows_event_queues: Arc<Mutex<HashMap<SurfaceId, Arc<Mutex<VecDeque<Event>>>>>>,
- current_pointer_surface: Arc<Mutex<Option<SurfaceId>>>,
- current_keyboard_surface: Arc<Mutex<Option<SurfaceId>>>,
- pub outputs: Vec<Arc<Output>>
+ inner: InnerEnv,
+ iterator: Mutex<EventIterator>,
+ monitors: Vec<(WlOutput, u32, u32, String)>,
+ queues: Mutex<HashMap<ProxyId, Arc<Mutex<VecDeque<GlutinEvent>>>>>,
+ known_surfaces: Mutex<HashSet<ProxyId>>,
+ focuses: Mutex<WaylandFocuses>
}
impl WaylandContext {
- pub fn new() -> Option<WaylandContext> {
- let display = match default_display() {
- Some(d) => d,
- None => return None,
- };
- let registry = display.get_registry();
- // let the registry get its events
- display.sync_roundtrip();
- let compositor = match registry.get_compositor() {
- Some(c) => c,
- None => return None,
- };
- let shell = match registry.get_shell() {
- Some(s) => s,
- None => return None,
+ fn init() -> Option<WaylandContext> {
+ let display = match get_display() {
+ Some(display) => display,
+ None => return None
};
- let seat = match registry.get_seats().into_iter().next() {
- Some(s) => s,
- None => return None,
- };
- let outputs = registry.get_outputs().into_iter().map(Arc::new).collect::<Vec<_>>();
- // let the other globals get their events
- display.sync_roundtrip();
-
- let current_pointer_surface = Arc::new(Mutex::new(None));
-
- // rustc has trouble finding the correct type here, so we explicit it.
- let windows_event_queues = Arc::new(Mutex::new(
- HashMap::<SurfaceId, Arc<Mutex<VecDeque<Event>>>>::new()
- ));
-
- // handle pointer inputs
- let mut pointer = seat.get_pointer();
- if let Some(ref mut p) = pointer {
- // set the enter/leave callbacks
- let current_surface = current_pointer_surface.clone();
- p.set_enter_action(move |_, _, sid, x, y| {
- *current_surface.lock().unwrap() = Some(sid);
- });
- let current_surface = current_pointer_surface.clone();
- p.set_leave_action(move |_, _, sid| {
- *current_surface.lock().unwrap() = None;
- });
- // set the events callbacks
- let current_surface = current_pointer_surface.clone();
- let event_queues = windows_event_queues.clone();
- p.set_motion_action(move |_, _, x, y| {
- // dispatch to the appropriate queue
- let sid = *current_surface.lock().unwrap();
- if let Some(sid) = sid {
- let map = event_queues.lock().unwrap();
- if let Some(queue) = map.get(&sid) {
- queue.lock().unwrap().push_back(Event::MouseMoved((x as i32,y as i32)))
- }
- }
- });
- let current_surface = current_pointer_surface.clone();
- let event_queues = windows_event_queues.clone();
- p.set_button_action(move |_, _, sid, b, s| {
- let button = match b {
- 0x110 => MouseButton::Left,
- 0x111 => MouseButton::Right,
- 0x112 => MouseButton::Middle,
- _ => return
- };
- let state = match s {
- ButtonState::Released => ElementState::Released,
- ButtonState::Pressed => ElementState::Pressed
- };
- // dispatch to the appropriate queue
- let sid = *current_surface.lock().unwrap();
- if let Some(sid) = sid {
- let map = event_queues.lock().unwrap();
- if let Some(queue) = map.get(&sid) {
- queue.lock().unwrap().push_back(Event::MouseInput(state, button))
+
+ let (mut inner_env, iterator) = InnerEnv::init(display);
+
+ let mut outputs_events = EventIterator::new();
+
+ let mut monitors = inner_env.globals.iter()
+ .flat_map(|&(id, _, _)| inner_env.rebind_id::<WlOutput>(id))
+ .map(|(mut monitor, _)| {
+ monitor.set_evt_iterator(&outputs_events);
+ (monitor, 0, 0, String::new())
+ }).collect();
+
+ inner_env.display.sync_roundtrip().unwrap();
+
+ super::monitor::init_monitors(&mut monitors, outputs_events);
+
+ Some(WaylandContext {
+ inner: inner_env,
+ iterator: Mutex::new(iterator),
+ monitors: monitors,
+ queues: Mutex::new(HashMap::new()),
+ known_surfaces: Mutex::new(HashSet::new()),
+ focuses: Mutex::new(WaylandFocuses {
+ pointer: None,
+ pointer_on: None,
+ pointer_at: None,
+ keyboard: None,
+ keyboard_on: None
+ })
+ })
+ }
+
+ 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());
+ self.known_surfaces.lock().unwrap().insert(id);
+ (s, queue)
+ })
+ }
+
+ pub fn dropped_surface(&self, id: ProxyId) {
+ self.queues.lock().unwrap().remove(&id);
+ self.known_surfaces.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 plain_from(&self, surface: &WlSurface, fullscreen: Option<ProxyId>) -> Option<WlShellSurface> {
+ use wayland_client::wayland::shell::WlShellSurfaceFullscreenMethod;
+
+ let inner = &self.inner;
+ if let Some((ref shell, _)) = inner.shell {
+ let shell_surface = shell.get_shell_surface(surface);
+ if let Some(monitor_id) = fullscreen {
+ for m in &self.monitors {
+ if m.0.id() == monitor_id {
+ shell_surface.set_fullscreen(
+ WlShellSurfaceFullscreenMethod::Default,
+ 0,
+ Some(&m.0)
+ );
+ return Some(shell_surface)
}
}
- });
+ }
+ shell_surface.set_toplevel();
+ Some(shell_surface)
+ } else {
+ None
}
+ }
- // handle keyboard inputs
- let mut keyboard = None;
- let current_keyboard_surface = Arc::new(Mutex::new(None));
- if let Some(mut wkbd) = seat.get_keyboard() {
- display.sync_roundtrip();
-
- let current_surface = current_keyboard_surface.clone();
- wkbd.set_enter_action(move |_, _, sid, _| {
- *current_surface.lock().unwrap() = Some(sid);
- });
- let current_surface = current_keyboard_surface.clone();
- wkbd.set_leave_action(move |_, _, sid| {
- *current_surface.lock().unwrap() = None;
- });
-
- let kbd = match MappedKeyboard::new(wkbd) {
- Ok(mkbd) => {
- // We managed to load a keymap
- let current_surface = current_keyboard_surface.clone();
- let event_queues = windows_event_queues.clone();
- mkbd.set_key_action(move |state, _, _, _, keycode, keystate| {
- let kstate = match keystate {
- KeyState::Released => ElementState::Released,
- KeyState::Pressed => ElementState::Pressed
- };
- let mut events = Vec::new();
- // key event
- events.push(Event::KeyboardInput(
- kstate,
- (keycode & 0xff) as u8,
- keycode_to_vkey(state, keycode)
- ));
- // utf8 events
- if kstate == ElementState::Pressed {
- if let Some(txt) = state.get_utf8(keycode) {
- events.extend(
- txt.chars().map(Event::ReceivedCharacter)
- );
- }
- }
- // dispatch to the appropriate queue
- let sid = *current_surface.lock().unwrap();
- if let Some(sid) = sid {
- let map = event_queues.lock().unwrap();
- if let Some(queue) = map.get(&sid) {
- queue.lock().unwrap().extend(events.into_iter());
- }
- }
- });
- AnyKeyboard::XKB(mkbd)
- },
- Err(mut rkbd) => {
- // fallback to raw inputs, no virtual keycodes
- let current_surface = current_keyboard_surface.clone();
- let event_queues = windows_event_queues.clone();
- rkbd.set_key_action(move |_, _, _, keycode, keystate| {
- let kstate = match keystate {
- KeyState::Released => ElementState::Released,
- KeyState::Pressed => ElementState::Pressed
- };
- let event = Event::KeyboardInput(kstate, (keycode & 0xff) as u8, None);
- // dispatch to the appropriate queue
- let sid = *current_surface.lock().unwrap();
- if let Some(sid) = sid {
- let map = event_queues.lock().unwrap();
- if let Some(queue) = map.get(&sid) {
- queue.lock().unwrap().push_back(event);
- }
- }
- });
- AnyKeyboard::RawKeyBoard(rkbd)
+ 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 mut focuses = self.focuses.lock().unwrap();
+ let known_surfaces = self.known_surfaces.lock().unwrap();
+ let queues = self.queues.lock().unwrap();
+ // first, keyboard events
+ let kdb_evts = super::keyboard::translate_kbd_events(&mut *focuses, &known_surfaces);
+ for (evt, id) in kdb_evts {
+ if let Some(q) = queues.get(&id) {
+ q.lock().unwrap().push_back(evt);
+ }
+ }
+ // then, the rest
+ for evt in &mut *iterator {
+ if let Some((evt, id)) = super::events::translate_event(
+ evt, &mut *focuses, &known_surfaces,
+ self.inner.seat.as_ref().map(|s| &s.0))
+ {
+ if let Some(q) = queues.get(&id) {
+ q.lock().unwrap().push_back(evt);
}
- };
- keyboard = Some(kbd);
+ }
}
+ }
- Some(WaylandContext {
- display: display,
- registry: registry,
- compositor: compositor,
- shell: shell,
- seat: seat,
- pointer: pointer.map(|p| Mutex::new(p)),
- keyboard: keyboard,
- windows_event_queues: windows_event_queues,
- current_pointer_surface: current_pointer_surface,
- current_keyboard_surface: current_keyboard_surface,
- outputs: outputs
- })
+ pub fn flush_events(&self) -> ::std::io::Result<i32> {
+ self.inner.display.flush()
}
- pub fn register_surface(&self, sid: SurfaceId, queue: Arc<Mutex<VecDeque<Event>>>) {
- self.windows_event_queues.lock().unwrap().insert(sid, queue);
- if let Some(ref p) = self.pointer {
- p.lock().unwrap().add_handled_surface(sid);
- }
+ 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));
+ }
+
+ pub fn monitor_ids(&self) -> Vec<ProxyId> {
+ self.monitors.iter().map(|o| o.0.id()).collect()
}
- pub fn deregister_surface(&self, sid: SurfaceId) {
- self.windows_event_queues.lock().unwrap().remove(&sid);
- if let Some(ref p) = self.pointer {
- p.lock().unwrap().remove_handled_surface(sid);
+ pub fn monitor_name(&self, pid: ProxyId) -> Option<String> {
+ for o in &self.monitors {
+ if o.0.id() == pid {
+ return Some(o.3.clone())
+ }
}
+ None
}
- pub fn push_event_for(&self, sid: SurfaceId, evt: Event) {
- let mut guard = self.windows_event_queues.lock().unwrap();
- if let Some(queue) = guard.get(&sid) {
- queue.lock().unwrap().push_back(evt);
+ pub fn monitor_dimensions(&self, pid: ProxyId) -> Option<(u32, u32)> {
+ for o in &self.monitors {
+ if o.0.id() == pid {
+ return Some((o.1, o.2))
+ }
}
+ None
}
}
diff --git a/src/api/wayland/events.rs b/src/api/wayland/events.rs
new file mode 100644
index 0000000..8b18020
--- /dev/null
+++ b/src/api/wayland/events.rs
@@ -0,0 +1,110 @@
+use std::collections::HashSet;
+
+use Event as GlutinEvent;
+use ElementState;
+use MouseButton;
+use MouseScrollDelta;
+
+use wayland_client::Event as WaylandEvent;
+use wayland_client::ProxyId;
+use wayland_client::wayland::WaylandProtocolEvent as WPE;
+use wayland_client::wayland::seat::{WlSeat, WlSeatEvent, WlPointerEvent,
+ WlPointerButtonState,
+ WlPointerAxis, WlSeatCapability};
+
+use super::wayland_kbd::MappedKeyboard;
+
+use super::context::WaylandFocuses;
+
+pub fn translate_event(
+ evt: WaylandEvent,
+ focuses: &mut WaylandFocuses,
+ known_surfaces: &HashSet<ProxyId>,
+ seat: Option<&WlSeat>,
+ ) -> Option<(GlutinEvent, ProxyId)>
+{
+ let WaylandEvent::Wayland(wayland_evt) = evt;
+ match wayland_evt {
+ WPE::WlSeat(_, seat_evt) => match seat_evt {
+ WlSeatEvent::Capabilities(cap) => {
+ if cap.contains(WlSeatCapability::Pointer) && focuses.pointer.is_none() {
+ if let Some(seat) = seat {
+ focuses.pointer = Some(seat.get_pointer());
+ }
+ }
+ if cap.contains(WlSeatCapability::Keyboard) && focuses.keyboard.is_none() {
+ if let Some(seat) = seat {
+ match MappedKeyboard::new(seat) {
+ Ok(mk) => {
+ focuses.keyboard = Some(mk)
+ },
+ Err(_) => {}
+ }
+ }
+ }
+ None
+ },
+ _ => None
+ },
+ WPE::WlPointer(_, pointer_evt) => match pointer_evt {
+ WlPointerEvent::Enter(_, surface, x, y) => {
+ if known_surfaces.contains(&surface) {
+ focuses.pointer_on = Some(surface);
+ focuses.pointer_at = Some((x, y));
+ Some((GlutinEvent::MouseMoved((x as i32, y as i32)), surface))
+ } else {
+ None
+ }
+ }
+ WlPointerEvent::Leave(_, _) => {
+ focuses.pointer_on = None;
+ focuses.pointer_at = None;
+ None
+ }
+ WlPointerEvent::Motion(_, x, y) => {
+ if let Some(surface) = focuses.pointer_on {
+ focuses.pointer_at = Some((x, y));
+ Some((GlutinEvent::MouseMoved((x as i32, y as i32)), surface))
+ } else {
+ None
+ }
+ }
+ WlPointerEvent::Button(_, _, button, state) => {
+ if let Some(surface) = focuses.pointer_on {
+ Some((GlutinEvent::MouseInput(
+ match state {
+ WlPointerButtonState::Pressed => ElementState::Pressed,
+ WlPointerButtonState::Released => ElementState::Released
+ },
+ match button {
+ 0x110 => MouseButton::Left,
+ 0x111 => MouseButton::Right,
+ 0x112 => MouseButton::Middle,
+ // TODO figure out the translation ?
+ _ => return None
+ }
+ ), surface))
+ } else {
+ None
+ }
+ }
+ WlPointerEvent::Axis(_, axis, amplitude) => {
+ if let Some(surface) = focuses.pointer_on {
+ Some((GlutinEvent::MouseWheel(
+ match axis {
+ WlPointerAxis::VerticalScroll => {
+ MouseScrollDelta::PixelDelta(amplitude as f32, 0.0)
+ }
+ WlPointerAxis::HorizontalScroll => {
+ MouseScrollDelta::PixelDelta(0.0, amplitude as f32)
+ }
+ }
+ ), surface))
+ } else {
+ None
+ }
+ }
+ },
+ _ => None
+ }
+} \ No newline at end of file
diff --git a/src/api/wayland/keyboard.rs b/src/api/wayland/keyboard.rs
index 911e897..3190b87 100644
--- a/src/api/wayland/keyboard.rs
+++ b/src/api/wayland/keyboard.rs
@@ -1,26 +1,85 @@
-use super::wayland_kbd::{KbState, keysyms};
+use std::collections::HashSet;
+use Event as GlutinEvent;
+use ElementState;
use VirtualKeyCode;
-pub fn keycode_to_vkey(state: &KbState, keycode: u32) -> Option<VirtualKeyCode> {
- // first line is hard-coded because it must be case insensitive
- // and is a linux constant anyway
- match keycode {
- 1 => return Some(VirtualKeyCode::Escape),
- 2 => return Some(VirtualKeyCode::Key1),
- 3 => return Some(VirtualKeyCode::Key2),
- 4 => return Some(VirtualKeyCode::Key3),
- 5 => return Some(VirtualKeyCode::Key4),
- 6 => return Some(VirtualKeyCode::Key5),
- 7 => return Some(VirtualKeyCode::Key6),
- 8 => return Some(VirtualKeyCode::Key7),
- 9 => return Some(VirtualKeyCode::Key8),
- 10 => return Some(VirtualKeyCode::Key9),
- 11 => return Some(VirtualKeyCode::Key0),
- _ => {}
+use wayland_client::ProxyId;
+use wayland_client::wayland::seat::{WlKeyboardEvent,WlKeyboardKeyState};
+
+use super::wayland_kbd::MappedKeyboardEvent;
+
+use super::context::WaylandFocuses;
+
+pub fn translate_kbd_events(
+ focuses: &mut WaylandFocuses,
+ known_surfaces: &HashSet<ProxyId>,
+) -> Vec<(GlutinEvent, ProxyId)> {
+ let mut out = Vec::new();
+ if let Some(mkbd) = focuses.keyboard.as_mut() {
+ for evt in mkbd {
+ match evt {
+ MappedKeyboardEvent::KeyEvent(kevt) => {
+ if let Some(surface) = focuses.keyboard_on {
+ let vkcode = match kevt.keycode {
+ 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),
+ _ => kevt.as_symbol().and_then(keysym_to_vkey)
+ };
+ let text = kevt.as_utf8();
+ out.push((
+ GlutinEvent::KeyboardInput(
+ match kevt.keystate {
+ WlKeyboardKeyState::Pressed => ElementState::Pressed,
+ WlKeyboardKeyState::Released =>ElementState::Released
+ },
+ (kevt.keycode & 0xff) as u8,
+ vkcode
+ ),
+ surface
+ ));
+ if let Some(c) = text.and_then(|s| s.chars().next()) {
+ out.push((
+ GlutinEvent::ReceivedCharacter(c),
+ surface
+ ));
+ }
+ }
+
+ }
+ MappedKeyboardEvent::Other(oevt) => match oevt {
+ WlKeyboardEvent::Enter(_, surface, _) => {
+ if known_surfaces.contains(&surface) {
+ focuses.keyboard_on = Some(surface);
+ out.push((GlutinEvent::Focused(true), surface));
+ }
+ },
+ WlKeyboardEvent::Leave(_, surface) => {
+ if known_surfaces.contains(&surface) {
+ focuses.keyboard_on = None;
+ out.push((GlutinEvent::Focused(false), surface));
+ }
+ }
+ _ => {}
+ }
+ }
+ }
}
- // for other keys, we use the keysym
- return match state.get_one_sym(keycode) {
+ out
+}
+
+pub 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),
diff --git a/src/api/wayland/mod.rs b/src/api/wayland/mod.rs
index ab71ffa..b6a2602 100644
--- a/src/api/wayland/mod.rs
+++ b/src/api/wayland/mod.rs
@@ -1,495 +1,18 @@
#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd"))]
-#![allow(unused_variables, dead_code)]
-use self::wayland::egl::{EGLSurface, is_egl_available};
-use self::wayland::core::Surface;
-use self::wayland::core::output::Output;
-use self::wayland::core::shell::{ShellSurface, ShellFullscreenMethod};
+pub use self::monitor::{MonitorId, get_available_monitors, get_primary_monitor};
+pub use self::window::{PollEventsIterator, WaitEventsIterator, Window, WindowProxy};
-use self::wayland_window::{DecoratedSurface, SurfaceGuard, substract_borders};
-
-use libc;
-use api::dlopen;
-use api::egl;
-use api::egl::Context as EglContext;
-
-use ContextError;
-use CreationError;
-use Event;
-use PixelFormat;
-use CursorState;
-use MouseCursor;
-use GlAttributes;
-use GlContext;
-use PixelFormatRequirements;
-use WindowAttributes;
-
-use std::collections::VecDeque;
-use std::ops::{Deref, DerefMut};
-use std::sync::{Arc, Mutex};
-use std::ffi::CString;
-
-use platform::MonitorId as PlatformMonitorId;
-
-use self::context::WaylandContext;
-
-extern crate wayland_client as wayland;
extern crate wayland_kbd;
extern crate wayland_window;
mod context;
+mod events;
mod keyboard;
-
-lazy_static! {
- static ref WAYLAND_CONTEXT: Option<WaylandContext> = {
- WaylandContext::new()
- };
-}
+mod monitor;
+mod window;
#[inline]
pub fn is_available() -> bool {
- WAYLAND_CONTEXT.is_some()
-}
-
-enum ShellWindow {
- Plain(ShellSurface<EGLSurface>),
- Decorated(DecoratedSurface<EGLSurface>)
-}
-
-impl ShellWindow {
- #[inline]
- fn get_shell(&mut self) -> ShellGuard {
- match self {
- &mut ShellWindow::Plain(ref mut s) => {
- ShellGuard::Plain(s)
- },
- &mut ShellWindow::Decorated(ref mut s) => {
- ShellGuard::Decorated(s.get_shell())
- }
- }
- }
-
- fn resize(&mut self, w: i32, h: i32, x: i32, y: i32) {
- match self {
- &mut ShellWindow::Plain(ref s) => s.resize(w, h, x, y),
- &mut ShellWindow::Decorated(ref mut s) => {
- s.resize(w, h);
- s.get_shell().resize(w, h, x, y);
- }
- }
- }
-
- fn set_cfg_callback(&mut self, arc: Arc<Mutex<(i32, i32, bool)>>) {
- match self {
- &mut ShellWindow::Decorated(ref mut s) => {
- s.get_shell().set_configure_callback(move |_, w, h| {
- let (w, h) = substract_borders(w, h);
- let mut guard = arc.lock().unwrap();
- *guard = (w, h, true);
- })
- }
- _ => {}
- }
- }
-}
-
-enum ShellGuard<'a> {
- Plain(&'a mut ShellSurface<EGLSurface>),
- Decorated(SurfaceGuard<'a, EGLSurface>)
-}
-
-impl<'a> Deref for ShellGuard<'a> {
- type Target = ShellSurface<EGLSurface>;
-
- #[inline]
- fn deref(&self) -> &ShellSurface<EGLSurface> {
- match self {
- &ShellGuard::Plain(ref s) => s,
- &ShellGuard::Decorated(ref s) => s.deref()
- }
- }
-}
-
-impl<'a> DerefMut for ShellGuard<'a> {
- #[inline]
- fn deref_mut(&mut self) -> &mut ShellSurface<EGLSurface> {
- match self {
- &mut ShellGuard::Plain(ref mut s) => s,
- &mut ShellGuard::Decorated(ref mut s) => s.deref_mut()
- }
- }
-}
-
-pub struct Window {
- shell_window: Mutex<ShellWindow>,
- pending_events: Arc<Mutex<VecDeque<Event>>>,
- need_resize: Arc<Mutex<(i32, i32, bool)>>,
- resize_callback: Option<fn(u32, u32)>,
- pub context: EglContext,
-}
-
-// private methods of wayalnd windows
-
-impl Window {
- fn resize_if_needed(&self) -> bool {
- let mut guard = self.need_resize.lock().unwrap();
- let (w, h, b) = *guard;
- *guard = (0, 0, false);
- if b {
- let mut guard = self.shell_window.lock().unwrap();
- guard.resize(w, h, 0, 0);
- if let Some(f) = self.resize_callback {
- f(w as u32, h as u32);
- }
- if let Some(ref ctxt) = *WAYLAND_CONTEXT {
- let mut window_guard = self.shell_window.lock().unwrap();
- ctxt.push_event_for(
- window_guard.get_shell().get_wsurface().get_id(),
- Event::Resized(w as u32, h as u32)
- );
- }
- }
- b
- }
-}
-
-#[derive(Clone)]
-pub struct WindowProxy;
-
-impl WindowProxy {
- #[inline]
- pub fn wakeup_event_loop(&self) {
- if let Some(ref ctxt) = *WAYLAND_CONTEXT {
- ctxt.display.sync();
- }
- }
-}
-
-#[derive(Clone)]
-pub struct MonitorId {
- output: Arc<Output>
-}
-
-#[inline]
-pub fn get_available_monitors() -> VecDeque<MonitorId> {
- WAYLAND_CONTEXT.as_ref().unwrap().outputs.iter().map(|o| MonitorId::new(o.clone())).collect()
-}
-#[inline]
-pub fn get_primary_monitor() -> MonitorId {
- match WAYLAND_CONTEXT.as_ref().unwrap().outputs.iter().next() {
- Some(o) => MonitorId::new(o.clone()),
- None => panic!("No monitor is available.")
- }
-}
-
-impl MonitorId {
- fn new(output: Arc<Output>) -> MonitorId {
- MonitorId {
- output: output
- }
- }
-
- pub fn get_name(&self) -> Option<String> {
- Some(format!("{} - {}", self.output.manufacturer(), self.output.model()))
- }
-
- #[inline]
- pub fn get_native_identifier(&self) -> ::native_monitor::NativeMonitorId {
- ::native_monitor::NativeMonitorId::Unavailable
- }
-
- pub fn get_dimensions(&self) -> (u32, u32) {
- let (w, h) = self.output.modes()
- .into_iter()
- .find(|m| m.is_current())
- .map(|m| (m.width, m.height))
- .unwrap();
- (w as u32, h as u32)
- }
-}
-
-
-pub struct PollEventsIterator<'a> {
- window: &'a Window,
-}
-
-impl<'a> Iterator for PollEventsIterator<'a> {
- type Item = Event;
-
- fn next(&mut self) -> Option<Event> {
- if let Some(ref ctxt) = *WAYLAND_CONTEXT {
- ctxt.display.dispatch_pending();
- }
- if self.window.resize_if_needed() {
- Some(Event::Refresh)
- } else {
- self.window.pending_events.lock().unwrap().pop_front()
- }
- }
-}
-
-pub struct WaitEventsIterator<'a> {
- window: &'a Window,
-}
-
-impl<'a> Iterator for WaitEventsIterator<'a> {
- type Item = Event;
-
- fn next(&mut self) -> Option<Event> {
- let mut evt = None;
- while evt.is_none() {
- if let Some(ref ctxt) = *WAYLAND_CONTEXT {
- ctxt.display.dispatch();
- }
- evt = if self.window.resize_if_needed() {
- Some(Event::Refresh)
- } else {
- self.window.pending_events.lock().unwrap().pop_front()
- };
- }
- evt
- }
-}
-
-impl Window {
- pub fn new(window: &WindowAttributes, pf_reqs: &PixelFormatRequirements,
- opengl: &GlAttributes<&Window>) -> Result<Window, CreationError>
- {
- use self::wayland::internals::FFI;
-
- // not implemented
- assert!(window.min_dimensions.is_none());
- assert!(window.max_dimensions.is_none());
-
- let wayland_context = match *WAYLAND_CONTEXT {
- Some(ref c) => c,
- None => return Err(CreationError::NotSupported),
- };
-
- if !is_egl_available() { return Err(CreationError::NotSupported) }
-
- let (w, h) = window.dimensions.unwrap_or((800, 600));
-
- let surface = EGLSurface::new(
- wayland_context.compositor.create_surface(),
- w as i32,
- h as i32
- );
-
- let mut shell_window = if let Some(PlatformMonitorId::Wayland(ref monitor)) = window.monitor {
- let shell_surface = wayland_context.shell.get_shell_surface(surface);
- shell_surface.set_fullscreen(ShellFullscreenMethod::Default, Some(&monitor.output));
- ShellWindow::Plain(shell_surface)
- } else {
- if window.decorations {
- ShellWindow::Decorated(match DecoratedSurface::new(
- surface,
- w as i32,
- h as i32,
- &wayland_context.registry,
- Some(&wayland_context.seat)
- ) {
- Ok(s) => s,
- Err(_) => return Err(CreationError::NotSupported)
- })
- } else {
- ShellWindow::Plain(wayland_context.shell.get_shell_surface(surface))
- }
- };
-
- 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((**shell_window.get_shell()).ptr() as *const _))
- )
- };
-
- // create a queue already containing a refresh event to trigger first draw
- // it's harmless and a removes the need to do a first swap_buffers() before
- // starting the event loop
- let events = Arc::new(Mutex::new({
- let mut v = VecDeque::new();
- v.push_back(Event::Refresh);
- v
- }));
-
- wayland_context.register_surface(shell_window.get_shell().get_wsurface().get_id(),
- events.clone());
-
- let need_resize = Arc::new(Mutex::new((0, 0, false)));
-
- shell_window.set_cfg_callback(need_resize.clone());
-
- wayland_context.display.flush().unwrap();
-
- Ok(Window {
- shell_window: Mutex::new(shell_window),
- pending_events: events,
- need_resize: need_resize,
- resize_callback: None,
- context: context
- })
- }
-
- pub fn set_title(&self, title: &str) {
- let ctitle = CString::new(title).unwrap();
- // intermediate variable is forced,
- // see https://github.com/rust-lang/rust/issues/22921
- let mut guard = self.shell_window.lock().unwrap();
- guard.get_shell().set_title(&ctitle);
- }
-
- #[inline]
- pub fn show(&self) {
- // TODO
- }
-
- #[inline]
- pub fn hide(&self) {
- // TODO
- }
-
- #[inline]
- pub fn get_position(&self) -> Option<(i32, i32)> {
- // not available with wayland
- None
- }
-
- #[inline]
- pub fn set_position(&self, _x: i32, _y: i32) {
- // not available with wayland
- }
-
- pub fn get_inner_size(&self) -> Option<(u32, u32)> {
- // intermediate variables are forced,
- // see https://github.com/rust-lang/rust/issues/22921
- let mut guard = self.shell_window.lock().unwrap();
- let shell = guard.get_shell();
- let (w, h) = shell.get_attached_size();
- Some((w as u32, h as u32))
- }
-
- #[inline]
- pub fn get_outer_size(&self) -> Option<(u32, u32)> {
- // maybe available if we draw the border ourselves ?
- // but for now, no.
- None
- }
-
- #[inline]
- pub fn set_inner_size(&self, x: u32, y: u32) {
- self.shell_window.lock().unwrap().resize(x as i32, y as i32, 0, 0)
- }
-
- #[inline]
- pub fn create_window_proxy(&self) -> WindowProxy {
- WindowProxy
- }
-
- #[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)>) {
- self.resize_callback = callback;
- }
-
- #[inline]
- pub fn set_cursor(&self, cursor: MouseCursor) {
- // TODO
- }
-
- #[inline]
- pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
- // TODO
- Ok(())
- }
-
- #[inline]
- pub fn hidpi_factor(&self) -> f32 {
- 1.0
- }
-
- #[inline]
- pub fn set_cursor_position(&self, x: i32, y: i32) -> Result<(), ()> {
- // TODO
- Ok(())
- }
-
- #[inline]
- pub fn platform_display(&self) -> *mut libc::c_void {
- unimplemented!()
- }
-
- #[inline]
- pub fn platform_window(&self) -> *mut libc::c_void {
- unimplemented!()
- }
-}
-
-impl GlContext for Window {
- #[inline]
- unsafe fn make_current(&self) -> Result<(), ContextError> {
- self.context.make_current()
- }
-
- #[inline]
- fn is_current(&self) -> bool {
- self.context.is_current()
- }
-
- #[inline]
- fn get_proc_address(&self, addr: &str) -> *const () {
- self.context.get_proc_address(addr)
- }
-
- #[inline]
- fn swap_buffers(&self) -> Result<(), ContextError> {
- self.context.swap_buffers()
- }
-
- #[inline]
- fn get_api(&self) -> ::Api {
- self.context.get_api()
- }
-
- #[inline]
- fn get_pixel_format(&self) -> PixelFormat {
- self.context.get_pixel_format().clone()
- }
-}
-
-impl Drop for Window {
- fn drop(&mut self) {
- if let Some(ref ctxt) = *WAYLAND_CONTEXT {
- // intermediate variable is forced,
- // see https://github.com/rust-lang/rust/issues/22921
- let mut guard = self.shell_window.lock().unwrap();
- let shell = guard.get_shell();
- ctxt.deregister_surface(
- shell.get_wsurface().get_id()
- )
- }
- }
+ context::WAYLAND_CONTEXT.is_some()
}
diff --git a/src/api/wayland/monitor.rs b/src/api/wayland/monitor.rs
new file mode 100644
index 0000000..d87d4b6
--- /dev/null
+++ b/src/api/wayland/monitor.rs
@@ -0,0 +1,75 @@
+use std::collections::VecDeque;
+
+use wayland_client::{ProxyId, EventIterator};
+use wayland_client::wayland::output::WlOutput;
+
+use super::context::WAYLAND_CONTEXT;
+
+#[derive(Clone)]
+pub struct MonitorId(ProxyId);
+
+#[inline]
+pub fn get_available_monitors() -> VecDeque<MonitorId> {
+ WAYLAND_CONTEXT.as_ref().map(|ctxt|
+ ctxt.monitor_ids().into_iter().map(MonitorId).collect()
+ ).unwrap_or(VecDeque::new())
+}
+#[inline]
+pub fn get_primary_monitor() -> MonitorId {
+ WAYLAND_CONTEXT.as_ref().and_then(|ctxt|
+ ctxt.monitor_ids().into_iter().next().map(MonitorId)
+ ).expect("wayland: No monitor available.")
+}
+
+impl MonitorId {
+ pub fn get_name(&self) -> Option<String> {
+ WAYLAND_CONTEXT.as_ref().and_then(|ctxt| ctxt.monitor_name(self.0))
+ }
+
+ #[inline]
+ pub fn get_native_identifier(&self) -> ::native_monitor::NativeMonitorId {
+ ::native_monitor::NativeMonitorId::Unavailable
+ }
+
+ pub fn get_dimensions(&self) -> (u32, u32) {
+ WAYLAND_CONTEXT.as_ref().and_then(|ctxt| ctxt.monitor_dimensions(self.0)).unwrap()
+ }
+}
+
+pub fn proxid_from_monitorid(x: &MonitorId) -> ProxyId {
+ x.0
+}
+
+pub fn init_monitors(outputs: &mut Vec<(WlOutput, u32, u32, String)>, evts: EventIterator) {
+ use wayland_client::{Event, Proxy};
+ use wayland_client::wayland::WaylandProtocolEvent;
+ use wayland_client::wayland::output::{WlOutputEvent, WlOutputMode};
+
+ for evt in evts {
+ match evt {
+ Event::Wayland(WaylandProtocolEvent::WlOutput(pid, oevt)) => match oevt {
+ WlOutputEvent::Geometry(_, _, _, _, _, maker, model, _) => {
+ for o in outputs.iter_mut() {
+ if o.0.id() == pid {
+ o.3 = format!("{} - {}", maker, model);
+ break
+ }
+ }
+ },
+ WlOutputEvent::Mode(flags, width, height, _) => {
+ if flags.contains(WlOutputMode::Current) {
+ for o in outputs.iter_mut() {
+ if o.0.id() == pid {
+ o.1 = width as u32;
+ o.2 = height as u32;
+ break
+ }
+ }
+ }
+ },
+ _ => {}
+ },
+ _ => {}
+ }
+ }
+} \ No newline at end of file
diff --git a/src/api/wayland/window.rs b/src/api/wayland/window.rs
new file mode 100644
index 0000000..0005a83
--- /dev/null
+++ b/src/api/wayland/window.rs
@@ -0,0 +1,370 @@
+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 platform::MonitorId as PlatformMonitorId;
+
+use wayland_client::EventIterator;
+use wayland_client::egl as wegl;
+use wayland_client::wayland::shell::WlShellSurface;
+use super::wayland_window::{DecoratedSurface, add_borders, substract_borders};
+use super::context::{WaylandContext, WAYLAND_CONTEXT};
+
+#[derive(Clone)]
+pub struct WindowProxy;
+
+impl WindowProxy {
+ #[inline]
+ pub fn wakeup_event_loop(&self) {
+ unimplemented!()
+ }
+}
+
+pub struct Window {
+ wayland_context: &'static WaylandContext,
+ egl_surface: wegl::WlEglSurface,
+ shell_window: Mutex<ShellWindow>,
+ 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> {
+ use wayland_client::Event as WEvent;
+ use wayland_client::wayland::WaylandProtocolEvent;
+ use wayland_client::wayland::shell::WlShellSurfaceEvent;
+
+ let mut newsize = None;
+ let mut evt_queue_guard = self.evt_queue.lock().unwrap();
+
+ let mut shell_window_guard = self.shell_window.lock().unwrap();
+ match *shell_window_guard {
+ ShellWindow::Decorated(ref mut deco) => {
+ for (_, w, h) in deco {
+ newsize = Some((w, h));
+ }
+ },
+ ShellWindow::Plain(ref plain, ref mut evtiter) => {
+ for evt in evtiter {
+ if let WEvent::Wayland(WaylandProtocolEvent::WlShellSurface(_, ssevt)) = evt {
+ match ssevt {
+ WlShellSurfaceEvent::Ping(u) => {
+ plain.pong(u);
+ },
+ WlShellSurfaceEvent::Configure(_, w, h) => {
+ newsize = Some((w, h));
+ },
+ _ => {}
+ }
+ }
+ }
+ }
+ }
+
+ if let Some((w, h)) = newsize {
+ let (w, h) = substract_borders(w, h);
+ *self.inner_size.lock().unwrap() = (w, h);
+ if let ShellWindow::Decorated(ref mut deco) = *shell_window_guard {
+ deco.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 {
+ evt_queue_guard.pop_front()
+ }
+ }
+}
+
+pub struct PollEventsIterator<'a> {
+ window: &'a Window,
+}
+
+impl<'a> Iterator for PollEventsIterator<'a> {
+ type Item = Event;
+
+ fn next(&mut self) -> Option<Event> {
+ 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();
+ }
+}
+
+pub struct WaitEventsIterator<'a> {
+ window: &'a Window,
+}
+
+impl<'a> Iterator for WaitEventsIterator<'a> {
+ type Item = Event;
+
+ fn next(&mut self) -> Option<Event> {
+ 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.")
+ }
+ }
+ }
+}
+
+enum ShellWindow {
+ Plain(WlShellSurface, EventIterator),
+ Decorated(DecoratedSurface)
+}
+
+impl Window {
+ pub fn new(window: &WindowAttributes, pf_reqs: &PixelFormatRequirements,
+ opengl: &GlAttributes<&Window>) -> Result<Window, CreationError>
+ {
+ use wayland_client::Proxy;
+ // not implemented
+ assert!(window.min_dimensions.is_none());
+ assert!(window.max_dimensions.is_none());
+
+ 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 shell_window = if let Some(PlatformMonitorId::Wayland(ref monitor_id)) = window.monitor {
+ let pid = super::monitor::proxid_from_monitorid(monitor_id);
+ match wayland_context.plain_from(&egl_surface, Some(pid)) {
+ Some(mut s) => {
+ let iter = EventIterator::new();
+ s.set_evt_iterator(&iter);
+ ShellWindow::Plain(s, iter)
+ },
+ None => return Err(CreationError::NotSupported)
+ }
+ } else if window.decorations {
+ match wayland_context.decorated_from(&egl_surface, w as i32, h as i32) {
+ Some(s) => ShellWindow::Decorated(s),
+ None => return Err(CreationError::NotSupported)
+ }
+ } else {
+ match wayland_context.plain_from(&egl_surface, None) {
+ Some(mut s) => {
+ let iter = EventIterator::new();
+ s.set_evt_iterator(&iter);
+ ShellWindow::Plain(s, iter)
+ },
+ None => return Err(CreationError::NotSupported)
+ }
+ };
+
+ Ok(Window {
+ wayland_context: wayland_context,
+ egl_surface: egl_surface,
+ shell_window: Mutex::new(shell_window),
+ 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) {
+ let guard = self.shell_window.lock().unwrap();
+ match *guard {
+ ShellWindow::Plain(ref plain, _) => { plain.set_title(title.into()); },
+ ShellWindow::Decorated(ref deco) => { deco.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)> {
+ 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)> {
+ 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) {
+ let mut guard = self.shell_window.lock().unwrap();
+ match *guard {
+ ShellWindow::Decorated(ref mut deco) => { deco.resize(x as i32, y as i32); },
+ _ => {}
+ }
+ self.egl_surface.resize(x as i32, y as i32, 0, 0)
+ }
+
+ #[inline]
+ pub fn create_window_proxy(&self) -> WindowProxy {
+ WindowProxy
+ }
+
+ #[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)>) {
+ self.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 {
+ 1.0
+ }
+
+ #[inline]
+ pub fn set_cursor_position(&self, _x: i32, _y: i32) -> Result<(), ()> {
+ // TODO: not yet possible on wayland
+ Err(())
+ }
+
+ #[inline]
+ pub fn platform_display(&self) -> *mut libc::c_void {
+ unimplemented!()
+ }
+
+ #[inline]
+ pub fn platform_window(&self) -> *mut libc::c_void {
+ unimplemented!()
+ }
+}
+
+impl GlContext for Window {
+ #[inline]
+ unsafe fn make_current(&self) -> Result<(), ContextError> {
+ self.context.make_current()
+ }
+
+ #[inline]
+ fn is_current(&self) -> bool {
+ self.context.is_current()
+ }
+
+ #[inline]
+ fn get_proc_address(&self, addr: &str) -> *const () {
+ self.context.get_proc_address(addr)
+ }
+
+ #[inline]
+ fn swap_buffers(&self) -> Result<(), ContextError> {
+ self.context.swap_buffers()
+ }
+
+ #[inline]
+ fn get_api(&self) -> ::Api {
+ self.context.get_api()
+ }
+
+ #[inline]
+ fn get_pixel_format(&self) -> PixelFormat {
+ 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())
+ }
+} \ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
index 5b1aa03..6cc0da7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -56,6 +56,9 @@ extern crate core_foundation;
extern crate core_graphics;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly"))]
extern crate x11_dl;
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly"))]
+#[macro_use(wayland_env)]
+extern crate wayland_client;
pub use events::*;
pub use headless::{HeadlessRendererBuilder, HeadlessContext};
diff --git a/src/platform/linux/api_dispatch.rs b/src/platform/linux/api_dispatch.rs
index f39ae43..a304f7a 100644
--- a/src/platform/linux/api_dispatch.rs
+++ b/src/platform/linux/api_dispatch.rs
@@ -30,7 +30,7 @@ enum Backend {
lazy_static!(
static ref BACKEND: Backend = {
// Wayland backend is not production-ready yet so we disable it
- if false && wayland::is_available() {
+ if wayland::is_available() {
Backend::Wayland
} else {
match XConnection::new(Some(x_error_callback)) {
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-22 03:36:54 +0000