diff options
| -rw-r--r-- | src/clients.rs | 231 |
1 files changed, 200 insertions, 31 deletions
diff --git a/src/clients.rs b/src/clients.rs index 23780b5..940efee 100644 --- a/src/clients.rs +++ b/src/clients.rs @@ -1,8 +1,10 @@ +use std::cmp::min; + use xcb::{ x::{ ConfigWindow, ConfigureNotifyEvent, ConfigureRequestEvent, ConfigureWindow, - DestroyNotifyEvent, EventMask, GetWindowAttributes, GetWindowAttributesReply, - MapRequestEvent, MapWindow, SendEvent, SendEventDest, UnmapNotifyEvent, Window, + DestroyNotifyEvent, EventMask, GetWindowAttributes, MapRequestEvent, MapWindow, SendEvent, + SendEventDest, UnmapNotifyEvent, UnmapWindow, Window, }, xinerama::{self, ScreenInfo}, BaseEvent, Connection, Extension, Xid, @@ -65,9 +67,9 @@ impl WM<'_> { /// 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)?; + self.clients.rearrange(self.conn); + self.conn.flush()?; } - Ok(()) } @@ -77,7 +79,8 @@ impl WM<'_> { // TODO: Allow changing some properties: // - Border width // - Size and position if floating - c.configure_notify(self.conn)?; + c.configure_notify(self.conn); + self.conn.flush()?; } else { // Configure it as requested, and sort the rest when we actually map the window self.conn @@ -86,10 +89,9 @@ impl WM<'_> { value_list: &[ ConfigWindow::X(e.x().into()), ConfigWindow::Y(e.y().into()), + ConfigWindow::Width(e.width().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()), ], }))? @@ -101,7 +103,8 @@ impl WM<'_> { /// 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)?; + self.clients.rearrange(self.conn); + self.conn.flush()?; } Ok(()) @@ -123,9 +126,7 @@ impl WM<'_> { } // Start managing, and map window - self.clients.manage(e.window(), &attrs)?; - self.conn.send_request(&MapWindow { window: e.window() }); - + self.clients.manage(self.conn, e.window()); // TODO: clear focus self.conn.flush()?; @@ -150,8 +151,32 @@ impl WM<'_> { /// Holds state related to the window manager's clients /// This contains a list of clients per monitor, alongside info on that monitor's screen size. -#[derive(Debug, Default)] -pub struct ClientState(Vec<MonitorInfo>); +pub struct ClientState { + /// The current arranging function. + /// This function is expected to ensure that all clients are the correct size, reconfigure them if needed, and map/unmap as needed. + arrange: &'static dyn Fn(&mut MonitorInfo, &Connection), + selected_monitor: usize, + mons: Vec<MonitorInfo>, +} + +impl Default for ClientState { + fn default() -> Self { + Self { + arrange: &tile, + selected_monitor: 0, + mons: vec![], + } + } +} + +impl std::fmt::Debug for ClientState { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("ClientState") + .field("selected_monitor", &self.selected_monitor) + .field("mons", &self.mons) + .finish() + } +} /// Info stored for a single monitor #[derive(Debug)] @@ -163,6 +188,13 @@ pub struct MonitorInfo { screen_info: MonitorGeometry, } +impl MonitorInfo { + fn clients_tiled_mut(&mut self) -> impl Iterator<Item = &mut Client> { + // TODO: tag filtering, floating + self.clients.iter_mut() + } +} + #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct MonitorGeometry { pub x_org: i16, @@ -187,32 +219,32 @@ impl ClientState { pub fn truncate_screens(&mut self, new_size: usize) { // hack: double borrow stuff let mut moved_clients = vec![]; - for old in self.0.drain(new_size - self.0.len()..self.0.len()) { + for old in self.mons.drain(new_size - self.mons.len()..self.mons.len()) { moved_clients.extend(old.clients.into_iter()); } - self.0[0].clients.extend(moved_clients); + self.mons[0].clients.extend(moved_clients); } /// Set the info for the given screen, resizing the monitor list if necessary. /// 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()) + while i >= self.mons.len() { + self.mons.push(MonitorInfo::default()) } - let dirty = self.0[i].screen_info != info; - self.0[i].screen_info = info; + let dirty = self.mons[i].screen_info != info; + self.mons[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() + self.mons.len() } /// Find the [`Client`] corresponding to the given window pub fn find_client_mut(&mut self, window: Window) -> Option<&mut Client> { - self.0 + self.mons .iter_mut() .flat_map(|mi| mi.clients.iter_mut()) .find(|c| c.window == window) @@ -221,7 +253,7 @@ impl ClientState { /// 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() { + for mon in self.mons.iter_mut() { if let Some(pos) = mon.clients.iter().position(|c| c.window == window) { return Some(mon.clients.remove(pos)); } @@ -229,14 +261,41 @@ impl ClientState { None } + /// Start managing the given window, adding it to the client list and ensuring its configuration is valid. + /// This function sends multiple requests without checking them, so conn.flush() should be called after. + fn manage(&mut self, conn: &Connection, window: Window) { + // TODO: inherit from parent if window is transient + let mon = self.selected_monitor; + + // TODO: inserting at index 0 is why dwm uses linked lists, maybe this can be improved + self.mons[mon].clients.insert( + 0, + Client { + window, + x: 0, + y: 0, + width: 0, + height: 0, + border_width: 0, + mapped: false, + }, + ); + + self.rearrange_monitor(conn, mon) + } + /// Rearrange all clients, reconfiguring them as needed. - pub fn rearrange(&mut self, _conn: &Connection) -> Result<()> { - todo!() + /// This function sends multiple requests without checking them, so conn.flush() should be called after. + pub fn rearrange(&mut self, conn: &Connection) { + for mon in 0..self.monitor_count() { + self.rearrange_monitor(conn, mon); + } } - /// 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!() + /// Rearrange a specific monitor + /// This function sends multiple requests without checking them, so conn.flush() should be called after. + fn rearrange_monitor(&mut self, conn: &Connection, mon: usize) { + (self.arrange)(&mut self.mons[mon], conn); } } @@ -251,11 +310,13 @@ pub struct Client { width: u16, height: u16, border_width: u16, + mapped: bool, } impl Client { - fn configure_notify(&self, conn: &Connection) -> Result<()> { - conn.check_request(conn.send_request_checked(&SendEvent { + /// This function does not check for success, so conn.flush() should be called after. + fn configure_notify(&self, conn: &Connection) { + conn.send_request(&SendEvent { destination: SendEventDest::Window(self.window), event_mask: EventMask::STRUCTURE_NOTIFY, event: &ConfigureNotifyEvent::new( @@ -270,9 +331,61 @@ impl Client { false, ), propagate: false, - }))?; + }); + } - Ok(()) + /// Set this client's geometry, also updating the X11 window if needed. + fn set_geom( + &mut self, + conn: &Connection, + x: i16, + y: i16, + width: u16, + height: u16, + border_width: u16, + ) { + if (x, y, width, height, border_width) + == (self.x, self.y, self.width, self.height, self.border_width) + { + return; + } + + self.x = x; + self.y = y; + self.width = width; + self.height = height; + self.border_width = border_width; + + conn.send_request(&ConfigureWindow { + window: self.window, + value_list: &[ + ConfigWindow::X(self.x.into()), + ConfigWindow::Y(self.y.into()), + ConfigWindow::Width(self.width.into()), + ConfigWindow::Height(self.height.into()), + ConfigWindow::BorderWidth(self.border_width.into()), + ], + }); + } + + /// Ensure this client is currently mapped / visible + fn ensure_mapped(&mut self, conn: &Connection) { + if !self.mapped { + conn.send_request(&MapWindow { + window: self.window, + }); + self.mapped = true; + } + } + + /// Ensure this client is currently unmapped / invisible + fn ensure_unmapped(&mut self, conn: &Connection) { + if self.mapped { + conn.send_request(&UnmapWindow { + window: self.window, + }); + self.mapped = false; + } } } @@ -289,3 +402,59 @@ impl Default for MonitorInfo { } } } + +fn tile(mon: &mut MonitorInfo, conn: &Connection) { + if mon.clients.is_empty() { + return; + } + + let n = mon.clients_tiled_mut().count(); + let nmaster = 1; + let mfact = 0.6; + + let MonitorGeometry { + x_org, + y_org, + width: mon_width, + height: mon_height, + } = mon.screen_info; + + let main_width = if nmaster == 0 { + 0 + } else if n > nmaster { + ((mon.screen_info.width as f64) * mfact) as u16 + } else { + mon.screen_info.width + }; + + let (mut main_y, mut second_y) = (0, 0); + for (i, c) in mon.clients_tiled_mut().enumerate() { + if i < nmaster { + let h = (mon_height - main_y) / (min(nmaster, n) - i) as u16; + c.set_geom( + conn, + x_org, + y_org + main_y as i16, + main_width - (2 * c.border_width), + h - (2 * c.border_width), + c.border_width, + ); + + main_y += h; + } else { + let h = (mon_height - second_y) / (n - i) as u16; + c.set_geom( + conn, + x_org + main_width as i16, + y_org + second_y as i16, + mon_width - main_width - (2 * c.border_width), + h - (2 * c.border_width), + c.border_width, + ); + + second_y += h; + } + + c.ensure_mapped(conn); + } +} |