use super::doc::Doc;
use crate::components::text_geometry::{hit, paragraph_rects};
use crate::{
components::edit_buffer::{Pos, Surface},
context::Context,
Rect, Vec2,
};
use std::ops::Range;
pub(crate) struct Loc {
pub para: usize,
pub line: usize,
pub x: f32,
pub y: f32,
}
impl Doc {
pub fn locate(&mut self, ctx: &mut Context, text: &str, pos: Pos) -> Loc {
let para = self.para_at(pos.byte.min(text.len()));
let rel = pos
.byte
.saturating_sub(self.paras[para].start)
.min(self.paras[para].len);
self.locate_in(ctx, text, para, rel, pos.upstream)
}
pub fn locate_in(
&mut self,
ctx: &mut Context,
text: &str,
para: usize,
rel: usize,
upstream: bool,
) -> Loc {
let layout = self.layout(ctx, text, para);
let line = Doc::line_of(&layout.lines, rel, upstream && rel > 0);
let l = &layout.lines[line];
Loc {
para,
line,
x: l.caret_x(rel).unwrap_or(0.0),
y: self.top(para) + l.top,
}
}
pub fn hit_point(&mut self, ctx: &mut Context, text: &str, point: Vec2) -> (Pos, usize) {
let para = self.para_at_y(point.y.max(0.0));
let layout = self.layout(ctx, text, para);
let rel_y = point.y - self.top(para);
let last = layout.lines.len() - 1;
let h = hit(&layout, Vec2::new(point.x, rel_y));
let start = self.paras[para].start;
(
Pos {
byte: start + h.byte,
upstream: h.line < last && h.byte == layout.lines[h.line].end,
},
start + h.cell,
)
}
pub fn move_lines(
&mut self,
ctx: &mut Context,
text: &str,
pos: Pos,
column: Option<f32>,
delta: i32,
) -> Option<(Pos, f32)> {
let here = self.locate(ctx, text, pos);
let x = column.unwrap_or(here.x);
let (mut para, mut line) = (here.para, here.line as i64 + i64::from(delta));
loop {
if line < 0 {
if para == 0 {
return Some((Pos::default(), x));
}
para -= 1;
line += self.layout(ctx, text, para).lines.len() as i64;
continue;
}
let layout = self.layout(ctx, text, para);
let count = layout.lines.len() as i64;
if line < count {
let l = &layout.lines[line as usize];
let (byte, _) = l.hit(x);
let upstream = line + 1 < count && byte == l.end;
let byte = self.paras[para].start + byte;
return Some((Pos { byte, upstream }, x));
}
if para + 1 >= self.paras.len() {
return Some((
Pos {
byte: text.len(),
upstream: false,
},
x,
));
}
line -= count;
para += 1;
}
}
pub fn line_bounds(&mut self, ctx: &mut Context, text: &str, pos: Pos) -> (Range<usize>, bool) {
let loc = self.locate(ctx, text, pos);
let layout = self.layout(ctx, text, loc.para);
let p = &self.paras[loc.para];
let l = &layout.lines[loc.line];
let last = loc.line + 1 == layout.lines.len();
let start = p.start + if loc.line == 0 { 0 } else { l.start };
let end = p.start + if last { p.len } else { l.end };
(start..end, !last)
}
pub fn selection_rects(
&mut self,
ctx: &mut Context,
text: &str,
range: Range<usize>,
paras: Range<usize>,
slab: f32,
) -> Vec<Rect> {
let mut rects = Vec::new();
for i in paras.start..paras.end.min(self.paras.len()) {
let (start, len, next) = {
let p = &self.paras[i];
(p.start, p.len, p.next_start())
};
if range.is_empty() || range.start >= next || range.end <= start {
continue;
}
let layout = self.layout(ctx, text, i);
let top = self.top(i);
paragraph_rects(
&layout,
range.start.saturating_sub(start)..range.end - start,
len,
slab,
top,
&mut rects,
);
}
rects
}
}
pub(crate) struct AreaSurface<'a> {
pub doc: &'a mut Doc,
pub ctx: &'a mut Context,
pub page: i32,
}
impl Surface for AreaSurface<'_> {
fn line(&mut self, text: &str, pos: Pos) -> (Range<usize>, bool) {
self.doc.line_bounds(self.ctx, text, pos)
}
fn vertical(
&mut self,
text: &str,
pos: Pos,
column: Option<f32>,
lines: i32,
) -> Option<(Pos, f32)> {
self.doc.move_lines(self.ctx, text, pos, column, lines)
}
fn hit(&mut self, text: &str, point: Vec2) -> (Pos, usize) {
self.doc.hit_point(self.ctx, text, point)
}
fn page_lines(&self) -> i32 {
self.page
}
}