use crate::render::text::{glyph_pos_at_ci, raw_to_expanded, visual_row_at_exp_ci};
use crate::style::Rect;
use cosmic_text::Buffer;
#[derive(Clone, Debug)]
#[allow(dead_code)]
pub(crate) struct Composition {
pub text: String,
pub anchor: usize, pub caret_bytes: Option<(usize, usize)>, }
#[allow(dead_code)]
impl Composition {
pub fn caret_chars(&self) -> (usize, usize) {
let len = self.text.len();
let (s, e) = match self.caret_bytes {
Some((a, b)) => (a, b),
None => return (self.text.chars().count(), self.text.chars().count()),
};
let clamp = |raw: usize| -> usize {
let base = if self.text.is_char_boundary(raw) {
raw
} else {
(0..raw)
.rev()
.find(|&i| self.text.is_char_boundary(i))
.unwrap_or(0)
};
self.text[..base.min(len)].chars().count()
};
(clamp(s), clamp(e))
}
pub fn display_range(&self) -> std::ops::Range<usize> {
let start = self.anchor;
let end = start + self.text.chars().count();
start..end
}
pub fn caret_display(&self) -> usize {
self.anchor + self.caret_chars().0
}
pub fn clause_in_preedit(&self) -> Option<std::ops::Range<usize>> {
let (s, e) = self.caret_chars();
if s != e {
Some(s..e)
} else {
None
}
}
pub fn doc_to_display(&self, doc: usize) -> usize {
let r = self.display_range();
if doc >= r.end {
doc
} else if doc >= r.start {
r.start
} else {
doc
}
}
pub fn display_to_doc(&self, display: usize) -> usize {
let r = self.display_range();
if display >= r.end {
display
} else if display >= r.start {
r.start
} else {
display
}
}
}
pub(crate) fn composition_rects(
buffer: &Buffer,
text: &str, comp_range: (usize, usize), clause_range: Option<(usize, usize)>, row_height: f32,
padding_left: f32,
padding_top: f32,
) -> Vec<Rect> {
let (start, end) = comp_range;
if start >= end {
return Vec::new();
}
let text_len = text.chars().count();
let elo = raw_to_expanded(text, start.min(text_len));
let ehi = raw_to_expanded(text, end.min(text_len));
let rlo = visual_row_at_exp_ci(buffer, elo);
let rhi = visual_row_at_exp_ci(buffer, ehi);
let mut rects = Vec::new();
for row in rlo..=rhi {
let row_start_x = if row == rlo {
glyph_pos_at_ci(buffer, elo, false).1
} else {
0.0
};
let row_end_x = if row == rhi {
glyph_pos_at_ci(buffer, ehi, false).1
} else {
buffer
.layout_runs()
.filter(|r| r.line_i == row)
.last()
.and_then(|r| r.glyphs.last().map(|g| g.x + g.w))
.unwrap_or(0.0)
};
let w = (row_end_x - row_start_x).max(1.0);
if w > 0.0 {
rects.push(Rect::new(
padding_left + row_start_x,
padding_top + row as f32 * row_height + row_height - 2.0,
w,
2.0,
));
}
}
if let Some((cs, ce)) = clause_range {
if cs < ce {
let ceo = raw_to_expanded(text, (start + cs).min(text_len));
let cleo = raw_to_expanded(text, (start + ce).min(text_len));
let crow = visual_row_at_exp_ci(buffer, ceo);
let cx = glyph_pos_at_ci(buffer, ceo, false).1;
let cw = (glyph_pos_at_ci(buffer, cleo, false).1 - cx).max(1.0);
if cw > 0.0 {
rects.push(Rect::new(
padding_left + cx,
padding_top + crow as f32 * row_height + row_height - 3.0,
cw,
3.0,
));
}
}
}
rects
}
#[cfg(test)]
mod tests {
use super::*;
#[allow(dead_code)]
fn doc_str(n: usize) -> String {
(0..n).map(|i| (b'a' + (i % 26) as u8) as char).collect()
}
#[test]
fn caret_chars_on_boundary() {
let comp = Composition {
text: "ab".into(),
anchor: 0,
caret_bytes: Some((1, 1)),
};
assert_eq!(comp.caret_chars(), (1, 1));
}
#[test]
fn caret_chars_byte_in_char_center_walks_left() {
let comp = Composition {
text: "中二".into(),
anchor: 0,
caret_bytes: Some((1, 5)),
};
let (s, e) = comp.caret_chars();
assert_eq!(s, 0); assert_eq!(e, 1); }
#[test]
fn caret_chars_out_of_range_clamped() {
let comp = Composition {
text: "ab".into(),
anchor: 0,
caret_bytes: Some((999, 999)),
};
assert_eq!(comp.caret_chars(), (2, 2));
}
#[test]
fn caret_chars_none_returns_end() {
let comp = Composition {
text: "abc".into(),
anchor: 0,
caret_bytes: None,
};
assert_eq!(comp.caret_chars(), (3, 3));
}
#[test]
fn doc_to_display_before_splice_identity() {
let comp = Composition {
text: "XY".into(),
anchor: 3,
caret_bytes: None,
};
assert_eq!(comp.doc_to_display(0), 0);
assert_eq!(comp.doc_to_display(2), 2);
}
#[test]
fn doc_to_display_inside_preedit_maps_to_anchor() {
let comp = Composition {
text: "XY".into(),
anchor: 3,
caret_bytes: None,
};
assert_eq!(comp.doc_to_display(3), 3); assert_eq!(comp.doc_to_display(4), 3); }
#[test]
fn doc_to_display_after_preedit_compensates() {
let comp = Composition {
text: "XY".into(),
anchor: 3,
caret_bytes: None,
};
assert_eq!(comp.doc_to_display(5), 5); }
#[test]
fn display_to_doc_inside_preedit_maps_to_anchor() {
let comp = Composition {
text: "XY".into(),
anchor: 3,
caret_bytes: None,
};
assert_eq!(comp.display_to_doc(4), 3);
}
#[test]
fn clause_when_range_collapsed_is_none() {
let comp = Composition {
text: "abc".into(),
anchor: 0,
caret_bytes: Some((1, 1)),
};
assert!(comp.clause_in_preedit().is_none());
}
#[test]
fn clause_when_range_expanded_is_some() {
let comp = Composition {
text: "abc".into(),
anchor: 0,
caret_bytes: Some((0, 3)),
};
assert_eq!(comp.clause_in_preedit().unwrap(), 0..3);
}
}