lemna 0.4.0

A Reactive UI framework for Rust
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

use std::any::Any;
use std::fmt;
use std::sync::{Arc, RwLock};

use ahash::AHasher;

use crate::base_types::*;
use crate::event::{self, Event};
use crate::font_cache::FontCache;
use crate::layout::*;
use crate::node::Node;
use crate::render::{Caches, Renderable};

pub type Message = Box<dyn Any>;
pub type State = Box<dyn Any>;
// AHasher makes it easier to make reproducible hashes
pub type ComponentHasher = AHasher;

#[macro_export]
macro_rules! msg {
    ($e:expr) => {
        Box::new($e)
    };
}

pub struct RenderContext {
    pub aabb: AABB,
    pub inner_scale: Option<Scale>,
    pub caches: Caches,
    pub prev_state: Option<Vec<Renderable>>,
    pub font_cache: Arc<RwLock<FontCache>>,
    pub scale_factor: f32,
}

pub trait Component: fmt::Debug {
    fn init(&mut self) {}

    fn new_props(&mut self) {}

    fn update(&mut self, msg: Message) -> Vec<Message> {
        vec![msg]
    }

    fn view(&self) -> Option<Node> {
        None
    }

    fn render(&mut self, _context: RenderContext) -> Option<Vec<Renderable>> {
        None
    }

    fn replace_state(&mut self, _other: State) {}

    fn take_state(&mut self) -> Option<State> {
        None
    }

    fn is_dirty(&mut self) -> bool {
        false
    }

    fn render_hash(&self, hasher: &mut ComponentHasher) {
        self.props_hash(hasher);
    }

    fn props_hash(&self, _hasher: &mut ComponentHasher) {}

    fn is_mouse_over(&self, mouse_position: Point, aabb: AABB) -> bool {
        aabb.is_under(mouse_position)
    }

    fn is_mouse_maybe_over(&self, mouse_position: Point, aabb: AABB) -> bool {
        aabb.is_under(mouse_position)
    }

    fn fill_bounds(
        &mut self,
        _width: Option<f32>,
        _height: Option<f32>,
        _max_width: Option<f32>,
        _max_height: Option<f32>,
        _font_cache: &FontCache,
        _scale_factor: f32,
    ) -> (Option<f32>, Option<f32>) {
        (None, None)
    }

    /// Give component full control over its own AABB
    fn full_control(&self) -> bool {
        false
    }

    /// Called when the child of a full control Node
    fn focus(&self) -> Option<Point> {
        None
    }

    fn set_aabb(
        &mut self,
        _aabb: &mut AABB,
        _parent_aabb: AABB,
        _children: Vec<(&mut AABB, Option<Scale>, Option<Point>)>,
        _frame: AABB,
        _scale_factor: f32,
    ) {
    }

    // Scrollable containers
    fn scroll_position(&self) -> Option<ScrollPosition> {
        None
    }

    fn frame_bounds(&self, aabb: AABB, _inner_scale: Option<Scale>) -> AABB {
        aabb
    }

    // Event handlers
    fn on_click(&mut self, _event: &mut Event<event::Click>) {}
    fn on_double_click(&mut self, _event: &mut Event<event::DoubleClick>) {}
    fn on_mouse_down(&mut self, _event: &mut Event<event::MouseDown>) {}
    fn on_mouse_up(&mut self, _event: &mut Event<event::MouseUp>) {}
    fn on_mouse_enter(&mut self, _event: &mut Event<event::MouseEnter>) {}
    fn on_mouse_leave(&mut self, _event: &mut Event<event::MouseLeave>) {}
    fn on_mouse_motion(&mut self, _event: &mut Event<event::MouseMotion>) {}
    fn on_focus(&mut self, _event: &mut Event<event::Focus>) {}
    fn on_blur(&mut self, _event: &mut Event<event::Blur>) {}
    fn on_tick(&mut self, _event: &mut Event<event::Tick>) {}
    fn on_key_down(&mut self, _event: &mut Event<event::KeyDown>) {}
    fn on_key_up(&mut self, _event: &mut Event<event::KeyUp>) {}
    fn on_key_press(&mut self, _event: &mut Event<event::KeyPress>) {}
    fn on_text_entry(&mut self, _event: &mut Event<event::TextEntry>) {}
    fn on_scroll(&mut self, _event: &mut Event<event::Scroll>) {}
    fn on_drag(&mut self, _event: &mut Event<event::Drag>) {}
    fn on_drag_start(&mut self, _event: &mut Event<event::DragStart>) {}
    fn on_drag_end(&mut self, _event: &mut Event<event::DragEnd>) {}
    fn on_drag_target(&mut self, _event: &mut Event<event::DragTarget>) {}
    fn on_drag_enter(&mut self, _event: &mut Event<event::DragEnter>) {}
    fn on_drag_leave(&mut self, _event: &mut Event<event::DragLeave>) {}
    fn on_drag_drop(&mut self, _event: &mut Event<event::DragDrop>) {}
    fn on_menu_select(&mut self, _event: &mut Event<event::MenuSelect>) {}
}