From 40c8831bf5903cbe912af471f0a14154d682eb9e Mon Sep 17 00:00:00 2001 From: Ren Amamiya Date: Mon, 23 Nov 2026 04:21:01 +0700 Subject: [PATCH] refactor: move panel state into panel stack entity --- crates/signed_app/src/app/mod.rs | 308 ++++--------------------- crates/signed_app/src/shared/panels.rs | 113 +++------ crates/ui/src/layout/panel.rs | 287 ++++++++++++++++++++++- 3 files changed, 362 insertions(+), 346 deletions(-) diff --git a/crates/signed_app/src/app/mod.rs b/crates/signed_app/src/app/mod.rs index 906c248..de7b52c 100644 --- a/crates/signed_app/src/app/mod.rs +++ b/crates/signed_app/src/app/mod.rs @@ -2,24 +2,22 @@ pub mod helpers; mod placeholder; mod sign_in; -use std::collections::HashMap; use std::sync::Arc; use gpui::prelude::FluentBuilder as _; use gpui::{ - App, AppContext as _, Context, Entity, InteractiveElement as _, IntoElement, - ParentElement as _, Render, SharedString, Styled as _, Subscription, WeakEntity, Window, div, - px, + AppContext as _, Context, Entity, InteractiveElement as _, IntoElement, ParentElement as _, + Render, SharedString, Styled as _, Subscription, Window, div, px, }; use helpers::apply_appearance_mode; use settings::SettingsStore; use signed_state::{Backend, BackendEvent}; use ui::common::{h_flex, v_flex}; use ui::icons::IconRole; -use ui::layout::panel::{Panel, PanelRow, PanelView}; +use ui::layout::panel::{PanelRow, PanelStack, PanelView}; use ui::layout::root::RootContext as _; use ui::layout::titlebar::Titlebar; -use ui::tabs::{Tab, Tabs, TabsVariant}; +use ui::tabs::{Tabs, TabsVariant}; use ui::toast::Toast; use crate::app::placeholder::PlaceholderView; @@ -33,18 +31,10 @@ use crate::titlebar::{ }; pub struct AppRoot { - /// The repository shown in the main panel and the detail panels beside it. - main: Option, - main_order: Vec, - main_views: HashMap>, - details: Vec, - detail_views: HashMap>, - active_detail: Option, - detail_pane: Entity, + panel: Entity, titlebar: Entity, sign_in: Entity, explore: Entity, - empty: Entity, passphrase: Option>, _subscriptions: Vec, } @@ -54,11 +44,11 @@ impl AppRoot { bind_repository_shortcuts(cx); let app = cx.entity().downgrade(); - let detail_pane = cx.new(|_| DetailPane { app: app.clone() }); + let empty = cx.new(|_| PlaceholderView::new("Select a repository")); + let panel = cx.new(|cx| PanelStack::new(empty.clone().into(), cx)); let titlebar = cx.new(|cx| TitlebarView::new(app.clone(), window, cx)); let sign_in = cx.new(|_| SignedOutView::new()); let explore = cx.new(|cx| ExploreView::new(app.clone(), cx)); - let empty = cx.new(|_| PlaceholderView::new("Select a repository")); let backend = Backend::global(cx); let settings = SettingsStore::global(cx); @@ -77,11 +67,12 @@ impl AppRoot { BackendEvent::SignerChanged => { let app = cx.entity().downgrade(); let backend = backend.clone(); - // Fires while AppRoot may still be under construction; - // opening panels reads the root, so run outside its lease. + window.defer(cx, move |window, cx| { let signed_in = backend.read(cx).current_user().is_some(); - log_dropped(app.update(cx, |this, cx| this.clear(cx))); + log_dropped(app.update(cx, |this, cx| { + this.clear(cx); + })); if signed_in { ExploreView::open(&app, window, cx); } @@ -103,17 +94,10 @@ impl AppRoot { }); Self { - main: None, - main_order: Vec::new(), - main_views: HashMap::new(), - details: Vec::new(), - detail_views: HashMap::new(), - active_detail: None, - detail_pane, + panel, titlebar, sign_in, explore, - empty, passphrase: None, _subscriptions: subscriptions, } @@ -128,198 +112,79 @@ impl AppRoot { cx.open_dialog(dialog); } - pub fn active_main(&self) -> Option> { - self.main - .as_ref() - .and_then(|id| self.main_views.get(id)) - .cloned() + /// The panel stack holding the main tile and the detail tiles. + pub fn panel(&self) -> Entity { + self.panel.clone() } - pub fn active_main_id(&self) -> Option<&SharedString> { - self.main.as_ref() - } - - pub fn open_mains(&self) -> &[SharedString] { - &self.main_order - } - - /// The open main panel with this id. - pub fn main_view(&self, id: &SharedString) -> Option> { - self.main_views.get(id).cloned() - } - - pub fn active_detail(&self) -> Option> { - self.active_detail - .as_ref() - .and_then(|id| self.detail_views.get(id)) - .cloned() - } - - pub fn has_main(&self, id: &SharedString) -> bool { - self.main_views.contains_key(id) - } - - pub fn has_details(&self) -> bool { - !self.details.is_empty() - } - - pub fn has_detail(&self, id: &SharedString) -> bool { - self.detail_views.contains_key(id) - } - - pub fn show_main( + pub fn open_main( &mut self, id: SharedString, view: Arc, cx: &mut Context, ) { - if self.main.as_ref() != Some(&id) { - self.clear_details(); - } - if !self.main_views.contains_key(&id) { - self.main_order.push(id.clone()); - } - self.main_views.insert(id.clone(), view); - self.main = Some(id); - cx.notify(); + self.panel + .update(cx, |panel, cx| panel.open_main(id, view, cx)); } - pub fn activate_main(&mut self, id: &SharedString, cx: &mut Context) { - if self.main.as_ref() != Some(id) { - self.clear_details(); - } - self.main = Some(id.clone()); - cx.notify(); - } - - pub fn activate_detail(&mut self, id: &SharedString, cx: &mut Context) { - if self.detail_views.contains_key(id) { - self.active_detail = Some(id.clone()); - cx.notify(); - } - } - - pub fn show_detail( + pub fn open_detail( &mut self, id: SharedString, view: Arc, cx: &mut Context, ) { - if !self.details.contains(&id) { - self.details.push(id.clone()); - } - self.detail_views.insert(id.clone(), view); - self.active_detail = Some(id); - cx.notify(); + self.panel + .update(cx, |panel, cx| panel.open_split(id, view, cx)); } pub fn close_detail(&mut self, id: &SharedString, cx: &mut Context) { - let Some(index) = self.details.iter().position(|open| open == id) else { - return; - }; - self.close_detail_at(index, cx); + self.panel.update(cx, |panel, cx| panel.close_split(id, cx)); + } + + pub fn activate_main(&mut self, id: &SharedString, cx: &mut Context) { + self.panel + .update(cx, |panel, cx| panel.activate_main(id, cx)); } pub fn close_main_at(&mut self, index: usize, cx: &mut Context) { - if index >= self.main_order.len() { - return; - } - - let id = self.main_order.remove(index); - self.main_views.remove(&id); - - if self.main.as_ref() == Some(&id) { - self.main = self - .main_order - .get(index) - .or_else(|| { - index - .checked_sub(1) - .and_then(|prev| self.main_order.get(prev)) - }) - .cloned(); - self.clear_details(); - } - - cx.notify(); + self.panel + .update(cx, |panel, cx| panel.close_main_at(index, cx)); } pub fn clear(&mut self, cx: &mut Context) { - self.main = None; - self.main_order.clear(); - self.main_views.clear(); - self.clear_details(); - cx.notify(); - } - - fn clear_details(&mut self) { - self.details.clear(); - self.detail_views.clear(); - self.active_detail = None; - } - - fn close_detail_at(&mut self, index: usize, cx: &mut Context) { - let id = self.details.remove(index); - self.detail_views.remove(&id); - - if self.active_detail.as_ref() == Some(&id) { - self.active_detail = self - .details - .get(index) - .or_else(|| index.checked_sub(1).and_then(|prev| self.details.get(prev))) - .cloned(); - } - - cx.notify(); - } - - fn activate_detail_at(&mut self, index: usize, cx: &mut Context) { - let Some(id) = self.details.get(index) else { - return; - }; - self.active_detail = Some(id.clone()); - cx.notify(); + self.panel.update(cx, |panel, cx| panel.clear(cx)); } /// Tabs for the repositories opened in the main panel. fn render_repo_tabs(&self, cx: &mut Context) -> Option { - let open = self.open_mains(); + let panel = self.panel.read(cx); - if open.is_empty() { + if panel.mains().is_empty() { return None; } - let tabs: Vec<_> = open + let selected = panel.active_main_index(); + let ids: Vec = panel + .mains() .iter() - .map(|id| (id.clone(), self.main_view(id))) + .map(|panel| panel.id().clone()) .collect(); - - let selected = self - .active_main_id() - .and_then(|id| open.iter().position(|open_id| open_id == id)) - .unwrap_or(usize::MAX); + let panel = self.panel.clone(); let app = cx.entity().downgrade(); let close_app = app.clone(); - let open_for_change = open.to_vec(); Some( Tabs::new("signed-repo-tabs") .variant(TabsVariant::Titlebar) .overflow_scroll(true) .selected(selected) - .tabs(move |_, cx| { - tabs.iter() - .map(|(id, view)| match view { - Some(view) => view.tab(id.clone().into(), cx).closeable(true), - None => Tab::new(id.clone(), id.clone()).closeable(true), - }) - .collect() - }) + .tabs(move |_, cx| panel.read(cx).main_tabs(cx)) .on_change(move |index, _, cx| { - let Some(id) = open_for_change.get(index).cloned() else { + let Some(id) = ids.get(index) else { return; }; + let id = id.clone(); log_dropped(app.update(cx, |app, cx| { app.activate_main(&id, cx); })); @@ -340,7 +205,6 @@ impl Render for AppRoot { let repo_tabs = self.render_repo_tabs(cx); let titlebar_view = self.titlebar.read(cx); - let main = self.active_main(); div() .relative() @@ -378,90 +242,14 @@ impl Render for AppRoot { titlebar.suffix(menu) }), ) - .child( - PanelRow::new("signed-panel") - .when_some(main.as_ref(), |row, main| { - row.main(main.clone()).when(self.has_details(), |row| { - row.split(self.detail_pane.clone()) - }) - }) - .when(!main.is_some() && signed_in, |row| { - row.main(self.empty.clone()) - }) - .when(!main.is_some() && !signed_in, |row| { - row.main(self.sign_in.clone()) - .split_at(self.explore.clone(), px(300.)) - }), - ), + .child(if signed_in { + self.panel.clone().into_any_element() + } else { + PanelRow::new("signed-out-panel") + .main(self.sign_in.clone()) + .split_at(self.explore.clone(), px(300.)) + .into_any_element() + }), ) } } - -/// The split pane beside the main panel: detail tabs over the active detail. -struct DetailPane { - app: WeakEntity, -} - -impl Panel for DetailPane { - fn title(&self, _cx: &App) -> SharedString { - SharedString::from("Workspace") - } -} - -impl Render for DetailPane { - fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { - let Some(app) = self.app.upgrade() else { - return div().into_any_element(); - }; - let app = app.read(cx); - - let selected = app - .active_detail - .as_ref() - .and_then(|active| app.details.iter().position(|id| id == active)) - .unwrap_or(usize::MAX); - - let details: Vec<_> = app - .details - .iter() - .map(|id| (id.clone(), app.detail_views.get(id).cloned())) - .collect(); - - let weak = self.app.clone(); - let body = app.active_detail().map(|view| view.view()); - - v_flex() - .size_full() - .gap_2() - .when(app.details.len() > 1, |this| { - let close_weak = weak.clone(); - this.child( - Tabs::new("signed-detail-tabs") - .variant(TabsVariant::Pill) - .overflow_scroll(true) - .selected(selected) - .tabs(move |_, cx| { - details - .iter() - .map(|(id, view)| match view { - Some(view) => view.tab(id.clone().into(), cx).closeable(true), - None => Tab::new(id.clone(), id.clone()).closeable(true), - }) - .collect() - }) - .on_change(move |index, _, cx| { - log_dropped(weak.update(cx, |app, cx| { - app.activate_detail_at(index, cx); - })); - }) - .on_close(move |index, _, cx| { - log_dropped(close_weak.update(cx, |app, cx| { - app.close_detail_at(index, cx); - })); - }), - ) - }) - .child(div().flex_1().min_h_0().w_full().children(body)) - .into_any_element() - } -} diff --git a/crates/signed_app/src/shared/panels.rs b/crates/signed_app/src/shared/panels.rs index 62330b2..97e88a5 100644 --- a/crates/signed_app/src/shared/panels.rs +++ b/crates/signed_app/src/shared/panels.rs @@ -5,87 +5,7 @@ use ui::layout::panel::{Panel, PanelView}; use crate::app::AppRoot; -/// Which slot of the workspace a panel opens into. -#[derive(Clone, Copy)] -enum PanelSlot { - Main, - Detail, -} - -impl PanelSlot { - /// Whether the slot already holds a panel under `id`. - fn has(self, workspace: &WeakEntity, id: &SharedString, cx: &App) -> bool { - match self { - PanelSlot::Main => workspace - .read_with(cx, |workspace, _| workspace.has_main(id)) - .unwrap_or(false), - PanelSlot::Detail => workspace - .read_with(cx, |workspace, _| workspace.has_detail(id)) - .unwrap_or(false), - } - } - - /// Activates the slot's cached panel under `id`. - fn activate(self, workspace: &WeakEntity, id: &SharedString, cx: &mut App) { - let result = match self { - PanelSlot::Main => { - workspace.update(cx, |workspace, cx| workspace.activate_main(id, cx)) - } - PanelSlot::Detail => { - workspace.update(cx, |workspace, cx| workspace.activate_detail(id, cx)) - } - }; - if let Err(error) = result { - log::warn!("failed to activate panel {id}: {error}"); - } - } - - /// Shows the panel in the slot. - fn show( - self, - workspace: &WeakEntity, - id: SharedString, - view: Arc, - cx: &mut App, - ) { - let result = match self { - PanelSlot::Main => { - workspace.update(cx, |workspace, cx| workspace.show_main(id, view, cx)) - } - PanelSlot::Detail => { - workspace.update(cx, |workspace, cx| workspace.show_detail(id, view, cx)) - } - }; - if let Err(error) = result { - log::warn!("failed to open panel: {error}"); - } - } -} - -/// Opens a panel in `slot`, reusing it when it is already cached. -fn open_slot( - slot: PanelSlot, - workspace: &WeakEntity, - id: impl Into, - build: F, - window: &mut Window, - cx: &mut App, -) where - P: Panel + 'static, - F: Fn(&mut Window, &mut App) -> Entity

+ 'static, -{ - let id = id.into(); - - if slot.has(workspace, &id, cx) { - slot.activate(workspace, &id, cx); - return; - } - - let view: Arc = Arc::new(build(window, cx)); - slot.show(workspace, id, view, cx); -} - -/// Opens a repository in the main panel, reusing it when it is already cached. +/// Opens a repository in the main panel, reusing its tab when it is already open. pub fn open_primary( workspace: &WeakEntity, id: impl Into, @@ -96,10 +16,24 @@ pub fn open_primary( P: Panel + 'static, F: Fn(&mut Window, &mut App) -> Entity

+ 'static, { - open_slot(PanelSlot::Main, workspace, id, build, window, cx); + let id = id.into(); + if workspace + .read_with(cx, |app, cx| app.panel().read(cx).has(&id)) + .unwrap_or(false) + { + if let Err(error) = workspace.update(cx, |app, cx| app.activate_main(&id, cx)) { + log::warn!("failed to activate panel {id}: {error}"); + } + return; + } + + let view: Arc = Arc::new(build(window, cx)); + if let Err(error) = workspace.update(cx, |app, cx| app.open_main(id.clone(), view, cx)) { + log::warn!("failed to open panel {id}: {error}"); + } } -/// Opens a detail panel beside the main panel, reusing it when it is already cached. +/// Opens a detail tile beside the main panel, reusing it when it is already open. pub fn open_detail( workspace: &WeakEntity, id: impl Into, @@ -110,5 +44,16 @@ pub fn open_detail( P: Panel + 'static, F: Fn(&mut Window, &mut App) -> Entity

+ 'static, { - open_slot(PanelSlot::Detail, workspace, id, build, window, cx); + let id = id.into(); + if workspace + .read_with(cx, |app, cx| app.panel().read(cx).has(&id)) + .unwrap_or(false) + { + return; + } + + let view: Arc = Arc::new(build(window, cx)); + if let Err(error) = workspace.update(cx, |app, cx| app.open_detail(id.clone(), view, cx)) { + log::warn!("failed to open panel {id}: {error}"); + } } diff --git a/crates/ui/src/layout/panel.rs b/crates/ui/src/layout/panel.rs index 16df7ff..1117dc4 100644 --- a/crates/ui/src/layout/panel.rs +++ b/crates/ui/src/layout/panel.rs @@ -3,15 +3,22 @@ //! between them; the divider opens at half the row or at a set width //! ([`PanelRow::split_at`]), and dragging it can be disabled //! ([`PanelRow::resizable`]). A double-click restores the half split. +//! +//! The [`PanelStack`] is the stateful variant: a main tile with one tile +//! per opened detail beside it, resizing like the row's split. use std::sync::Arc; use gpui::{ - AnyElement, AnyView, App, Axis, Div, ElementId, Entity, IntoElement, ParentElement as _, - Pixels, Render, RenderOnce, SharedString, StyleRefinement, Styled as _, Window, div, + AnyElement, AnyView, App, Axis, Context, Div, ElementId, Entity, IntoElement, + ParentElement as _, Pixels, Render, RenderOnce, SharedString, StyleRefinement, Styled as _, + WeakEntity, Window, div, }; +use crate::components::button::{Button, ButtonVariant}; +use crate::components::common::{ResultLogErr as _, Sizable as _}; use crate::components::tabs::Tab; +use crate::icons::IconRole; use crate::layout::StyledExt as _; use crate::layout::resizable::{Resizable, ResizableState}; use crate::theme::{ActiveTheme as _, PANE_MIN_SIZE, RESIZE_HANDLE_WIDTH}; @@ -269,3 +276,279 @@ impl RenderOnce for PanelRow { .child(row) } } + +/// One tile of the panel stack: a main view or a detail opened beside it. +#[derive(Clone)] +pub struct SubPanel { + id: SharedString, + view: Arc, +} + +impl SubPanel { + /// Wraps a panel view under `id`. + pub fn new(id: impl Into, view: Arc) -> Self { + Self { + id: id.into(), + view, + } + } + + /// The tile's id. + pub fn id(&self) -> &SharedString { + &self.id + } + + /// The tile's panel view. + pub fn view(&self) -> &Arc { + &self.view + } +} + +/// The window's panels: the active main tile, plus one tile per opened detail. +pub struct PanelStack { + mains: Vec, + active_main: Option, + splits: Vec, + state: Entity, + fallback: AnyView, + weak_self: WeakEntity, + style: StyleRefinement, +} + +impl PanelStack { + /// Creates a stack showing `fallback` while no panel is open. + pub fn new(fallback: AnyView, cx: &mut Context) -> Self { + Self { + mains: Vec::new(), + active_main: None, + splits: Vec::new(), + state: ResizableState::new(cx), + fallback, + weak_self: cx.weak_entity(), + style: StyleRefinement::default(), + } + } + + /// Shows a panel as the main tile, activating its tab when already open. + pub fn open_main( + &mut self, + id: SharedString, + view: Arc, + cx: &mut Context, + ) { + if self.mains.iter().any(|panel| panel.id == id) { + if self.active_main.as_ref() != Some(&id) { + self.active_main = Some(id); + self.splits.clear(); + cx.notify(); + } + } else { + let panel = SubPanel::new(id, view); + self.active_main = Some(panel.id.clone()); + self.mains.push(panel); + self.splits.clear(); + cx.notify(); + } + } + + /// Opens a detail tile beside the main tile; open details keep their tile. + pub fn open_split( + &mut self, + id: SharedString, + view: Arc, + cx: &mut Context, + ) { + if self.splits.iter().any(|panel| panel.id == id) { + return; + } + self.splits.push(SubPanel::new(id, view)); + cx.notify(); + } + + /// Activates the main tile with `id`, closing the detail tiles. + pub fn activate_main(&mut self, id: &SharedString, cx: &mut Context) { + if self.active_main.as_ref() == Some(id) || !self.mains.iter().any(|panel| panel.id == *id) + { + return; + } + self.active_main = Some(id.clone()); + self.splits.clear(); + cx.notify(); + } + + /// Closes the main tab at `index`, activating a neighbor when it was active. + pub fn close_main_at(&mut self, index: usize, cx: &mut Context) { + if index >= self.mains.len() { + return; + } + + let id = self.mains.remove(index).id; + + if self.active_main.as_ref() == Some(&id) { + self.active_main = self + .mains + .get(index) + .or_else(|| index.checked_sub(1).and_then(|prev| self.mains.get(prev))) + .map(|panel| panel.id.clone()); + self.splits.clear(); + } + + cx.notify(); + } + + /// Closes the detail tile with `id`. + pub fn close_split(&mut self, id: &SharedString, cx: &mut Context) { + self.remove_split(id, cx); + } + + /// Closes every panel, leaving the fallback. + pub fn clear(&mut self, cx: &mut Context) { + self.mains.clear(); + self.active_main = None; + self.splits.clear(); + cx.notify(); + } + + /// Whether a main tab or a detail tile is open under `id`. + pub fn has(&self, id: &SharedString) -> bool { + self.mains.iter().any(|panel| &panel.id == id) + || self.splits.iter().any(|panel| &panel.id == id) + } + + /// The main tabs, in open order. + pub fn mains(&self) -> &[SubPanel] { + &self.mains + } + + /// The id of the main tile on screen, if any. + pub fn active_main_id(&self) -> Option<&SharedString> { + self.active_main.as_ref() + } + + /// Builds the titlebar tabs for the open mains. + pub fn main_tabs(&self, cx: &App) -> Vec { + self.mains + .iter() + .map(|panel| panel.view.tab(panel.id.clone().into(), cx).closeable(true)) + .collect() + } + + /// The active tab's position in [`Self::mains`], or `usize::MAX` when none. + pub fn active_main_index(&self) -> usize { + self.active_main + .as_ref() + .and_then(|active| self.mains.iter().position(|panel| &panel.id == active)) + .unwrap_or(usize::MAX) + } + + /// Whether a main tile renders; pane 0 is the main tile when it does. + fn has_main_tile(&self) -> bool { + self.active_main.is_some() + } + + /// Removes the stored size of the tile at `pane index`, keeping the rest. + fn remove_split(&mut self, id: &SharedString, cx: &mut Context) { + let Some(index) = self.splits.iter().position(|panel| panel.id == *id) else { + return; + }; + self.splits.remove(index); + + let base = usize::from(self.has_main_tile()); + let pane_count = base + self.splits.len(); + + let sizes: Vec = self + .state + .read(cx) + .sizes() + .iter() + .enumerate() + .filter(|(ix, _)| *ix != base + index) + .map(|(_, &size)| size) + .take(pane_count.saturating_sub(1)) + .collect(); + + self.state.update(cx, |state, cx| { + state.set_sizes(sizes, cx); + }); + + cx.notify(); + } +} + +impl gpui::Styled for PanelStack { + fn style(&mut self) -> &mut StyleRefinement { + &mut self.style + } +} + +impl Render for PanelStack { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + let content = if self.mains.is_empty() && self.splits.is_empty() { + island(div().size_full().child(self.fallback.clone()), cx).into_any_element() + } else { + let mut resizable = Resizable::new("panel-stack", self.state.clone()) + .axis(Axis::Horizontal) + .h_full(); + + if let Some(main) = self + .active_main + .as_ref() + .and_then(|active| self.mains.iter().find(|panel| &panel.id == active)) + { + resizable = resizable.pane(island( + div() + .size_full() + .child(main.view.view().cached(content_style())), + cx, + )); + } + + for panel in &self.splits { + let id = panel.id.clone(); + let weak_self = self.weak_self.clone(); + + resizable = resizable.pane( + div() + .relative() + .size_full() + .child(island( + div() + .size_full() + .child(panel.view.view().cached(content_style())), + cx, + )) + .child( + div().absolute().top_1().right_1().child( + Button::new((ElementId::from("panel-stack-close"), id.clone())) + .icon(IconRole::Close) + .variant(ButtonVariant::Ghost) + .xsmall() + .on_click(move |_, window, cx| { + let stack = weak_self.clone(); + let id = id.clone(); + window.defer(cx, move |_, cx| { + stack + .update(cx, |stack, cx| { + stack.close_split(&id, cx); + }) + .log_err(); + }); + }), + ), + ), + ); + } + + div().size_full().child(resizable).into_any_element() + }; + + div() + .size_full() + .min_w_0() + .p_2() + .pt_1() + .refine_style(&self.style) + .child(content) + .into_any_element() + } +}