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, TextButtonElement},
    foundation::{Id, Key, WidgetProperties, ValueChanged},
    ui::{Clip, VoidCallback},
    widgets::{FocusNode, NoneWidget, Widget},
};

use super::ButtonStyle;

// defaultStyleOf(BuildContext context): ButtonStyle
// Defines the button's default appearance.
// override
//
// themeStyleOf(BuildContext context): ButtonStyle?
// Returns the TextButtonThemeData.style of the closest TextButtonTheme ancestor.
// override

pub struct TextButton {
    // True if this widget will be selected as the initial focus when no other node in its scope is currently focused.
    pub autofocus: bool,
    
    // Typically the button's label.
    pub child: Box<dyn Widget>,
    
    // The content will be clipped (or not) according to this option.
    pub clip_behavior: Clip,
    
    // Whether the button is enabled or disabled.
    pub enabled: bool,
    
    // An optional focus node to use as the focus node for this widget.
    pub focus_node: FocusNode,
    
    // Controls how one widget replaces another widget in the tree.
    pub key: Key,
    
    // Handler called when the focus changes.
    pub on_focus_change: Option<ValueChanged<bool>>,
    
    // Called when a pointer enters or exits the button response area.
    pub on_hover: Option<ValueChanged<bool>>,
    
    // Called when the button is long-pressed.
    pub on_long_press: Option<VoidCallback>,
    
    // Called when the button is tapped or otherwise activated.
    pub on_pressed: Option<VoidCallback>,
    
    // Customizes this button's appearance.
    pub style: ButtonStyle
}

impl Default for TextButton {
    fn default() -> Self {
        Self {
            autofocus: Default::default(),
            child: box NoneWidget,
            clip_behavior: Default::default(),
            enabled: Default::default(),
            focus_node: Default::default(),
            key: Default::default(),
            on_focus_change: Default::default(),
            on_hover: Default::default(),
            on_long_press: Default::default(),
            on_pressed: Default::default(),
            style: Default::default(),
        }
    }
}

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

impl WidgetProperties for TextButton {
    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
    }
}