iced_table2 0.14.2

iced_table but updated to work with iced version 0.14.0
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

use iced::widget::{self, scrollable, text};
use iced::{Element, Task, Theme};
use iced_table2::table::{self, table};

fn main() -> iced::Result {
    iced::application(App::default, App::update, App::view)
        .title("Basic Table")
        .run()
}

struct App {
    columns: Vec<MyColumn>,
    rows: Vec<Person>,
    header_id: widget::Id,
    body_id: widget::Id,
}

#[derive(Debug, Clone)]
enum Message {
    SyncHeader(scrollable::AbsoluteOffset),
}

struct Person {
    name: &'static str,
    age: u32,
    email: &'static str,
}

struct MyColumn {
    title: &'static str,
    width: f32,
}

impl<'a> table::Column<'a, Message, Theme, iced::Renderer> for MyColumn {
    type Row = Person;

    fn header(&'a self, _col_index: usize) -> Element<'a, Message> {
        text(self.title).into()
    }

    fn cell(
        &'a self,
        col_index: usize,
        _row_index: usize,
        row: &'a Person,
    ) -> Element<'a, Message> {
        let content: String = match col_index {
            0 => row.name.to_string(),
            1 => row.age.to_string(),
            2 => row.email.to_string(),
            _ => String::new(),
        };
        text(content).into()
    }

    fn width(&self) -> f32 {
        self.width
    }

    fn resize_offset(&self) -> Option<f32> {
        None
    }
}

impl Default for App {
    fn default() -> Self {
        Self {
            columns: vec![
                MyColumn { title: "Name", width: 200.0 },
                MyColumn { title: "Age", width: 100.0 },
                MyColumn { title: "Email", width: 300.0 },
            ],
            rows: vec![
                Person { name: "Alice", age: 30, email: "alice@example.com" },
                Person { name: "Bob", age: 25, email: "bob@example.com" },
                Person { name: "Charlie", age: 35, email: "charlie@example.com" },
                Person { name: "Diana", age: 28, email: "diana@example.com" },
                Person { name: "Eve", age: 42, email: "eve@example.com" },
            ],
            header_id: widget::Id::unique(),
            body_id: widget::Id::unique(),
        }
    }
}

impl App {
    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::SyncHeader(offset) => {
                widget::operation::scroll_to(self.header_id.clone(), offset)
            }
        }
    }

    fn view(&self) -> Element<'_, Message> {
        table(
            self.header_id.clone(),
            self.body_id.clone(),
            &self.columns,
            &self.rows,
            Message::SyncHeader,
        )
        .cell_padding(8)
        .min_width(600.0)
        .into()
    }
}