logo
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use crate::{
    elements::{Element, ListTileElement},
    foundation::{colorspace::Color, Id, Key, WidgetProperties},
    painting::{EdgeInsetsGeometry, NoneEdgeInsetsGeometry, NoneShapeBorder, ShapeBorder},
    services::MouseCursor,
    widgets::{FocusNode, NoneWidget, Widget},
};

use super::VisualDensity;

pub struct ListTile {
    pub key: Key,
    pub leading: Box<dyn Widget>,
    pub title: Box<dyn Widget>,
    pub subtitle: Box<dyn Widget>,
    pub trailing: Box<dyn Widget>,
    pub is_three_line: bool,
    pub dense: bool,
    pub visual_density: VisualDensity,
    pub shape: Box<dyn ShapeBorder>,
    pub content_padding: Box<dyn EdgeInsetsGeometry>,
    pub enabled: bool,
    // pub on_tap: GestureTapCallback,
    // pub on_long_press: GestureLongPressCallback,
    pub mouse_cursor: MouseCursor,
    pub selected: bool,
    pub focus_color: Color,
    pub hover_color: Color,
    pub focus_node: FocusNode,
    pub autofocus: bool,
    pub tile_color: Color,
    pub selected_tile_color: Color,
    pub enable_feedback: bool,
    pub horizontal_title_gap: f32,
    pub min_vertical_padding: f32,
    pub min_leading_width: f32,
}

impl Default for ListTile {
    fn default() -> Self {
        Self {
            key: Default::default(),
            leading: box NoneWidget,
            title: box NoneWidget,
            subtitle: box NoneWidget,
            trailing: box NoneWidget,
            is_three_line: Default::default(),
            dense: Default::default(),
            visual_density: Default::default(),
            shape: box NoneShapeBorder,
            content_padding: box NoneEdgeInsetsGeometry,
            enabled: Default::default(),
            // on_tap: Default::default(),
            // on_long_press: Default::default(),
            mouse_cursor: Default::default(),
            selected: Default::default(),
            focus_color: Default::default(),
            hover_color: Default::default(),
            focus_node: Default::default(),
            autofocus: Default::default(),
            tile_color: Default::default(),
            selected_tile_color: Default::default(),
            enable_feedback: Default::default(),
            horizontal_title_gap: Default::default(),
            min_vertical_padding: Default::default(),
            min_leading_width: Default::default(),
        }
    }
}

impl Widget for ListTile {
    fn create_element(&self) -> Box<dyn Element> {
        box ListTileElement::new(self)
    }
}

impl WidgetProperties for ListTile {
    fn key(&self) -> &Key {
        &self.key
    }

    fn x(&self) -> f32 {
        // self.x
        0.0
    }

    fn y(&self) -> f32 {
        // self.y
        0.0
    }

    fn w(&self) -> f32 {
        // self.w
        0.0
    }

    fn h(&self) -> f32 {
        // self.h
        0.0
    }

    fn w_min(&self) -> f32 {
        // self.w_min
        0.0
    }

    fn h_min(&self) -> f32 {
        // self.h_min
        0.0
    }

    fn w_max(&self) -> f32 {
        // self.w_max
        0.0
    }

    fn h_max(&self) -> f32 {
        // self.h_max
        0.0
    }

    fn parent(&self) -> Option<Id> {
        // self.parent
        None
    }

    fn depth(&self) -> f32 {
        // self.depth
        0.0
    }

    fn visible(&self) -> bool {
        // self.visible
        true
    }

    fn mouse_input(&self) -> bool {
        // self.mouse_input
        true
    }

    fn key_input(&self) -> bool {
        // self.key_input
        true
    }

    fn renderable(&self) -> bool {
        // self.renderable
        true
    }

    fn internal_visible(&self) -> bool {
        // self.internal_visible
        true
    }
}