feat: per-window themes ("This window" theme scope) (#279)

* feat: per-window themes via ambient render window

Let a user set a theme for one window without affecting others, persisted
across restart. The active theme stays global by default; a per-window
override is resolved during that window's render pass.

Mechanism: an ambient "current render window" thread-local in warpui_core,
set by the 3 render chokepoints (build_scene/render_view/render_views) via
an RAII guard. Appearance::theme()/ui_builder() consult it to resolve a
per-window override from new HashMaps, with a zero-cost is_empty() fast
path so the feature costs nothing when unused. (The plan called for setting
the ambient from Appearance directly in warpui_core, but warpui_core cannot
depend on warp_core/Appearance, so the ambient lives in warpui_core and
Appearance reads it.)

- Appearance: theme_overrides/ui_builder_overrides maps; set/clear_window_theme
  invalidate only the target window.
- AppearanceManager: set/clear_window_theme; Workspace::on_window_closed clears
  the override so maps don't leak.
- Theme chooser: "All windows"/"This window" scope toggle (default All);
  "This window" routes to the per-window path and records the override on the
  Workspace for persistence.
- Persistence: theme_override TEXT column (migration + schema + model), saved
  via serde_json so ThemeKind::Custom round-trips, re-applied on window restore.

Verification: warp_core, warpui_core and persistence compile cleanly and a new
Appearance unit test covers override resolution + the fast path. The warp app
crate could not be built/tested in this environment (xcrun "metal" toolchain
unavailable; wasm fallback blocked by clang) -- run ./script/presubmit to
verify the app crate, clippy/fmt, and the new test.

(cherry picked from commit 80f5c59)

* fix: restore per-window theme override when theme preview is cancelled (#279)

revert_theme cleared the global transient preview but left a 'This window'
scope override in place, since per-window previews write straight into the
override map with no transient layer. Capture the window's override when the
chooser opens and restore (or clear) it on the revert path, mirroring
clear_transient_theme for the global preview.

Addresses zerx-lab review on PR #279. Could not full-build to verify (Metal
toolchain absent locally); change is type/borrow-checked against the API.

* fix(theme): keep_theme 同步 per-window override，避免重开主题选择器后丢失窗口主题

---------

Co-authored-by: zerx-lab <bot@zerx-lab.dev>

Author: TranscriptionFactory

app/src/app_state.rs

@@ -19,7 +19,7 @@ use crate::server::ids::SyncId;
 use crate::settings_view::SettingsSection;
 use crate::tab::SelectedTabColor;
 use crate::terminal::ShellLaunchData;
-use crate::themes::theme::AnsiColorIdentifier;
+use crate::themes::theme::{AnsiColorIdentifier, ThemeKind};
 use crate::workspace::view::left_panel::ToolPanelView;
 use crate::workspace::WorkspaceRegistry;
 use warpui::SingletonEntity as _;
@@ -57,6 +57,9 @@ pub struct WindowSnapshot {
     pub left_panel_width: Option<f32>,
     pub right_panel_width: Option<f32>,
     pub agent_management_filters: Option<PersistedAgentManagementFilters>,
+    /// The per-window theme override for this window, if the user set one via the
+    /// theme chooser's "This window" scope. Re-applied on restore.
+    pub theme_override: Option<ThemeKind>,
 }
 
 #[derive(Clone, Debug, PartialEq)]

app/src/appearance.rs

@@ -1,7 +1,7 @@
 use settings::Setting as _;
 use warpui::{
     fonts::FamilyId, AddSingletonModel, AppContext, AssetProvider, Entity, ModelContext,
-    SingletonEntity,
+    SingletonEntity, WindowId,
 };
 
 #[cfg(target_os = "macos")]
@@ -202,6 +202,29 @@ impl AppearanceManager {
         self.refresh_theme_state(ctx);
     }
 
+    /// Applies a per-window theme override, affecting only `window_id`. Windows
+    /// without an override continue to follow the global theme (including
+    /// system-theme follow via `refresh_theme_state`).
+    pub fn set_window_theme(
+        &mut self,
+        window_id: WindowId,
+        theme_kind: ThemeKind,
+        ctx: &mut ModelContext<Self>,
+    ) {
+        let theme = Settings::theme_for_theme_kind(&theme_kind, ctx);
+        Appearance::handle(ctx).update(ctx, |appearance, ctx| {
+            appearance.set_window_theme(window_id, theme, ctx);
+        });
+    }
+
+    /// Clears a per-window theme override, returning `window_id` to the global
+    /// theme. No-op if the window has no override.
+    pub fn clear_window_theme(&mut self, window_id: WindowId, ctx: &mut ModelContext<Self>) {
+        Appearance::handle(ctx).update(ctx, |appearance, ctx| {
+            appearance.clear_window_theme(window_id, ctx);
+        });
+    }
+
     #[cfg(target_os = "macos")]
     pub fn app_icon_at_startup(&self) -> AppIcon {
         self.app_icon_at_startup

app/src/launch_configs/launch_config_tests.rs

@@ -35,6 +35,7 @@ fn single_tab_snapshot(root: PaneNodeSnapshot) -> AppState {
             left_panel_width: None,
             right_panel_width: None,
             agent_management_filters: None,
+            theme_override: None,
         }],
         active_window_index: Some(0),
         block_lists: Default::default(),
@@ -59,6 +60,7 @@ fn multi_tab_snapshot(active_tab_index: usize, tabs: Vec<TabSnapshot>) -> AppSta
             left_panel_width: None,
             right_panel_width: None,
             agent_management_filters: None,
+            theme_override: None,
         }],
         active_window_index: Some(0),
         block_lists: Default::default(),

app/src/persistence/sqlite.rs

@@ -1080,6 +1080,12 @@ fn save_app_state(conn: &mut SqliteConnection, app_state: &AppState) -> Result<(
                     .agent_management_filters
                     .as_ref()
                     .and_then(|f| serde_json::to_string(f).ok()),
+                // Serialize with serde (not Display) so the `ThemeKind::Custom`
+                // variant round-trips.
+                theme_override: window
+                    .theme_override
+                    .as_ref()
+                    .and_then(|k| serde_json::to_string(k).ok()),
             };
             diesel::insert_into(schema::windows::dsl::windows)
                 .values(new_window)
@@ -2848,6 +2854,9 @@ fn read_sqlite_data(
                 agent_management_filters: window
                     .agent_management_filters
                     .and_then(|s| serde_json::from_str(&s).ok()),
+                theme_override: window
+                    .theme_override
+                    .and_then(|s| serde_json::from_str(&s).ok()),
             }
         })
         .collect();

app/src/persistence/sqlite_tests.rs

@@ -155,6 +155,7 @@ fn test_terminal_window_snapshot(vertical_tabs_panel_open: bool) -> WindowSnapsh
         left_panel_width: None,
         right_panel_width: None,
         agent_management_filters: None,
+        theme_override: None,
     }
 }
 
@@ -238,6 +239,7 @@ fn test_sqlite_round_trips_custom_vertical_tabs_title() {
             left_panel_width: None,
             right_panel_width: None,
             agent_management_filters: None,
+            theme_override: None,
         }],
         active_window_index: Some(0),
         block_lists: Default::default(),
@@ -310,6 +312,7 @@ fn test_sqlite_round_trips_code_pane_with_multiple_tabs() {
             left_panel_width: None,
             right_panel_width: None,
             agent_management_filters: None,
+            theme_override: None,
         }],
         active_window_index: Some(0),
         block_lists: Default::default(),

app/src/themes/theme_chooser.rs

@@ -22,6 +22,7 @@ use warpui::{
 };
 
 use crate::resource_center::{mark_feature_used_and_write_to_user_defaults, Tip, TipAction};
+use crate::ui_components::tab_selector::{render_tab_selector, SettingsTab};
 use crate::themes::theme::{RespectSystemTheme, ThemeKind, WarpTheme};
 use crate::util::traffic_lights::traffic_light_data;
 use crate::workspace::PANEL_HEADER_HEIGHT;
@@ -67,13 +68,51 @@ const THEME_CHOOSER_ITEM_PADDING: f32 = 16.;
 struct MouseStateHandles {
     create_theme_button_hover_state: MouseStateHandle,
     close_button_mouse_state: MouseStateHandle,
+    scope_all_windows_mouse_state: MouseStateHandle,
+    scope_this_window_mouse_state: MouseStateHandle,
 }
 
 pub enum ThemeChooserEvent {
     Click,
     Close(ThemeChooserMode),
     OpenThemeCreatorModal,
     OpenThemeDeletionModal(ThemeKind),
+    /// The per-window theme override for this window changed. `Some(kind)` when
+    /// the user committed a "This window" theme; `None` when the window was
+    /// returned to the global theme. The owning `Workspace` records this for
+    /// persistence.
+    WindowThemeOverride(Option<ThemeKind>),
+}
+
+/// Whether a theme selection applies to every window (the global theme setting)
+/// or only the current window (a per-window override).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum ThemeScope {
+    /// Change the global theme; affects all windows without an override.
+    #[default]
+    AllWindows,
+    /// Change only the current window via a per-window override.
+    ThisWindow,
+}
+
+impl ThemeScope {
+    const ALL_WINDOWS_LABEL: &'static str = "All windows";
+    const THIS_WINDOW_LABEL: &'static str = "This window";
+
+    fn label(self) -> &'static str {
+        match self {
+            ThemeScope::AllWindows => Self::ALL_WINDOWS_LABEL,
+            ThemeScope::ThisWindow => Self::THIS_WINDOW_LABEL,
+        }
+    }
+
+    fn from_label(label: &str) -> Option<Self> {
+        match label {
+            Self::ALL_WINDOWS_LABEL => Some(ThemeScope::AllWindows),
+            Self::THIS_WINDOW_LABEL => Some(ThemeScope::ThisWindow),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -145,6 +184,8 @@ pub struct ThemeChooser {
     themes: Tracked<Vec<ThemeChooserItem>>,
     filtered_themes: Tracked<Option<Vec<ThemeChooserItem>>>,
     mode: ThemeChooserMode,
+    /// Whether selections apply globally or only to this window.
+    scope: ThemeScope,
     search_editor: ViewHandle<EditorView>,
     tips_completed: ModelHandle<TipsCompleted>,
     window_id: warpui::WindowId,
@@ -159,6 +200,7 @@ pub enum ThemeChooserAction {
     Down,
     OpenThemeCreator,
     OpenThemeDeletionModal(ThemeKind),
+    SetScope(ThemeScope),
 }
 
 pub fn init(app: &mut AppContext) {
@@ -234,6 +276,7 @@ impl ThemeChooser {
             selected_theme: Tracked::new(None),
             filtered_themes: Tracked::new(None),
             mode: ThemeChooserMode::for_active_theme(ctx),
+            scope: ThemeScope::default(),
             search_editor,
             tips_completed,
             window_id: ctx.window_id(),
@@ -400,6 +443,17 @@ impl ThemeChooser {
             },
             ctx
         );
+
+        // In "This window" scope, the per-window override was already applied by
+        // `select_theme`; record it on the owning workspace for persistence and
+        // skip writing the global theme setting.
+        if self.scope == ThemeScope::ThisWindow {
+            ctx.emit(ThemeChooserEvent::WindowThemeOverride(Some(
+                selected_kind.clone(),
+            )));
+            return;
+        }
+
         let theme_settings = ThemeSettings::handle(ctx);
 
         let selected_themes = respect_system_theme(theme_settings.as_ref(ctx))
@@ -437,6 +491,35 @@ impl ThemeChooser {
                 });
             }
         };
+
+        // Choosing a theme for all windows clears this window's per-window
+        // override (if any) so it follows the global theme again.
+        let window_id = self.window_id;
+        AppearanceManager::handle(ctx).update(ctx, |appearance_manager, ctx| {
+            appearance_manager.clear_window_theme(window_id, ctx);
+        });
+        ctx.emit(ThemeChooserEvent::WindowThemeOverride(None));
+    }
+
+    /// Switches the selection scope (all windows vs. this window). Switching to
+    /// "All windows" immediately drops this window's override so it rejoins the
+    /// global theme. Switching to "This window" defers until the user picks a
+    /// theme.
+    fn set_scope(&mut self, scope: ThemeScope, ctx: &mut ViewContext<Self>) {
+        if self.scope == scope {
+            return;
+        }
+        self.scope = scope;
+
+        if scope == ThemeScope::AllWindows {
+            let window_id = self.window_id;
+            AppearanceManager::handle(ctx).update(ctx, |appearance_manager, ctx| {
+                appearance_manager.clear_window_theme(window_id, ctx);
+            });
+            ctx.emit(ThemeChooserEvent::WindowThemeOverride(None));
+        }
+
+        ctx.notify();
     }
 
     fn theme_position(&self, kind: ThemeKind) -> Option<usize> {
@@ -463,8 +546,14 @@ impl ThemeChooser {
             ctx.notify();
         });
 
-        AppearanceManager::handle(ctx).update(ctx, |appearance_manager, ctx| {
-            appearance_manager.set_transient_theme(kind, ctx);
+        // Preview the selection. In "All windows" scope this is a global transient
+        // preview; in "This window" scope it applies a per-window override so only
+        // the current window changes.
+        let scope = self.scope;
+        let window_id = self.window_id;
+        AppearanceManager::handle(ctx).update(ctx, |appearance_manager, ctx| match scope {
+            ThemeScope::AllWindows => appearance_manager.set_transient_theme(kind, ctx),
+            ThemeScope::ThisWindow => appearance_manager.set_window_theme(window_id, kind, ctx),
         });
     }
 
@@ -660,6 +749,39 @@ impl ThemeChooser {
             .finish()
     }
 
+    fn render_scope_selector(&self, appearance: &Appearance) -> Box<dyn Element> {
+        let tabs = vec![
+            SettingsTab::new(
+                ThemeScope::AllWindows.label(),
+                self.button_mouse_states
+                    .scope_all_windows_mouse_state
+                    .clone(),
+            ),
+            SettingsTab::new(
+                ThemeScope::ThisWindow.label(),
+                self.button_mouse_states
+                    .scope_this_window_mouse_state
+                    .clone(),
+            ),
+        ];
+
+        let selector = render_tab_selector(
+            tabs,
+            self.scope.label(),
+            |label, ctx| {
+                if let Some(scope) = ThemeScope::from_label(label) {
+                    ctx.dispatch_typed_action(ThemeChooserAction::SetScope(scope));
+                }
+            },
+            appearance,
+        );
+
+        Container::new(selector)
+            .with_margin_left(TITLE_MARGIN)
+            .with_margin_right(TITLE_MARGIN)
+            .finish()
+    }
+
     fn render_search_bar(&self, appearance: &Appearance) -> Box<dyn Element> {
         Container::new(
             Flex::row()
@@ -806,6 +928,7 @@ impl TypedActionView for ThemeChooser {
             Enter => self.enter(ctx),
             OpenThemeCreator => self.open_theme_creator_modal(ctx),
             OpenThemeDeletionModal(kind) => self.open_theme_deletion_modal(kind.clone(), ctx),
+            SetScope(scope) => self.set_scope(*scope, ctx),
         }
     }
 }
@@ -831,6 +954,7 @@ impl View for ThemeChooser {
             Flex::column()
                 .with_child(self.render_header(traffic_light_data.as_ref(), appearance, app))
                 .with_child(self.render_title_row(appearance))
+                .with_child(self.render_scope_selector(appearance))
                 .with_child(self.mode.render_hint_text(appearance))
                 .with_child(self.render_search_bar(appearance))
                 .with_child(self.render_list(appearance))