From 80fdb915ab31faa17f271a8b294da657ecd6e18e Mon Sep 17 00:00:00 2001 From: noonebtw Date: Tue, 19 Jan 2021 01:28:50 +0100 Subject: [PATCH] refactoring; Arc -> Rc; basic tiling functionality --- Cargo.toml | 3 +- rustfmt.toml | 3 + src/wm.rs | 1890 +++++++++++++++++++++++++++----------------------- vm-ss.png | Bin 0 -> 134626 bytes 4 files changed, 1022 insertions(+), 874 deletions(-) create mode 100644 rustfmt.toml create mode 100644 vm-ss.png diff --git a/Cargo.toml b/Cargo.toml index c5f0815..d2280ae 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,4 +8,5 @@ edition = "2018" [dependencies] nix = "0.19.1" -x11 = {version = "2.18.2", features = ["xlib"] } \ No newline at end of file +x11 = {version = "2.18.2", features = ["xlib"] } +log = "0.4.13" \ No newline at end of file diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 0000000..9cdbf20 --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1,3 @@ +hard_tabs = true +imports_granularity = "Crate" +wrap_comments = true \ No newline at end of file diff --git a/src/wm.rs b/src/wm.rs index 0778b7f..eed0383 100644 --- a/src/wm.rs +++ b/src/wm.rs @@ -1,952 +1,1096 @@ // asdf use std::{ - cell::{Cell, RefCell, RefMut}, - collections::{hash_map::Entry, HashMap}, - ffi::CString, - io::{Error, ErrorKind, Result}, - ptr::{null, null_mut}, - rc::{Rc, Weak as WeakRc}, - sync::{Arc, Weak}, + cell::{RefCell, RefMut}, + collections::{hash_map::Entry, HashMap}, + ffi::CString, + io::{Error, ErrorKind, Result}, + ptr::{null, null_mut}, + rc::{Rc, Weak}, }; use x11::{ - xlib, - xlib::{ - Atom, ButtonPressMask, ButtonReleaseMask, CWEventMask, ControlMask, EnterWindowMask, - FocusChangeMask, GrabModeAsync, LeaveWindowMask, LockMask, Mod1Mask, Mod2Mask, Mod3Mask, - Mod4Mask, Mod5Mask, PointerMotionMask, PropertyChangeMask, ShiftMask, StructureNotifyMask, - SubstructureNotifyMask, SubstructureRedirectMask, Window, XDefaultScreen, XEvent, - XInternAtom, XOpenDisplay, XRootWindow, - }, + xlib, + xlib::{ + Atom, ButtonPressMask, ButtonReleaseMask, CWEventMask, ControlMask, EnterWindowMask, + FocusChangeMask, GrabModeAsync, LockMask, Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask, + PointerMotionMask, PropertyChangeMask, ShiftMask, StructureNotifyMask, + SubstructureNotifyMask, SubstructureRedirectMask, Window, XDefaultScreen, XEvent, + XInternAtom, XOpenDisplay, XRootWindow, + }, }; +use log::info; + use nix::unistd::{close, execvp, fork, setsid, ForkResult}; #[derive(Clone)] pub struct Display(Rc<*mut x11::xlib::Display>); impl Display { - pub fn new(display: *mut x11::xlib::Display) -> Self { - Self { - 0: Rc::new(display), - } - } + pub fn new(display: *mut x11::xlib::Display) -> Self { + Self { + 0: Rc::new(display), + } + } - pub fn get(&self) -> *mut x11::xlib::Display { - *self.0 - } + pub fn get(&self) -> *mut x11::xlib::Display { + *self.0 + } } pub struct WMAtoms { - pub protocols: Option, - pub delete: Option, - pub active_window: Option, - pub take_focus: Option, + pub protocols: Option, + pub delete: Option, + pub active_window: Option, + pub take_focus: Option, } impl WMAtoms { - pub fn init(display: Display) -> Self { - Self { - protocols: { - Some(unsafe { - let wm_protocols_str = CString::new("WM_PROTOCOLS").unwrap(); - XInternAtom(display.get(), wm_protocols_str.as_c_str().as_ptr(), 0) - }) - .filter(|&atom| atom != 0) - }, - delete: { - Some(unsafe { - let wm_delete_str = CString::new("WM_DELETE_WINDOW").unwrap(); - XInternAtom(display.get(), wm_delete_str.as_c_str().as_ptr(), 0) - }) - .filter(|&atom| atom != 0) - }, - active_window: { - Some(unsafe { - let atom_cstr = CString::new("_NET_ACTIVE_WINDOW").unwrap(); - XInternAtom(display.get(), atom_cstr.as_c_str().as_ptr(), 0) - }) - .filter(|&atom| atom != 0) - }, - take_focus: { - Some(unsafe { - let atom_cstr = CString::new("WM_TAKE_FOCUS").unwrap(); - XInternAtom(display.get(), atom_cstr.as_c_str().as_ptr(), 0) - }) - .filter(|&atom| atom != 0) - }, - ..Default::default() - } - } + pub fn init(display: Display) -> Self { + Self { + protocols: { + Some(unsafe { + let wm_protocols_str = CString::new("WM_PROTOCOLS").unwrap(); + XInternAtom(display.get(), wm_protocols_str.as_c_str().as_ptr(), 0) + }) + .filter(|&atom| atom != 0) + }, + delete: { + Some(unsafe { + let wm_delete_str = CString::new("WM_DELETE_WINDOW").unwrap(); + XInternAtom(display.get(), wm_delete_str.as_c_str().as_ptr(), 0) + }) + .filter(|&atom| atom != 0) + }, + active_window: { + Some(unsafe { + let atom_cstr = CString::new("_NET_ACTIVE_WINDOW").unwrap(); + XInternAtom(display.get(), atom_cstr.as_c_str().as_ptr(), 0) + }) + .filter(|&atom| atom != 0) + }, + take_focus: { + Some(unsafe { + let atom_cstr = CString::new("WM_TAKE_FOCUS").unwrap(); + XInternAtom(display.get(), atom_cstr.as_c_str().as_ptr(), 0) + }) + .filter(|&atom| atom != 0) + }, + ..Default::default() + } + } } impl Default for WMAtoms { - fn default() -> Self { - Self { - protocols: None, - delete: None, - active_window: None, - take_focus: None, - } - } -} - -#[derive(Clone, Copy, Debug)] -pub struct ClientState { - size: (u32, u32), - position: (i32, i32), + fn default() -> Self { + Self { + protocols: None, + delete: None, + active_window: None, + take_focus: None, + } + } } #[derive(Clone, Debug)] pub struct Client { - window: Window, - state: Cell, + window: Window, + size: (i32, i32), + position: (i32, i32), } impl Default for Client { - fn default() -> Self { - Self { - window: 0, - state: Cell::new(ClientState { - size: (0, 0), - position: (0, 0), - }), - } - } + fn default() -> Self { + Self { + window: 0, + size: (0, 0), + position: (0, 0), + } + } } impl Client { - pub fn new(window: xlib::Window) -> Self { - Self { - window, - ..Default::default() - } - } - - pub fn get_state(&self) -> ClientState { - self.state.get() - } + pub fn new(window: xlib::Window) -> Self { + Self { + window, + ..Default::default() + } + } } impl PartialEq for Client { - fn eq(&self, other: &Self) -> bool { - self.window == other.window - } + fn eq(&self, other: &Self) -> bool { + self.window == other.window + } } impl Eq for Client {} pub struct XLibState { - display: Display, - root: Window, - screen: i32, - pub atoms: WMAtoms, + display: Display, + root: Window, + screen: i32, + pub atoms: WMAtoms, } impl XLibState { - pub fn new() -> Self { - let (display, screen, root) = unsafe { - let display = XOpenDisplay(null()); - assert_ne!(display, null_mut()); + pub fn new() -> Self { + let (display, screen, root) = unsafe { + let display = XOpenDisplay(null()); + assert_ne!(display, null_mut()); - let display = Display::new(display); - let screen = XDefaultScreen(display.get()); - let root = XRootWindow(display.get(), screen); + let display = Display::new(display); + let screen = XDefaultScreen(display.get()); + let root = XRootWindow(display.get(), screen); - (display, screen, root) - }; + (display, screen, root) + }; - Self { - display: display.clone(), - root, - screen, - atoms: WMAtoms::init(display), - } - } + Self { + display: display.clone(), + root, + screen, + atoms: WMAtoms::init(display), + } + } - pub fn dpy(&self) -> *mut x11::xlib::Display { - self.display.get() - } + pub fn dpy(&self) -> *mut x11::xlib::Display { + self.display.get() + } - pub fn root(&self) -> Window { - self.root - } + pub fn root(&self) -> Window { + self.root + } - pub fn screen(&self) -> i32 { - self.screen - } + pub fn screen(&self) -> i32 { + self.screen + } - pub fn grab_key(&self, window: xlib::Window, keycode: i32, mask: u32) { - let numlock_mask = self.numlock_mask(); - let modifiers = vec![0, LockMask, numlock_mask, LockMask | numlock_mask]; - for &modifier in modifiers.iter() { - unsafe { - xlib::XGrabKey( - self.dpy(), - keycode, - mask | modifier, - window, - 1, /* true */ - GrabModeAsync, - GrabModeAsync, - ); - } - } - } + pub fn grab_key(&self, window: xlib::Window, keycode: i32, mask: u32) { + let numlock_mask = self.numlock_mask(); + let modifiers = vec![0, LockMask, numlock_mask, LockMask | numlock_mask]; + for &modifier in modifiers.iter() { + unsafe { + xlib::XGrabKey( + self.dpy(), + keycode, + mask | modifier, + window, + 1, /* true */ + GrabModeAsync, + GrabModeAsync, + ); + } + } + } - pub fn grab_button(&self, window: xlib::Window, button: u32, mod_mask: u32, button_mask: i64) { - let numlock_mask = self.numlock_mask(); - let modifiers = vec![0, LockMask, numlock_mask, LockMask | numlock_mask]; + pub fn grab_button(&self, window: xlib::Window, button: u32, mod_mask: u32, button_mask: i64) { + let numlock_mask = self.numlock_mask(); + let modifiers = vec![0, LockMask, numlock_mask, LockMask | numlock_mask]; - modifiers.iter().for_each(|&modifier| { - unsafe { - xlib::XGrabButton( - self.dpy(), - button, - mod_mask | modifier, - window, - 1, /*true */ - button_mask as u32, - GrabModeAsync, - GrabModeAsync, - 0, - 0, - ); - } - }); - } + modifiers.iter().for_each(|&modifier| { + unsafe { + xlib::XGrabButton( + self.dpy(), + button, + mod_mask | modifier, + window, + 1, /*true */ + button_mask as u32, + GrabModeAsync, + GrabModeAsync, + 0, + 0, + ); + } + }); + } - pub fn keycode(&self, string: S) -> i32 - where - S: Into, - { - let c_string = CString::new(string.into()).unwrap(); - unsafe { - let keysym = xlib::XStringToKeysym(c_string.as_ptr()); - xlib::XKeysymToKeycode(self.dpy(), keysym) as i32 - } - } + pub fn keycode(&self, string: S) -> i32 + where + S: Into, + { + let c_string = CString::new(string.into()).unwrap(); + unsafe { + let keysym = xlib::XStringToKeysym(c_string.as_ptr()); + xlib::XKeysymToKeycode(self.dpy(), keysym) as i32 + } + } - fn check_for_protocol(&self, window: xlib::Window, proto: xlib::Atom) -> bool { - let mut protos: *mut xlib::Atom = null_mut(); - let mut num_protos: i32 = 0; + fn check_for_protocol(&self, window: xlib::Window, proto: xlib::Atom) -> bool { + let mut protos: *mut xlib::Atom = null_mut(); + let mut num_protos: i32 = 0; - unsafe { - if xlib::XGetWMProtocols(self.dpy(), window, &mut protos, &mut num_protos) != 0 { - for i in 0..num_protos { - if *protos.offset(i as isize) == proto { - return true; - } - } - } - } + unsafe { + if xlib::XGetWMProtocols(self.dpy(), window, &mut protos, &mut num_protos) != 0 { + for i in 0..num_protos { + if *protos.offset(i as isize) == proto { + return true; + } + } + } + } - return false; - } + return false; + } - fn send_event(&self, window: xlib::Window, proto: Option) -> bool { - if proto.is_some() - && self.check_for_protocol(window, proto.unwrap()) - && self.atoms.protocols.is_some() - { - let mut data = xlib::ClientMessageData::default(); - data.set_long(0, proto.unwrap() as i64); - let mut event = XEvent { - client_message: xlib::XClientMessageEvent { - type_: xlib::ClientMessage, - serial: 0, - display: self.dpy(), - send_event: 0, - window, - format: 32, - message_type: self.atoms.protocols.unwrap(), - data, - }, - }; + fn send_event(&self, window: xlib::Window, proto: Option) -> bool { + if proto.is_some() + && self.check_for_protocol(window, proto.unwrap()) + && self.atoms.protocols.is_some() + { + let mut data = xlib::ClientMessageData::default(); + data.set_long(0, proto.unwrap() as i64); + let mut event = XEvent { + client_message: xlib::XClientMessageEvent { + type_: xlib::ClientMessage, + serial: 0, + display: self.dpy(), + send_event: 0, + window, + format: 32, + message_type: self.atoms.protocols.unwrap(), + data, + }, + }; - unsafe { - xlib::XSendEvent(self.dpy(), window, 0, xlib::NoEventMask, &mut event); - } + unsafe { + xlib::XSendEvent(self.dpy(), window, 0, xlib::NoEventMask, &mut event); + } - return true; - } + return true; + } - return false; - } + return false; + } - fn numlock_mask(&self) -> u32 { - unsafe { - let modmap = xlib::XGetModifierMapping(self.dpy()); - let max_keypermod = (*modmap).max_keypermod; + fn numlock_mask(&self) -> u32 { + unsafe { + let modmap = xlib::XGetModifierMapping(self.dpy()); + let max_keypermod = (*modmap).max_keypermod; - for i in 0..8 { - for j in 0..max_keypermod { - if *(*modmap) - .modifiermap - .offset((i * max_keypermod + j) as isize) - == xlib::XKeysymToKeycode(self.dpy(), x11::keysym::XK_Num_Lock as u64) - { - return 1 << i; - } - } - } - } + for i in 0..8 { + for j in 0..max_keypermod { + if *(*modmap) + .modifiermap + .offset((i * max_keypermod + j) as isize) + == xlib::XKeysymToKeycode(self.dpy(), x11::keysym::XK_Num_Lock as u64) + { + return 1 << i; + } + } + } + } - 0 - } + 0 + } - fn clean_mask(&self) -> u32 { - !(self.numlock_mask() | LockMask) - & (ShiftMask | ControlMask | Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask) - } + fn clean_mask(&self) -> u32 { + !(self.numlock_mask() | LockMask) + & (ShiftMask | ControlMask | Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask) + } } #[derive(Clone, Debug)] pub struct WMStateMut { - //move_window: - // u64 : window to move - // (i32, i32) : initial cursor position - // (i32, i32) : initial window position - move_window: Option<(u64, (i32, i32), (i32, i32))>, - //resize_window: - // u64 : window to move - // (i32, i32) : initial window position - resize_window: Option<(u64, (i32, i32))>, - clients: HashMap>, - focused_client: WeakRc, + //move_window: + // u64 : window to move + // (i32, i32) : initial cursor position + // (i32, i32) : initial window position + move_window: Option<(u64, (i32, i32), (i32, i32))>, + //resize_window: + // u64 : window to move + // (i32, i32) : initial window position + resize_window: Option<(u64, (i32, i32))>, + clients: HashMap>>, + focused_client: Weak>, + master_stack: Vec>>, } impl Default for WMStateMut { - fn default() -> Self { - Self { - move_window: None, - resize_window: None, - clients: HashMap::new(), - focused_client: WeakRc::new(), - } - } + fn default() -> Self { + Self { + move_window: None, + resize_window: None, + clients: HashMap::new(), + focused_client: Weak::new(), + master_stack: vec![], + } + } } pub struct WMState { - xlib_state: XLibState, - key_handlers: Vec<(i32, u32, Arc)>, - // (button, mod_mask, button_mask) - buttons: Vec<(u32, u32, i64)>, - event_handlers: Vec>, - mut_state: RefCell, + xlib_state: XLibState, + key_handlers: Vec<(i32, u32, Rc)>, + // (button, mod_mask, button_mask) + buttons: Vec<(u32, u32, i64)>, + event_handlers: Vec>, + mut_state: RefCell, } impl WMState { - pub fn new() -> Self { - Self { - xlib_state: XLibState::new(), - mut_state: RefCell::new(WMStateMut::default()), - key_handlers: vec![], - event_handlers: vec![], - buttons: vec![], - } - } - - pub fn init() -> Self { - let state = Self::new() - .grab_button( - 1, - Mod1Mask, - ButtonPressMask | ButtonReleaseMask | PointerMotionMask, - ) - .add_event_handler(Self::handle_move_window) - .grab_button( - 3, - Mod1Mask, - ButtonPressMask | ButtonReleaseMask | PointerMotionMask, - ) - .add_event_handler(Self::handle_resize_window) - .add_key_handler("T", Mod1Mask, |state, _| { - println!("spawning terminal"); - let _ = state.spawn("xterm", &[]); - }) - .add_key_handler("L", Mod1Mask, |state, _| { - println!("{:#?}", state.mut_state.borrow()); - }) - .add_key_handler("Q", Mod1Mask, |state, event| unsafe { - if event.key.subwindow != 0 { - if state.xlib_state.atoms.delete.is_none() - || !state - .xlib_state - .send_event(event.key.subwindow, state.xlib_state.atoms.delete) - { - xlib::XKillClient(state.dpy(), event.key.subwindow); - } - } - }) - .add_key_handler("Q", Mod1Mask | ShiftMask, |state, _event| { - unsafe { - xlib::XCloseDisplay(state.dpy()); - } - - std::process::exit(0); - }); - - unsafe { - let mut wa: xlib::XSetWindowAttributes = std::mem::MaybeUninit::zeroed().assume_init(); - wa.event_mask = SubstructureRedirectMask - | StructureNotifyMask - | SubstructureNotifyMask - | EnterWindowMask - | PointerMotionMask - | ButtonPressMask; - - xlib::XChangeWindowAttributes(state.dpy(), state.root(), CWEventMask, &mut wa); - - xlib::XSelectInput(state.dpy(), state.root(), wa.event_mask); - } - - state - } - - pub fn run(self) -> Self { - loop { - let event = unsafe { - let mut event: xlib::XEvent = std::mem::MaybeUninit::zeroed().assume_init(); - xlib::XNextEvent(self.dpy(), &mut event); - - event - }; - - self.event_handlers.iter().for_each(|handler| { - handler(&self, &event); - }); - - match event.get_type() { - xlib::MapRequest => { - let event = unsafe { &event.map_request }; - - let _ = self - .mut_state - .try_borrow_mut() - .ok() - .and_then(|mut m| { - if !m.clients.contains_key(&event.window) { - Some( - m.clients - .entry(event.window) - .or_insert_with(|| Rc::new(Client::new(event.window))) - .clone(), - ) - } else { - None - } - }) - .and_then(|c| { - unsafe { xlib::XMapWindow(self.dpy(), c.window) }; - - unsafe { - xlib::XSelectInput( - self.dpy(), - event.window, - EnterWindowMask - | FocusChangeMask - | PropertyChangeMask - | StructureNotifyMask, - ); - } - - self.buttons - .iter() - .for_each(|&(button, mod_mask, button_mask)| { - self.xlib_state.grab_button( - c.window, - button, - mod_mask, - button_mask, - ); - }); - - self.arrange_clients(); - - self.focus_client(c); - - Some(()) - }); - } - xlib::UnmapNotify => { - let event = unsafe { &event.unmap }; - - println!("UnmapNotify: {:?}", event.window); - - if event.send_event == 0 { - let _ = self.mut_state.try_borrow_mut().and_then(|mut_state| { - if mut_state.clients.contains_key(&event.window) { - RefMut::map(mut_state, |t| &mut t.clients).remove(&event.window); - } - - Ok(()) - }); - } - - self.arrange_clients(); - } - xlib::DestroyNotify => { - let event = unsafe { &event.destroy_window }; - - println!("DestroyNotify: {:?}", event.window); - - let _ = self.mut_state.try_borrow_mut().and_then(|mut_state| { - if mut_state.clients.contains_key(&event.window) { - RefMut::map(mut_state, |t| &mut t.clients).remove(&event.window); - } - - Ok(()) - }); - - self.arrange_clients(); - } - xlib::ConfigureRequest => { - let event = unsafe { &event.configure_request }; - - match self.mut_state.borrow_mut().clients.entry(event.window) { - Entry::Occupied(entry) => { - self.configure_client(entry.get().clone()); - } - _ => { - let mut wc = xlib::XWindowChanges { - x: event.x, - y: event.y, - width: event.width, - height: event.height, - border_width: event.border_width, - sibling: event.above, - stack_mode: event.detail, - }; - - unsafe { - xlib::XConfigureWindow( - self.dpy(), - event.window, - event.value_mask as u32, - &mut wc, - ); - } - } - } - } - xlib::EnterNotify => { - let event = unsafe { &event.crossing }; - - println!("EnterNotify: {:?}", event.window); - - match self.mut_state.try_borrow().ok().and_then(|mut_state| { - mut_state - .clients - .get(&event.window) - .and_then(|c| Some(c.clone())) - }) { - Some(client) => { - self.focus_client(client); - } - None => {} - }; - } - xlib::ButtonPress => { - let event = unsafe { &event.button }; - - match self.mut_state.try_borrow().ok().and_then(|mut_state| { - mut_state - .clients - .get(&event.subwindow) - .and_then(|c| Some(c.clone())) - }) { - Some(client) => { - self.focus_client(client.clone()); - println!("raising window {:?}", client.window); - unsafe { - xlib::XRaiseWindow(self.dpy(), client.window); - xlib::XSync(self.dpy(), 0); - } - } - None => {} - }; - } - xlib::KeyPress => { - let clean_mask = self.xlib_state.clean_mask(); - - self.key_handlers.iter().for_each(|(key, mask, handler)| { - if unsafe { - event.key.keycode == *key as u32 - && event.key.state & clean_mask == *mask & clean_mask - } { - handler(&self, &event); - } - }) - } - _ => {} - } - } - } - - pub fn dpy(&self) -> *mut xlib::Display { - self.xlib_state.dpy() - } - - pub fn root(&self) -> xlib::Window { - self.xlib_state.root() - } - - pub fn grab_button(mut self, button: u32, mod_mask: u32, button_mask: i64) -> Self { - self.buttons.push((button, mod_mask, button_mask)); - self.xlib_state - .grab_button(self.root(), button, mod_mask, button_mask); - - self - } - - pub fn add_event_handler(mut self, handler: F) -> Self - where - F: Fn(&Self, &XEvent) + 'static, - { - self.event_handlers.push(Arc::new(handler)); - - self - } - - pub fn add_key_handler(mut self, key: S, mask: u32, handler: F) -> Self - where - S: Into, - F: Fn(&Self, &XEvent) + 'static, - { - let keycode = self.xlib_state.keycode(key); - - self.key_handlers.push((keycode, mask, Arc::new(handler))); - self.xlib_state.grab_key(self.root(), keycode, mask); - - self - } - - fn unfocus_client(&self, client: Rc) { - unsafe { - xlib::XSetInputFocus( - self.dpy(), - client.window, - xlib::RevertToPointerRoot, - xlib::CurrentTime, - ); - - xlib::XDeleteProperty( - self.dpy(), - self.root(), - self.xlib_state.atoms.active_window.unwrap(), - ); - } - } - - fn focus_client(&self, client: Rc) { - let _ = self.mut_state.try_borrow_mut().and_then(|m| { - let mut focused_client = RefMut::map(m, |m| &mut m.focused_client); - match focused_client.upgrade() { - Some(c) => { - self.unfocus_client(c.clone()); - } - _ => {} - } - - *focused_client = Rc::downgrade(&client); - - Ok(()) - }); - - unsafe { - xlib::XSetInputFocus( - self.dpy(), - client.window, - xlib::RevertToPointerRoot, - xlib::CurrentTime, - ); - - xlib::XChangeProperty( - self.dpy(), - self.root(), - self.xlib_state.atoms.active_window.unwrap(), - xlib::XA_WINDOW, - 32, - xlib::PropModeReplace, - &client.window as *const u64 as *const _, - 1, - ); - } - - self.xlib_state - .send_event(client.window, self.xlib_state.atoms.take_focus); - } - - fn arrange_clients(&self) { - let (screen_w, screen_h) = unsafe { - ( - xlib::XDisplayWidth(self.dpy(), self.xlib_state.screen()), - xlib::XDisplayHeight(self.dpy(), self.xlib_state.screen()), - ) - }; - - let clients_num = self.mut_state.borrow().clients.len() as i32; - - if clients_num != 0 { - let window_w = screen_w / clients_num; - - for (i, (_, client)) in self.mut_state.borrow().clients.iter().enumerate() { - let client_state = ClientState { - size: (window_w as u32, screen_h as u32), - position: (window_w * i as i32, 0), - }; - - client.state.replace(client_state); - - let mut wc = xlib::XWindowChanges { - x: client_state.position.0, - y: client_state.position.1, - width: client_state.size.0 as i32, - height: client_state.size.1 as i32, - border_width: 0, - sibling: 0, - stack_mode: 0, - }; - - unsafe { - xlib::XConfigureWindow( - self.dpy(), - client.window, - (xlib::CWY | xlib::CWX | xlib::CWHeight | xlib::CWWidth) as u32, - &mut wc, - ); - - self.configure_client(client.clone()); - - xlib::XSync(self.dpy(), 0); - } - } - } - } - - fn configure_client(&self, client: Rc) { - let client_state = client.get_state(); - - let mut event = xlib::XConfigureEvent { - type_: xlib::ConfigureNotify, - display: self.dpy(), - event: client.window, - window: client.window, - x: client_state.position.0, - y: client_state.position.1, - width: client_state.size.0 as i32, - height: client_state.size.1 as i32, - border_width: 0, - override_redirect: 0, - send_event: 0, - serial: 0, - above: 0, - }; - - unsafe { - xlib::XSendEvent( - self.dpy(), - client.window, - 0, - StructureNotifyMask, - &mut event as *mut _ as *mut XEvent, - ); - } - } - - fn handle_move_window(&self, event: &XEvent) { - let clean_mask = self.xlib_state.clean_mask(); - - let move_window = &mut self.mut_state.borrow_mut().move_window; - - if unsafe { - move_window.is_none() - && event.get_type() == xlib::ButtonPress - && event.button.button == 1 - && event.button.state & clean_mask == Mod1Mask & clean_mask - && event.button.subwindow != 0 - } { - let win_pos = unsafe { - let mut attr: xlib::XWindowAttributes = - std::mem::MaybeUninit::zeroed().assume_init(); - xlib::XGetWindowAttributes(self.dpy(), event.button.subwindow, &mut attr); - - (attr.x, attr.y) - }; - - *move_window = Some(unsafe { - ( - event.button.subwindow, - (event.button.x, event.button.y), - win_pos, - ) - }); - } else if unsafe { - move_window.is_some() - && event.get_type() == xlib::ButtonRelease - && event.button.button == 1 - } { - *move_window = None; - } else if move_window.is_some() && event.get_type() == xlib::MotionNotify { - let move_window = move_window.unwrap(); - - let attr = unsafe { - let mut attr: xlib::XWindowAttributes = - std::mem::MaybeUninit::zeroed().assume_init(); - xlib::XGetWindowAttributes(self.dpy(), move_window.0, &mut attr); - - attr - }; - - let (x, y) = unsafe { - ( - event.motion.x - move_window.1 .0 + move_window.2 .0, - event.motion.y - move_window.1 .1 + move_window.2 .1, - ) - }; - - let mut wc = xlib::XWindowChanges { - x, - y, - width: attr.width, - height: attr.height, - border_width: 0, - sibling: 0, - stack_mode: 0, - }; - - unsafe { - xlib::XConfigureWindow( - self.dpy(), - move_window.0, - (xlib::CWX | xlib::CWY) as u32, - &mut wc, - ); - - xlib::XSync(self.dpy(), 0); - } - } - } - - fn handle_resize_window(&self, event: &XEvent) { - let clean_mask = self.xlib_state.clean_mask(); - - let resize_window = &mut self.mut_state.borrow_mut().resize_window; - - if unsafe { - resize_window.is_none() - && event.get_type() == xlib::ButtonPress - && event.button.button == 3 - && event.button.state & clean_mask == Mod1Mask & clean_mask - && event.button.subwindow != 0 - } { - unsafe { - let mut attr: xlib::XWindowAttributes = - std::mem::MaybeUninit::zeroed().assume_init(); - - xlib::XGetWindowAttributes(self.dpy(), event.button.subwindow, &mut attr); - - *resize_window = Some((event.button.subwindow, (attr.x, attr.y))); - - xlib::XWarpPointer( - self.dpy(), - 0, - event.button.subwindow, - 0, - 0, - 0, - 0, - attr.width + attr.border_width - 1, - attr.height + attr.border_width - 1, - ); - }; - } else if unsafe { - resize_window.is_some() - && event.get_type() == xlib::ButtonRelease - && event.button.button == 3 - } { - *resize_window = None; - } else if resize_window.is_some() && event.get_type() == xlib::MotionNotify { - let resize_window = resize_window.unwrap(); - - let attr = unsafe { - let mut attr: xlib::XWindowAttributes = - std::mem::MaybeUninit::zeroed().assume_init(); - xlib::XGetWindowAttributes(self.dpy(), resize_window.0, &mut attr); - - attr - }; - - unsafe { - let (width, height) = { - ( - std::cmp::max( - 1, - event.motion.x - resize_window.1 .0 + 2 * attr.border_width + 1, - ), - std::cmp::max( - 1, - event.motion.y - resize_window.1 .1 + 2 * attr.border_width + 1, - ), - ) - }; - - let mut wc = xlib::XWindowChanges { - x: attr.x, - y: attr.y, - width, - height, - border_width: attr.border_width, - sibling: 0, - stack_mode: 0, - }; - - xlib::XConfigureWindow( - self.dpy(), - resize_window.0, - (xlib::CWWidth | xlib::CWHeight) as u32, - &mut wc, - ); - - xlib::XSync(self.dpy(), 0); - } - } - } - - // spawn a new process / calls execvp - pub fn spawn(&self, command: T, args: &[T]) -> Result<()> { - let fd = unsafe { xlib::XConnectionNumber(self.dpy()) }; - - match unsafe { fork() } { - Ok(ForkResult::Parent { .. }) => Ok(()), - Ok(ForkResult::Child) => { - // i dont think i want to exit this block without closing the program, - // so unwrap everything - - close(fd) - .or_else(|_| Err("failed to close x connection")) - .unwrap(); - setsid().ok().ok_or("failed to setsid").unwrap(); - - let c_cmd = CString::new(command.to_string()).unwrap(); - - let c_args: Vec<_> = args - .iter() - .map(|s| CString::new(s.to_string()).unwrap()) - .collect(); - - execvp( - &c_cmd, - &c_args.iter().map(|s| s.as_c_str()).collect::>(), - ) - .or(Err("failed to execvp()")) - .unwrap(); - - eprintln!("execvp({}) failed.", c_cmd.to_str().unwrap()); - std::process::exit(0); - } - Err(_) => Err(Error::new(ErrorKind::Other, "failed to fork.")), - } - } + pub fn new() -> Self { + Self { + xlib_state: XLibState::new(), + mut_state: RefCell::new(WMStateMut::default()), + key_handlers: vec![], + event_handlers: vec![], + buttons: vec![], + } + } + + pub fn init() -> Self { + let state = Self::new() + .grab_button( + 1, + Mod1Mask, + ButtonPressMask | ButtonReleaseMask | PointerMotionMask, + ) + //.add_event_handler(Self::handle_move_window) + .grab_button( + 3, + Mod1Mask, + ButtonPressMask | ButtonReleaseMask | PointerMotionMask, + ) + //.add_event_handler(Self::handle_resize_window) + .add_key_handler("T", Mod1Mask, |state, _| { + println!("spawning terminal"); + let _ = state.spawn("xterm", &[]); + }) + .add_key_handler("M", Mod1Mask, |state, event| { + Some(state.mut_state.borrow_mut()).and_then(|mut mstate| { + (mstate + .clients + .iter() + .filter(|&(_, c)| c.borrow().window == unsafe { event.button.subwindow }) + .next() + .and_then(|(_, c)| Some(c.clone()))) + .and_then(|c| { + mstate.master_stack.push(Rc::downgrade(&c)); + Some(()) + }) + }); + + state.arrange_clients(); + }) + .add_key_handler("L", Mod1Mask, |state, _| { + println!("{:#?}", state.mut_state.borrow()); + }) + .add_key_handler("Q", Mod1Mask, |state, event| unsafe { + if event.key.subwindow != 0 { + if state.xlib_state.atoms.delete.is_none() + || !state + .xlib_state + .send_event(event.key.subwindow, state.xlib_state.atoms.delete) + { + xlib::XKillClient(state.dpy(), event.key.subwindow); + } + } + }) + .add_key_handler("Q", Mod1Mask | ShiftMask, |state, _event| { + unsafe { + xlib::XCloseDisplay(state.dpy()); + } + + std::process::exit(0); + }); + + unsafe { + let mut wa: xlib::XSetWindowAttributes = std::mem::MaybeUninit::zeroed().assume_init(); + wa.event_mask = SubstructureRedirectMask + | StructureNotifyMask + | SubstructureNotifyMask + | EnterWindowMask + | PointerMotionMask + | ButtonPressMask; + + xlib::XChangeWindowAttributes(state.dpy(), state.root(), CWEventMask, &mut wa); + + xlib::XSelectInput(state.dpy(), state.root(), wa.event_mask); + } + + state + } + + pub fn run(self) -> Self { + loop { + let event = unsafe { + let mut event: xlib::XEvent = std::mem::MaybeUninit::zeroed().assume_init(); + xlib::XNextEvent(self.dpy(), &mut event); + + event + }; + + self.event_handlers.iter().for_each(|handler| { + handler(&self, &event); + }); + + match event.get_type() { + xlib::MapRequest => { + self.map_request(unsafe { &event.map_request }); + } + xlib::UnmapNotify => { + self.unmap_notify(unsafe { &event.unmap }); + } + xlib::DestroyNotify => { + self.destroy_notify(unsafe { &event.destroy_window }); + } + xlib::ConfigureRequest => { + self.configure_request(unsafe { &event.configure_request }); + } + xlib::EnterNotify => { + self.enter_notify(unsafe { &event.crossing }); + } + xlib::ButtonPress => { + self.button_press(unsafe { &event.button }); + } + xlib::KeyPress => { + let clean_mask = self.xlib_state.clean_mask(); + + self.key_handlers.iter().for_each(|(key, mask, handler)| { + if unsafe { + event.key.keycode == *key as u32 + && event.key.state & clean_mask == *mask & clean_mask + } { + handler(&self, &event); + } + }) + } + _ => {} + } + } + } + + pub fn dpy(&self) -> *mut xlib::Display { + self.xlib_state.dpy() + } + + pub fn root(&self) -> xlib::Window { + self.xlib_state.root() + } + + pub fn grab_button(mut self, button: u32, mod_mask: u32, button_mask: i64) -> Self { + self.buttons.push((button, mod_mask, button_mask)); + self.xlib_state + .grab_button(self.root(), button, mod_mask, button_mask); + + self + } + + #[allow(dead_code)] + pub fn add_event_handler(mut self, handler: F) -> Self + where + F: Fn(&Self, &XEvent) + 'static, + { + self.event_handlers.push(Rc::new(handler)); + + self + } + + pub fn add_key_handler(mut self, key: S, mask: u32, handler: F) -> Self + where + S: Into, + F: Fn(&Self, &XEvent) + 'static, + { + let keycode = self.xlib_state.keycode(key); + + self.key_handlers.push((keycode, mask, Rc::new(handler))); + self.xlib_state.grab_key(self.root(), keycode, mask); + + self + } + + fn map_request(&self, event: &xlib::XMapRequestEvent) { + info!("[MapRequest] event: {:#?}", event); + + let _ = Some(self.mut_state.borrow_mut()) + .and_then(|mut state| { + if !state.clients.contains_key(&event.window) { + info!("[MapRequest] new client: {:#?}", event.window); + Some( + state + .clients + .entry(event.window) + .or_insert_with(|| Rc::new(RefCell::new(Client::new(event.window)))) + .clone(), + ) + } else { + None + } + }) + .and_then(|c| { + unsafe { + xlib::XMapWindow(self.dpy(), c.borrow().window); + + xlib::XSelectInput( + self.dpy(), + event.window, + EnterWindowMask + | FocusChangeMask | PropertyChangeMask + | StructureNotifyMask, + ); + } + + self.buttons + .iter() + .for_each(|&(button, mod_mask, button_mask)| { + self.xlib_state.grab_button( + c.borrow().window, + button, + mod_mask, + button_mask, + ); + }); + + self.arrange_clients(); + self.focus_client(c.clone()); + + Some(()) + }); + } + + fn unmap_notify(&self, event: &xlib::XUnmapEvent) { + info!("[UnmapNotify] event: {:#?}", event); + + if event.send_event == 0 { + let _ = Some(self.mut_state.borrow_mut()).and_then(|mut state| { + if state.clients.contains_key(&event.window) { + let client = state.clients.remove(&event.window); + info!("[UnmapNotify] removing client: {:#?}", client); + } + + Some(()) + }); + } + + self.arrange_clients(); + } + + fn destroy_notify(&self, event: &xlib::XDestroyWindowEvent) { + info!("[DestroyNotify] event: {:?}", event); + + let _ = Some(self.mut_state.borrow_mut()).and_then(|mut state| { + let _entry = state.clients.remove(&event.window); + + info!("[DestroyNotify] removed entry: {:?}", _entry); + + Some(()) + }); + + self.arrange_clients(); + } + + fn configure_request(&self, event: &xlib::XConfigureRequestEvent) { + info!("[ConfigureRequest] event: {:?}", event); + + match self.mut_state.borrow_mut().clients.entry(event.window) { + Entry::Occupied(entry) => { + info!( + "[ConfigureRequest] found Client for Window({:?}): {:#?}", + event.window, + entry.get() + ); + + self.configure_client(entry.get().clone()); + } + _ => { + info!( + "[ConfigureRequest] no client found for Window({:?}), calling XConfigureWindow()", + event.window); + + let mut wc = xlib::XWindowChanges { + x: event.x, + y: event.y, + width: event.width, + height: event.height, + border_width: event.border_width, + sibling: event.above, + stack_mode: event.detail, + }; + + unsafe { + xlib::XConfigureWindow( + self.dpy(), + event.window, + event.value_mask as u32, + &mut wc, + ); + } + } + } + } + + fn enter_notify(&self, event: &xlib::XCrossingEvent) { + info!("[EnterNotify] event: {:?}", event); + + Some(self.mut_state.borrow()) + .and_then(|state| { + state + .clients + .get(&event.window) + .and_then(|c| Some(c.clone())) + }) + .and_then(|c| { + info!( + "[EnterNotify] focusing Client for Window({:?})", + event.window + ); + self.focus_client(c); + + Some(()) + }); + } + + fn button_press(&self, event: &xlib::XButtonEvent) { + info!("[ButtonPress] event: {:?}", event); + + Some(self.mut_state.borrow()) + .and_then(|state| { + state + .clients + .get(&event.subwindow) + .and_then(|c| Some(c.clone())) + }) + .and_then(|c| { + info!( + "[ButtonPress] focusing Client for Window({:?})", + event.window + ); + + self.focus_client(c.clone()); + + info!("[ButtonPress] raising Window({:?})", event.window); + + unsafe { + xlib::XRaiseWindow(self.dpy(), c.borrow().window); + xlib::XSync(self.dpy(), 0); + } + + Some(()) + }); + } + + fn unfocus_client(&self, client: Rc>) { + unsafe { + xlib::XSetInputFocus( + self.dpy(), + client.borrow().window, + xlib::RevertToPointerRoot, + xlib::CurrentTime, + ); + + xlib::XDeleteProperty( + self.dpy(), + self.root(), + self.xlib_state.atoms.active_window.unwrap(), + ); + } + } + + fn focus_client(&self, client: Rc>) { + let _ = self.mut_state.try_borrow_mut().and_then(|m| { + let mut focused_client = RefMut::map(m, |m| &mut m.focused_client); + match focused_client.upgrade() { + Some(c) => { + self.unfocus_client(c.clone()); + } + _ => {} + } + + *focused_client = Rc::downgrade(&client); + + Ok(()) + }); + + unsafe { + xlib::XSetInputFocus( + self.dpy(), + client.borrow().window, + xlib::RevertToPointerRoot, + xlib::CurrentTime, + ); + + xlib::XChangeProperty( + self.dpy(), + self.root(), + self.xlib_state.atoms.active_window.unwrap(), + xlib::XA_WINDOW, + 32, + xlib::PropModeReplace, + &client.borrow().window as *const u64 as *const _, + 1, + ); + } + + self.xlib_state + .send_event(client.borrow().window, self.xlib_state.atoms.take_focus); + } + + fn arrange_clients(&self) { + self.refresh_stack(); + + let (screen_w, screen_h) = unsafe { + ( + xlib::XDisplayWidth(self.dpy(), self.xlib_state.screen()), + xlib::XDisplayHeight(self.dpy(), self.xlib_state.screen()), + ) + }; + + Some(self.mut_state.borrow_mut()).and_then(|mut state| { + // no need to arrange any clients if there is no clients + if !state.clients.is_empty() { + // if master stack is empty, populate with first entry in clients list + if state.master_stack.is_empty() { + let first_client = Rc::downgrade(state.clients.iter().next().unwrap().1); + state.master_stack.push(first_client); + } + + let window_w = { + let has_aux_stack = state + .clients + .iter() + .filter(|&(_, client)| { + state + .master_stack + .iter() + .filter(|weak_client| weak_client.upgrade().unwrap() != *client) + .count() != 0 + }) + .count() != 0; + + if has_aux_stack { + screen_w / 2 + } else { + screen_w + } + }; + + for (i, weak_client) in state.master_stack.iter().enumerate() { + let client = weak_client.upgrade().unwrap(); + + let mut wc = { + let mut client = client.borrow_mut(); + let window_h = screen_h / state.master_stack.len() as i32; + + client.size = (window_w, window_h); + client.position = (0, window_h * i as i32); + + xlib::XWindowChanges { + x: client.position.0, + y: client.position.1, + width: client.size.0, + height: client.size.1, + border_width: 0, + sibling: 0, + stack_mode: 0, + } + }; + + unsafe { + xlib::XConfigureWindow( + self.dpy(), + client.borrow().window, + (xlib::CWY | xlib::CWX | xlib::CWHeight | xlib::CWWidth) as u32, + &mut wc, + ); + + self.configure_client(client.clone()); + + xlib::XSync(self.dpy(), 0); + } + } + + // filter only windows that arent inthe master stack, essentially aux stack + for (i, (_, client)) in state + .clients + .iter() + .filter(|&(_, c)| { + state + .master_stack + .iter() + .filter(|w| w.upgrade().unwrap() == *c) + .count() == 0 + }) + .enumerate() + { + let mut wc = { + let mut client = client.borrow_mut(); + let window_h = + screen_h / (state.clients.len() - state.master_stack.len()) as i32; + + client.size = (window_w, window_h); + client.position = (window_w, window_h * i as i32); + + xlib::XWindowChanges { + x: client.position.0, + y: client.position.1, + width: client.size.0, + height: client.size.1, + border_width: 0, + sibling: 0, + stack_mode: 0, + } + }; + + unsafe { + xlib::XConfigureWindow( + self.dpy(), + client.borrow().window, + (xlib::CWY | xlib::CWX | xlib::CWHeight | xlib::CWWidth) as u32, + &mut wc, + ); + + self.configure_client(client.clone()); + + xlib::XSync(self.dpy(), 0); + } + } + } + + Some(()) + }); + } + + fn refresh_stack(&self) { + Some(self.mut_state.borrow_mut()).and_then(|mut state| { + state.master_stack = state + .master_stack + .iter() + .filter_map(|weak_client| { + weak_client + .upgrade() + .and_then(|_| Some(weak_client.clone())) + }) + .collect(); + + Some(()) + }); + } + + fn configure_client(&self, client: Rc>) { + let mut event = { + let client = client.borrow(); + + xlib::XConfigureEvent { + type_: xlib::ConfigureNotify, + display: self.dpy(), + event: client.window, + window: client.window, + x: client.position.0, + y: client.position.1, + width: client.size.0, + height: client.size.1, + border_width: 0, + override_redirect: 0, + send_event: 0, + serial: 0, + above: 0, + } + }; + + unsafe { + xlib::XSendEvent( + self.dpy(), + event.window, + 0, + StructureNotifyMask, + &mut event as *mut _ as *mut XEvent, + ); + } + } + + fn handle_move_window(&self, event: &XEvent) { + let clean_mask = self.xlib_state.clean_mask(); + + let move_window = &mut self.mut_state.borrow_mut().move_window; + + if unsafe { + move_window.is_none() + && event.get_type() == xlib::ButtonPress + && event.button.button == 1 + && event.button.state & clean_mask == Mod1Mask & clean_mask + && event.button.subwindow != 0 + } { + let win_pos = unsafe { + let mut attr: xlib::XWindowAttributes = + std::mem::MaybeUninit::zeroed().assume_init(); + xlib::XGetWindowAttributes(self.dpy(), event.button.subwindow, &mut attr); + + (attr.x, attr.y) + }; + + *move_window = Some(unsafe { + ( + event.button.subwindow, + (event.button.x, event.button.y), + win_pos, + ) + }); + } else if unsafe { + move_window.is_some() + && event.get_type() == xlib::ButtonRelease + && event.button.button == 1 + } { + *move_window = None; + } else if move_window.is_some() && event.get_type() == xlib::MotionNotify { + let move_window = move_window.unwrap(); + + let attr = unsafe { + let mut attr: xlib::XWindowAttributes = + std::mem::MaybeUninit::zeroed().assume_init(); + xlib::XGetWindowAttributes(self.dpy(), move_window.0, &mut attr); + + attr + }; + + let (x, y) = unsafe { + ( + event.motion.x - move_window.1 .0 + move_window.2 .0, + event.motion.y - move_window.1 .1 + move_window.2 .1, + ) + }; + + let mut wc = xlib::XWindowChanges { + x, + y, + width: attr.width, + height: attr.height, + border_width: 0, + sibling: 0, + stack_mode: 0, + }; + + unsafe { + xlib::XConfigureWindow( + self.dpy(), + move_window.0, + (xlib::CWX | xlib::CWY) as u32, + &mut wc, + ); + + xlib::XSync(self.dpy(), 0); + } + } + } + + fn handle_resize_window(&self, event: &XEvent) { + let clean_mask = self.xlib_state.clean_mask(); + + let resize_window = &mut self.mut_state.borrow_mut().resize_window; + + if unsafe { + resize_window.is_none() + && event.get_type() == xlib::ButtonPress + && event.button.button == 3 + && event.button.state & clean_mask == Mod1Mask & clean_mask + && event.button.subwindow != 0 + } { + unsafe { + let mut attr: xlib::XWindowAttributes = + std::mem::MaybeUninit::zeroed().assume_init(); + + xlib::XGetWindowAttributes(self.dpy(), event.button.subwindow, &mut attr); + + *resize_window = Some((event.button.subwindow, (attr.x, attr.y))); + + xlib::XWarpPointer( + self.dpy(), + 0, + event.button.subwindow, + 0, + 0, + 0, + 0, + attr.width + attr.border_width - 1, + attr.height + attr.border_width - 1, + ); + }; + } else if unsafe { + resize_window.is_some() + && event.get_type() == xlib::ButtonRelease + && event.button.button == 3 + } { + *resize_window = None; + } else if resize_window.is_some() && event.get_type() == xlib::MotionNotify { + let resize_window = resize_window.unwrap(); + + let attr = unsafe { + let mut attr: xlib::XWindowAttributes = + std::mem::MaybeUninit::zeroed().assume_init(); + xlib::XGetWindowAttributes(self.dpy(), resize_window.0, &mut attr); + + attr + }; + + unsafe { + let (width, height) = { + ( + std::cmp::max( + 1, + event.motion.x - resize_window.1 .0 + 2 * attr.border_width + 1, + ), + std::cmp::max( + 1, + event.motion.y - resize_window.1 .1 + 2 * attr.border_width + 1, + ), + ) + }; + + let mut wc = xlib::XWindowChanges { + x: attr.x, + y: attr.y, + width, + height, + border_width: attr.border_width, + sibling: 0, + stack_mode: 0, + }; + + xlib::XConfigureWindow( + self.dpy(), + resize_window.0, + (xlib::CWWidth | xlib::CWHeight) as u32, + &mut wc, + ); + + xlib::XSync(self.dpy(), 0); + } + } + } + + // spawn a new process / calls execvp + pub fn spawn(&self, command: T, args: &[T]) -> Result<()> { + let fd = unsafe { xlib::XConnectionNumber(self.dpy()) }; + + match unsafe { fork() } { + Ok(ForkResult::Parent { .. }) => Ok(()), + Ok(ForkResult::Child) => { + // i dont think i want to exit this block without closing the program, + // so unwrap everything + + close(fd) + .or_else(|_| Err("failed to close x connection")) + .unwrap(); + setsid().ok().ok_or("failed to setsid").unwrap(); + + let c_cmd = CString::new(command.to_string()).unwrap(); + + let c_args: Vec<_> = args + .iter() + .map(|s| CString::new(s.to_string()).unwrap()) + .collect(); + + execvp( + &c_cmd, + &c_args.iter().map(|s| s.as_c_str()).collect::>(), + ) + .or(Err("failed to execvp()")) + .unwrap(); + + eprintln!("execvp({}) failed.", c_cmd.to_str().unwrap()); + std::process::exit(0); + } + Err(_) => Err(Error::new(ErrorKind::Other, "failed to fork.")), + } + } } diff --git a/vm-ss.png b/vm-ss.png new file mode 100644 index 0000000000000000000000000000000000000000..caeed26cb8c89cbf73297292d56639cdd8f0ace9 GIT binary patch literal 134626 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
j~F;@;ykDTT3 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
SWr(lPUC+yv$gsL2i$vPB3|&RvPpmK8 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�g52~$TI2XRk!L!c#coFF&QLnS=#2QT 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