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

use std::ops::DerefMut;

use limn_layout::linear_layout::{LinearLayout, LinearLayoutSettings};
use limn_layout::grid_layout::GridLayout;

use resources::WidgetId;

use app::App;

use widget::Widget;
use event::EventArgs;

pub use self::solver::LimnSolver;
pub use limn_layout::*;

impl Widget {
    /// Set this widgets container to be a `LinearLayout`.
    /// Children added to this widget will be arranged along one axis without overlapping.
    pub fn linear_layout(&mut self, settings: LinearLayoutSettings) -> &mut Self {
        let container = LinearLayout::new(self.layout().deref_mut(), settings);
        self.layout().set_container(container);
        self
    }

    /// Set this widgets container to be a `GridLayout`.
    /// Children added to this widget will be arranged in a grid.
    pub fn grid(&mut self, num_columns: usize) -> &mut Self {
        let container = GridLayout::new(self.layout().deref_mut(), num_columns);
        self.layout().set_container(container);
        self
    }
}

#[derive(Clone)]
pub struct UpdateLayout(pub Widget);
#[derive(Debug, Copy, Clone)]
pub struct ResizeWindow;
#[derive(Debug, Clone)]
pub struct LayoutChanged(pub Vec<(usize, VarType, f64)>);
#[derive(Debug, Copy, Clone)]
pub struct LayoutUpdated;

impl App {
    pub fn add_layout_handlers(&mut self) {
        self.add_handler(|_: &ResizeWindow, args: EventArgs| {
            args.ui.resize_window_to_fit();
        });
        self.add_handler(|event: &UpdateLayout, args: EventArgs| {
            let event = event.clone();
            let UpdateLayout(widget_ref) = event;
            let mut widget = widget_ref.widget_mut();
            args.ui.solver.update_layout(&mut widget.layout);
            args.ui.check_layout_changes();
        });
        self.add_handler(|event: &LayoutChanged, args: EventArgs| {
            let changes = &event.0;
            for &(widget_id, var, value) in changes {
                let widget_id = WidgetId(widget_id);
                if let Some(mut widget) = args.ui.get_widget(widget_id) {
                    debug!("{:?}: {:?} = {}", widget.name(), var, value);
                    widget.update_bounds(var, value as f32);
                }
            }
            // redraw everything when layout changes, for now
            args.ui.redraw();
        });
    }
}