1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// 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::process;
use std::ptr;
use libc::c_int;
use libc::pid_t;
use x11::xlib;
use x11::xlib::{XEvent, GrabModeAsync};
use dotwm::DotWM;
use safe_x11::grab_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>)>;
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);
}
}
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
}
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
}
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
}
pub fn focus_next(wm: &mut DotWM, _: xlib::XEvent, _: &[String]) -> bool {
wm.focus_next();
true
}
pub fn quit_dotwm(_: &mut DotWM, _: xlib::XEvent, _: &[String]) -> bool {
process::exit(0);
}
/// 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]) {
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));
}
|
