Add infobox

5 files changed, 176 insertions, 44 deletions

diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml
index cb2032de..b6816d71 100644
--- a/helix-view/Cargo.toml
+++ b/helix-view/Cargo.toml
@@ -31,6 +31,7 @@ slotmap = "1"
 
 encoding_rs = "0.8"
 chardetng = "0.1"
+unicode-width = "0.1"
 
 serde = { version = "1.0", features = ["derive"] }
 toml = "0.5"
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
index a16cc50f..b006a124 100644
--- a/helix-view/src/editor.rs
+++ b/helix-view/src/editor.rs
@@ -1,6 +1,7 @@
 use crate::{
     clipboard::{get_clipboard_provider, ClipboardProvider},
     graphics::{CursorKind, Rect},
+    info::Info,
     theme::{self, Theme},
     tree::Tree,
     Document, DocumentId, RegisterSelection, View, ViewId,
@@ -32,6 +33,7 @@ pub struct Editor {
     pub syn_loader: Arc<syntax::Loader>,
     pub theme_loader: Arc<theme::Loader>,
 
+    pub autoinfo: Option<Info>,
     pub status_msg: Option<(String, Severity)>,
 }
 
@@ -64,6 +66,7 @@ impl Editor {
             theme_loader: themes,
             registers: Registers::default(),
             clipboard_provider: get_clipboard_provider(),
+            autoinfo: None,
             status_msg: None,
         }
     }
diff --git a/helix-view/src/info.rs b/helix-view/src/info.rs
new file mode 100644
index 00000000..eef8d3a1
--- /dev/null
+++ b/helix-view/src/info.rs
@@ -0,0 +1,51 @@
+use crate::input::KeyEvent;
+use std::fmt::Write;
+use unicode_width::UnicodeWidthStr;
+
+#[derive(Debug)]
+/// Info box used in editor. Rendering logic will be in other crate.
+pub struct Info {
+    /// Title kept as static str for now.
+    pub title: &'static str,
+    /// Text body, should contains newline.
+    pub text: String,
+    /// Body width.
+    pub width: u16,
+    /// Body height.
+    pub height: u16,
+}
+
+impl Info {
+    pub fn key(title: &'static str, body: Vec<(Vec<KeyEvent>, &'static str)>) -> Info {
+        let keymaps_width: u16 = body
+            .iter()
+            .map(|r| r.0.iter().map(|e| e.width() as u16 + 2).sum::<u16>() - 2)
+            .max()
+            .unwrap();
+        let mut text = String::new();
+        let mut width = 0;
+        let height = body.len() as u16;
+        for (mut keyevents, desc) in body {
+            let keyevent = keyevents.remove(0);
+            let mut left = keymaps_width - keyevent.width() as u16;
+            write!(text, "{}", keyevent).ok();
+            for keyevent in keyevents {
+                write!(text, ", {}", keyevent).ok();
+                left -= 2 + keyevent.width() as u16;
+            }
+            for _ in 0..left {
+                text.push(' ');
+            }
+            if keymaps_width + 2 + (desc.width() as u16) > width {
+                width = keymaps_width + 2 + desc.width() as u16;
+            }
+            writeln!(text, "  {}", &desc).ok();
+        }
+        Info {
+            title,
+            text,
+            width,
+            height,
+        }
+    }
+}
diff --git a/helix-view/src/input.rs b/helix-view/src/input.rs
index 5f61ce14..6e8292e9 100644
--- a/helix-view/src/input.rs
+++ b/helix-view/src/input.rs
@@ -13,6 +13,32 @@ pub struct KeyEvent {
     pub modifiers: KeyModifiers,
 }
 
+pub(crate) mod keys {
+    pub(crate) const BACKSPACE: &str = "backspace";
+    pub(crate) const ENTER: &str = "ret";
+    pub(crate) const LEFT: &str = "left";
+    pub(crate) const RIGHT: &str = "right";
+    pub(crate) const UP: &str = "up";
+    pub(crate) const DOWN: &str = "down";
+    pub(crate) const HOME: &str = "home";
+    pub(crate) const END: &str = "end";
+    pub(crate) const PAGEUP: &str = "pageup";
+    pub(crate) const PAGEDOWN: &str = "pagedown";
+    pub(crate) const TAB: &str = "tab";
+    pub(crate) const BACKTAB: &str = "backtab";
+    pub(crate) const DELETE: &str = "del";
+    pub(crate) const INSERT: &str = "ins";
+    pub(crate) const NULL: &str = "null";
+    pub(crate) const ESC: &str = "esc";
+    pub(crate) const SPACE: &str = "space";
+    pub(crate) const LESS_THAN: &str = "lt";
+    pub(crate) const GREATER_THAN: &str = "gt";
+    pub(crate) const PLUS: &str = "plus";
+    pub(crate) const MINUS: &str = "minus";
+    pub(crate) const SEMICOLON: &str = "semicolon";
+    pub(crate) const PERCENT: &str = "percent";
+}
+
 impl fmt::Display for KeyEvent {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_fmt(format_args!(
@@ -34,28 +60,29 @@ impl fmt::Display for KeyEvent {
             },
         ))?;
         match self.code {
-            KeyCode::Backspace => f.write_str("backspace")?,
-            KeyCode::Enter => f.write_str("ret")?,
-            KeyCode::Left => f.write_str("left")?,
-            KeyCode::Right => f.write_str("right")?,
-            KeyCode::Up => f.write_str("up")?,
-            KeyCode::Down => f.write_str("down")?,
-            KeyCode::Home => f.write_str("home")?,
-            KeyCode::End => f.write_str("end")?,
-            KeyCode::PageUp => f.write_str("pageup")?,
-            KeyCode::PageDown => f.write_str("pagedown")?,
-            KeyCode::Tab => f.write_str("tab")?,
-            KeyCode::BackTab => f.write_str("backtab")?,
-            KeyCode::Delete => f.write_str("del")?,
-            KeyCode::Insert => f.write_str("ins")?,
-            KeyCode::Null => f.write_str("null")?,
-            KeyCode::Esc => f.write_str("esc")?,
-            KeyCode::Char('<') => f.write_str("lt")?,
-            KeyCode::Char('>') => f.write_str("gt")?,
-            KeyCode::Char('+') => f.write_str("plus")?,
-            KeyCode::Char('-') => f.write_str("minus")?,
-            KeyCode::Char(';') => f.write_str("semicolon")?,
-            KeyCode::Char('%') => f.write_str("percent")?,
+            KeyCode::Backspace => f.write_str(keys::BACKSPACE)?,
+            KeyCode::Enter => f.write_str(keys::ENTER)?,
+            KeyCode::Left => f.write_str(keys::LEFT)?,
+            KeyCode::Right => f.write_str(keys::RIGHT)?,
+            KeyCode::Up => f.write_str(keys::UP)?,
+            KeyCode::Down => f.write_str(keys::DOWN)?,
+            KeyCode::Home => f.write_str(keys::HOME)?,
+            KeyCode::End => f.write_str(keys::END)?,
+            KeyCode::PageUp => f.write_str(keys::PAGEUP)?,
+            KeyCode::PageDown => f.write_str(keys::PAGEDOWN)?,
+            KeyCode::Tab => f.write_str(keys::TAB)?,
+            KeyCode::BackTab => f.write_str(keys::BACKTAB)?,
+            KeyCode::Delete => f.write_str(keys::DELETE)?,
+            KeyCode::Insert => f.write_str(keys::INSERT)?,
+            KeyCode::Null => f.write_str(keys::NULL)?,
+            KeyCode::Esc => f.write_str(keys::ESC)?,
+            KeyCode::Char(' ') => f.write_str(keys::SPACE)?,
+            KeyCode::Char('<') => f.write_str(keys::LESS_THAN)?,
+            KeyCode::Char('>') => f.write_str(keys::GREATER_THAN)?,
+            KeyCode::Char('+') => f.write_str(keys::PLUS)?,
+            KeyCode::Char('-') => f.write_str(keys::MINUS)?,
+            KeyCode::Char(';') => f.write_str(keys::SEMICOLON)?,
+            KeyCode::Char('%') => f.write_str(keys::PERCENT)?,
             KeyCode::F(i) => f.write_fmt(format_args!("F{}", i))?,
             KeyCode::Char(c) => f.write_fmt(format_args!("{}", c))?,
         };
@@ -63,34 +90,83 @@ impl fmt::Display for KeyEvent {
     }
 }
 
+impl unicode_width::UnicodeWidthStr for KeyEvent {
+    fn width(&self) -> usize {
+        use unicode_width::UnicodeWidthChar;
+        let mut width = match self.code {
+            KeyCode::Backspace => keys::BACKSPACE.len(),
+            KeyCode::Enter => keys::ENTER.len(),
+            KeyCode::Left => keys::LEFT.len(),
+            KeyCode::Right => keys::RIGHT.len(),
+            KeyCode::Up => keys::UP.len(),
+            KeyCode::Down => keys::DOWN.len(),
+            KeyCode::Home => keys::HOME.len(),
+            KeyCode::End => keys::END.len(),
+            KeyCode::PageUp => keys::PAGEUP.len(),
+            KeyCode::PageDown => keys::PAGEDOWN.len(),
+            KeyCode::Tab => keys::TAB.len(),
+            KeyCode::BackTab => keys::BACKTAB.len(),
+            KeyCode::Delete => keys::DELETE.len(),
+            KeyCode::Insert => keys::INSERT.len(),
+            KeyCode::Null => keys::NULL.len(),
+            KeyCode::Esc => keys::ESC.len(),
+            KeyCode::Char(' ') => keys::SPACE.len(),
+            KeyCode::Char('<') => keys::LESS_THAN.len(),
+            KeyCode::Char('>') => keys::GREATER_THAN.len(),
+            KeyCode::Char('+') => keys::PLUS.len(),
+            KeyCode::Char('-') => keys::MINUS.len(),
+            KeyCode::Char(';') => keys::SEMICOLON.len(),
+            KeyCode::Char('%') => keys::PERCENT.len(),
+            KeyCode::F(1..=9) => 2,
+            KeyCode::F(_) => 3,
+            KeyCode::Char(c) => c.width().unwrap_or(0),
+        };
+        if self.modifiers.contains(KeyModifiers::SHIFT) {
+            width += 2;
+        }
+        if self.modifiers.contains(KeyModifiers::ALT) {
+            width += 2;
+        }
+        if self.modifiers.contains(KeyModifiers::CONTROL) {
+            width += 2;
+        }
+        width
+    }
+
+    fn width_cjk(&self) -> usize {
+        self.width()
+    }
+}
+
 impl std::str::FromStr for KeyEvent {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut tokens: Vec<_> = s.split('-').collect();
         let code = match tokens.pop().ok_or_else(|| anyhow!("Missing key code"))? {
-            "backspace" => KeyCode::Backspace,
-            "space" => KeyCode::Char(' '),
-            "ret" => KeyCode::Enter,
-            "lt" => KeyCode::Char('<'),
-            "gt" => KeyCode::Char('>'),
-            "plus" => KeyCode::Char('+'),
-            "minus" => KeyCode::Char('-'),
-            "semicolon" => KeyCode::Char(';'),
-            "percent" => KeyCode::Char('%'),
-            "left" => KeyCode::Left,
-            "right" => KeyCode::Right,
-            "up" => KeyCode::Down,
-            "home" => KeyCode::Home,
-            "end" => KeyCode::End,
-            "pageup" => KeyCode::PageUp,
-            "pagedown" => KeyCode::PageDown,
-            "tab" => KeyCode::Tab,
-            "backtab" => KeyCode::BackTab,
-            "del" => KeyCode::Delete,
-            "ins" => KeyCode::Insert,
-            "null" => KeyCode::Null,
-            "esc" => KeyCode::Esc,
+            keys::BACKSPACE => KeyCode::Backspace,
+            keys::ENTER => KeyCode::Enter,
+            keys::LEFT => KeyCode::Left,
+            keys::RIGHT => KeyCode::Right,
+            keys::UP => KeyCode::Up,
+            keys::DOWN => KeyCode::Down,
+            keys::HOME => KeyCode::Home,
+            keys::END => KeyCode::End,
+            keys::PAGEUP => KeyCode::PageUp,
+            keys::PAGEDOWN => KeyCode::PageDown,
+            keys::TAB => KeyCode::Tab,
+            keys::BACKTAB => KeyCode::BackTab,
+            keys::DELETE => KeyCode::Delete,
+            keys::INSERT => KeyCode::Insert,
+            keys::NULL => KeyCode::Null,
+            keys::ESC => KeyCode::Esc,
+            keys::SPACE => KeyCode::Char(' '),
+            keys::LESS_THAN => KeyCode::Char('<'),
+            keys::GREATER_THAN => KeyCode::Char('>'),
+            keys::PLUS => KeyCode::Char('+'),
+            keys::MINUS => KeyCode::Char('-'),
+            keys::SEMICOLON => KeyCode::Char(';'),
+            keys::PERCENT => KeyCode::Char('%'),
             single if single.len() == 1 => KeyCode::Char(single.chars().next().unwrap()),
             function if function.len() > 1 && function.starts_with('F') => {
                 let function: String = function.chars().skip(1).collect();
diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs
index caed2952..9bcc0b7d 100644
--- a/helix-view/src/lib.rs
+++ b/helix-view/src/lib.rs
@@ -5,6 +5,7 @@ pub mod clipboard;
 pub mod document;
 pub mod editor;
 pub mod graphics;
+pub mod info;
 pub mod input;
 pub mod keyboard;
 pub mod register_selection;