use iced::widget::canvas;
use iced::{Point, Size};
use std::borrow::Cow;
use syntect::parsing::SyntaxSet;
use crate::buffer::text_utils::char_range_to_byte_range;
use super::wrapping::VisualLine;
use crate::canvas_editor::IndentStyle;
use crate::canvas_editor::features::{
bracket_match, color_preview, indent_guides,
};
use crate::canvas_editor::virtual_text::{LineRun, VirtualText, width_between};
use crate::canvas_editor::{
CodeEditor, TAB_WIDTH, measure_char_width, measure_text_width,
};
pub(super) fn draw_text_runs(
frame: &mut canvas::Frame,
content: &str,
mut position: Point,
color: iced::Color,
ctx: &RenderContext<'_>,
) {
let mut start = 0;
while start < content.len() {
let ascii = content[start..].starts_with(|ch: char| ch.is_ascii());
let end = content[start..]
.char_indices()
.find(|(_, ch)| ch.is_ascii() != ascii)
.map_or(content.len(), |(i, _)| start + i);
let run = &content[start..end];
let width =
measure_text_width(run, ctx.full_char_width, ctx.char_width);
frame.fill_text(canvas::Text {
content: run.to_owned(),
position,
color,
size: ctx.font_size.into(),
max_width: width + ctx.font_size * 2.0,
font: if ascii { ctx.font } else { iced::Font::DEFAULT },
shaping: if ascii {
iced::advanced::text::Shaping::Basic
} else {
iced::advanced::text::Shaping::Advanced
},
..canvas::Text::default()
});
position.x += width;
start = end;
}
}
const INDENT_GUIDE_WIDTH: f32 = 1.0;
const SWATCH_SIZE_RATIO: f32 = 0.6;
const SWATCH_GAP: f32 = 3.0;
const SWATCH_BORDER_WIDTH: f32 = 1.0;
fn swatch_belongs_to_segment(
literal_end_col: usize,
segment_start_col: usize,
segment_end_col: usize,
) -> bool {
literal_end_col > segment_start_col && literal_end_col <= segment_end_col
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn calculate_segment_geometry(
line_content: &str,
visual_start_col: usize,
segment_start_col: usize,
segment_end_col: usize,
base_offset: f32,
full_char_width: f32,
char_width: f32,
virtual_text: &[(usize, f32)],
) -> (f32, f32) {
let segment_start_col = segment_start_col.max(visual_start_col);
let segment_end_col = segment_end_col.max(segment_start_col);
let mut prefix_width = 0.0;
let mut segment_width = 0.0;
for (i, c) in line_content.chars().enumerate() {
if i >= segment_end_col {
break;
}
let w = measure_char_width(c, full_char_width, char_width);
if i >= visual_start_col && i < segment_start_col {
prefix_width += w;
} else if i >= segment_start_col {
segment_width += w;
}
}
let has_text = segment_start_col < segment_end_col;
prefix_width += width_between(
virtual_text,
visual_start_col,
segment_start_col,
has_text,
);
if has_text {
segment_width += width_between(
virtual_text,
segment_start_col + 1,
segment_end_col,
false,
);
}
(base_offset + prefix_width, segment_width)
}
pub(crate) fn expand_tabs(text: &str, tab_width: usize) -> Cow<'_, str> {
if !text.contains('\t') {
return Cow::Borrowed(text);
}
let mut expanded = String::with_capacity(text.len());
for ch in text.chars() {
if ch == '\t' {
for _ in 0..tab_width {
expanded.push(' ');
}
} else {
expanded.push(ch);
}
}
Cow::Owned(expanded)
}
pub(crate) fn expand_tabs_visible(text: &str, tab_width: usize) -> String {
let mut result = String::with_capacity(text.len() * 2);
for ch in text.chars() {
match ch {
'\t' => {
result.push('→');
for _ in 1..tab_width {
result.push('·');
}
}
' ' => result.push('·'),
other => result.push(other),
}
}
result
}
fn split_whitespace_segments(text: &str) -> Vec<(bool, &str)> {
if text.is_empty() {
return vec![];
}
let mut result = Vec::new();
let mut seg_start = 0usize;
let mut chars = text.char_indices().peekable();
let is_ws_char = |c: char| c == '·' || c == '→';
let first_ch = chars.peek().map(|(_, c)| *c).unwrap_or(' ');
let mut current_is_ws = is_ws_char(first_ch);
for (byte_idx, ch) in chars {
let ch_is_ws = is_ws_char(ch);
if ch_is_ws != current_is_ws {
result.push((current_is_ws, &text[seg_start..byte_idx]));
seg_start = byte_idx;
current_is_ws = ch_is_ws;
}
}
result.push((current_is_ws, &text[seg_start..]));
result
}
pub(super) struct RenderContext<'a> {
pub(super) visual_lines: &'a [VisualLine],
pub(super) bounds_width: f32,
pub(super) gutter_width: f32,
pub(super) line_height: f32,
pub(super) font_size: f32,
pub(super) full_char_width: f32,
pub(super) char_width: f32,
pub(super) font: iced::Font,
pub(super) horizontal_scroll_offset: f32,
}
impl CodeEditor {
#[allow(clippy::too_many_arguments)]
pub(super) fn draw_text_with_syntax_highlighting(
&self,
frame: &mut canvas::Frame,
ctx: &RenderContext,
visual_line: &VisualLine,
y: f32,
syntax_ref: Option<&syntect::parsing::SyntaxReference>,
syntax_set: &SyntaxSet,
syntax_theme: Option<&syntect::highlighting::Theme>,
) {
let line = visual_line.logical_line;
let line_content = self.buffer.line(line);
let cols = (visual_line.start_col, visual_line.end_col);
let runs = if let (Some(syntax), Some(syntax_theme)) =
(syntax_ref, syntax_theme)
{
let spans = self.highlighted_line_cached(
line,
syntax,
syntax_theme,
syntax_set,
);
self.line_runs(line, Some(spans.as_slice()), cols)
} else {
self.line_runs(line, None, cols)
};
let mut x = ctx.gutter_width + 5.0 - ctx.horizontal_scroll_offset;
let y = y + 2.0;
for run in runs {
x += match run {
LineRun::Text { start, end, color } => self.draw_text_piece(
frame,
ctx,
line_content,
(start, end),
color,
x,
y,
),
LineRun::Virtual(item) => {
Self::draw_virtual_text(frame, ctx, item, x, y)
}
};
}
}
#[allow(clippy::too_many_arguments)]
fn draw_text_piece(
&self,
frame: &mut canvas::Frame,
ctx: &RenderContext,
line_content: &str,
cols: (usize, usize),
color: iced::Color,
x: f32,
y: f32,
) -> f32 {
if cols.0 >= cols.1 {
return 0.0;
}
let (start_byte, end_byte) =
char_range_to_byte_range(line_content, cols.0, cols.1);
let segment_text = &line_content[start_byte..end_byte];
let display_text = if self.show_whitespace {
expand_tabs_visible(segment_text, TAB_WIDTH)
} else {
expand_tabs(segment_text, TAB_WIDTH).into_owned()
};
let display_width = measure_text_width(
&display_text,
ctx.full_char_width,
ctx.char_width,
);
if self.show_whitespace {
let ws_color = self.style.whitespace_color;
let mut seg_x = x;
for (is_ws, seg) in split_whitespace_segments(&display_text) {
let seg_color = if is_ws { ws_color } else { color };
draw_text_runs(
frame,
seg,
Point::new(seg_x, y),
seg_color,
ctx,
);
seg_x += measure_text_width(
seg,
ctx.full_char_width,
ctx.char_width,
);
}
} else {
draw_text_runs(frame, &display_text, Point::new(x, y), color, ctx);
}
display_width
}
fn draw_virtual_text(
frame: &mut canvas::Frame,
ctx: &RenderContext,
item: &VirtualText,
x: f32,
y: f32,
) -> f32 {
draw_text_runs(frame, &item.text, Point::new(x, y), item.color, ctx);
measure_text_width(&item.text, ctx.full_char_width, ctx.char_width)
}
pub(super) fn draw_indent_guides(
&self,
frame: &mut canvas::Frame,
ctx: &RenderContext,
visual_line: &VisualLine,
y: f32,
) {
if !self.show_indent_guides || !visual_line.is_first_segment() {
return;
}
let unit = match self.indent_style {
IndentStyle::Spaces(width) => usize::from(width),
IndentStyle::Tab => TAB_WIDTH,
};
let levels = indent_guides::guide_levels(
&self.buffer,
visual_line.logical_line,
unit,
);
let base_x = ctx.gutter_width + 5.0 - ctx.horizontal_scroll_offset;
for level in 0..levels {
let x = base_x + (level * unit) as f32 * ctx.char_width;
frame.fill_rectangle(
Point::new(x, y),
Size::new(INDENT_GUIDE_WIDTH, ctx.line_height),
self.style.indent_guide_color,
);
}
}
pub(super) fn draw_color_swatches(
&self,
frame: &mut canvas::Frame,
ctx: &RenderContext,
visual_line: &VisualLine,
y: f32,
literals: &mut color_preview::LineLiterals,
) {
if !self.show_color_previews {
return;
}
let line_content = self.buffer.line(visual_line.logical_line);
let side = (ctx.line_height * SWATCH_SIZE_RATIO).floor().max(1.0);
let inner_side = (side - 2.0 * SWATCH_BORDER_WIDTH).max(1.0);
for literal in literals.get(&self.buffer, visual_line.logical_line) {
if !swatch_belongs_to_segment(
literal.end_col,
visual_line.start_col,
visual_line.end_col,
) {
continue;
}
let (x, _width) = calculate_segment_geometry(
line_content,
visual_line.start_col,
literal.end_col,
literal.end_col,
ctx.gutter_width + 5.0,
ctx.full_char_width,
ctx.char_width,
&self.virtual_text_widths(visual_line.logical_line),
);
let border_position = Point::new(
x - ctx.horizontal_scroll_offset + SWATCH_GAP,
y + (ctx.line_height - side) / 2.0,
);
let inner_position = Point::new(
border_position.x + SWATCH_BORDER_WIDTH,
border_position.y + SWATCH_BORDER_WIDTH,
);
frame.fill_rectangle(
border_position,
Size::new(side, side),
self.style.gutter_border,
);
for color in [self.style.background, literal.color] {
frame.fill_rectangle(
inner_position,
Size::new(inner_side, inner_side),
color,
);
}
}
}
pub(super) fn draw_bracket_pair_colors(
&self,
frame: &mut canvas::Frame,
ctx: &RenderContext,
visual_line: &VisualLine,
y: f32,
) {
if !self.bracket_pair_colorization_enabled {
return;
}
let palette = self.bracket_pair_colors();
let logical_line = visual_line.logical_line;
let start_depth = self
.bracket_depth_cache
.borrow_mut()
.depth_at_line_start(&self.buffer, logical_line);
let line_content = self.buffer.line(logical_line);
let indices =
bracket_match::bracket_depth_indices(line_content, start_depth);
for (col, depth) in indices {
if col < visual_line.start_col || col >= visual_line.end_col {
continue;
}
let Some(ch) = line_content.chars().nth(col) else {
continue;
};
let (x, _width) = calculate_segment_geometry(
line_content,
visual_line.start_col,
col,
col + 1,
ctx.gutter_width + 5.0,
ctx.full_char_width,
ctx.char_width,
&self.virtual_text_widths(visual_line.logical_line),
);
frame.fill_text(canvas::Text {
content: ch.to_string(),
position: Point::new(x - ctx.horizontal_scroll_offset, y + 2.0),
color: palette[depth % palette.len()],
size: ctx.font_size.into(),
font: ctx.font,
..canvas::Text::default()
});
}
}
}
#[cfg(test)]
mod tests {
use std::cmp::Ordering;
use super::*;
use crate::canvas_editor::{CHAR_WIDTH, FONT_SIZE, compare_floats};
#[test]
fn test_a_swatch_lands_on_the_segment_holding_the_literals_last_character()
{
assert!(
!swatch_belongs_to_segment(37, 0, 20),
"the first segment ends before the literal does"
);
assert!(swatch_belongs_to_segment(37, 20, 40));
assert!(
!swatch_belongs_to_segment(37, 40, 60),
"a later segment must not draw it a second time"
);
}
#[test]
fn test_every_column_is_claimed_by_exactly_one_segment() {
const SEGMENTS: [(usize, usize); 3] = [(0, 20), (20, 40), (40, 60)];
for literal_end_col in 1..=60 {
let owners = SEGMENTS
.iter()
.filter(|(start, end)| {
swatch_belongs_to_segment(literal_end_col, *start, *end)
})
.count();
assert_eq!(owners, 1, "end column {literal_end_col} has {owners}");
}
}
#[test]
fn test_a_swatch_at_the_very_end_of_a_segment_belongs_to_it() {
assert!(swatch_belongs_to_segment(20, 0, 20));
assert!(!swatch_belongs_to_segment(20, 20, 40));
}
#[test]
fn test_calculate_segment_geometry_ascii() {
let content = "Hello World";
let (x, w) = calculate_segment_geometry(
content,
0,
6,
11,
0.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
let expected_x = CHAR_WIDTH * 6.0;
let expected_w = CHAR_WIDTH * 5.0;
assert_eq!(
compare_floats(x, expected_x),
Ordering::Equal,
"X position mismatch for ASCII"
);
assert_eq!(
compare_floats(w, expected_w),
Ordering::Equal,
"Width mismatch for ASCII"
);
}
#[test]
fn test_calculate_segment_geometry_cjk() {
let content = "你好世界";
let (x, w) = calculate_segment_geometry(
content,
0,
2,
4,
10.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
let expected_x = 10.0 + FONT_SIZE * 2.0;
let expected_w = FONT_SIZE * 2.0;
assert_eq!(
compare_floats(x, expected_x),
Ordering::Equal,
"X position mismatch for CJK"
);
assert_eq!(
compare_floats(w, expected_w),
Ordering::Equal,
"Width mismatch for CJK"
);
}
#[test]
fn test_calculate_segment_geometry_mixed() {
let content = "Hi你好";
let (x, w) = calculate_segment_geometry(
content,
0,
2,
4,
0.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
let expected_x = CHAR_WIDTH * 2.0;
let expected_w = FONT_SIZE * 2.0;
assert_eq!(
compare_floats(x, expected_x),
Ordering::Equal,
"X position mismatch for mixed content"
);
assert_eq!(
compare_floats(w, expected_w),
Ordering::Equal,
"Width mismatch for mixed content"
);
}
#[test]
fn test_calculate_segment_geometry_empty_range() {
let content = "Hello";
let (x, w) = calculate_segment_geometry(
content,
0,
0,
0,
0.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
assert!((x - 0.0).abs() < f32::EPSILON);
assert!((w - 0.0).abs() < f32::EPSILON);
}
#[test]
fn test_calculate_segment_geometry_with_visual_offset() {
let content = "0123456789";
let (x, w) = calculate_segment_geometry(
content,
2,
3,
5,
5.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
let expected_x = 5.0 + CHAR_WIDTH * 1.0;
let expected_w = CHAR_WIDTH * 2.0;
assert_eq!(
compare_floats(x, expected_x),
Ordering::Equal,
"X position mismatch with visual offset"
);
assert_eq!(
compare_floats(w, expected_w),
Ordering::Equal,
"Width mismatch with visual offset"
);
}
#[test]
fn test_calculate_segment_geometry_out_of_bounds() {
let content = "Hello";
let (x, w) = calculate_segment_geometry(
content,
0,
10,
15,
0.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
let expected_x = CHAR_WIDTH * 5.0; let expected_w = 0.0;
assert_eq!(
compare_floats(x, expected_x),
Ordering::Equal,
"X position mismatch for out of bounds start"
);
assert!(
(w - expected_w).abs() < f32::EPSILON,
"Width should be 0 for out of bounds segment"
);
}
#[test]
fn test_calculate_segment_geometry_special_chars() {
let content = "A👋\tB";
let (x, w) = calculate_segment_geometry(
content,
0,
1,
2,
0.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
let expected_x_emoji = CHAR_WIDTH; let expected_w_emoji = FONT_SIZE;
assert_eq!(
compare_floats(x, expected_x_emoji),
Ordering::Equal,
"X pos for emoji"
);
assert_eq!(
compare_floats(w, expected_w_emoji),
Ordering::Equal,
"Width for emoji"
);
let (x_tab, w_tab) = calculate_segment_geometry(
content,
0,
2,
3,
0.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
let expected_x_tab = CHAR_WIDTH + FONT_SIZE; let expected_w_tab =
CHAR_WIDTH * crate::canvas_editor::TAB_WIDTH as f32;
assert_eq!(
compare_floats(x_tab, expected_x_tab),
Ordering::Equal,
"X pos for tab"
);
assert_eq!(
compare_floats(w_tab, expected_w_tab),
Ordering::Equal,
"Width for tab"
);
}
#[test]
fn test_calculate_segment_geometry_inverted_range() {
let content = "0123456789";
let (x, w) = calculate_segment_geometry(
content,
0,
5,
3,
0.0,
FONT_SIZE,
CHAR_WIDTH,
&[],
);
let expected_x = CHAR_WIDTH * 5.0;
let expected_w = 0.0;
assert_eq!(
compare_floats(x, expected_x),
Ordering::Equal,
"X pos for inverted range"
);
assert!(
(w - expected_w).abs() < f32::EPSILON,
"Width for inverted range"
);
}
#[test]
fn test_expand_tabs_visible_spaces() {
assert_eq!(expand_tabs_visible("a b", 4), "a·b");
assert_eq!(expand_tabs_visible(" x ", 4), "··x··");
}
#[test]
fn test_expand_tabs_visible_tabs() {
assert_eq!(expand_tabs_visible("\t", 4), "→···");
assert_eq!(expand_tabs_visible("a\tb", 4), "a→···b");
}
#[test]
fn test_expand_tabs_visible_no_whitespace() {
assert_eq!(expand_tabs_visible("hello", 4), "hello");
}
#[test]
fn test_split_whitespace_segments_mixed() {
let segs = split_whitespace_segments("a·b");
assert_eq!(segs, vec![(false, "a"), (true, "·"), (false, "b")]);
}
#[test]
fn test_split_whitespace_segments_leading_ws() {
let segs = split_whitespace_segments("··x");
assert_eq!(segs, vec![(true, "··"), (false, "x")]);
}
#[test]
fn test_split_whitespace_segments_all_ws() {
let segs = split_whitespace_segments("···");
assert_eq!(segs, vec![(true, "···")]);
}
#[test]
fn test_split_whitespace_segments_empty() {
let segs = split_whitespace_segments("");
assert!(segs.is_empty());
}
}