diff options
Diffstat (limited to 'helix-view/src')
| -rw-r--r-- | helix-view/src/editor.rs | 9 | ||||
| -rw-r--r-- | helix-view/src/graphics.rs | 481 | ||||
| -rw-r--r-- | helix-view/src/input.rs | 15 | ||||
| -rw-r--r-- | helix-view/src/keyboard.rs | 160 | ||||
| -rw-r--r-- | helix-view/src/lib.rs | 2 | ||||
| -rw-r--r-- | helix-view/src/theme.rs | 81 | ||||
| -rw-r--r-- | helix-view/src/tree.rs | 3 | ||||
| -rw-r--r-- | helix-view/src/view.rs | 3 |
8 files changed, 660 insertions, 94 deletions
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index 7f910b80..0a2dc54d 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -1,12 +1,10 @@ -use crate::clipboard::{get_clipboard_provider, ClipboardProvider}; use crate::{ + clipboard::{get_clipboard_provider, ClipboardProvider}, + graphics::{CursorKind, Rect}, theme::{self, Theme}, tree::Tree, Document, DocumentId, RegisterSelection, View, ViewId, }; -use helix_core::syntax; -use tui::layout::Rect; -use tui::terminal::CursorKind; use futures_util::future; use std::{path::PathBuf, sync::Arc, time::Duration}; @@ -17,6 +15,7 @@ use anyhow::Error; pub use helix_core::diagnostic::Severity; pub use helix_core::register::Registers; +use helix_core::syntax; use helix_core::Position; #[derive(Debug)] @@ -45,7 +44,7 @@ pub enum Action { impl Editor { pub fn new( - mut area: tui::layout::Rect, + mut area: Rect, themes: Arc<theme::Loader>, config_loader: Arc<syntax::Loader>, ) -> Self { diff --git a/helix-view/src/graphics.rs b/helix-view/src/graphics.rs new file mode 100644 index 00000000..e14ce2b9 --- /dev/null +++ b/helix-view/src/graphics.rs @@ -0,0 +1,481 @@ +use bitflags::bitflags;
+use std::cmp::{max, min};
+
+#[derive(Debug)]
+/// UNSTABLE
+pub enum CursorKind {
+ /// █
+ Block,
+ /// |
+ Bar,
+ /// _
+ Underline,
+ /// Hidden cursor, can set cursor position with this to let IME have correct cursor position.
+ Hidden,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Margin {
+ pub vertical: u16,
+ pub horizontal: u16,
+}
+
+/// A simple rectangle used in the computation of the layout and to give widgets an hint about the
+/// area they are supposed to render to.
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub struct Rect {
+ pub x: u16,
+ pub y: u16,
+ pub width: u16,
+ pub height: u16,
+}
+
+impl Default for Rect {
+ fn default() -> Rect {
+ Rect {
+ x: 0,
+ y: 0,
+ width: 0,
+ height: 0,
+ }
+ }
+}
+
+impl Rect {
+ /// Creates a new rect, with width and height limited to keep the area under max u16.
+ /// If clipped, aspect ratio will be preserved.
+ pub fn new(x: u16, y: u16, width: u16, height: u16) -> Rect {
+ let max_area = u16::max_value();
+ let (clipped_width, clipped_height) =
+ if u32::from(width) * u32::from(height) > u32::from(max_area) {
+ let aspect_ratio = f64::from(width) / f64::from(height);
+ let max_area_f = f64::from(max_area);
+ let height_f = (max_area_f / aspect_ratio).sqrt();
+ let width_f = height_f * aspect_ratio;
+ (width_f as u16, height_f as u16)
+ } else {
+ (width, height)
+ };
+ Rect {
+ x,
+ y,
+ width: clipped_width,
+ height: clipped_height,
+ }
+ }
+
+ pub fn area(self) -> u16 {
+ self.width * self.height
+ }
+
+ pub fn left(self) -> u16 {
+ self.x
+ }
+
+ pub fn right(self) -> u16 {
+ self.x.saturating_add(self.width)
+ }
+
+ pub fn top(self) -> u16 {
+ self.y
+ }
+
+ pub fn bottom(self) -> u16 {
+ self.y.saturating_add(self.height)
+ }
+
+ pub fn inner(self, margin: &Margin) -> Rect {
+ if self.width < 2 * margin.horizontal || self.height < 2 * margin.vertical {
+ Rect::default()
+ } else {
+ Rect {
+ x: self.x + margin.horizontal,
+ y: self.y + margin.vertical,
+ width: self.width - 2 * margin.horizontal,
+ height: self.height - 2 * margin.vertical,
+ }
+ }
+ }
+
+ pub fn union(self, other: Rect) -> Rect {
+ let x1 = min(self.x, other.x);
+ let y1 = min(self.y, other.y);
+ let x2 = max(self.x + self.width, other.x + other.width);
+ let y2 = max(self.y + self.height, other.y + other.height);
+ Rect {
+ x: x1,
+ y: y1,
+ width: x2 - x1,
+ height: y2 - y1,
+ }
+ }
+
+ pub fn intersection(self, other: Rect) -> Rect {
+ let x1 = max(self.x, other.x);
+ let y1 = max(self.y, other.y);
+ let x2 = min(self.x + self.width, other.x + other.width);
+ let y2 = min(self.y + self.height, other.y + other.height);
+ Rect {
+ x: x1,
+ y: y1,
+ width: x2 - x1,
+ height: y2 - y1,
+ }
+ }
+
+ pub fn intersects(self, other: Rect) -> bool {
+ self.x < other.x + other.width
+ && self.x + self.width > other.x
+ && self.y < other.y + other.height
+ && self.y + self.height > other.y
+ }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum Color {
+ Reset,
+ Black,
+ Red,
+ Green,
+ Yellow,
+ Blue,
+ Magenta,
+ Cyan,
+ Gray,
+ DarkGray,
+ LightRed,
+ LightGreen,
+ LightYellow,
+ LightBlue,
+ LightMagenta,
+ LightCyan,
+ White,
+ Rgb(u8, u8, u8),
+ Indexed(u8),
+}
+
+#[cfg(feature = "term")]
+impl From<Color> for crossterm::style::Color {
+ fn from(color: Color) -> Self {
+ use crossterm::style::Color as CColor;
+
+ match color {
+ Color::Reset => CColor::Reset,
+ Color::Black => CColor::Black,
+ Color::Red => CColor::DarkRed,
+ Color::Green => CColor::DarkGreen,
+ Color::Yellow => CColor::DarkYellow,
+ Color::Blue => CColor::DarkBlue,
+ Color::Magenta => CColor::DarkMagenta,
+ Color::Cyan => CColor::DarkCyan,
+ Color::Gray => CColor::Grey,
+ Color::DarkGray => CColor::DarkGrey,
+ Color::LightRed => CColor::Red,
+ Color::LightGreen => CColor::Green,
+ Color::LightBlue => CColor::Blue,
+ Color::LightYellow => CColor::Yellow,
+ Color::LightMagenta => CColor::Magenta,
+ Color::LightCyan => CColor::Cyan,
+ Color::White => CColor::White,
+ Color::Indexed(i) => CColor::AnsiValue(i),
+ Color::Rgb(r, g, b) => CColor::Rgb { r, g, b },
+ }
+ }
+}
+
+bitflags! {
+ /// Modifier changes the way a piece of text is displayed.
+ ///
+ /// They are bitflags so they can easily be composed.
+ ///
+ /// ## Examples
+ ///
+ /// ```rust
+ /// # use helix_view::graphics::Modifier;
+ ///
+ /// let m = Modifier::BOLD | Modifier::ITALIC;
+ /// ```
+ #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+ pub struct Modifier: u16 {
+ const BOLD = 0b0000_0000_0001;
+ const DIM = 0b0000_0000_0010;
+ const ITALIC = 0b0000_0000_0100;
+ const UNDERLINED = 0b0000_0000_1000;
+ const SLOW_BLINK = 0b0000_0001_0000;
+ const RAPID_BLINK = 0b0000_0010_0000;
+ const REVERSED = 0b0000_0100_0000;
+ const HIDDEN = 0b0000_1000_0000;
+ const CROSSED_OUT = 0b0001_0000_0000;
+ }
+}
+
+/// Style let you control the main characteristics of the displayed elements.
+///
+/// ```rust
+/// # use helix_view::graphics::{Color, Modifier, Style};
+/// Style::default()
+/// .fg(Color::Black)
+/// .bg(Color::Green)
+/// .add_modifier(Modifier::ITALIC | Modifier::BOLD);
+/// ```
+///
+/// It represents an incremental change. If you apply the styles S1, S2, S3 to a cell of the
+/// terminal buffer, the style of this cell will be the result of the merge of S1, S2 and S3, not
+/// just S3.
+///
+/// ```rust
+/// # use helix_view::graphics::{Rect, Color, Modifier, Style};
+/// # use helix_tui::buffer::Buffer;
+/// let styles = [
+/// Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
+/// Style::default().bg(Color::Red),
+/// Style::default().fg(Color::Yellow).remove_modifier(Modifier::ITALIC),
+/// ];
+/// let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
+/// for style in &styles {
+/// buffer.get_mut(0, 0).set_style(*style);
+/// }
+/// assert_eq!(
+/// Style {
+/// fg: Some(Color::Yellow),
+/// bg: Some(Color::Red),
+/// add_modifier: Modifier::BOLD,
+/// sub_modifier: Modifier::empty(),
+/// },
+/// buffer.get(0, 0).style(),
+/// );
+/// ```
+///
+/// The default implementation returns a `Style` that does not modify anything. If you wish to
+/// reset all properties until that point use [`Style::reset`].
+///
+/// ```
+/// # use helix_view::graphics::{Rect, Color, Modifier, Style};
+/// # use helix_tui::buffer::Buffer;
+/// let styles = [
+/// Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
+/// Style::reset().fg(Color::Yellow),
+/// ];
+/// let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
+/// for style in &styles {
+/// buffer.get_mut(0, 0).set_style(*style);
+/// }
+/// assert_eq!(
+/// Style {
+/// fg: Some(Color::Yellow),
+/// bg: Some(Color::Reset),
+/// add_modifier: Modifier::empty(),
+/// sub_modifier: Modifier::empty(),
+/// },
+/// buffer.get(0, 0).style(),
+/// );
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Style {
+ pub fg: Option<Color>,
+ pub bg: Option<Color>,
+ pub add_modifier: Modifier,
+ pub sub_modifier: Modifier,
+}
+
+impl Default for Style {
+ fn default() -> Style {
+ Style {
+ fg: None,
+ bg: None,
+ add_modifier: Modifier::empty(),
+ sub_modifier: Modifier::empty(),
+ }
+ }
+}
+
+impl Style {
+ /// Returns a `Style` resetting all properties.
+ pub fn reset() -> Style {
+ Style {
+ fg: Some(Color::Reset),
+ bg: Some(Color::Reset),
+ add_modifier: Modifier::empty(),
+ sub_modifier: Modifier::all(),
+ }
+ }
+
+ /// Changes the foreground color.
+ ///
+ /// ## Examples
+ ///
+ /// ```rust
+ /// # use helix_view::graphics::{Color, Style};
+ /// let style = Style::default().fg(Color::Blue);
+ /// let diff = Style::default().fg(Color::Red);
+ /// assert_eq!(style.patch(diff), Style::default().fg(Color::Red));
+ /// ```
+ pub fn fg(mut self, color: Color) -> Style {
+ self.fg = Some(color);
+ self
+ }
+
+ /// Changes the background color.
+ ///
+ /// ## Examples
+ ///
+ /// ```rust
+ /// # use helix_view::graphics::{Color, Style};
+ /// let style = Style::default().bg(Color::Blue);
+ /// let diff = Style::default().bg(Color::Red);
+ /// assert_eq!(style.patch(diff), Style::default().bg(Color::Red));
+ /// ```
+ pub fn bg(mut self, color: Color) -> Style {
+ self.bg = Some(color);
+ self
+ }
+
+ /// Changes the text emphasis.
+ ///
+ /// When applied, it adds the given modifier to the `Style` modifiers.
+ ///
+ /// ## Examples
+ ///
+ /// ```rust
+ /// # use helix_view::graphics::{Color, Modifier, Style};
+ /// let style = Style::default().add_modifier(Modifier::BOLD);
+ /// let diff = Style::default().add_modifier(Modifier::ITALIC);
+ /// let patched = style.patch(diff);
+ /// assert_eq!(patched.add_modifier, Modifier::BOLD | Modifier::ITALIC);
+ /// assert_eq!(patched.sub_modifier, Modifier::empty());
+ /// ```
+ pub fn add_modifier(mut self, modifier: Modifier) -> Style {
+ self.sub_modifier.remove(modifier);
+ self.add_modifier.insert(modifier);
+ self
+ }
+
+ /// Changes the text emphasis.
+ ///
+ /// When applied, it removes the given modifier from the `Style` modifiers.
+ ///
+ /// ## Examples
+ ///
+ /// ```rust
+ /// # use helix_view::graphics::{Color, Modifier, Style};
+ /// let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
+ /// let diff = Style::default().remove_modifier(Modifier::ITALIC);
+ /// let patched = style.patch(diff);
+ /// assert_eq!(patched.add_modifier, Modifier::BOLD);
+ /// assert_eq!(patched.sub_modifier, Modifier::ITALIC);
+ /// ```
+ pub fn remove_modifier(mut self, modifier: Modifier) -> Style {
+ self.add_modifier.remove(modifier);
+ self.sub_modifier.insert(modifier);
+ self
+ }
+
+ /// Results in a combined style that is equivalent to applying the two individual styles to
+ /// a style one after the other.
+ ///
+ /// ## Examples
+ /// ```
+ /// # use helix_view::graphics::{Color, Modifier, Style};
+ /// let style_1 = Style::default().fg(Color::Yellow);
+ /// let style_2 = Style::default().bg(Color::Red);
+ /// let combined = style_1.patch(style_2);
+ /// assert_eq!(
+ /// Style::default().patch(style_1).patch(style_2),
+ /// Style::default().patch(combined));
+ /// ```
+ pub fn patch(mut self, other: Style) -> Style {
+ self.fg = other.fg.or(self.fg);
+ self.bg = other.bg.or(self.bg);
+
+ self.add_modifier.remove(other.sub_modifier);
+ self.add_modifier.insert(other.add_modifier);
+ self.sub_modifier.remove(other.add_modifier);
+ self.sub_modifier.insert(other.sub_modifier);
+
+ self
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_rect_size_truncation() {
+ for width in 256u16..300u16 {
+ for height in 256u16..300u16 {
+ let rect = Rect::new(0, 0, width, height);
+ rect.area(); // Should not panic.
+ assert!(rect.width < width || rect.height < height);
+ // The target dimensions are rounded down so the math will not be too precise
+ // but let's make sure the ratios don't diverge crazily.
+ assert!(
+ (f64::from(rect.width) / f64::from(rect.height)
+ - f64::from(width) / f64::from(height))
+ .abs()
+ < 1.0
+ )
+ }
+ }
+
+ // One dimension below 255, one above. Area above max u16.
+ let width = 900;
+ let height = 100;
+ let rect = Rect::new(0, 0, width, height);
+ assert_ne!(rect.width, 900);
+ assert_ne!(rect.height, 100);
+ assert!(rect.width < width || rect.height < height);
+ }
+
+ #[test]
+ fn test_rect_size_preservation() {
+ for width in 0..256u16 {
+ for height in 0..256u16 {
+ let rect = Rect::new(0, 0, width, height);
+ rect.area(); // Should not panic.
+ assert_eq!(rect.width, width);
+ assert_eq!(rect.height, height);
+ }
+ }
+
+ // One dimension below 255, one above. Area below max u16.
+ let rect = Rect::new(0, 0, 300, 100);
+ assert_eq!(rect.width, 300);
+ assert_eq!(rect.height, 100);
+ }
+
+ fn styles() -> Vec<Style> {
+ vec![
+ Style::default(),
+ Style::default().fg(Color::Yellow),
+ Style::default().bg(Color::Yellow),
+ Style::default().add_modifier(Modifier::BOLD),
+ Style::default().remove_modifier(Modifier::BOLD),
+ Style::default().add_modifier(Modifier::ITALIC),
+ Style::default().remove_modifier(Modifier::ITALIC),
+ Style::default().add_modifier(Modifier::ITALIC | Modifier::BOLD),
+ Style::default().remove_modifier(Modifier::ITALIC | Modifier::BOLD),
+ ]
+ }
+
+ #[test]
+ fn combined_patch_gives_same_result_as_individual_patch() {
+ let styles = styles();
+ for &a in &styles {
+ for &b in &styles {
+ for &c in &styles {
+ for &d in &styles {
+ let combined = a.patch(b.patch(c.patch(d)));
+
+ assert_eq!(
+ Style::default().patch(a).patch(b).patch(c).patch(d),
+ Style::default().patch(combined)
+ );
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/helix-view/src/input.rs b/helix-view/src/input.rs index ab417819..5f61ce14 100644 --- a/helix-view/src/input.rs +++ b/helix-view/src/input.rs @@ -1,10 +1,9 @@ //! Input event handling, currently backed by crossterm. use anyhow::{anyhow, Error}; -use crossterm::event; use serde::de::{self, Deserialize, Deserializer}; use std::fmt; -pub use crossterm::event::{KeyCode, KeyModifiers}; +use crate::keyboard::{KeyCode, KeyModifiers}; /// Represents a key event. // We use a newtype here because we want to customize Deserialize and Display. @@ -132,9 +131,15 @@ impl<'de> Deserialize<'de> for KeyEvent { } } -impl From<event::KeyEvent> for KeyEvent { - fn from(event::KeyEvent { code, modifiers }: event::KeyEvent) -> KeyEvent { - KeyEvent { code, modifiers } +#[cfg(feature = "term")] +impl From<crossterm::event::KeyEvent> for KeyEvent { + fn from( + crossterm::event::KeyEvent { code, modifiers }: crossterm::event::KeyEvent, + ) -> KeyEvent { + KeyEvent { + code: code.into(), + modifiers: modifiers.into(), + } } } diff --git a/helix-view/src/keyboard.rs b/helix-view/src/keyboard.rs new file mode 100644 index 00000000..8a2b6545 --- /dev/null +++ b/helix-view/src/keyboard.rs @@ -0,0 +1,160 @@ +use bitflags::bitflags;
+
+bitflags! {
+ /// Represents key modifiers (shift, control, alt).
+ #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+ pub struct KeyModifiers: u8 {
+ const SHIFT = 0b0000_0001;
+ const CONTROL = 0b0000_0010;
+ const ALT = 0b0000_0100;
+ const NONE = 0b0000_0000;
+ }
+}
+
+#[cfg(feature = "term")]
+impl From<KeyModifiers> for crossterm::event::KeyModifiers {
+ fn from(key_modifiers: KeyModifiers) -> Self {
+ use crossterm::event::KeyModifiers as CKeyModifiers;
+
+ let mut result = CKeyModifiers::NONE;
+
+ if key_modifiers & KeyModifiers::SHIFT != KeyModifiers::NONE {
+ result &= CKeyModifiers::SHIFT;
+ }
+
+ if key_modifiers & KeyModifiers::CONTROL != KeyModifiers::NONE {
+ result &= CKeyModifiers::CONTROL;
+ }
+
+ if key_modifiers & KeyModifiers::ALT != KeyModifiers::NONE {
+ result &= CKeyModifiers::ALT;
+ }
+
+ result
+ }
+}
+
+#[cfg(feature = "term")]
+impl From<crossterm::event::KeyModifiers> for KeyModifiers {
+ fn from(val: crossterm::event::KeyModifiers) -> Self {
+ use crossterm::event::KeyModifiers as CKeyModifiers;
+
+ let mut result = KeyModifiers::NONE;
+
+ if val & CKeyModifiers::SHIFT != CKeyModifiers::NONE {
+ result &= KeyModifiers::SHIFT;
+ }
+
+ if val & CKeyModifiers::CONTROL != CKeyModifiers::NONE {
+ result &= KeyModifiers::CONTROL;
+ }
+
+ if val & CKeyModifiers::ALT != CKeyModifiers::NONE {
+ result &= KeyModifiers::ALT;
+ }
+
+ result
+ }
+}
+
+/// Represents a key.
+#[derive(Debug, PartialOrd, PartialEq, Eq, Clone, Copy, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum KeyCode {
+ /// Backspace key.
+ Backspace,
+ /// Enter key.
+ Enter,
+ /// Left arrow key.
+ Left,
+ /// Right arrow key.
+ Right,
+ /// Up arrow key.
+ Up,
+ /// Down arrow key.
+ Down,
+ /// Home key.
+ Home,
+ /// End key.
+ End,
+ /// Page up key.
+ PageUp,
+ /// Page dow key.
+ PageDown,
+ /// Tab key.
+ Tab,
+ /// Shift + Tab key.
+ BackTab,
+ /// Delete key.
+ Delete,
+ /// Insert key.
+ Insert,
+ /// F key.
+ ///
+ /// `KeyCode::F(1)` represents F1 key, etc.
+ F(u8),
+ /// A character.
+ ///
+ /// `KeyCode::Char('c')` represents `c` character, etc.
+ Char(char),
+ /// Null.
+ Null,
+ /// Escape key.
+ Esc,
+}
+
+#[cfg(feature = "term")]
+impl From<KeyCode> for crossterm::event::KeyCode {
+ fn from(key_code: KeyCode) -> Self {
+ use crossterm::event::KeyCode as CKeyCode;
+
+ match key_code {
+ KeyCode::Backspace => CKeyCode::Backspace,
+ KeyCode::Enter => CKeyCode::Enter,
+ KeyCode::Left => CKeyCode::Left,
+ KeyCode::Right => CKeyCode::Right,
+ KeyCode::Up => CKeyCode::Up,
+ KeyCode::Down => CKeyCode::Down,
+ KeyCode::Home => CKeyCode::Home,
+ KeyCode::End => CKeyCode::End,
+ KeyCode::PageUp => CKeyCode::PageUp,
+ KeyCode::PageDown => CKeyCode::PageDown,
+ KeyCode::Tab => CKeyCode::Tab,
+ KeyCode::BackTab => CKeyCode::BackTab,
+ KeyCode::Delete => CKeyCode::Delete,
+ KeyCode::Insert => CKeyCode::Insert,
+ KeyCode::F(f_number) => CKeyCode::F(f_number),
+ KeyCode::Char(character) => CKeyCode::Char(character),
+ KeyCode::Null => CKeyCode::Null,
+ KeyCode::Esc => CKeyCode::Esc,
+ }
+ }
+}
+
+#[cfg(feature = "term")]
+impl From<crossterm::event::KeyCode> for KeyCode {
+ fn from(val: crossterm::event::KeyCode) -> Self {
+ use crossterm::event::KeyCode as CKeyCode;
+
+ match val {
+ CKeyCode::Backspace => KeyCode::Backspace,
+ CKeyCode::Enter => KeyCode::Enter,
+ CKeyCode::Left => KeyCode::Left,
+ CKeyCode::Right => KeyCode::Right,
+ CKeyCode::Up => KeyCode::Up,
+ CKeyCode::Down => KeyCode::Down,
+ CKeyCode::Home => KeyCode::Home,
+ CKeyCode::End => KeyCode::End,
+ CKeyCode::PageUp => KeyCode::PageUp,
+ CKeyCode::PageDown => KeyCode::PageDown,
+ CKeyCode::Tab => KeyCode::Tab,
+ CKeyCode::BackTab => KeyCode::BackTab,
+ CKeyCode::Delete => KeyCode::Delete,
+ CKeyCode::Insert => KeyCode::Insert,
+ CKeyCode::F(f_number) => KeyCode::F(f_number),
+ CKeyCode::Char(character) => KeyCode::Char(character),
+ CKeyCode::Null => KeyCode::Null,
+ CKeyCode::Esc => KeyCode::Esc,
+ }
+ }
+}
diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs index b3e87bf4..caed2952 100644 --- a/helix-view/src/lib.rs +++ b/helix-view/src/lib.rs @@ -4,7 +4,9 @@ pub mod macros; pub mod clipboard; pub mod document; pub mod editor; +pub mod graphics; pub mod input; +pub mod keyboard; pub mod register_selection; pub mod theme; pub mod tree; diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs index 66b91294..947c6ee0 100644 --- a/helix-view/src/theme.rs +++ b/helix-view/src/theme.rs @@ -9,86 +9,7 @@ use once_cell::sync::Lazy; use serde::{Deserialize, Deserializer}; use toml::Value; -#[cfg(feature = "term")] -pub use tui::style::{Color, Modifier, Style}; - -// #[derive(Clone, Copy, PartialEq, Eq, Default, Hash)] -// pub struct Color { -// pub r: u8, -// pub g: u8, -// pub b: u8, -// } - -// impl Color { -// pub fn new(r: u8, g: u8, b: u8) -> Self { -// Self { r, g, b } -// } -// } - -// #[cfg(feature = "term")] -// impl Into<tui::style::Color> for Color { -// fn into(self) -> tui::style::Color { -// tui::style::Color::Rgb(self.r, self.g, self.b) -// } -// } - -// impl std::str::FromStr for Color { -// type Err = (); - -// /// Tries to parse a string (`'#FFFFFF'` or `'FFFFFF'`) into RGB. -// fn from_str(input: &str) -> Result<Self, Self::Err> { -// let input = input.trim(); -// let input = match (input.chars().next(), input.len()) { -// (Some('#'), 7) => &input[1..], -// (_, 6) => input, -// _ => return Err(()), -// }; - -// u32::from_str_radix(&input, 16) -// .map(|s| Color { -// r: ((s >> 16) & 0xFF) as u8, -// g: ((s >> 8) & 0xFF) as u8, -// b: (s & 0xFF) as u8, -// }) -// .map_err(|_| ()) -// } -// } - -// #[derive(Clone, Copy, PartialEq, Eq, Default, Hash)] -// pub struct Style { -// pub fg: Option<Color>, -// pub bg: Option<Color>, -// // TODO: modifiers (bold, underline, italic, etc) -// } - -// impl Style { -// pub fn fg(mut self, fg: Color) -> Self { -// self.fg = Some(fg); -// self -// } - -// pub fn bg(mut self, bg: Color) -> Self { -// self.bg = Some(bg); -// self -// } -// } - -// #[cfg(feature = "term")] -// impl Into<tui::style::Style> for Style { -// fn into(self) -> tui::style::Style { -// let style = tui::style::Style::default(); - -// if let Some(fg) = self.fg { -// style.fg(fg.into()); -// } - -// if let Some(bg) = self.bg { -// style.bg(bg.into()); -// } - -// style -// } -// } +pub use crate::graphics::{Color, Modifier, Style}; /// Color theme for syntax highlighting. diff --git a/helix-view/src/tree.rs b/helix-view/src/tree.rs index f7d6c1f2..6d5be390 100644 --- a/helix-view/src/tree.rs +++ b/helix-view/src/tree.rs @@ -1,6 +1,5 @@ -use crate::{View, ViewId}; +use crate::{graphics::Rect, View, ViewId}; use slotmap::HopSlotMap; -use tui::layout::Rect; // the dimensions are recomputed on windo resize/tree change. // diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs index c0a72c78..24df7a4f 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -1,12 +1,11 @@ use std::borrow::Cow; -use crate::{Document, DocumentId, ViewId}; +use crate::{graphics::Rect, Document, DocumentId, ViewId}; use helix_core::{ coords_at_pos, graphemes::{grapheme_width, RopeGraphemes}, Position, RopeSlice, Selection, }; -use tui::layout::Rect; pub const PADDING: usize = 5; |