git.iko.soy/helix
on 2158366 help sign in
helix/helix-view/src/view.rs
365 lines 11 kB history raw
1use std::borrow::Cow;
3use crate::{graphics::Rect, Document, DocumentId, ViewId};
4use helix_core::{
5 coords_at_pos,
6 graphemes::{grapheme_width, RopeGraphemes},
7 line_ending::line_end_char_index,
8 Position, RopeSlice, Selection,
9};
11type Jump = (DocumentId, Selection);
13#[derive(Debug, Clone)]
14pub struct JumpList {
15 jumps: Vec<Jump>,
16 current: usize,
19impl JumpList {
20 pub fn new(initial: Jump) -> Self {
21 Self {
22 jumps: vec![initial],
23 current: 0,
24 }
25 }
27 pub fn push(&mut self, jump: Jump) {
28 self.jumps.truncate(self.current);
29 // don't push duplicates
30 if self.jumps.last() != Some(&jump) {
31 self.jumps.push(jump);
32 self.current = self.jumps.len();
33 }
34 }
36 pub fn forward(&mut self, count: usize) -> Option<&Jump> {
37 if self.current + count < self.jumps.len() {
38 self.current += count;
39 self.jumps.get(self.current)
40 } else {
41 None
42 }
43 }
45 // Taking view and doc to prevent unnecessary cloning when jump is not required.
46 pub fn backward(&mut self, view_id: ViewId, doc: &mut Document, count: usize) -> Option<&Jump> {
47 if let Some(current) = self.current.checked_sub(count) {
48 if self.current == self.jumps.len() {
49 let jump = (doc.id(), doc.selection(view_id).clone());
50 self.push(jump);
51 }
52 self.current = current;
53 self.jumps.get(self.current)
54 } else {
55 None
56 }
57 }
60#[derive(Debug)]
61pub struct View {
62 pub id: ViewId,
63 pub doc: DocumentId,
64 pub offset: Position,
65 pub area: Rect,
66 pub jumps: JumpList,
67 /// the last accessed file before the current one
68 pub last_accessed_doc: Option<DocumentId>,
71impl View {
72 pub fn new(doc: DocumentId) -> Self {
73 Self {
74 id: ViewId::default(),
75 doc,
76 offset: Position::new(0, 0),
77 area: Rect::default(), // will get calculated upon inserting into tree
78 jumps: JumpList::new((doc, Selection::point(0))), // TODO: use actual sel
79 last_accessed_doc: None,
80 }
81 }
83 pub fn inner_area(&self) -> Rect {
84 // TODO: not ideal
85 const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter
86 Rect::new(
87 self.area.x + OFFSET,
88 self.area.y,
89 self.area.width - OFFSET,
90 self.area.height.saturating_sub(1), // -1 for statusline
91 )
92 }
94 pub fn ensure_cursor_in_view(&mut self, doc: &Document, scrolloff: usize) {
95 let cursor = doc
96 .selection(self.id)
97 .primary()
98 .cursor(doc.text().slice(..));
99 let Position { col, row: line } = coords_at_pos(doc.text().slice(..), cursor);
100 let inner_area = self.inner_area();
101 let last_line = (self.offset.row + inner_area.height as usize).saturating_sub(1);
103 // - 1 so we have at least one gap in the middle.
104 // a height of 6 with padding of 3 on each side will keep shifting the view back and forth
105 // as we type
106 let scrolloff = scrolloff.min(inner_area.height.saturating_sub(1) as usize / 2);
108 let last_col = self.offset.col + inner_area.width.saturating_sub(1) as usize;
110 if line > last_line.saturating_sub(scrolloff) {
111 // scroll down
112 self.offset.row += line - (last_line.saturating_sub(scrolloff));
113 } else if line < self.offset.row + scrolloff {
114 // scroll up
115 self.offset.row = line.saturating_sub(scrolloff);
116 }
118 if col > last_col.saturating_sub(scrolloff) {
119 // scroll right
120 self.offset.col += col - (last_col.saturating_sub(scrolloff));
121 } else if col < self.offset.col + scrolloff {
122 // scroll left
123 self.offset.col = col.saturating_sub(scrolloff);
124 }
125 }
127 /// Calculates the last visible line on screen
128 #[inline]
129 pub fn last_line(&self, doc: &Document) -> usize {
130 let height = self.inner_area().height;
131 std::cmp::min(
132 // Saturating subs to make it inclusive zero indexing.
133 (self.offset.row + height as usize).saturating_sub(1),
134 doc.text().len_lines().saturating_sub(1),
135 )
136 }
138 /// Translates a document position to an absolute position in the terminal.
139 /// Returns a (line, col) position if the position is visible on screen.
140 // TODO: Could return width as well for the character width at cursor.
141 pub fn screen_coords_at_pos(
142 &self,
143 doc: &Document,
144 text: RopeSlice,
145 pos: usize,
146 ) -> Option<Position> {
147 let line = text.char_to_line(pos);
149 if line < self.offset.row || line > self.last_line(doc) {
150 // Line is not visible on screen
151 return None;
152 }
154 let line_start = text.line_to_char(line);
155 let line_slice = text.slice(line_start..pos);
156 let mut col = 0;
157 let tab_width = doc.tab_width();
159 for grapheme in RopeGraphemes::new(line_slice) {
160 if grapheme == "\t" {
161 col += tab_width;
162 } else {
163 let grapheme = Cow::from(grapheme);
164 col += grapheme_width(&grapheme);
165 }
166 }
168 // It is possible for underflow to occur if the buffer length is larger than the terminal width.
169 let row = line.saturating_sub(self.offset.row);
170 let col = col.saturating_sub(self.offset.col);
172 Some(Position::new(row, col))
173 }
175 pub fn text_pos_at_screen_coords(
176 &self,
177 text: &RopeSlice,
178 row: u16,
179 column: u16,
180 tab_width: usize,
181 ) -> Option<usize> {
182 let inner = self.inner_area();
183 // 1 for status
184 if row < inner.top() || row >= inner.bottom() {
185 return None;
186 }
188 if column < inner.left() || column > inner.right() {
189 return None;
190 }
192 let line_number = (row - inner.y) as usize + self.offset.row;
194 if line_number > text.len_lines() - 1 {
195 return Some(text.len_chars());
196 }
198 let mut pos = text.line_to_char(line_number);
200 let current_line = text.line(line_number);
202 let target = (column - inner.x) as usize + self.offset.col;
203 let mut selected = 0;
205 for grapheme in RopeGraphemes::new(current_line) {
206 if selected >= target {
207 break;
208 }
209 if grapheme == "\t" {
210 selected += tab_width;
211 } else {
212 let width = grapheme_width(&Cow::from(grapheme));
213 selected += width;
214 }
215 pos += grapheme.chars().count();
216 }
218 Some(pos.min(line_end_char_index(&text.slice(..), line_number)))
219 }
221 /// Translates a screen position to position in the text document.
222 /// Returns a usize typed position in bounds of the text if found in this view, None if out of view.
223 pub fn pos_at_screen_coords(&self, doc: &Document, row: u16, column: u16) -> Option<usize> {
224 self.text_pos_at_screen_coords(&doc.text().slice(..), row, column, doc.tab_width())
225 }
226 // pub fn traverse<F>(&self, text: RopeSlice, start: usize, end: usize, fun: F)
227 // where
228 // F: Fn(usize, usize),
229 // {
230 // let start = self.screen_coords_at_pos(text, start);
231 // let end = self.screen_coords_at_pos(text, end);
233 // match (start, end) {
234 // // fully on screen
235 // (Some(start), Some(end)) => {
236 // // we want to calculate ends of lines for each char..
237 // }
238 // // from start to end of screen
239 // (Some(start), None) => {}
240 // // from start of screen to end
241 // (None, Some(end)) => {}
242 // // not on screen
243 // (None, None) => return,
244 // }
245 // }
248#[cfg(test)]
249mod tests {
250 use super::*;
251 use helix_core::Rope;
252 const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter
254 #[test]
255 fn test_text_pos_at_screen_coords() {
256 let mut view = View::new(DocumentId::default());
257 view.area = Rect::new(40, 40, 40, 40);
258 let rope = Rope::from_str("abc\n\tdef");
259 let text = rope.slice(..);
261 assert_eq!(view.text_pos_at_screen_coords(&text, 40, 2, 4), None);
263 assert_eq!(view.text_pos_at_screen_coords(&text, 40, 41, 4), None);
265 assert_eq!(view.text_pos_at_screen_coords(&text, 0, 2, 4), None);
267 assert_eq!(view.text_pos_at_screen_coords(&text, 0, 49, 4), None);
269 assert_eq!(view.text_pos_at_screen_coords(&text, 0, 41, 4), None);
271 assert_eq!(view.text_pos_at_screen_coords(&text, 40, 81, 4), None);
273 assert_eq!(view.text_pos_at_screen_coords(&text, 78, 41, 4), None);
275 assert_eq!(
276 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 3, 4),
277 Some(3)
278 );
280 assert_eq!(view.text_pos_at_screen_coords(&text, 40, 80, 4), Some(3));
282 assert_eq!(
283 view.text_pos_at_screen_coords(&text, 41, 40 + OFFSET + 1, 4),
284 Some(5)
285 );
287 assert_eq!(
288 view.text_pos_at_screen_coords(&text, 41, 40 + OFFSET + 4, 4),
289 Some(5)
290 );
292 assert_eq!(
293 view.text_pos_at_screen_coords(&text, 41, 40 + OFFSET + 7, 4),
294 Some(8)
295 );
297 assert_eq!(view.text_pos_at_screen_coords(&text, 41, 80, 4), Some(8));
298 }
300 #[test]
301 fn test_text_pos_at_screen_coords_cjk() {
302 let mut view = View::new(DocumentId::default());
303 view.area = Rect::new(40, 40, 40, 40);
304 let rope = Rope::from_str("Hi! こんにちは皆さん");
305 let text = rope.slice(..);
307 assert_eq!(
308 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 0, 4),
309 Some(0)
310 );
312 assert_eq!(
313 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 5, 4),
314 Some(5)
315 );
317 assert_eq!(
318 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 6, 4),
319 Some(5)
320 );
322 assert_eq!(
323 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 7, 4),
324 Some(6)
325 );
327 assert_eq!(
328 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 8, 4),
329 Some(6)
330 );
331 }
333 #[test]
334 fn test_text_pos_at_screen_coords_graphemes() {
335 let mut view = View::new(DocumentId::default());
336 view.area = Rect::new(40, 40, 40, 40);
337 let rope = Rope::from_str("Hèl̀l̀ò world!");
338 let text = rope.slice(..);
340 assert_eq!(
341 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 0, 4),
342 Some(0)
343 );
345 assert_eq!(
346 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 1, 4),
347 Some(1)
348 );
350 assert_eq!(
351 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 2, 4),
352 Some(3)
353 );
355 assert_eq!(
356 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 3, 4),
357 Some(5)
358 );
360 assert_eq!(
361 view.text_pos_at_screen_coords(&text, 40, 40 + OFFSET + 4, 4),
362 Some(7)
363 );
364 }