diff --git a/Cargo.lock b/Cargo.lock index c4f795b9d..e7ec29589 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -59,6 +59,12 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" +[[package]] +name = "cassowary" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53" + [[package]] name = "cc" version = "1.0.54" @@ -176,6 +182,12 @@ dependencies = [ "winapi", ] +[[package]] +name = "either" +version = "1.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3" + [[package]] name = "futf" version = "0.1.4" @@ -298,6 +310,8 @@ dependencies = [ "ropey", "smallvec", "tendril", + "unicode-segmentation", + "unicode-width", ] [[package]] @@ -312,6 +326,7 @@ dependencies = [ "num_cpus", "piper", "smol", + "tui", ] [[package]] @@ -323,6 +338,15 @@ dependencies = [ "libc", ] +[[package]] +name = "itertools" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b" +dependencies = [ + "either", +] + [[package]] name = "lazy_static" version = "1.4.0" @@ -651,12 +675,32 @@ dependencies = [ "utf-8", ] +[[package]] +name = "tui" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9533d39bef0ae8f510e8a99d78702e68d1bbf0b98a78ec9740509d287010ae1e" +dependencies = [ + "bitflags", + "cassowary", + "either", + "itertools", + "unicode-segmentation", + "unicode-width", +] + [[package]] name = "unicode-segmentation" version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0" +[[package]] +name = "unicode-width" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "caaa9d531767d1ff2150b9332433f32a24622147e5ebb1f26409d5da67afd479" + [[package]] name = "unicode-xid" version = "0.2.0" diff --git a/helix-core/Cargo.toml b/helix-core/Cargo.toml index fc6a1b530..fda4e5d9a 100644 --- a/helix-core/Cargo.toml +++ b/helix-core/Cargo.toml @@ -12,4 +12,6 @@ ropey = { git = "https://github.com/cessen/ropey" } anyhow = "1.0.31" smallvec = "1.4.0" tendril = { git = "https://github.com/servo/tendril" } +unicode-segmentation = "1.6.0" +unicode-width = "0.1.7" # slab = "0.4.2" diff --git a/helix-core/src/graphemes.rs b/helix-core/src/graphemes.rs new file mode 100644 index 000000000..ec4e9d243 --- /dev/null +++ b/helix-core/src/graphemes.rs @@ -0,0 +1,213 @@ +// Based on https://github.com/cessen/led/blob/c4fa72405f510b7fd16052f90a598c429b3104a6/src/graphemes.rs +use ropey::{iter::Chunks, str_utils::byte_to_char_idx, RopeSlice}; +use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete}; +use unicode_width::UnicodeWidthStr; + +pub fn grapheme_width(g: &str) -> usize { + if g.as_bytes()[0] <= 127 { + // Fast-path ascii. + // Point 1: theoretically, ascii control characters should have zero + // width, but in our case we actually want them to have width: if they + // show up in text, we want to treat them as textual elements that can + // be editied. So we can get away with making all ascii single width + // here. + // Point 2: we're only examining the first codepoint here, which means + // we're ignoring graphemes formed with combining characters. However, + // if it starts with ascii, it's going to be a single-width grapeheme + // regardless, so, again, we can get away with that here. + // Point 3: we're only examining the first _byte_. But for utf8, when + // checking for ascii range values only, that works. + 1 + } else { + // We use max(1) here because all grapeheme clusters--even illformed + // ones--should have at least some width so they can be edited + // properly. + UnicodeWidthStr::width(g).max(1) + } +} + +pub fn nth_prev_grapheme_boundary(slice: &RopeSlice, char_idx: usize, n: usize) -> usize { + // TODO: implement this more efficiently. This has to do a lot of + // re-scanning of rope chunks. Probably move the main implementation here, + // and have prev_grapheme_boundary call this instead. + let mut char_idx = char_idx; + for _ in 0..n { + char_idx = prev_grapheme_boundary(slice, char_idx); + } + char_idx +} + +/// Finds the previous grapheme boundary before the given char position. +pub fn prev_grapheme_boundary(slice: &RopeSlice, char_idx: usize) -> usize { + // Bounds check + debug_assert!(char_idx <= slice.len_chars()); + + // We work with bytes for this, so convert. + let byte_idx = slice.char_to_byte(char_idx); + + // Get the chunk with our byte index in it. + let (mut chunk, mut chunk_byte_idx, mut chunk_char_idx, _) = slice.chunk_at_byte(byte_idx); + + // Set up the grapheme cursor. + let mut gc = GraphemeCursor::new(byte_idx, slice.len_bytes(), true); + + // Find the previous grapheme cluster boundary. + loop { + match gc.prev_boundary(chunk, chunk_byte_idx) { + Ok(None) => return 0, + Ok(Some(n)) => { + let tmp = byte_to_char_idx(chunk, n - chunk_byte_idx); + return chunk_char_idx + tmp; + } + Err(GraphemeIncomplete::PrevChunk) => { + let (a, b, c, _) = slice.chunk_at_byte(chunk_byte_idx - 1); + chunk = a; + chunk_byte_idx = b; + chunk_char_idx = c; + } + Err(GraphemeIncomplete::PreContext(n)) => { + let ctx_chunk = slice.chunk_at_byte(n - 1).0; + gc.provide_context(ctx_chunk, n - ctx_chunk.len()); + } + _ => unreachable!(), + } + } +} + +pub fn nth_next_grapheme_boundary(slice: &RopeSlice, char_idx: usize, n: usize) -> usize { + // TODO: implement this more efficiently. This has to do a lot of + // re-scanning of rope chunks. Probably move the main implementation here, + // and have next_grapheme_boundary call this instead. + let mut char_idx = char_idx; + for _ in 0..n { + char_idx = next_grapheme_boundary(slice, char_idx); + } + char_idx +} + +/// Finds the next grapheme boundary after the given char position. +pub fn next_grapheme_boundary(slice: &RopeSlice, char_idx: usize) -> usize { + // Bounds check + debug_assert!(char_idx <= slice.len_chars()); + + // We work with bytes for this, so convert. + let byte_idx = slice.char_to_byte(char_idx); + + // Get the chunk with our byte index in it. + let (mut chunk, mut chunk_byte_idx, mut chunk_char_idx, _) = slice.chunk_at_byte(byte_idx); + + // Set up the grapheme cursor. + let mut gc = GraphemeCursor::new(byte_idx, slice.len_bytes(), true); + + // Find the next grapheme cluster boundary. + loop { + match gc.next_boundary(chunk, chunk_byte_idx) { + Ok(None) => return slice.len_chars(), + Ok(Some(n)) => { + let tmp = byte_to_char_idx(chunk, n - chunk_byte_idx); + return chunk_char_idx + tmp; + } + Err(GraphemeIncomplete::NextChunk) => { + chunk_byte_idx += chunk.len(); + let (a, _, c, _) = slice.chunk_at_byte(chunk_byte_idx); + chunk = a; + chunk_char_idx = c; + } + Err(GraphemeIncomplete::PreContext(n)) => { + let ctx_chunk = slice.chunk_at_byte(n - 1).0; + gc.provide_context(ctx_chunk, n - ctx_chunk.len()); + } + _ => unreachable!(), + } + } +} + +/// Returns whether the given char position is a grapheme boundary. +pub fn is_grapheme_boundary(slice: &RopeSlice, char_idx: usize) -> bool { + // Bounds check + debug_assert!(char_idx <= slice.len_chars()); + + // We work with bytes for this, so convert. + let byte_idx = slice.char_to_byte(char_idx); + + // Get the chunk with our byte index in it. + let (chunk, chunk_byte_idx, _, _) = slice.chunk_at_byte(byte_idx); + + // Set up the grapheme cursor. + let mut gc = GraphemeCursor::new(byte_idx, slice.len_bytes(), true); + + // Determine if the given position is a grapheme cluster boundary. + loop { + match gc.is_boundary(chunk, chunk_byte_idx) { + Ok(n) => return n, + Err(GraphemeIncomplete::PreContext(n)) => { + let (ctx_chunk, ctx_byte_start, _, _) = slice.chunk_at_byte(n - 1); + gc.provide_context(ctx_chunk, ctx_byte_start); + } + _ => unreachable!(), + } + } +} + +/// An iterator over the graphemes of a RopeSlice. +#[derive(Clone)] +pub struct RopeGraphemes<'a> { + text: RopeSlice<'a>, + chunks: Chunks<'a>, + cur_chunk: &'a str, + cur_chunk_start: usize, + cursor: GraphemeCursor, +} + +impl<'a> RopeGraphemes<'a> { + pub fn new<'b>(slice: &RopeSlice<'b>) -> RopeGraphemes<'b> { + let mut chunks = slice.chunks(); + let first_chunk = chunks.next().unwrap_or(""); + RopeGraphemes { + text: *slice, + chunks: chunks, + cur_chunk: first_chunk, + cur_chunk_start: 0, + cursor: GraphemeCursor::new(0, slice.len_bytes(), true), + } + } +} + +impl<'a> Iterator for RopeGraphemes<'a> { + type Item = RopeSlice<'a>; + + fn next(&mut self) -> Option> { + let a = self.cursor.cur_cursor(); + let b; + loop { + match self + .cursor + .next_boundary(self.cur_chunk, self.cur_chunk_start) + { + Ok(None) => { + return None; + } + Ok(Some(n)) => { + b = n; + break; + } + Err(GraphemeIncomplete::NextChunk) => { + self.cur_chunk_start += self.cur_chunk.len(); + self.cur_chunk = self.chunks.next().unwrap_or(""); + } + _ => unreachable!(), + } + } + + if a < self.cur_chunk_start { + let a_char = self.text.byte_to_char(a); + let b_char = self.text.byte_to_char(b); + + Some(self.text.slice(a_char..b_char)) + } else { + let a2 = a - self.cur_chunk_start; + let b2 = b - self.cur_chunk_start; + Some((&self.cur_chunk[a2..b2]).into()) + } + } +} diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs index 421d8f3cb..d2c78d3fc 100644 --- a/helix-core/src/lib.rs +++ b/helix-core/src/lib.rs @@ -1,4 +1,5 @@ mod buffer; +mod graphemes; mod selection; mod state; mod transaction; diff --git a/helix-core/src/selection.rs b/helix-core/src/selection.rs index 98bbdb7fa..b02560a82 100644 --- a/helix-core/src/selection.rs +++ b/helix-core/src/selection.rs @@ -99,8 +99,8 @@ impl Range { /// A selection consists of one or more selection ranges. pub struct Selection { // TODO: decide how many ranges to inline SmallVec<[Range; 1]> - ranges: SmallVec<[Range; 1]>, - primary_index: usize, + pub(crate) ranges: SmallVec<[Range; 1]>, + pub(crate) primary_index: usize, } impl Selection { diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 22de6ca7f..682d298a7 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -1,17 +1,30 @@ -use crate::{Buffer, Selection}; +use crate::graphemes::{nth_next_grapheme_boundary, nth_prev_grapheme_boundary}; +use crate::{Buffer, Selection, SelectionRange}; /// A state represents the current editor state of a single buffer. pub struct State { - // TODO: maybe doc: ? - buffer: Buffer, + doc: Buffer, selection: Selection, } +#[derive(Copy, Clone, PartialEq, Eq)] +pub enum Direction { + Forward, + Backward, +} +#[derive(Copy, Clone, PartialEq, Eq)] +pub enum Granularity { + Character, + Word, + Line, + // LineBoundary +} + impl State { #[must_use] - pub fn new(buffer: Buffer) -> Self { + pub fn new(doc: Buffer) -> Self { Self { - buffer, + doc, selection: Selection::single(0, 0), } } @@ -40,4 +53,67 @@ impl State { // syntax // foldable // changeFilter/transactionFilter + + pub fn move_pos( + &self, + pos: usize, + dir: Direction, + granularity: Granularity, + n: usize, + ) -> usize { + let text = &self.doc.contents; + match (dir, granularity) { + (Direction::Backward, Granularity::Character) => { + nth_prev_grapheme_boundary(&text.slice(..), pos, n) + } + (Direction::Forward, Granularity::Character) => { + nth_next_grapheme_boundary(&text.slice(..), pos, n) + } + _ => pos, + } + } + + pub fn move_selection( + &self, + sel: Selection, + dir: Direction, + granularity: Granularity, + // TODO: n + ) -> Selection { + // TODO: move all selections according to normal cursor move semantics by collapsing it + // into cursors and moving them vertically + + let ranges = sel.ranges.into_iter().map(|range| { + // let pos = if !range.is_empty() { + // // if selection already exists, bump it to the start or end of current select first + // if dir == Direction::Backward { + // range.from() + // } else { + // range.to() + // } + // } else { + let pos = self.move_pos(range.head, dir, granularity, 1) + // }; + SelectionRange::new(pos, pos) + }); + + Selection::new(ranges.collect(), sel.primary_index) + // TODO: update selection in state via transaction + } + + pub fn extend_selection( + &self, + sel: Selection, + dir: Direction, + granularity: Granularity, + n: usize, + ) -> Selection { + let ranges = sel.ranges.into_iter().map(|range| { + let pos = self.move_pos(range.head, dir, granularity, n); + SelectionRange::new(range.anchor, pos) + }); + + Selection::new(ranges.collect(), sel.primary_index) + // TODO: update selection in state via transaction + } } diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml index 0ab6209e3..bd488d2fb 100644 --- a/helix-term/Cargo.toml +++ b/helix-term/Cargo.toml @@ -29,3 +29,4 @@ futures = { version = "0.3.5", default-features = false, features = ["std"] } smol = "0.1.10" num_cpus = "1.13.0" piper = "0.1.2" +tui = { version = "0.9.5", default-features = false } diff --git a/helix-term/src/component.rs b/helix-term/src/component.rs new file mode 100644 index 000000000..8ec5663a3 --- /dev/null +++ b/helix-term/src/component.rs @@ -0,0 +1,18 @@ + +// IDEA: render to a cache buffer, then if not changed, copy the buf into the parent +pub trait Component { + /// Process input events, return true if handled. + fn process_event(&mut self, event: crossterm::event::Event, args) -> bool; + /// Should redraw? Useful for saving redraw cycles if we know component didn't change. + fn should_update(&self) -> bool { true } + + fn render(&mut self, surface: &mut Surface, args: ()); +} + +// HStack / VStack +// focus by component id: each View/Editor gets it's own incremental id at create +// Component: View(Arc) -> multiple views can point to same state +// id 0 = prompt? +// when entering to prompt, it needs to direct Commands to last focus window +// -> prompt.trigger(focus_id), on_leave -> focus(focus_id) +// popups on another layer diff --git a/helix-term/src/editor.rs b/helix-term/src/editor.rs index 54c70e1bd..111c32731 100644 --- a/helix-term/src/editor.rs +++ b/helix-term/src/editor.rs @@ -278,4 +278,11 @@ impl Editor { println!("The text you entered: {}", typed_text); Ok(()) } + + pub fn render(&self) { + // create a new window sized surface + // paint all components + // diff vs last frame, swap + // paint diff + } } diff --git a/helix-term/src/line.rs b/helix-term/src/line.rs index 58d4c9d8e..7cbfab617 100644 --- a/helix-term/src/line.rs +++ b/helix-term/src/line.rs @@ -11,6 +11,8 @@ use futures::{future::FutureExt, select, StreamExt}; use smol::Timer; // use futures_timer::Delay; +use tui::{backend::CrosstermBackend, Terminal}; + use crossterm::{ cursor::position, event::{DisableMouseCapture, EnableMouseCapture, Event, EventStream, KeyCode}, @@ -64,6 +66,9 @@ fn main() -> Result<()> { let mut stdout = stdout(); execute!(stdout, EnableMouseCapture)?; + let backend = CrosstermBackend::new(stdout); + let mut terminal = Terminal::new(backend)?; + use std::thread; // Same number of threads as there are CPU cores. diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs index aaa83a862..e21fc7d7a 100644 --- a/helix-term/src/main.rs +++ b/helix-term/src/main.rs @@ -1,4 +1,5 @@ // mod editor; +mod component; // use editor::Editor;