reverse the dependency between helix-tui and helix-view (#366)

* reverse the dependency between helix-tui and helix-view by moving a fiew types to view

* fix tests

* clippy and format fixes

Co-authored-by: Keith Simmons <keithsim@microsoft.com>

38 files changed, 773 insertions, 697 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 2a90b539..a1e29d2e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -371,6 +371,7 @@ dependencies = [
  "cassowary",
  "crossterm",
  "helix-core",
+ "helix-view",
  "serde",
  "unicode-segmentation",
  "unicode-width",
@@ -381,6 +382,7 @@ name = "helix-view"
 version = "0.2.0"
 dependencies = [
  "anyhow",
+ "bitflags",
  "chardetng",
  "crossterm",
  "encoding_rs",
diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml
index 385af64c..2334c34a 100644
--- a/helix-term/Cargo.toml
+++ b/helix-term/Cargo.toml
@@ -23,8 +23,8 @@ path = "src/main.rs"
 
 [dependencies]
 helix-core = { version = "0.2", path = "../helix-core" }
-helix-view = { version = "0.2", path = "../helix-view", features = ["term"]}
-helix-lsp = { version = "0.2", path = "../helix-lsp"}
+helix-view = { version = "0.2", path = "../helix-view" }
+helix-lsp = { version = "0.2", path = "../helix-lsp" }
 
 anyhow = "1"
 once_cell = "1.8"
diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index f9c6c9c1..f33a5831 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -1,6 +1,6 @@
 use helix_core::syntax;
 use helix_lsp::{lsp, LspProgressMap};
-use helix_view::{document::Mode, theme, Document, Editor, Theme, View};
+use helix_view::{document::Mode, graphics::Rect, theme, Document, Editor, Theme, View};
 
 use crate::{
     args::Args,
@@ -29,8 +29,6 @@ use crossterm::{
     execute, terminal,
 };
 
-use tui::layout::Rect;
-
 use futures_util::{future, stream::FuturesUnordered};
 
 type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index d99c840f..d98bda74 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -15,7 +15,8 @@ use helix_core::{
 
 use helix_view::{
     document::{IndentStyle, Mode},
-    input::{KeyCode, KeyEvent},
+    input::KeyEvent,
+    keyboard::KeyCode,
     view::{View, PADDING},
     Document, DocumentId, Editor, ViewId,
 };
diff --git a/helix-term/src/compositor.rs b/helix-term/src/compositor.rs
index b04d4588..cd0a12b5 100644
--- a/helix-term/src/compositor.rs
+++ b/helix-term/src/compositor.rs
@@ -3,9 +3,10 @@
 // cursive does compositor.screen_mut().add_layer_at(pos::absolute(x, y), <component>)
 use helix_core::Position;
 use helix_lsp::LspProgressMap;
+use helix_view::graphics::{CursorKind, Rect};
 
 use crossterm::event::Event;
-use tui::{buffer::Buffer as Surface, layout::Rect, terminal::CursorKind};
+use tui::buffer::Buffer as Surface;
 
 pub type Callback = Box<dyn FnOnce(&mut Compositor)>;
 
diff --git a/helix-term/src/config.rs b/helix-term/src/config.rs
index 87d9e365..3c05144a 100644
--- a/helix-term/src/config.rs
+++ b/helix-term/src/config.rs
@@ -23,8 +23,11 @@ pub struct LspConfig {
 #[test]
 fn parsing_keymaps_config_file() {
     use helix_core::hashmap;
-    use helix_view::document::Mode;
-    use helix_view::input::{KeyCode, KeyEvent, KeyModifiers};
+    use helix_view::{
+        document::Mode,
+        input::KeyEvent,
+        keyboard::{KeyCode, KeyModifiers},
+    };
 
     let sample_keymaps = r#"
             [keys.insert]
diff --git a/helix-term/src/keymap.rs b/helix-term/src/keymap.rs
index b4c2055f..05869610 100644
--- a/helix-term/src/keymap.rs
+++ b/helix-term/src/keymap.rs
@@ -3,8 +3,11 @@ pub use crate::commands::Command;
 use crate::config::Config;
 use anyhow::{anyhow, Error, Result};
 use helix_core::hashmap;
-use helix_view::document::Mode;
-use helix_view::input::{KeyCode, KeyEvent, KeyModifiers};
+use helix_view::{
+    document::Mode,
+    input::KeyEvent,
+    keyboard::{KeyCode, KeyModifiers},
+};
 use serde::Deserialize;
 use std::{
     collections::HashMap,
diff --git a/helix-term/src/ui/completion.rs b/helix-term/src/ui/completion.rs
index 85543610..74a82dab 100644
--- a/helix-term/src/ui/completion.rs
+++ b/helix-term/src/ui/completion.rs
@@ -1,15 +1,14 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-};
+use tui::buffer::Buffer as Surface;
 
 use std::borrow::Cow;
 
 use helix_core::{Position, Transaction};
-use helix_view::Editor;
+use helix_view::{
+    graphics::{Color, Rect, Style},
+    Editor,
+};
 
 use crate::commands;
 use crate::ui::{menu, Markdown, Menu, Popup, PromptEvent};
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index 1c443bc7..93f000e7 100644
--- a/helix-term/src/ui/editor.rs
+++ b/helix-term/src/ui/editor.rs
@@ -12,21 +12,20 @@ use helix_core::{
     LineEnding, Position, Range,
 };
 use helix_lsp::LspProgressMap;
-use helix_view::input::{KeyCode, KeyEvent, KeyModifiers};
-use helix_view::{document::Mode, Document, Editor, Theme, View};
+use helix_view::{
+    document::Mode,
+    graphics::{Color, CursorKind, Modifier, Rect, Style},
+    input::KeyEvent,
+    keyboard::{KeyCode, KeyModifiers},
+    Document, Editor, Theme, View,
+};
 use std::borrow::Cow;
 
 use crossterm::{
     cursor,
     event::{read, Event, EventStream},
 };
-use tui::{
-    backend::CrosstermBackend,
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Modifier, Style},
-    terminal::CursorKind,
-};
+use tui::{backend::CrosstermBackend, buffer::Buffer as Surface};
 
 pub struct EditorView {
     keymaps: Keymaps,
diff --git a/helix-term/src/ui/markdown.rs b/helix-term/src/ui/markdown.rs
index 72a3e4ff..36d570cd 100644
--- a/helix-term/src/ui/markdown.rs
+++ b/helix-term/src/ui/markdown.rs
@@ -1,16 +1,14 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-    text::Text,
-};
+use tui::{buffer::Buffer as Surface, text::Text};
 
 use std::{borrow::Cow, sync::Arc};
 
 use helix_core::{syntax, Position};
-use helix_view::{Editor, Theme};
+use helix_view::{
+    graphics::{Color, Rect, Style},
+    Editor, Theme,
+};
 
 pub struct Markdown {
     contents: String,
diff --git a/helix-term/src/ui/menu.rs b/helix-term/src/ui/menu.rs
index 0a264f7c..f32ce01c 100644
--- a/helix-term/src/ui/menu.rs
+++ b/helix-term/src/ui/menu.rs
@@ -1,11 +1,6 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-    widgets::Table,
-};
+use tui::{buffer::Buffer as Surface, widgets::Table};
 
 pub use tui::widgets::{Cell, Row};
 
@@ -15,7 +10,10 @@ use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;
 use fuzzy_matcher::FuzzyMatcher;
 
 use helix_core::Position;
-use helix_view::Editor;
+use helix_view::{
+    graphics::{Color, Rect, Style},
+    Editor,
+};
 
 pub trait Item {
     // TODO: sort_text
diff --git a/helix-term/src/ui/mod.rs b/helix-term/src/ui/mod.rs
index 29d555ac..14dc9169 100644
--- a/helix-term/src/ui/mod.rs
+++ b/helix-term/src/ui/mod.rs
@@ -18,12 +18,12 @@ pub use prompt::{Prompt, PromptEvent};
 pub use spinner::{ProgressSpinners, Spinner};
 pub use text::Text;
 
-pub use tui::layout::Rect;
-pub use tui::style::{Color, Modifier, Style};
-
 use helix_core::regex::Regex;
 use helix_core::register::Registers;
-use helix_view::{Document, Editor, View};
+use helix_view::{
+    graphics::{Color, Modifier, Rect, Style},
+    Document, Editor, View,
+};
 
 use std::path::{Path, PathBuf};
 
diff --git a/helix-term/src/ui/picker.rs b/helix-term/src/ui/picker.rs
index d1152659..15e6b062 100644
--- a/helix-term/src/ui/picker.rs
+++ b/helix-term/src/ui/picker.rs
@@ -2,8 +2,6 @@ use crate::compositor::{Component, Compositor, Context, EventResult};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 use tui::{
     buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
     widgets::{Block, BorderType, Borders},
 };
 
@@ -14,9 +12,11 @@ use std::borrow::Cow;
 
 use crate::ui::{Prompt, PromptEvent};
 use helix_core::Position;
-use helix_view::editor::Action;
-use helix_view::Editor;
-use tui::terminal::CursorKind;
+use helix_view::{
+    editor::Action,
+    graphics::{Color, CursorKind, Rect, Style},
+    Editor,
+};
 
 pub struct Picker<T> {
     options: Vec<T>,
diff --git a/helix-term/src/ui/popup.rs b/helix-term/src/ui/popup.rs
index 8488d1c6..af72735c 100644
--- a/helix-term/src/ui/popup.rs
+++ b/helix-term/src/ui/popup.rs
@@ -1,15 +1,14 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-};
+use tui::buffer::Buffer as Surface;
 
 use std::borrow::Cow;
 
 use helix_core::Position;
-use helix_view::Editor;
+use helix_view::{
+    graphics::{Color, Rect, Style},
+    Editor,
+};
 
 // TODO: share logic with Menu, it's essentially Popup(render_fn), but render fn needs to return
 // a width/height hint. maybe Popup(Box<Component>)
diff --git a/helix-term/src/ui/prompt.rs b/helix-term/src/ui/prompt.rs
index 63078c39..6bb1b006 100644
--- a/helix-term/src/ui/prompt.rs
+++ b/helix-term/src/ui/prompt.rs
@@ -1,14 +1,17 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crate::ui;
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use helix_core::Position;
-use helix_view::{Editor, Theme};
 use std::{borrow::Cow, ops::RangeFrom};
-use tui::terminal::CursorKind;
+use tui::buffer::Buffer as Surface;
 
 use helix_core::{
     unicode::segmentation::{GraphemeCursor, GraphemeIncomplete},
     unicode::width::UnicodeWidthStr,
+    Position,
+};
+use helix_view::{
+    graphics::{Color, CursorKind, Margin, Modifier, Rect, Style},
+    Editor, Theme,
 };
 
 pub type Completion = (RangeFrom<usize>, Cow<'static, str>);
@@ -251,12 +254,6 @@ impl Prompt {
     }
 }
 
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Modifier, Style},
-};
-
 const BASE_WIDTH: u16 = 30;
 
 impl Prompt {
@@ -343,7 +340,6 @@ impl Prompt {
             let background = theme.get("ui.help");
             surface.clear_with(area, background);
 
-            use tui::layout::Margin;
             text.render(
                 area.inner(&Margin {
                     vertical: 1,
diff --git a/helix-term/src/ui/text.rs b/helix-term/src/ui/text.rs
index 6225e769..7c491841 100644
--- a/helix-term/src/ui/text.rs
+++ b/helix-term/src/ui/text.rs
@@ -1,15 +1,14 @@
 use crate::compositor::{Component, Compositor, Context, EventResult};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
-use tui::{
-    buffer::Buffer as Surface,
-    layout::Rect,
-    style::{Color, Style},
-};
+use tui::buffer::Buffer as Surface;
 
 use std::borrow::Cow;
 
 use helix_core::Position;
-use helix_view::Editor;
+use helix_view::{
+    graphics::{Color, Rect, Style},
+    Editor,
+};
 
 pub struct Text {
     contents: String,
diff --git a/helix-tui/Cargo.toml b/helix-tui/Cargo.toml
index 30e2374d..bd0c2697 100644
--- a/helix-tui/Cargo.toml
+++ b/helix-tui/Cargo.toml
@@ -22,4 +22,5 @@ unicode-segmentation = "1.2"
 unicode-width = "0.1"
 crossterm = { version = "0.20", optional = true }
 serde = { version = "1", "optional" = true, features = ["derive"]}
+helix-view = { path = "../helix-view", features = ["term"] }
 helix-core = { version = "0.2", path = "../helix-core" }
diff --git a/helix-tui/src/backend/crossterm.rs b/helix-tui/src/backend/crossterm.rs
index 189f9dce..eff098b3 100644
--- a/helix-tui/src/backend/crossterm.rs
+++ b/helix-tui/src/backend/crossterm.rs
@@ -1,10 +1,4 @@
-use crate::{
-    backend::Backend,
-    buffer::Cell,
-    layout::Rect,
-    style::{Color, Modifier},
-    terminal::CursorKind,
-};
+use crate::{backend::Backend, buffer::Cell};
 use crossterm::{
     cursor::{CursorShape, Hide, MoveTo, SetCursorShape, Show},
     execute, queue,
@@ -14,6 +8,7 @@ use crossterm::{
     },
     terminal::{self, Clear, ClearType},
 };
+use helix_view::graphics::{Color, CursorKind, Modifier, Rect};
 use std::io::{self, Write};
 
 pub struct CrosstermBackend<W: Write> {
@@ -133,32 +128,6 @@ fn map_error(error: crossterm::Result<()>) -> io::Result<()> {
     error.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))
 }
 
-impl From<Color> for CColor {
-    fn from(color: Color) -> Self {
-        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 },
-        }
-    }
-}
-
 #[derive(Debug)]
 struct ModifierDiff {
     pub from: Modifier,
diff --git a/helix-tui/src/backend/mod.rs b/helix-tui/src/backend/mod.rs
index 5cf21768..c6c11019 100644
--- a/helix-tui/src/backend/mod.rs
+++ b/helix-tui/src/backend/mod.rs
@@ -1,8 +1,8 @@
 use std::io;
 
 use crate::buffer::Cell;
-use crate::layout::Rect;
-use crate::terminal::CursorKind;
+
+use helix_view::graphics::{CursorKind, Rect};
 
 #[cfg(feature = "crossterm")]
 mod crossterm;
diff --git a/helix-tui/src/backend/test.rs b/helix-tui/src/backend/test.rs
index 4681831d..a03bcd8e 100644
--- a/helix-tui/src/backend/test.rs
+++ b/helix-tui/src/backend/test.rs
@@ -1,9 +1,8 @@
 use crate::{
     backend::Backend,
     buffer::{Buffer, Cell},
-    layout::Rect,
-    terminal::CursorKind,
 };
+use helix_view::graphics::{CursorKind, Rect};
 use std::{fmt::Write, io};
 use unicode_width::UnicodeWidthStr;
 
diff --git a/helix-tui/src/buffer.rs b/helix-tui/src/buffer.rs
index 8b03cb0d..806a178b 100644
--- a/helix-tui/src/buffer.rs
+++ b/helix-tui/src/buffer.rs
@@ -1,12 +1,10 @@
-use crate::{
-    layout::Rect,
-    style::{Color, Modifier, Style},
-    text::{Span, Spans},
-};
+use crate::text::{Span, Spans};
 use std::cmp::min;
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 
+use helix_view::graphics::{Color, Modifier, Rect, Style};
+
 /// A buffer cell
 #[derive(Debug, Clone, PartialEq)]
 pub struct Cell {
@@ -89,8 +87,7 @@ impl Default for Cell {
 ///
 /// ```
 /// use helix_tui::buffer::{Buffer, Cell};
-/// use helix_tui::layout::Rect;
-/// use helix_tui::style::{Color, Style, Modifier};
+/// use helix_view::graphics::{Rect, Color, Style, Modifier};
 ///
 /// let mut buf = Buffer::empty(Rect{x: 0, y: 0, width: 10, height: 5});
 /// buf.get_mut(0, 2).set_symbol("x");
@@ -193,7 +190,7 @@ impl Buffer {
     ///
     /// ```
     /// # use helix_tui::buffer::Buffer;
-    /// # use helix_tui::layout::Rect;
+    /// # use helix_view::graphics::Rect;
     /// let rect = Rect::new(200, 100, 10, 10);
     /// let buffer = Buffer::empty(rect);
     /// // Global coordinates to the top corner of this buffer's area
@@ -225,7 +222,7 @@ impl Buffer {
     ///
     /// ```
     /// # use helix_tui::buffer::Buffer;
-    /// # use helix_tui::layout::Rect;
+    /// # use helix_view::graphics::Rect;
     /// let rect = Rect::new(200, 100, 10, 10);
     /// let buffer = Buffer::empty(rect);
     /// assert_eq!(buffer.pos_of(0), (200, 100));
diff --git a/helix-tui/src/layout.rs b/helix-tui/src/layout.rs
index 5248f7bf..e6a84aa0 100644
--- a/helix-tui/src/layout.rs
+++ b/helix-tui/src/layout.rs
@@ -1,11 +1,12 @@
 use std::cell::RefCell;
-use std::cmp::{max, min};
 use std::collections::HashMap;
 
 use cassowary::strength::{REQUIRED, WEAK};
 use cassowary::WeightedRelation::*;
 use cassowary::{Constraint as CassowaryConstraint, Expression, Solver, Variable};
 
+use helix_view::graphics::{Margin, Rect};
+
 #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
 pub enum Corner {
     TopLeft,
@@ -45,12 +46,6 @@ impl Constraint {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Margin {
-    pub vertical: u16,
-    pub horizontal: u16,
-}
-
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Alignment {
     Left,
@@ -119,7 +114,8 @@ impl Layout {
     ///
     /// # Examples
     /// ```
-    /// # use helix_tui::layout::{Rect, Constraint, Direction, Layout};
+    /// # use helix_tui::layout::{Constraint, Direction, Layout};
+    /// # use helix_view::graphics::Rect;
     /// let chunks = Layout::default()
     ///     .direction(Direction::Vertical)
     ///     .constraints([Constraint::Length(5), Constraint::Min(0)].as_ref())
@@ -348,117 +344,6 @@ impl Element {
     }
 }
 
-/// 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
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -487,48 +372,4 @@ mod tests {
         assert_eq!(target.height, chunks.iter().map(|r| r.height).sum::<u16>());
         chunks.windows(2).for_each(|w| assert!(w[0].y <= w[1].y));
     }
-
-    #[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);
-    }
 }
diff --git a/helix-tui/src/lib.rs b/helix-tui/src/lib.rs
index 05263bc8..2636b268 100644
--- a/helix-tui/src/lib.rs
+++ b/helix-tui/src/lib.rs
@@ -125,7 +125,6 @@
 pub mod backend;
 pub mod buffer;
 pub mod layout;
-pub mod style;
 pub mod symbols;
 pub mod terminal;
 pub mod text;
diff --git a/helix-tui/src/terminal.rs b/helix-tui/src/terminal.rs
index b9b2437a..4637eb71 100644
--- a/helix-tui/src/terminal.rs
+++ b/helix-tui/src/terminal.rs
@@ -1,4 +1,5 @@
-use crate::{backend::Backend, buffer::Buffer, layout::Rect};
+use crate::{backend::Backend, buffer::Buffer};
+use helix_view::graphics::{CursorKind, Rect};
 use std::io;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -8,19 +9,6 @@ enum ResizeBehavior {
     Auto,
 }
 
-#[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)]
 /// UNSTABLE
 pub struct Viewport {
diff --git a/helix-tui/src/text.rs b/helix-tui/src/text.rs
index b23bfd81..4af6b09d 100644
--- a/helix-tui/src/text.rs
+++ b/helix-tui/src/text.rs
@@ -21,7 +21,7 @@
 //! ```rust
 //! # use helix_tui::widgets::Block;
 //! # use helix_tui::text::{Span, Spans};
-//! # use helix_tui::style::{Color, Style};
+//! # use helix_view::graphics::{Color, Style};
 //! // A simple string with no styling.
 //! // Converted to Spans(vec![
 //! //   Span { content: Cow::Borrowed("My title"), style: Style { .. } }
@@ -46,8 +46,8 @@
 //!     Span::raw(" title"),
 //! ]);
 //! ```
-use crate::style::Style;
 use helix_core::line_ending::str_is_line_ending;
+use helix_view::graphics::Style;
 use std::borrow::Cow;
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
@@ -92,7 +92,7 @@ impl<'a> Span<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::Span;
-    /// # use helix_tui::style::{Color, Modifier, Style};
+    /// # use helix_view::graphics::{Color, Modifier, Style};
     /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
     /// Span::styled("My text", style);
     /// Span::styled(String::from("My text"), style);
@@ -121,7 +121,7 @@ impl<'a> Span<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::{Span, StyledGrapheme};
-    /// # use helix_tui::style::{Color, Modifier, Style};
+    /// # use helix_view::graphics::{Color, Modifier, Style};
     /// # use std::iter::Iterator;
     /// let style = Style::default().fg(Color::Yellow);
     /// let span = Span::styled("Text", style);
@@ -211,7 +211,7 @@ impl<'a> Spans<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::{Span, Spans};
-    /// # use helix_tui::style::{Color, Style};
+    /// # use helix_view::graphics::{Color, Style};
     /// let spans = Spans::from(vec![
     ///     Span::styled("My", Style::default().fg(Color::Yellow)),
     ///     Span::raw(" text"),
@@ -265,7 +265,7 @@ impl<'a> From<Spans<'a>> for String {
 ///
 /// ```rust
 /// # use helix_tui::text::Text;
-/// # use helix_tui::style::{Color, Modifier, Style};
+/// # use helix_view::graphics::{Color, Modifier, Style};
 /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
 ///
 /// // An initial two lines of `Text` built from a `&str`
@@ -319,7 +319,7 @@ impl<'a> Text<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::Text;
-    /// # use helix_tui::style::{Color, Modifier, Style};
+    /// # use helix_view::graphics::{Color, Modifier, Style};
     /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
     /// Text::styled("The first line\nThe second line", style);
     /// Text::styled(String::from("The first line\nThe second line"), style);
@@ -369,7 +369,7 @@ impl<'a> Text<'a> {
     ///
     /// ```rust
     /// # use helix_tui::text::Text;
-    /// # use helix_tui::style::{Color, Modifier, Style};
+    /// # use helix_view::graphics::{Color, Modifier, Style};
     /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
     /// let mut raw_text = Text::raw("The first line\nThe second line");
     /// let styled_text = Text::styled(String::from("The first line\nThe second line"), style);
diff --git a/helix-tui/src/widgets/block.rs b/helix-tui/src/widgets/block.rs
index 2569c17d..648c2d7e 100644
--- a/helix-tui/src/widgets/block.rs
+++ b/helix-tui/src/widgets/block.rs
@@ -1,11 +1,10 @@
 use crate::{
     buffer::Buffer,
-    layout::Rect,
-    style::Style,
     symbols::line,
     text::{Span, Spans},
     widgets::{Borders, Widget},
 };
+use helix_view::graphics::{Rect, Style};
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum BorderType {
@@ -33,7 +32,7 @@ impl BorderType {
 ///
 /// ```
 /// # use helix_tui::widgets::{Block, BorderType, Borders};
-/// # use helix_tui::style::{Style, Color};
+/// # use helix_view::graphics::{Style, Color};
 /// Block::default()
 ///     .title("Block")
 ///     .borders(Borders::LEFT | Borders::RIGHT)
@@ -212,7 +211,6 @@ impl<'a> Widget for Block<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::layout::Rect;
 
     #[test]
     fn inner_takes_into_account_the_borders() {
diff --git a/helix-tui/src/widgets/mod.rs b/helix-tui/src/widgets/mod.rs
index 484ad50e..e5608a79 100644
--- a/helix-tui/src/widgets/mod.rs
+++ b/helix-tui/src/widgets/mod.rs
@@ -20,9 +20,11 @@ pub use self::block::{Block, BorderType};
 pub use self::paragraph::{Paragraph, Wrap};
 pub use self::table::{Cell, Row, Table, TableState};
 
-use crate::{buffer::Buffer, layout::Rect};
+use crate::buffer::Buffer;
 use bitflags::bitflags;
 
+use helix_view::graphics::Rect;
+
 bitflags! {
     /// Bitflags that can be composed to set the visible borders essentially on the block widget.
     pub struct Borders: u32 {
diff --git a/helix-tui/src/widgets/paragraph.rs b/helix-tui/src/widgets/paragraph.rs
index ecce8581..bdfb5b9a 100644
--- a/helix-tui/src/widgets/paragraph.rs
+++ b/helix-tui/src/widgets/paragraph.rs
@@ -1,13 +1,13 @@
 use crate::{
     buffer::Buffer,
-    layout::{Alignment, Rect},
-    style::Style,
+    layout::Alignment,
     text::{StyledGrapheme, Text},
     widgets::{
         reflow::{LineComposer, LineTruncator, WordWrapper},
         Block, Widget,
     },
 };
+use helix_view::graphics::{Rect, Style};
 use std::iter;
 use unicode_width::UnicodeWidthStr;
 
@@ -26,8 +26,8 @@ fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment)
 /// ```
 /// # use helix_tui::text::{Text, Spans, Span};
 /// # use helix_tui::widgets::{Block, Borders, Paragraph, Wrap};
-/// # use helix_tui::style::{Style, Color, Modifier};
 /// # use helix_tui::layout::{Alignment};
+/// # use helix_view::graphics::{Style, Color, Modifier};
 /// let text = vec![
 ///     Spans::from(vec![
 ///         Span::raw("First"),
diff --git a/helix-tui/src/widgets/table.rs b/helix-tui/src/widgets/table.rs
index d42d7d30..44f6c58f 100644
--- a/helix-tui/src/widgets/table.rs
+++ b/helix-tui/src/widgets/table.rs
@@ -1,7 +1,6 @@
 use crate::{
     buffer::Buffer,
-    layout::{Constraint, Rect},
-    style::Style,
+    layout::Constraint,
     text::Text,
     widgets::{Block, Widget},
 };
@@ -10,6 +9,7 @@ use cassowary::{
     WeightedRelation::*,
     {Expression, Solver},
 };
+use helix_view::graphics::{Rect, Style};
 use std::{
     collections::HashMap,
     iter::{self, Iterator},
@@ -21,8 +21,8 @@ use unicode_width::UnicodeWidthStr;
 /// It can be created from anything that can be converted to a [`Text`].
 /// ```rust
 /// # use helix_tui::widgets::Cell;
-/// # use helix_tui::style::{Style, Modifier};
 /// # use helix_tui::text::{Span, Spans, Text};
+/// # use helix_view::graphics::{Style, Modifier};
 /// Cell::from("simple string");
 ///
 /// Cell::from(Span::from("span"));
@@ -74,7 +74,7 @@ where
 /// But if you need a bit more control over individual cells, you can explicity create [`Cell`]s:
 /// ```rust
 /// # use helix_tui::widgets::{Row, Cell};
-/// # use helix_tui::style::{Style, Color};
+/// # use helix_view::graphics::{Style, Color};
 /// Row::new(vec![
 ///     Cell::from("Cell1"),
 ///     Cell::from("Cell2").style(Style::default().fg(Color::Yellow)),
@@ -137,7 +137,7 @@ impl<'a> Row<'a> {
 /// ```rust
 /// # use helix_tui::widgets::{Block, Borders, Table, Row, Cell};
 /// # use helix_tui::layout::Constraint;
-/// # use helix_tui::style::{Style, Color, Modifier};
+/// # use helix_view::graphics::{Style, Color, Modifier};
 /// # use helix_tui::text::{Text, Spans, Span};
 /// Table::new(vec![
 ///     // Row can be created from simple strings.
diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml
index cadbbdbd..9c3c23ff 100644
--- a/helix-view/Cargo.toml
+++ b/helix-view/Cargo.toml
@@ -9,20 +9,18 @@ categories = ["editor"]
 repository = "https://github.com/helix-editor/helix"
 homepage = "https://helix-editor.com"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [features]
-term = ["tui", "crossterm"]
-default = ["term"]
+default = []
+term = ["crossterm"]
 
 [dependencies]
+bitflags = "1.0"
 anyhow = "1"
 helix-core = { version = "0.2", path = "../helix-core" }
 helix-lsp = { version = "0.2", path = "../helix-lsp"}
+crossterm = { version = "0.20", optional = true }
 
 # Conversion traits
-tui = { path = "../helix-tui", package = "helix-tui", default-features = false, features = ["crossterm"], optional = true }
-crossterm = { version = "0.20", features = ["event-stream"], optional = true }
 once_cell = "1.8"
 url = "2"
 
@@ -39,3 +37,6 @@ toml = "0.5"
 log = "~0.4"
 
 which = "4.1"
+
+[dev-dependencies]
+helix-tui = { path = "../helix-tui" }
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-tui/src/style.rs b/helix-view/src/graphics.rs
index f322d304..e14ce2b9 100644
--- a/helix-tui/src/style.rs
+++ b/helix-view/src/graphics.rs
@@ -1,281 +1,481 @@
-//! `style` contains the primitives used to control how your user interface will look.
-
-use bitflags::bitflags;
-
-#[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),
-}
-
-bitflags! {
-    /// Modifier changes the way a piece of text is displayed.
-    ///
-    /// They are bitflags so they can easily be composed.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use helix_tui::style::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_tui::style::{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_tui::style::{Color, Modifier, Style};
-/// # use helix_tui::buffer::Buffer;
-/// # use helix_tui::layout::Rect;
-/// 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_tui::style::{Color, Modifier, Style};
-/// # use helix_tui::buffer::Buffer;
-/// # use helix_tui::layout::Rect;
-/// 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_tui::style::{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_tui::style::{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_tui::style::{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_tui::style::{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_tui::style::{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::*;
-
-    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)
-                        );
-                    }
-                }
-            }
-        }
-    }
-}
+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;