From c991172a28755e43981b9cea65f873d5cdd8dd87 Mon Sep 17 00:00:00 2001 From: Victor Berger Date: Fri, 7 Oct 2016 19:52:19 +0200 Subject: [PATCH] wayland: remove old code for new backend --- Cargo.toml | 6 +- src/api/wayland/context.rs | 231 +++++------------------------ src/api/wayland/events.rs | 112 -------------- src/api/wayland/keyboard.rs | 229 ---------------------------- src/api/wayland/mod.rs | 10 +- src/api/wayland/monitor.rs | 75 ---------- src/api/wayland/window.rs | 208 +++----------------------- src/os/unix.rs | 23 ++- src/platform/linux/api_dispatch.rs | 23 ++- 9 files changed, 83 insertions(+), 834 deletions(-) delete mode 100644 src/api/wayland/events.rs delete mode 100644 src/api/wayland/keyboard.rs delete mode 100644 src/api/wayland/monitor.rs diff --git a/Cargo.toml b/Cargo.toml index b2af1c94..da966210 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -39,7 +39,7 @@ kernel32-sys = "0.2" dwmapi-sys = "0.1" [target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))'.dependencies] -wayland-client = { version = "0.5.4", features = ["dlopen"] } -wayland-kbd = "0.3.3" -wayland-window = "0.2.2" +wayland-client = { version = "0.7.1", features = ["dlopen"] } +wayland-kbd = "0.6" +wayland-window = "0.4" x11-dl = "2.8" diff --git a/src/api/wayland/context.rs b/src/api/wayland/context.rs index 58789202..dc03e964 100644 --- a/src/api/wayland/context.rs +++ b/src/api/wayland/context.rs @@ -1,211 +1,46 @@ -use Event as GlutinEvent; +use std::collections::VecDeque; -use std::collections::{HashMap, VecDeque, HashSet}; -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, WlPointer}; -use wayland_client::wayland::shell::{WlShell, WlShellSurface}; -use wayland_client::wayland::shm::WlShm; -use wayland_client::wayland::subcompositor::WlSubcompositor; - -use super::wayland_kbd::MappedKeyboard; -use super::wayland_window::DecoratedSurface; - -lazy_static! { - pub static ref WAYLAND_CONTEXT: Option = { - WaylandContext::init() - }; -} +use wayland_client::protocol::{wl_compositor, wl_seat, wl_shell, wl_shm, wl_subcompositor}; wayland_env!(InnerEnv, - compositor: WlCompositor, - seat: WlSeat, - shell: WlShell, - shm: WlShm, - subcompositor: WlSubcompositor + compositor: wl_compositor::WlCompositor, + seat: wl_seat::WlSeat, + shell: wl_shell::WlShell, + shm: wl_shm::WlShm, + subcompositor: wl_subcompositor::WlSubcompositor ); -pub struct WaylandFocuses { - pub pointer: Option, - pub pointer_on: Option, - pub pointer_at: Option<(f64, f64)>, - pub keyboard: Option, - pub keyboard_on: Option -} - pub struct WaylandContext { - inner: InnerEnv, - iterator: Mutex, - monitors: Vec<(WlOutput, u32, u32, String)>, - queues: Mutex>>>>, - known_surfaces: Mutex>, - focuses: 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 outputs_events = EventIterator::new(); - - let mut monitors = inner_env.globals.iter() - .flat_map(|&(id, _, _)| inner_env.rebind_id::(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>>)> { - 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 { - 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 plain_from(&self, surface: &WlSurface, fullscreen: Option) -> Option { - 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 - } - } - - 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); - } - } - } - } - - 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)); - } - - pub fn monitor_ids(&self) -> Vec { - self.monitors.iter().map(|o| o.0.id()).collect() - } - - pub fn monitor_name(&self, pid: ProxyId) -> Option { - for o in &self.monitors { - if o.0.id() == pid { - return Some(o.3.clone()) - } - } + pub fn init() -> Option { None } - - 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 + + pub fn get_primary_monitor(&self) -> MonitorId { + unimplemented!() + } + + pub fn get_available_monitors(&self) -> VecDeque { + unimplemented!() + } +} + +#[derive(Clone)] +pub struct MonitorId; + +impl MonitorId { + pub fn get_name(&self) -> Option { + unimplemented!() + } + + #[inline] + pub fn get_native_identifier(&self) -> ::native_monitor::NativeMonitorId { + ::native_monitor::NativeMonitorId::Unavailable + } + + pub fn get_dimensions(&self) -> (u32, u32) { + unimplemented!() } } diff --git a/src/api/wayland/events.rs b/src/api/wayland/events.rs deleted file mode 100644 index 92a0b95f..00000000 --- a/src/api/wayland/events.rs +++ /dev/null @@ -1,112 +0,0 @@ -use std::collections::HashSet; - -use TouchPhase; -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, - 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) - } - }, - TouchPhase::Moved - ), surface)) - } else { - None - } - } - }, - _ => None - } -} diff --git a/src/api/wayland/keyboard.rs b/src/api/wayland/keyboard.rs deleted file mode 100644 index 3190b870..00000000 --- a/src/api/wayland/keyboard.rs +++ /dev/null @@ -1,229 +0,0 @@ -use std::collections::HashSet; - -use Event as GlutinEvent; -use ElementState; -use VirtualKeyCode; - -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, -) -> 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)); - } - } - _ => {} - } - } - } - } - out -} - -pub fn keysym_to_vkey(keysym: u32) -> Option { - 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 - } -} \ No newline at end of file diff --git a/src/api/wayland/mod.rs b/src/api/wayland/mod.rs index 77f018e5..11ab4842 100644 --- a/src/api/wayland/mod.rs +++ b/src/api/wayland/mod.rs @@ -1,18 +1,10 @@ #![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))] -pub use self::monitor::{MonitorId, get_available_monitors, get_primary_monitor}; pub use self::window::{PollEventsIterator, WaitEventsIterator, Window, WindowProxy}; +pub use self::context::{WaylandContext,MonitorId}; extern crate wayland_kbd; extern crate wayland_window; mod context; -mod events; -mod keyboard; -mod monitor; mod window; - -#[inline] -pub fn is_available() -> bool { - context::WAYLAND_CONTEXT.is_some() -} diff --git a/src/api/wayland/monitor.rs b/src/api/wayland/monitor.rs deleted file mode 100644 index d87d4b67..00000000 --- a/src/api/wayland/monitor.rs +++ /dev/null @@ -1,75 +0,0 @@ -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 { - 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 { - 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 index 38f89bfe..99b7e694 100644 --- a/src/api/wayland/window.rs +++ b/src/api/wayland/window.rs @@ -1,16 +1,10 @@ -use std::collections::VecDeque; -use std::sync::{Arc, Mutex}; +use std::sync::Arc; -use libc; +use wayland_client::protocol::{wl_display,wl_surface}; -use {CreationError, CursorState, Event, MouseCursor, WindowAttributes}; -use platform::MonitorId as PlatformMonitorId; +use {CreationError, MouseCursor, CursorState, Event, WindowAttributes}; -use wayland_client::EventIterator; -use wayland_client::wayland::compositor::WlSurface; -use wayland_client::wayland::shell::WlShellSurface; -use super::wayland_window::{DecoratedSurface, add_borders, substract_borders}; -use super::context::{WaylandContext, WAYLAND_CONTEXT}; +use super::WaylandContext; #[derive(Clone)] pub struct WindowProxy; @@ -23,61 +17,7 @@ impl WindowProxy { } pub struct Window { - wayland_context: &'static WaylandContext, - surface: WlSurface, - shell_window: Mutex, - evt_queue: Arc>>, - inner_size: Mutex<(i32, i32)>, - resize_callback: Option, -} - -impl Window { - fn next_event(&self) -> Option { - 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); - } - 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() - } - } + resize_callback: Option } pub struct PollEventsIterator<'a> { @@ -88,13 +28,7 @@ impl<'a> Iterator for PollEventsIterator<'a> { type Item = Event; fn next(&mut self) -> Option { - 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(); + unimplemented!() } } @@ -106,91 +40,18 @@ impl<'a> Iterator for WaitEventsIterator<'a> { type Item = Event; fn next(&mut self) -> Option { - 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.") - } - } + unimplemented!() } } -enum ShellWindow { - Plain(WlShellSurface, EventIterator), - Decorated(DecoratedSurface) -} - impl Window { - pub fn new(window: &WindowAttributes) -> Result + pub fn new(ctxt: Arc, attributes: &WindowAttributes) -> Result { - 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), - }; - - 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 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(&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(&surface, w as i32, h as i32) { - Some(s) => ShellWindow::Decorated(s), - None => return Err(CreationError::NotSupported) - } - } else { - match wayland_context.plain_from(&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, - surface: surface, - shell_window: Mutex::new(shell_window), - evt_queue: evt_queue, - inner_size: Mutex::new((w as i32, h as i32)), - resize_callback: None, - }) + unimplemented!() } 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()); } - } + // TODO } #[inline] @@ -215,24 +76,19 @@ impl Window { } pub fn get_inner_size(&self) -> Option<(u32, u32)> { - let (w, h) = *self.inner_size.lock().unwrap(); - Some((w as u32, h as u32)) + // TODO + None } #[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)) + // TODO + None } #[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); }, - _ => {} - } + // TODO } #[inline] @@ -277,6 +133,7 @@ impl Window { #[inline] pub fn hidpi_factor(&self) -> f32 { + // TODO 1.0 } @@ -285,35 +142,18 @@ impl Window { // TODO: not yet possible on wayland Err(()) } - - #[inline] - pub fn get_wayland_display(&self) -> *mut libc::c_void { - WAYLAND_CONTEXT.as_ref().unwrap() // context exists if window was created - .display_ptr() as *mut libc::c_void + + pub fn get_display(&self) -> &wl_display::WlDisplay { + unimplemented!() } - - #[inline] - pub fn get_wayland_surface(&self) -> *mut libc::c_void { - use wayland_client::Proxy; - self.surface.ptr() as *mut libc::c_void - } - - #[inline] - pub fn platform_display(&self) -> *mut libc::c_void { - WAYLAND_CONTEXT.as_ref().unwrap() // context exists if window was created - .display_ptr() as *mut libc::c_void - } - - #[inline] - pub fn platform_window(&self) -> *mut libc::c_void { - use wayland_client::Proxy; - self.surface.ptr() as *mut libc::c_void + + pub fn get_surface(&self) -> &wl_surface::WlSurface { + unimplemented!() } } impl Drop for Window { fn drop(&mut self) { - use wayland_client::Proxy; - self.wayland_context.dropped_surface(self.surface.id()); + // TODO } -} \ No newline at end of file +} diff --git a/src/os/unix.rs b/src/os/unix.rs index c4dfac90..ae5928cd 100644 --- a/src/os/unix.rs +++ b/src/os/unix.rs @@ -5,6 +5,9 @@ use Window; use platform::Window as LinuxWindow; use WindowBuilder; +use wayland_client::protocol::wl_display::WlDisplay; +use wayland_client::protocol::wl_surface::WlSurface; + /// Additional methods on `Window` that are specific to Unix. pub trait WindowExt { /// Returns a pointer to the `Window` object of xlib that is used by this window. @@ -29,19 +32,15 @@ pub trait WindowExt { /// The pointer will become invalid when the glutin `Window` is destroyed. fn get_xcb_connection(&self) -> Option<*mut libc::c_void>; - /// Returns a pointer to the `wl_surface` object of wayland that is used by this window. + /// Returns a reference to the `WlSurface` object of wayland that is used by this window. /// /// Returns `None` if the window doesn't use wayland (if it uses xlib for example). - /// - /// The pointer will become invalid when the glutin `Window` is destroyed. - fn get_wayland_surface(&self) -> Option<*mut libc::c_void>; + fn get_wayland_surface(&self) -> Option<&WlSurface>; - /// Returns a pointer to the `wl_display` object of wayland that is used by this window. + /// Returns a pointer to the `WlDisplay` object of wayland that is used by this window. /// /// Returns `None` if the window doesn't use wayland (if it uses xlib for example). - /// - /// The pointer will become invalid when the glutin `Window` is destroyed. - fn get_wayland_display(&self) -> Option<*mut libc::c_void>; + fn get_wayland_display(&self) -> Option<&WlDisplay>; } impl WindowExt for Window { @@ -69,17 +68,17 @@ impl WindowExt for Window { } #[inline] - fn get_wayland_surface(&self) -> Option<*mut libc::c_void> { + fn get_wayland_surface(&self) -> Option<&WlSurface> { match self.window { - LinuxWindow::Wayland(ref w) => Some(w.get_wayland_surface()), + LinuxWindow::Wayland(ref w) => Some(w.get_surface()), _ => None } } #[inline] - fn get_wayland_display(&self) -> Option<*mut libc::c_void> { + fn get_wayland_display(&self) -> Option<&WlDisplay> { match self.window { - LinuxWindow::Wayland(ref w) => Some(w.get_wayland_display()), + LinuxWindow::Wayland(ref w) => Some(w.get_display()), _ => None } } diff --git a/src/platform/linux/api_dispatch.rs b/src/platform/linux/api_dispatch.rs index 975cadaf..6b542c81 100644 --- a/src/platform/linux/api_dispatch.rs +++ b/src/platform/linux/api_dispatch.rs @@ -1,6 +1,3 @@ -/*pub use api::x11::{Window, WindowProxy, MonitorId, get_available_monitors, get_primary_monitor}; -pub use api::x11::{WaitEventsIterator, PollEventsIterator};*/ - use std::collections::VecDeque; use std::sync::Arc; @@ -22,15 +19,15 @@ pub struct PlatformSpecificWindowBuilderAttributes; enum Backend { X(Arc), - Wayland, + Wayland(Arc), Error(XNotSupported), } lazy_static!( static ref BACKEND: Backend = { // Wayland backend is not production-ready yet so we disable it - if wayland::is_available() { - Backend::Wayland + if let Some(ctxt) = wayland::WaylandContext::init() { + Backend::Wayland(Arc::new(ctxt)) } else { match XConnection::new(Some(x_error_callback)) { Ok(x) => Backend::X(Arc::new(x)), @@ -78,7 +75,7 @@ pub enum MonitorId { #[inline] pub fn get_available_monitors() -> VecDeque { match *BACKEND { - Backend::Wayland => wayland::get_available_monitors() + Backend::Wayland(ref ctxt) => ctxt.get_available_monitors() .into_iter() .map(MonitorId::Wayland) .collect(), @@ -93,7 +90,7 @@ pub fn get_available_monitors() -> VecDeque { #[inline] pub fn get_primary_monitor() -> MonitorId { match *BACKEND { - Backend::Wayland => MonitorId::Wayland(wayland::get_primary_monitor()), + Backend::Wayland(ref ctxt) => MonitorId::Wayland(ctxt.get_primary_monitor()), Backend::X(ref connec) => MonitorId::X(x11::get_primary_monitor(connec)), Backend::Error(_) => MonitorId::None, } @@ -173,8 +170,8 @@ impl Window { -> Result { match *BACKEND { - Backend::Wayland => { - wayland::Window::new(window).map(Window::Wayland) + Backend::Wayland(ref ctxt) => { + wayland::Window::new(ctxt.clone(), window).map(Window::Wayland) }, Backend::X(ref connec) => { @@ -318,17 +315,19 @@ impl Window { #[inline] pub fn platform_display(&self) -> *mut libc::c_void { + use wayland_client::Proxy; match self { &Window::X(ref w) => w.platform_display(), - &Window::Wayland(ref w) => w.platform_display() + &Window::Wayland(ref w) => w.get_display().ptr() as *mut _ } } #[inline] pub fn platform_window(&self) -> *mut libc::c_void { + use wayland_client::Proxy; match self { &Window::X(ref w) => w.platform_window(), - &Window::Wayland(ref w) => w.platform_window() + &Window::Wayland(ref w) => w.get_surface().ptr() as *mut _ } } }