From fff359dc57ae8e1f154627497c7caabb07201acb Mon Sep 17 00:00:00 2001 From: Jiekang Tian Date: Sun, 15 Nov 2026 00:07:51 +0800 Subject: [PATCH 1/2] refactor(app): prepare shared state for native viewports --- crates/app/src/main.rs | 84 +++++++++---------- crates/app/src/shell.rs | 54 +++++++----- crates/app/src/ui/canvas/board.rs | 25 ++++-- crates/app/src/ui/canvas/board_tests.rs | 3 +- crates/app/src/ui/canvas/navigation_input.rs | 27 +++--- crates/app/src/ui/canvas/render_detail.rs | 39 ++++++++- crates/app/src/ui/canvas/view_fit.rs | 11 +-- crates/app/src/ui/command_exec_tests.rs | 6 +- crates/app/src/ui/data_sheet/dock_tests.rs | 7 +- crates/app/src/ui/file_drop.rs | 3 +- crates/app/src/ui/mod.rs | 5 ++ .../app/src/ui/primary_sidebar/selection.rs | 3 +- crates/app/src/ui/workspace_geometry.rs | 25 +++--- crates/render/src/rich_text.rs | 11 +-- 14 files changed, 179 insertions(+), 124 deletions(-) diff --git a/crates/app/src/main.rs b/crates/app/src/main.rs index f88251cd..40d8a05a 100644 --- a/crates/app/src/main.rs +++ b/crates/app/src/main.rs @@ -118,7 +118,8 @@ pub(crate) fn cancel_relaunch() { } struct Shell { - app: PlotiumApp, + // Deferred viewport callbacks can share application state without owning the shell. + app: Arc>, recovery: Option, pending_recovery: Option, pending_crash_report: Option, @@ -168,19 +169,19 @@ impl Shell { } impl Shell { - fn start_pending_project_save(&mut self, ctx: &egui::Context) { + fn start_pending_project_save(&mut self, app: &mut PlotiumApp, ctx: &egui::Context) { project_save::start_pending_project_save( - &mut self.app, + app, &mut self.manual_save_job, self.recovery_job.as_ref(), ctx, ); } - fn drive_project_transition(&mut self, ctx: &egui::Context) { + fn drive_project_transition(&mut self, app: &mut PlotiumApp, ctx: &egui::Context) { use plotium_core::state::ProjectTransition; let Some(target) = project_save::ready_project_transition( - &mut self.app, + app, &mut self.manual_save_job, self.recovery_job.as_ref(), ctx, @@ -190,52 +191,52 @@ impl Shell { let completed = match target { ProjectTransition::New => { - self.clear_recovery_for_project_swap(); - self.app.start_new_project(); + self.clear_recovery_for_project_swap(app); + app.start_new_project(); true } ProjectTransition::Close => { - self.clear_recovery_for_project_swap(); - self.app.close_project(); + self.clear_recovery_for_project_swap(app); + app.close_project(); true } ProjectTransition::Open(path) => { - let opened = self.app.load_project_from(&path); + let opened = app.load_project_from(&path); if opened { - self.clear_recovery_for_project_swap(); + self.clear_recovery_for_project_swap(app); } opened } ProjectTransition::Quit => { - self.app.session.ui.project_transition = None; - self.app.session.allow_close = true; + app.session.ui.project_transition = None; + app.session.allow_close = true; ctx.send_viewport_cmd(egui::ViewportCommand::Close); return; } }; if !completed { - self.app.session.ui.project_transition = None; + app.session.ui.project_transition = None; } - self.observed_edit_generation = self.app.doc.edit_generation; + self.observed_edit_generation = app.doc.edit_generation; self.last_recovered_generation = None; self.recovery_deadline = None; self.next_recovery_at = Instant::now() + RECOVERY_INTERVAL; } - fn clear_recovery_for_project_swap(&mut self) { + fn clear_recovery_for_project_swap(&mut self, app: &mut PlotiumApp) { if let Some(Err(error)) = self .recovery .as_ref() .map(plotium_core::project::RecoveryManager::clear_current) { - self.app.session.status = + app.session.status = format!("Project changed, but old recovery data could not be cleared: {error}"); } self.recovery_written = false; self.last_recovered_generation = None; } - fn tick_recovery(&mut self, ctx: &egui::Context) { + fn tick_recovery(&mut self, app: &mut PlotiumApp, ctx: &egui::Context) { let now = Instant::now(); if self .recovery_job @@ -254,12 +255,11 @@ impl Shell { self.next_recovery_at = now + RECOVERY_INTERVAL; } Ok(Err(error)) => { - self.app.session.status = format!("Automatic recovery save failed: {error}"); + app.session.status = format!("Automatic recovery save failed: {error}"); self.next_recovery_at = now + RECOVERY_RETRY_INTERVAL; } Err(_) => { - self.app.session.status = - "Automatic recovery worker failed unexpectedly.".into(); + app.session.status = "Automatic recovery worker failed unexpectedly.".into(); self.next_recovery_at = now + RECOVERY_RETRY_INTERVAL; } } @@ -268,7 +268,7 @@ impl Shell { self.next_recovery_at = Instant::now() + RECOVERY_INTERVAL; return; } - if !self.app.doc.dirty { + if !app.doc.dirty { if self.recovery_job.is_none() && self.recovery_written { match self .recovery @@ -276,7 +276,7 @@ impl Shell { .map(plotium_core::project::RecoveryManager::clear_current) { Some(Err(error)) => { - self.app.session.status = + app.session.status = format!("Saved project, but could not clear recovery data: {error}"); self.recovery_written = false; self.last_recovered_generation = None; @@ -291,12 +291,8 @@ impl Shell { self.next_recovery_at = now + RECOVERY_INTERVAL; return; } - let generation = self.app.doc.edit_generation; - if !recovery_needed( - self.app.doc.dirty, - generation, - self.last_recovered_generation, - ) { + let generation = app.doc.edit_generation; + if !recovery_needed(app.doc.dirty, generation, self.last_recovered_generation) { self.recovery_deadline = None; self.next_recovery_at = now + RECOVERY_INTERVAL; return; @@ -312,23 +308,22 @@ impl Shell { ctx.request_repaint_after(Duration::from_millis(100)); return; } - if self.manual_save_job.is_some() || self.app.session.ui.pending_project_save.is_some() { + if self.manual_save_job.is_some() || app.session.ui.pending_project_save.is_some() { self.next_recovery_at = now + RECOVERY_RETRY_INTERVAL; ctx.request_repaint_after(Duration::from_millis(100)); return; } if now >= self.next_recovery_at { - if self.app.compute_busy() { + if app.compute_busy() { self.next_recovery_at = now + RECOVERY_RETRY_INTERVAL; ctx.request_repaint_after(RECOVERY_RETRY_INTERVAL); return; } if let Some(recovery) = &self.recovery { - let request = match plotium_core::project::prepare_recovery_snapshot(&self.app) { + let request = match plotium_core::project::prepare_recovery_snapshot(app) { Ok(request) => request, Err(error) => { - self.app.session.status = - format!("Automatic recovery save failed: {error}"); + app.session.status = format!("Automatic recovery save failed: {error}"); self.next_recovery_at = now + RECOVERY_RETRY_INTERVAL; ctx.request_repaint_after(RECOVERY_RETRY_INTERVAL); return; @@ -349,7 +344,7 @@ impl Shell { ctx.request_repaint_after(self.next_recovery_at.saturating_duration_since(now)); } - fn show_recovery_prompt(&mut self, ctx: &egui::Context) { + fn show_recovery_prompt(&mut self, app: &mut PlotiumApp, ctx: &egui::Context) { let Some(snapshot) = self.pending_recovery.clone() else { return; }; @@ -386,7 +381,7 @@ impl Shell { if recover { match plotium_core::project::restore_recovery(&snapshot) { - Ok(mut app) => { + Ok(mut recovered) => { let adopted = self .recovery .as_mut() @@ -397,12 +392,11 @@ impl Shell { let cleanup_warning = match adopted { Ok(warning) => warning, Err(error) => { - self.app.session.status = - format!("Could not claim recovery data: {error}"); + app.session.status = format!("Could not claim recovery data: {error}"); return; } }; - app.session.status = cleanup_warning.map_or_else( + recovered.session.status = cleanup_warning.map_or_else( || "Recovered unsaved work. Save the project to make it permanent.".into(), |warning| { format!( @@ -410,16 +404,16 @@ impl Shell { ) }, ); - self.app.install_loaded_project(app); + app.install_loaded_project(recovered); self.pending_recovery = None; self.recovery_written = true; - self.last_recovered_generation = Some(self.app.doc.edit_generation); - self.observed_edit_generation = self.app.doc.edit_generation; + self.last_recovered_generation = Some(app.doc.edit_generation); + self.observed_edit_generation = app.doc.edit_generation; self.recovery_deadline = None; self.next_recovery_at = Instant::now() + RECOVERY_INTERVAL; } Err(error) => { - self.app.session.status = format!("Recovery failed: {error}"); + app.session.status = format!("Recovery failed: {error}"); } } } else if discard { @@ -435,7 +429,7 @@ impl Shell { match result { Ok(()) => self.pending_recovery = None, Err(error) => { - self.app.session.status = format!("Could not discard recovery data: {error}"); + app.session.status = format!("Could not discard recovery data: {error}"); } } } @@ -597,7 +591,7 @@ fn main() -> eframe::Result<()> { open_documents.set_context(&cc.egui_ctx); let observed_edit_generation = app.doc.edit_generation; Ok(Box::new(Shell { - app, + app: Arc::new(Mutex::new(app)), recovery, pending_recovery, pending_crash_report, diff --git a/crates/app/src/shell.rs b/crates/app/src/shell.rs index f70fbfdb..7c9bc453 100644 --- a/crates/app/src/shell.rs +++ b/crates/app/src/shell.rs @@ -149,57 +149,67 @@ pub(super) fn poll_manual_project_save( impl eframe::App for Shell { fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) { + let shared = Arc::clone(&self.app); + let mut app = shared.lock().expect("application state lock poisoned"); #[cfg(target_os = "macos")] { // Native menus and Dock events must also work with no visible window. if self.pending_recovery.is_none() { - self.open_documents.poll(&mut self.app, ctx); + self.open_documents.poll(&mut app, ctx); self.native_menu - .poll(&mut self.app, &mut self.clipboard_table_paste, ctx); + .poll(&mut app, &mut self.clipboard_table_paste, ctx); } // Fullscreen transitions can make the root temporarily non-visible: // eframe still calls logic, but skips ui and would otherwise exit. - ui::handle_close_request(&mut self.app, ctx); + ui::handle_close_request(&mut app, ctx); } - poll_background_work(&mut self.app, &mut self.manual_save_job, ctx); + poll_background_work(&mut app, &mut self.manual_save_job, ctx); // A finished recovery snapshot may be holding a queued manual save. - self.tick_recovery(ctx); - self.start_pending_project_save(ctx); + self.tick_recovery(&mut app, ctx); + self.start_pending_project_save(&mut app, ctx); self.agent_connections.poll( - &mut self.app, + &mut app, ctx, self.pending_recovery.is_some() || self.manual_save_job.is_some(), ); } fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) { - ui::result_follow::pause_on_input(&mut self.app, ctx, raw_input); - ui::import_feedback::cancel_on_input(&mut self.app, raw_input); + // eframe calls this hook for child viewports too. Their input must + // not cancel intents or synthesize shortcuts in the main window. + if raw_input.viewport_id != egui::ViewportId::ROOT { + return; + } + let mut app = self.app.lock().expect("application state lock poisoned"); + ui::result_follow::pause_on_input(&mut app, ctx, raw_input); + ui::import_feedback::cancel_on_input(&mut app, raw_input); #[cfg(windows)] ui::clipboard_native::restore_missing_paste_shortcut(raw_input); } fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) { let ctx = ui.ctx().clone(); + let shared = Arc::clone(&self.app); + let mut app = shared.lock().expect("application state lock poisoned"); observability::show_pending_crash_dialog(); - self.scale.drive(&mut self.app, &ctx, frame); + self.scale.drive(&mut app, &ctx, frame); let ribbon_chrome = ui::current_ribbon_chrome(&ctx, frame); let recovery_blocked = self.pending_recovery.is_some(); if !recovery_blocked && let Some(driver) = &mut self.shot { - driver.drive(&mut self.app, &ctx); + driver.drive(&mut app, &ctx); } - self.show_recovery_prompt(&ctx); - if self.app.session.updates.tick() { + self.show_recovery_prompt(&mut app, &ctx); + if app.session.updates.tick() { ctx.request_repaint_after(std::time::Duration::from_millis(200)); - } else if let Some(delay) = self.app.session.updates.next_check_delay() { + } else if let Some(delay) = app.session.updates.next_check_delay() { ctx.request_repaint_after(delay.max(std::time::Duration::from_millis(100))); } if let plotium_core::update::UpdateStatus::Installed { plan, .. } = - self.app.session.updates.status() + app.session.updates.status() { *PENDING_INSTALL.lock().unwrap() = Some(plan.clone()); } ui::render( - &mut self.app, + &mut app, &mut self.clipboard_table_paste, &mut self.batch_workflow, &mut self.agent_connections, @@ -210,18 +220,18 @@ impl eframe::App for Shell { ); // Apply save completion after every edit-producing poll. This makes the // generation check below cover compute results that arrived this frame. - poll_manual_project_save(&mut self.app, &mut self.manual_save_job, &ctx); - self.start_pending_project_save(&ctx); + poll_manual_project_save(&mut app, &mut self.manual_save_job, &ctx); + self.start_pending_project_save(&mut app, &ctx); self.agent_connections.poll( - &mut self.app, + &mut app, &ctx, recovery_blocked || self.manual_save_job.is_some(), ); - self.drive_project_transition(&ctx); - if self.app.data_export_busy() { + self.drive_project_transition(&mut app, &ctx); + if app.data_export_busy() { ctx.request_repaint_after(std::time::Duration::from_millis(33)); } - self.tick_recovery(&ctx); + self.tick_recovery(&mut app, &ctx); } #[cfg(windows)] diff --git a/crates/app/src/ui/canvas/board.rs b/crates/app/src/ui/canvas/board.rs index d6947e25..8e91e3aa 100644 --- a/crates/app/src/ui/canvas/board.rs +++ b/crates/app/src/ui/canvas/board.rs @@ -1,4 +1,5 @@ use super::*; +use crate::ui::viewport_local_id; /// Height (screen px) of the grab-bar/label strip drawn just above each page on /// the board. Fixed in screen space so it stays readable and grabbable at any @@ -69,15 +70,19 @@ pub(crate) fn freeze_board_for_gesture(app: &mut PlotiumApp) { /// Seed the fit springs from the live camera. fn seed_board_fit_springs(app: &mut PlotiumApp, ctx: &egui::Context) { - crate::ui::switcher::seed_spring(ctx, egui::Id::new(FIT_ZOOM_ID), app.session.board.zoom); crate::ui::switcher::seed_spring( ctx, - egui::Id::new(FIT_CENTER_X_ID), + viewport_local_id(ctx, FIT_ZOOM_ID), + app.session.board.zoom, + ); + crate::ui::switcher::seed_spring( + ctx, + viewport_local_id(ctx, FIT_CENTER_X_ID), app.session.board.world_center[0], ); crate::ui::switcher::seed_spring( ctx, - egui::Id::new(FIT_CENTER_Y_ID), + viewport_local_id(ctx, FIT_CENTER_Y_ID), app.session.board.world_center[1], ); } @@ -148,17 +153,21 @@ pub(crate) fn drive_board_fit( let ctx = ui.ctx(); let dt = ui.input(|i| i.stable_dt); let before = app.session.board; - app.session.board.zoom = - crate::ui::switcher::animate_spring(ctx, egui::Id::new(FIT_ZOOM_ID), target.zoom, dt); + app.session.board.zoom = crate::ui::switcher::animate_spring( + ctx, + viewport_local_id(ctx, FIT_ZOOM_ID), + target.zoom, + dt, + ); app.session.board.world_center[0] = crate::ui::switcher::animate_spring( ctx, - egui::Id::new(FIT_CENTER_X_ID), + viewport_local_id(ctx, FIT_CENTER_X_ID), target.world_center[0], dt, ); app.session.board.world_center[1] = crate::ui::switcher::animate_spring( ctx, - egui::Id::new(FIT_CENTER_Y_ID), + viewport_local_id(ctx, FIT_CENTER_Y_ID), target.world_center[1], dt, ); @@ -185,7 +194,7 @@ fn fit_bbox_around_occluders( // A card can cover the entire board while the window is being resized. // Keep the camera until usable space returns; there is no valid fit yet. let (best_index, best_viewport) = best?; - let id = egui::Id::new(FIT_CANDIDATE_ID); + let id = viewport_local_id(ctx, FIT_CANDIDATE_ID); let previous_index = ctx.data(|data| data.get_temp::(id)); let chosen = previous_index .filter(|index| *index != best_index) diff --git a/crates/app/src/ui/canvas/board_tests.rs b/crates/app/src/ui/canvas/board_tests.rs index 9901eeb4..fd2d0dfc 100644 --- a/crates/app/src/ui/canvas/board_tests.rs +++ b/crates/app/src/ui/canvas/board_tests.rs @@ -246,8 +246,9 @@ fn fit_uses_the_open_space_below_a_floating_task_card_when_it_is_better() { let _ = fit_bbox_around_occluders((0.0, 0.0, 800.0, 100.0), &geometry, &ctx); + let id = crate::ui::viewport_local_id(&ctx, FIT_CANDIDATE_ID); assert_eq!( - ctx.data(|data| data.get_temp::(egui::Id::new(FIT_CANDIDATE_ID))), + ctx.data(|data| data.get_temp::(id)), Some(1), "a wide target should use the full-width space below the card" ); diff --git a/crates/app/src/ui/canvas/navigation_input.rs b/crates/app/src/ui/canvas/navigation_input.rs index 2fabcbe3..3fcaf977 100644 --- a/crates/app/src/ui/canvas/navigation_input.rs +++ b/crates/app/src/ui/canvas/navigation_input.rs @@ -56,8 +56,8 @@ struct GestureEnd { pointer: Pos2, } -fn trackpad_target_id() -> egui::Id { - egui::Id::new("plotium.trackpad_navigation_target") +fn trackpad_target_id(ctx: &egui::Context) -> egui::Id { + crate::ui::viewport_local_id(ctx, "plotium.trackpad_navigation_target") } /// The plot under `p` when it is the selected plot and `p` is on its data body. @@ -94,8 +94,9 @@ pub(super) fn trackpad_target( return None; } let pass = ctx.cumulative_pass_nr(); + let id = trackpad_target_id(ctx); ctx.data_mut(|data| { - let stored = data.get_temp::(trackpad_target_id()); + let stored = data.get_temp::(id); let continued = stored.filter(|state| { let other_canvas = matches!( state.target, @@ -115,7 +116,7 @@ pub(super) fn trackpad_target( }); let target = continued.map_or_else(choose, |state| state.target); data.insert_temp( - trackpad_target_id(), + id, TrackpadTargetState { target, serial: gesture.serial, @@ -163,17 +164,18 @@ pub(super) fn note_wheel_device(ctx: &egui::Context, events: &[egui::Event], tra .iter() .any(|event| matches!(event, egui::Event::MouseWheel { .. })); if pinch || wheel { - ctx.data_mut(|data| data.insert_temp(wheel_device_id(), pinch || trackpad)); + let id = wheel_device_id(ctx); + ctx.data_mut(|data| data.insert_temp(id, pinch || trackpad)); } } pub(crate) fn last_wheel_was_trackpad(ctx: &egui::Context) -> bool { - ctx.data(|data| data.get_temp::(wheel_device_id())) - .unwrap_or(false) + let id = wheel_device_id(ctx); + ctx.data(|data| data.get_temp::(id)).unwrap_or(false) } -fn wheel_device_id() -> egui::Id { - egui::Id::new("plotium.last_wheel_trackpad") +fn wheel_device_id(ctx: &egui::Context) -> egui::Id { + crate::ui::viewport_local_id(ctx, "plotium.last_wheel_trackpad") } pub(super) fn classify_navigation_input( @@ -206,9 +208,9 @@ pub(super) fn macos_trackpad_gesture( board_target: bool, } - let state_id = egui::Id::new("plotium.macos_trackpad_gesture"); + let state_id = crate::ui::viewport_local_id(ctx, "plotium.macos_trackpad_gesture"); + let serial_id = crate::ui::viewport_local_id(ctx, "plotium.macos_trackpad_gesture_serial"); ctx.data_mut(|data| { - let serial_id = egui::Id::new("plotium.macos_trackpad_gesture_serial"); let mut serial = data.get_temp::(serial_id).unwrap_or_default(); let mut stored = data.get_temp::(state_id).unwrap_or_default(); let mut frame_target = stored.active.then_some(stored.board_target); @@ -298,7 +300,8 @@ pub(crate) fn sync_macos_trackpad_gesture( }) { let gesture = macos_trackpad_gesture(ctx, events, false); if gesture.finished { - ctx.data_mut(|data| data.remove_temp::(trackpad_target_id())); + let id = trackpad_target_id(ctx); + ctx.data_mut(|data| data.remove_temp::(id)); } } #[cfg(not(target_os = "macos"))] diff --git a/crates/app/src/ui/canvas/render_detail.rs b/crates/app/src/ui/canvas/render_detail.rs index f777f24b..9e683abe 100644 --- a/crates/app/src/ui/canvas/render_detail.rs +++ b/crates/app/src/ui/canvas/render_detail.rs @@ -10,9 +10,10 @@ struct InteractiveRenderState { } pub(super) fn mark_workspace_navigation(ctx: &egui::Context, now: f64) { + let id = crate::ui::viewport_local_id(ctx, STATE_ID); ctx.data_mut(|data| { data.insert_temp( - egui::Id::new(STATE_ID), + id, InteractiveRenderState { until: now + INTERACTIVE_SECONDS, }, @@ -22,7 +23,7 @@ pub(super) fn mark_workspace_navigation(ctx: &egui::Context, now: f64) { } pub(super) fn workspace_render_detail(ctx: &egui::Context, now: f64) -> ScreenRenderDetail { - let id = egui::Id::new(STATE_ID); + let id = crate::ui::viewport_local_id(ctx, STATE_ID); let state = ctx.data_mut(|data| data.get_temp::(id)); let Some(state) = state else { return ScreenRenderDetail::Full; @@ -81,4 +82,38 @@ mod tests { plotium_render::rich_text::navigation_font_size(12.3) ); } + + #[test] + fn navigating_one_viewport_keeps_the_other_at_full_detail() { + let ctx = egui::Context::default(); + let child = egui::ViewportId::from_hash_of("preview"); + ctx.set_embed_viewports(false); + let mut input = egui::RawInput::default(); + input.viewports.insert( + child, + egui::ViewportInfo { + parent: Some(egui::ViewportId::ROOT), + ..Default::default() + }, + ); + let _ = ctx.run_ui(input.clone(), |ui| { + mark_workspace_navigation(ui.ctx(), 10.0); + ui.ctx() + .show_viewport_deferred(child, egui::ViewportBuilder::default(), |_, _| {}); + }); + input.viewport_id = child; + let _ = ctx.run_ui(input.clone(), |ui| { + assert_eq!( + workspace_render_detail(ui.ctx(), 10.1), + ScreenRenderDetail::Full + ); + }); + input.viewport_id = egui::ViewportId::ROOT; + let _ = ctx.run_ui(input, |ui| { + assert_eq!( + workspace_render_detail(ui.ctx(), 10.1), + ScreenRenderDetail::Interactive + ); + }); + } } diff --git a/crates/app/src/ui/canvas/view_fit.rs b/crates/app/src/ui/canvas/view_fit.rs index f461006b..2bdc381c 100644 --- a/crates/app/src/ui/canvas/view_fit.rs +++ b/crates/app/src/ui/canvas/view_fit.rs @@ -21,17 +21,18 @@ pub(crate) enum PlotFitAxes { /// Publish the board rectangle canvas navigation ran against this frame, so /// keyboard commands can hit-test the pointer without re-deriving layout. pub(crate) fn store_navigation_rect(ctx: &egui::Context, rect: EguiRect) { - ctx.data_mut(|data| { - data.insert_temp(egui::Id::new(NAVIGATION_RECT_ID), rect); - }); + let id = crate::ui::viewport_local_id(ctx, NAVIGATION_RECT_ID); + ctx.data_mut(|data| data.insert_temp(id, rect)); } pub(crate) fn navigation_rect(ctx: &egui::Context) -> Option { - ctx.data(|data| data.get_temp::(egui::Id::new(NAVIGATION_RECT_ID))) + let id = crate::ui::viewport_local_id(ctx, NAVIGATION_RECT_ID); + ctx.data(|data| data.get_temp::(id)) } pub(crate) fn clear_navigation_rect(ctx: &egui::Context) { - ctx.data_mut(|data| data.remove::(egui::Id::new(NAVIGATION_RECT_ID))); + let id = crate::ui::viewport_local_id(ctx, NAVIGATION_RECT_ID); + ctx.data_mut(|data| data.remove::(id)); } /// The pointer position, unless a floating task card sits under it — over a diff --git a/crates/app/src/ui/command_exec_tests.rs b/crates/app/src/ui/command_exec_tests.rs index 099ae477..b7eaff52 100644 --- a/crates/app/src/ui/command_exec_tests.rs +++ b/crates/app/src/ui/command_exec_tests.rs @@ -43,7 +43,8 @@ fn zoom_to_fit_command_seeds_springs_from_the_live_camera() { ("board_fit_center_x", 900.0), ("board_fit_center_y", -900.0), ] { - crate::ui::switcher::animate_spring(&ctx, egui::Id::new(id), stale, 0.0); + let key = crate::ui::viewport_local_id(&ctx, id); + crate::ui::switcher::animate_spring(&ctx, key, stale, 0.0); } execute_without_clipboard(CommandId::ZoomToFit, &mut app, &ctx); @@ -57,7 +58,8 @@ fn zoom_to_fit_command_seeds_springs_from_the_live_camera() { ("board_fit_center_x", 30.0), ("board_fit_center_y", -40.0), ] { - let seeded = crate::ui::switcher::animate_spring(&ctx, egui::Id::new(id), live, 0.0); + let key = crate::ui::viewport_local_id(&ctx, id); + let seeded = crate::ui::switcher::animate_spring(&ctx, key, live, 0.0); assert_eq!(seeded, live); } assert_eq!(app.session.status, "Fit all 1 board frame to view."); diff --git a/crates/app/src/ui/data_sheet/dock_tests.rs b/crates/app/src/ui/data_sheet/dock_tests.rs index eeba5a7b..fa2cbf0e 100644 --- a/crates/app/src/ui/data_sheet/dock_tests.rs +++ b/crates/app/src/ui/data_sheet/dock_tests.rs @@ -119,12 +119,7 @@ impl Workspace { } fn board(&self) -> Rect { - self.ctx - .data(|data| { - data.get_temp::(egui::Id::new( - "plotium.workspace_geometry", - )) - }) + crate::ui::workspace_geometry::current(&self.ctx) .expect("the board was laid out") .board_rect } diff --git a/crates/app/src/ui/file_drop.rs b/crates/app/src/ui/file_drop.rs index 3b93b185..ffad6169 100644 --- a/crates/app/src/ui/file_drop.rs +++ b/crates/app/src/ui/file_drop.rs @@ -102,8 +102,7 @@ thread_local! { } pub(super) fn handle(app: &mut PlotiumApp, ctx: &egui::Context) { - let board_rect = ctx - .data(|data| data.get_temp::(egui::Id::new("plotium.canvas.navigation_rect"))); + let board_rect = canvas::navigation_rect(ctx); let (hovered_paths, dropped, pointer, now) = ctx.input(|input| { ( input diff --git a/crates/app/src/ui/mod.rs b/crates/app/src/ui/mod.rs index 4e3fe30d..6868a6a0 100644 --- a/crates/app/src/ui/mod.rs +++ b/crates/app/src/ui/mod.rs @@ -83,6 +83,11 @@ pub(crate) use windows::handle_close_request; use windows::*; use workspace_geometry::resolve as workspace_geometry; +// egui's temporary data map is shared across native windows. +fn viewport_local_id(ctx: &egui::Context, key: &str) -> Id { + Id::new((ctx.viewport_id(), key)) +} + #[allow(clippy::too_many_arguments)] // Desktop-owned services stay outside PlotiumApp. pub fn render( app: &mut PlotiumApp, diff --git a/crates/app/src/ui/primary_sidebar/selection.rs b/crates/app/src/ui/primary_sidebar/selection.rs index a7744a68..1acb1f72 100644 --- a/crates/app/src/ui/primary_sidebar/selection.rs +++ b/crates/app/src/ui/primary_sidebar/selection.rs @@ -224,8 +224,7 @@ pub(crate) fn handle_keyboard_selection(app: &mut PlotiumApp, ctx: &egui::Contex ) }); if input.3 { - let canvas_rect = - ctx.data(|data| data.get_temp::(Id::new("plotium.canvas.navigation_rect"))); + let canvas_rect = crate::ui::canvas::navigation_rect(ctx); let pointer_over_canvas = ctx .pointer_hover_pos() .zip(canvas_rect) diff --git a/crates/app/src/ui/workspace_geometry.rs b/crates/app/src/ui/workspace_geometry.rs index 273c9344..78289614 100644 --- a/crates/app/src/ui/workspace_geometry.rs +++ b/crates/app/src/ui/workspace_geometry.rs @@ -1,4 +1,4 @@ -use egui::{Id, Rect}; +use egui::Rect; use plotium_core::state::PlotiumApp; const GEOMETRY_ID: &str = "plotium.workspace_geometry"; @@ -52,17 +52,16 @@ pub(crate) fn set_sidebar_rects( primary: Option, secondary: Option, ) { + let id = super::viewport_local_id(ctx, SIDEBAR_RECTS_ID); ctx.data_mut(|data| { - data.insert_temp( - Id::new(SIDEBAR_RECTS_ID), - SidebarRects { primary, secondary }, - ); + data.insert_temp(id, SidebarRects { primary, secondary }); }); } pub(super) fn resolve(app: &PlotiumApp, host_rect: Rect, ctx: &egui::Context) -> WorkspaceGeometry { + let sidebar_id = super::viewport_local_id(ctx, SIDEBAR_RECTS_ID); let sidebars = ctx - .data(|data| data.get_temp::(Id::new(SIDEBAR_RECTS_ID))) + .data(|data| data.get_temp::(sidebar_id)) .unwrap_or_default(); let mut board_rect = host_rect; if let Some(primary) = sidebars.primary { @@ -88,8 +87,8 @@ pub(super) fn resolve(app: &PlotiumApp, host_rect: Rect, ctx: &egui::Context) -> .filter(|rect| rect.width() > 1.0 && rect.height() > 1.0) .into_iter() .collect(); - let id = Id::new(GEOMETRY_ID); - let previous = ctx.data(|data| data.get_temp::(id)); + let id = super::viewport_local_id(ctx, GEOMETRY_ID); + let previous = current(ctx); let changed = previous.as_ref().is_none_or(|old| { old.board_rect != board_rect || old.task_card_bounds != task_card_bounds @@ -109,10 +108,12 @@ pub(super) fn resolve(app: &PlotiumApp, host_rect: Rect, ctx: &egui::Context) -> } pub(crate) fn task_card_bounds(ctx: &egui::Context) -> Option { - ctx.data(|data| { - data.get_temp::(Id::new(GEOMETRY_ID)) - .map(|geometry| geometry.task_card_bounds) - }) + current(ctx).map(|geometry| geometry.task_card_bounds) +} + +pub(super) fn current(ctx: &egui::Context) -> Option { + let id = super::viewport_local_id(ctx, GEOMETRY_ID); + ctx.data(|data| data.get_temp(id)) } #[cfg(test)] diff --git a/crates/render/src/rich_text.rs b/crates/render/src/rich_text.rs index 4180b24b..77e6d875 100644 --- a/crates/render/src/rich_text.rs +++ b/crates/render/src/rich_text.rs @@ -313,20 +313,21 @@ pub fn navigation_font_size(size: f32) -> f32 { } #[cfg(feature = "screen")] -fn navigation_text_id() -> egui::Id { - egui::Id::new("plotium.render.navigation_text") +fn navigation_text_id(ctx: &egui::Context) -> egui::Id { + egui::Id::new((ctx.viewport_id(), "plotium.render.navigation_text")) } #[cfg(feature = "screen")] fn navigation_text(ctx: &egui::Context) -> bool { - ctx.data(|data| data.get_temp(navigation_text_id())) - .unwrap_or(false) + let id = navigation_text_id(ctx); + ctx.data(|data| data.get_temp(id)).unwrap_or(false) } /// Selects whether text painted from now on snaps to navigation font sizes. #[cfg(feature = "screen")] pub(crate) fn set_navigation_text(ctx: &egui::Context, enabled: bool) { - ctx.data_mut(|data| data.insert_temp(navigation_text_id(), enabled)); + let id = navigation_text_id(ctx); + ctx.data_mut(|data| data.insert_temp(id, enabled)); } /// An egui galley for `text`, with scripts set smaller and aligned to the From 4e2697ff0e628bba25d60446adec7705b05c894d Mon Sep 17 00:00:00 2001 From: Jiekang Tian Date: Sun, 15 Nov 2026 00:42:08 +0800 Subject: [PATCH 2/2] feat(app): preview a canvas in a separate window --- crates/app/src/detached_preview.rs | 250 ++++++++++++++++++ crates/app/src/main.rs | 10 +- crates/app/src/shell.rs | 24 +- crates/app/src/ui/canvas/header_menu.rs | 37 +++ crates/app/src/ui/canvas/mod.rs | 10 +- crates/app/src/ui/command_exec.rs | 3 + crates/app/src/ui/commands.rs | 7 + crates/app/src/ui/commands/identity.rs | 2 + crates/app/src/ui/commands/roster.rs | 1 + crates/app/src/ui/commands/types.rs | 1 + .../src/ui/file_dialogs/image_import/proxy.rs | 8 + crates/app/src/ui/mod.rs | 2 + crates/app/src/ui/native_lifecycle.rs | 74 ++++-- crates/app/src/ui/native_menu.rs | 21 +- crates/app/src/ui/primary_sidebar.rs | 2 + crates/app/src/ui/shortcuts.rs | 14 + .../src/content/docs/reference/ui-overview.md | 3 + .../docs/zh-cn/reference/ui-overview.md | 3 + 18 files changed, 435 insertions(+), 37 deletions(-) create mode 100644 crates/app/src/detached_preview.rs create mode 100644 crates/app/src/ui/canvas/header_menu.rs diff --git a/crates/app/src/detached_preview.rs b/crates/app/src/detached_preview.rs new file mode 100644 index 00000000..ab4fc496 --- /dev/null +++ b/crates/app/src/detached_preview.rs @@ -0,0 +1,250 @@ +//! Native read-only view of a canvas in the current project. + +use std::sync::{Arc, Mutex}; + +use egui::{Context, Id, Pos2, Rect, Vec2, ViewportCommand, ViewportId}; +use plotium_core::state::{CanvasId, PlotiumApp, ProjectContextId}; +use plotium_render::{DocumentViewport, screen}; + +#[derive(Clone, Copy)] +struct Target { + project: ProjectContextId, + canvas: CanvasId, +} + +#[derive(Default)] +pub(crate) struct DetachedPreview { + target: Option, + revision: Option<(u64, u64)>, + camera: Arc>>, +} + +#[derive(Clone, Copy)] +struct Camera { + zoom: f32, + center: Vec2, +} + +pub(crate) fn viewport_id() -> ViewportId { + ViewportId::from_hash_of("plotium.detached_preview") +} + +fn request_id() -> Id { + Id::new("plotium.detached_preview.open") +} + +pub(crate) fn active_canvas(app: &PlotiumApp) -> Option { + let index = app.session.active_canvas?; + Some(app.doc.canvases.get(index)?.resource_id) +} + +pub(crate) fn request_open(app: &mut PlotiumApp, ctx: &Context, canvas: Option) { + if ctx.embed_viewports() { + app.session.status = "Independent canvas windows are unavailable here.".into(); + return; + } + if let Some(canvas) = canvas.or_else(|| active_canvas(app)) { + ctx.data_mut(|data| { + data.insert_temp( + request_id(), + Some(Target { + project: app.session.project_context, + canvas, + }), + ); + }); + ctx.request_repaint_of(ViewportId::ROOT); + } +} + +fn canvas_index(app: &PlotiumApp, target: Target) -> Option { + if app.session.project_context != target.project { + return None; + } + app.doc + .canvases + .iter() + .position(|canvas| canvas.resource_id == target.canvas) +} + +impl DetachedPreview { + #[cfg(target_os = "macos")] + pub(crate) fn is_focused(&self, ctx: &Context) -> bool { + self.target.is_some() + && ctx.input(|input| { + input + .raw + .viewports + .get(&viewport_id()) + .is_some_and(|view| view.focused == Some(true) && view.visible() != Some(false)) + && input.viewport().focused != Some(true) + }) + } + + pub(crate) fn is_open(&self) -> bool { + self.target.is_some() + } + + pub(crate) fn close(&mut self) { + self.target = None; + self.revision = None; + } + + pub(crate) fn refresh(&mut self, app: &PlotiumApp, ctx: &Context) { + if self.target.is_none() { + return; + } + let revision = (app.doc.edit_generation, app.doc.automation_revision); + if self.revision.replace(revision) != Some(revision) { + ctx.request_repaint_of(viewport_id()); + ctx.request_repaint_of(ViewportId::ROOT); + } + } + + pub(crate) fn register( + &mut self, + app: &PlotiumApp, + ctx: &Context, + shared: &Arc>, + ) { + // The deferred callback borrows the same state on a separate pass. + // An embedded callback would run now, while the root holds the lock. + if ctx.embed_viewports() { + return; + } + if let Some(target) = + ctx.data_mut(|data| data.remove_temp::>(request_id()).flatten()) + { + self.target = Some(target); + self.camera = Arc::default(); + self.revision = None; + ctx.send_viewport_cmd_to(viewport_id(), ViewportCommand::Focus); + } + let Some(target) = self.target else { return }; + let Some(index) = canvas_index(app, target) else { + self.close(); + return; + }; + crate::ui::file_dialogs::image_import::request_thumbnail(ctx, target.canvas); + let title = format!("{} — Plotium Canvas Preview", app.doc.canvases[index].name); + let shared = Arc::clone(shared); + let camera = Arc::clone(&self.camera); + ctx.show_viewport_deferred( + viewport_id(), + egui::ViewportBuilder::default() + .with_title(title) + .with_inner_size([820.0, 580.0]), + move |ui, _| { + if ui.input(|input| input.viewport().close_requested()) { + return; + } + #[allow(unused_mut)] // macOS shortcuts are handled by the native menu. + let mut app = shared.lock().expect("application state lock poisoned"); + #[cfg(not(target_os = "macos"))] + crate::ui::handle_preview_shortcut(&mut app, ui.ctx()); + let Some(index) = canvas_index(&app, target) else { + return; + }; + let mut camera = camera.lock().expect("preview camera lock poisoned"); + render(&app, index, &mut camera, ui); + }, + ); + self.refresh(app, ctx); + } +} + +fn render(app: &PlotiumApp, index: usize, camera: &mut Option, ui: &mut egui::Ui) { + egui::Panel::top("preview_controls").show_inside(ui, |ui| { + ui.horizontal(|ui| { + if ui.button("Fit Canvas").clicked() { + *camera = None; + } + let fullscreen = ui.input(|input| input.viewport().fullscreen.unwrap_or(false)); + if ui + .button(if fullscreen { + "Exit Full Screen" + } else { + "Full Screen" + }) + .clicked() + { + ui.ctx() + .send_viewport_cmd(ViewportCommand::Fullscreen(!fullscreen)); + } + ui.weak("Read only · Drag to pan · Scroll or pinch to zoom"); + }); + }); + egui::CentralPanel::default().show_inside(ui, |ui| { + let area = ui.available_rect_before_wrap(); + let response = ui.allocate_rect(area, egui::Sense::click_and_drag()); + let document = crate::ui::canvas::image_painting::canvas_document(app, index); + let size = egui::vec2(document.width, document.height); + if !size.is_finite() + || size.x <= 0.0 + || size.y <= 0.0 + || area.width() <= 24.0 + || area.height() <= 24.0 + { + return; + } + let fit = Camera { + zoom: ((area.width() - 24.0) / size.x).min((area.height() - 24.0) / size.y), + center: size * 0.5, + }; + if response.double_clicked() { + *camera = None; + } + let drag = response.drag_delta(); + let (pan, zoom) = if response.hovered() { + ui.input(preview_scroll) + } else { + (Vec2::ZERO, 1.0) + }; + if drag != Vec2::ZERO || pan != Vec2::ZERO || (zoom - 1.0).abs() > 0.001 { + let camera = camera.get_or_insert(fit); + camera.center -= (drag + pan) / camera.zoom; + if zoom.is_finite() && (zoom - 1.0).abs() > 0.001 { + let pointer = response.hover_pos().unwrap_or(area.center()); + let anchor = pointer - area.center(); + let next_zoom = (camera.zoom * zoom).clamp(fit.zoom * 0.05, fit.zoom * 100.0); + camera.center += anchor / camera.zoom - anchor / next_zoom; + camera.zoom = next_zoom; + } + } + let camera = camera.unwrap_or(fit); + let top_left: Pos2 = area.center() - camera.center * camera.zoom; + let page = Rect::from_min_size(top_left, size * camera.zoom); + screen::paint_document_for_editor_with_detail( + &ui.painter_at(area), + plotium_render::Rect::new(page.left(), page.top(), page.width(), page.height()), + &document, + DocumentViewport { + zoom: camera.zoom, + pan: [0.0, 0.0], + }, + screen::ScreenRenderDetail::Full, + ); + }); +} + +fn preview_scroll(input: &egui::InputState) -> (Vec2, f32) { + let pinch = input.zoom_delta(); + if (pinch - 1.0).abs() > 0.001 { + return (Vec2::ZERO, pinch); + } + // macOS trackpad swipes arrive as pixel deltas. Mouse wheel notches zoom. + if cfg!(target_os = "macos") + && input.events.iter().any(|event| { + matches!( + event, + egui::Event::MouseWheel { + unit: egui::MouseWheelUnit::Point, + .. + } + ) + }) + { + return (input.smooth_scroll_delta, 1.0); + } + (Vec2::ZERO, (input.smooth_scroll_delta.y * 0.008).exp()) +} diff --git a/crates/app/src/main.rs b/crates/app/src/main.rs index 40d8a05a..2ff3bd8e 100644 --- a/crates/app/src/main.rs +++ b/crates/app/src/main.rs @@ -5,6 +5,7 @@ mod agent_connections; mod agent_install; +mod detached_preview; mod fonts; mod graphics; mod observability; @@ -120,6 +121,7 @@ pub(crate) fn cancel_relaunch() { struct Shell { // Deferred viewport callbacks can share application state without owning the shell. app: Arc>, + detached_preview: detached_preview::DetachedPreview, recovery: Option, pending_recovery: Option, pending_crash_report: Option, @@ -583,15 +585,15 @@ fn main() -> eframe::Result<()> { } } #[cfg(target_os = "macos")] - let native_menu = - ui::native_menu::NativeMenu::new(&app, &cc.egui_ctx).map_err(|error| { - std::io::Error::other(format!("failed to install macOS menu: {error}")) - })?; + let native_menu = ui::native_menu::NativeMenu::new(&app, cc).map_err(|error| { + std::io::Error::other(format!("failed to install macOS menu: {error}")) + })?; #[cfg(target_os = "macos")] open_documents.set_context(&cc.egui_ctx); let observed_edit_generation = app.doc.edit_generation; Ok(Box::new(Shell { app: Arc::new(Mutex::new(app)), + detached_preview: Default::default(), recovery, pending_recovery, pending_crash_report, diff --git a/crates/app/src/shell.rs b/crates/app/src/shell.rs index 7c9bc453..947b6d6f 100644 --- a/crates/app/src/shell.rs +++ b/crates/app/src/shell.rs @@ -153,11 +153,18 @@ impl eframe::App for Shell { let mut app = shared.lock().expect("application state lock poisoned"); #[cfg(target_os = "macos")] { + if ctx.input(|input| input.viewport().close_requested()) { + self.detached_preview.close(); + } // Native menus and Dock events must also work with no visible window. if self.pending_recovery.is_none() { self.open_documents.poll(&mut app, ctx); - self.native_menu - .poll(&mut app, &mut self.clipboard_table_paste, ctx); + self.native_menu.poll( + &mut app, + &mut self.clipboard_table_paste, + ctx, + &mut self.detached_preview, + ); } // Fullscreen transitions can make the root temporarily non-visible: // eframe still calls logic, but skips ui and would otherwise exit. @@ -172,12 +179,24 @@ impl eframe::App for Shell { ctx, self.pending_recovery.is_some() || self.manual_save_job.is_some(), ); + self.detached_preview.register(&app, ctx, &shared); + if ctx.input(|input| input.viewport().visible() == Some(false)) + && self.detached_preview.is_open() + { + ui::file_dialogs::image_import::poll_rebuilds(&mut app, ctx); + } } fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) { // eframe calls this hook for child viewports too. Their input must // not cancel intents or synthesize shortcuts in the main window. if raw_input.viewport_id != egui::ViewportId::ROOT { + if raw_input.viewport_id == detached_preview::viewport_id() + && raw_input.viewport().close_requested() + { + self.detached_preview.close(); + ctx.request_repaint_of(egui::ViewportId::ROOT); + } return; } let mut app = self.app.lock().expect("application state lock poisoned"); @@ -232,6 +251,7 @@ impl eframe::App for Shell { ctx.request_repaint_after(std::time::Duration::from_millis(33)); } self.tick_recovery(&mut app, &ctx); + self.detached_preview.refresh(&app, &ctx); } #[cfg(windows)] diff --git a/crates/app/src/ui/canvas/header_menu.rs b/crates/app/src/ui/canvas/header_menu.rs new file mode 100644 index 00000000..de8b3c4b --- /dev/null +++ b/crates/app/src/ui/canvas/header_menu.rs @@ -0,0 +1,37 @@ +use egui::{Rect, Response, Ui}; +use plotium_core::state::{CanvasId, FrameRef, PlotiumApp}; + +use super::board::{frame_header_at, frame_zoom_menu}; +use crate::ui::{commands, menus}; + +pub(super) fn show_header_menu(app: &mut PlotiumApp, board: Rect, response: &Response) -> bool { + let ctx = &response.ctx; + let key = response.id.with("canvas_header_menu"); + if response.secondary_clicked() { + let canvas = response + .interact_pointer_pos() + .filter(|point| board.contains(*point)) + .and_then(|point| match frame_header_at(app, board, point)? { + FrameRef::Page(index) => Some(app.doc.canvases.get(index)?.resource_id), + FrameRef::Sheet(_) => None, + }); + ctx.data_mut(|data| data.insert_temp(key, canvas)); + } + let Some(canvas) = ctx.data(|data| data.get_temp::>(key).flatten()) else { + return false; + }; + response + .context_menu(|ui| { + detached_preview_menu(app, ui, canvas); + frame_zoom_menu(app, ui); + }) + .is_some() +} + +pub(crate) fn detached_preview_menu(app: &mut PlotiumApp, ui: &mut Ui, canvas: CanvasId) { + let id = commands::CommandId::DetachedPreview(Some(canvas)); + if menus::command_row(app, ui, id, None) { + commands::execute_without_clipboard(id, app, ui.ctx()); + ui.close(); + } +} diff --git a/crates/app/src/ui/canvas/mod.rs b/crates/app/src/ui/canvas/mod.rs index 4ce90ff5..f477015f 100644 --- a/crates/app/src/ui/canvas/mod.rs +++ b/crates/app/src/ui/canvas/mod.rs @@ -32,6 +32,9 @@ mod authoring; mod axis_mapping; mod band_editor; mod board; +mod header_menu; +pub(crate) use header_menu::detached_preview_menu; +use header_menu::show_header_menu; mod board_caption; mod board_marquee; mod board_notes; @@ -306,8 +309,11 @@ pub fn render_central(app: &mut PlotiumApp, ui: &mut Ui) { paint_frame_captions(app, rect, ui, &painter); render_inline_panel_note_editor(app, rect, ui); paint_sheet_frames(app, rect, ui, &painter); + let header_menu = show_header_menu(app, rect, &resp); if !board_frame_display(app, FrameRef::Page(ci)).shows_content() { - resp.context_menu(|ui| frame_zoom_menu(app, ui)); + if !header_menu { + resp.context_menu(|ui| frame_zoom_menu(app, ui)); + } return; } paint_layout_overlay(app, ci, rect, &painter, chrome); @@ -328,7 +334,7 @@ pub fn render_central(app: &mut PlotiumApp, ui: &mut Ui) { canvas_cursor(app, ci, rect, ui); } - if data_edit_target(app, ci).is_none() { + if !header_menu && data_edit_target(app, ci).is_none() { if resp.secondary_clicked() && let Some(pointer) = resp.interact_pointer_pos() { diff --git a/crates/app/src/ui/command_exec.rs b/crates/app/src/ui/command_exec.rs index 4448d192..217c6e4f 100644 --- a/crates/app/src/ui/command_exec.rs +++ b/crates/app/src/ui/command_exec.rs @@ -234,6 +234,9 @@ fn execute_inner( CommandId::UiScaleUp => crate::scale::nudge_ui_zoom(app, ctx, 1), CommandId::UiScaleDown => crate::scale::nudge_ui_zoom(app, ctx, -1), CommandId::UiScaleReset => crate::scale::reset_ui_zoom(app, ctx), + CommandId::DetachedPreview(canvas) => { + crate::detached_preview::request_open(app, ctx, canvas) + } CommandId::Present => super::present::toggle_present_mode(app), CommandId::ToggleGrid => { if let Some(canvas) = app.session.active_canvas { diff --git a/crates/app/src/ui/commands.rs b/crates/app/src/ui/commands.rs index 97af4824..ee1bc046 100644 --- a/crates/app/src/ui/commands.rs +++ b/crates/app/src/ui/commands.rs @@ -273,6 +273,13 @@ pub fn describe(app: &PlotiumApp, id: CommandId) -> CommandDescriptor { .is_some_and(|monitor| monitor.user.is_some()), "Adjust the UI scale before resetting it to automatic.", ), + CommandId::DetachedPreview(canvas) => requires( + canvas.map_or_else( + || crate::detached_preview::active_canvas(app).is_some(), + |id| app.doc.canvases.iter().any(|canvas| canvas.resource_id == id), + ), + "Select a canvas before opening a preview.", + ), CommandId::Present => requires( has_canvas, "Open a canvas before entering presentation mode.", diff --git a/crates/app/src/ui/commands/identity.rs b/crates/app/src/ui/commands/identity.rs index a8010b53..a94186dc 100644 --- a/crates/app/src/ui/commands/identity.rs +++ b/crates/app/src/ui/commands/identity.rs @@ -213,6 +213,7 @@ pub(super) fn command_identity( Some(icon::ARROW_COUNTER_CLOCKWISE), None, ), + CommandId::DetachedPreview(_) => plain("Open in New Window", None), CommandId::Present => ( "Present Full Screen".into(), Some(icon::PROJECTOR_SCREEN), @@ -554,6 +555,7 @@ fn simple_stable_id(id: CommandId) -> &'static str { CommandId::UiScaleDown => "view.ui_scale_down", CommandId::UiScaleReset => "view.ui_scale_reset", CommandId::Present => "view.present", + CommandId::DetachedPreview(_) => "view.detached_preview", CommandId::ToggleGrid => "view.grid", CommandId::ToggleSnap => "view.snap", CommandId::Preferences => "app.preferences", diff --git a/crates/app/src/ui/commands/roster.rs b/crates/app/src/ui/commands/roster.rs index 6eefe957..1c01f10e 100644 --- a/crates/app/src/ui/commands/roster.rs +++ b/crates/app/src/ui/commands/roster.rs @@ -86,6 +86,7 @@ pub(super) fn command_ids(recent_files: usize) -> Vec { CommandId::UiScaleDown, CommandId::UiScaleReset, CommandId::Present, + CommandId::DetachedPreview(None), CommandId::ToggleGrid, CommandId::ToggleSnap, CommandId::Preferences, diff --git a/crates/app/src/ui/commands/types.rs b/crates/app/src/ui/commands/types.rs index e2b3bda3..a99df0c4 100644 --- a/crates/app/src/ui/commands/types.rs +++ b/crates/app/src/ui/commands/types.rs @@ -81,6 +81,7 @@ pub enum CommandId { UiScaleDown, UiScaleReset, Present, + DetachedPreview(Option), ToggleGrid, ToggleSnap, Preferences, diff --git a/crates/app/src/ui/file_dialogs/image_import/proxy.rs b/crates/app/src/ui/file_dialogs/image_import/proxy.rs index 936bcdb7..ad40ae15 100644 --- a/crates/app/src/ui/file_dialogs/image_import/proxy.rs +++ b/crates/app/src/ui/file_dialogs/image_import/proxy.rs @@ -210,6 +210,14 @@ pub(crate) fn poll_rebuilds(app: &mut PlotiumApp, ctx: &egui::Context) { .insert((hash, page_index), decoded_edge.min(*edge)); // The board and sidebar were already painted this frame. ctx.request_repaint(); + if ctx.input(|input| { + input + .raw + .viewports + .contains_key(&crate::detached_preview::viewport_id()) + }) { + ctx.request_repaint_of(crate::detached_preview::viewport_id()); + } } if rebuilds.active.is_some() { return; diff --git a/crates/app/src/ui/mod.rs b/crates/app/src/ui/mod.rs index 6868a6a0..f812b3bb 100644 --- a/crates/app/src/ui/mod.rs +++ b/crates/app/src/ui/mod.rs @@ -51,6 +51,8 @@ mod scientific_task_feedback; mod secondary_sidebar; mod settings_dialog; mod shortcuts; +#[cfg(not(target_os = "macos"))] +pub(crate) use shortcuts::handle_preview_shortcut; mod sidebars; mod switcher; #[cfg(not(target_os = "macos"))] diff --git a/crates/app/src/ui/native_lifecycle.rs b/crates/app/src/ui/native_lifecycle.rs index 5db118bc..5964697b 100644 --- a/crates/app/src/ui/native_lifecycle.rs +++ b/crates/app/src/ui/native_lifecycle.rs @@ -3,9 +3,10 @@ use std::cell::Cell; use objc2::rc::Retained; +use objc2::runtime::AnyObject; use objc2::{DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send, sel}; use objc2_app_kit::{ - NSWindowDidEnterFullScreenNotification, NSWindowDidExitFullScreenNotification, + NSWindow, NSWindowDidEnterFullScreenNotification, NSWindowDidExitFullScreenNotification, NSWindowWillEnterFullScreenNotification, NSWindowWillExitFullScreenNotification, }; use objc2_foundation::{ @@ -13,6 +14,7 @@ use objc2_foundation::{ NSObjectProtocol, }; use plotium_core::state::PlotiumApp; +use raw_window_handle::{HasWindowHandle, RawWindowHandle}; // Core Apple event FourCharCodes from AERegistry.h. const CORE_EVENT_CLASS: u32 = u32::from_be_bytes(*b"aevt"); @@ -70,10 +72,10 @@ pub(super) struct AppleEvents { } impl AppleEvents { - pub(super) fn new(ctx: &egui::Context) -> Self { + pub(super) fn new(cc: &eframe::CreationContext<'_>) -> Self { let mtm = MainThreadMarker::new().expect("native menus are created on the main thread"); let handler = LifecycleHandler::alloc(mtm).set_ivars(EventState { - ctx: ctx.clone(), + ctx: cc.egui_ctx.clone(), quit_requested: Cell::new(false), }); // SAFETY: NSObject's init has this signature and initializes our superclass. @@ -98,30 +100,41 @@ impl AppleEvents { andEventID: QUIT_APPLICATION ]; } + let root_window = root_window(cc); + if root_window.is_none() { + log::warn!("could not identify the main window for full screen notifications"); + } let center = NSNotificationCenter::defaultCenter(); - // SAFETY: These selectors each take one NSNotification. Only the root - // window can enter full screen; tool windows are embedded egui panels. + // SAFETY: These selectors each take one NSNotification. Filter by the + // root window so a preview changing Space cannot affect root close. // Observe completion without replacing winit's native window delegate. - unsafe { - for (name, selector) in [ - ( - NSWindowWillEnterFullScreenNotification, - sel!(fullscreenWillChange:), - ), - ( - NSWindowWillExitFullScreenNotification, - sel!(fullscreenWillChange:), - ), - ( - NSWindowDidEnterFullScreenNotification, - sel!(fullscreenDidEnter:), - ), - ( - NSWindowDidExitFullScreenNotification, - sel!(fullscreenDidExit:), - ), - ] { - center.addObserver_selector_name_object(&handler, selector, Some(name), None); + if let Some(root_window) = root_window { + unsafe { + for (name, selector) in [ + ( + NSWindowWillEnterFullScreenNotification, + sel!(fullscreenWillChange:), + ), + ( + NSWindowWillExitFullScreenNotification, + sel!(fullscreenWillChange:), + ), + ( + NSWindowDidEnterFullScreenNotification, + sel!(fullscreenDidEnter:), + ), + ( + NSWindowDidExitFullScreenNotification, + sel!(fullscreenDidExit:), + ), + ] { + center.addObserver_selector_name_object( + &handler, + selector, + Some(name), + Some(&root_window), + ); + } } } Self { handler } @@ -155,6 +168,17 @@ impl Drop for AppleEvents { } } +fn root_window(cc: &eframe::CreationContext<'_>) -> Option> { + let handle = cc.window_handle().ok()?; + let RawWindowHandle::AppKit(handle) = handle.as_raw() else { + return None; + }; + // SAFETY: On the main thread, raw-window-handle guarantees a live NSView + // for the lifetime of the handle. NSView's window getter returns NSWindow. + let view = unsafe { handle.ns_view.cast::().as_ref() }; + unsafe { msg_send![view, window] } +} + pub(super) fn show_window(ctx: &egui::Context) { super::window_lifecycle::cancel_close(ctx); ctx.send_viewport_cmd(egui::ViewportCommand::Visible(true)); diff --git a/crates/app/src/ui/native_menu.rs b/crates/app/src/ui/native_menu.rs index 5523e2ee..499fccf6 100644 --- a/crates/app/src/ui/native_menu.rs +++ b/crates/app/src/ui/native_menu.rs @@ -55,7 +55,11 @@ pub(crate) struct NativeMenu { } impl NativeMenu { - pub(crate) fn new(app: &PlotiumApp, ctx: &egui::Context) -> Result { + pub(crate) fn new( + app: &PlotiumApp, + cc: &eframe::CreationContext<'_>, + ) -> Result { + let ctx = &cc.egui_ctx; let (sender, receiver) = mpsc::channel(); let repaint = ctx.clone(); muda::MenuEvent::set_event_handler(Some(move |event: muda::MenuEvent| { @@ -69,7 +73,7 @@ impl NativeMenu { let menu = Menu::new(); let mut native = Self { _menu: menu, - lifecycle: super::native_lifecycle::AppleEvents::new(ctx), + lifecycle: super::native_lifecycle::AppleEvents::new(cc), receiver, events: HashMap::new(), tracked: Vec::new(), @@ -113,6 +117,7 @@ impl NativeMenu { app: &mut PlotiumApp, clipboard: &mut ClipboardTablePaste, ctx: &egui::Context, + preview: &mut crate::detached_preview::DetachedPreview, ) { // AppKit fires menu key equivalents before egui ever sees the // keystroke, so mirror the focus gate every egui shortcut handler @@ -127,7 +132,13 @@ impl NativeMenu { let Some(&id) = self.events.get(&stable_id) else { continue; }; - if typing + let preview_focused = preview.is_focused(ctx); + if preview_focused && id == CommandId::CloseWindow { + preview.close(); + continue; + } + if !preview_focused + && typing && !matches!( id, CommandId::CommandPalette | CommandId::CloseWindow | CommandId::Quit @@ -136,7 +147,9 @@ impl NativeMenu { { continue; } - if id != CommandId::CloseWindow { + if id != CommandId::CloseWindow + && (!preview_focused || matches!(id, CommandId::Quit | CommandId::CommandPalette)) + { super::native_lifecycle::show_window(ctx); } commands::execute(id, app, clipboard, ctx); diff --git a/crates/app/src/ui/primary_sidebar.rs b/crates/app/src/ui/primary_sidebar.rs index fbb3d130..fa1b29e3 100644 --- a/crates/app/src/ui/primary_sidebar.rs +++ b/crates/app/src/ui/primary_sidebar.rs @@ -180,6 +180,8 @@ fn canvas_list(app: &mut PlotiumApp, ui: &mut Ui) { start_rename = Some(ci); } resp.context_menu(|ui| { + let canvas = app.doc.canvases[ci].resource_id; + crate::ui::canvas::detached_preview_menu(app, ui, canvas); if ui.button("Rename").clicked() { start_rename = Some(ci); ui.close(); diff --git a/crates/app/src/ui/shortcuts.rs b/crates/app/src/ui/shortcuts.rs index 95c02b07..fd93ec0d 100644 --- a/crates/app/src/ui/shortcuts.rs +++ b/crates/app/src/ui/shortcuts.rs @@ -354,6 +354,20 @@ fn shortcut_command(ctx: &egui::Context) -> Option { }) } +#[cfg(not(target_os = "macos"))] +pub(crate) fn handle_preview_shortcut(app: &mut PlotiumApp, ctx: &egui::Context) { + use commands::CommandId; + match ctx.input(bound_command) { + // The main window's Ctrl+W closes the project. Here it closes the view. + Some(CommandId::CloseProject) => ctx.send_viewport_cmd(egui::ViewportCommand::Close), + Some(id @ (CommandId::Undo | CommandId::Redo)) => { + commands::execute_without_clipboard(id, app, ctx); + ctx.request_repaint_of(egui::ViewportId::ROOT); + } + _ => {} + } +} + fn bound_command(i: &egui::InputState) -> Option { BINDINGS .iter() diff --git a/docs/src/content/docs/reference/ui-overview.md b/docs/src/content/docs/reference/ui-overview.md index 33847c14..ec615796 100644 --- a/docs/src/content/docs/reference/ui-overview.md +++ b/docs/src/content/docs/reference/ui-overview.md @@ -40,6 +40,9 @@ introduces the same regions in walkthrough form. [Navigation](/reference/shortcuts/#navigation) for fitting and moving the view. Screen plots adapt line and contour detail to their displayed size. Zoom in to inspect fine detail; figure exports are unaffected by this screen simplification. + Right-click a page header or its row in the **Canvas** sidebar and choose + **Open in New Window** to preview that page. Edits in the main window update + the preview, which has its own pan, zoom, and **Fit Canvas** controls. - **Data sheet** — the panel docked below the board where a table is edited. The board shrinks to make room. Drag its top edge to resize it; its header collapses, maximizes, or closes it. See [Tables](/guides/tables/#editing). diff --git a/docs/src/content/docs/zh-cn/reference/ui-overview.md b/docs/src/content/docs/zh-cn/reference/ui-overview.md index dc5d650d..6ddf609f 100644 --- a/docs/src/content/docs/zh-cn/reference/ui-overview.md +++ b/docs/src/content/docs/zh-cn/reference/ui-overview.md @@ -33,6 +33,9 @@ Plotium 的界面为英文;手册中加粗的英文词即界面上的原文标 [导航](/zh-cn/reference/shortcuts/#导航)。 屏幕上的曲线和等高线细节会随显示尺寸调整。检查精细结构时请放大视图; 图形导出不受这种屏幕简化影响。 + 右键单击页面标题或 **Canvas** 侧栏中对应的条目,选择 **Open in New Window**, + 即可在独立窗口预览该页面。主窗口中的编辑会实时更新预览;预览窗口可独立平移、 + 缩放,也可点击 **Fit Canvas** 让页面适应窗口。 - **数据工作表(Data sheet)**——停靠在画板下方、用于编辑表格的面板,画板会相应 变矮。拖动其上边缘可调整高度;标题栏可折叠、最大化或关闭它。参见 [表格](/zh-cn/guides/tables/#编辑)。