use crate::buffer::TextBuffer;
use std::cmp::Ordering;
use std::collections::HashSet;
use std::ops::Range;
use crate::canvas_editor::{compare_floats, measure_char_width};
#[derive(Debug, Clone, PartialEq)]
pub struct VisualLine {
pub logical_line: usize,
pub segment_index: usize,
pub start_col: usize,
pub end_col: usize,
}
impl VisualLine {
pub fn new(
logical_line: usize,
segment_index: usize,
start_col: usize,
end_col: usize,
) -> Self {
Self { logical_line, segment_index, start_col, end_col }
}
pub fn is_first_segment(&self) -> bool {
self.segment_index == 0
}
pub fn len(&self) -> usize {
self.end_col - self.start_col
}
}
pub struct WrappingCalculator {
wrap_enabled: bool,
wrap_column: Option<usize>,
full_char_width: f32,
char_width: f32,
}
impl WrappingCalculator {
pub fn new(
wrap_enabled: bool,
wrap_column: Option<usize>,
full_char_width: f32,
char_width: f32,
) -> Self {
Self { wrap_enabled, wrap_column, full_char_width, char_width }
}
pub fn calculate_visual_lines(
&self,
text_buffer: &TextBuffer,
viewport_width: f32,
gutter_width: f32,
hidden: &HashSet<usize>,
) -> Vec<VisualLine> {
self.calculate_visual_lines_range(
text_buffer,
viewport_width,
gutter_width,
hidden,
0..text_buffer.line_count(),
)
}
pub(crate) fn calculate_visual_lines_range(
&self,
text_buffer: &TextBuffer,
viewport_width: f32,
gutter_width: f32,
hidden: &HashSet<usize>,
logical_range: Range<usize>,
) -> Vec<VisualLine> {
let logical_range = logical_range.start.min(text_buffer.line_count())
..logical_range.end.min(text_buffer.line_count());
if !self.wrap_enabled {
return logical_range
.filter(|line| !hidden.contains(line))
.map(|line| {
VisualLine::new(line, 0, 0, text_buffer.line_len(line))
})
.collect();
}
let wrap_width_pixels = if let Some(cols) = self.wrap_column {
cols as f32 * self.char_width
} else {
(viewport_width - gutter_width).max(self.char_width)
};
let mut visual_lines = Vec::new();
for logical_line in logical_range {
if hidden.contains(&logical_line) {
continue; }
let line_content = text_buffer.line(logical_line);
if line_content.is_empty() {
visual_lines.push(VisualLine::new(logical_line, 0, 0, 0));
continue;
}
let mut segment_index = 0;
let mut current_width = 0.0;
let mut current_segment_start_col = 0;
for (i, c) in line_content.chars().enumerate() {
let char_width = measure_char_width(
c,
self.full_char_width,
self.char_width,
);
if compare_floats(current_width + char_width, wrap_width_pixels)
== Ordering::Greater
&& i > current_segment_start_col
{
visual_lines.push(VisualLine::new(
logical_line,
segment_index,
current_segment_start_col,
i, ));
segment_index += 1;
current_segment_start_col = i;
current_width = 0.0;
}
current_width += char_width;
}
visual_lines.push(VisualLine::new(
logical_line,
segment_index,
current_segment_start_col,
line_content.chars().count(),
));
}
visual_lines
}
pub fn logical_to_visual(
visual_lines: &[VisualLine],
line: usize,
col: usize,
) -> Option<usize> {
let start =
visual_lines.partition_point(|visual| visual.logical_line < line);
let end =
visual_lines.partition_point(|visual| visual.logical_line <= line);
let line_segments = visual_lines.get(start..end)?;
let segment =
line_segments.partition_point(|visual| visual.end_col <= col);
if let Some(visual) = line_segments.get(segment)
&& col >= visual.start_col
{
return Some(start + segment);
}
line_segments
.last()
.filter(|visual| col == visual.end_col)
.map(|_| end.saturating_sub(1))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::canvas_editor::{CHAR_WIDTH, FONT_SIZE};
#[test]
fn test_no_wrap_when_disabled() {
let buffer = TextBuffer::new("line 1\nline 2\nline 3");
let calc = WrappingCalculator::new(false, None, FONT_SIZE, CHAR_WIDTH);
let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &HashSet::new());
assert_eq!(visual_lines.len(), 3);
assert_eq!(visual_lines[0].logical_line, 0);
assert_eq!(visual_lines[1].logical_line, 1);
assert_eq!(visual_lines[2].logical_line, 2);
}
#[test]
fn test_hidden_lines_are_skipped() {
let buffer = TextBuffer::new("line 1\nline 2\nline 3\nline 4");
let calc = WrappingCalculator::new(false, None, FONT_SIZE, CHAR_WIDTH);
let hidden: HashSet<usize> = [1, 2].into_iter().collect();
let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &hidden);
assert_eq!(visual_lines.len(), 2);
assert_eq!(visual_lines[0].logical_line, 0);
assert_eq!(visual_lines[1].logical_line, 3);
}
#[test]
fn test_hidden_lines_are_skipped_when_wrapping() {
let buffer = TextBuffer::new("aaaa\nbbbb\ncccc");
let calc =
WrappingCalculator::new(true, Some(80), FONT_SIZE, CHAR_WIDTH);
let hidden: HashSet<usize> = [1].into_iter().collect();
let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &hidden);
assert_eq!(visual_lines.len(), 2);
assert_eq!(visual_lines[0].logical_line, 0);
assert_eq!(visual_lines[1].logical_line, 2);
}
#[test]
fn test_wrap_at_fixed_column() {
let buffer =
TextBuffer::new("this is a very long line that should be wrapped");
let calc =
WrappingCalculator::new(true, Some(10), FONT_SIZE, CHAR_WIDTH);
let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &HashSet::new());
assert_eq!(visual_lines.len(), 5);
assert_eq!(visual_lines[0].start_col, 0);
assert_eq!(visual_lines[0].end_col, 10);
assert_eq!(visual_lines[1].start_col, 10);
assert_eq!(visual_lines[1].end_col, 20);
assert_eq!(visual_lines[4].start_col, 40);
assert_eq!(visual_lines[4].end_col, 47);
}
#[test]
fn test_logical_to_visual_mapping() {
let buffer =
TextBuffer::new("short\nthis is a very long line that wraps\nend");
let calc =
WrappingCalculator::new(true, Some(15), FONT_SIZE, CHAR_WIDTH);
let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &HashSet::new());
assert_eq!(
WrappingCalculator::logical_to_visual(&visual_lines, 0, 0),
Some(0)
);
assert_eq!(
WrappingCalculator::logical_to_visual(&visual_lines, 1, 0),
Some(1)
);
assert_eq!(
WrappingCalculator::logical_to_visual(&visual_lines, 1, 14),
Some(1)
);
assert_eq!(
WrappingCalculator::logical_to_visual(&visual_lines, 1, 15),
Some(2)
);
assert_eq!(
WrappingCalculator::logical_to_visual(&visual_lines, 1, 30),
Some(3)
);
assert_eq!(
WrappingCalculator::logical_to_visual(&visual_lines, 1, 35),
Some(3)
);
assert_eq!(
WrappingCalculator::logical_to_visual(&visual_lines, 99, 0),
None
);
}
#[test]
fn test_calculate_visual_lines_range_keeps_logical_indices() {
let buffer = TextBuffer::new("zero\none\ntwo\nthree");
let calc = WrappingCalculator::new(false, None, FONT_SIZE, CHAR_WIDTH);
let visual_lines = calc.calculate_visual_lines_range(
&buffer,
800.0,
60.0,
&HashSet::new(),
1..3,
);
assert_eq!(
visual_lines
.iter()
.map(|visual| visual.logical_line)
.collect::<Vec<_>>(),
vec![1, 2]
);
}
#[test]
fn test_wrap_empty_lines() {
let buffer = TextBuffer::new("line1\n\nline3");
let calc =
WrappingCalculator::new(true, Some(10), FONT_SIZE, CHAR_WIDTH);
let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &HashSet::new());
assert_eq!(visual_lines.len(), 3);
assert_eq!(visual_lines[1].logical_line, 1);
assert_eq!(visual_lines[1].len(), 0);
}
#[test]
fn test_wrap_very_long_line() {
let long_text = "a".repeat(100);
let buffer = TextBuffer::new(&long_text);
let calc =
WrappingCalculator::new(true, Some(20), FONT_SIZE, CHAR_WIDTH);
let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &HashSet::new());
assert_eq!(visual_lines.len(), 5);
assert!(visual_lines.iter().all(|vl| vl.logical_line == 0));
}
#[test]
fn test_visual_line_is_first_segment() {
let vl1 = VisualLine::new(0, 0, 0, 10);
let vl2 = VisualLine::new(0, 1, 10, 20);
assert!(vl1.is_first_segment());
assert!(!vl2.is_first_segment());
}
#[test]
fn test_wrap_cjk() {
let text = "你好世界你好"; let buffer = TextBuffer::new(text);
let calc =
WrappingCalculator::new(true, Some(10), FONT_SIZE, CHAR_WIDTH); let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &HashSet::new());
assert_eq!(visual_lines.len(), 1);
assert_eq!(visual_lines[0].len(), 6);
let text = "你好世界你好世"; let buffer = TextBuffer::new(text);
let visual_lines =
calc.calculate_visual_lines(&buffer, 800.0, 60.0, &HashSet::new());
assert_eq!(visual_lines.len(), 2);
assert_eq!(visual_lines[0].len(), 6); assert_eq!(visual_lines[1].len(), 1); assert_eq!(visual_lines[1].start_col, 6); }
}