poincare-app 0.2.0

Interactive 3D mathematical graphing application
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

use eframe::egui;
use grimdock::TabStyleOverride;
use grimdock::{
    ChildSide, DropPolicy, HeaderVisibility, Node, PaneOptions, PanelContext, PanelTree, SplitDir,
    Tab,
};

use crate::App;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum DockTab {
    Plots,
    Viewport,
    PlotProperties,
}

fn tab(title: &str, id: DockTab) -> Tab<DockTab> {
    let (icon, color) = match id {
        DockTab::Plots => ("☰", egui::Color32::from_rgb(110, 160, 220)),
        DockTab::Viewport => ("⬡", egui::Color32::from_rgb(100, 200, 140)),
        DockTab::PlotProperties => ("⚙", egui::Color32::from_rgb(210, 150, 80)), // amber
    };
    Tab::new(title, id)
        .with_leading_visual(icon)
        .with_style_override(TabStyleOverride {
            icon_color: Some(color),
            ..TabStyleOverride::none()
        })
}

pub(crate) fn build_panel_tree() -> PanelTree<DockTab> {
    let mut tree = PanelTree::new(vec![
        tab("Viewport", DockTab::Viewport).with_draggable(false)
    ]);
    tree.split_leaf(
        0,
        SplitDir::Horizontal,
        tab("Plots", DockTab::Plots),
        ChildSide::First,
    );
    tree.split_leaf(
        2,
        SplitDir::Vertical,
        tab("Plot", DockTab::PlotProperties),
        ChildSide::Second,
    );

    if let Node::Split { ratio, .. } = tree.node_mut(0) {
        *ratio = 0.19;
    }
    if let Node::Split { ratio, .. } = tree.node_mut(2) {
        *ratio = 0.72;
    }
    tree.set_pane_options(
        5,
        PaneOptions {
            header_visibility: HeaderVisibility::Hidden,
            allow_collapse: false,
            allow_tab_reorder: false,
            allow_tab_drag_out: false,
            allow_resize: true,
            drop_policy: DropPolicy::none(),
            lock_layout: false,
            paint_content_bg: false,
            ..PaneOptions::default()
        },
    );
    tree.set_pane_options(
        6,
        PaneOptions {
            allow_collapse: false,
            allow_tab_reorder: false,
            allow_tab_drag_out: false,
            allow_resize: true,
            drop_policy: DropPolicy::none(),
            lock_layout: false,
            paint_content_bg: true,
            ..PaneOptions::default()
        },
    );

    tree
}

impl App {
    pub(crate) fn dock_ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
        let mut panel_tree = self.panel_tree.take().unwrap_or_else(build_panel_tree);
        let panel_style = self.panel_style.clone();
        let output = PanelContext::new(ui, &mut panel_tree, &panel_style).show(|ui, tab| {
            self.render_dock_tab(ui, frame, *tab);
        });

        if let Some(tab) = self.pending_focus_tab.take() {
            panel_tree.focus_tab(&tab);
        }

        self.panel_tree = Some(panel_tree);

        if !output.closed_tabs.is_empty() {
            for tab in output.closed_tabs {
                let (title, target_leaf) = match tab {
                    DockTab::Plots => ("Plots", 1),
                    DockTab::Viewport => ("Viewport", 5),
                    DockTab::PlotProperties => ("Plot", 6),
                };
                self.panel_tree
                    .as_mut()
                    .expect("panel tree restored after dock render")
                    .ensure_tab_in_leaf(
                        target_leaf,
                        crate::dock::tab(title, tab).with_closable(false),
                    );
            }
        }
    }

    fn render_dock_tab(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame, tab: DockTab) {
        match tab {
            DockTab::Plots => {
                self.left_panel(ui);
            }
            DockTab::Viewport => {
                let ctx = ui.ctx().clone();
                self.viewport(&ctx, ui);
            }
            DockTab::PlotProperties => {
                egui::ScrollArea::vertical().show(ui, |ui| {
                    self.bottom_inspector(ui);
                });
            }
        }
    }
}