refactor: move panel state into panel stack entity
Rust / build (macos-latest, stable) (push) Waiting to run
Rust / build (ubuntu-latest, stable) (push) Waiting to run
Rust / build (windows-latest, stable) (push) Waiting to run

This commit is contained in:
2026-11-23 04:21:01 +07:00
parent bef96c614b
commit 40c8831bf5
3 changed files with 362 additions and 346 deletions
+48 -260
View File
@@ -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<SharedString>,
main_order: Vec<SharedString>,
main_views: HashMap<SharedString, Arc<dyn PanelView>>,
details: Vec<SharedString>,
detail_views: HashMap<SharedString, Arc<dyn PanelView>>,
active_detail: Option<SharedString>,
detail_pane: Entity<DetailPane>,
panel: Entity<PanelStack>,
titlebar: Entity<TitlebarView>,
sign_in: Entity<SignedOutView>,
explore: Entity<ExploreView>,
empty: Entity<PlaceholderView>,
passphrase: Option<Entity<PassphraseDialog>>,
_subscriptions: Vec<Subscription>,
}
@@ -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<Arc<dyn PanelView>> {
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<PanelStack> {
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<Arc<dyn PanelView>> {
self.main_views.get(id).cloned()
}
pub fn active_detail(&self) -> Option<Arc<dyn PanelView>> {
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<dyn PanelView>,
cx: &mut Context<Self>,
) {
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<Self>) {
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<Self>) {
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<dyn PanelView>,
cx: &mut Context<Self>,
) {
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<Self>) {
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>) {
self.panel
.update(cx, |panel, cx| panel.activate_main(id, cx));
}
pub fn close_main_at(&mut self, index: usize, cx: &mut Context<Self>) {
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>) {
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<Self>) {
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<Self>) {
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<Self>) -> Option<Tabs> {
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<SharedString> = 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<AppRoot>,
}
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<Self>) -> 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()
}
}
+29 -84
View File
@@ -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<AppRoot>, 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<AppRoot>, 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<AppRoot>,
id: SharedString,
view: Arc<dyn PanelView>,
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<P, F>(
slot: PanelSlot,
workspace: &WeakEntity<AppRoot>,
id: impl Into<SharedString>,
build: F,
window: &mut Window,
cx: &mut App,
) where
P: Panel + 'static,
F: Fn(&mut Window, &mut App) -> Entity<P> + 'static,
{
let id = id.into();
if slot.has(workspace, &id, cx) {
slot.activate(workspace, &id, cx);
return;
}
let view: Arc<dyn PanelView> = 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<P, F>(
workspace: &WeakEntity<AppRoot>,
id: impl Into<SharedString>,
@@ -96,10 +16,24 @@ pub fn open_primary<P, F>(
P: Panel + 'static,
F: Fn(&mut Window, &mut App) -> Entity<P> + '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<dyn PanelView> = 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<P, F>(
workspace: &WeakEntity<AppRoot>,
id: impl Into<SharedString>,
@@ -110,5 +44,16 @@ pub fn open_detail<P, F>(
P: Panel + 'static,
F: Fn(&mut Window, &mut App) -> Entity<P> + '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<dyn PanelView> = 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}");
}
}