VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(vectorcraft): move main.rs items to {app,host_services,prefs,titlebar}.rs
aiongg7bbf803f7e5b
diff --git a/apps/vectorcraft/src/app.rs b/apps/vectorcraft/src/app.rsnew file mode 100644index 000000000..c7d6ada32--- /dev/null+++ b/apps/vectorcraft/src/app.rs@@ -0,0 +1,166 @@+use super::prefs::save_prefs;+use super::*;++/// The parts of [`App::raw_input_hook`] that every window needs, for the OS windows of floating+/// panels: a click or Escape that closes the macOS menu bar's open menu, and the pen barrel+/// button's secondary click on Windows. The control channel's input and the native menu's keys+/// go to the main window only.+#[cfg(target_os = "macos")]+pub(crate) fn native_input_hook(app: &VectorcraftApp) -> Option<vectorcraft_ui_egui::NativeInputHook> {+ app.services.native_menu.is_some().then(|| std::sync::Arc::new(mac_menu::raw_input_hook) as vectorcraft_ui_egui::NativeInputHook)+}++#[cfg(all(windows, not(target_vendor = "win7")))]+pub(crate) fn native_input_hook(_: &VectorcraftApp) -> Option<vectorcraft_ui_egui::NativeInputHook> {+ Some(std::sync::Arc::new(windows_stylus::raw_input_hook))+}++#[cfg(not(any(target_os = "macos", all(windows, not(target_vendor = "win7")))))]+pub(crate) fn native_input_hook(_: &VectorcraftApp) -> Option<vectorcraft_ui_egui::NativeInputHook> {+ None+}++impl eframe::App for App {+ // Each frame runs unconfined: it is the person at the keyboard's. The app confines what the+ // control channel asks for, and the frames carrying input it injected, to the automation roots+ // (`VectorcraftApp::with_automation_roots`), which are in force elsewhere in the process.+ fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {+ file_access::unconfined(|| self.logic_frame(ctx, frame));+ self.app.finish_ime_logic(ctx);+ }+ /// Restore the borderless caption, apply platform menu and pen input, and hand the frame to the+ /// app's raw-input hook while the keyboard user is unconfined.+ fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {+ // winit gives the window its caption back when it changes the window's flags (maximize,+ // restore, …): take it off again before the frame is laid out (#1758).+ if let Some(window_frame) = self.window_frame.as_mut() {+ window_frame();+ }+ #[cfg(target_os = "macos")]+ if self.app.services.native_menu.is_some() {+ mac_menu::raw_input_hook(raw);+ }+ // A pen contact with the barrel button held presses the secondary button (Windows Ink).+ #[cfg(all(windows, not(target_vendor = "win7")))]+ windows_stylus::raw_input_hook(raw);+ file_access::unconfined(|| self.app.raw_input_hook(ctx, raw));+ }+ #[cfg_attr(not(target_os = "macos"), allow(unused_variables))]+ fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {+ #[cfg(target_os = "macos")]+ {+ let bar = vectorcraft_ui_egui::chrome::APP_BAR_HEIGHT;+ let inset = mac_window::center_buttons(frame, ui.ctx().zoom_factor(), bar);+ self.app.titlebar_inset = inset.unwrap_or(mac_window::DEFAULT_INSET);+ }+ file_access::unconfined(|| self.app.ui(ui));+ // Preferences are written when confirmed, not only at exit: a session ended any other way+ // (the system shutting down, the process ended or crashing) used to lose them (#1747).+ if self.app.take_prefs_changed() {+ file_access::unconfined(|| save_prefs(&self.app));+ }+ // Not while a file dialog's sheet has the keyboard: its name field's composition would go.+ #[cfg(target_os = "macos")]+ if !self.app.file_dialog_open() && self.app.take_ime_discard() {+ discard_marked_text();+ }+ }+ #[cfg(not(feature = "windows7"))]+ fn on_exit(&mut self) {+ file_access::unconfined(|| save_prefs(&self.app));+ end_before_teardown(self.frames);+ }+ #[cfg(feature = "windows7")]+ fn on_exit(&mut self, _gl: Option<&eframe::glow::Context>) {+ file_access::unconfined(|| save_prefs(&self.app));+ }+}++impl App {+ fn logic_frame(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {+ self.frames = ctx.cumulative_frame_nr();+ if let Some(why) = self.graphics_loss.take() {+ // eframe can't give a window a new device: the user saves and starts again.+ self.graphics_lost = self.app.graphics_lost(&why);+ self.app.status(if self.graphics_lost {+ "The graphics device was lost: unsaved changes are kept for Data Recovery. Save your documents and restart VectorCraft"+ } else {+ "The graphics device was lost: save your documents and restart VectorCraft"+ });+ }+ if self.graphics_lost && ctx.input(|i| i.viewport().close_requested()) {+ // The window can't show the Save Changes question: it closes, and the next launch+ // offers the changes back.+ vectorcraft_ui_egui::background::wait_all(&mut self.app);+ return;+ }+ // Files from the Finder and the Dock wait while a file dialog is open: what asked for it runs+ // again on its document when it answers.+ #[cfg(target_os = "macos")]+ if !self.app.file_dialog_open() {+ let files = open_documents::take();+ if !files.is_empty() {+ bring_window_forward(ctx);+ }+ open_files(&mut self.app, files);+ }+ self.app.tick(ctx);+ if self.pending_maximize {+ if let Some(w) = &self.winit_window {+ self.pending_maximize = window::apply_pending_maximize(w, true, &mut self.maximize_tries);+ } else {+ self.pending_maximize = false;+ }+ }+ let host_maximized = self.winit_window.as_ref().map(|w| w.is_maximized());+ window::track(ctx, &mut self.app.ui.window, host_maximized);+ if self.app.ui.status == "quit" {+ ctx.send_viewport_cmd(egui::ViewportCommand::Close);+ }+ }+}++/// On macOS with accessibility, end the process once the app has saved what it keeps on quitting,+/// before eframe tears the window down (#661). AccessKit then gives the window's content view back+/// its own class, which AppKit's Touch Bar support was observing it under, and AppKit aborts the+/// app as it quits on Macs with a Touch Bar. Nothing after the window is needed on a normal quit.+/// Not while the window is still starting up (`frames` below [`gpu::STARTUP_FRAMES`]): a graphics+/// failure then starts the app again on another adapter (#651).+#[allow(unused_variables)]+fn end_before_teardown(frames: u64) {+ #[cfg(all(target_os = "macos", feature = "accessibility", feature = "wgpu"))]+ if frames >= gpu::STARTUP_FRAMES {+ log::info!("quitting");+ log::logger().flush();+ std::process::exit(0);+ }+}++/// Show the window when files are opened from the Finder or the Dock: a minimized window comes back+/// out of the Dock and the app takes focus, as a document-based Mac app does (#3769).+#[cfg_attr(not(target_os = "macos"), allow(dead_code))]+pub(crate) fn bring_window_forward(ctx: &egui::Context) {+ ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(false));+ ctx.send_viewport_cmd(egui::ViewportCommand::Focus);+}++/// Open files handed to the app (command line, macOS Finder and Dock) as documents. A file that+/// can't be opened is reported to the user and on stderr; the others still open.+pub(crate) fn open_files(app: &mut VectorcraftApp, files: Vec<String>) {+ for f in files {+ if let Err(e) = vectorcraft_ui_egui::io::open_reporting(app, &f) {+ eprintln!("vectorcraft: {f}: {e}");+ }+ }+}++/// Tell the macOS input method to drop its composition (the Type tool kept the marked text as+/// typed). winit's IME toggle only clears its own copy, so the IME would type it again.+#[cfg(target_os = "macos")]+fn discard_marked_text() {+ if let Some(mtm) = objc2::MainThreadMarker::new()+ && let Some(ic) = objc2_app_kit::NSTextInputContext::currentInputContext(mtm)+ {+ ic.discardMarkedText();+ }+}diff --git a/apps/vectorcraft/src/host_services.rs b/apps/vectorcraft/src/host_services.rsnew file mode 100644index 000000000..aa7d7f42c--- /dev/null+++ b/apps/vectorcraft/src/host_services.rs@@ -0,0 +1,326 @@+use super::*;++/// The window file dialogs belong to.+pub(crate) type Parent = Option<std::sync::Arc<winit::window::Window>>;++/// What rfd's blocking and asynchronous file dialogs are both set up with.+trait DialogSettings: Sized {+ fn parent(self, window: &winit::window::Window) -> Self;+ fn title(self, title: &str) -> Self;+ fn filter(self, name: &str, exts: &[impl ToString]) -> Self;+ fn folder(self, folder: &str) -> Self;+ fn file_name(self, name: &str) -> Self;+}++macro_rules! dialog_settings {+ ($($dialog:ty),*) => {$(+ impl DialogSettings for $dialog {+ fn parent(self, window: &winit::window::Window) -> Self {+ self.set_parent(window)+ }+ fn title(self, title: &str) -> Self {+ self.set_title(title)+ }+ fn filter(self, name: &str, exts: &[impl ToString]) -> Self {+ self.add_filter(name, exts)+ }+ fn folder(self, folder: &str) -> Self {+ self.set_directory(folder)+ }+ fn file_name(self, name: &str) -> Self {+ self.set_file_name(name)+ }+ }+ )*};+}++dialog_settings!(rfd::FileDialog, rfd::AsyncFileDialog);++/// `d` set up for `request`: its title, file types, folder and suggested name.+fn dialog_for<D: DialogSettings>(d: D, request: &PickRequest) -> D {+ let pick = match request {+ PickRequest::Open(pick) | PickRequest::Save(pick) => pick,+ PickRequest::OpenMany => {+ return fileio::place_filters().fold(d.title(vectorcraft_ui_egui::i18n::t("Place")), |d, (name, exts)| {+ d.filter(vectorcraft_ui_egui::i18n::tr_ctx(vectorcraft_ui_egui::i18n::current(), "file-filter", name), exts)+ });+ }+ PickRequest::Folder => return d,+ };+ let d = pick.filters.iter().fold(d, |d, (name, exts)| {+ d.filter(vectorcraft_ui_egui::i18n::tr_ctx(vectorcraft_ui_egui::i18n::current(), "file-filter", name.as_str()), exts)+ });+ let d = match &pick.folder {+ Some(folder) => d.folder(folder),+ None => d,+ };+ if pick.name.is_empty() { d } else { d.file_name(&pick.name) }+}++/// A native file dialog for `request` over `parent` (on Linux the portal then shows it over the+/// window and keeps it in front).+#[cfg(not(target_os = "macos"))]+fn file_dialog(request: &PickRequest, parent: &Parent) -> rfd::FileDialog {+ match parent {+ Some(w) => dialog_for(rfd::FileDialog::new().parent(w), request),+ None => dialog_for(rfd::FileDialog::new(), request),+ }+}++/// Before `request`'s dialog shows: a save dialog's folder (the Templates folder) may not exist yet.+fn make_folder(request: &PickRequest) {+ if let PickRequest::Save(FilePick { folder: Some(folder), .. }) = request {+ let _ = std::fs::create_dir_all(folder);+ }+}++/// Show `dialog` for `request` (on the calling thread, until it closes) → the paths picked. On+/// Linux and the BSDs a save dialog with two or more file types is the desktop portal's, over+/// `parent`, and its answer also names the file type picked ([`portal_save`]); `dialog` shows when+/// the portal can't.+#[cfg(not(target_os = "macos"))]+#[cfg_attr(windows, allow(unused_variables))]+fn show_dialog(dialog: rfd::FileDialog, request: &PickRequest, parent: &Parent) -> Vec<String> {+ make_folder(request);+ #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd"))]+ if let PickRequest::Save(pick) = request+ && let Some(answer) = portal_save::pick(pick, parent.as_deref())+ {+ return answer;+ }+ let paths = match request {+ PickRequest::Open(_) => dialog.pick_file().into_iter().collect(),+ PickRequest::OpenMany => dialog.pick_files().unwrap_or_default(),+ PickRequest::Save(_) => dialog.save_file().into_iter().collect(),+ PickRequest::Folder => dialog.pick_folder().into_iter().collect(),+ };+ paths.into_iter().map(|p| p.to_string_lossy().to_string()).collect()+}++/// Show the dialog for `request` over `parent` now → the paths picked.+#[cfg(not(target_os = "macos"))]+fn pick_now(request: PickRequest, parent: &Parent) -> Vec<String> {+ show_dialog(file_dialog(&request, parent), &request, parent)+}++/// macOS shows no dialog in line: its modal loop would run inside winit's event handler, and an+/// event winit held back meanwhile aborts the app (#867). Dialogs are sheets there ([`start_pick`]);+/// one asked for any other way (a bug: outside a command, a dialog's OK or a button) picks nothing.+#[cfg(target_os = "macos")]+fn pick_now(request: PickRequest, _parent: &Parent) -> Vec<String> {+ log::error!("no file dialog shown for {request:?}: macOS shows them as sheets, from commands, dialogs' OK and buttons only");+ Vec::new()+}++/// File → Show in Folder: select `path` in Finder / Explorer, or open its folder elsewhere.+fn reveal(path: &str) -> Result<(), String> {+ explorer_safe(path)?;+ reveal_command(path).spawn().map(|_| ()).map_err(|e| format!("can't show {path}: {e}"))+}++#[cfg(target_os = "macos")]+fn reveal_command(path: &str) -> std::process::Command {+ let mut c = std::process::Command::new("open");+ c.args(["-R", path]);+ c+}++#[cfg(windows)]+fn reveal_command(path: &str) -> std::process::Command {+ use std::os::windows::process::CommandExt as _;+ // Explorer reads `/select,"path"` itself (the usual argument quoting breaks paths with spaces)+ // and needs backslashes.+ let mut c = std::process::Command::new("explorer");+ c.raw_arg(format!("/select,\"{}\"", path.replace('/', "\\")));+ c+}++#[cfg(not(any(target_os = "macos", windows)))]+fn reveal_command(path: &str) -> std::process::Command {+ let folder = std::path::Path::new(path).parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(std::path::Path::new("."));+ let mut c = std::process::Command::new("xdg-open");+ c.arg(folder);+ c+}++/// Write a file the safe way: a failed write keeps the old file ([`fileio::write_atomic`]).+fn write_file(path: &str, bytes: &[u8]) -> Result<(), String> {+ fileio::write_atomic(std::path::Path::new(path), bytes).map_err(|e| e.to_string())+}++/// Linux: show the dialog for `request` over `parent` on a thread of its own, answering on the+/// receiver. Shown on the UI thread, nothing would answer the compositor meanwhile, which then+/// offers to kill the window as not responding (#592).+#[cfg(not(target_os = "macos"))]+fn start_pick(request: PickRequest, parent: &Parent, ui: &egui::Context) -> Option<std::sync::mpsc::Receiver<Vec<String>>> {+ let dialog = file_dialog(&request, parent);+ let (tx, rx) = std::sync::mpsc::channel();+ let ui = ui.clone();+ let parent = parent.clone();+ std::thread::Builder::new()+ .name("file-dialog".into())+ .spawn(move || {+ // The app gone meanwhile has no use for the answer.+ let _ = tx.send(show_dialog(dialog, &request, &parent));+ ui.request_repaint();+ })+ .ok()?;+ Some(rx)+}++/// The paths a dialog shown as a sheet picks, once it closes.+#[cfg(target_os = "macos")]+type SheetAnswer = std::pin::Pin<Box<dyn std::future::Future<Output = Vec<String>> + Send>>;++/// macOS: show the dialog for `request` as a sheet on `parent`'s window, answering on the receiver+/// (#867). Shown in line, the panel ran AppKit's modal event loop inside winit's event handler: an+/// event winit had held back meanwhile (one came as a resize of the panel ended) then re-entered+/// the handler, and winit's panic there, inside an AppKit callback, aborted the app. The sheet+/// returns at once and the window keeps running; a thread of its own waits for the answer.+#[cfg(target_os = "macos")]+fn start_pick(request: PickRequest, parent: &Parent, ui: &egui::Context) -> Option<std::sync::mpsc::Receiver<Vec<String>>> {+ use winit::raw_window_handle::HasWindowHandle as _;+ // rfd runs the panel modally after all unless it has the running app's window to hold the+ // sheet (and from another thread it can't reach the window): no dialog then (`pick_now`).+ let mtm = objc2::MainThreadMarker::new();+ let running = mtm.is_some_and(|mtm| objc2_app_kit::NSApplication::sharedApplication(mtm).isRunning());+ let Some(window) = parent.as_ref().filter(|w| running && w.window_handle().is_ok()) else {+ log::error!("no window to show the file dialog on (main thread: {}, running: {running})", mtm.is_some());+ return None;+ };+ // The thread first, so the answer of a sheet once shown always has somewhere to go.+ let (sheet_tx, sheet_rx) = std::sync::mpsc::channel::<SheetAnswer>();+ let (tx, rx) = std::sync::mpsc::channel();+ let ui = ui.clone();+ std::thread::Builder::new()+ .name("file-dialog".into())+ .spawn(move || {+ if let Ok(answer) = sheet_rx.recv() {+ // The app gone meanwhile has no use for the answer.+ let _ = tx.send(pollster::block_on(answer));+ ui.request_repaint();+ }+ })+ .ok()?;+ make_folder(&request);+ // The panel is built and the sheet is begun below, on the main thread (as it must).+ let dialog = dialog_for(rfd::AsyncFileDialog::new().parent(window), &request);+ let path = |f: &rfd::FileHandle| f.path().to_string_lossy().to_string();+ let answer: SheetAnswer = match request {+ PickRequest::Open(_) => {+ let picked = dialog.pick_file();+ Box::pin(async move { picked.await.iter().map(path).collect() })+ }+ PickRequest::OpenMany => {+ let picked = dialog.pick_files();+ Box::pin(async move { picked.await.unwrap_or_default().iter().map(path).collect() })+ }+ // A save panel with two or more named file types is built by `mac_save_format`, which sets+ // up its Format menu before the sheet begins (#866); rfd shows the others.+ PickRequest::Save(pick) => match mac_save_format::begin(window, &pick) {+ // The dialog thread blocks here until the sheet answers.+ Some(picked) => Box::pin(async move { picked.recv().unwrap_or_default() }),+ None => {+ // Nothing is added to the sheet once rfd has begun it: an accessory view set then+ // made recent macOS versions dismiss the sheet at once (#1800).+ let picked = dialog.save_file();+ Box::pin(async move { picked.await.iter().map(path).collect() })+ }+ },+ PickRequest::Folder => {+ let picked = dialog.pick_folder();+ Box::pin(async move { picked.await.iter().map(path).collect() })+ }+ };+ // The thread can't be gone: it waits for this. If it were, its receiver answers as cancelled.+ let _ = sheet_tx.send(answer);+ Some(rx)+}++/// The host's services; `ui` is woken when a file dialog answers.+pub(crate) fn services(parent: Parent, ui: egui::Context) -> Services {+ use winit::raw_window_handle::{HasWindowHandle as _, RawWindowHandle};+ let wayland = parent.as_ref().and_then(|w| w.window_handle().ok()).is_some_and(|h| matches!(h.as_raw(), RawWindowHandle::Wayland(_)));+ // A window on X11 (XWayland included) reads a tablet pen's pressure itself (#764).+ #[cfg(target_os = "linux")]+ let x11 = parent+ .as_ref()+ .and_then(|w| w.window_handle().ok())+ .is_some_and(|h| matches!(h.as_raw(), RawWindowHandle::Xlib(_) | RawWindowHandle::Xcb(_)));+ let (p1, p2, p3, p4, p5) = (parent.clone(), parent.clone(), parent.clone(), parent.clone(), parent);+ #[cfg(target_os = "macos")]+ let sampled_ui = ui.clone();+ Services {+ pick_open: Some(Box::new(move |pick: &FilePick| pick_now(PickRequest::Open(pick.clone()), &p1).into_iter().next())),+ pick_open_multi: Some(Box::new(move || pick_now(PickRequest::OpenMany, &p2))),+ pick_save: Some(Box::new(move |pick: &FilePick| pick_now(PickRequest::Save(pick.clone()), &p3).into_iter().next())),+ // Linux shows dialogs on a thread of their own (#592), macOS as sheets (#867); Windows+ // dialogs run the window's events while they are open.+ start_pick: cfg!(unix).then(|| Box::new(move |request: PickRequest| start_pick(request, &p5, &ui)) as vectorcraft_ui_egui::picks::StartPick),+ dialogs_are_sheets: cfg!(target_os = "macos"),+ wayland,+ no_cursor_theme: wayland && cursor_theme::theme_missing(),+ #[cfg(target_os = "linux")]+ stylus: if x11 { tablet::start() } else { None },+ // macOS reads it from AppKit's events (#852).+ #[cfg(target_os = "macos")]+ stylus: mac_tablet::start(),+ // Windows reads it from the pen's pointer messages (`windows_stylus`).+ #[cfg(all(windows, not(target_vendor = "win7")))]+ stylus: Some(windows_stylus::start()),+ read: Some(Box::new(|p: &str| std::fs::read(p).map_err(|e| e.to_string()))),+ write: Some(Box::new(write_file)),+ exists: Some(Box::new(|p: &str| std::path::Path::new(p).exists())),+ // Background Save and Export write from a worker thread.+ write_shared: Some(std::sync::Arc::new(write_file)),+ // Native saves stream into the file as they are encoded.+ stream_shared: Some(std::sync::Arc::new(|p: &str, fill: &mut dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>| {+ fileio::write_file_with(p, fill).map_err(|e| e.to_string())+ })),+ // Every format Copy offers and Paste reads (menu-bar Paste never sees egui's Paste event).+ system_clipboard: Some(clipboard::system_clipboard()),+ // Linux checks whether Paste has something to take on a background thread: an X11 clipboard+ // owner that never answers holds a read for up to 4 s. Windows only asks which formats the+ // clipboard holds and macOS asks the pasteboard server, so they check in line.+ clipboard_probe: cfg!(target_os = "linux").then(|| Box::new(clipboard::system_clipboard) as ClipboardProbeFactory),+ // Help → Discord / website / GitHub, the Discord button, About and Home links.+ open_url: Some(Box::new(|url: &str| {+ let _ = webbrowser::open(url);+ })),+ reveal: Some(Box::new(reveal)),+ // Links panel: Edit Original; Package: Show Package. Relink to Folder and Package pick folders.+ open_file: Some(Box::new(open_file)),+ pick_folder: Some(Box::new(move || pick_now(PickRequest::Folder, &p4).into_iter().next())),+ // Sample Color from Screen: the system's color sampler.+ #[cfg(target_os = "macos")]+ screen_color: Some(mac_screen_color::sampler(sampled_ui)),+ // File → Print: the system's printers and print queue.+ print: Some(Box::new(printing::SystemPrint)),+ ..Default::default()+ }+}++/// Windows passes `path` to Explorer inside quotes it adds itself, so a path holding a quote (which+/// no Windows file name has) is refused rather than split into other arguments.+fn explorer_safe(path: &str) -> Result<(), String> {+ if cfg!(windows) && path.contains('"') { Err(format!("can't open {path}: the path contains a quotation mark")) } else { Ok(()) }+}++/// Edit Original, Show Package: open `path` (a file or a folder) in the system's default app for it.+fn open_file(path: &str) -> Result<(), String> {+ explorer_safe(path)?;+ #[cfg(windows)]+ let mut c = {+ use std::os::windows::process::CommandExt as _;+ let mut c = std::process::Command::new("explorer");+ c.raw_arg(format!("\"{}\"", path.replace('/', "\\")));+ c+ };+ #[cfg(target_os = "macos")]+ let mut c = std::process::Command::new("open");+ #[cfg(not(any(target_os = "macos", windows)))]+ let mut c = std::process::Command::new("xdg-open");+ #[cfg(not(windows))]+ c.arg(path);+ c.spawn().map(|_| ()).map_err(|e| format!("can't open {path}: {e}"))+}diff --git a/apps/vectorcraft/src/main.rs b/apps/vectorcraft/src/main.rsindex 76b18e515..2cdf80b42 100644--- a/apps/vectorcraft/src/main.rs+++ b/apps/vectorcraft/src/main.rs@@ -65,6 +65,31 @@ use vectorcraft_ui_egui::graphics::GraphicsLoss;use vectorcraft_ui_egui::picks::PickRequest;use vectorcraft_ui_egui::{ClipboardProbeFactory, FilePick, Services, VectorcraftApp};+mod app;+mod host_services;+mod prefs;+mod titlebar;++#[cfg(all(test, feature = "wgpu"))]+use app::bring_window_forward;+use app::native_input_hook;+use app::open_files;+use host_services::services;+#[cfg(all(test, feature = "wgpu"))]+use prefs::{KEEP_UI_PREFS, decode_saved_prefs, keep_prefs_copy, prefs_bytes};+use prefs::{load_prefs, log_dir, prefs_enabled, prefs_path, read_prefs};+#[cfg(all(test, feature = "wgpu", any(target_os = "macos", target_os = "windows")))]+use titlebar::CUSTOM_TITLEBAR;+#[cfg(feature = "wgpu")]+use titlebar::adapter_summary;+#[cfg(all(test, feature = "wgpu"))]+use titlebar::custom_titlebar_from;+#[cfg(all(test, feature = "wgpu"))]+use titlebar::opted_into_system_title_bar;+#[cfg(windows)]+use titlebar::set_taskbar_icon;+use titlebar::{custom_titlebar, native_options};+struct App {app: VectorcraftApp,/// Reported by wgpu when the window's graphics device is lost (a driver reset).@@ -83,718 +108,6 @@ struct App {maximize_tries: u8,}-/// The parts of [`App::raw_input_hook`] that every window needs, for the OS windows of floating-/// panels: a click or Escape that closes the macOS menu bar's open menu, and the pen barrel-/// button's secondary click on Windows. The control channel's input and the native menu's keys-/// go to the main window only.-#[cfg(target_os = "macos")]-fn native_input_hook(app: &VectorcraftApp) -> Option<vectorcraft_ui_egui::NativeInputHook> {- app.services.native_menu.is_some().then(|| std::sync::Arc::new(mac_menu::raw_input_hook) as vectorcraft_ui_egui::NativeInputHook)-}-#[cfg(all(windows, not(target_vendor = "win7")))]-fn native_input_hook(_: &VectorcraftApp) -> Option<vectorcraft_ui_egui::NativeInputHook> {- Some(std::sync::Arc::new(windows_stylus::raw_input_hook))-}-#[cfg(not(any(target_os = "macos", all(windows, not(target_vendor = "win7")))))]-fn native_input_hook(_: &VectorcraftApp) -> Option<vectorcraft_ui_egui::NativeInputHook> {- None-}--impl eframe::App for App {- // Each frame runs unconfined: it is the person at the keyboard's. The app confines what the- // control channel asks for, and the frames carrying input it injected, to the automation roots- // (`VectorcraftApp::with_automation_roots`), which are in force elsewhere in the process.- fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {- file_access::unconfined(|| self.logic_frame(ctx, frame));- self.app.finish_ime_logic(ctx);- }- /// Restore the borderless caption, apply platform menu and pen input, and hand the frame to the- /// app's raw-input hook while the keyboard user is unconfined.- fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {- // winit gives the window its caption back when it changes the window's flags (maximize,- // restore, …): take it off again before the frame is laid out (#1758).- if let Some(window_frame) = self.window_frame.as_mut() {- window_frame();- }- #[cfg(target_os = "macos")]- if self.app.services.native_menu.is_some() {- mac_menu::raw_input_hook(raw);- }- // A pen contact with the barrel button held presses the secondary button (Windows Ink).- #[cfg(all(windows, not(target_vendor = "win7")))]- windows_stylus::raw_input_hook(raw);- file_access::unconfined(|| self.app.raw_input_hook(ctx, raw));- }- #[cfg_attr(not(target_os = "macos"), allow(unused_variables))]- fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {- #[cfg(target_os = "macos")]- {- let bar = vectorcraft_ui_egui::chrome::APP_BAR_HEIGHT;- let inset = mac_window::center_buttons(frame, ui.ctx().zoom_factor(), bar);- self.app.titlebar_inset = inset.unwrap_or(mac_window::DEFAULT_INSET);- }- file_access::unconfined(|| self.app.ui(ui));- // Preferences are written when confirmed, not only at exit: a session ended any other way- // (the system shutting down, the process ended or crashing) used to lose them (#1747).- if self.app.take_prefs_changed() {- file_access::unconfined(|| save_prefs(&self.app));- }- // Not while a file dialog's sheet has the keyboard: its name field's composition would go.- #[cfg(target_os = "macos")]- if !self.app.file_dialog_open() && self.app.take_ime_discard() {- discard_marked_text();- }- }- #[cfg(not(feature = "windows7"))]- fn on_exit(&mut self) {- file_access::unconfined(|| save_prefs(&self.app));- end_before_teardown(self.frames);- }- #[cfg(feature = "windows7")]- fn on_exit(&mut self, _gl: Option<&eframe::glow::Context>) {- file_access::unconfined(|| save_prefs(&self.app));- }-}--impl App {- fn logic_frame(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {- self.frames = ctx.cumulative_frame_nr();- if let Some(why) = self.graphics_loss.take() {- // eframe can't give a window a new device: the user saves and starts again.- self.graphics_lost = self.app.graphics_lost(&why);- self.app.status(if self.graphics_lost {- "The graphics device was lost: unsaved changes are kept for Data Recovery. Save your documents and restart VectorCraft"- } else {- "The graphics device was lost: save your documents and restart VectorCraft"- });- }- if self.graphics_lost && ctx.input(|i| i.viewport().close_requested()) {- // The window can't show the Save Changes question: it closes, and the next launch- // offers the changes back.- vectorcraft_ui_egui::background::wait_all(&mut self.app);- return;- }- // Files from the Finder and the Dock wait while a file dialog is open: what asked for it runs- // again on its document when it answers.- #[cfg(target_os = "macos")]- if !self.app.file_dialog_open() {- let files = open_documents::take();- if !files.is_empty() {- bring_window_forward(ctx);- }- open_files(&mut self.app, files);- }- self.app.tick(ctx);- if self.pending_maximize {- if let Some(w) = &self.winit_window {- self.pending_maximize = window::apply_pending_maximize(w, true, &mut self.maximize_tries);- } else {- self.pending_maximize = false;- }- }- let host_maximized = self.winit_window.as_ref().map(|w| w.is_maximized());- window::track(ctx, &mut self.app.ui.window, host_maximized);- if self.app.ui.status == "quit" {- ctx.send_viewport_cmd(egui::ViewportCommand::Close);- }- }-}--/// On macOS with accessibility, end the process once the app has saved what it keeps on quitting,-/// before eframe tears the window down (#661). AccessKit then gives the window's content view back-/// its own class, which AppKit's Touch Bar support was observing it under, and AppKit aborts the-/// app as it quits on Macs with a Touch Bar. Nothing after the window is needed on a normal quit.-/// Not while the window is still starting up (`frames` below [`gpu::STARTUP_FRAMES`]): a graphics-/// failure then starts the app again on another adapter (#651).-#[allow(unused_variables)]-fn end_before_teardown(frames: u64) {- #[cfg(all(target_os = "macos", feature = "accessibility", feature = "wgpu"))]- if frames >= gpu::STARTUP_FRAMES {- log::info!("quitting");- log::logger().flush();- std::process::exit(0);- }-}--/// Show the window when files are opened from the Finder or the Dock: a minimized window comes back-/// out of the Dock and the app takes focus, as a document-based Mac app does (#3769).-#[cfg_attr(not(target_os = "macos"), allow(dead_code))]-fn bring_window_forward(ctx: &egui::Context) {- ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(false));- ctx.send_viewport_cmd(egui::ViewportCommand::Focus);-}--/// Open files handed to the app (command line, macOS Finder and Dock) as documents. A file that-/// can't be opened is reported to the user and on stderr; the others still open.-fn open_files(app: &mut VectorcraftApp, files: Vec<String>) {- for f in files {- if let Err(e) = vectorcraft_ui_egui::io::open_reporting(app, &f) {- eprintln!("vectorcraft: {f}: {e}");- }- }-}--/// Tell the macOS input method to drop its composition (the Type tool kept the marked text as-/// typed). winit's IME toggle only clears its own copy, so the IME would type it again.-#[cfg(target_os = "macos")]-fn discard_marked_text() {- if let Some(mtm) = objc2::MainThreadMarker::new()- && let Some(ic) = objc2_app_kit::NSTextInputContext::currentInputContext(mtm)- {- ic.discardMarkedText();- }-}--/// Where UI preferences live: ~/Library/Application Support/VectorCraft (macOS),-/// %APPDATA%\VectorCraft (Windows), $XDG_CONFIG_HOME or ~/.config/vectorcraft (Linux).-fn prefs_path() -> Option<std::path::PathBuf> {- prefs_dir::prefs_path_for("VectorCraft", "vectorcraft")-}--/// The same place under the project's former name (DrawCraft): read once if there are no-/// VectorCraft preferences yet, so settings survive the rename.-fn legacy_prefs_path() -> Option<std::path::PathBuf> {- prefs_dir::prefs_path_for("DrawCraft", "drawcraft")-}--/// Where the log files live: `logs` in the preferences folder (see `logging`).-fn log_dir() -> Option<std::path::PathBuf> {- Some(prefs_path()?.parent()?.join("logs"))-}--/// Runs without preferences (`VECTORCRAFT_NO_PREFS`, agents' test runs) neither read nor write them.-fn prefs_enabled() -> bool {- std::env::var_os("VECTORCRAFT_NO_PREFS").is_none()-}--/// The saved UI preferences, read before the window opens (they hold its size and position).-/// A file read only in part, or with layouts converted from an older version, is copied beside-/// itself before anything saves over it.-fn read_prefs() -> Option<vectorcraft_ui_egui::UiState> {- if !prefs_enabled() {- return None;- }- if let Some(p) = prefs_path()- && let Ok(bytes) = std::fs::read(&p)- {- let read = vectorcraft_ui_egui::UiState::read_preferences(&bytes);- if read.as_ref().is_none_or(|read| !read.intact) {- keep_prefs_copy(&p, &bytes, "ui.unreadable");- }- if read.as_ref().is_some_and(|read| read.converted) {- keep_prefs_copy(&p, &bytes, "ui.before-layout-migration");- }- return read.map(|read| read.ui);- }- let bytes = legacy_prefs_path().and_then(|p| std::fs::read(p).ok())?;- decode_saved_prefs(&bytes)-}--/// Saved preferences, with what this version cannot read of their docking data dropped and-/// older layouts converted (`vectorcraft_ui_egui::layout_migration`).-fn decode_saved_prefs(bytes: &[u8]) -> Option<vectorcraft_ui_egui::UiState> {- vectorcraft_ui_egui::UiState::read_preferences(bytes).map(|read| read.ui)-}--/// Set when `ui.json` needed a copy kept ([`keep_prefs_copy`]) and none could be: the file is-/// then left as it is rather than overwritten.-static KEEP_UI_PREFS: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);--/// Copy `ui.json` beside it as `<stem>.json` or the first free `<stem>-N.json`, before the next-/// save replaces it: `ui.unreadable` when it could not be read in full (a newer VectorCraft may-/// have written it), `ui.before-layout-migration` when its layouts were converted.-fn keep_prefs_copy(path: &std::path::Path, bytes: &[u8], stem: &str) {- use std::io::Write as _;- for n in 1..100u32 {- let name = if n == 1 { format!("{stem}.json") } else { format!("{stem}-{n}.json") };- match std::fs::OpenOptions::new().write(true).create_new(true).open(path.with_file_name(name)) {- Ok(mut file) => {- if file.write_all(bytes).is_ok() {- return;- }- break;- }- Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}- Err(_) => break,- }- }- KEEP_UI_PREFS.store(true, std::sync::atomic::Ordering::Relaxed);-}--fn load_prefs(app: &mut VectorcraftApp, saved: Option<vectorcraft_ui_egui::UiState>) {- if !prefs_enabled() {- return;- }- if let Some(ui) = saved {- app.ui = ui.sanitized();- }- vectorcraft_ui_egui::prefs_dialog::restore(app);-}--fn save_prefs(app: &VectorcraftApp) {- if !prefs_enabled() || KEEP_UI_PREFS.load(std::sync::atomic::Ordering::Relaxed) {- return;- }- if let Some(p) = prefs_path() {- let _ = std::fs::create_dir_all(p.parent().unwrap_or(std::path::Path::new(".")));- if let Ok(bytes) = prefs_bytes(app) {- // Preferences are best effort: a failed write keeps the previous file.- let _ = fileio::write_atomic(&p, &bytes);- }- }-}--/// The preferences file's contents: the UI state with the engine preferences.-fn prefs_bytes(app: &VectorcraftApp) -> serde_json::Result<Vec<u8>> {- let mut ui = app.ui.clone();- ui.engine_prefs = app.session.prefs.to_json();- serde_json::to_vec_pretty(&ui)-}--/// The window file dialogs belong to.-type Parent = Option<std::sync::Arc<winit::window::Window>>;--/// What rfd's blocking and asynchronous file dialogs are both set up with.-trait DialogSettings: Sized {- fn parent(self, window: &winit::window::Window) -> Self;- fn title(self, title: &str) -> Self;- fn filter(self, name: &str, exts: &[impl ToString]) -> Self;- fn folder(self, folder: &str) -> Self;- fn file_name(self, name: &str) -> Self;-}--macro_rules! dialog_settings {- ($($dialog:ty),*) => {$(- impl DialogSettings for $dialog {- fn parent(self, window: &winit::window::Window) -> Self {- self.set_parent(window)- }- fn title(self, title: &str) -> Self {- self.set_title(title)- }- fn filter(self, name: &str, exts: &[impl ToString]) -> Self {- self.add_filter(name, exts)- }- fn folder(self, folder: &str) -> Self {- self.set_directory(folder)- }- fn file_name(self, name: &str) -> Self {- self.set_file_name(name)- }- }- )*};-}--dialog_settings!(rfd::FileDialog, rfd::AsyncFileDialog);--/// `d` set up for `request`: its title, file types, folder and suggested name.-fn dialog_for<D: DialogSettings>(d: D, request: &PickRequest) -> D {- let pick = match request {- PickRequest::Open(pick) | PickRequest::Save(pick) => pick,- PickRequest::OpenMany => {- return fileio::place_filters().fold(d.title(vectorcraft_ui_egui::i18n::t("Place")), |d, (name, exts)| {- d.filter(vectorcraft_ui_egui::i18n::tr_ctx(vectorcraft_ui_egui::i18n::current(), "file-filter", name), exts)- });- }- PickRequest::Folder => return d,- };- let d = pick.filters.iter().fold(d, |d, (name, exts)| {- d.filter(vectorcraft_ui_egui::i18n::tr_ctx(vectorcraft_ui_egui::i18n::current(), "file-filter", name.as_str()), exts)- });- let d = match &pick.folder {- Some(folder) => d.folder(folder),- None => d,- };- if pick.name.is_empty() { d } else { d.file_name(&pick.name) }-}--/// A native file dialog for `request` over `parent` (on Linux the portal then shows it over the-/// window and keeps it in front).-#[cfg(not(target_os = "macos"))]-fn file_dialog(request: &PickRequest, parent: &Parent) -> rfd::FileDialog {- match parent {- Some(w) => dialog_for(rfd::FileDialog::new().parent(w), request),- None => dialog_for(rfd::FileDialog::new(), request),- }-}--/// Before `request`'s dialog shows: a save dialog's folder (the Templates folder) may not exist yet.-fn make_folder(request: &PickRequest) {- if let PickRequest::Save(FilePick { folder: Some(folder), .. }) = request {- let _ = std::fs::create_dir_all(folder);- }-}--/// Show `dialog` for `request` (on the calling thread, until it closes) → the paths picked. On-/// Linux and the BSDs a save dialog with two or more file types is the desktop portal's, over-/// `parent`, and its answer also names the file type picked ([`portal_save`]); `dialog` shows when-/// the portal can't.-#[cfg(not(target_os = "macos"))]-#[cfg_attr(windows, allow(unused_variables))]-fn show_dialog(dialog: rfd::FileDialog, request: &PickRequest, parent: &Parent) -> Vec<String> {- make_folder(request);- #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd"))]- if let PickRequest::Save(pick) = request- && let Some(answer) = portal_save::pick(pick, parent.as_deref())- {- return answer;- }- let paths = match request {- PickRequest::Open(_) => dialog.pick_file().into_iter().collect(),- PickRequest::OpenMany => dialog.pick_files().unwrap_or_default(),- PickRequest::Save(_) => dialog.save_file().into_iter().collect(),- PickRequest::Folder => dialog.pick_folder().into_iter().collect(),- };- paths.into_iter().map(|p| p.to_string_lossy().to_string()).collect()-}--/// Show the dialog for `request` over `parent` now → the paths picked.-#[cfg(not(target_os = "macos"))]-fn pick_now(request: PickRequest, parent: &Parent) -> Vec<String> {- show_dialog(file_dialog(&request, parent), &request, parent)-}--/// macOS shows no dialog in line: its modal loop would run inside winit's event handler, and an-/// event winit held back meanwhile aborts the app (#867). Dialogs are sheets there ([`start_pick`]);-/// one asked for any other way (a bug: outside a command, a dialog's OK or a button) picks nothing.-#[cfg(target_os = "macos")]-fn pick_now(request: PickRequest, _parent: &Parent) -> Vec<String> {- log::error!("no file dialog shown for {request:?}: macOS shows them as sheets, from commands, dialogs' OK and buttons only");- Vec::new()-}--/// File → Show in Folder: select `path` in Finder / Explorer, or open its folder elsewhere.-fn reveal(path: &str) -> Result<(), String> {- explorer_safe(path)?;- reveal_command(path).spawn().map(|_| ()).map_err(|e| format!("can't show {path}: {e}"))-}--#[cfg(target_os = "macos")]-fn reveal_command(path: &str) -> std::process::Command {- let mut c = std::process::Command::new("open");- c.args(["-R", path]);- c-}--#[cfg(windows)]-fn reveal_command(path: &str) -> std::process::Command {- use std::os::windows::process::CommandExt as _;- // Explorer reads `/select,"path"` itself (the usual argument quoting breaks paths with spaces)- // and needs backslashes.- let mut c = std::process::Command::new("explorer");- c.raw_arg(format!("/select,\"{}\"", path.replace('/', "\\")));- c-}--#[cfg(not(any(target_os = "macos", windows)))]-fn reveal_command(path: &str) -> std::process::Command {- let folder = std::path::Path::new(path).parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(std::path::Path::new("."));- let mut c = std::process::Command::new("xdg-open");- c.arg(folder);- c-}--/// Write a file the safe way: a failed write keeps the old file ([`fileio::write_atomic`]).-fn write_file(path: &str, bytes: &[u8]) -> Result<(), String> {- fileio::write_atomic(std::path::Path::new(path), bytes).map_err(|e| e.to_string())-}--/// Linux: show the dialog for `request` over `parent` on a thread of its own, answering on the-/// receiver. Shown on the UI thread, nothing would answer the compositor meanwhile, which then-/// offers to kill the window as not responding (#592).-#[cfg(not(target_os = "macos"))]-fn start_pick(request: PickRequest, parent: &Parent, ui: &egui::Context) -> Option<std::sync::mpsc::Receiver<Vec<String>>> {- let dialog = file_dialog(&request, parent);- let (tx, rx) = std::sync::mpsc::channel();- let ui = ui.clone();- let parent = parent.clone();- std::thread::Builder::new()- .name("file-dialog".into())- .spawn(move || {- // The app gone meanwhile has no use for the answer.- let _ = tx.send(show_dialog(dialog, &request, &parent));- ui.request_repaint();- })- .ok()?;- Some(rx)-}--/// The paths a dialog shown as a sheet picks, once it closes.-#[cfg(target_os = "macos")]-type SheetAnswer = std::pin::Pin<Box<dyn std::future::Future<Output = Vec<String>> + Send>>;--/// macOS: show the dialog for `request` as a sheet on `parent`'s window, answering on the receiver-/// (#867). Shown in line, the panel ran AppKit's modal event loop inside winit's event handler: an-/// event winit had held back meanwhile (one came as a resize of the panel ended) then re-entered-/// the handler, and winit's panic there, inside an AppKit callback, aborted the app. The sheet-/// returns at once and the window keeps running; a thread of its own waits for the answer.-#[cfg(target_os = "macos")]-fn start_pick(request: PickRequest, parent: &Parent, ui: &egui::Context) -> Option<std::sync::mpsc::Receiver<Vec<String>>> {- use winit::raw_window_handle::HasWindowHandle as _;- // rfd runs the panel modally after all unless it has the running app's window to hold the- // sheet (and from another thread it can't reach the window): no dialog then (`pick_now`).- let mtm = objc2::MainThreadMarker::new();- let running = mtm.is_some_and(|mtm| objc2_app_kit::NSApplication::sharedApplication(mtm).isRunning());- let Some(window) = parent.as_ref().filter(|w| running && w.window_handle().is_ok()) else {- log::error!("no window to show the file dialog on (main thread: {}, running: {running})", mtm.is_some());- return None;- };- // The thread first, so the answer of a sheet once shown always has somewhere to go.- let (sheet_tx, sheet_rx) = std::sync::mpsc::channel::<SheetAnswer>();- let (tx, rx) = std::sync::mpsc::channel();- let ui = ui.clone();- std::thread::Builder::new()- .name("file-dialog".into())- .spawn(move || {- if let Ok(answer) = sheet_rx.recv() {- // The app gone meanwhile has no use for the answer.- let _ = tx.send(pollster::block_on(answer));- ui.request_repaint();- }- })- .ok()?;- make_folder(&request);- // The panel is built and the sheet is begun below, on the main thread (as it must).- let dialog = dialog_for(rfd::AsyncFileDialog::new().parent(window), &request);- let path = |f: &rfd::FileHandle| f.path().to_string_lossy().to_string();- let answer: SheetAnswer = match request {- PickRequest::Open(_) => {- let picked = dialog.pick_file();- Box::pin(async move { picked.await.iter().map(path).collect() })- }- PickRequest::OpenMany => {- let picked = dialog.pick_files();- Box::pin(async move { picked.await.unwrap_or_default().iter().map(path).collect() })- }- // A save panel with two or more named file types is built by `mac_save_format`, which sets- // up its Format menu before the sheet begins (#866); rfd shows the others.- PickRequest::Save(pick) => match mac_save_format::begin(window, &pick) {- // The dialog thread blocks here until the sheet answers.- Some(picked) => Box::pin(async move { picked.recv().unwrap_or_default() }),- None => {- // Nothing is added to the sheet once rfd has begun it: an accessory view set then- // made recent macOS versions dismiss the sheet at once (#1800).- let picked = dialog.save_file();- Box::pin(async move { picked.await.iter().map(path).collect() })- }- },- PickRequest::Folder => {- let picked = dialog.pick_folder();- Box::pin(async move { picked.await.iter().map(path).collect() })- }- };- // The thread can't be gone: it waits for this. If it were, its receiver answers as cancelled.- let _ = sheet_tx.send(answer);- Some(rx)-}--/// The host's services; `ui` is woken when a file dialog answers.-fn services(parent: Parent, ui: egui::Context) -> Services {- use winit::raw_window_handle::{HasWindowHandle as _, RawWindowHandle};- let wayland = parent.as_ref().and_then(|w| w.window_handle().ok()).is_some_and(|h| matches!(h.as_raw(), RawWindowHandle::Wayland(_)));- // A window on X11 (XWayland included) reads a tablet pen's pressure itself (#764).- #[cfg(target_os = "linux")]- let x11 = parent- .as_ref()- .and_then(|w| w.window_handle().ok())- .is_some_and(|h| matches!(h.as_raw(), RawWindowHandle::Xlib(_) | RawWindowHandle::Xcb(_)));- let (p1, p2, p3, p4, p5) = (parent.clone(), parent.clone(), parent.clone(), parent.clone(), parent);- #[cfg(target_os = "macos")]- let sampled_ui = ui.clone();- Services {- pick_open: Some(Box::new(move |pick: &FilePick| pick_now(PickRequest::Open(pick.clone()), &p1).into_iter().next())),- pick_open_multi: Some(Box::new(move || pick_now(PickRequest::OpenMany, &p2))),- pick_save: Some(Box::new(move |pick: &FilePick| pick_now(PickRequest::Save(pick.clone()), &p3).into_iter().next())),- // Linux shows dialogs on a thread of their own (#592), macOS as sheets (#867); Windows- // dialogs run the window's events while they are open.- start_pick: cfg!(unix).then(|| Box::new(move |request: PickRequest| start_pick(request, &p5, &ui)) as vectorcraft_ui_egui::picks::StartPick),- dialogs_are_sheets: cfg!(target_os = "macos"),- wayland,- no_cursor_theme: wayland && cursor_theme::theme_missing(),- #[cfg(target_os = "linux")]- stylus: if x11 { tablet::start() } else { None },- // macOS reads it from AppKit's events (#852).- #[cfg(target_os = "macos")]- stylus: mac_tablet::start(),- // Windows reads it from the pen's pointer messages (`windows_stylus`).- #[cfg(all(windows, not(target_vendor = "win7")))]- stylus: Some(windows_stylus::start()),- read: Some(Box::new(|p: &str| std::fs::read(p).map_err(|e| e.to_string()))),- write: Some(Box::new(write_file)),- exists: Some(Box::new(|p: &str| std::path::Path::new(p).exists())),- // Background Save and Export write from a worker thread.- write_shared: Some(std::sync::Arc::new(write_file)),- // Native saves stream into the file as they are encoded.- stream_shared: Some(std::sync::Arc::new(|p: &str, fill: &mut dyn FnMut(&mut dyn std::io::Write) -> std::io::Result<()>| {- fileio::write_file_with(p, fill).map_err(|e| e.to_string())- })),- // Every format Copy offers and Paste reads (menu-bar Paste never sees egui's Paste event).- system_clipboard: Some(clipboard::system_clipboard()),- // Linux checks whether Paste has something to take on a background thread: an X11 clipboard- // owner that never answers holds a read for up to 4 s. Windows only asks which formats the- // clipboard holds and macOS asks the pasteboard server, so they check in line.- clipboard_probe: cfg!(target_os = "linux").then(|| Box::new(clipboard::system_clipboard) as ClipboardProbeFactory),- // Help → Discord / website / GitHub, the Discord button, About and Home links.- open_url: Some(Box::new(|url: &str| {- let _ = webbrowser::open(url);- })),- reveal: Some(Box::new(reveal)),- // Links panel: Edit Original; Package: Show Package. Relink to Folder and Package pick folders.- open_file: Some(Box::new(open_file)),- pick_folder: Some(Box::new(move || pick_now(PickRequest::Folder, &p4).into_iter().next())),- // Sample Color from Screen: the system's color sampler.- #[cfg(target_os = "macos")]- screen_color: Some(mac_screen_color::sampler(sampled_ui)),- // File → Print: the system's printers and print queue.- print: Some(Box::new(printing::SystemPrint)),- ..Default::default()- }-}--/// Windows passes `path` to Explorer inside quotes it adds itself, so a path holding a quote (which-/// no Windows file name has) is refused rather than split into other arguments.-fn explorer_safe(path: &str) -> Result<(), String> {- if cfg!(windows) && path.contains('"') { Err(format!("can't open {path}: the path contains a quotation mark")) } else { Ok(()) }-}--/// Edit Original, Show Package: open `path` (a file or a folder) in the system's default app for it.-fn open_file(path: &str) -> Result<(), String> {- explorer_safe(path)?;- #[cfg(windows)]- let mut c = {- use std::os::windows::process::CommandExt as _;- let mut c = std::process::Command::new("explorer");- c.raw_arg(format!("\"{}\"", path.replace('/', "\\")));- c- };- #[cfg(target_os = "macos")]- let mut c = std::process::Command::new("open");- #[cfg(not(any(target_os = "macos", windows)))]- let mut c = std::process::Command::new("xdg-open");- #[cfg(not(windows))]- c.arg(path);- c.spawn().map(|_| ()).map_err(|e| format!("can't open {path}: {e}"))-}--/// The window, Dock, taskbar and app-switcher icon (`assets/app-icon/`, see its README). macOS gets-/// the version with Apple's transparent margin; elsewhere the full-bleed tile. The app ID matches-/// `packaging/linux/ai.storyteller.vectorcraft.desktop` so Wayland docks find the launcher icon.-fn app_icon() -> egui::IconData {- #[cfg(target_os = "macos")]- let png: &[u8] = include_bytes!("../../../assets/app-icon/vectorcraft-macos-512.png");- #[cfg(not(target_os = "macos"))]- let png: &[u8] = include_bytes!("../../../assets/app-icon/hicolor/256x256/apps/ai.storyteller.vectorcraft.png");- eframe::icon_data::from_png_bytes(png).unwrap_or_default()-}--/// Windows shows a window's big icon (`ICON_BIG`) in the taskbar and Alt+Tab; eframe sets only the-/// small one (the title bar's), so the taskbar showed a generic icon. Set the big one too.-#[cfg(windows)]-fn set_taskbar_icon(w: &winit::window::Window) {- use winit::platform::windows::WindowExtWindows as _;- let icon = app_icon();- // An icon that can't be made leaves the generic one: nothing else depends on it.- if let Ok(i) = winit::window::Icon::from_rgba(icon.rgba, icon.width, icon.height) {- w.set_taskbar_icon(Some(i));- }-}--/// "name (backend, kind)" of the adapter the window renders with, for Help › About and bug reports.-#[cfg(feature = "wgpu")]-fn adapter_summary(info: &eframe::wgpu::AdapterInfo) -> String {- format!("{} ({:?}, {:?})", info.name.trim(), info.backend, info.device_type)-}--/// Windows and Linux: no OS title bar; the app bar is the title bar (`vectorcraft_ui_egui::titlebar`).-/// macOS keeps its traffic lights over the integrated title strip.-///-/// Used on macOS and Windows (where VectorCraft keeps today's frame regardless of the-/// `craft-window` probe) and by the tests; Linux and the BSDs take the decision from the probe.-#[cfg_attr(not(any(target_os = "macos", target_os = "windows")), allow(dead_code))]-const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");--/// Whether the user asked for the system title bar in Preferences › User Interface › System Title-/// Bar. Read from the saved preferences before the window opens; a missing or unreadable value is-/// `false` (the default). This preference forces the desktop/native frame back on.-fn opted_into_system_title_bar(saved: Option<&vectorcraft_ui_egui::UiState>) -> bool {- saved.map(|ui| ui.engine_prefs.get("systemTitleBar").and_then(serde_json::Value::as_bool).unwrap_or(false)).unwrap_or(false)-}--/// Whether this start draws its own title bar, given the frame the shared `craft-window` crate-/// decided and the user's System Title Bar preference.-///-/// The suite-wide rule (`craft_window::Choice`) is: the desktop draws the frame-/// ([`craft_window::Frame::Desktop`]) on macOS, Windows, X11 and any Wayland compositor with-/// server-side decorations (KDE, Sway, Hyprland, COSMIC); the app draws it-/// ([`craft_window::Frame::App`]) only where the compositor leaves it to the app (GNOME's Mutter),-/// or when `VECTORCRAFT_TITLEBAR` overrides the probe. VectorCraft draws its own title bar exactly-/// when `craft-window` says the app owns the frame **and** the user has not opted into the system-/// title bar; the preference always forces the native frame back on.-///-/// macOS and Windows keep today's behavior and are decided by [`CUSTOM_TITLEBAR`] rather than the-/// probe: `craft-window` returns `Frame::Desktop` for both (the OS always draws a frame), but-/// VectorCraft insets its content under the macOS traffic lights and draws its own caption buttons-/// on Windows — an overdraw on an OS-decorated window that is VectorCraft's choice, not-/// `craft-window`'s. Only Linux and the BSDs take the decision from the probe.-#[cfg(not(any(target_os = "macos", target_os = "windows")))]-fn custom_titlebar_from(frame: &craft_window::Frame, opted_into_system: bool) -> bool {- matches!(frame, craft_window::Frame::App(_)) && !opted_into_system-}--/// macOS and Windows: today's behavior, independent of the `craft-window` probe (see-/// [`custom_titlebar_from`]). macOS never draws its own frame (`CUSTOM_TITLEBAR` is `false`);-/// Windows draws its own caption unless the user opted into the system title bar.-#[cfg(any(target_os = "macos", target_os = "windows"))]-fn custom_titlebar_from(_frame: &craft_window::Frame, opted_into_system: bool) -> bool {- CUSTOM_TITLEBAR && !opted_into_system-}--/// Whether this start draws its own title bar. Probes the shared `craft-window` crate once (its-/// override variable is `VECTORCRAFT_TITLEBAR`) and combines its decision with the saved System-/// Title Bar preference. Call once at startup, before [`native_options`].-///-/// On Linux, Preferences › Performance › Linux Display Server › X11 opens the window through-/// XWayland (below). A GNOME/Wayland probe would say `Frame::App` there, but the window really runs-/// on X11, whose window manager draws the frame — so when XWayland is being forced, keep the native-/// frame, the same as a real X11 session. An explicit `VECTORCRAFT_TITLEBAR` override still wins.-fn custom_titlebar(saved: Option<&vectorcraft_ui_egui::UiState>) -> bool {- let choice = craft_window::Choice::probe(craft_window::Prefix::new("VECTORCRAFT"));- let opted_into_system = opted_into_system_title_bar(saved);- #[cfg(target_os = "linux")]- {- let pref = saved.and_then(|ui| ui.engine_prefs.get("linuxDisplayServer")).and_then(serde_json::Value::as_str);- // `overridden() == None` means the probe decided (no VECTORCRAFT_TITLEBAR). When the window- // will actually open on X11 (XWayland) — the user asked for it *and* the X11 libraries are- // present, the same two conditions the launch path checks below — that run is effectively- // X11, so keep the native frame. If the libraries are missing, startup stays on Wayland, so- // the probe's own decision (app-drawn on GNOME) must stand.- let forced_to_x11 = xwayland::wanted(pref, |name| std::env::var_os(name), xwayland::pen_attached) && xwayland::x11_libraries_found();- if choice.overridden().is_none() && forced_to_x11 {- return custom_titlebar_from(&craft_window::Frame::Desktop, opted_into_system);- }- }- custom_titlebar_from(choice.frame(), opted_into_system)-}--fn native_options(custom_titlebar: bool) -> eframe::NativeOptions {- eframe::NativeOptions {- viewport: egui::ViewportBuilder::default()- .with_title("VectorCraft")- .with_inner_size(window::DEFAULT_SIZE)- .with_min_inner_size(window::MIN_SIZE)- .with_drag_and_drop(true)- .with_decorations(!custom_titlebar)- .with_fullsize_content_view(true)- .with_titlebar_shown(false)- .with_title_shown(false)- .with_icon(app_icon())- .with_app_id("ai.storyteller.vectorcraft"),- #[cfg(feature = "windows7")]- renderer: eframe::Renderer::Glow,- ..Default::default()- }-}-/// `vectorcraft --help`. Headless work (convert, run, MCP) is `vectorcraft-cli`'s.const USAGE: &str = "\Usage: vectorcraft [options] [files…]diff --git a/apps/vectorcraft/src/prefs.rs b/apps/vectorcraft/src/prefs.rsnew file mode 100644index 000000000..67a5a4a08--- /dev/null+++ b/apps/vectorcraft/src/prefs.rs@@ -0,0 +1,107 @@+use super::*;++/// Where UI preferences live: ~/Library/Application Support/VectorCraft (macOS),+/// %APPDATA%\VectorCraft (Windows), $XDG_CONFIG_HOME or ~/.config/vectorcraft (Linux).+pub(crate) fn prefs_path() -> Option<std::path::PathBuf> {+ prefs_dir::prefs_path_for("VectorCraft", "vectorcraft")+}++/// The same place under the project's former name (DrawCraft): read once if there are no+/// VectorCraft preferences yet, so settings survive the rename.+fn legacy_prefs_path() -> Option<std::path::PathBuf> {+ prefs_dir::prefs_path_for("DrawCraft", "drawcraft")+}++/// Where the log files live: `logs` in the preferences folder (see `logging`).+pub(crate) fn log_dir() -> Option<std::path::PathBuf> {+ Some(prefs_path()?.parent()?.join("logs"))+}++/// Runs without preferences (`VECTORCRAFT_NO_PREFS`, agents' test runs) neither read nor write them.+pub(crate) fn prefs_enabled() -> bool {+ std::env::var_os("VECTORCRAFT_NO_PREFS").is_none()+}++/// The saved UI preferences, read before the window opens (they hold its size and position).+/// A file read only in part, or with layouts converted from an older version, is copied beside+/// itself before anything saves over it.+pub(crate) fn read_prefs() -> Option<vectorcraft_ui_egui::UiState> {+ if !prefs_enabled() {+ return None;+ }+ if let Some(p) = prefs_path()+ && let Ok(bytes) = std::fs::read(&p)+ {+ let read = vectorcraft_ui_egui::UiState::read_preferences(&bytes);+ if read.as_ref().is_none_or(|read| !read.intact) {+ keep_prefs_copy(&p, &bytes, "ui.unreadable");+ }+ if read.as_ref().is_some_and(|read| read.converted) {+ keep_prefs_copy(&p, &bytes, "ui.before-layout-migration");+ }+ return read.map(|read| read.ui);+ }+ let bytes = legacy_prefs_path().and_then(|p| std::fs::read(p).ok())?;+ decode_saved_prefs(&bytes)+}++/// Saved preferences, with what this version cannot read of their docking data dropped and+/// older layouts converted (`vectorcraft_ui_egui::layout_migration`).+pub(crate) fn decode_saved_prefs(bytes: &[u8]) -> Option<vectorcraft_ui_egui::UiState> {+ vectorcraft_ui_egui::UiState::read_preferences(bytes).map(|read| read.ui)+}++/// Set when `ui.json` needed a copy kept ([`keep_prefs_copy`]) and none could be: the file is+/// then left as it is rather than overwritten.+pub(crate) static KEEP_UI_PREFS: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);++/// Copy `ui.json` beside it as `<stem>.json` or the first free `<stem>-N.json`, before the next+/// save replaces it: `ui.unreadable` when it could not be read in full (a newer VectorCraft may+/// have written it), `ui.before-layout-migration` when its layouts were converted.+pub(crate) fn keep_prefs_copy(path: &std::path::Path, bytes: &[u8], stem: &str) {+ use std::io::Write as _;+ for n in 1..100u32 {+ let name = if n == 1 { format!("{stem}.json") } else { format!("{stem}-{n}.json") };+ match std::fs::OpenOptions::new().write(true).create_new(true).open(path.with_file_name(name)) {+ Ok(mut file) => {+ if file.write_all(bytes).is_ok() {+ return;+ }+ break;+ }+ Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}+ Err(_) => break,+ }+ }+ KEEP_UI_PREFS.store(true, std::sync::atomic::Ordering::Relaxed);+}++pub(crate) fn load_prefs(app: &mut VectorcraftApp, saved: Option<vectorcraft_ui_egui::UiState>) {+ if !prefs_enabled() {+ return;+ }+ if let Some(ui) = saved {+ app.ui = ui.sanitized();+ }+ vectorcraft_ui_egui::prefs_dialog::restore(app);+}++pub(crate) fn save_prefs(app: &VectorcraftApp) {+ if !prefs_enabled() || KEEP_UI_PREFS.load(std::sync::atomic::Ordering::Relaxed) {+ return;+ }+ if let Some(p) = prefs_path() {+ let _ = std::fs::create_dir_all(p.parent().unwrap_or(std::path::Path::new(".")));+ if let Ok(bytes) = prefs_bytes(app) {+ // Preferences are best effort: a failed write keeps the previous file.+ let _ = fileio::write_atomic(&p, &bytes);+ }+ }+}++/// The preferences file's contents: the UI state with the engine preferences.+pub(crate) fn prefs_bytes(app: &VectorcraftApp) -> serde_json::Result<Vec<u8>> {+ let mut ui = app.ui.clone();+ ui.engine_prefs = app.session.prefs.to_json();+ serde_json::to_vec_pretty(&ui)+}diff --git a/apps/vectorcraft/src/titlebar.rs b/apps/vectorcraft/src/titlebar.rsnew file mode 100644index 000000000..3d538ec88--- /dev/null+++ b/apps/vectorcraft/src/titlebar.rs@@ -0,0 +1,120 @@+use super::*;++/// The window, Dock, taskbar and app-switcher icon (`assets/app-icon/`, see its README). macOS gets+/// the version with Apple's transparent margin; elsewhere the full-bleed tile. The app ID matches+/// `packaging/linux/ai.storyteller.vectorcraft.desktop` so Wayland docks find the launcher icon.+fn app_icon() -> egui::IconData {+ #[cfg(target_os = "macos")]+ let png: &[u8] = include_bytes!("../../../assets/app-icon/vectorcraft-macos-512.png");+ #[cfg(not(target_os = "macos"))]+ let png: &[u8] = include_bytes!("../../../assets/app-icon/hicolor/256x256/apps/ai.storyteller.vectorcraft.png");+ eframe::icon_data::from_png_bytes(png).unwrap_or_default()+}++/// Windows shows a window's big icon (`ICON_BIG`) in the taskbar and Alt+Tab; eframe sets only the+/// small one (the title bar's), so the taskbar showed a generic icon. Set the big one too.+#[cfg(windows)]+pub(crate) fn set_taskbar_icon(w: &winit::window::Window) {+ use winit::platform::windows::WindowExtWindows as _;+ let icon = app_icon();+ // An icon that can't be made leaves the generic one: nothing else depends on it.+ if let Ok(i) = winit::window::Icon::from_rgba(icon.rgba, icon.width, icon.height) {+ w.set_taskbar_icon(Some(i));+ }+}++/// "name (backend, kind)" of the adapter the window renders with, for Help › About and bug reports.+#[cfg(feature = "wgpu")]+pub(crate) fn adapter_summary(info: &eframe::wgpu::AdapterInfo) -> String {+ format!("{} ({:?}, {:?})", info.name.trim(), info.backend, info.device_type)+}++/// Windows and Linux: no OS title bar; the app bar is the title bar (`vectorcraft_ui_egui::titlebar`).+/// macOS keeps its traffic lights over the integrated title strip.+///+/// Used on macOS and Windows (where VectorCraft keeps today's frame regardless of the+/// `craft-window` probe) and by the tests; Linux and the BSDs take the decision from the probe.+#[cfg_attr(not(any(target_os = "macos", target_os = "windows")), allow(dead_code))]+pub(crate) const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");++/// Whether the user asked for the system title bar in Preferences › User Interface › System Title+/// Bar. Read from the saved preferences before the window opens; a missing or unreadable value is+/// `false` (the default). This preference forces the desktop/native frame back on.+pub(crate) fn opted_into_system_title_bar(saved: Option<&vectorcraft_ui_egui::UiState>) -> bool {+ saved.map(|ui| ui.engine_prefs.get("systemTitleBar").and_then(serde_json::Value::as_bool).unwrap_or(false)).unwrap_or(false)+}++/// Whether this start draws its own title bar, given the frame the shared `craft-window` crate+/// decided and the user's System Title Bar preference.+///+/// The suite-wide rule (`craft_window::Choice`) is: the desktop draws the frame+/// ([`craft_window::Frame::Desktop`]) on macOS, Windows, X11 and any Wayland compositor with+/// server-side decorations (KDE, Sway, Hyprland, COSMIC); the app draws it+/// ([`craft_window::Frame::App`]) only where the compositor leaves it to the app (GNOME's Mutter),+/// or when `VECTORCRAFT_TITLEBAR` overrides the probe. VectorCraft draws its own title bar exactly+/// when `craft-window` says the app owns the frame **and** the user has not opted into the system+/// title bar; the preference always forces the native frame back on.+///+/// macOS and Windows keep today's behavior and are decided by [`CUSTOM_TITLEBAR`] rather than the+/// probe: `craft-window` returns `Frame::Desktop` for both (the OS always draws a frame), but+/// VectorCraft insets its content under the macOS traffic lights and draws its own caption buttons+/// on Windows — an overdraw on an OS-decorated window that is VectorCraft's choice, not+/// `craft-window`'s. Only Linux and the BSDs take the decision from the probe.+#[cfg(not(any(target_os = "macos", target_os = "windows")))]+pub(crate) fn custom_titlebar_from(frame: &craft_window::Frame, opted_into_system: bool) -> bool {+ matches!(frame, craft_window::Frame::App(_)) && !opted_into_system+}++/// macOS and Windows: today's behavior, independent of the `craft-window` probe (see+/// [`custom_titlebar_from`]). macOS never draws its own frame (`CUSTOM_TITLEBAR` is `false`);+/// Windows draws its own caption unless the user opted into the system title bar.+#[cfg(any(target_os = "macos", target_os = "windows"))]+pub(crate) fn custom_titlebar_from(_frame: &craft_window::Frame, opted_into_system: bool) -> bool {+ CUSTOM_TITLEBAR && !opted_into_system+}++/// Whether this start draws its own title bar. Probes the shared `craft-window` crate once (its+/// override variable is `VECTORCRAFT_TITLEBAR`) and combines its decision with the saved System+/// Title Bar preference. Call once at startup, before [`native_options`].+///+/// On Linux, Preferences › Performance › Linux Display Server › X11 opens the window through+/// XWayland (below). A GNOME/Wayland probe would say `Frame::App` there, but the window really runs+/// on X11, whose window manager draws the frame — so when XWayland is being forced, keep the native+/// frame, the same as a real X11 session. An explicit `VECTORCRAFT_TITLEBAR` override still wins.+pub(crate) fn custom_titlebar(saved: Option<&vectorcraft_ui_egui::UiState>) -> bool {+ let choice = craft_window::Choice::probe(craft_window::Prefix::new("VECTORCRAFT"));+ let opted_into_system = opted_into_system_title_bar(saved);+ #[cfg(target_os = "linux")]+ {+ let pref = saved.and_then(|ui| ui.engine_prefs.get("linuxDisplayServer")).and_then(serde_json::Value::as_str);+ // `overridden() == None` means the probe decided (no VECTORCRAFT_TITLEBAR). When the window+ // will actually open on X11 (XWayland) — the user asked for it *and* the X11 libraries are+ // present, the same two conditions the launch path checks below — that run is effectively+ // X11, so keep the native frame. If the libraries are missing, startup stays on Wayland, so+ // the probe's own decision (app-drawn on GNOME) must stand.+ let forced_to_x11 = xwayland::wanted(pref, |name| std::env::var_os(name), xwayland::pen_attached) && xwayland::x11_libraries_found();+ if choice.overridden().is_none() && forced_to_x11 {+ return custom_titlebar_from(&craft_window::Frame::Desktop, opted_into_system);+ }+ }+ custom_titlebar_from(choice.frame(), opted_into_system)+}++pub(crate) fn native_options(custom_titlebar: bool) -> eframe::NativeOptions {+ eframe::NativeOptions {+ viewport: egui::ViewportBuilder::default()+ .with_title("VectorCraft")+ .with_inner_size(window::DEFAULT_SIZE)+ .with_min_inner_size(window::MIN_SIZE)+ .with_drag_and_drop(true)+ .with_decorations(!custom_titlebar)+ .with_fullsize_content_view(true)+ .with_titlebar_shown(false)+ .with_title_shown(false)+ .with_icon(app_icon())+ .with_app_id("ai.storyteller.vectorcraft"),+ #[cfg(feature = "windows7")]+ renderer: eframe::Renderer::Glow,+ ..Default::default()+ }+}