use slint::Model;
pub fn resolve_click<T: Clone + PartialEq>(current: &[T], item: T, shift: bool) -> Vec<T> {
if !shift {
return vec![item];
}
if current.contains(&item) {
current.iter().filter(|x| **x != item).cloned().collect()
} else {
let mut extended = Vec::with_capacity(current.len() + 1);
extended.extend_from_slice(current);
extended.push(item);
extended
}
}
pub fn resolve_box<T: Clone + PartialEq>(current: &[T], hits: Vec<T>, shift: bool) -> Vec<T> {
if !shift {
return hits;
}
let mut extended = current.to_vec();
for hit in hits {
if !extended.contains(&hit) {
extended.push(hit);
}
}
extended
}
pub fn project_selection<T: Clone + 'static>(
model: &impl Model<Data = T>,
wanted: impl Fn(&T) -> bool,
flag: impl Fn(&mut T) -> &mut bool,
) {
for i in 0..model.row_count() {
let Some(mut row) = model.row_data(i) else {
continue;
};
let want = wanted(&row);
let current = flag(&mut row);
if *current != want {
*current = want;
model.set_row_data(i, row);
}
}
}
pub fn apply_click<T: Clone + 'static, K: Clone + PartialEq>(
model: &impl Model<Data = T>,
key: impl Fn(&T) -> K,
flag: impl Fn(&mut T) -> &mut bool,
item: K,
shift: bool,
) {
let current = collect_selected(model, &key, &flag);
let next = resolve_click(¤t, item, shift);
project_selection(model, |row| next.contains(&key(row)), &flag);
}
pub fn apply_box<T: Clone + 'static, K: Clone + PartialEq>(
model: &impl Model<Data = T>,
key: impl Fn(&T) -> K,
flag: impl Fn(&mut T) -> &mut bool,
hits: Vec<K>,
shift: bool,
) {
let current = collect_selected(model, &key, &flag);
let next = resolve_box(¤t, hits, shift);
project_selection(model, |row| next.contains(&key(row)), &flag);
}
pub fn clear_selection<T: Clone + 'static>(
model: &impl Model<Data = T>,
flag: impl Fn(&mut T) -> &mut bool,
) {
project_selection(model, |_| false, flag);
}
fn collect_selected<T: Clone + 'static, K>(
model: &impl Model<Data = T>,
key: &impl Fn(&T) -> K,
flag: &impl Fn(&mut T) -> &mut bool,
) -> Vec<K> {
(0..model.row_count())
.filter_map(|i| model.row_data(i))
.filter_map(|mut row| {
if *flag(&mut row) {
Some(key(&row))
} else {
None
}
})
.collect()
}
pub fn selected_rows<T: Clone + 'static, K>(
model: &impl Model<Data = T>,
key: impl Fn(&T) -> K,
flag: impl Fn(&T) -> bool,
) -> Vec<K> {
(0..model.row_count())
.filter_map(|i| model.row_data(i))
.filter(|row| flag(row))
.map(|row| key(&row))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use slint::VecModel;
use std::rc::Rc;
#[test]
fn click_replaces_the_selection() {
assert_eq!(resolve_click(&[1, 2, 3], 9, false), vec![9]);
}
#[test]
fn click_on_the_only_selected_item_is_idempotent() {
assert_eq!(resolve_click(&[7], 7, false), vec![7]);
}
#[test]
fn shift_click_appends_an_unselected_item() {
assert_eq!(resolve_click(&[1, 2], 3, true), vec![1, 2, 3]);
}
#[test]
fn shift_click_removes_a_selected_item_and_keeps_order() {
assert_eq!(resolve_click(&[1, 2, 3], 2, true), vec![1, 3]);
}
#[test]
fn shift_click_on_an_empty_selection_selects() {
assert_eq!(resolve_click(&[], 4, true), vec![4]);
}
#[test]
fn click_policy_is_not_id_specific() {
let current = [(1, 2), (3, 4)];
assert_eq!(resolve_click(¤t, (3, 4), true), vec![(1, 2)]);
}
#[test]
fn box_replaces_the_selection() {
assert_eq!(resolve_box(&[1, 2], vec![5, 6], false), vec![5, 6]);
}
#[test]
fn empty_box_clears_without_shift() {
assert_eq!(resolve_box(&[1, 2], Vec::new(), false), Vec::<i32>::new());
}
#[test]
fn shift_box_keeps_current_order_and_appends_new_hits() {
assert_eq!(resolve_box(&[3, 1], vec![4, 5], true), vec![3, 1, 4, 5]);
}
#[test]
fn shift_box_never_toggles_an_already_selected_hit() {
assert_eq!(resolve_box(&[1, 2], vec![2, 3], true), vec![1, 2, 3]);
}
#[test]
fn shift_box_with_no_hits_is_a_no_op() {
assert_eq!(resolve_box(&[1, 2], Vec::new(), true), vec![1, 2]);
}
#[derive(Clone, PartialEq, Debug)]
struct Row {
id: i32,
selected: bool,
}
fn rows(ids: &[i32]) -> Rc<VecModel<Row>> {
Rc::new(VecModel::from(
ids.iter()
.map(|&id| Row {
id,
selected: false,
})
.collect::<Vec<_>>(),
))
}
fn project(model: &VecModel<Row>, selection: &[i32]) {
project_selection(model, |r| selection.contains(&r.id), |r| &mut r.selected);
}
fn flags(model: &VecModel<Row>) -> Vec<bool> {
(0..model.row_count())
.filter_map(|i| model.row_data(i))
.map(|r| r.selected)
.collect()
}
#[test]
fn project_marks_selected_rows() {
let model = rows(&[1, 2, 3]);
project(&model, &[2]);
assert_eq!(flags(&model), vec![false, true, false]);
}
#[test]
fn project_clears_stale_flags() {
let model = rows(&[1, 2]);
project(&model, &[1]);
project(&model, &[2]);
assert_eq!(flags(&model), vec![false, true]);
}
#[test]
fn project_only_writes_changed_rows() {
let model = rows(&[1, 2]);
project(&model, &[1]);
let before = flags(&model);
project(&model, &[1]);
assert_eq!(flags(&model), before);
assert_eq!(before, vec![true, false]);
}
#[test]
fn project_into_an_empty_model_is_a_no_op() {
let model = rows(&[]);
project(&model, &[1, 2]);
assert_eq!(flags(&model), Vec::<bool>::new());
}
#[test]
fn selected_rows_reads_back_what_was_projected() {
let model = rows(&[1, 2, 3]);
project(&model, &[3, 1]);
assert_eq!(selected_rows(&model, |r| r.id, |r| r.selected), vec![1, 3]);
}
#[test]
fn selected_rows_is_empty_when_nothing_is_selected() {
let model = rows(&[1, 2]);
assert_eq!(
selected_rows(&model, |r| r.id, |r| r.selected),
Vec::<i32>::new()
);
}
#[test]
fn gesture_round_trip_through_the_rows() {
let model = rows(&[1, 2, 3]);
for (item, shift) in [(2, false), (3, true), (2, true)] {
let current = selected_rows(&model, |r| r.id, |r| r.selected);
let next = resolve_click(¤t, item, shift);
project(&model, &next);
}
assert_eq!(flags(&model), vec![false, false, true]);
}
#[test]
fn negative_ids_work() {
assert_eq!(resolve_click(&[-1], -2, true), vec![-1, -2]);
}
}