feat: Add an integrated terminal.

This commit adds an integrated terminal to Helix, which can be
opened by using the :term command.

Co-authored-by: Andrey Tkachenko <[email protected]>

Author: ryanabx

Cargo.lock

@@ -4,6 +4,7 @@ members = [
   "helix-core",
   "helix-graphics",
   "helix-input",
+  "helix-terminal-view",
   "helix-view",
   "helix-term",
   "helix-tui",

Cargo.toml

@@ -678,6 +678,12 @@ impl Application {
                     return true;
                 }
             }
+            EditorEvent::TerminalEvent(event) => {
+                let needs_render = self.editor.handle_virtual_terminal_events(event).await;
+                if needs_render {
+                    self.render().await;
+                }
+            }
         }
 
         false

helix-term/src/application.rs

@@ -2,6 +2,7 @@ pub(crate) mod dap;
 pub(crate) mod lsp;
 pub(crate) mod syntax;
 pub(crate) mod typed;
+pub(crate) mod vte;
 
 pub use dap::*;
 use futures_util::FutureExt;
@@ -18,6 +19,7 @@ use tui::{
     widgets::Cell,
 };
 pub use typed::*;
+pub use vte::*;
 
 use helix_core::{
     char_idx_at_visual_offset,
@@ -615,6 +617,8 @@ impl MappableCommand {
         goto_prev_tabstop, "Goto next snippet placeholder",
         rotate_selections_first, "Make the first selection your primary one",
         rotate_selections_last, "Make the last selection your primary one",
+        toggle_terminal, "Toggle integrated terminal",
+        close_terminal, "Close active terminal",
     );
 }
 

helix-term/src/commands.rs

@@ -1402,7 +1402,7 @@ fn compute_inlay_hints_for_view(
                     };
 
                     let width = label.width();
-                    let limit = limit.get().into();
+                    let limit: usize = limit.get().into();
                     if width > limit {
                         let mut floor_boundary = 0;
                         let mut acc = 0;

helix-term/src/commands/lsp.rs

@@ -571,6 +571,20 @@ fn new_file(cx: &mut compositor::Context, _args: Args, event: PromptEvent) -> an
     Ok(())
 }
 
+fn toggle_terminal(
+    cx: &mut compositor::Context,
+    _args: Args,
+    event: PromptEvent,
+) -> anyhow::Result<()> {
+    if event != PromptEvent::Validate {
+        return Ok(());
+    }
+
+    cx.editor.terminals.toggle_terminal();
+
+    Ok(())
+}
+
 fn format(cx: &mut compositor::Context, _args: Args, event: PromptEvent) -> anyhow::Result<()> {
     if event != PromptEvent::Validate {
         return Ok(());
@@ -2912,6 +2926,17 @@ pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[
             ..Signature::DEFAULT
         },
     },
+    TypableCommand {
+        name: "term",
+        aliases: &[],
+        doc: "Toggle the integrated terminal.",
+        fun: toggle_terminal,
+        completer: CommandCompleter::none(),
+        signature: Signature {
+            positionals: (0, Some(0)),
+            ..Signature::DEFAULT
+        },
+    },
     TypableCommand {
         name: "format",
         aliases: &["fmt"],

helix-term/src/commands/typed.rs

@@ -0,0 +1,9 @@
+use super::Context;
+
+pub fn toggle_terminal(cx: &mut Context) {
+    cx.editor.terminals.toggle_terminal();
+}
+
+pub fn close_terminal(cx: &mut Context) {
+    cx.editor.terminals.toggle_terminal();
+}

helix-term/src/commands/vte.rs

@@ -41,6 +41,7 @@ pub struct EditorView {
     pseudo_pending: Vec<KeyEvent>,
     pub(crate) last_insert: (commands::MappableCommand, Vec<InsertEvent>),
     pub(crate) completion: Option<Completion>,
+    pub(crate) terminal: super::terminal::Terminal,
     spinners: ProgressSpinners,
     /// Tracks if the terminal window is focused by reaction to terminal focus events
     terminal_focused: bool,
@@ -65,6 +66,7 @@ impl EditorView {
             pseudo_pending: Vec::new(),
             last_insert: (commands::MappableCommand::normal_mode, Vec::new()),
             completion: None,
+            terminal: super::terminal::Terminal::new(),
             spinners: ProgressSpinners::default(),
             terminal_focused: true,
         }
@@ -492,7 +494,7 @@ impl EditorView {
         let cursor_scope = match mode {
             Mode::Insert => theme.find_highlight_exact("ui.cursor.insert"),
             Mode::Select => theme.find_highlight_exact("ui.cursor.select"),
-            Mode::Normal => theme.find_highlight_exact("ui.cursor.normal"),
+            _ => theme.find_highlight_exact("ui.cursor.normal"),
         }
         .unwrap_or(base_cursor_scope);
 
@@ -1360,6 +1362,10 @@ impl Component for EditorView {
         event: &Event,
         context: &mut crate::compositor::Context,
     ) -> EventResult {
+        if let Some(result) = self.terminal.handle_event(event, context) {
+            return result;
+        }
+
         let mut cx = commands::Context {
             editor: context.editor,
             count: None,
@@ -1541,9 +1547,21 @@ impl Component for EditorView {
             editor_area = editor_area.clip_top(1);
         }
 
+        let original_height = editor_area.height;
+        if cx.editor.terminals.visible {
+            editor_area = editor_area.clip_bottom(editor_area.height / 2);
+        }
+
         // if the terminal size suddenly changed, we need to trigger a resize
         cx.editor.resize(editor_area);
 
+        if cx.editor.terminals.visible {
+            let mut term_area = editor_area;
+            term_area.height = original_height - editor_area.height;
+            term_area.y += editor_area.height;
+            self.terminal.render(term_area, surface, cx);
+        }
+
         if use_bufferline {
             Self::render_bufferline(cx.editor, area.with_height(1), surface);
         }
@@ -1624,18 +1642,29 @@ impl Component for EditorView {
         }
     }
 
-    fn cursor(&self, _area: Rect, editor: &Editor) -> (Option<Position>, CursorKind) {
-        match editor.cursor() {
-            // all block cursors are drawn manually
-            (pos, CursorKind::Block) => {
-                if self.terminal_focused {
-                    (pos, CursorKind::Hidden)
-                } else {
-                    // use terminal cursor when terminal loses focus
-                    (pos, CursorKind::Underline)
+    fn cursor(&self, area: Rect, editor: &Editor) -> (Option<Position>, CursorKind) {
+        if editor.terminals.visible {
+            let mut a = area;
+            a.y += a.height / 2;
+
+            if let Some(v) = self.terminal.get_cursor(a, editor) {
+                v
+            } else {
+                (None, CursorKind::Hidden)
+            }
+        } else {
+            match editor.cursor() {
+                // all block cursors are drawn manually
+                (pos, CursorKind::Block) => {
+                    if self.terminal_focused {
+                        (pos, CursorKind::Hidden)
+                    } else {
+                        // use terminal cursor when terminal loses focus
+                        (pos, CursorKind::Underline)
+                    }
                 }
+                cursor => cursor,
             }
-            cursor => cursor,
         }
     }
 }

helix-term/src/ui/editor.rs

@@ -11,6 +11,7 @@ pub mod popup;
 pub mod prompt;
 mod spinner;
 mod statusline;
+mod terminal;
 mod text;
 mod text_decorations;
 

helix-term/src/ui/mod.rs

@@ -0,0 +1,125 @@
+use std::cell::Cell;
+
+use helix_core::Position;
+use helix_view::{
+    graphics::{CursorKind, Rect},
+    input,
+    theme::Modifier,
+    Editor,
+};
+use tui::buffer::Buffer;
+
+use crate::compositor::{Context, EventResult};
+
+pub struct Terminal {
+    size: Cell<(u16, u16)>,
+    prev_pressed: Cell<bool>,
+}
+
+impl Terminal {
+    pub fn new() -> Self {
+        Self {
+            size: Cell::new((24, 80)),
+            prev_pressed: Cell::new(false),
+        }
+    }
+
+    pub fn render(&self, area: Rect, surface: &mut Buffer, cx: &mut Context) {
+        if self.size.get() != (area.height, area.width) && area.height > 0 && area.width > 0 {
+            self.size.set((area.height, area.width));
+
+            cx.editor
+                .terminals
+                .handle_input_event(&input::Event::Resize(self.size.get().1, self.size.get().0));
+        }
+
+        if let Some((_, term)) = cx.editor.terminals.get_active() {
+            let content = term.renderable_content();
+
+            surface.clear(area);
+
+            for cell in content.display_iter {
+                if let Some(c) = surface.get_mut(
+                    area.left() + cell.point.column.0 as u16,
+                    area.top() + cell.point.line.0 as u16,
+                ) {
+                    let style = helix_view::theme::Style::reset()
+                        .bg(helix_view::terminal::color_from_ansi(cell.bg))
+                        .fg(helix_view::terminal::color_from_ansi(cell.fg))
+                        .add_modifier(Modifier::from_bits(cell.flags.bits()).unwrap());
+
+                    let style = if let Some(col) = cell.underline_color() {
+                        style.underline_color(helix_view::terminal::color_from_ansi(col))
+                    } else {
+                        style
+                    };
+
+                    c.reset();
+                    c.set_char(cell.c);
+                    c.set_style(style);
+                }
+            }
+        }
+    }
+
+    pub(crate) fn get_cursor(
+        &self,
+        area: Rect,
+        editor: &Editor,
+    ) -> Option<(Option<Position>, CursorKind)> {
+        editor.terminals.get_active().map(|(_, term)| {
+            let pt = term.grid().cursor.point;
+            (
+                Some(Position {
+                    row: area.y as usize + pt.line.0 as usize,
+                    col: area.x as usize + pt.column.0 as usize,
+                }),
+                helix_view::terminal::cursor_kind_from_ansi(term.cursor_style().shape),
+            )
+        })
+    }
+
+    pub(crate) fn handle_event(
+        &self,
+        event: &input::Event,
+        context: &mut Context,
+    ) -> Option<EventResult> {
+        if context.editor.terminals.visible {
+            match event {
+                input::Event::Key(input::KeyEvent {
+                    code: input::KeyCode::Char('\\'),
+                    ..
+                }) => {
+                    if self.prev_pressed.get() {
+                        context.editor.terminals.visible = false;
+                        Some(EventResult::Consumed(None))
+                    } else {
+                        self.prev_pressed.set(true);
+
+                        if context.editor.terminals.handle_input_event(event) {
+                            Some(EventResult::Consumed(None))
+                        } else {
+                            Some(EventResult::Ignored(None))
+                        }
+                    }
+                }
+
+                input::Event::Resize(_, _) => Some(EventResult::Ignored(None)),
+
+                event => {
+                    if let input::Event::Key(..) = &event {
+                        self.prev_pressed.set(false);
+                    }
+
+                    if context.editor.terminals.handle_input_event(event) {
+                        Some(EventResult::Consumed(None))
+                    } else {
+                        Some(EventResult::Ignored(None))
+                    }
+                }
+            }
+        } else {
+            None
+        }
+    }
+}