diff options
| -rw-r--r-- | src/clients.rs | 206 |
1 files changed, 181 insertions, 25 deletions
diff --git a/src/clients.rs b/src/clients.rs index 341f73c..23780b5 100644 --- a/src/clients.rs +++ b/src/clients.rs @@ -1,17 +1,20 @@ use xcb::{ x::{ - ConfigureNotifyEvent, ConfigureRequestEvent, DestroyNotifyEvent, MapRequestEvent, - UnmapNotifyEvent, + ConfigWindow, ConfigureNotifyEvent, ConfigureRequestEvent, ConfigureWindow, + DestroyNotifyEvent, EventMask, GetWindowAttributes, GetWindowAttributesReply, + MapRequestEvent, MapWindow, SendEvent, SendEventDest, UnmapNotifyEvent, Window, }, xinerama::{self, ScreenInfo}, - Extension, + BaseEvent, Connection, Extension, Xid, }; use crate::{error::*, WM}; impl WM<'_> { /// Update the client state's recorded monitors and monitor sizes - pub(crate) fn update_geometry(&mut self) -> Result<()> { + /// Returns true if any values changed, meaning windows should be re-tiled. + pub(crate) fn update_geometry(&mut self) -> Result<bool> { + let mut dirty = false; if self .conn .active_extensions() @@ -23,16 +26,18 @@ impl WM<'_> { // Monitor removed, move its clients away if reply.screen_info().len() > self.clients.monitor_count() { + dirty = true; self.clients.truncate_screens(reply.screen_info().len()); } // Update screen info & add new client lists if needed for (i, monitor) in reply.screen_info().iter().enumerate() { - self.clients.set_screen_info(i, *monitor); + dirty |= self.clients.set_monitor_geometry(i, (*monitor).into()); } } else { // Only one screen if self.clients.monitor_count() > 1 { + dirty = true; self.clients.truncate_screens(1); } @@ -43,9 +48,9 @@ impl WM<'_> { .nth(self.screen_num as usize) .ok_or(Error::NoSuchScreen)?; - self.clients.set_screen_info( + dirty |= self.clients.set_monitor_geometry( 0, - ScreenInfo { + MonitorGeometry { x_org: 0, y_org: 0, width: screen.width_in_pixels(), @@ -54,23 +59,92 @@ impl WM<'_> { ); } - Ok(()) + Ok(dirty) } - pub(crate) fn handle_configure_request(&mut self, _e: ConfigureRequestEvent) -> Result<()> { - todo!() + /// Update our monitor geometry if the root window is reconfigured + pub(crate) fn handle_configure_notify(&mut self, e: ConfigureNotifyEvent) -> Result<()> { + if e.window() == self.root && self.update_geometry()? { + self.clients.rearrange(self.conn)?; + } + + Ok(()) } - pub(crate) fn handle_configure_notify(&mut self, _e: ConfigureNotifyEvent) -> Result<()> { - todo!() + + /// Handle a configure request, by checking it's valid and performing it if so + pub(crate) fn handle_configure_request(&mut self, e: ConfigureRequestEvent) -> Result<()> { + if let Some(c) = self.clients.find_client_mut(e.window()) { + // TODO: Allow changing some properties: + // - Border width + // - Size and position if floating + c.configure_notify(self.conn)?; + } else { + // Configure it as requested, and sort the rest when we actually map the window + self.conn + .check_request(self.conn.send_request_checked(&ConfigureWindow { + window: e.window(), + value_list: &[ + ConfigWindow::X(e.x().into()), + ConfigWindow::Y(e.y().into()), + ConfigWindow::Height(e.height().into()), + ConfigWindow::Width(e.height().into()), + ConfigWindow::BorderWidth(e.border_width().into()), + ConfigWindow::Sibling(e.parent()), + ConfigWindow::StackMode(e.stack_mode()), + ], + }))? + } + + Ok(()) } - pub(crate) fn handle_destroy_notify(&mut self, _e: DestroyNotifyEvent) -> Result<()> { - todo!() + + /// Handle a destroyed window, removing it from the client list and rearranging. + pub(crate) fn handle_destroy_notify(&mut self, e: DestroyNotifyEvent) -> Result<()> { + if self.clients.remove_client(e.window()).is_some() { + self.clients.rearrange(self.conn)?; + } + + Ok(()) } - pub(crate) fn handle_map_request(&mut self, _e: MapRequestEvent) -> Result<()> { - todo!() + + /// Map a window on request, starting to manage it if needed. + pub(crate) fn handle_map_request(&mut self, e: MapRequestEvent) -> Result<()> { + // Ignore already managed windows + if self.clients.find_client_mut(e.window()).is_some() { + return Ok(()); + } + + let attrs = self.conn.wait_for_reply( + self.conn + .send_request(&GetWindowAttributes { window: e.window() }), + )?; + if attrs.override_redirect() { + return Ok(()); + } + + // Start managing, and map window + self.clients.manage(e.window(), &attrs)?; + self.conn.send_request(&MapWindow { window: e.window() }); + + // TODO: clear focus + + self.conn.flush()?; + + Ok(()) } - pub(crate) fn handle_unmap_notify(&mut self, _e: UnmapNotifyEvent) -> Result<()> { - todo!() + + /// Handle a window being unmapped by updating its client state, or stop managing it. + pub(crate) fn handle_unmap_notify(&mut self, e: UnmapNotifyEvent) -> Result<()> { + if self.clients.find_client_mut(e.window()).is_some() { + if e.is_from_send_event() { + // TODO: set client state to withdrawn + } else { + self.clients.remove_client(e.window()); + // TODO: 'disown' the window - unmange(c, 0) + } + } + + Ok(()) } } @@ -86,13 +160,26 @@ pub struct MonitorInfo { clients: Vec<Client>, /// The monitor's geometry - screen_info: ScreenInfo, + screen_info: MonitorGeometry, } -/// Information about a single client / window -#[derive(Debug)] -pub struct Client { - // TODO +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct MonitorGeometry { + pub x_org: i16, + pub y_org: i16, + pub width: u16, + pub height: u16, +} + +impl From<ScreenInfo> for MonitorGeometry { + fn from(value: ScreenInfo) -> Self { + Self { + x_org: value.x_org, + y_org: value.y_org, + width: value.width, + height: value.height, + } + } } impl ClientState { @@ -107,24 +194,93 @@ impl ClientState { } /// Set the info for the given screen, resizing the monitor list if necessary. - pub fn set_screen_info(&mut self, i: usize, info: ScreenInfo) { + /// Returns true if the new info is different from the old one. + pub fn set_monitor_geometry(&mut self, i: usize, info: MonitorGeometry) -> bool { while i >= self.0.len() { self.0.push(MonitorInfo::default()) } + let dirty = self.0[i].screen_info != info; self.0[i].screen_info = info; + + dirty } /// Get the amount of monitors this state is currently aware of pub fn monitor_count(&self) -> usize { self.0.len() } + + /// Find the [`Client`] corresponding to the given window + pub fn find_client_mut(&mut self, window: Window) -> Option<&mut Client> { + self.0 + .iter_mut() + .flat_map(|mi| mi.clients.iter_mut()) + .find(|c| c.window == window) + } + + /// Remove the client associated with the given window. + /// This doesn't perform any of the associated X11 stuff + pub fn remove_client(&mut self, window: Window) -> Option<Client> { + for mon in self.0.iter_mut() { + if let Some(pos) = mon.clients.iter().position(|c| c.window == window) { + return Some(mon.clients.remove(pos)); + } + } + None + } + + /// Rearrange all clients, reconfiguring them as needed. + pub fn rearrange(&mut self, _conn: &Connection) -> Result<()> { + todo!() + } + + /// Start managing the given window, adding it to the client list and ensuring its configuration is valid. + fn manage(&self, _window: Window, _attrs: &GetWindowAttributesReply) -> Result<()> { + todo!() + } +} + +/// Information about a single client / window +#[derive(Debug)] +pub struct Client { + /// The corresponding X11 window + window: Window, + + x: i16, + y: i16, + width: u16, + height: u16, + border_width: u16, +} + +impl Client { + fn configure_notify(&self, conn: &Connection) -> Result<()> { + conn.check_request(conn.send_request_checked(&SendEvent { + destination: SendEventDest::Window(self.window), + event_mask: EventMask::STRUCTURE_NOTIFY, + event: &ConfigureNotifyEvent::new( + self.window, + self.window, + Window::none(), + self.x, + self.y, + self.width, + self.height, + self.border_width, + false, + ), + propagate: false, + }))?; + + Ok(()) + } } impl Default for MonitorInfo { fn default() -> Self { Self { clients: vec![], - screen_info: ScreenInfo { + screen_info: MonitorGeometry { x_org: 0, y_org: 0, width: 0, |