Skip to main content

functora_egui/layout/
shell.rs

1use std::cell::Cell;
2
3use crate::nav::NavHistory;
4use crate::responsive::responsive_ext::ResponsiveExt;
5use crate::route::RouteMetadata;
6use crate::theme::shadcn_theme_ext::ShadcnThemeExt;
7use crate::theme_extra::Theme;
8use crate::widgets::breadcrumb::{Breadcrumb, NavAction};
9
10type FooterFn<'a> = Box<dyn FnOnce(&mut egui::Ui) + 'a>;
11
12#[must_use]
13pub fn initial_sidebar_collapsed(ctx: &egui::Context) -> bool {
14    let width = sidebar_startup_width(ctx);
15    if width == 0.0 {
16        true
17    } else {
18        width < crate::responsive::breakpoint::Breakpoint::MOBILE_MAX_WIDTH
19    }
20}
21
22#[cfg(all(target_arch = "wasm32", feature = "web"))]
23fn sidebar_startup_width(ctx: &egui::Context) -> f32 {
24    web_sys::window()
25        .and_then(|win| {
26            win.visual_viewport()
27                .map(|vp| crate::utils::f64_to_f32(vp.width()))
28                .or_else(|| {
29                    win.inner_width()
30                        .ok()
31                        .and_then(|v| v.as_f64())
32                        .map(crate::utils::f64_to_f32)
33                })
34        })
35        .unwrap_or_else(|| ctx.input(|i| i.viewport_rect().width()))
36}
37
38#[cfg(not(all(target_arch = "wasm32", feature = "web")))]
39fn sidebar_startup_width(ctx: &egui::Context) -> f32 {
40    ctx.input(|i| i.viewport_rect().width())
41}
42
43fn sync_sidebar_collapsed(ctx: &egui::Context, collapsed: bool) -> bool {
44    let width = ctx.input(|i| i.viewport_rect().width());
45    let is_mobile = ctx.on_mobile();
46    let init_id = egui::Id::unique("shell_sidebar_init_done");
47    let prev_id = egui::Id::unique("shell_prev_is_mobile");
48    let init_done = ctx.data(|d| d.get_temp::<bool>(init_id).unwrap_or(false));
49    if !init_done {
50        if width == 0.0 {
51            let _ = ctx.data_mut(|d| d.insert_temp(prev_id, true));
52            true
53        } else {
54            let _ = ctx.data_mut(|d| {
55                let _ = d.insert_temp(init_id, true);
56                d.insert_temp(prev_id, is_mobile)
57            });
58            is_mobile
59        }
60    } else if width == 0.0 {
61        collapsed
62    } else {
63        let prev = ctx.data(|d| d.get_temp::<bool>(prev_id).unwrap_or(is_mobile));
64        let _ = ctx.data_mut(|d| d.insert_temp(prev_id, is_mobile));
65        match (is_mobile, prev) {
66            (true, false) => true,
67            (false, true) => false,
68            (true, true) | (false, false) => collapsed,
69        }
70    }
71}
72
73#[must_use]
74pub fn sidebar_effective_width(ctx: &egui::Context, labels: &[&str]) -> f32 {
75    let spacing = ctx.responsive_spacing();
76    let max_text = labels
77        .iter()
78        .map(|name| {
79            let font_id = egui::FontId::proportional(14.0);
80            crate::text::natural_width(ctx, (*name).to_owned(), font_id)
81        })
82        .fold(0.0, f32::max);
83    let icon = spacing.touch_height * 0.5;
84    let toggle_size = crate::tokens::component_size::ComponentSize::Sm
85        .metrics_for(&spacing)
86        .0;
87    max_text + icon + spacing.gap + spacing.touch_padding * 2.0 + spacing.gap + toggle_size
88}
89
90/// Clamps the sidebar width to the viewport: full label width where it fits,
91/// shrunk instead of overflowing on narrow screens.
92fn clamped_sidebar_width(ctx: &egui::Context, sidebar_labels: &[&str]) -> f32 {
93    let spacing = ctx.responsive_spacing();
94    let screen_width = ctx.input(|i| i.viewport_rect().width());
95    let max_allowed_outer = (screen_width - spacing.page_padding * 2.0).max(0.0);
96    sidebar_effective_width(ctx, sidebar_labels).min((max_allowed_outer - 16.0).max(0.0))
97}
98
99/// Renders the collapsible sidebar and folds a mobile close request back
100/// into `collapsed`. Shared by the desktop side panel and the mobile drawer.
101fn render_sidebar(
102    ui: &mut egui::Ui,
103    effective: f32,
104    collapsed: &mut bool,
105    sidebar: &mut dyn FnMut(&mut egui::Ui) -> bool,
106) {
107    let close = std::cell::Cell::new(false);
108    let _ = crate::widgets::sidebar::widget::Sidebar::new()
109        .width(effective)
110        .collapsible()
111        .show(ui, collapsed, |side_ui| {
112            close.set(sidebar(side_ui));
113        });
114    if close.get() {
115        *collapsed = true;
116    }
117}
118
119pub struct Shell<'a, R>
120where
121    R: RouteMetadata,
122{
123    brand: &'a str,
124    brand_icon: Option<crate::icons::lucide_icon::LucideIcon>,
125    version: Option<&'a str>,
126    collapsed: &'a mut bool,
127    theme: Option<&'a mut Theme>,
128    language: Option<&'a Cell<functora_core::i18n::Language>>,
129    search_label: Option<&'a str>,
130    search_shortcut: Option<&'a str>,
131    on_brand: Option<Box<dyn FnMut() + 'a>>,
132    on_search: Option<Box<dyn FnMut() + 'a>>,
133    sidebar: Box<dyn FnMut(&mut egui::Ui) -> bool + 'a>,
134    breadcrumb: Option<(&'a R, &'a NavHistory<R>)>,
135    sidebar_labels: Vec<&'a str>,
136    scroll_top: bool,
137    footer: Option<FooterFn<'a>>,
138    system_back: bool,
139}
140
141impl<'a, R> Shell<'a, R>
142where
143    R: RouteMetadata,
144{
145    pub fn new(
146        brand: &'a str,
147        collapsed: &'a mut bool,
148        sidebar: impl FnMut(&mut egui::Ui) -> bool + 'a,
149    ) -> Self {
150        Self {
151            brand,
152            brand_icon: None,
153            version: None,
154            collapsed,
155            theme: None,
156            language: None,
157            search_label: None,
158            search_shortcut: None,
159            on_brand: None,
160            on_search: None,
161            sidebar: Box::new(sidebar),
162            breadcrumb: None,
163            sidebar_labels: Vec::new(),
164            scroll_top: false,
165            footer: None,
166            system_back: true,
167        }
168    }
169
170    #[must_use]
171    pub fn brand_icon(mut self, icon: Option<crate::icons::lucide_icon::LucideIcon>) -> Self {
172        self.brand_icon = icon;
173        self
174    }
175
176    #[must_use]
177    pub fn version(mut self, version: &'a str) -> Self {
178        self.version = Some(version);
179        self
180    }
181
182    #[must_use]
183    pub fn theme(mut self, theme: &'a mut Theme) -> Self {
184        self.theme = Some(theme);
185        self
186    }
187
188    #[must_use]
189    pub fn language(mut self, language: &'a Cell<functora_core::i18n::Language>) -> Self {
190        self.language = Some(language);
191        self
192    }
193
194    #[must_use]
195    pub fn search(mut self, label: &'a str, shortcut: Option<&'a str>) -> Self {
196        self.search_label = Some(label);
197        self.search_shortcut = shortcut;
198        self
199    }
200
201    #[must_use]
202    pub fn on_brand(mut self, f: impl FnMut() + 'a) -> Self {
203        self.on_brand = Some(Box::new(f));
204        self
205    }
206
207    #[must_use]
208    pub fn on_search(mut self, f: impl FnMut() + 'a) -> Self {
209        self.on_search = Some(Box::new(f));
210        self
211    }
212
213    #[must_use]
214    pub fn breadcrumb(mut self, route: &'a R, history: &'a NavHistory<R>) -> Self {
215        self.breadcrumb = Some((route, history));
216        self
217    }
218
219    #[must_use]
220    pub fn sidebar_labels(mut self, labels: impl IntoIterator<Item = &'a str>) -> Self {
221        self.sidebar_labels = labels.into_iter().collect();
222        self
223    }
224
225    #[must_use]
226    pub fn scroll_top(mut self, top: bool) -> Self {
227        self.scroll_top = top;
228        self
229    }
230
231    #[must_use]
232    pub fn footer(mut self, footer: impl FnOnce(&mut egui::Ui) + 'a) -> Self {
233        self.footer = Some(Box::new(footer));
234        self
235    }
236
237    #[must_use]
238    pub fn system_back(mut self, enabled: bool) -> Self {
239        self.system_back = enabled;
240        self
241    }
242
243    pub fn show(
244        self,
245        ui: &mut egui::Ui,
246        content: impl FnOnce(&mut egui::Ui),
247    ) -> Option<NavAction<R>> {
248        let Self {
249            brand,
250            brand_icon,
251            version,
252            collapsed,
253            theme,
254            language,
255            search_label,
256            search_shortcut,
257            on_brand,
258            mut on_search,
259            mut sidebar,
260            breadcrumb,
261            sidebar_labels,
262            scroll_top,
263            footer,
264            system_back,
265        } = self;
266        let ctx = ui.ctx().clone();
267        if let Some(lang_cell) = language {
268            crate::language::set_language(&ctx, lang_cell.get());
269        }
270        let route_id = egui::Id::unique("shell_prev_route");
271        let prev_route = ctx.data(|d| d.get_temp::<R>(route_id));
272        let route_changed = breadcrumb.is_some_and(|(route, _)| prev_route.as_ref() != Some(route));
273        if route_changed && let Some((route, _)) = breadcrumb {
274            let _ = ctx.data_mut(|d| d.insert_temp(route_id, route.clone()));
275        }
276        let mut collapsed_val = sync_sidebar_collapsed(&ctx, *collapsed);
277        let mut breadcrumb_action = system_back_action(&ctx, system_back, breadcrumb);
278        let brand_clicked = std::rc::Rc::new(std::cell::Cell::new(false));
279        if let Some(th) = theme.as_deref() {
280            crate::theme_extra::set_theme(&ctx, *th);
281        }
282        let theme_bg = ShadcnThemeExt::shadcn_theme(&ctx);
283        let top = egui::Panel::top("top_bar")
284            .frame(egui::Frame::NONE.fill(theme_bg.card))
285            .show_separator_line(false)
286            .show(ui, |top_ui| {
287                let mut navbar = crate::widgets::navbar::widget::Navbar::new(brand);
288                navbar = navbar.brand_icon(brand_icon);
289                if let Some(v) = version {
290                    navbar = navbar.version(v);
291                }
292                if let Some(l) = search_label {
293                    navbar = navbar.search(l, search_shortcut);
294                }
295                let mut on_brand_wrapper: Option<Box<dyn FnMut() + 'a>> = on_brand.map(|mut cb| {
296                    let clicked = std::rc::Rc::clone(&brand_clicked);
297                    Box::new(move || {
298                        clicked.set(true);
299                        cb();
300                    }) as Box<dyn FnMut() + 'a>
301                });
302                let brand_cb: Option<&mut dyn FnMut()> = on_brand_wrapper
303                    .as_mut()
304                    .map(|b| b.as_mut() as &mut dyn FnMut());
305                let search_cb: Option<&mut dyn FnMut()> =
306                    on_search.as_mut().map(|b| b.as_mut() as &mut dyn FnMut());
307                let _ = navbar.show(
308                    top_ui,
309                    &mut collapsed_val,
310                    theme,
311                    language,
312                    brand_cb,
313                    search_cb,
314                );
315            });
316        let _ = ui.painter().hline(
317            top.response.rect.x_range(),
318            top.response.rect.max.y - 0.5,
319            egui::Stroke::new(1.0, theme_bg.border),
320        );
321        if !ctx.on_mobile() {
322            let is_rail = collapsed_val;
323            let spacing = ctx.responsive_spacing();
324            let effective = if is_rail {
325                spacing.touch_height
326            } else {
327                clamped_sidebar_width(&ctx, &sidebar_labels)
328            };
329            let ppp = ctx.pixels_per_point();
330            let panel_outer = if ppp > 0.0 {
331                ((effective + 16.0) * ppp).round() / ppp
332            } else {
333                effective + 16.0
334            };
335            let panel_fill = if is_rail {
336                theme_bg.background
337            } else {
338                theme_bg.card
339            };
340            let _ = egui::Panel::right("sidebar_panel")
341                .exact_size(panel_outer)
342                .frame(egui::Frame::NONE.fill(panel_fill))
343                .resizable(false)
344                .show_separator_line(false)
345                .show(ui, |panel_ui| {
346                    let mut tmp = collapsed_val;
347                    let _ = egui::ScrollArea::vertical().show(panel_ui, |scroll_ui| {
348                        render_sidebar(scroll_ui, effective, &mut tmp, &mut sidebar);
349                    });
350                    collapsed_val = tmp;
351                });
352        }
353        let _ = egui::CentralPanel::default()
354            .frame(egui::Frame::NONE.fill(theme_bg.background))
355            .show(ui, |central_ui| {
356                if central_ui.on_mobile() {
357                    let effective = clamped_sidebar_width(central_ui.ctx(), &sidebar_labels);
358                    let mut tmp = collapsed_val;
359                    render_sidebar(central_ui, effective, &mut tmp, &mut sidebar);
360                    collapsed_val = tmp;
361                    central_ui.add_space(-central_ui.spacing().item_spacing.y);
362                }
363                if let Some((route, history)) = breadcrumb {
364                    render_breadcrumb_strip(
365                        central_ui,
366                        route,
367                        history,
368                        !brand_clicked.get(),
369                        language,
370                        &mut breadcrumb_action,
371                    );
372                }
373                render_scrolled_content(central_ui, scroll_top, route_changed, footer, content);
374            });
375        *collapsed = collapsed_val;
376        breadcrumb_action
377    }
378}
379
380/// Maps the hardware back button onto a shell navigation action: `Back`
381/// when the history can go back, consumed otherwise.
382fn system_back_action<R: RouteMetadata>(
383    ctx: &egui::Context,
384    system_back: bool,
385    breadcrumb: Option<(&R, &NavHistory<R>)>,
386) -> Option<NavAction<R>> {
387    if !system_back {
388        None
389    } else if let Some((_, history)) = breadcrumb {
390        let mut do_nav = false;
391        let _ =
392            crate::platform::android_back::handle_system_back(ctx, history.can_go_back(), || {
393                do_nav = true
394            });
395        do_nav.then_some(NavAction::Back)
396    } else {
397        let _ = crate::platform::android_back::handle_system_back(ctx, false, || {});
398        None
399    }
400}
401
402/// Renders the breadcrumb strip when there is anywhere to go, recording the
403/// clicked action into `breadcrumb_action`.
404fn render_breadcrumb_strip<R: RouteMetadata>(
405    central_ui: &mut egui::Ui,
406    route: &R,
407    history: &NavHistory<R>,
408    brand_alive: bool,
409    language: Option<&std::cell::Cell<functora_core::i18n::Language>>,
410    breadcrumb_action: &mut Option<NavAction<R>>,
411) {
412    let should_show = brand_alive
413        && (history.can_go_back() || history.can_go_forward() || route.parent().is_some());
414    if should_show {
415        let lang = language.map_or_else(
416            functora_core::i18n::detect_browser_language,
417            std::cell::Cell::get,
418        );
419        let available_w = central_ui.available_width();
420        let strip_theme = ShadcnThemeExt::shadcn_theme(central_ui.ctx());
421        let strip = egui::Frame::NONE
422            .fill(strip_theme.card)
423            .inner_margin(egui::Margin::symmetric(12, 8))
424            .show(central_ui, |strip_ui| {
425                strip_ui.set_min_width(available_w - 24.0);
426                if let Some(action) = Breadcrumb::new(route, history).show(strip_ui, lang) {
427                    *breadcrumb_action = Some(action);
428                }
429            });
430        let _ = central_ui.painter().hline(
431            central_ui.max_rect().x_range(),
432            strip.response.rect.max.y + 0.5,
433            egui::Stroke::new(1.0, strip_theme.border),
434        );
435        central_ui.add_space(8.0);
436    }
437}
438
439/// Renders the centered, scrollable page content with the footer docked at
440/// its end, resetting the scroll position when the route changed.
441fn render_scrolled_content(
442    central_ui: &mut egui::Ui,
443    scroll_top: bool,
444    route_changed: bool,
445    mut footer: Option<FooterFn<'_>>,
446    content: impl FnOnce(&mut egui::Ui),
447) {
448    let spacing = central_ui.responsive_spacing();
449    let available = central_ui.available_width();
450    let content_width = available.min(spacing.content_max_width);
451    let margin = ((available - content_width) * 0.5).max(0.0);
452    let inner_width = (content_width - 2.0 * spacing.page_padding).max(0.0);
453    let mut scroll = egui::ScrollArea::vertical().auto_shrink([false; 2]);
454    if scroll_top || route_changed {
455        scroll = scroll.vertical_scroll_offset(0.0);
456    }
457    let _ = scroll.show(central_ui, |scroll_ui| {
458        scroll_ui.add_space(spacing.page_padding);
459        let _ = scroll_ui.horizontal_top(|h_ui| {
460            h_ui.add_space(margin);
461            h_ui.add_space(spacing.page_padding);
462            let _ = h_ui.vertical(|v_ui| {
463                v_ui.set_max_width(inner_width);
464                content(v_ui);
465                if let Some(f) = footer.take() {
466                    v_ui.add_space(16.0);
467                    let _ = crate::widgets::footer::widget::Footer::new().show(v_ui, f);
468                    v_ui.add_space(12.0);
469                } else {
470                    v_ui.add_space(48.0);
471                }
472            });
473            h_ui.add_space(spacing.page_padding);
474            h_ui.add_space(margin);
475        });
476    });
477}