+ commands,

+ compositor::{Component, Context, EventResult},

+ keymap::{KeymapResult, KeymapResultKind, Keymaps},

+ ui::{Completion, ProgressSpinners},

+ coords_at_pos, encoding,

+ graphemes::{

+ ensure_grapheme_boundary_next_byte, next_grapheme_boundary, prev_grapheme_boundary,

+ },

+ syntax::{self, HighlightEvent},

+ unicode::segmentation::UnicodeSegmentation,

+ LineEnding, Position, Range, Selection, Transaction,

+ graphics::{CursorKind, Modifier, Rect, Style},

+ input::KeyEvent,

+use std::borrow::Cow;

+use crossterm::event::{Event, MouseButton, MouseEvent, MouseEventKind};

+use tui::buffer::{Buffer as Surface, SurfaceExt};

+ on_next_key: Option<Box<dyn FnOnce(&mut commands::Context, KeyEvent)>>,

+ last_insert: (commands::MappableCommand, Vec<InsertEvent>),

+ CompletionApply(CompleteAction),

+}

+

+impl Default for EditorView {

+ fn default() -> Self {

+ Self::new(Keymaps::default())

+ }

+ let inner = view.inner_area();

+ // DAP: Highlight current stack frame position

+ let stack_frame = editor.debugger.as_ref().and_then(|debugger| {

+ if let (Some(frame), Some(thread_id)) = (debugger.active_frame, debugger.thread_id) {

+ debugger

+ .stack_frames

+ .get(&thread_id)

+ .and_then(|bt| bt.get(frame))

+ } else {

+ None

+ });

+ if let Some(frame) = stack_frame {

+ if doc.path().is_some()

+ && frame

+ .source

+ .as_ref()

+ .and_then(|source| source.path.as_ref())

+ == doc.path()

+ {

+ let line = frame.line - 1; // convert to 0-indexing

+ if line >= view.offset.row && line < view.offset.row + area.height as usize {

+ surface.set_style(

+ Rect::new(

+ area.x,

+ area.y + (line - view.offset.row) as u16,

+ area.width,

+ 1,

+ ),

+ theme.get("ui.highlight"),

+ );

+ }

+ let highlights = Self::doc_syntax_highlights(doc, view.offset, inner.height, theme);

+ let highlights = syntax::merge(highlights, Self::doc_diagnostics_highlights(doc, theme));

+ let highlights: Box<dyn Iterator<Item = HighlightEvent>> = if is_focused {

+ Box::new(syntax::merge(

+ highlights,

+ Self::doc_selection_highlights(doc, view, theme, &editor.config.cursor_shape),

+ ))

+ } else {

+ Box::new(highlights)

+ };

+ Self::render_text_highlights(doc, view.offset, inner, surface, theme, highlights);

+ Self::render_gutter(editor, doc, view, view.area, surface, theme, is_focused);

+ Self::render_focused_view_elements(view, doc, inner, theme, surface);

+ surface

+ .get_mut(x, y)

+ self.render_diagnostics(doc, view, inner, surface, theme);

+ self.render_statusline(doc, view, statusline_area, surface, theme, is_focused);

+ /// Get syntax highlights for a document in a view represented by the first line

+ pub fn doc_syntax_highlights<'doc>(

+ doc: &'doc Document,

+ offset: Position,

+ _theme: &Theme,

+ ) -> Box<dyn Iterator<Item = HighlightEvent> + 'doc> {

+ let last_line = std::cmp::min(

+ // Saturating subs to make it inclusive zero indexing.

+ (offset.row + height as usize).saturating_sub(1),

+ doc.text().len_lines().saturating_sub(1),

+ );

+ let range = {

+ // calculate viewport byte ranges

+ let start = text.line_to_byte(offset.row);

+ let end = text.line_to_byte(last_line + 1);

+ start..end

+ };

+ match doc.syntax() {

+ Some(syntax) => {

+ let iter = syntax

+ // TODO: range doesn't actually restrict source, just highlight range

+ .highlight_iter(text.slice(..), Some(range), None)

+ .map(|event| event.unwrap())

+ .map(move |event| match event {

+ // convert byte offsets to char offset

+ HighlightEvent::Source { start, end } => {

+ let start =

+ text.byte_to_char(ensure_grapheme_boundary_next_byte(text, start));

+ let end =

+ text.byte_to_char(ensure_grapheme_boundary_next_byte(text, end));

+ HighlightEvent::Source { start, end }

+ }

+ event => event,

+ });

+ Box::new(iter)

+ }

+ None => Box::new(

+ [HighlightEvent::Source {

+ start: text.byte_to_char(range.start),

+ end: text.byte_to_char(range.end),

+ }]

+ .into_iter(),

+ ),

+ }

+ pub fn doc_diagnostics_highlights(

+ ) -> Vec<(usize, std::ops::Range<usize>)> {

+ let diagnostic_scope = theme

+ .find_scope_index("diagnostic")

+ .or_else(|| theme.find_scope_index("ui.cursor"))

+ .or_else(|| theme.find_scope_index("ui.selection"))

+ .expect(

+ "at least one of the following scopes must be defined in the theme: `diagnostic`, `ui.cursor`, or `ui.selection`",

+ );

+ doc.diagnostics()

+ .iter()

+ .map(|diagnostic| {

+ (

+ diagnostic_scope,

+ diagnostic.range.start..diagnostic.range.end,

+ })

+ .collect()

+ ) -> Vec<(usize, std::ops::Range<usize>)> {

+ let mode = doc.mode();

+ .find_scope_index("ui.selection")

+ .find_scope_index("ui.cursor")

+ Mode::Insert => theme.find_scope_index("ui.cursor.insert"),

+ Mode::Select => theme.find_scope_index("ui.cursor.select"),

+ Mode::Normal => Some(base_cursor_scope),

+ let primary_cursor_scope = theme

+ .find_scope_index("ui.cursor.primary")

+ .unwrap_or(cursor_scope);

+ let primary_selection_scope = theme

+ .find_scope_index("ui.selection.primary")

+ .unwrap_or(selection_scope);

+ let mut spans: Vec<(usize, std::ops::Range<usize>)> = Vec::new();

+ if !selection_is_primary || cursor_is_block {

+ spans.push((selection_scope, range.anchor..cursor_start));

+ if !selection_is_primary || cursor_is_block {

+ if !selection_is_primary || cursor_is_block {

+ spans.push((selection_scope, cursor_end..range.anchor));

+ spans

+ pub fn render_text_highlights<H: Iterator<Item = HighlightEvent>>(

+ offset: Position,

+ viewport: Rect,

+ surface: &mut Surface,

+ highlights: H,

+ ) {

+ let mut spans = Vec::new();

+ let mut visual_x = 0u16;

+ let mut line = 0u16;

+ let tab_width = doc.tab_width();

+ let tab = " ".repeat(tab_width);

+ let text_style = theme.get("ui.text");

+ // It's slightly more efficient to produce a full RopeSlice from the Rope, then slice that a bunch

+ // of times than it is to always call Rope::slice/get_slice (it will internally always hit RSEnum::Light).

+ let text = text.slice(..);

+ 'outer: for event in highlights {

+ match event {

+ HighlightEvent::HighlightStart(span) => {

+ spans.push(span);

+ }

+ HighlightEvent::HighlightEnd => {

+ spans.pop();

+ }

+ HighlightEvent::Source { start, end } => {

+ // `unwrap_or_else` part is for off-the-end indices of

+ // the rope, to allow cursor highlighting at the end

+ // of the rope.

+ let text = text.get_slice(start..end).unwrap_or_else(|| " ".into());

+

+ use helix_core::graphemes::{grapheme_width, RopeGraphemes};

+

+ for grapheme in RopeGraphemes::new(text) {

+ let out_of_bounds = visual_x < offset.col as u16

+ || visual_x >= viewport.width + offset.col as u16;

+

+ if LineEnding::from_rope_slice(&grapheme).is_some() {

+ if !out_of_bounds {

+ let style = spans.iter().fold(text_style, |acc, span| {

+ acc.patch(theme.highlight(span.0))

+ });

+

+ // we still want to render an empty cell with the style

+ surface.set_string(

+ viewport.x + visual_x - offset.col as u16,

+ viewport.y + line,

+ " ",

+ style,

+ );

+ }

+

+ visual_x = 0;

+ line += 1;

+ // TODO: with proper iter this shouldn't be necessary

+ if line >= viewport.height {

+ break 'outer;

+ }

+ } else {

+ let grapheme = Cow::from(grapheme);

+

+ let (grapheme, width) = if grapheme == "\t" {

+ // make sure we display tab as appropriate amount of spaces

+ let visual_tab_width = tab_width - (visual_x as usize % tab_width);

+ (&tab[..visual_tab_width], visual_tab_width)

+ } else {

+ // Cow will prevent allocations if span contained in a single slice

+ // which should really be the majority case

+ let width = grapheme_width(&grapheme);

+ (grapheme.as_ref(), width)

+ };

+ if !out_of_bounds {

+ let style = spans.iter().fold(text_style, |acc, span| {

+ acc.patch(theme.highlight(span.0))

+ });

+

+ // if we're offscreen just keep going until we hit a new line

+ surface.set_string(

+ viewport.x + visual_x - offset.col as u16,

+ viewport.y + line,

+ grapheme,

+ style,

+ );

+ }

+

+ visual_x = visual_x.saturating_add(width as u16);

+ }

+ }

+ }

+ /// Render brace match, etc (meant for the focused view only)

+ pub fn render_focused_view_elements(

+ doc: &Document,

+ surface: &mut Surface,

+ ) {

+ // Highlight matching braces

+ if let Some(syntax) = doc.syntax() {

+ let text = doc.text().slice(..);

+ use helix_core::match_brackets;

+ let pos = doc.selection(view.id).primary().cursor(text);

+

+ let pos = match_brackets::find_matching_bracket(syntax, doc.text(), pos)

+ .and_then(|pos| view.screen_coords_at_pos(doc, text, pos));

+

+ if let Some(pos) = pos {

+ // ensure col is on screen

+ if (pos.col as u16) < viewport.width + view.offset.col as u16

+ && pos.col >= view.offset.col

+ {

+ let style = theme.try_get("ui.cursor.match").unwrap_or_else(|| {

+ Style::default()

+ .add_modifier(Modifier::REVERSED)

+ .add_modifier(Modifier::DIM)

+ });

+

+ surface

+ .get_mut(viewport.x + pos.col as u16, viewport.y + pos.row as u16)

+ .set_style(style);

+ }

+ }

+ }

+ }

+

+ pub fn render_gutter(

+ editor: &Editor,

+ doc: &Document,

+ view: &View,

+ viewport: Rect,

+ surface: &mut Surface,

+ theme: &Theme,

+ let last_line = view.last_line(doc);

+

+ // it's used inside an iterator so the collect isn't needless:

+ // https://github.com/rust-lang/rust-clippy/issues/6164

+ #[allow(clippy::needless_collect)]

+ let cursors: Vec<_> = doc

+ // avoid lots of small allocations by reusing a text buffer for each line

+ let mut text = String::with_capacity(8);

+

+ for (constructor, width) in view.gutters() {

+ let gutter = constructor(editor, doc, view, theme, is_focused, *width);

+ text.reserve(*width); // ensure there's enough space for the gutter

+ for (i, line) in (view.offset.row..(last_line + 1)).enumerate() {

+ let selected = cursors.contains(&line);

+

+ if let Some(style) = gutter(line, selected, &mut text) {

+ surface.set_stringn(

+ viewport.x + offset,

+ viewport.y + i as u16,

+ &text,

+ *width,

+ gutter_style.patch(style),

+ }

+ offset += *width as u16;

+ &self,

+ let text = Text::styled(

+ &diagnostic.message,

+ match diagnostic.severity {

+ },

+ );

+ let paragraph = Paragraph::new(lines)

+ pub fn render_statusline(

+ &self,

+ viewport: Rect,

+ is_focused: bool,

+ use tui::text::{Span, Spans};

+ //-------------------------------

+ // Left side of the status line.

+ //-------------------------------

+ let mode = match doc.mode() {

+ Mode::Insert => "INS",

+ Mode::Select => "SEL",

+ Mode::Normal => "NOR",

+ };

+ let progress = doc

+ .language_server()

+ .and_then(|srv| {

+ self.spinners

+ .get(srv.id())

+ .and_then(|spinner| spinner.frame())

+ })

+ .unwrap_or("");

+ let base_style = if is_focused {

+ theme.get("ui.statusline")

+ } else {

+ theme.get("ui.statusline.inactive")

+ };

+ // statusline

+ surface.set_style(viewport.with_height(1), base_style);

+ if is_focused {

+ surface.set_string(viewport.x + 1, viewport.y, mode, base_style);

+ }

+ surface.set_string(viewport.x + 5, viewport.y, progress, base_style);

+

+ //-------------------------------

+ // Right side of the status line.

+ //-------------------------------

+

+ let mut right_side_text = Spans::default();

+

+ // Compute the individual info strings and add them to `right_side_text`.

+

+ // Diagnostics

+ let diags = doc.diagnostics().iter().fold((0, 0), |mut counts, diag| {

+ use helix_core::diagnostic::Severity;

+ match diag.severity {

+ Some(Severity::Warning) => counts.0 += 1,

+ Some(Severity::Error) | None => counts.1 += 1,

+ _ => {}

+ }

+ counts

+ });

+ let (warnings, errors) = diags;

+ let warning_style = theme.get("warning");

+ let error_style = theme.get("error");

+ for i in 0..2 {

+ let (count, style) = match i {

+ 0 => (warnings, warning_style),

+ 1 => (errors, error_style),

+ _ => unreachable!(),

+ };

+ if count == 0 {

+ continue;

+ let style = base_style.patch(style);

+ right_side_text.0.push(Span::styled("●", style));

+ right_side_text

+ .0

+ .push(Span::styled(format!(" {} ", count), base_style));

+

+ // Selections

+ let sels_count = doc.selection(view.id).len();

+ right_side_text.0.push(Span::styled(

+ format!(

+ " {} sel{} ",

+ sels_count,

+ if sels_count == 1 { "" } else { "s" }

+ ),

+ base_style,

+ ));

+

+ // Position

+ let pos = coords_at_pos(

+ doc.text().slice(..),

+ doc.selection(view.id)

+ .primary()

+ .cursor(doc.text().slice(..)),

+ );

+ right_side_text.0.push(Span::styled(

+ format!(" {}:{} ", pos.row + 1, pos.col + 1), // Convert to 1-indexing.

+ base_style,

+ ));

+

+ let enc = doc.encoding();

+ if enc != encoding::UTF_8 {

+ right_side_text

+ .0

+ .push(Span::styled(format!(" {} ", enc.name()), base_style));

+ }

+

+ // Render to the statusline.

+ surface.set_spans(

+ viewport.x

+ + viewport

+ .width

+ .saturating_sub(right_side_text.width() as u16),

+ viewport.y,

+ &right_side_text,

+ right_side_text.width() as u16,

+ );

+

+ //-------------------------------

+ // Middle / File path / Title

+ //-------------------------------

+ let title = {

+ let rel_path = doc.relative_path();

+ let path = rel_path

+ .as_ref()

+ .map(|p| p.to_string_lossy())

+ .unwrap_or_else(|| SCRATCH_BUFFER_NAME.into());

+ format!("{}{}", path, if doc.is_modified() { "[+]" } else { "" })

+ };

+

+ surface.set_string_truncated(

+ viewport.x + 8, // 8: 1 space + 3 char mode string + 1 space + 1 spinner + 1 space

+ viewport.y,

+ &title,

+ viewport

+ .width

+ .saturating_sub(6)

+ .saturating_sub(right_side_text.width() as u16 + 1) as usize, // "+ 1": a space between the title and the selection info

+ |_| base_style,

+ true,

+ true,

+ );

+ /// activated). Only KeymapResultKind::{NotFound, Cancelled} is returned

+ cxt.editor.autoinfo = None;

+ let key_result = self.keymaps.get_mut(&mode).unwrap().get(event);

+ cxt.editor.autoinfo = key_result.sticky.map(|node| node.infobox());

+

+ match &key_result.kind {

+ KeymapResultKind::Matched(command) => command.execute(cxt),

+ KeymapResultKind::Pending(node) => cxt.editor.autoinfo = Some(node.infobox()),

+ KeymapResultKind::MatchedSequence(commands) => {

+ command.execute(cxt);

+ KeymapResultKind::NotFound | KeymapResultKind::Cancelled(_) => return Some(key_result),

+ match keyresult.kind {

+ KeymapResultKind::NotFound => {

+ if let Some(ch) = event.char() {

+ commands::insert::insert_char(cx, ch)

+ KeymapResultKind::Cancelled(pending) => {

+ if let KeymapResultKind::Matched(command) =

+ self.keymaps.get_mut(&Mode::Insert).unwrap().get(ev).kind

+ match event {

+ // count handling

+ key!(i @ '0'..='9') => {

+ cxt.editor.count =

+ std::num::NonZeroUsize::new(cxt.editor.count.map_or(i, |c| c.get() * 10 + i));

+ key!('.') if self.keymaps.pending().is_empty() => {

+ // first execute whatever put us into insert mode

+ self.last_insert.0.execute(cxt);

+ // then replay the inputs

+ for key in self.last_insert.1.clone() {

+ match key {

+ InsertEvent::Key(key) => self.insert_mode(cxt, key),

+ InsertEvent::CompletionApply(compl) => {

+ let (view, doc) = current!(cxt.editor);

+

+ doc.restore(view.id);

+

+ let text = doc.text().slice(..);

+ let cursor = doc.selection(view.id).primary().cursor(text);

+

+ let shift_position =

+ |pos: usize| -> usize { pos + cursor - compl.trigger_offset };

+

+ let tx = Transaction::change(

+ doc.text(),

+ compl.changes.iter().cloned().map(|(start, end, t)| {

+ (shift_position(start), shift_position(end), t)

+ }),

+ );

+ doc.apply(&tx, view.id);

+ }

+ InsertEvent::TriggerCompletion => {

+ let (_, doc) = current!(cxt.editor);

+ doc.savepoint();

+ self.handle_keymap_event(mode, cxt, event);

+ items: Vec<helix_lsp::lsp::CompletionItem>,

+ offset_encoding: helix_lsp::OffsetEncoding,

+ start_offset: usize,

+ ) {

+ let mut completion =

+ Completion::new(editor, items, offset_encoding, start_offset, trigger_offset);

+ return;

+ // Immediately initialize a savepoint

+ doc_mut!(editor).savepoint();

+

+ editor.last_completion = None;

+ completion.required_size((size.width, size.height));

+ pub fn clear_completion(&mut self, editor: &mut Editor) {

+

+ // Clear any savepoints

+ let doc = doc_mut!(editor);

+ doc.savepoint = None;

+ editor.clear_idle_timer(); // don't retrigger

+ pub fn handle_idle_timeout(&mut self, cx: &mut crate::compositor::Context) -> EventResult {

+ if self.completion.is_some()

+ || !cx.editor.config.auto_completion

+ || doc!(cx.editor).mode != Mode::Insert

+ {

+ return EventResult::Ignored(None);

+ }

+

+ let mut cx = commands::Context {

+ register: None,

+ editor: cx.editor,

+ jobs: cx.jobs,

+ count: None,

+ callback: None,

+ on_next_key_callback: None,

+ };

+ crate::commands::insert::idle_completion(&mut cx);

+ EventResult::Consumed(None)

+ event: MouseEvent,

+ match event {

+ MouseEvent {

+ kind: MouseEventKind::Down(MouseButton::Left),

+ row,

+ column,

+ modifiers,

+ ..

+ } => {

+ let result = editor.tree.views().find_map(|(view, _focus)| {

+ view.pos_at_screen_coords(&editor.documents[&view.doc], row, column)

+ .map(|pos| (pos, view.id))

+ });

+ if let Some((pos, view_id)) = result {

+ let doc = editor.document_mut(editor.tree.get(view_id).doc).unwrap();

+ if modifiers == crossterm::event::KeyModifiers::ALT {

+ editor.tree.focus = view_id;

+ let result = editor.tree.views().find_map(|(view, _focus)| {

+ view.gutter_coords_at_screen_coords(row, column)

+ .map(|coords| (coords, view.id))

+ });

+

+ if let Some((coords, view_id)) = result {

+ editor.tree.focus = view_id;

+ let view = editor.tree.get(view_id);

+ let doc = editor.documents.get_mut(&view.doc).unwrap();

+ let line = coords.row + view.offset.row;

+ if line < doc.text().len_lines() {

+ MouseEvent {

+ kind: MouseEventKind::Drag(MouseButton::Left),

+ row,

+ column,

+ ..

+ } => {

+ let pos = match view.pos_at_screen_coords(doc, row, column) {

+ *primary = Range::new(primary.anchor, pos);

+ MouseEvent {

+ kind: MouseEventKind::ScrollUp | MouseEventKind::ScrollDown,

+ row,

+ column,

+ ..

+ } => {

+ let result = cxt.editor.tree.views().find_map(|(view, _focus)| {

+ view.pos_at_screen_coords(&cxt.editor.documents[&view.doc], row, column)

+ .map(|_| view.id)

+ });

+

+ match result {

+ Some(view_id) => cxt.editor.tree.focus = view_id,

+ let offset = cxt.editor.config.scroll_lines.abs() as usize;

+ commands::scroll(cxt, offset, direction);

+ MouseEvent {

+ kind: MouseEventKind::Up(MouseButton::Left),

+ ..

+ } => {

+ if !cxt.editor.config.middle_click_paste {

+ let range = doc.selection(view.id).primary();

+ if range.to() - range.from() <= 1 {

+ return EventResult::Ignored(None);

+

+ commands::MappableCommand::yank_main_selection_to_primary_clipboard.execute(cxt);

+

+ EventResult::Consumed(None)

+ MouseEvent {

+ kind: MouseEventKind::Up(MouseButton::Right),

+ row,

+ column,

+ modifiers,

+ ..

+ } => {

+ let result = cxt.editor.tree.views().find_map(|(view, _focus)| {

+ view.gutter_coords_at_screen_coords(row, column)

+ .map(|coords| (coords, view.id))

+ });

+ if let Some((coords, view_id)) = result {

+ cxt.editor.tree.focus = view_id;

+ let view = cxt.editor.tree.get(view_id);

+ let doc = cxt.editor.documents.get_mut(&view.doc).unwrap();

+ let line = coords.row + view.offset.row;

+ if let Ok(pos) = doc.text().try_line_to_char(line) {

+ doc.set_selection(view_id, Selection::point(pos));

+ if modifiers == crossterm::event::KeyModifiers::ALT {

+ commands::MappableCommand::dap_edit_log.execute(cxt);

+ } else {

+ commands::MappableCommand::dap_edit_condition.execute(cxt);

+ return EventResult::Consumed(None);

+ }

+ MouseEvent {

+ kind: MouseEventKind::Up(MouseButton::Middle),

+ row,

+ column,

+ modifiers,

+ ..

+ } => {

+ if !editor.config.middle_click_paste {

+ if modifiers == crossterm::event::KeyModifiers::ALT {

+ let result = editor.tree.views().find_map(|(view, _focus)| {

+ view.pos_at_screen_coords(&editor.documents[&view.doc], row, column)

+ .map(|pos| (pos, view.id))

+ });

+

+ if let Some((pos, view_id)) = result {

+ let doc = editor.document_mut(editor.tree.get(view_id).doc).unwrap();

+ editor.tree.focus = view_id;

+ event: Event,

+ callback: None,

+ Event::Key(key) => {

+ let mut key = KeyEvent::from(key);

+ let doc = doc!(cx.editor);

+ let mode = doc.mode();

+ if let Some(on_next_key) = self.on_next_key.take() {

+ // if there's a command waiting input, do that first

+ on_next_key(&mut cx, key);

+ } else {

+ // use a fake context here

+ let mut cx = Context {

+ editor: cx.editor,

+ jobs: cx.jobs,

+ scroll: None,

+ let res = completion.handle_event(event, &mut cx);

+

+ if let EventResult::Consumed(callback) = res {

+ consumed = true;

+ self.clear_completion(cx.editor);

+ if let Some(compl) = cx.editor.last_completion.take() {

+ self.last_insert.1.push(InsertEvent::CompletionApply(compl));

+ }

+

+

+ // lastly we recalculate completion

+ if let Some(completion) = &mut self.completion {

+ completion.update(&mut cx);

+ if completion.is_empty() {

+ self.clear_completion(cx.editor);

+ }

+ }

+ let callback = cx.callback.take();

+ view.ensure_cursor_in_view(doc, cx.editor.config.scrolloff);

+ // commiting changes when leaving insert mode.

+ if doc.mode() != Mode::Insert {

+ doc.append_changes_to_history(view.id);

+ // mode transitions

+ match (mode, doc.mode()) {

+ (Mode::Normal, Mode::Insert) => {

+ // HAXX: if we just entered insert mode from normal, clear key buf

+ // and record the command that got us into this mode.

+ // how we entered insert mode is important, and we should track that so

+ // we can repeat the side effect.

+

+ self.last_insert.0 =

+ match self.keymaps.get_mut(&mode).unwrap().get(key).kind {

+ KeymapResultKind::Matched(command) => command,

+ // FIXME: insert mode can only be entered through single KeyCodes

+ _ => unimplemented!(),

+ };

+ self.last_insert.1.clear();

+ }

+ (Mode::Insert, Mode::Normal) => {

+ // if exiting insert mode, remove completion

+ self.completion = None;

+ _ => (),

+

+ EventResult::Consumed(callback)

+

+ Event::Mouse(event) => self.handle_mouse_event(event, &mut cx),

+ let bg = cx.editor.theme.get("ui.background");

+ surface.add_change(termwiz::surface::Change::ClearScreen(

+ bg.bg.expect("no bg color set!").into(),

+ ));

+ cx.editor.resize(area.clip_bottom(1)); // -1 from bottom for commandline

+ if cx.editor.config.auto_info {

+ let s = key.to_string();

+ if s.graphemes(true).count() > 1 {

+ disp.push_str(&format!("<{}>", s));

+ } else {

+ disp.push_str(&s);

+ }

+ if let Some(pseudo_pending) = &cx.editor.pseudo_pending {

+ disp.push_str(pseudo_pending.as_str())

+ // All block cursors are drawn manually

+ (pos, CursorKind::Block) => (pos, CursorKind::Hidden),