Make main() own the channel, and pass it off

macos-click-through
KillTheMule 5 years ago
parent 50f7f3bbf2
commit 74c4075f06

@ -19,6 +19,7 @@ msgbox = "0.4.0"
rust-embed = { version = "5.2.0", features = ["debug-embed"] } rust-embed = { version = "5.2.0", features = ["debug-embed"] }
image = "0.22.3" image = "0.22.3"
nvim-rs = "0.1.0" nvim-rs = "0.1.0"
#nvim-rs = { git = "https://github.com/KillTheMule/nvim-rs", branch = "master" }
tokio = { version = "0.2.9", features = [ "blocking" ] } tokio = { version = "0.2.9", features = [ "blocking" ] }
async-trait = "0.1.18" async-trait = "0.1.18"

@ -8,21 +8,20 @@ mod renderer;
mod error_handling; mod error_handling;
mod ui_commands; mod ui_commands;
#[macro_use] extern crate async_trait;
#[macro_use] extern crate derive_new; #[macro_use] extern crate derive_new;
#[macro_use] extern crate rust_embed; #[macro_use] extern crate rust_embed;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use std::thread; //use std::thread;
use std::process::Stdio; use std::process::Stdio;
use std::sync::mpsc::{channel, Receiver, Sender}; use std::sync::mpsc::{channel, Receiver};
use async_trait::async_trait; use async_trait::async_trait;
use rmpv::Value; use rmpv::Value;
use nvim_rs::runtime::ChildStdin; use nvim_rs::runtime::ChildStdin;
use nvim_rs::{create, Neovim, UiAttachOptions, Handler}; use nvim_rs::{create, Neovim, UiAttachOptions, Handler};
use tokio::process::Command; use tokio::process::Command;
use tokio::task::spawn_blocking; use tokio::runtime::Runtime;
use window::ui_loop; use window::ui_loop;
use editor::Editor; use editor::Editor;
@ -58,7 +57,7 @@ struct NeovimHandler(Arc<Mutex<Editor>>);
impl Handler for NeovimHandler { impl Handler for NeovimHandler {
type Writer = ChildStdin; type Writer = ChildStdin;
async fn handle_notify(&self, event_name: String, arguments: Vec<Value>, neovim: Neovim<ChildStdin>) { async fn handle_notify(&self, event_name: String, arguments: Vec<Value>, _neovim: Neovim<ChildStdin>) {
dbg!(&event_name); dbg!(&event_name);
let parsed_events = parse_neovim_event(event_name, arguments) let parsed_events = parse_neovim_event(event_name, arguments)
.unwrap_or_explained_panic("Could not parse event", "Could not parse event from neovim"); .unwrap_or_explained_panic("Could not parse event", "Could not parse event from neovim");
@ -69,8 +68,7 @@ impl Handler for NeovimHandler {
} }
} }
#[tokio::main] async fn start_nvim(editor: Arc<Mutex<Editor>>, receiver: Receiver<UiCommand>) {
async fn start_nvim(editor: Arc<Mutex<Editor>>) -> Sender<UiCommand> {
let (mut nvim, io_handler, _) = create::new_child_cmd(&mut create_nvim_command(), NeovimHandler(editor.clone())).await let (mut nvim, io_handler, _) = create::new_child_cmd(&mut create_nvim_command(), NeovimHandler(editor.clone())).await
.unwrap_or_explained_panic("Could not create nvim process", "Could not locate or start the neovim process"); .unwrap_or_explained_panic("Could not create nvim process", "Could not locate or start the neovim process");
@ -86,23 +84,31 @@ async fn start_nvim(editor: Arc<Mutex<Editor>>) -> Sender<UiCommand> {
let mut options = UiAttachOptions::new(); let mut options = UiAttachOptions::new();
options.set_linegrid_external(true); options.set_linegrid_external(true);
options.set_rgb(true); options.set_rgb(true);
nvim.set_var("neovide", Value::Boolean(true)).await; nvim.set_var("neovide", Value::Boolean(true)).await
.unwrap_or_explained_panic("Could not communicate.", "Could not communicate with neovim process");
nvim.ui_attach(INITIAL_WIDTH as i64, INITIAL_HEIGHT as i64, &options).await nvim.ui_attach(INITIAL_WIDTH as i64, INITIAL_HEIGHT as i64, &options).await
.unwrap_or_explained_panic("Could not attach.", "Could not attach ui to neovim process"); .unwrap_or_explained_panic("Could not attach.", "Could not attach ui to neovim process");
let (mut sender, receiver) = channel::<UiCommand>(); loop {
tokio::spawn(async move { let r = receiver.recv();
while let Ok(ui_command) = spawn_blocking(|| receiver.recv()).await.unwrap() {
dbg!(&ui_command);
ui_command.execute(&nvim).await;
}
});
sender if let Ok(ui_command) = r {
dbg!(&ui_command);
ui_command.execute(&nvim).await;
} else {
return
}
}
} }
fn main() { fn main() {
let rt = Runtime::new().unwrap();
let editor = Arc::new(Mutex::new(Editor::new(INITIAL_WIDTH, INITIAL_HEIGHT))); let editor = Arc::new(Mutex::new(Editor::new(INITIAL_WIDTH, INITIAL_HEIGHT)));
let sender = start_nvim(editor.clone()); let (sender, receiver) = channel::<UiCommand>();
let editor_clone = editor.clone();
rt.spawn(async move {
start_nvim(editor_clone, receiver).await;
});
ui_loop(editor, sender, (INITIAL_WIDTH, INITIAL_HEIGHT)); ui_loop(editor, sender, (INITIAL_WIDTH, INITIAL_HEIGHT));
} }

Loading…
Cancel
Save