aboutsummaryrefslogtreecommitdiffstats
path: root/src/api
diff options
context:
space:
mode:
Diffstat (limited to 'src/api')
-rw-r--r--src/api/wayland/context.rs10
-rw-r--r--src/api/wayland/mod.rs186
2 files changed, 168 insertions, 28 deletions
diff --git a/src/api/wayland/context.rs b/src/api/wayland/context.rs
index 1af6311..6d7df86 100644
--- a/src/api/wayland/context.rs
+++ b/src/api/wayland/context.rs
@@ -25,7 +25,7 @@ pub struct WaylandContext {
pub compositor: Compositor,
pub shell: Shell,
pub seat: Seat,
- pub pointer: Option<Pointer<WSurface>>,
+ 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>>>,
@@ -196,7 +196,7 @@ impl WaylandContext {
compositor: compositor,
shell: shell,
seat: seat,
- pointer: pointer,
+ pointer: pointer.map(|p| Mutex::new(p)),
keyboard: keyboard,
windows_event_queues: windows_event_queues,
current_pointer_surface: current_pointer_surface,
@@ -207,9 +207,15 @@ impl WaylandContext {
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 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);
+ }
}
} \ No newline at end of file
diff --git a/src/api/wayland/mod.rs b/src/api/wayland/mod.rs
index 77ebc16..ba1931b 100644
--- a/src/api/wayland/mod.rs
+++ b/src/api/wayland/mod.rs
@@ -6,6 +6,8 @@ use self::wayland::core::Surface;
use self::wayland::core::output::Output;
use self::wayland::core::shell::{ShellSurface, ShellFullscreenMethod};
+use self::wayland_window::{DecoratedSurface, SurfaceGuard, substract_borders};
+
use libc;
use api::dlopen;
use api::egl;
@@ -21,6 +23,7 @@ use MouseCursor;
use GlContext;
use std::collections::VecDeque;
+use std::ops::{Deref, DerefMut};
use std::sync::{Arc, Mutex};
use std::ffi::CString;
@@ -30,6 +33,7 @@ use self::context::WaylandContext;
extern crate wayland_client as wayland;
extern crate wayland_kbd;
+extern crate wayland_window;
mod context;
mod keyboard;
@@ -44,12 +48,97 @@ pub fn is_available() -> bool {
WAYLAND_CONTEXT.is_some()
}
+enum ShellWindow {
+ Plain(ShellSurface<EGLSurface>),
+ Decorated(DecoratedSurface<EGLSurface>)
+}
+
+impl ShellWindow {
+ 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>;
+ fn deref(&self) -> &ShellSurface<EGLSurface> {
+ match self {
+ &ShellGuard::Plain(ref s) => s,
+ &ShellGuard::Decorated(ref s) => s.deref()
+ }
+ }
+}
+
+impl<'a> DerefMut for ShellGuard<'a> {
+ 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_surface: ShellSurface<EGLSurface>,
+ 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);
+ }
+ }
+ b
+ }
+}
+
#[derive(Clone)]
pub struct WindowProxy;
@@ -113,7 +202,11 @@ impl<'a> Iterator for PollEventsIterator<'a> {
if let Some(ref ctxt) = *WAYLAND_CONTEXT {
ctxt.display.dispatch_pending();
}
- self.window.pending_events.lock().unwrap().pop_front()
+ if self.window.resize_if_needed() {
+ Some(Event::Refresh)
+ } else {
+ self.window.pending_events.lock().unwrap().pop_front()
+ }
}
}
@@ -125,10 +218,18 @@ impl<'a> Iterator for WaitEventsIterator<'a> {
type Item = Event;
fn next(&mut self) -> Option<Event> {
- if let Some(ref ctxt) = *WAYLAND_CONTEXT {
- ctxt.display.dispatch();
+ 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()
+ };
}
- self.window.pending_events.lock().unwrap().pop_front()
+ evt
}
}
@@ -151,12 +252,26 @@ impl Window {
h as i32
);
- let shell_surface = wayland_context.shell.get_shell_surface(surface);
- if let Some(PlatformMonitorID::Wayland(ref monitor)) = builder.monitor {
+ let mut shell_window = if let Some(PlatformMonitorID::Wayland(ref monitor)) = builder.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 {
- shell_surface.set_toplevel();
- }
+ if builder.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) };
@@ -171,26 +286,43 @@ impl Window {
egl,
&builder,
egl::NativeDisplay::Wayland(Some(wayland_context.display.ptr() as *const _)))
- .and_then(|p| p.finish((*shell_surface).ptr() as *const _))
+ .and_then(|p| p.finish((**shell_window.get_shell()).ptr() as *const _))
)
};
- let events = Arc::new(Mutex::new(VecDeque::new()));
+ // 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_surface.get_wsurface().get_id(), events.clone());
+ 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_surface: shell_surface,
+ 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();
- self.shell_surface.set_title(&ctitle);
+ // 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);
}
pub fn show(&self) {
@@ -211,7 +343,11 @@ impl Window {
}
pub fn get_inner_size(&self) -> Option<(u32, u32)> {
- let (w, h) = self.shell_surface.get_attached_size();
+ // 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))
}
@@ -222,7 +358,7 @@ impl Window {
}
pub fn set_inner_size(&self, x: u32, y: u32) {
- self.shell_surface.resize(x as i32, y as i32, 0, 0)
+ self.shell_window.lock().unwrap().resize(x as i32, y as i32, 0, 0)
}
pub fn create_window_proxy(&self) -> WindowProxy {
@@ -242,15 +378,7 @@ impl Window {
}
pub fn set_window_resize_callback(&mut self, callback: Option<fn(u32, u32)>) {
- if let Some(callback) = callback {
- self.shell_surface.set_configure_callback(
- move |_,w,h| { callback(w as u32, h as u32) }
- );
- } else {
- self.shell_surface.set_configure_callback(
- move |_,_,_| {}
- );
- }
+ self.resize_callback = callback;
}
pub fn set_cursor(&self, cursor: MouseCursor) {
@@ -309,7 +437,13 @@ impl GlContext for Window {
impl Drop for Window {
fn drop(&mut self) {
if let Some(ref ctxt) = *WAYLAND_CONTEXT {
- ctxt.deregister_surface(self.shell_surface.get_wsurface().get_id())
+ // 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()
+ )
}
}
}