112 lines
3.7 KiB
Rust
112 lines
3.7 KiB
Rust
use std::vec::Vec;
|
|
use std::process::{ Command, Child, Stdio };
|
|
use std::io::{ BufReader, BufRead, Write };
|
|
use std::cell::RefCell;
|
|
use std::path::Path;
|
|
use std::io::Read;
|
|
|
|
use ron;
|
|
|
|
use crate::window_manager::{ DrawInstructions, WindowLike, WindowLikeType };
|
|
use crate::messages::{ WindowMessage, WindowMessageResponse };
|
|
use crate::framebuffer::Dimensions;
|
|
use crate::themes::ThemeInfo;
|
|
|
|
pub struct ProxyWindowLike {
|
|
process: RefCell<Child>,
|
|
}
|
|
|
|
//try to handle panics of child processes so the entire wm doesn't crash
|
|
//we can "guarantee" that the ron::to_string(...).unwrap() calls will never panic
|
|
impl WindowLike for ProxyWindowLike {
|
|
fn handle_message(&mut self, message: WindowMessage) -> WindowMessageResponse {
|
|
if let Some(stdin) = self.process.borrow_mut().stdin.as_mut() {
|
|
let _ = stdin.write_all(("handle_message ".to_string() + &ron::to_string(&message).unwrap() + "\n").as_bytes());
|
|
}
|
|
let output = self.read_line();
|
|
ron::from_str(&output).unwrap_or(WindowMessageResponse::JustRedraw)
|
|
}
|
|
|
|
fn draw(&self, theme_info: &ThemeInfo) -> Vec<DrawInstructions> {
|
|
if let Some(stdin) = self.process.borrow_mut().stdin.as_mut() {
|
|
let _ = stdin.write_all(("draw ".to_string() + &ron::to_string(&theme_info).unwrap() + "\n").as_bytes());
|
|
}
|
|
let output = self.read_line();
|
|
ron::from_str(&output).unwrap_or(Vec::new())
|
|
}
|
|
|
|
//properties
|
|
fn title(&self) -> String {
|
|
if let Some(stdin) = self.process.borrow_mut().stdin.as_mut() {
|
|
let _ = stdin.write_all("title\n".as_bytes());
|
|
}
|
|
self.read_line().chars().filter(|c| *c != '\n').collect()
|
|
}
|
|
|
|
fn resizable(&self) -> bool {
|
|
if let Some(stdin) = self.process.borrow_mut().stdin.as_mut() {
|
|
let _ = stdin.write_all("resizable\n".to_string().as_bytes());
|
|
}
|
|
let output = self.read_line();
|
|
ron::from_str(&output).unwrap_or(false)
|
|
}
|
|
|
|
fn subtype(&self) -> WindowLikeType {
|
|
if let Some(stdin) = self.process.borrow_mut().stdin.as_mut() {
|
|
let _ = stdin.write_all("subtype\n".to_string().as_bytes());
|
|
}
|
|
let output = self.read_line();
|
|
ron::from_str(&output).unwrap_or(WindowLikeType::Window)
|
|
}
|
|
|
|
fn ideal_dimensions(&self, dimensions: Dimensions) -> Dimensions {
|
|
if let Some(stdin) = self.process.borrow_mut().stdin.as_mut() {
|
|
let _ = stdin.write_all(("ideal_dimensions ".to_string() + &ron::to_string(&dimensions).unwrap() + "\n").as_bytes());
|
|
}
|
|
let output = self.read_line();
|
|
ron::from_str(&output).unwrap_or([420, 420])
|
|
}
|
|
}
|
|
|
|
//kill process when this window like dropped
|
|
impl Drop for ProxyWindowLike {
|
|
fn drop(&mut self) {
|
|
let _ = self.process.borrow_mut().kill();
|
|
}
|
|
}
|
|
|
|
impl ProxyWindowLike {
|
|
pub fn new(command: &mut Command) -> Self {
|
|
ProxyWindowLike {
|
|
process: RefCell::new(command.stdout(Stdio::piped()).stdin(Stdio::piped()).stderr(Stdio::null()).spawn().unwrap()),
|
|
}
|
|
}
|
|
|
|
pub fn new_rust(file: &str) -> Self {
|
|
let loc = format!("./target/release/{}", file);
|
|
if Path::new(&loc).exists() {
|
|
ProxyWindowLike::new(Command::new(loc).stdout(Stdio::piped()).stdin(Stdio::piped()).stderr(Stdio::null()))
|
|
} else {
|
|
ProxyWindowLike::new(Command::new("cargo").arg("run").arg("--quiet").arg("--release").arg("--bin").arg(file).stdout(Stdio::piped()).stdin(Stdio::piped()).stderr(Stdio::null()))
|
|
}
|
|
}
|
|
|
|
//return empty string if error, do not propogate Err becuase that's messy
|
|
//or maybe return "panicked"?
|
|
fn read_line(&self) -> String {
|
|
let mut buffer = self.process.borrow_mut();
|
|
if let Some(buffer) = buffer.stdout.as_mut() {
|
|
let mut output = String::new();
|
|
let mut reader = BufReader::new(buffer);
|
|
if let Ok(_) = reader.read_line(&mut output) {
|
|
output
|
|
} else {
|
|
String::new()
|
|
}
|
|
} else {
|
|
String::new()
|
|
}
|
|
}
|
|
}
|
|
|