Skip to main content

ListDelegate

faststep

Trait ListDelegate 

Source 
pub trait ListDelegate<'text, ItemId> {
    type Message: Copy;

    // Required method
    fn draw_row<D>(
        &self,
        display: &mut D,
        row: ListRow<ItemId>,
        env: &ViewEnvironment<'_, 'text>,
    )
       where D: DrawTarget<Color = Rgb565>;

    // Provided methods
    fn did_highlight_item(
        &mut self,
        _selection: ListSelection<ItemId>,
        _highlighted: bool,
    ) -> Option<Self::Message> { ... }
    fn did_select_item(
        &mut self,
        _selection: ListSelection<ItemId>,
    ) -> Option<Self::Message> { ... }
}
Expand description

Delegate responsible for drawing list rows and reacting to row changes.

Required Associated Types§

Source

type Message: Copy

Application-defined message emitted by delegate callbacks.

Required Methods§

Source

fn draw_row<D>( &self, display: &mut D, row: ListRow<ItemId>, env: &ViewEnvironment<'_, 'text>, )
where D: DrawTarget<Color = Rgb565>,

Draws one row.

Provided Methods§

Source

fn did_highlight_item( &mut self, _selection: ListSelection<ItemId>, _highlighted: bool, ) -> Option<Self::Message>

Called when a row highlight state changes.

Examples found in repository?
src/list_view/interaction.rs (line 163)
148    fn set_highlighted_index<'text>(&mut self, next: Option<usize>) -> Option<Delegate::Message>
149    where
150        Delegate: ListDelegate<'text, DataSource::ItemId>,
151    {
152        if self.highlighted_index == next {
153            return None;
154        }
155
156        let previous = self.highlighted_index.take();
157        self.highlighted_index = next.filter(|index| *index < self.data_source.item_count());
158
159        let mut message = None;
160        if let Some(index) = previous
161            && let Some(selection) = self.selection_for_index(index)
162        {
163            message = message.or(self.delegate.did_highlight_item(selection, false));
164        }
165        if let Some(index) = self.highlighted_index
166            && let Some(selection) = self.selection_for_index(index)
167        {
168            message = message.or(self.delegate.did_highlight_item(selection, true));
169        }
170        message
171    }
Source

fn did_select_item( &mut self, _selection: ListSelection<ItemId>, ) -> Option<Self::Message>

Called when a row is selected.

Examples found in repository?
src/list_view/interaction.rs (line 76)
12    pub fn handle_touch<'text>(
13        &mut self,
14        touch: TouchEvent,
15        viewport: Rectangle,
16    ) -> ListEvent<Delegate::Message>
17    where
18        Delegate: ListDelegate<'text, DataSource::ItemId>,
19    {
20        if !touch.within(viewport) && !self.scroll_view.is_dragging() {
21            return ListEvent::none();
22        }
23
24        let local_touch = offset_touch(touch, viewport.top_left);
25        let touched_index = self.item_index_at_point(touch.point, viewport);
26        let was_dragging = self.scroll_view.is_dragging();
27        let previous_highlight = self.highlighted_index;
28        let previous_selection = self.selected_index;
29        let mut activity = ListActivity::None;
30        let mut message = None;
31
32        let scrolled = match touch.phase {
33            TouchPhase::Start => {
34                self.touch_started_inside = touch.within(viewport);
35                self.tap_candidate = self.touch_started_inside;
36                self.scroll_view.begin_drag(local_touch);
37                message = message.or(
38                    self.set_highlighted_index(touched_index.filter(|_| self.touch_started_inside))
39                );
40                false
41            }
42            TouchPhase::Move => {
43                let changed =
44                    self.scroll_view
45                        .drag(local_touch, self.content_height(), viewport.size.height);
46                if changed || self.scroll_view.is_scrolling() {
47                    self.tap_candidate = false;
48                    message = message.or(self.set_highlighted_index(None));
49                } else {
50                    let next_highlight = if self.touch_started_inside && touch.within(viewport) {
51                        touched_index
52                    } else {
53                        None
54                    };
55                    message = message.or(self.set_highlighted_index(next_highlight));
56                }
57                changed
58            }
59            TouchPhase::End | TouchPhase::Cancel => {
60                let changed = self.scroll_view.end_drag(
61                    local_touch,
62                    self.content_height(),
63                    viewport.size.height,
64                );
65
66                if matches!(touch.phase, TouchPhase::End)
67                    && self.touch_started_inside
68                    && self.tap_candidate
69                    && touch.within(viewport)
70                {
71                    if let Some(index) = touched_index {
72                        if self.allows_selection {
73                            self.selected_index = Some(index);
74                        }
75                        if let Some(selection) = self.selection_for_index(index) {
76                            message = message.or(self.delegate.did_select_item(selection));
77                        }
78                    }
79                }
80
81                message = message.or(self.set_highlighted_index(None));
82                self.touch_started_inside = false;
83                self.tap_candidate = false;
84                changed
85            }
86        };
87
88        let visual_state_changed = previous_highlight != self.highlighted_index
89            || previous_selection != self.selected_index;
90        let motion_active = scrolled || self.scroll_view.is_scrolling();
91
92        if motion_active {
93            activity = ListActivity::Motion;
94        } else if visual_state_changed {
95            activity = ListActivity::Interactive;
96        }
97
98        ListEvent {
99            redraw: match activity {
100                ListActivity::None => ViewRedraw::None,
101                ListActivity::Interactive | ListActivity::Motion => ViewRedraw::Dirty(viewport),
102            },
103            captured: was_dragging || touch.within(viewport) || self.touch_started_inside,
104            message,
105            activity,
106        }
107    }

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§