wgpui_base/input/editor/display_map/
display_map.rs1use std::ops::Range;
8
9use ropey::Rope;
10use wgpui::{App, Font, Pixels};
11
12use super::fold_map::FoldMap;
13use super::folding::FoldRange;
14pub use super::text_wrapper::WrappingIndent;
15use super::text_wrapper::{LineItem, WrapDisplayPoint};
16use super::wrap_map::WrapMap;
17use super::{BufferPoint, DisplayPoint};
18use crate::input::Point as TreeSitterPoint;
19use crate::input::display_map::WrapPoint;
20use crate::input::rope_ext::RopeExt as _;
21
22pub struct DisplayMap {
30 wrap_map: WrapMap,
31 fold_map: FoldMap,
32}
33
34impl DisplayMap {
35 pub fn new(font: Font, font_size: Pixels, wrap_width: Option<Pixels>) -> Self {
36 Self {
37 wrap_map: WrapMap::new(font, font_size, wrap_width),
38 fold_map: FoldMap::new(),
39 }
40 }
41
42 pub fn buffer_pos_to_display_pos(&self, pos: BufferPoint) -> DisplayPoint {
46 let wrap_pos = self.wrap_map.buffer_pos_to_wrap_pos(pos);
48
49 if let Some(display_row) = self.fold_map.wrap_row_to_display_row(wrap_pos.row) {
51 DisplayPoint::new(display_row, wrap_pos.col)
52 } else {
53 let display_row = self.fold_map.nearest_visible_display_row(wrap_pos.row);
55 DisplayPoint::new(display_row, 0) }
57 }
58
59 pub fn display_pos_to_buffer_pos(&self, pos: DisplayPoint) -> BufferPoint {
61 let wrap_row = self.fold_map.display_row_to_wrap_row(pos.row).unwrap_or(0);
63
64 let wrap_pos = WrapPoint::new(wrap_row, pos.col);
66 self.wrap_map.wrap_pos_to_buffer_pos(wrap_pos)
67 }
68
69 #[inline]
71 pub fn display_row_count(&self) -> usize {
72 self.fold_map.display_row_count()
73 }
74
75 pub fn display_row_to_buffer_line(&self, display_row: usize) -> usize {
77 let wrap_row = self
79 .fold_map
80 .display_row_to_wrap_row(display_row)
81 .unwrap_or(0);
82
83 self.wrap_map.wrap_row_to_buffer_line(wrap_row)
85 }
86
87 pub fn buffer_line_to_display_row_range(&self, line: usize) -> Option<Range<usize>> {
90 let wrap_row_range = self.wrap_map.buffer_line_to_wrap_row_range(line);
92
93 let mut first_display_row = None;
95 let mut last_display_row = None;
96
97 for wrap_row in wrap_row_range {
98 if let Some(display_row) = self.fold_map.wrap_row_to_display_row(wrap_row) {
99 if first_display_row.is_none() {
100 first_display_row = Some(display_row);
101 }
102 last_display_row = Some(display_row);
103 }
104 }
105
106 if let (Some(start), Some(end)) = (first_display_row, last_display_row) {
107 Some(start..end + 1)
108 } else {
109 None }
111 }
112
113 #[inline]
115 pub fn is_buffer_line_hidden(&self, line: usize) -> bool {
116 self.buffer_line_to_display_row_range(line).is_none()
117 }
118
119 pub fn buffer_line_to_display_row(&self, line: usize) -> usize {
122 match self.buffer_line_to_display_row_range(line) {
123 Some(range) => range.start,
124 None => {
125 let wrap_row = self.wrap_map.buffer_line_to_first_wrap_row(line);
126 self.fold_map.nearest_visible_display_row(wrap_row)
127 }
128 }
129 }
130
131 pub fn set_fold_candidates(&mut self, candidates: Vec<FoldRange>) {
133 self.fold_map.set_candidates(candidates);
134 self.rebuild_fold_projection();
135 }
136
137 pub fn set_folded(&mut self, start_line: usize, folded: bool) {
139 self.fold_map.set_folded(start_line, folded);
140 self.rebuild_fold_projection();
141 }
142
143 pub fn toggle_fold(&mut self, start_line: usize) {
145 self.fold_map.toggle_fold(start_line);
146 self.rebuild_fold_projection();
147 }
148
149 #[inline]
151 pub fn is_folded_at(&self, start_line: usize) -> bool {
152 self.fold_map.is_folded_at(start_line)
153 }
154
155 #[inline]
157 pub fn is_fold_candidate(&self, start_line: usize) -> bool {
158 self.fold_map.is_fold_candidate(start_line)
159 }
160
161 #[inline]
163 pub fn folded_ranges(&self) -> &[FoldRange] {
164 self.fold_map.folded_ranges()
165 }
166
167 pub fn clear_folds(&mut self) {
169 self.fold_map.clear_folds();
170 self.rebuild_fold_projection();
171 }
172
173 pub fn adjust_folds_for_edit(&mut self, old_text: &Rope, range: &Range<usize>, new_text: &str) {
180 if self.fold_map.folded_ranges().is_empty() && self.fold_map.fold_candidates().is_empty() {
181 return;
182 }
183
184 let edit_start_line = old_text.offset_to_point(range.start).row;
185 let edit_end_line = old_text
186 .offset_to_point(range.end.min(old_text.len_bytes()))
187 .row;
188
189 let old_lines_in_range = edit_end_line.saturating_sub(edit_start_line);
190 let new_lines_in_range = new_text.chars().filter(|c| *c == '\n').count();
191 let line_delta = new_lines_in_range as isize - old_lines_in_range as isize;
192
193 self.fold_map
194 .adjust_folds_for_edit(edit_start_line, edit_end_line, line_delta);
195 }
196
197 pub fn update_fold_candidates_for_edit(
202 &mut self,
203 extract_fold_ranges: impl FnOnce(Range<usize>, &Rope) -> Vec<FoldRange>,
204 edit_byte_range: Range<usize>,
205 new_text: &Rope,
206 ) {
207 let new_start_line = new_text.offset_to_point(edit_byte_range.start).row;
208 let new_end_line = new_text
209 .offset_to_point(edit_byte_range.end.min(new_text.len_bytes()))
210 .row;
211
212 let new_candidates = extract_fold_ranges(edit_byte_range, new_text);
213 self.fold_map
214 .merge_candidates_for_edit(new_start_line, new_end_line, new_candidates);
215 }
216
217 pub fn on_text_changed(
219 &mut self,
220 changed_text: &Rope,
221 range: &Range<usize>,
222 new_text: &Rope,
223 cx: &mut App,
224 ) {
225 self.wrap_map
226 .on_text_changed(changed_text, range, new_text, cx);
227 self.rebuild_fold_projection();
228 }
229
230 pub(crate) fn set_inline_metrics(
232 &mut self,
233 metrics: std::rc::Rc<[(std::ops::Range<usize>, Pixels)]>,
234 cx: &mut App,
235 ) {
236 self.wrap_map.set_inline_metrics(metrics, cx);
237 self.rebuild_fold_projection();
238 }
239
240 pub fn on_layout_changed(&mut self, wrap_width: Option<Pixels>, cx: &mut App) {
241 self.wrap_map.on_layout_changed(wrap_width, cx);
242 self.rebuild_fold_projection();
243 }
244
245 pub fn set_wrapping_indent(&mut self, wrapping_indent: WrappingIndent, cx: &mut App) {
247 self.wrap_map.set_wrapping_indent(wrapping_indent, cx);
248 self.rebuild_fold_projection();
249 }
250
251 pub(crate) fn set_tab_size(&mut self, tab_size: usize, cx: &mut App) {
253 if self.wrap_map.set_tab_size(tab_size, cx) {
254 self.rebuild_fold_projection();
255 }
256 }
257
258 pub fn set_font(&mut self, font: Font, font_size: Pixels, cx: &mut App) {
260 self.wrap_map.set_font(font, font_size, cx);
261 self.rebuild_fold_projection();
262 }
263
264 pub fn ensure_text_prepared(&mut self, text: &Rope, cx: &mut App) {
266 let did_initialize = self.wrap_map.ensure_text_prepared(text, cx);
267 if did_initialize {
268 self.rebuild_fold_projection();
269 }
270 }
271
272 pub fn set_text(&mut self, text: &Rope, cx: &mut App) {
274 self.wrap_map.set_text(text, cx);
275 self.rebuild_fold_projection();
276 }
277
278 fn rebuild_fold_projection(&mut self) {
283 if !self.fold_map.folded_ranges().is_empty() {
284 self.fold_map.rebuild(&self.wrap_map);
285 } else {
286 self.fold_map
289 .mark_dirty_with_wrap_count(self.wrap_map.wrap_row_count());
290 }
291 }
292
293 #[inline]
297 pub(crate) fn offset_to_wrap_display_point(&self, offset: usize) -> WrapDisplayPoint {
298 self.wrap_map.wrapper().offset_to_display_point(offset)
299 }
300
301 #[inline]
304 pub(crate) fn offset_to_wrap_display_point_with_affinity(
305 &self,
306 offset: usize,
307 line_end_affinity: bool,
308 ) -> WrapDisplayPoint {
309 self.wrap_map
310 .wrapper()
311 .offset_to_display_point_with_affinity(offset, line_end_affinity)
312 }
313
314 pub(crate) fn offset_to_display_row(&self, offset: usize, line_end_affinity: bool) -> usize {
316 let point = self.offset_to_wrap_display_point_with_affinity(offset, line_end_affinity);
317 self.wrap_row_to_display_row(point.row)
318 .unwrap_or_else(|| self.nearest_visible_display_row(point.row))
319 }
320
321 #[inline]
323 pub(crate) fn wrap_display_point_to_offset(&self, point: WrapDisplayPoint) -> usize {
324 self.wrap_map.wrapper().display_point_to_offset(point)
325 }
326
327 #[inline]
329 pub(crate) fn wrap_display_point_to_point(&self, point: WrapDisplayPoint) -> TreeSitterPoint {
330 self.wrap_map.wrapper().display_point_to_point(point)
331 }
332
333 #[inline]
336 pub fn wrap_row_to_display_row(&self, wrap_row: usize) -> Option<usize> {
337 self.fold_map.wrap_row_to_display_row(wrap_row)
338 }
339
340 #[inline]
342 pub fn nearest_visible_display_row(&self, wrap_row: usize) -> usize {
343 self.fold_map.nearest_visible_display_row(wrap_row)
344 }
345
346 #[inline]
348 pub fn display_row_to_wrap_row(&self, display_row: usize) -> Option<usize> {
349 self.fold_map.display_row_to_wrap_row(display_row)
350 }
351
352 pub(crate) fn display_row_column_to_offset(&self, display_row: usize, column: usize) -> usize {
353 let wrap_row = self
354 .fold_map
355 .display_row_to_wrap_row(display_row)
356 .unwrap_or(0);
357 self.wrap_map
358 .wrapper()
359 .display_point_to_offset(WrapDisplayPoint::new(wrap_row, 0, column))
360 }
361
362 #[inline]
364 pub(crate) fn longest_row(&self) -> usize {
365 self.wrap_map.wrapper().longest_row()
366 }
367
368 #[inline]
372 pub(crate) fn line(&self, row: usize) -> Option<&LineItem> {
373 self.wrap_map.line(row)
374 }
375
376 #[inline]
378 pub fn text(&self) -> &Rope {
379 self.wrap_map.text()
380 }
381
382 #[inline]
384 pub fn visible_wrap_row_count_for_buffer_line(&self, line: usize) -> usize {
385 self.wrap_map
386 .visible_wrap_row_count_for_line(line, &self.fold_map)
387 }
388
389 #[inline]
391 pub fn wrap_row_count(&self) -> usize {
392 self.wrap_map.wrap_row_count()
393 }
394
395 #[inline]
397 pub fn buffer_line_count(&self) -> usize {
398 self.wrap_map.buffer_line_count()
399 }
400}