use std::ops::Range;
use super::super::dom::{Control, Edit, El};
use super::{ic, icons};
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct VirtualList {
pub row_h: f64,
pub overscan: usize,
}
impl VirtualList {
pub fn new(row_h: f64) -> Self {
Self { row_h: row_h.max(1.0), overscan: 4 }
}
pub fn overscan(mut self, rows: usize) -> Self {
self.overscan = rows;
self
}
pub fn content_height(&self, n: usize) -> f64 {
n as f64 * self.row_h
}
pub fn max_scroll(&self, n: usize, viewport_h: f64) -> f64 {
(self.content_height(n) - viewport_h).max(0.0)
}
pub fn clamp(&self, n: usize, scroll: f64, viewport_h: f64) -> f64 {
if scroll.is_finite() {
scroll.clamp(0.0, self.max_scroll(n, viewport_h))
} else {
0.0
}
}
pub fn visible(&self, n: usize, scroll: f64, viewport_h: f64) -> Range<usize> {
if n == 0 || viewport_h <= 0.0 {
return 0..0;
}
let s = self.clamp(n, scroll, viewport_h);
let first = ((s / self.row_h).floor() as usize).min(n);
let last = (((s + viewport_h) / self.row_h).ceil() as usize).min(n);
first..last.max(first)
}
pub fn range(&self, n: usize, scroll: f64, viewport_h: f64) -> Range<usize> {
let v = self.visible(n, scroll, viewport_h);
if v.is_empty() {
return v;
}
v.start.saturating_sub(self.overscan)..(v.end + self.overscan).min(n)
}
pub fn reveal(&self, n: usize, i: usize, scroll: f64, viewport_h: f64) -> f64 {
let top = i.min(n.saturating_sub(1)) as f64 * self.row_h;
let s = if top < scroll {
top
} else if top + self.row_h > scroll + viewport_h {
top + self.row_h - viewport_h
} else {
scroll
};
self.clamp(n, s, viewport_h)
}
pub fn el(&self, id: &str, n: usize, scroll: f64, viewport_h: f64, empty: Option<&str>, mut row: impl FnMut(usize) -> El) -> El {
let list = El::new("div.m-vlist").id(id);
if n == 0 {
return match empty {
Some(t) => list.child(El::new("div.m-empty").text(t)),
None => list,
};
}
let s = self.clamp(n, scroll, viewport_h);
let r = self.range(n, s, viewport_h.max(self.row_h));
let pad = |h: f64| El::new("div.m-vpad").css(format!("height: {h}px"));
let rows = r.clone().map(|i| El::new("div.m-vrow").css(format!("height: {}px", self.row_h)).child(row(i)));
let body = El::new("div.m-vbody")
.child(pad(r.start as f64 * self.row_h))
.children(rows)
.child(pad((n - r.end) as f64 * self.row_h));
list.scroll_top(s).child(body)
}
}
pub fn search_bar(id: &str, edit: Edit, name: &str, cancel: Option<&str>) -> El {
let has_text = !edit.value.is_empty();
let field = El::new("div.m-search.m-sfield")
.child(ic(icons::SEARCH))
.child(El::new("input.m-sinput").id(id).name(name).control(Control::input(edit)))
.child_if(has_text, || El::new("button.m-sclear").id(format!("{id}:clear")).tab().name("×").svg(super::icon(icons::CLOSE)));
El::new("div.m-sbar").child(field).child_if(cancel.is_some(), || {
let t = cancel.unwrap_or_default();
El::new("button.m-scancel").id(format!("{id}:cancel")).tab().text(t)
})
}
fn norm(s: &str) -> String {
super::super::i18n::case::lower(s).replace(['_', '/', '-', '.', ','], " ")
}
pub fn search_rank(label: &str, query: &str) -> Option<u8> {
let q = norm(query);
let q = q.trim();
if q.is_empty() {
return Some(0);
}
let l = norm(label);
let words: Vec<&str> = l.split_whitespace().collect();
let toks: Vec<&str> = q.split_whitespace().collect();
if l.trim_start().starts_with(q) {
return Some(0);
}
if toks.iter().all(|t| words.iter().any(|w| w.starts_with(t))) {
return Some(1);
}
if toks.iter().all(|t| l.contains(t)) {
return Some(2);
}
None
}
pub fn search_filter<L: AsRef<str>>(labels: &[L], query: &str) -> Vec<usize> {
let mut hits: Vec<(u8, usize)> = labels.iter().enumerate().filter_map(|(i, l)| search_rank(l.as_ref(), query).map(|r| (r, i))).collect();
hits.sort_by_key(|h| h.0);
hits.into_iter().map(|h| h.1).collect()
}