jolly 0.3.0

a bookmark manager meets an application launcher, developed with iced
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use iced::{advanced, keyboard, widget};

use crate::custom;
use crate::entry;
use crate::store;
use crate::theme;
use crate::ui;

const PADDING: u16 = 2;

#[derive(Default)]
pub struct SearchResults {
    entries: Vec<entry::EntryId>,
    selected: usize,
    settings: ui::UISettings,
}

impl std::hash::Hash for SearchResults {
    fn hash<H>(&self, state: &mut H)
    where
        H: std::hash::Hasher,
    {
        self.entries.hash(state);
        self.selected.hash(state);
    }
}

impl std::cmp::PartialEq for SearchResults {
    fn eq(&self, other: &Self) -> bool {
        use std::hash::{Hash, Hasher};

        let mut s = std::collections::hash_map::DefaultHasher::new();
        self.hash(&mut s);

        let mut o = std::collections::hash_map::DefaultHasher::new();
        other.hash(&mut o);
        s.finish() == o.finish()
    }
}

impl SearchResults {
    pub fn new(results: impl Iterator<Item = entry::EntryId>, settings: &ui::UISettings) -> Self {
        SearchResults {
            entries: results.take(settings.max_results).collect(),
            selected: 0,
            settings: settings.clone(),
        }
    }

    pub fn set_selection(&mut self, id: entry::EntryId) {
        if id < self.entries.len() {
            self.selected = id;
        }
    }

    pub fn selected(&self) -> Option<entry::EntryId> {
        self.entries.get(self.selected).map(|e| *e)
    }

    pub fn handle_kb(&mut self, event: keyboard::Event) {
        let code = match event {
            keyboard::Event::KeyPressed {
                key_code: code,
                modifiers: _,
            } => code,
            _ => return,
        };

        if code == keyboard::KeyCode::Up {
            if self.selected > 0 {
                self.selected -= 1;
            }
        }
        if code == keyboard::KeyCode::Down {
            let max_num = self.entries.len();
            if self.selected + 1 < max_num {
                self.selected += 1;
            }
        }
    }

    pub fn view<'a, F, Renderer>(
        &'a self,
        searchtext: &str,
        store: &'a store::Store,
        f: F,
    ) -> iced::Element<'a, crate::Message, Renderer>
    where
        F: 'static + Copy + Fn(entry::EntryId) -> crate::Message,
        Renderer: advanced::renderer::Renderer<Theme = theme::Theme> + 'a,
        Renderer: advanced::text::Renderer,
        Renderer: advanced::image::Renderer<Handle = widget::image::Handle>,
    {
        // if we dont have any entries, return an empty search results
        // (if we dont do this, the empty column will still show its
        // padding
        if self.entries.is_empty() {
            return widget::Space::with_height(0).into();
        }

        let mut column = widget::Column::new().padding(PADDING);
        for (i, e) in self.entries.iter().enumerate() {
            let entry = store.get(*e);
            // unwrap will never panic since UI_MAX_RESULTS is const
            let entry_widget =
                entry.build_entry(f, searchtext, &self.settings, i == self.selected, *e);

            let mouse_area = custom::MouseArea::new(entry_widget)
                .on_mouse_enter(crate::Message::EntryHovered(i));

            column = column.push(mouse_area);
        }
        let element: iced::Element<'_, _, _> = column.into();
        element
    }

    pub fn entries(&self) -> &[entry::EntryId] {
        &self.entries
    }
}