helix-mods/helix-term/src/application.rs

222 lines
7.2 KiB
Rust
Raw Normal View History

use clap::ArgMatches as Args;
use helix_view::{document::Mode, Document, Editor, Theme, View};
2021-03-22 04:40:07 +01:00
use crate::{compositor::Compositor, ui};
2020-12-06 03:53:58 +01:00
use log::{error, info};
use std::{
2020-10-09 22:05:57 +02:00
io::{self, stdout, Stdout, Write},
path::PathBuf,
2020-12-23 07:50:16 +01:00
sync::Arc,
time::Duration,
};
use smol::prelude::*;
2020-06-24 21:03:38 +02:00
use anyhow::Error;
2020-06-04 01:05:01 +02:00
use crossterm::{
event::{Event, EventStream},
execute, terminal,
2020-06-04 01:05:01 +02:00
};
use tui::layout::Rect;
2020-11-02 10:41:27 +01:00
2020-12-13 04:23:50 +01:00
pub struct Application {
2020-12-06 03:53:58 +01:00
compositor: Compositor,
editor: Editor,
2020-12-06 03:53:58 +01:00
2020-12-13 04:23:50 +01:00
executor: &'static smol::Executor<'static>,
}
2020-12-13 04:23:50 +01:00
impl Application {
pub fn new(mut args: Args, executor: &'static smol::Executor<'static>) -> Result<Self, Error> {
let mut compositor = Compositor::new()?;
let size = compositor.size();
let mut editor = Editor::new(executor, size);
2020-12-06 03:53:58 +01:00
let files = args.values_of_t::<PathBuf>("files").unwrap();
for file in files {
editor.open(file)?;
2020-12-06 03:53:58 +01:00
}
compositor.push(Box::new(ui::EditorView::new()));
2020-12-06 03:53:58 +01:00
let mut app = Self {
compositor,
2021-03-22 04:26:04 +01:00
editor,
2020-12-06 03:53:58 +01:00
executor,
};
Ok(app)
}
fn render(&mut self) {
2020-12-13 04:23:50 +01:00
let executor = &self.executor;
let editor = &mut self.editor;
let compositor = &mut self.compositor;
2020-12-13 04:23:50 +01:00
let mut cx = crate::compositor::Context {
editor,
executor,
scroll: None,
};
2020-12-13 04:23:50 +01:00
compositor.render(&mut cx);
2020-12-06 03:53:58 +01:00
}
pub async fn event_loop(&mut self) {
let mut reader = EventStream::new();
self.render();
loop {
2021-02-19 09:46:43 +01:00
if self.editor.should_close() {
break;
}
2020-12-06 03:53:58 +01:00
use futures_util::{select, FutureExt};
select! {
event = reader.next().fuse() => {
self.handle_terminal_events(event)
}
call = self.editor.language_servers.incoming.next().fuse() => {
2020-12-06 03:53:58 +01:00
self.handle_language_server_message(call).await
}
}
}
}
pub fn handle_terminal_events(&mut self, event: Option<Result<Event, crossterm::ErrorKind>>) {
let mut cx = crate::compositor::Context {
editor: &mut self.editor,
executor: &self.executor,
scroll: None,
};
2020-12-06 03:53:58 +01:00
// Handle key events
let should_redraw = match event {
2020-12-06 03:53:58 +01:00
Some(Ok(Event::Resize(width, height))) => {
self.compositor.resize(width, height);
2020-12-06 03:53:58 +01:00
self.compositor
.handle_event(Event::Resize(width, height), &mut cx)
2020-12-06 03:53:58 +01:00
}
Some(Ok(event)) => self.compositor.handle_event(event, &mut cx),
2021-02-09 07:40:30 +01:00
Some(Err(x)) => panic!("{}", x),
None => panic!(),
};
2021-02-19 09:46:43 +01:00
if should_redraw && !self.editor.should_close() {
self.render();
}
}
pub async fn handle_language_server_message(&mut self, call: Option<helix_lsp::Call>) {
use helix_lsp::{Call, Notification};
match call {
Some(Call::Notification(helix_lsp::jsonrpc::Notification {
method, params, ..
})) => {
let notification = Notification::parse(&method, params);
match notification {
Notification::PublishDiagnostics(params) => {
let path = Some(params.uri.to_file_path().unwrap());
2020-12-22 08:58:00 +01:00
2021-02-05 09:50:31 +01:00
let view = self
.editor
.tree
.views()
.map(|(view, _key)| view)
2021-02-21 11:47:21 +01:00
.find(|view| view.doc.path() == path.as_ref());
if let Some(view) = view {
let doc = view.doc.text();
let diagnostics = params
.diagnostics
.into_iter()
.map(|diagnostic| {
use helix_core::{
2021-03-22 04:40:07 +01:00
diagnostic::{Range, Severity, Severity::*},
Diagnostic,
};
use helix_lsp::{lsp, util::lsp_pos_to_pos};
use lsp::DiagnosticSeverity;
let start = lsp_pos_to_pos(doc, diagnostic.range.start);
let end = lsp_pos_to_pos(doc, diagnostic.range.end);
Diagnostic {
range: Range { start, end },
line: diagnostic.range.start.line as usize,
message: diagnostic.message,
severity: diagnostic.severity.map(
|severity| match severity {
DiagnosticSeverity::Error => Error,
DiagnosticSeverity::Warning => Warning,
DiagnosticSeverity::Information => Info,
DiagnosticSeverity::Hint => Hint,
},
),
// code
// source
}
})
.collect();
view.doc.diagnostics = diagnostics;
// TODO: we want to process all the events in queue, then render. publishDiagnostic tends to send a whole bunch of events
self.render();
}
}
_ => unreachable!(),
}
}
Some(Call::MethodCall(call)) => {
error!("Method not found {}", call.method);
2020-11-05 07:15:19 +01:00
// self.language_server.reply(
// call.id,
// // TODO: make a Into trait that can cast to Err(jsonrpc::Error)
// Err(helix_lsp::jsonrpc::Error {
// code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound,
// message: "Method not found".to_string(),
// data: None,
// }),
// );
}
None => (),
2020-12-25 09:42:50 +01:00
e => unreachable!("{:?}", e),
}
}
pub async fn run(&mut self) -> Result<(), Error> {
terminal::enable_raw_mode()?;
2020-06-04 01:05:01 +02:00
let mut stdout = stdout();
2020-06-05 12:21:27 +02:00
execute!(stdout, terminal::EnterAlternateScreen)?;
2020-09-19 04:57:22 +02:00
// Exit the alternate screen and disable raw mode before panicking
let hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
execute!(std::io::stdout(), terminal::LeaveAlternateScreen);
terminal::disable_raw_mode();
2020-09-19 04:57:22 +02:00
hook(info);
}));
self.event_loop().await;
2020-06-05 12:21:27 +02:00
2020-09-05 15:01:05 +02:00
// reset cursor shape
write!(stdout, "\x1B[2 q");
2020-06-07 14:11:08 +02:00
execute!(stdout, terminal::LeaveAlternateScreen)?;
terminal::disable_raw_mode()?;
Ok(())
2020-06-01 10:42:28 +02:00
}
}