sweeten 0.14.0

`sweeten` your daily `iced` brew
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

//! Demonstrates scroll-to-item functionality using position tracking.
//!
//! This example shows:
//! - Setting a [`position::Id`] on a [`Column`] to enable position tracking
//! - Using [`position::find_position`] to query a child's layout bounds
//! - Scrolling to a specific item with [`scroll_to`]
//!
//! Run with: `cargo run --example scroll_to_item`

use iced::widget::scrollable::AbsoluteOffset;
use iced::widget::{Id, container, scrollable, text};
use iced::{Element, Fill, Task};

use sweeten::widget::operation::position;
use sweeten::widget::{button, column, row};

const ITEM_COUNT: usize = 100;

pub fn main() -> iced::Result {
    iced::application(App::new, App::update, App::view)
        .title("sweeten - scroll to item")
        .window_size((500.0, 600.0))
        .run()
}

struct App {
    column_id: position::Id,
    scrollable_id: Id,
}

#[derive(Debug, Clone)]
enum Message {
    ScrollTo(usize),
    ScrollResult(Option<iced::Rectangle>),
}

impl App {
    fn new() -> (Self, Task<Message>) {
        (
            Self {
                column_id: position::Id::unique(),
                scrollable_id: Id::unique(),
            },
            Task::none(),
        )
    }

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::ScrollTo(index) => {
                return position::find_position(self.column_id.clone(), index)
                    .map(Message::ScrollResult);
            }
            Message::ScrollResult(Some(bounds)) => {
                return iced::widget::operation::scroll_to(
                    self.scrollable_id.clone(),
                    AbsoluteOffset {
                        x: None,
                        y: Some(bounds.y),
                    },
                );
            }
            Message::ScrollResult(None) => {}
        }
        Task::none()
    }

    fn view(&self) -> Element<'_, Message> {
        let items = (0..ITEM_COUNT).map(|i| {
            container(text(format!("Item {i}")))
                .style(container::rounded_box)
                .padding(10)
                .width(Fill)
                .into()
        });

        let buttons: Vec<Element<'_, Message>> = [0, 10, 25, 50, 75, 99]
            .iter()
            .map(|&i| {
                button(text(format!("Item {i}")).size(12))
                    .on_press(Message::ScrollTo(i))
                    .into()
            })
            .collect();

        let sidebar = column(buttons).spacing(5).width(100);

        let content = scrollable(
            column(items)
                .id(self.column_id.clone())
                .spacing(5)
                .width(Fill),
        )
        .id(self.scrollable_id.clone())
        .spacing(10)
        .height(Fill)
        .width(Fill);

        row![sidebar, content].spacing(10).padding(20).into()
    }
}