path: root/src/command.rs

// See LICENSE file for copyright and license details.

//! Command execution module.
//!
use std::collections::HashMap;
use std::ffi::OsStr;
use std::io::Result;
use std::ops::Deref;
use std::process::{Command,Child};
use std::ptr;

use libc::c_int;
use libc::pid_t;

use x11::xlib;
use x11::xlib::{XEvent, GrabModeAsync};

use dotwm::DotWM;
use dotwm::NetAtom;
use safe_x11::{grab_key,ungrab_key};

const WNOHANG: c_int = 0x00000001;

extern {
    /// wait for a child process to stop or terminate.
    pub fn waitpid(pid: pid_t, stat_loc: *mut c_int, options: c_int) -> pid_t;
}

/// Executes the given command.
pub fn exec_cmd<S: AsRef<OsStr>>(program: S, args: &[S]) -> Result<Child> {
    Command::new(program).args(args).spawn()
}

/// Collect all the zombies. There's no need to add another dependency for this
/// since it's trivial to implement.
///
/// See https://github.com/Kintaro/zombie for reference.
pub fn collect_zombies() {
    unsafe { 
        while waitpid(-1, ptr::null_mut(), WNOHANG) > 0 {}
    };
}

/// Defines a callback to call no certains events.
pub type ExecFn = fn(&mut DotWM, XEvent, &[String]) -> bool;

/// Map for keys => functions
pub type BindingHash = HashMap<(u32, u32), (ExecFn, Vec<String>)>;

/// Exec a binding function.
pub fn exec_func(wm: &mut DotWM, bindings: &mut BindingHash, key: u32, modifiers: u32, ev: xlib::XEvent) {
    if let Some(&(func, ref args)) = bindings.get(&(key, modifiers)) {
        let v = args.clone();
        func(wm, ev, &v);
    }
}

/// Exec a external function
pub fn exec(_: &mut DotWM, _: xlib::XEvent, args: &[String]) -> bool {
    if let Some(program) = args.first() {
        let mut prog_args = vec![];
        for arg in args[1..].iter() {
            prog_args.push(arg);
        }
        exec_cmd(program, prog_args.deref()).unwrap();
    }
    true
}

/// Toggles the fullscreen of the current window
pub fn fullscreen(wm: &mut DotWM, _: xlib::XEvent, _: &[String]) -> bool {
    let wmstate = wm.netatoms[&NetAtom::NetWmState];
    let fs_atom = wm.netatoms[&NetAtom::NetFullscreen];

    if let Some(win) = wm.current_window_mut() {
        win.toggle_fullscreen(wmstate, fs_atom, true);
    };
    true
}

/// Move the window to a relative position
pub fn move_win(wm: &mut DotWM, _: xlib::XEvent, args: &[String]) -> bool {
    let x = args[0].parse::<i32>().unwrap();
    let y = args[1].parse::<i32>().unwrap();
    if let Some(ref win) = wm.current_window() {
        win.move_offset(x, y);
    };
    true
}

/// Move the window to an absolute position.
pub fn move_win_to(wm: &mut DotWM, _: xlib::XEvent, args: &[String]) -> bool {
    let x = args[0].parse::<i32>().unwrap();
    let y = args[1].parse::<i32>().unwrap();
    if let Some(ref win) = wm.current_window() {
        match win.move_to(x, y) {
            Ok(()) => true,
            Err(_) => {
                false
            }
        }
    } else {
        true
    }
}

pub fn move_win_sticky(wm: &mut DotWM, _: xlib::XEvent, args: &[String]) -> bool {
    if let Some(ref win) = wm.current_window() {
        let attrs = win.attributes();

        match &*args[0] {
            "left" => {
                let mut xgeo = wm.x_geometries();
                xgeo.sort_by(|a,b| b.cmp(a));

                let val = xgeo.iter().skip_while(|&a| *a >= attrs.x).next();
                if let Some(v) = val {
                    let _ = win.move_to(*v, attrs.y);
                }
            },
            "right" => {
                let mut xgeo = wm.x_geometries();
                let win_right = attrs.x + attrs.width;
                xgeo.sort_by(|a,b| a.cmp(b));

                let val = xgeo.iter().skip_while(|&a| *a <= win_right).next();
                if let Some(v) = val {
                    let _ = win.move_to(*v - attrs.width, attrs.y);
                }
            },
            "up" => {
                let mut ygeo = wm.y_geometries();
                ygeo.sort_by(|a,b| b.cmp(a));

                let val = ygeo.iter().skip_while(|&a| *a >= attrs.y).next();
                if let Some(v) = val {
                    let _ = win.move_to(attrs.x, *v);
                }
            },
            "down" => {
                let mut ygeo = wm.y_geometries();
                let win_bot = attrs.y + attrs.height;
                ygeo.sort_by(|a,b| a.cmp(b));

                let val = ygeo.iter().skip_while(|&a| *a <= win_bot).next();
                if let Some(v) = val {
                    let _ = win.move_to(attrs.x, *v - attrs.height);
                }
            },
            _ => (),
        }
    }
    true
}

/// Resize the window certain amount in x and y.
pub fn resize_win(wm: &mut DotWM, _: xlib::XEvent, args: &[String]) -> bool {
    let w = args[0].parse::<i32>().unwrap();
    let h = args[1].parse::<i32>().unwrap();

    if let Some(ref win) = wm.current_window() {
        win.resize(w, h);
    };

    true
}

/// Resizes the window sticking with other windows.
///
/// The movement of the `right` command is the same logic as the `down`, idem to the
/// movement between `left` and `up`
pub fn resize_win_sticky(wm: &mut DotWM, _: xlib::XEvent, args: &[String]) -> bool {
    if let Some(ref win) = wm.current_window() {
        let attrs = win.attributes();

        match &*args[0] {
            "left" => {
                let mut xgeo = wm.x_geometries();
                xgeo.sort_by(|a,b| b.cmp(a));

                let val = xgeo.iter().skip_while(|&a| *a >= attrs.x + attrs.width).next();
                if let Some(v) = val {
                    let diff = attrs.width - (*v - attrs.x);
                    if *v - attrs.x > 0 {
                        let _ = win.resize_to(attrs.width - diff, attrs.height);
                    }
                }
            },
            "right" => {
                let mut xgeo = wm.x_geometries();
                let win_right = attrs.x + attrs.width;
                xgeo.sort_by(|a,b| a.cmp(b));

                let val = xgeo.iter().skip_while(|&a| *a <= win_right).next();
                if let Some(xpoint) = val {
                    let new_width = *xpoint - attrs.x;
                    let _ = win.resize_to(new_width, attrs.height);
                }
            },
            "up" => {
                let mut ygeo = wm.y_geometries();
                ygeo.sort_by(|a,b| b.cmp(a));

                let val = ygeo.iter().skip_while(|&a| *a >= attrs.y + attrs.height).next();
                if let Some(v) = val {
                    let diff = attrs.height - (*v - attrs.y);
                    if *v - attrs.y > 0 {
                        let _ = win.resize_to(attrs.width, attrs.height - diff);
                    }
                }
            },
            "down" => {
                let mut ygeo = wm.y_geometries();
                let win_bot = attrs.y + attrs.height;
                ygeo.sort_by(|a,b| a.cmp(b));

                let val = ygeo.iter().skip_while(|&a| *a <= win_bot).next();
                if let Some(v) = val {
                    let new_height = *v - attrs.y;
                    let _ = win.resize_to(attrs.width, new_height);
                }
            },
            _ => (),
        }
    }
    true
}

/// Close the current window
pub fn close_win(wm: &mut DotWM, _: xlib::XEvent, _: &[String]) -> bool {
    if let Some(ref win) = wm.current_window() {
        win.delete();
    };

    true
}

/// Focus the next window on the list
pub fn focus_next(wm: &mut DotWM, _: xlib::XEvent, _: &[String]) -> bool {
    wm.focus_next();
    true
}

/// Tells the window manager that is time to exit.
pub fn quit_dotwm(wm: &mut DotWM, _: xlib::XEvent, _: &[String]) -> bool {
    wm.finish = true;
    true
}

/// Add a binding to the WM.
///
/// # Example
///
/// ```
/// fn quit_dotwm(_: &mut DotWM, _: xlib::XEvent, _: &[String]) -> bool {
///     process::exit(0);
/// }
///
/// // ...
///
/// add_binding(keysym::XK_Return, xlib::Mod4Mask, exec,
///             &["xterm"]);
/// ```
pub fn add_binding(wm: &mut DotWM, bindings: &mut BindingHash,
               key: u32, modifiers: u32, func: ExecFn, args: &[&str]) {
        ungrab_key(wm.display, key, modifiers);
        grab_key(wm.display, key, modifiers, true, GrabModeAsync, GrabModeAsync);        
        let mut v = vec![];
        for arg in args {
            v.push(arg.to_string());
        }
        bindings.insert((key, modifiers), (func, v));
}

pub fn change_desktop(wm: &mut DotWM, _: xlib::XEvent, args: &[String]) -> bool {
    let num = args[0].parse::<usize>().unwrap();
    wm.change_desktop(num);
    true
}