use super::{
access, choice::Choice, nav::Navigable, options::OptionsState, paint, trigger::Trigger,
ComboBoxOption, ComboBoxState, ComboBoxStyle,
};
use crate::components::{Popup, ScrollArea, ScrollStyle, TextEdit, Ui};
use crate::{Id, Padding, Rect, Vec2};
use winit::keyboard::KeyCode;
#[derive(Default)]
pub(super) struct ListState {
pub(super) focus_filter: bool,
active_row: Option<usize>,
size: Vec2,
options: OptionsState,
}
pub(super) struct List<'s, T> {
pub(super) trigger: &'s Trigger,
pub(super) label: &'s str,
pub(super) options: &'s [ComboBoxOption<T>],
pub(super) selected: Option<&'s T>,
pub(super) filterable: bool,
}
struct Geometry {
pitch: f32,
filter: f32,
height: f32,
}
impl Geometry {
fn new(ui: &Ui<'_>, style: &ComboBoxStyle, rows: usize, filterable: bool) -> Self {
let count = rows.max(1).min(style.visible_rows.max(1));
let pitch = style.row_height + style.row_gap;
let filter = if filterable {
ui.style().text_edit_height.max(30.0) + 2.0
} else {
0.0
};
let height = count as f32 * pitch - style.row_gap + style.popup_padding.size().y + filter;
Self {
pitch,
filter,
height,
}
}
fn list_height(&self, style: &ComboBoxStyle) -> f32 {
(self.height - style.popup_padding.size().y - self.filter).max(0.0)
}
}
struct View<'a> {
query: &'a mut String,
active: &'a mut Option<Id>,
list: &'a mut ListState,
}
#[derive(Default)]
struct Filter {
node: Option<usize>,
changed: bool,
}
impl<T: PartialEq> List<'_, T> {
pub(super) fn show(
&self,
ui: &mut Ui<'_>,
state: &mut ComboBoxState,
progress: f32,
mut reveal: bool,
keys: &[KeyCode],
) -> Option<Choice> {
let rows = if state.open || progress > 0.0 {
reveal |= self.observe(ui, &mut state.list.options);
state
.list
.options
.matching(self.options, &state.query)
.len()
} else {
0
};
let geometry = Geometry::new(ui, &self.trigger.style, rows, self.filterable);
let keys = if state.open { keys } else { &[] };
let view = View {
query: &mut state.query,
active: &mut state.active,
list: &mut state.list,
};
let choice = self
.popup(&geometry, progress)
.show(ui, &mut state.open, |ui| {
self.content(ui, view, &geometry, keys, reveal)
})
.and_then(|shown| shown.inner);
state.list.focus_filter &= state.open;
choice
}
fn observe(&self, ui: &mut Ui<'_>, cache: &mut OptionsState) -> bool {
let changed = cache.refresh(self.options);
if cache.duplicates {
ui.context.report(
crate::DiagnosticKind::IdCollision,
Some(self.trigger.id),
Some(self.trigger.rect),
|| "duplicate id: two ComboBox options share one id".into(),
);
}
changed
}
fn popup(&self, geometry: &Geometry, progress: f32) -> Popup {
let (trigger, style) = (self.trigger, &self.trigger.style);
let mut popup = Popup::new(trigger.id, trigger.rect)
.size(Vec2::new(trigger.rect.size().x, geometry.height))
.gap(style.popup_gap)
.padding(style.popup_padding)
.corner_radius(style.rounding)
.fill(style.popup_fill)
.border(style.popup_border)
.return_focus(trigger.id);
popup.key_target = Some(trigger.id);
popup.progress = progress;
popup.animated = true;
popup
}
fn content(
&self,
ui: &mut Ui<'_>,
view: View<'_>,
geometry: &Geometry,
keys: &[KeyCode],
mut reveal: bool,
) -> Option<Choice> {
let filter = self.filter(ui, view.query, &mut view.list.focus_filter, geometry);
reveal |= filter.changed;
let listed = view.list.options.matching(self.options, view.query);
let navigable = Navigable::new(self.options, listed);
reveal |= navigable.restore(view.active);
let keyboard = navigable.navigate(keys, self.trigger.style.visible_rows, view.active);
reveal |= keyboard.moved;
let row = listed
.iter()
.position(|&i| Some(self.options[i].id) == *view.active);
reveal |= view.list.active_row != row;
view.list.active_row = row;
let size = Vec2::new(ui.available_width(), ui.available_height());
reveal |= view.list.size != size;
view.list.size = size;
if let Some(node) = filter.node.and_then(|at| ui.context.a11y_node_mut(at)) {
access::popup_owner(node, self.trigger.id, self.trigger.list, *view.active);
}
let clicked = self.rows(ui, listed, *view.active, geometry, row.filter(|_| reveal));
clicked
.map(Choice::Pointer)
.or(keyboard.chosen.map(Choice::Keyboard))
}
fn filter(
&self,
ui: &mut Ui<'_>,
query: &mut String,
focus: &mut bool,
geometry: &Geometry,
) -> Filter {
if !self.filterable {
return Filter::default();
}
let before = query.clone();
let at = ui.context.a11y_len();
let field = ui.add(
TextEdit::new(query)
.id_source("filter")
.placeholder("Filter…")
.width(ui.available_width())
.height(geometry.filter - 2.0),
);
if *focus && ui.enabled && !field.rect.intersect(ui.clip_rect()).is_empty() {
ui.context.request_focus(field.id);
*focus = false;
}
Filter {
node: (ui.context.a11y_len() > at).then_some(at),
changed: before != *query,
}
}
fn rows(
&self,
ui: &mut Ui<'_>,
listed: &[usize],
active: Option<Id>,
geometry: &Geometry,
reveal: Option<usize>,
) -> Option<usize> {
let (trigger, style) = (self.trigger, &self.trigger.style);
let list = ui.a11y_begin(trigger.list, crate::AccessRole::ListBox, |node| {
node.label(self.label);
});
let scroll_style = ScrollStyle {
padding: Padding::default(),
spacing: 0.0,
bar_margin: 0.0,
bar_width: 4.0,
..ui.style().scroll
};
let mut scroll = ScrollArea::vertical()
.id_source("options")
.style(scroll_style)
.overlay_scrollbars(true)
.max_height(geometry.list_height(style))
.show_hints(false)
.middle_mouse_scroll(false)
.a11y_hidden();
if let Some(row) = reveal {
scroll = scroll.scroll_to_rect(Rect::from_min_size(
Vec2::new(0.0, row as f32 * geometry.pitch),
Vec2::new(1.0, style.row_height),
));
}
let mut clicked = None;
let (area, viewport) = if listed.is_empty() {
(trigger.list, paint::empty(ui, style))
} else {
let mut build_row = |ui: &mut Ui<'_>, row: usize| {
let index = listed[row];
let option = &self.options[index];
if paint::option(
ui,
trigger.id.with(("option", option.id)),
&option.label,
Some(&option.value) == self.selected,
Some(option.id) == active,
option.enabled,
(row, listed.len()),
style,
) {
clicked = Some(index);
}
};
if listed.len() <= style.visible_rows {
let shown = scroll.show(ui, |ui| {
ui.layout.spacing = style.row_gap;
for row in 0..listed.len() {
build_row(ui, row);
}
});
(shown.id, shown.viewport)
} else {
let shown = scroll.show_rows(ui, geometry.pitch, listed.len(), build_row);
(shown.id, shown.viewport)
}
};
ui.context.a11y_scroll(&list, area);
ui.a11y_end(list, Some(viewport));
clicked
}
}