aboutsummaryrefslogtreecommitdiffstats
path: root/src/api
diff options
context:
space:
mode:
Diffstat (limited to 'src/api')
-rw-r--r--src/api/wayland/context.rs63
-rw-r--r--src/api/wayland/monitor.rs59
-rw-r--r--src/api/wayland/window.rs90
3 files changed, 190 insertions, 22 deletions
diff --git a/src/api/wayland/context.rs b/src/api/wayland/context.rs
index 285f50c..f303b54 100644
--- a/src/api/wayland/context.rs
+++ b/src/api/wayland/context.rs
@@ -10,7 +10,7 @@ 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;
+use wayland_client::wayland::shell::{WlShell, WlShellSurface};
use wayland_client::wayland::shm::WlShm;
use wayland_client::wayland::subcompositor::WlSubcompositor;
@@ -42,7 +42,7 @@ pub struct WaylandFocuses {
pub struct WaylandContext {
inner: InnerEnv,
iterator: Mutex<EventIterator>,
- monitors: Vec<WlOutput>,
+ monitors: Vec<(WlOutput, u32, u32, String)>,
queues: Mutex<HashMap<ProxyId, Arc<Mutex<VecDeque<GlutinEvent>>>>>,
known_surfaces: Mutex<HashSet<ProxyId>>,
focuses: Mutex<WaylandFocuses>
@@ -57,13 +57,19 @@ impl WaylandContext {
let (mut inner_env, iterator) = InnerEnv::init(display);
- let monitors = inner_env.globals.iter()
+ let mut outputs_events = EventIterator::new();
+
+ let mut monitors = inner_env.globals.iter()
.flat_map(|&(id, _, _)| inner_env.rebind_id::<WlOutput>(id))
- .map(|(monitor, _)| monitor)
- .collect();
+ .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),
@@ -114,6 +120,31 @@ impl WaylandContext {
}
}
+ 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
+ }
+ }
+
pub fn display_ptr(&self) -> *const c_void {
self.inner.display.ptr() as *const _
}
@@ -155,4 +186,26 @@ impl WaylandContext {
};
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 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 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/monitor.rs b/src/api/wayland/monitor.rs
index 3a42f1f..d87d4b6 100644
--- a/src/api/wayland/monitor.rs
+++ b/src/api/wayland/monitor.rs
@@ -1,28 +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;
+pub struct MonitorId(ProxyId);
#[inline]
pub fn get_available_monitors() -> VecDeque<MonitorId> {
- unimplemented!()
+ 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 {
- unimplemented!()
+ 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> {
- unimplemented!()
+ WAYLAND_CONTEXT.as_ref().and_then(|ctxt| ctxt.monitor_name(self.0))
}
#[inline]
pub fn get_native_identifier(&self) -> ::native_monitor::NativeMonitorId {
- unimplemented!()
+ ::native_monitor::NativeMonitorId::Unavailable
}
pub fn get_dimensions(&self) -> (u32, u32) {
- unimplemented!()
+ 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 faf772e..a9285fa 100644
--- a/src/api/wayland/window.rs
+++ b/src/api/wayland/window.rs
@@ -9,8 +9,11 @@ use {ContextError, CreationError, CursorState, Event, GlAttributes, GlContext,
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};
@@ -27,7 +30,7 @@ impl WindowProxy {
pub struct Window {
wayland_context: &'static WaylandContext,
egl_surface: wegl::WlEglSurface,
- decorated_surface: Mutex<DecoratedSurface>,
+ shell_window: Mutex<ShellWindow>,
evt_queue: Arc<Mutex<VecDeque<Event>>>,
inner_size: Mutex<(i32, i32)>,
resize_callback: Option<fn(u32, u32)>,
@@ -36,21 +39,50 @@ pub struct Window {
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;
- for (_, w, h) in &mut *self.decorated_surface.lock().unwrap() {
- newsize = Some((w, h));
+ 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);
- self.decorated_surface.lock().unwrap().resize(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 {
- self.evt_queue.lock().unwrap().pop_front()
+ evt_queue_guard.pop_front()
}
}
}
@@ -99,10 +131,16 @@ impl<'a> Iterator for WaitEventsIterator<'a> {
}
}
+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());
@@ -142,15 +180,36 @@ impl Window {
)
};
- let decorated_surface = match wayland_context.decorated_from(&egl_surface, w as i32, h as i32) {
- Some(s) => s,
- 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(&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,
- decorated_surface: Mutex::new(decorated_surface),
+ shell_window: Mutex::new(shell_window),
evt_queue: evt_queue,
inner_size: Mutex::new((w as i32, h as i32)),
resize_callback: None,
@@ -159,7 +218,11 @@ impl Window {
}
pub fn set_title(&self, title: &str) {
- self.decorated_surface.lock().unwrap().set_title(title.into())
+ 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]
@@ -197,7 +260,12 @@ impl Window {
#[inline]
pub fn set_inner_size(&self, x: u32, y: u32) {
- self.decorated_surface.lock().unwrap().resize(x as i32, y as i32)
+ 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]
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-21 23:37:53 +0000