use crate::kind::{Filter, Kind};
use hyprforge_clipboard::{Entry, EntryId, HistoryError};
use hyprforge_popup::Stack;
pub enum HistoryState {
Loaded(Vec<Entry>),
Unreadable(String),
}
impl HistoryState {
pub fn from_result(result: Result<hyprforge_clipboard::History, HistoryError>) -> HistoryState {
match result {
Ok(history) => HistoryState::Loaded(history.entries().to_vec()),
Err(err) => HistoryState::Unreadable(err.to_string()),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Section {
Pinned,
Recent,
}
impl Section {
pub fn title(self) -> &'static str {
match self {
Section::Pinned => "Pinned",
Section::Recent => "Recent",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Line {
Header(Section),
Entry(usize),
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ListGeometry {
pub viewport_height: f64,
pub header_height: f64,
pub row_height: f64,
pub spacing: f64,
}
const DEFAULT_GEOMETRY: ListGeometry = ListGeometry { viewport_height: 1000.0, header_height: 26.0, row_height: 34.0, spacing: 0.0 };
pub struct Model {
history: HistoryState,
query: String,
filter: Filter,
selected: usize,
notice: Option<String>,
clear_armed: bool,
geometry: ListGeometry,
scroll_offset: f64,
paste_target: Option<String>,
}
impl Model {
pub fn new(history: HistoryState) -> Model {
Model {
history,
query: String::new(),
filter: Filter::All,
selected: 0,
notice: None,
clear_armed: false,
geometry: DEFAULT_GEOMETRY,
scroll_offset: 0.0,
paste_target: None,
}
}
pub fn set_geometry(&mut self, geometry: ListGeometry) {
self.geometry = ListGeometry {
viewport_height: geometry.viewport_height.max(0.0),
header_height: geometry.header_height.max(1.0),
row_height: geometry.row_height.max(1.0),
spacing: geometry.spacing.max(0.0),
};
self.sync_scroll();
}
pub fn row_stride(&self) -> f64 {
self.geometry.row_height + self.geometry.spacing
}
pub fn paste_target(&self) -> Option<&str> {
self.paste_target.as_deref()
}
pub fn set_paste_target(&mut self, target: Option<String>) {
self.paste_target = target;
}
pub fn history(&self) -> &HistoryState {
&self.history
}
pub fn filter_text(&self) -> &str {
&self.query
}
pub fn filter(&self) -> Filter {
self.filter
}
pub fn filtered(&self) -> Vec<&Entry> {
let HistoryState::Loaded(entries) = &self.history else {
return Vec::new();
};
let needle = self.query.to_lowercase();
entries
.iter()
.filter(|e| self.filter.admits(Kind::of(&e.content)))
.filter(|e| needle.is_empty() || e.content.preview(usize::MAX).to_lowercase().contains(&needle))
.collect()
}
pub fn lines(&self) -> Vec<Line> {
let filtered = self.filtered();
let pinned = filtered.iter().take_while(|e| e.pinned).count();
let mut lines = Vec::with_capacity(filtered.len() + 2);
if pinned > 0 {
lines.push(Line::Header(Section::Pinned));
lines.extend((0..pinned).map(Line::Entry));
if pinned < filtered.len() {
lines.push(Line::Header(Section::Recent));
}
}
lines.extend((pinned..filtered.len()).map(Line::Entry));
lines
}
pub fn stack(&self) -> Stack {
let g = self.geometry;
Stack::new(
self.lines().iter().map(|line| match line {
Line::Header(_) => g.header_height,
Line::Entry(_) => g.row_height,
}),
g.spacing,
)
}
pub fn scroll_offset(&self) -> f64 {
self.scroll_offset
}
pub fn scroll_by(&mut self, delta: f64) {
let content = self.stack().content_height();
self.scroll_offset = hyprforge_popup::clamp_offset(self.scroll_offset + delta, content, self.geometry.viewport_height);
}
fn sync_scroll(&mut self) {
let lines = self.lines();
let Some(line) = lines.iter().position(|l| *l == Line::Entry(self.selected)) else {
self.scroll_offset = 0.0;
return;
};
let first = if line > 0 && matches!(lines[line - 1], Line::Header(_)) { line - 1 } else { line };
self.scroll_offset = self.stack().reveal(first, line, self.scroll_offset, self.geometry.viewport_height);
}
fn refilter(&mut self) {
self.selected = 0;
self.scroll_offset = 0.0;
self.sync_scroll();
}
pub fn type_char(&mut self, c: char) {
self.query.push(c);
self.refilter();
}
pub fn backspace(&mut self) {
self.query.pop();
self.refilter();
}
pub fn set_filter(&mut self, filter: Filter) {
if self.filter != filter {
self.filter = filter;
self.refilter();
}
}
pub fn move_selection(&mut self, delta: i32) {
let len = self.filtered().len();
if len == 0 {
self.selected = 0;
return;
}
let current = self.selected.min(len - 1) as i32;
self.selected = (current + delta).clamp(0, len as i32 - 1) as usize;
self.sync_scroll();
}
pub fn selected_index(&self) -> usize {
self.selected
}
pub fn select(&mut self, index: usize) {
let len = self.filtered().len();
if len == 0 {
self.selected = 0;
return;
}
self.selected = index.min(len - 1);
self.sync_scroll();
}
pub fn selected_entry(&self) -> Option<Entry> {
self.filtered().get(self.selected).map(|e| (*e).clone())
}
pub fn set_entry_pinned(&mut self, id: &EntryId, pinned: bool) {
let HistoryState::Loaded(entries) = &mut self.history else { return };
let Some(entry) = entries.iter_mut().find(|e| &e.id == id) else { return };
entry.pinned = pinned;
sort_entries(entries);
if let Some(new_index) = self.filtered().iter().position(|e| &e.id == id) {
self.selected = new_index;
}
self.sync_scroll();
}
pub fn remove_entry(&mut self, id: &EntryId) {
let HistoryState::Loaded(entries) = &mut self.history else { return };
entries.retain(|e| &e.id != id);
let len = self.filtered().len();
self.selected = self.selected.min(len.saturating_sub(1));
self.scroll_by(0.0);
self.sync_scroll();
}
pub fn clearable(&self) -> Vec<EntryId> {
match &self.history {
HistoryState::Loaded(entries) => entries.iter().filter(|e| !e.pinned).map(|e| e.id.clone()).collect(),
HistoryState::Unreadable(_) => Vec::new(),
}
}
pub fn clear_armed(&self) -> bool {
self.clear_armed
}
pub fn set_clear_armed(&mut self, armed: bool) {
self.clear_armed = armed;
}
pub fn notice(&self) -> Option<&str> {
self.notice.as_deref()
}
pub fn set_notice(&mut self, notice: Option<String>) {
self.notice = notice;
}
}
fn sort_entries(entries: &mut [Entry]) {
entries.sort_by(|a, b| b.pinned.cmp(&a.pinned).then(b.copied_at.cmp(&a.copied_at)).then(a.id.cmp(&b.id)));
}
#[cfg(test)]
mod tests {
use super::*;
use hyprforge_clipboard::Content;
fn text_entry(s: &str) -> Entry {
let content = Content::Text(s.to_string());
Entry { id: EntryId::of(&content), content, copied_at: 0, pinned: false }
}
fn model_with(texts: &[&str]) -> Model {
Model::new(HistoryState::Loaded(texts.iter().map(|s| text_entry(s)).collect()))
}
const G: ListGeometry = ListGeometry { viewport_height: 100.0, header_height: 26.0, row_height: 34.0, spacing: 0.0 };
fn model_with_viewport(texts: &[&str], viewport_height: f64) -> Model {
let mut model = model_with(texts);
model.set_geometry(ListGeometry { viewport_height, ..G });
model
}
#[test]
fn an_empty_query_under_all_shows_everything() {
assert_eq!(model_with(&["alpha", "beta", "gamma"]).filtered().len(), 3);
}
#[test]
fn typing_filters_case_insensitively_to_what_was_typed() {
let mut model = model_with(&["Alpha", "beta", "gamma"]);
model.type_char('A');
model.type_char('L');
let filtered = model.filtered();
assert_eq!(filtered.len(), 1);
assert_eq!(filtered[0].content, Content::Text("Alpha".into()));
}
#[test]
fn backspace_widens_the_filter_back_out() {
let mut model = model_with(&["alpha", "beta"]);
model.type_char('z');
assert!(model.filtered().is_empty());
model.backspace();
assert_eq!(model.filtered().len(), 2);
}
#[test]
fn a_tab_shows_only_its_own_kind() {
let mut model = model_with(&["https://example.org", "plain words", "/etc/hosts", "#ff0000"]);
model.set_filter(Filter::Links);
assert_eq!(model.filtered().len(), 1);
model.set_filter(Filter::Files);
assert_eq!(model.filtered()[0].content, Content::Text("/etc/hosts".into()));
model.set_filter(Filter::Text);
assert_eq!(model.filtered().len(), 2, "plain text and the colour");
}
#[test]
fn changing_tab_goes_back_to_the_top_of_the_new_list() {
let mut model = model_with(&["a", "b", "c", "https://x.org"]);
model.select(2);
model.set_filter(Filter::Text);
assert_eq!(model.selected_index(), 0);
}
#[test]
fn with_nothing_pinned_there_are_no_labels_at_all() {
let model = model_with(&["a", "b"]);
assert_eq!(model.lines(), vec![Line::Entry(0), Line::Entry(1)]);
}
#[test]
fn pinned_entries_get_their_own_label_and_the_rest_are_recent() {
let mut model = model_with(&["a", "b", "c"]);
let c = model.filtered()[2].id.clone();
model.set_entry_pinned(&c, true);
assert_eq!(
model.lines(),
vec![Line::Header(Section::Pinned), Line::Entry(0), Line::Header(Section::Recent), Line::Entry(1), Line::Entry(2)]
);
}
#[test]
fn when_everything_is_pinned_there_is_no_empty_recent_label() {
let mut model = model_with(&["a"]);
let a = model.filtered()[0].id.clone();
model.set_entry_pinned(&a, true);
assert_eq!(model.lines(), vec![Line::Header(Section::Pinned), Line::Entry(0)]);
}
#[test]
fn the_stack_has_one_line_per_line_at_its_own_height() {
let mut model = model_with(&["a", "b"]);
model.set_geometry(G);
let a = model.filtered()[1].id.clone();
model.set_entry_pinned(&a, true);
let stack = model.stack();
assert_eq!(stack.len(), model.lines().len());
assert_eq!(stack.height(0), G.header_height);
assert_eq!(stack.height(1), G.row_height);
}
#[test]
fn the_selection_stops_at_both_ends_rather_than_wrapping() {
let mut model = model_with(&["a", "b"]);
model.move_selection(5);
assert_eq!(model.selected_index(), 1);
model.move_selection(-5);
assert_eq!(model.selected_index(), 0);
}
#[test]
fn selecting_past_the_end_clamps_to_the_last_entry() {
let mut model = model_with(&["a", "b"]);
model.select(50);
assert_eq!(model.selected_index(), 1);
}
#[test]
fn pinning_the_selected_entry_keeps_it_selected_after_it_moves() {
let mut model = model_with(&["a", "b", "c"]);
model.select(2);
let c = model.filtered()[2].id.clone();
model.set_entry_pinned(&c, true);
assert_eq!(model.filtered()[model.selected_index()].id, c);
}
#[test]
fn pinning_an_id_that_is_not_in_the_history_does_nothing() {
let mut model = model_with(&["a"]);
model.set_entry_pinned(&EntryId::from_raw("not-a-real-id"), true);
assert!(model.filtered().iter().all(|e| !e.pinned));
}
#[test]
fn deleting_the_selected_entry_selects_the_one_that_was_below_it() {
let mut model = model_with(&["a", "b", "c"]);
model.select(1);
let b = model.filtered()[1].id.clone();
model.remove_entry(&b);
assert_eq!(model.filtered().len(), 2);
assert_eq!(model.selected_entry().unwrap().content, Content::Text("c".into()));
}
#[test]
fn deleting_the_last_entry_selects_the_new_last_one() {
let mut model = model_with(&["a", "b"]);
model.select(1);
let b = model.filtered()[1].id.clone();
model.remove_entry(&b);
assert_eq!(model.selected_index(), 0);
}
#[test]
fn clearing_would_remove_everything_except_what_is_pinned() {
let mut model = model_with(&["a", "b", "c"]);
let b = model.filtered()[1].id.clone();
model.set_entry_pinned(&b, true);
let clearable = model.clearable();
assert_eq!(clearable.len(), 2);
assert!(!clearable.contains(&b));
}
#[test]
fn an_unreadable_history_offers_nothing_to_clear_and_is_not_empty() {
let model = Model::new(HistoryState::Unreadable("bad toml".into()));
assert!(model.clearable().is_empty());
assert!(model.filtered().is_empty());
assert!(matches!(model.history(), HistoryState::Unreadable(_)));
}
#[test]
fn hovering_a_row_that_is_already_visible_does_not_move_the_view() {
let mut model = model_with_viewport(&["a", "b", "c", "d", "e"], 3.0 * 34.0);
model.select(2);
let before = model.scroll_offset();
model.select(1);
assert_eq!(model.scroll_offset(), before);
}
#[test]
fn moving_past_the_bottom_scrolls_by_exactly_one_row() {
let mut model = model_with_viewport(&["a", "b", "c", "d", "e"], 3.0 * 34.0);
model.move_selection(2);
assert_eq!(model.scroll_offset(), 0.0);
model.move_selection(1);
assert_eq!(model.scroll_offset(), 34.0);
}
#[test]
fn reaching_the_first_row_of_a_group_shows_its_label_too() {
let mut model = model_with_viewport(&["a", "b", "c", "d", "e", "f"], 2.0 * 34.0);
let a = model.filtered()[0].id.clone();
model.set_entry_pinned(&a, true);
model.select(5);
assert!(model.scroll_offset() > 0.0);
model.select(0);
assert_eq!(model.scroll_offset(), 0.0, "the label above the first pinned row is at the very top");
}
#[test]
fn scrolling_clamps_at_both_ends() {
let mut model = model_with_viewport(&["a", "b", "c", "d", "e"], 100.0);
model.scroll_by(-500.0);
assert_eq!(model.scroll_offset(), 0.0);
model.scroll_by(1_000_000.0);
assert_eq!(model.scroll_offset(), model.stack().content_height() - 100.0);
}
#[test]
fn a_short_list_that_already_fits_cannot_be_scrolled() {
let mut model = model_with_viewport(&["a", "b"], 1000.0);
model.scroll_by(500.0);
assert_eq!(model.scroll_offset(), 0.0);
}
#[test]
fn a_shorter_filtered_list_clamps_the_view_back_to_the_top() {
let mut model = model_with_viewport(&["aa", "ab", "cc", "dd", "ee"], 2.0 * 34.0);
model.select(4);
assert!(model.scroll_offset() > 0.0);
model.type_char('a');
assert_eq!(model.scroll_offset(), 0.0);
}
#[test]
fn a_notice_and_an_armed_clear_can_be_set_and_cleared() {
let mut model = model_with(&["a"]);
assert_eq!(model.notice(), None);
model.set_notice(Some("hyprforge-clipd isn't running".to_string()));
assert_eq!(model.notice(), Some("hyprforge-clipd isn't running"));
model.set_clear_armed(true);
assert!(model.clear_armed());
}
}