mirror of
https://github.com/storytold/deckcraft.git
synced 2026-10-29 04:56:58 -06:00
Brandon Thomas
ec44671a81
# Conflicts: # crates/engine/src/tools.rs # crates/model/src/defaults.rs # crates/model/src/lib.rs # crates/ui-egui/src/canvas.rs # crates/ui-egui/src/lib.rs
1932 lines
85 KiB
Rust
1932 lines
85 KiB
Rust
//! DeckCraft's egui frontend: a PowerPoint-style UI over `deckcraft-engine`.
|
||
//!
|
||
//! The UI is thin: every action goes through [`SlideApp::run`], which handles UI commands
|
||
//! (views, panes, zoom) here and sends everything else to the engine. The ribbon, menus,
|
||
//! shortcuts, the command palette and the control channel all share that entry point.
|
||
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
||
#![forbid(unsafe_code)]
|
||
|
||
pub mod animtimeline;
|
||
pub mod backstage;
|
||
pub mod canvas;
|
||
pub mod control;
|
||
pub mod credits;
|
||
pub mod dialogs;
|
||
pub mod doc_window;
|
||
pub mod eyedropper;
|
||
pub mod fillui;
|
||
pub mod icons;
|
||
pub mod media;
|
||
pub mod menus;
|
||
pub mod panes;
|
||
pub mod qat;
|
||
pub mod ribbon;
|
||
pub mod selpane;
|
||
pub mod show;
|
||
pub mod sorter;
|
||
pub mod status;
|
||
pub mod textures;
|
||
pub mod theme;
|
||
pub mod thumbs;
|
||
pub mod toast;
|
||
pub mod uifonts;
|
||
pub mod widgets;
|
||
|
||
use std::sync::mpsc::{Receiver, Sender};
|
||
|
||
use deckcraft_engine::{Mods, Session, UiRequest};
|
||
use serde::{Deserialize, Serialize};
|
||
use serde_json::{Value, json};
|
||
|
||
pub use control::{ControlRequest, ControlResponse};
|
||
|
||
pub type ReadFn = Box<dyn Fn(&str) -> Result<Vec<u8>, String>>;
|
||
pub type WriteFn = Box<dyn FnMut(&str, &[u8]) -> Result<(), String>>;
|
||
pub type PickFn = Box<dyn FnMut(&str) -> Option<String>>;
|
||
pub type OpenAsyncFn = Box<dyn FnMut(&str)>;
|
||
pub type DownloadFn = Box<dyn FnMut(&str, &[u8])>;
|
||
/// Files `(name, bytes)` delivered asynchronously by the host (web file picker, dropped files).
|
||
pub type Inbox = std::sync::Arc<std::sync::Mutex<Vec<(String, Vec<u8>)>>>;
|
||
|
||
/// Platform services injected by the host (desktop or web).
|
||
#[derive(Default)]
|
||
pub struct Services {
|
||
/// Open-file dialog for a purpose (`open`, `picture`, `audio`, `video`) → path.
|
||
pub pick_open: Option<PickFn>,
|
||
/// Save dialog with a suggested name → path.
|
||
pub pick_save: Option<PickFn>,
|
||
pub read: Option<ReadFn>,
|
||
pub write: Option<WriteFn>,
|
||
/// Asynchronous open dialog (web): the chosen file arrives through `inbox`.
|
||
pub open_async: Option<OpenAsyncFn>,
|
||
/// Hand bytes to the user as a named file (browser download).
|
||
pub download: Option<DownloadFn>,
|
||
pub inbox: Option<Inbox>,
|
||
/// Image on the system clipboard (PNG bytes), when the host can read one.
|
||
pub clipboard_image: Option<Box<dyn FnMut() -> Option<Vec<u8>>>>,
|
||
/// Audio output for media playback (cpal on desktop); without one media plays silently.
|
||
pub audio_out: Option<Box<dyn deckcraft_media::AudioOut>>,
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub enum ViewMode {
|
||
#[default]
|
||
Normal,
|
||
Outline,
|
||
Sorter,
|
||
NotesPage,
|
||
Reading,
|
||
}
|
||
|
||
/// Persisted UI state.
|
||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||
#[serde(default, rename_all = "camelCase")]
|
||
pub struct UiState {
|
||
pub brightness: theme::Brightness,
|
||
pub tab: String,
|
||
pub ribbon_collapsed: bool,
|
||
pub view: ViewMode,
|
||
pub notes: bool,
|
||
pub notes_height: f32,
|
||
pub thumbs_width: f32,
|
||
/// Open task pane: `format`, `animation`, `selection`, `comments`, `designer`, `background`,
|
||
/// `smartart` (Text Pane).
|
||
pub pane: Option<String>,
|
||
pub pane_width: f32,
|
||
pub ruler: bool,
|
||
pub gridlines: bool,
|
||
/// Slides per page previewed in Handout Master view (1, 2, 3, 4, 6 or 9).
|
||
pub handout_per_page: u8,
|
||
pub guides: bool,
|
||
pub smart_guides: bool,
|
||
/// None = fit to window.
|
||
pub zoom: Option<f32>,
|
||
pub sorter_zoom: f32,
|
||
pub recent: Vec<String>,
|
||
pub presenter_view: bool,
|
||
pub ui_scale: f32,
|
||
/// Format Shape pane: tab (`fill`, `effects`, `size`, `picture`, `text`).
|
||
pub format_tab: String,
|
||
/// The Text Pane's current SmartArt line (Add Shape, Promote and Demote act on it).
|
||
pub smartart_row: usize,
|
||
/// A Text Pane line to focus once it is drawn (after Enter, Tab or Backspace rebuilt the list).
|
||
pub smartart_focus: Option<usize>,
|
||
/// The Text Pane's line drafts, for the SmartArt group they were read from.
|
||
pub smartart_drafts: (u32, Vec<String>),
|
||
pub grayscale: bool,
|
||
/// Comment the Review Previous/Next buttons last landed on: `(slide, index)`.
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub comment_focus: Option<(usize, usize)>,
|
||
/// Quick Access Toolbar buttons, left to right.
|
||
pub qat: Vec<qat::QatItem>,
|
||
}
|
||
|
||
impl Default for UiState {
|
||
fn default() -> Self {
|
||
UiState {
|
||
brightness: theme::Brightness::Light,
|
||
tab: "Home".into(),
|
||
ribbon_collapsed: false,
|
||
view: ViewMode::Normal,
|
||
notes: true,
|
||
notes_height: 52.0,
|
||
thumbs_width: 236.0,
|
||
pane: None,
|
||
pane_width: 300.0,
|
||
ruler: false,
|
||
gridlines: false,
|
||
handout_per_page: 6,
|
||
guides: false,
|
||
smart_guides: true,
|
||
zoom: None,
|
||
sorter_zoom: 1.0,
|
||
recent: vec![],
|
||
presenter_view: true,
|
||
ui_scale: 1.0,
|
||
format_tab: "fill".into(),
|
||
smartart_row: 0,
|
||
smartart_focus: None,
|
||
smartart_drafts: (0, vec![]),
|
||
grayscale: false,
|
||
comment_focus: None,
|
||
qat: qat::defaults(),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Text put on the system clipboard when the copied objects (a rectangle, a picture, slides…)
|
||
/// carry no text. egui-winit drops Ctrl+V when the system clipboard is empty, so without it the
|
||
/// shortcut never reached the session and only the context menu could paste objects (#182). An
|
||
/// invisible word joiner, so a paste into another app adds nothing visible.
|
||
const OBJECTS_MARKER: &str = "\u{2060}";
|
||
|
||
/// What a copy/cut leaves on the system clipboard for the session's plain-text rendering `t`.
|
||
fn system_clipboard_text(t: &str) -> String {
|
||
if t.is_empty() { OBJECTS_MARKER.to_string() } else { t.to_string() }
|
||
}
|
||
|
||
/// UI-only commands (id, label, shortcut, params).
|
||
pub const UI_COMMANDS: &[(&str, &str, Option<&str>, &str)] = &[
|
||
("view.normal", "Normal", None, "{}"),
|
||
("view.outline", "Outline View", None, "{}"),
|
||
("view.sorter", "Slide Sorter", None, "{}"),
|
||
("view.notesPage", "Notes Page", None, "{}"),
|
||
("view.reading", "Reading View", None, "{}"),
|
||
("view.notes", "Notes", None, "{on?: bool}"),
|
||
("view.ruler", "Ruler", None, "{on?: bool}"),
|
||
("view.gridlines", "Gridlines", Some("Shift+F9"), "{on?: bool}"),
|
||
("view.guides", "Guides", Some("Alt+F9"), "{on?: bool}"),
|
||
("view.gridOptions", "Grid Options…", None, "{spacing?: pt, snap?: bool, smartGuides?: bool, gridlines?: bool, guides?: bool}"),
|
||
("view.zoomIn", "Zoom In", Some("Cmd+="), "{}"),
|
||
("view.zoomOut", "Zoom Out", Some("Cmd+-"), "{}"),
|
||
("view.zoom", "Set Zoom", None, "{percent}"),
|
||
("view.zoomDialog", "Zoom…", None, "{}"),
|
||
("view.fit", "Fit to Window", None, "{}"),
|
||
("view.pane", "Task Pane", None, "{pane: format|animation|selection|comments|designer|background|smartart|null}"),
|
||
("view.tab", "Ribbon Tab", None, "{tab}"),
|
||
("view.collapseRibbon", "Collapse the Ribbon", Some("Cmd+F1"), "{}"),
|
||
("view.dark", "Dark Mode", None, "{on?: bool}"),
|
||
("view.grayscale", "Grayscale", None, "{on?: bool}"),
|
||
("view.newWindow", "New Window", None, "{on?: bool, slide?: index, delta?: int}"),
|
||
("show.start", "Slide Show", Some("F5"), "{from?: index, custom?: name}"),
|
||
("show.presenter", "Presenter View", None, "{on?: bool}"),
|
||
("show.end", "End Show", None, "{}"),
|
||
("app.home", "Home", None, "{on?}"),
|
||
("app.backstage", "File", Some("Alt+F"), "{page?: home|new|open|info|saveAs|print|export|account, on?: bool}"),
|
||
("app.closePresentation", "Close", Some("Cmd+W"), "{}"),
|
||
(
|
||
"app.print",
|
||
"Print",
|
||
Some("Cmd+P"),
|
||
"{layout?, perPage?, slides?, includeHidden?, frame?, paper?: letter|a4|legal|a3, orientation?: portrait|landscape}",
|
||
),
|
||
("app.about", "About DeckCraft", None, "{}"),
|
||
("app.palette", "Command Palette", Some("Cmd+Shift+P"), "{}"),
|
||
("app.preferences", "Preferences…", Some("Cmd+,"), "{}"),
|
||
("app.openDialog", "Open…", None, "{purpose?}"),
|
||
("app.insertPictureDialog", "Picture from File…", None, "{}"),
|
||
("app.smartArtPictureDialog", "Insert Picture in SmartArt…", None, "{id?, index}"),
|
||
("app.insertAudioDialog", "Audio from File…", None, "{}"),
|
||
("app.insertVideoDialog", "Video from File…", None, "{}"),
|
||
("app.saveAsDialog", "Save As…", None, "{}"),
|
||
("app.exportDialog", "Export…", None, "{}"),
|
||
("app.browseThemeDialog", "Browse for Themes…", None, "{}"),
|
||
("app.dialog", "Open Dialog", None, "{id}"),
|
||
("app.pasteSpecial", "Paste Special…", Some("Cmd+Alt+V"), "{}"),
|
||
("app.qat", "Quick Access Toolbar", None, "{add: command id, params?, label?, icon?} | {remove: id, params?} | {reset: true} → [buttons]"),
|
||
("app.links", "Community Links", None, "{}"),
|
||
];
|
||
|
||
pub struct Perf {
|
||
pub frame_ms: f64,
|
||
pub render_ms: f64,
|
||
pub fps: f64,
|
||
}
|
||
|
||
pub struct SlideApp {
|
||
/// Table Design's border pen (`color`, `width`, `dash` for `table.borders`).
|
||
pub table_pen: serde_json::Value,
|
||
pub session: Session,
|
||
pub services: Services,
|
||
pub ui: UiState,
|
||
pub textures: textures::Textures,
|
||
pub control_rx: Option<Receiver<ControlRequest>>,
|
||
pub dialog: Option<dialogs::Dialog>,
|
||
pub show: Option<show::Show>,
|
||
/// Audio/video playback (editor control bar, slide show, `media.*` commands).
|
||
pub media: media::MediaHost,
|
||
pub status: Option<(String, f64)>,
|
||
/// A brief notice over the bottom of the window (missing fonts on opening a file).
|
||
pub toast: Option<toast::Toast>,
|
||
/// Documents (by uid) whose missing fonts have been mentioned.
|
||
fonts_noted: std::collections::HashSet<u64>,
|
||
pub perf: Perf,
|
||
/// Synthetic input events (control channel `ui.click` etc.), injected one per frame.
|
||
pub synthetic: Vec<egui::Event>,
|
||
/// Canvas screen rect and points-per-slide-point scale (for control & tests).
|
||
pub canvas_rect: Option<egui::Rect>,
|
||
/// The Eyedropper is waiting for a click on the slide.
|
||
pub eyedropper: Option<eyedropper::State>,
|
||
pub canvas_scale: f32,
|
||
pub slide_rect: Option<egui::Rect>,
|
||
/// Where the canvas texture (the slide and the pasteboard drawn around it) is on screen.
|
||
pub canvas_region: Option<egui::Rect>,
|
||
pub palette: Option<(String, usize)>,
|
||
/// Integrated title bar (macOS traffic lights over our chrome).
|
||
pub integrated_titlebar: bool,
|
||
/// The File tab's full-window view (Backstage). Over a presentation it replaces the ribbon,
|
||
/// slides and status bar until Esc or Back; with nothing open it is the start screen. Opening,
|
||
/// creating or closing a presentation leaves it.
|
||
pub backstage: Option<backstage::Backstage>,
|
||
pending_urls: Vec<String>,
|
||
/// Text for the system clipboard from a Copy or Cut command, handed over on the next frame.
|
||
pending_copy: Option<String>,
|
||
shot_token: u64,
|
||
queued_shots: Vec<(u64, f64, u32)>,
|
||
pending_shots: Vec<(u64, Option<String>, Sender<ControlResponse>, f64)>,
|
||
styled: bool,
|
||
restyle: bool,
|
||
fonts_ready: bool,
|
||
last_time: f64,
|
||
/// When AutoRecover data was last written (seconds, egui time).
|
||
pub last_recovery: f64,
|
||
/// Quit was confirmed (changes saved or discarded): let the window close.
|
||
pub quit_confirmed: bool,
|
||
pub(crate) notes_buf: (u64, usize, String),
|
||
/// Faces borrowed from the font database for text the interface fonts can't draw (#101).
|
||
pub ui_fonts: uifonts::UiFonts,
|
||
/// Thumbnail pane drag (slide index, current drop index).
|
||
pub(crate) thumb_drag: Option<(usize, usize)>,
|
||
/// Selection pane: folded groups, renaming, drag and drop.
|
||
pub selpane: selpane::State,
|
||
/// View › New Window: a second window on one presentation. `None` when it is closed.
|
||
pub doc_window: Option<doc_window::DocWindow>,
|
||
/// Slide Sorter: folded sections, inline rename, dragging a whole section.
|
||
pub sorter: sorter::State,
|
||
/// The slide thumbnail pane was the last thing clicked, so ⌘A selects slides, not shapes.
|
||
pub(crate) slides_focused: bool,
|
||
}
|
||
|
||
fn grid_options_touched(p: &Value) -> bool {
|
||
["spacing", "snap", "smartGuides", "gridlines", "guides"].iter().any(|k| p.get(*k).is_some())
|
||
}
|
||
|
||
fn grid_flag(p: &Value, key: &str) -> Result<Option<bool>, String> {
|
||
match p.get(key) {
|
||
None => Ok(None),
|
||
Some(Value::Bool(b)) => Ok(Some(*b)),
|
||
Some(_) => Err(format!("`{key}` must be true or false")),
|
||
}
|
||
}
|
||
|
||
impl SlideApp {
|
||
pub fn new(session: Session, mut services: Services) -> Self {
|
||
let audio_out = services.audio_out.take();
|
||
SlideApp {
|
||
table_pen: serde_json::json!({"width": 1.0}),
|
||
session,
|
||
services,
|
||
ui: UiState::default(),
|
||
textures: textures::Textures::default(),
|
||
control_rx: None,
|
||
dialog: None,
|
||
show: None,
|
||
media: media::MediaHost::new(audio_out),
|
||
status: None,
|
||
toast: None,
|
||
fonts_noted: Default::default(),
|
||
perf: Perf { frame_ms: 0.0, render_ms: 0.0, fps: 0.0 },
|
||
synthetic: vec![],
|
||
canvas_rect: None,
|
||
eyedropper: None,
|
||
canvas_scale: 1.0,
|
||
slide_rect: None,
|
||
canvas_region: None,
|
||
palette: None,
|
||
integrated_titlebar: false,
|
||
backstage: None,
|
||
pending_urls: vec![],
|
||
pending_copy: None,
|
||
shot_token: 0,
|
||
queued_shots: vec![],
|
||
pending_shots: vec![],
|
||
styled: false,
|
||
restyle: true,
|
||
fonts_ready: false,
|
||
last_time: 0.0,
|
||
last_recovery: 0.0,
|
||
quit_confirmed: false,
|
||
notes_buf: (0, usize::MAX, String::new()),
|
||
ui_fonts: uifonts::UiFonts::default(),
|
||
thumb_drag: None,
|
||
selpane: selpane::State::default(),
|
||
doc_window: None,
|
||
sorter: sorter::State::default(),
|
||
slides_focused: false,
|
||
}
|
||
}
|
||
|
||
pub fn with_control(mut self, rx: Receiver<ControlRequest>) -> Self {
|
||
self.control_rx = Some(rx);
|
||
self
|
||
}
|
||
|
||
pub fn set_status(&mut self, msg: impl Into<String>) {
|
||
self.status = Some((msg.into(), now_ms()));
|
||
}
|
||
|
||
/// A message that must be seen wherever the user is: a toast, which also shows over the start
|
||
/// screen and the File tab, where there is no status bar.
|
||
pub fn notify(&mut self, msg: impl Into<String>) {
|
||
self.toast = Some(toast::Toast { text: msg.into(), at: now_ms() });
|
||
}
|
||
|
||
/// Run a command by id (UI commands here, everything else in the engine). Errors show in the
|
||
/// status bar and are returned.
|
||
pub fn run(&mut self, id: &str, params: Value) -> Result<Value, String> {
|
||
let r = if UI_COMMANDS.iter().any(|c| c.0 == id) {
|
||
self.run_ui(id, ¶ms)
|
||
} else {
|
||
self.session.execute(id, ¶ms).map_err(|e| e.to_string())
|
||
};
|
||
match &r {
|
||
// Copy and Cut from the ribbon, menus, the slide's context menu or the control channel
|
||
// put the text on the system clipboard, as Ctrl+C and Ctrl+X do (#431).
|
||
Ok(v) if matches!(id, "edit.copy" | "edit.cut") => {
|
||
if let Some(t) = v.get("text").and_then(Value::as_str) {
|
||
self.pending_copy = Some(t.to_string());
|
||
}
|
||
}
|
||
Ok(_) => {}
|
||
Err(e) => self.set_status(e.clone()),
|
||
}
|
||
self.drain_requests();
|
||
r
|
||
}
|
||
|
||
pub(crate) fn docs_key(&self) -> (usize, Option<usize>) {
|
||
(self.session.documents().len(), self.session.active_index())
|
||
}
|
||
|
||
/// The File tab's view is open over a presentation (not just the start screen with nothing
|
||
/// open).
|
||
pub fn backstage_open(&self) -> bool {
|
||
self.backstage.is_some() && self.session.active().is_some()
|
||
}
|
||
|
||
/// Opens the File tab's view on `page` (keeping its state when it is already open).
|
||
pub fn open_backstage(&mut self, page: backstage::Page) {
|
||
let key = self.docs_key();
|
||
match &mut self.backstage {
|
||
Some(b) => b.go(page),
|
||
None => self.backstage = Some(backstage::Backstage::new(page, key)),
|
||
}
|
||
}
|
||
|
||
/// Back to the presentation (no effect on the start screen, where nothing is open).
|
||
pub fn close_backstage(&mut self) {
|
||
if self.session.active().is_some() {
|
||
self.backstage = None;
|
||
}
|
||
}
|
||
|
||
/// Keeps the File tab's view in step with the open presentations: it closes when one is
|
||
/// opened, created or closed (the result shows), and it is the start screen when none is open.
|
||
fn sync_backstage(&mut self) {
|
||
let key = self.docs_key();
|
||
let has_doc = self.session.active().is_some();
|
||
let stale = self.backstage.as_ref().is_some_and(|b| b.docs != key);
|
||
if has_doc && stale {
|
||
self.backstage = None;
|
||
} else if !has_doc && (stale || self.backstage.is_none()) {
|
||
self.backstage = Some(backstage::Backstage::new(backstage::Page::Home, key));
|
||
}
|
||
}
|
||
|
||
/// File › Close and Ctrl+W: closes the active presentation, asking first when it has unsaved
|
||
/// changes (Save, Don't Save, Cancel), as PowerPoint does.
|
||
pub fn close_presentation(&mut self) {
|
||
match self.session.active() {
|
||
None => {}
|
||
Some(d) if d.is_dirty() => self.dialog = Some(dialogs::Dialog::new("close")),
|
||
Some(_) => {
|
||
let _ = self.run("file.close", json!({}));
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The file name a save or export suggests: the presentation's title with `ext`.
|
||
fn suggested_name(&self, ext: &str) -> String {
|
||
let name = self.session.active().map(|d| d.title()).unwrap_or_else(|| "Presentation".into());
|
||
format!("{name}.{ext}")
|
||
}
|
||
|
||
/// Exports the active presentation as `fmt` (`pdf`, `png`, `pngAll`, `jpeg`, `pptx`,
|
||
/// `deckcraft`, `outline`) through `file.export`: the save picker on the desktop, a download
|
||
/// on the web. `extra` adds `file.export` params (the PDF's layout, slides…). The
|
||
/// presentation keeps its own file. Returns whether a file was written or handed over.
|
||
pub fn export_as(&mut self, fmt: &str, extra: Value) -> bool {
|
||
let Some(slide) = self.session.active().map(|d| d.selection.slide) else { return false };
|
||
let (ext, format, all) = match fmt {
|
||
"pdf" => ("pdf", "pdf", false),
|
||
"png" => ("png", "png", false),
|
||
"pngAll" => ("png", "png", true),
|
||
"jpeg" | "jpg" => ("jpg", "jpeg", false),
|
||
"pptx" => ("pptx", "pptx", false),
|
||
"outline" | "txt" => ("txt", "outline", false),
|
||
"deckcraft" => ("deckcraft", "deckcraft", false),
|
||
other => {
|
||
self.set_status(format!("DeckCraft can't export “{other}”"));
|
||
return false;
|
||
}
|
||
};
|
||
let suggested = self.suggested_name(ext);
|
||
if let Some(pick) = self.services.pick_save.as_mut() {
|
||
let Some(path) = pick(&suggested) else { return false };
|
||
let mut params = json!({"path": path, "format": format, "all": all});
|
||
if let (Some(o), Some(x)) = (params.as_object_mut(), extra.as_object()) {
|
||
o.extend(x.clone());
|
||
}
|
||
return match self.run("file.export", params) {
|
||
Ok(_) => {
|
||
self.set_status(format!("Exported {path}"));
|
||
true
|
||
}
|
||
Err(_) => false,
|
||
};
|
||
}
|
||
let Some(doc) = self.session.active().map(|d| d.doc.clone()) else { return false };
|
||
let bytes = match format {
|
||
"png" | "jpeg" => {
|
||
let scale = 2.0;
|
||
let img = deckcraft_render::render_slide(&doc, slide, &deckcraft_render::RenderOpts { scale, ..Default::default() });
|
||
let dpi = deckcraft_render::dpi_for_scale(scale);
|
||
Ok(if format == "png" { img.to_png_at(dpi) } else { img.to_jpeg_at(92, Some(dpi)) })
|
||
}
|
||
"pdf" => deckcraft_engine::cmd::file::pdf_bytes(&doc, &extra),
|
||
other => deckcraft_engine::cmd::file::save_bytes(&doc, other),
|
||
};
|
||
self.download(&suggested, bytes)
|
||
}
|
||
|
||
/// Hands `bytes` to the browser as a download (web); false (with the reason in the status
|
||
/// bar) when there are no bytes or no way to download.
|
||
fn download(&mut self, name: &str, bytes: deckcraft_engine::Result<Vec<u8>>) -> bool {
|
||
match (bytes, self.services.download.as_mut()) {
|
||
(Ok(b), Some(dl)) => {
|
||
dl(name, &b);
|
||
true
|
||
}
|
||
(Err(e), _) => {
|
||
self.set_status(e.to_string());
|
||
false
|
||
}
|
||
(Ok(_), None) => {
|
||
self.set_status("Saving a copy needs a file picker, which this window doesn't have.");
|
||
false
|
||
}
|
||
}
|
||
}
|
||
|
||
/// File › Print: DeckCraft prints through a PDF. On the desktop the PDF (with the Print page's
|
||
/// layout, slides and options) is written to the temporary folder and opened in the system's
|
||
/// PDF viewer, which has the printers; on the web it downloads.
|
||
pub fn print_pdf(&mut self, params: Value) -> bool {
|
||
let Some((title, doc)) = self.session.active().map(|d| (d.title(), d.doc.clone())) else { return false };
|
||
let mut params = if params.is_object() { params } else { json!({}) };
|
||
if self.services.pick_save.is_none() {
|
||
// Web: the browser hands the PDF to the user.
|
||
let bytes = deckcraft_engine::cmd::file::pdf_bytes(&doc, ¶ms);
|
||
return self.download(&format!("{title}.pdf"), bytes);
|
||
}
|
||
let safe: String = title.chars().map(|c| if c.is_alphanumeric() || c == ' ' || c == '-' { c } else { '_' }).collect();
|
||
let path = std::env::temp_dir().join(format!("{safe} (print).pdf")).to_string_lossy().to_string();
|
||
if let Some(o) = params.as_object_mut() {
|
||
o.insert("path".into(), json!(path));
|
||
o.insert("format".into(), json!("pdf"));
|
||
}
|
||
match self.run("file.export", params) {
|
||
Ok(_) => {
|
||
self.open_url(&format!("file:///{}", path.replace('\\', "/").trim_start_matches('/')));
|
||
self.set_status("Opened the presentation as a PDF to print");
|
||
true
|
||
}
|
||
Err(_) => false,
|
||
}
|
||
}
|
||
|
||
fn flag(&mut self, params: &Value, cur: bool) -> bool {
|
||
params.get("on").and_then(Value::as_bool).unwrap_or(!cur)
|
||
}
|
||
|
||
fn run_ui(&mut self, id: &str, p: &Value) -> Result<Value, String> {
|
||
match id {
|
||
"view.normal" => self.ui.view = ViewMode::Normal,
|
||
"view.outline" => self.ui.view = ViewMode::Outline,
|
||
"view.sorter" => self.ui.view = ViewMode::Sorter,
|
||
"view.notesPage" => self.ui.view = ViewMode::NotesPage,
|
||
"view.reading" => self.start_show(self.session.active().map(|d| d.selection.slide).unwrap_or(0), true),
|
||
"view.notes" => self.ui.notes = self.flag(p, self.ui.notes),
|
||
"view.ruler" => self.ui.ruler = self.flag(p, self.ui.ruler),
|
||
"view.gridlines" => self.ui.gridlines = self.flag(p, self.ui.gridlines),
|
||
"view.guides" => {
|
||
self.ui.guides = self.flag(p, self.ui.guides);
|
||
// A presentation without guides gets PowerPoint's two centre guides.
|
||
if self.ui.guides && self.session.active().is_some_and(|d| d.doc.guides.is_empty()) {
|
||
let _ = self.session.execute("guide.add", &json!({"defaults": true}));
|
||
}
|
||
}
|
||
"view.gridOptions" => {
|
||
if grid_options_touched(p) {
|
||
let spacing = match p.get("spacing") {
|
||
None => None,
|
||
Some(raw) => {
|
||
let n = raw.as_f64().filter(|v| v.is_finite()).ok_or("`spacing` must be a finite number of points")?;
|
||
if !(1.0..=288.0).contains(&n) {
|
||
return Err("`spacing` must be from 1 to 288 points".into());
|
||
}
|
||
Some(n)
|
||
}
|
||
};
|
||
let snap = grid_flag(p, "snap")?;
|
||
let smart = grid_flag(p, "smartGuides")?;
|
||
let gridlines = grid_flag(p, "gridlines")?;
|
||
let guides = grid_flag(p, "guides")?;
|
||
if let Some(n) = spacing {
|
||
self.session.prefs.grid_spacing = n;
|
||
}
|
||
if let Some(b) = snap {
|
||
self.session.prefs.snap_to_grid = b;
|
||
}
|
||
if let Some(b) = smart {
|
||
self.session.prefs.smart_guides = b;
|
||
self.ui.smart_guides = b;
|
||
}
|
||
if let Some(b) = gridlines {
|
||
self.ui.gridlines = b;
|
||
}
|
||
if let Some(b) = guides {
|
||
self.ui.guides = b;
|
||
}
|
||
} else {
|
||
self.dialog = Some(dialogs::Dialog::new("gridOptions"));
|
||
}
|
||
return Ok(json!({
|
||
"spacing": self.session.prefs.grid_spacing,
|
||
"snap": self.session.prefs.snap_to_grid,
|
||
"smartGuides": self.session.prefs.smart_guides,
|
||
"gridlines": self.ui.gridlines,
|
||
"guides": self.ui.guides,
|
||
}));
|
||
}
|
||
"view.zoomIn" | "view.zoomOut" => {
|
||
let cur = self.ui.zoom.unwrap_or(self.canvas_scale);
|
||
let steps = [0.1, 0.25, 0.33, 0.5, 0.66, 0.75, 1.0, 1.25, 1.5, 2.0, 3.0, 4.0];
|
||
let next = if id == "view.zoomIn" {
|
||
steps.iter().copied().find(|s| *s > cur + 0.01).unwrap_or(4.0)
|
||
} else {
|
||
steps.iter().rev().copied().find(|s| *s < cur - 0.01).unwrap_or(0.1)
|
||
};
|
||
self.ui.zoom = Some(next);
|
||
}
|
||
"view.zoom" => {
|
||
let pct = p.get("percent").and_then(Value::as_f64).ok_or("missing `percent`")?;
|
||
self.ui.zoom = Some((pct as f32 / 100.0).clamp(0.1, 4.0));
|
||
}
|
||
"view.zoomDialog" => self.dialog = Some(dialogs::Dialog::new("zoom")),
|
||
"view.fit" => self.ui.zoom = None,
|
||
"view.pane" => {
|
||
let pane = p.get("pane").and_then(Value::as_str).map(String::from);
|
||
self.ui.pane =
|
||
if pane.is_some() && pane == self.ui.pane && p.get("toggle").and_then(Value::as_bool).unwrap_or(false) { None } else { pane };
|
||
if let Some(tab) = p.get("tab").and_then(Value::as_str) {
|
||
self.ui.format_tab = tab.to_string();
|
||
}
|
||
}
|
||
"view.tab" => {
|
||
let tab = p.get("tab").and_then(Value::as_str).ok_or("missing `tab`")?;
|
||
self.ui.tab = tab.to_string();
|
||
self.ui.ribbon_collapsed = false;
|
||
}
|
||
"view.collapseRibbon" => self.ui.ribbon_collapsed = !self.ui.ribbon_collapsed,
|
||
"view.dark" => {
|
||
let on = self.flag(p, self.ui.brightness == theme::Brightness::Dark);
|
||
self.ui.brightness = if on { theme::Brightness::Dark } else { theme::Brightness::Light };
|
||
self.restyle = true;
|
||
}
|
||
"view.grayscale" => self.ui.grayscale = self.flag(p, self.ui.grayscale),
|
||
"view.newWindow" => return doc_window::command(self, p),
|
||
"show.start" => {
|
||
if let Some(name) = p.get("custom").and_then(Value::as_str).filter(|s| !s.is_empty()) {
|
||
self.start_custom_show(name, false);
|
||
} else if p.get("from").is_some() {
|
||
let from = p.get("from").and_then(Value::as_u64).map(|v| v as usize).unwrap_or(0);
|
||
self.start_show(from, false);
|
||
} else {
|
||
self.start_show(self.show_start_index(), false);
|
||
}
|
||
}
|
||
"show.presenter" => self.ui.presenter_view = self.flag(p, self.ui.presenter_view),
|
||
"show.end" => {
|
||
self.show = None;
|
||
self.media.stop_owned(media::Owner::Show);
|
||
}
|
||
"app.home" => {
|
||
let on = self.flag(p, self.backstage_open());
|
||
if on {
|
||
self.open_backstage(backstage::Page::Home);
|
||
} else {
|
||
self.close_backstage();
|
||
}
|
||
}
|
||
"app.backstage" => {
|
||
if !p.get("on").and_then(Value::as_bool).unwrap_or(true) {
|
||
self.close_backstage();
|
||
return Ok(json!({"page": self.backstage.as_ref().map(|b| b.page.id())}));
|
||
}
|
||
let page = match p.get("page").and_then(Value::as_str) {
|
||
Some(id) => backstage::Page::parse(id).ok_or_else(|| format!("unknown File page `{id}`"))?,
|
||
None => backstage::Page::Home,
|
||
};
|
||
if page.needs_doc() && self.session.active().is_none() {
|
||
return Err(format!("File › {} needs an open presentation", page.label()));
|
||
}
|
||
self.open_backstage(page);
|
||
return Ok(json!({"page": page.id()}));
|
||
}
|
||
"app.closePresentation" => self.close_presentation(),
|
||
"app.print" => {
|
||
if self.session.active().is_none() {
|
||
return Err("nothing to print: no presentation is open".into());
|
||
}
|
||
return Ok(json!({"printed": self.print_pdf(p.clone())}));
|
||
}
|
||
"app.about" => self.dialog = Some(dialogs::Dialog::new("about")),
|
||
"app.palette" => self.palette = Some((String::new(), 0)),
|
||
"app.preferences" => self.dialog = Some(dialogs::Dialog::new("preferences")),
|
||
"app.openDialog" => self.pick_and_open(),
|
||
"app.insertPictureDialog" => self.pick_and_insert("picture", "insert.picture"),
|
||
"app.smartArtPictureDialog" => {
|
||
if self.services.pick_open.is_none() {
|
||
return Err("picking a SmartArt picture needs the desktop app".into());
|
||
}
|
||
self.pick_and_run("picture", "smartArt.picture", p);
|
||
}
|
||
"app.insertAudioDialog" => self.pick_and_insert("audio", "insert.audio"),
|
||
"app.insertVideoDialog" => self.pick_and_insert("video", "insert.video"),
|
||
"app.saveAsDialog" => self.save_as_dialog("deckcraft"),
|
||
"app.exportDialog" => self.dialog = Some(dialogs::Dialog::new("export")),
|
||
"app.pasteSpecial" => self.dialog = Some(dialogs::Dialog::new("pasteSpecial")),
|
||
"app.browseThemeDialog" => {
|
||
if self.session.active().is_none() {
|
||
return Err("open a presentation first".into());
|
||
}
|
||
if self.services.pick_open.is_some() {
|
||
self.pick_and_insert("theme", "design.browseTheme");
|
||
} else {
|
||
// The browser's asynchronous picker would open the file as a new document.
|
||
self.set_status("Browse for Themes needs the desktop app for now".to_string());
|
||
}
|
||
}
|
||
"app.qat" => return qat::command(self, p),
|
||
"app.dialog" => {
|
||
let d = p.get("id").and_then(Value::as_str).ok_or("missing `id`")?;
|
||
self.dialog = Some(dialogs::Dialog::new(d));
|
||
}
|
||
"app.links" => {
|
||
use deckcraft_engine::links::*;
|
||
return Ok(json!({"discord": DISCORD, "website": WEBSITE, "apps": APPS, "appPage": APP_PAGE, "github": GITHUB}));
|
||
}
|
||
_ => return Err(format!("unknown UI command `{id}`")),
|
||
}
|
||
Ok(Value::Null)
|
||
}
|
||
|
||
/// Whether ⌘A should act on the slide list: always in the sorter, in Normal view once the
|
||
/// thumbnail pane has been clicked.
|
||
pub(crate) fn slides_list_focused(&self) -> bool {
|
||
self.ui.view == ViewMode::Sorter || (self.ui.view == ViewMode::Normal && self.slides_focused)
|
||
}
|
||
|
||
/// First slide Play from Start should open: the custom show or range, skipping hidden slides.
|
||
pub fn show_start_index(&self) -> usize {
|
||
self.session.active().and_then(|d| deckcraft_anim::show_order(&d.doc).first().copied()).unwrap_or(0)
|
||
}
|
||
|
||
pub fn start_show(&mut self, from: usize, reading: bool) {
|
||
self.media.stop_owned(media::Owner::Editor);
|
||
if let Some(d) = self.session.active() {
|
||
self.show = Some(show::Show::new(&d.doc, from, reading, self.ui.presenter_view && !reading));
|
||
}
|
||
}
|
||
|
||
/// Play custom show `name` from its first slide. Set Up Slide Show is left as it was.
|
||
pub fn start_custom_show(&mut self, name: &str, reading: bool) {
|
||
let state = self.session.active().and_then(|d| deckcraft_anim::ShowState::play_custom(&d.doc, name));
|
||
let Some(state) = state else { return };
|
||
let from = state.slide;
|
||
self.start_show(from, reading);
|
||
if let Some(show) = self.show.as_mut() {
|
||
show.state = state;
|
||
}
|
||
}
|
||
|
||
fn pick_and_open(&mut self) {
|
||
if let Some(pick) = self.services.pick_open.as_mut() {
|
||
if let Some(path) = pick("open")
|
||
&& let Err(e) = self.open_path(&path)
|
||
{
|
||
self.notify(e);
|
||
}
|
||
} else if let Some(f) = self.services.open_async.as_mut() {
|
||
f("open");
|
||
}
|
||
}
|
||
|
||
pub fn open_path(&mut self, path: &str) -> Result<(), String> {
|
||
self.session.execute("file.open", &json!({"path": path})).map_err(|e| e.to_string())?;
|
||
self.ui.recent.retain(|p| p != path);
|
||
self.ui.recent.insert(0, path.to_string());
|
||
self.ui.recent.truncate(12);
|
||
self.ui.view = ViewMode::Normal;
|
||
Ok(())
|
||
}
|
||
|
||
/// Transitions › Sound › Other Sound…: pick an audio file for the selected slides.
|
||
pub(crate) fn pick_transition_sound(&mut self) {
|
||
if self.services.pick_open.is_some() {
|
||
self.pick_and_insert("audio", "transition.sound");
|
||
}
|
||
}
|
||
|
||
fn pick_and_insert(&mut self, purpose: &str, cmd: &str) {
|
||
self.pick_and_run(purpose, cmd, &json!({}));
|
||
}
|
||
|
||
/// Pick a file and run `cmd` with it (`name` + `data`, or `path`) added to `extra`.
|
||
fn pick_and_run(&mut self, purpose: &str, cmd: &str, extra: &Value) {
|
||
if let Some(pick) = self.services.pick_open.as_mut() {
|
||
if let Some(path) = pick(purpose) {
|
||
let mut args = if extra.is_object() { extra.clone() } else { json!({}) };
|
||
let r = match self.services.read.as_ref().map(|r| r(&path)) {
|
||
Some(Ok(bytes)) => {
|
||
let name = std::path::Path::new(&path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
|
||
args["name"] = json!(name);
|
||
args["data"] = json!(deckcraft_engine::cmd::base64_encode(&bytes));
|
||
self.session.execute(cmd, &args)
|
||
}
|
||
_ => {
|
||
args["path"] = json!(path);
|
||
self.session.execute(cmd, &args)
|
||
}
|
||
};
|
||
if let Err(e) = r {
|
||
self.set_status(e.to_string());
|
||
}
|
||
}
|
||
} else if let Some(f) = self.services.open_async.as_mut() {
|
||
f(purpose);
|
||
}
|
||
}
|
||
|
||
pub fn save_as_dialog(&mut self, format: &str) {
|
||
let name = self.session.active().map(|d| d.title()).unwrap_or_else(|| "Presentation".into());
|
||
let ext = if format == "pptx" { "pptx" } else { "deckcraft" };
|
||
let suggested = format!("{name}.{ext}");
|
||
if let Some(pick) = self.services.pick_save.as_mut() {
|
||
if let Some(path) = pick(&suggested) {
|
||
match self.session.execute("file.saveAs", &json!({"path": path})) {
|
||
Ok(_) => {
|
||
self.set_status(format!("Saved {path}"));
|
||
self.ui.recent.retain(|p| *p != path);
|
||
self.ui.recent.insert(0, path);
|
||
}
|
||
Err(e) => self.set_status(e.to_string()),
|
||
}
|
||
}
|
||
} else if let Some(dl) = self.services.download.as_mut()
|
||
&& let Some(d) = self.session.active()
|
||
{
|
||
match deckcraft_engine::cmd::file::save_bytes(&d.doc, ext) {
|
||
Ok(bytes) => dl(&suggested, &bytes),
|
||
Err(e) => self.set_status(e.to_string()),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Save every presentation with unsaved changes (asking for a location where needed).
|
||
/// Returns false if one wasn't saved (cancelled or failed).
|
||
pub fn save_all(&mut self) -> bool {
|
||
let dirty: Vec<usize> = self.session.documents().iter().enumerate().filter(|(_, d)| d.is_dirty()).map(|(i, _)| i).collect();
|
||
for i in dirty {
|
||
self.session.set_active(i);
|
||
self.save();
|
||
if self.session.documents().get(i).is_some_and(|d| d.is_dirty()) {
|
||
return false;
|
||
}
|
||
}
|
||
true
|
||
}
|
||
|
||
pub fn save(&mut self) {
|
||
if self.session.active().and_then(|d| d.path.clone()).is_some() {
|
||
match self.session.execute("file.save", &json!({})) {
|
||
Ok(_) => self.set_status("Saved"),
|
||
Err(e) => self.set_status(e.to_string()),
|
||
}
|
||
} else {
|
||
self.save_as_dialog("deckcraft");
|
||
}
|
||
}
|
||
|
||
/// Act on requests commands left for the UI.
|
||
fn drain_requests(&mut self) {
|
||
for r in std::mem::take(&mut self.session.ui_requests) {
|
||
match r {
|
||
UiRequest::Dialog { id, params } => {
|
||
let mut d = dialogs::Dialog::new(&id);
|
||
d.params = params;
|
||
self.dialog = Some(d);
|
||
}
|
||
UiRequest::Pane { id } => self.ui.pane = Some(id),
|
||
UiRequest::StartShow { from } => self.start_show(from, false),
|
||
UiRequest::Message { text } => self.set_status(text),
|
||
UiRequest::PickFile { purpose } => {
|
||
if purpose == "saveAs" {
|
||
self.save_as_dialog("deckcraft");
|
||
}
|
||
}
|
||
UiRequest::Media { action, shape, ms } => {
|
||
let owner = if self.show.is_some() { media::Owner::Show } else { media::Owner::Editor };
|
||
if let Some((uid, doc)) = self.session.active().map(|d| (d.uid, d.doc.clone())) {
|
||
self.media.request(uid, &doc, &action, shape, ms, owner);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn drain_inbox(&mut self) {
|
||
let Some(inbox) = self.services.inbox.clone() else { return };
|
||
let files: Vec<(String, Vec<u8>)> = inbox.lock().map(|mut v| std::mem::take(&mut *v)).unwrap_or_default();
|
||
for (name, bytes) in files {
|
||
self.open_or_insert_bytes(&name, &bytes);
|
||
}
|
||
}
|
||
|
||
/// A dropped or picked file: presentations open, media is inserted.
|
||
pub fn open_or_insert_bytes(&mut self, name: &str, bytes: &[u8]) {
|
||
let lower = name.to_ascii_lowercase();
|
||
let data = deckcraft_engine::cmd::base64_encode(bytes);
|
||
let ct = deckcraft_engine::cmd::insert::content_type(name, bytes);
|
||
let cmd = if lower.ends_with(".deckcraft")
|
||
|| lower.ends_with(".slidecraft")
|
||
|| lower.ends_with(".pptx")
|
||
|| lower.ends_with(".potx")
|
||
|| lower.ends_with(".ppsx")
|
||
{
|
||
"file.openBytes"
|
||
} else if ct.starts_with("image/") {
|
||
"insert.picture"
|
||
} else if ct.starts_with("audio/") {
|
||
"insert.audio"
|
||
} else if ct.starts_with("video/") {
|
||
"insert.video"
|
||
} else if lower.ends_with(".txt") || lower.ends_with(".md") {
|
||
"slide.fromOutline"
|
||
} else {
|
||
self.set_status(format!("{name}: DeckCraft can't open this kind of file"));
|
||
return;
|
||
};
|
||
let p = if cmd == "slide.fromOutline" {
|
||
json!({"text": String::from_utf8_lossy(bytes), "markdown": lower.ends_with(".md")})
|
||
} else {
|
||
json!({"name": name, "data": data})
|
||
};
|
||
if self.session.active().is_none() && cmd != "file.openBytes" {
|
||
let _ = self.session.execute("file.new", &json!({}));
|
||
}
|
||
match self.session.execute(cmd, &p) {
|
||
Err(e) if cmd == "file.openBytes" => self.notify(e.to_string()),
|
||
Err(e) => self.set_status(e.to_string()),
|
||
Ok(_) => {}
|
||
}
|
||
}
|
||
|
||
/// Per-frame logic before layout: styles, control requests, screenshots, shortcuts.
|
||
pub fn logic(&mut self, ctx: &egui::Context) {
|
||
let scale = self.ui.ui_scale.clamp(0.5, 3.0);
|
||
if (ctx.zoom_factor() - scale).abs() > 1e-3 {
|
||
ctx.set_zoom_factor(scale);
|
||
}
|
||
if !self.styled {
|
||
theme::install_fonts_with(ctx, &self.ui_fonts.faces);
|
||
self.styled = true;
|
||
self.restyle = true;
|
||
} else {
|
||
self.fonts_ready = true;
|
||
}
|
||
if self.restyle {
|
||
theme::apply(ctx, &theme::Tokens::for_brightness(self.ui.brightness));
|
||
self.restyle = false;
|
||
}
|
||
let now = ctx.input(|i| i.time);
|
||
let dt = now - self.last_time;
|
||
if dt > 0.0 {
|
||
self.perf.fps = self.perf.fps * 0.9 + (1.0 / dt).min(240.0) * 0.1;
|
||
}
|
||
self.last_time = now;
|
||
self.drain_control(ctx);
|
||
if self.fonts_ready {
|
||
self.drain_inbox();
|
||
}
|
||
if !self.synthetic.is_empty() {
|
||
ctx.request_repaint();
|
||
}
|
||
if self.fonts_ready {
|
||
self.note_ui_text(ctx);
|
||
}
|
||
self.collect_screenshots(ctx);
|
||
self.issue_screenshots(ctx);
|
||
// Closing the window with unsaved changes asks first.
|
||
if ctx.input(|i| i.viewport().close_requested()) && !self.quit_confirmed && self.session.documents().iter().any(|d| d.is_dirty()) {
|
||
ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
|
||
self.show = None;
|
||
if self.dialog.as_ref().is_none_or(|d| d.id != "quit") {
|
||
self.dialog = Some(dialogs::Dialog::new("quit"));
|
||
}
|
||
}
|
||
// AutoRecover: unsaved presentations are written to the recovery folder periodically.
|
||
if self.session.recovery_dir.is_some() && now - self.last_recovery > (self.session.prefs.recovery_minutes * 60.0).max(10.0) {
|
||
self.last_recovery = now;
|
||
if self.session.documents().iter().any(|d| d.is_dirty())
|
||
&& let Err(e) = self.session.execute("file.recovery.save", &json!({}))
|
||
{
|
||
self.set_status(format!("Couldn't save AutoRecover information: {e}"));
|
||
}
|
||
}
|
||
// On the web, dropped files can only be read asynchronously: the host reads them and
|
||
// delivers them through `Services::inbox`.
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
for f in ctx.input(|i| i.raw.dropped_files.clone()) {
|
||
let name = f.path().file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped file".into());
|
||
match f.bytes() {
|
||
Ok(bytes) => self.open_or_insert_bytes(&name, &bytes),
|
||
Err(e) => self.set_status(e),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Borrow faces for interface text in scripts the interface fonts lack (#101): the open
|
||
/// presentations' names and text, recent files, and what is typed or composed this frame.
|
||
fn note_ui_text(&mut self, ctx: &egui::Context) {
|
||
let typed: String = ctx.input(|i| {
|
||
i.events
|
||
.iter()
|
||
.filter_map(|e| match e {
|
||
egui::Event::Text(t) | egui::Event::Paste(t) => Some(t.as_str()),
|
||
egui::Event::Ime(egui::ImeEvent::Preedit { text, .. } | egui::ImeEvent::Commit(text)) => Some(text.as_str()),
|
||
_ => None,
|
||
})
|
||
.collect()
|
||
});
|
||
self.ui_fonts.note(ctx, &typed);
|
||
for d in self.session.documents() {
|
||
self.ui_fonts.note(ctx, &d.title());
|
||
}
|
||
for r in &self.ui.recent {
|
||
self.ui_fonts.note(ctx, r);
|
||
}
|
||
if let Some(st) = self.session.active() {
|
||
self.ui_fonts.note_doc(ctx, st);
|
||
}
|
||
self.ui_fonts.apply(ctx);
|
||
}
|
||
|
||
/// An input method's event for the slide's text (#101): the preedit is shown in the text and
|
||
/// replaced on each update; the commit replaces it as one undo step.
|
||
fn ime_event(&mut self, e: &egui::ImeEvent) {
|
||
let r = match e {
|
||
egui::ImeEvent::Preedit { text, active_range_chars } => {
|
||
self.session.compose_text(text, active_range_chars.as_ref().map(|r| (r.start, r.end)))
|
||
}
|
||
egui::ImeEvent::Commit(text) => self.session.commit_text(text),
|
||
#[allow(deprecated)]
|
||
egui::ImeEvent::Disabled => {
|
||
self.session.end_composition();
|
||
Ok(Value::Null)
|
||
}
|
||
_ => Ok(Value::Null),
|
||
};
|
||
if let Err(e) = r {
|
||
self.set_status(e.to_string());
|
||
}
|
||
}
|
||
|
||
/// Inject synthetic events (one pointer event per frame).
|
||
pub fn raw_input_hook(&mut self, raw: &mut egui::RawInput) {
|
||
if self.synthetic.is_empty() {
|
||
return;
|
||
}
|
||
let n = match self.synthetic.first() {
|
||
Some(egui::Event::PointerMoved(_) | egui::Event::PointerButton { .. }) => 1,
|
||
_ => self.synthetic.iter().position(|e| matches!(e, egui::Event::Key { pressed: false, .. })).map_or(self.synthetic.len(), |i| i + 1),
|
||
};
|
||
if let Some(egui::Event::PointerMoved(p) | egui::Event::PointerButton { pos: p, .. }) = self.synthetic.first() {
|
||
raw.events.push(egui::Event::PointerMoved(*p));
|
||
}
|
||
let n = n.min(self.synthetic.len());
|
||
raw.events.extend(self.synthetic.drain(..n));
|
||
}
|
||
|
||
/// Keyboard and clipboard for the slide (when no text field has focus).
|
||
fn keyboard(&mut self, ctx: &egui::Context) {
|
||
if ctx.memory(|m| m.focused().is_some()) || self.dialog.as_ref().is_some_and(|d| d.modal()) || self.palette.is_some() {
|
||
return;
|
||
}
|
||
let events = ctx.input(|i| i.events.clone());
|
||
if self.backstage.is_some() {
|
||
// The File tab: its own keys (Esc goes back, arrows walk the side menu) and app
|
||
// shortcuts (New, Open, Command Palette…); typing, pasting or deleting would edit the
|
||
// hidden presentation.
|
||
for e in events {
|
||
if let egui::Event::Key { key, pressed: true, modifiers, .. } = e {
|
||
let mods = Mods { shift: modifiers.shift, alt: modifiers.alt, cmd: modifiers.command || modifiers.ctrl };
|
||
if backstage::key(self, key, mods) || !(mods.cmd || mods.alt) || menus::ui_shortcut(self, key, mods) {
|
||
continue;
|
||
}
|
||
// Engine shortcuts that don't touch the hidden slide (Ctrl+N).
|
||
if mods.cmd
|
||
&& matches!(key, egui::Key::N)
|
||
&& let Err(e) = self.session.key(key_name(key), mods)
|
||
{
|
||
self.set_status(e.to_string());
|
||
}
|
||
}
|
||
}
|
||
self.drain_requests();
|
||
return;
|
||
}
|
||
for e in events {
|
||
match e {
|
||
egui::Event::Text(t) => {
|
||
if self.session.active().is_some_and(|d| d.selection.text.is_some() || d.selection.shapes.len() == 1)
|
||
&& let Err(e) = self.session.type_text(&t)
|
||
{
|
||
self.set_status(e.to_string());
|
||
}
|
||
}
|
||
egui::Event::Ime(ime) => self.ime_event(&ime),
|
||
egui::Event::Copy => {
|
||
if let Ok(v) = self.session.execute("edit.copy", &json!({}))
|
||
&& let Some(t) = v.get("text").and_then(Value::as_str)
|
||
{
|
||
ctx.copy_text(system_clipboard_text(t));
|
||
}
|
||
}
|
||
egui::Event::Cut => {
|
||
if let Ok(v) = self.session.execute("edit.cut", &json!({}))
|
||
&& let Some(t) = v.get("text").and_then(Value::as_str)
|
||
{
|
||
ctx.copy_text(system_clipboard_text(t));
|
||
}
|
||
}
|
||
egui::Event::Paste(text) => {
|
||
// Our own marker for objects without text: paste what the session copied.
|
||
let text = if text == OBJECTS_MARKER { String::new() } else { text };
|
||
// An image on the clipboard (screenshots, copied pictures) becomes a picture.
|
||
let img = if text.is_empty() { self.services.clipboard_image.as_mut().and_then(|f| f()) } else { None };
|
||
let r = match img {
|
||
Some(png) => self
|
||
.session
|
||
.execute("insert.picture", &json!({"name": "Pasted image.png", "data": deckcraft_engine::cmd::base64_encode(&png)})),
|
||
None => self.session.execute("edit.paste", &json!({"text": text})),
|
||
};
|
||
if let Err(e) = r {
|
||
self.set_status(e.to_string());
|
||
}
|
||
}
|
||
egui::Event::Key { key, pressed: true, modifiers, .. } => {
|
||
let mods = Mods { shift: modifiers.shift, alt: modifiers.alt, cmd: modifiers.command || modifiers.ctrl };
|
||
if !self.session.tool.drawing_freeform() && menus::ui_shortcut(self, key, mods) {
|
||
continue;
|
||
}
|
||
let name = key_name(key);
|
||
match self.session.key(name, mods) {
|
||
Ok(_) => {}
|
||
Err(e) => self.set_status(e.to_string()),
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
self.drain_requests();
|
||
}
|
||
|
||
/// Lay out the whole window.
|
||
pub fn ui(&mut self, ui: &mut egui::Ui) {
|
||
let ctx = ui.ctx().clone();
|
||
if !self.fonts_ready {
|
||
ctx.request_repaint();
|
||
return;
|
||
}
|
||
let t0 = now_ms();
|
||
let t = theme::Tokens::get(&ctx);
|
||
self.tick_media(&ctx);
|
||
eyedropper::tick(self, &ctx);
|
||
if self.show.is_some() {
|
||
show::ui(self, ui);
|
||
doc_window::show(self, &ctx);
|
||
self.perf.frame_ms = now_ms() - t0;
|
||
return;
|
||
}
|
||
self.sync_backstage();
|
||
self.keyboard(&ctx);
|
||
self.sync_backstage();
|
||
ribbon::title_bar(self, ui);
|
||
if self.backstage.is_none() && self.session.active().is_some() {
|
||
ribbon::show(self, ui);
|
||
status::status_bar(self, ui);
|
||
}
|
||
egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.chrome)).show(ui, |ui| {
|
||
if self.backstage.is_some() {
|
||
// File tab: the Backstage view replaces everything below the title bar.
|
||
backstage::show(self, ui);
|
||
return;
|
||
}
|
||
if self.session.active().is_none() {
|
||
return;
|
||
}
|
||
match self.ui.view {
|
||
ViewMode::Sorter => sorter::show(self, ui),
|
||
ViewMode::NotesPage => sorter::notes_page(self, ui),
|
||
ViewMode::Outline | ViewMode::Normal | ViewMode::Reading => {
|
||
if self.ui.pane.is_some() {
|
||
panes::show(self, ui);
|
||
}
|
||
if self.ui.view == ViewMode::Outline {
|
||
sorter::outline_pane(self, ui);
|
||
} else {
|
||
thumbs::show(self, ui);
|
||
}
|
||
egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.canvas)).show(ui, |ui| {
|
||
if self.ui.notes {
|
||
status::notes_pane(self, ui);
|
||
}
|
||
canvas::show(self, ui);
|
||
});
|
||
}
|
||
}
|
||
});
|
||
toast::note_missing_fonts(self);
|
||
toast::show(self, &ctx);
|
||
dialogs::show(self, &ctx);
|
||
menus::palette(self, &ctx);
|
||
for url in std::mem::take(&mut self.pending_urls) {
|
||
ctx.open_url(egui::OpenUrl::new_tab(url));
|
||
}
|
||
if let Some(t) = self.pending_copy.take() {
|
||
ctx.copy_text(t);
|
||
}
|
||
self.drain_requests();
|
||
doc_window::show(self, &ctx);
|
||
self.perf.frame_ms = now_ms() - t0;
|
||
}
|
||
|
||
/// Media clocks and video textures. Voices belong to the open presentation: closing the last
|
||
/// one, or switching decks, stops them. The editor's media also stops when its slide is left.
|
||
fn tick_media(&mut self, ctx: &egui::Context) {
|
||
let uid = self.session.active().map(|d| d.uid);
|
||
self.media.set_document(uid);
|
||
if !self.media.any_active() {
|
||
self.session.media_status.clear();
|
||
return;
|
||
}
|
||
if self.show.is_none()
|
||
&& let Some(d) = self.session.active()
|
||
{
|
||
let here: Vec<deckcraft_model::ShapeId> = if d.selection.target == deckcraft_engine::Target::Slides {
|
||
media::slide_media(&d.doc, d.selection.slide).into_iter().map(|m| m.0).collect()
|
||
} else {
|
||
vec![]
|
||
};
|
||
let gone: Vec<_> =
|
||
self.media.ids().into_iter().filter(|id| !here.contains(id) && self.media.owner(*id) == Some(media::Owner::Editor)).collect();
|
||
for id in gone {
|
||
self.media.stop(id);
|
||
}
|
||
}
|
||
self.media.tick(ctx, &mut self.session);
|
||
}
|
||
|
||
pub fn open_url(&mut self, url: &str) {
|
||
self.pending_urls.push(url.to_string());
|
||
}
|
||
|
||
fn drain_control(&mut self, ctx: &egui::Context) {
|
||
let Some(rx) = self.control_rx.take() else { return };
|
||
while let Ok(req) = rx.try_recv() {
|
||
let reply = req.reply.clone();
|
||
match control::handle(self, ctx, &req) {
|
||
control::Outcome::Done(v) => {
|
||
let _ = reply.send(v);
|
||
}
|
||
control::Outcome::Screenshot { path } => {
|
||
self.shot_token += 1;
|
||
let token = self.shot_token;
|
||
self.queued_shots.push((token, now_ms() + 120.0, 0));
|
||
self.pending_shots.push((token, path, reply, now_ms() + 8000.0));
|
||
}
|
||
}
|
||
}
|
||
self.control_rx = Some(rx);
|
||
}
|
||
|
||
fn issue_screenshots(&mut self, ctx: &egui::Context) {
|
||
let now = now_ms();
|
||
self.queued_shots.retain_mut(|(token, at, frames)| {
|
||
*frames += 1;
|
||
if now >= *at && *frames >= 3 {
|
||
ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(egui::UserData::new(*token)));
|
||
false
|
||
} else {
|
||
true
|
||
}
|
||
});
|
||
if !self.queued_shots.is_empty() || !self.pending_shots.is_empty() {
|
||
ctx.request_repaint_after(std::time::Duration::from_millis(16));
|
||
}
|
||
}
|
||
|
||
fn collect_screenshots(&mut self, ctx: &egui::Context) {
|
||
if self.pending_shots.is_empty() {
|
||
return;
|
||
}
|
||
let events: Vec<_> = ctx.input(|i| {
|
||
i.raw
|
||
.events
|
||
.iter()
|
||
.filter_map(|e| match e {
|
||
egui::Event::Screenshot { user_data, image, .. } => {
|
||
let token = user_data.data.as_ref().and_then(|d| d.downcast_ref::<u64>()).copied()?;
|
||
Some((token, image.clone()))
|
||
}
|
||
_ => None,
|
||
})
|
||
.collect()
|
||
});
|
||
for (token, image) in events {
|
||
if let Some(i) = self.pending_shots.iter().position(|(t, ..)| *t == token) {
|
||
let (_, path, reply, _) = self.pending_shots.remove(i);
|
||
let _ = reply.send(control::save_screenshot(self, &image, path.as_deref()));
|
||
}
|
||
}
|
||
let now = now_ms();
|
||
self.pending_shots.retain(|(_, _, reply, deadline)| {
|
||
if now < *deadline {
|
||
return true;
|
||
}
|
||
let _ = reply.send(json!({"ok": false, "error": "no frame was presented (screen locked or window hidden); use ui.render"}));
|
||
false
|
||
});
|
||
}
|
||
}
|
||
|
||
/// Engine key name for an egui key.
|
||
pub fn key_name(key: egui::Key) -> &'static str {
|
||
use egui::Key::*;
|
||
match key {
|
||
Enter => "Enter",
|
||
Escape => "Escape",
|
||
Backspace => "Backspace",
|
||
Delete => "Delete",
|
||
Tab => "Tab",
|
||
ArrowLeft => "Left",
|
||
ArrowRight => "Right",
|
||
ArrowUp => "Up",
|
||
ArrowDown => "Down",
|
||
Home => "Home",
|
||
End => "End",
|
||
PageUp => "PageUp",
|
||
PageDown => "PageDown",
|
||
Space => "Space",
|
||
F2 => "F2",
|
||
F5 => "F5",
|
||
F7 => "F7",
|
||
other => other.name(),
|
||
}
|
||
}
|
||
|
||
pub fn now_ms() -> f64 {
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
{
|
||
use std::time::{SystemTime, UNIX_EPOCH};
|
||
SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs_f64() * 1000.0).unwrap_or(0.0)
|
||
}
|
||
#[cfg(target_arch = "wasm32")]
|
||
{
|
||
js_now()
|
||
}
|
||
}
|
||
|
||
#[cfg(target_arch = "wasm32")]
|
||
fn js_now() -> f64 {
|
||
js_sys::Date::now()
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod animpane_tests;
|
||
#[cfg(test)]
|
||
mod browsetheme_tests;
|
||
#[cfg(test)]
|
||
mod eyedropper_tests;
|
||
#[cfg(test)]
|
||
mod huge_deck_tests;
|
||
#[cfg(test)]
|
||
mod ime_tests;
|
||
#[cfg(test)]
|
||
mod replacefonts_tests;
|
||
#[cfg(test)]
|
||
mod slide_size_tests;
|
||
#[cfg(test)]
|
||
mod ui_soak_tests;
|
||
|
||
#[cfg(test)]
|
||
#[path = "datetime_tests.rs"]
|
||
mod datetime_tests;
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
#![allow(clippy::unwrap_used, clippy::expect_used)]
|
||
|
||
use super::*;
|
||
|
||
fn title_text(app: &SlideApp) -> String {
|
||
let d = app.session.active().unwrap();
|
||
let sh = &d.doc.slides[0].shapes[0];
|
||
sh.text.as_ref().map(|t| t.paragraphs.iter().map(|p| p.text()).collect::<Vec<_>>().join("\n")).unwrap_or_default()
|
||
}
|
||
|
||
#[test]
|
||
fn quick_access_toolbar_adds_removes_resets_and_persists() {
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
let ids = |app: &SlideApp| app.ui.qat.iter().map(|q| q.id.clone()).collect::<Vec<_>>();
|
||
assert_eq!(ids(harness.state()), ["app.home", "file.save", "app.exportDialog", "edit.undo", "edit.redo", "show.fromStart"]);
|
||
let app = harness.state_mut();
|
||
app.run("app.qat", json!({"add": "insert.table", "label": "Table", "icon": "table"})).unwrap();
|
||
app.run("app.qat", json!({"add": "insert.table"})).unwrap();
|
||
app.run("app.qat", json!({"add": "view.pane", "params": {"pane": "selection"}, "label": "Selection Pane"})).unwrap();
|
||
assert!(app.run("app.qat", json!({"add": "no.such"})).is_err());
|
||
app.run("app.qat", json!({"remove": "edit.redo"})).unwrap();
|
||
assert_eq!(ids(app), ["app.home", "file.save", "app.exportDialog", "edit.undo", "show.fromStart", "insert.table", "view.pane"]);
|
||
assert_eq!(app.ui.qat[5].label, "Table");
|
||
// Saved with the rest of the UI state and read back.
|
||
let back: UiState = serde_json::from_value(serde_json::to_value(&app.ui).unwrap()).unwrap();
|
||
assert_eq!(back.qat, app.ui.qat);
|
||
harness.run_steps(2);
|
||
let app = harness.state_mut();
|
||
app.run("app.qat", json!({"remove": "view.pane", "params": {"pane": "selection"}})).unwrap();
|
||
assert_eq!(app.ui.qat.len(), 6);
|
||
app.run("app.qat", json!({"reset": true})).unwrap();
|
||
assert_eq!(ids(app), ["app.home", "file.save", "app.exportDialog", "edit.undo", "edit.redo", "show.fromStart"]);
|
||
// An older settings file without the toolbar gets the defaults.
|
||
let old: UiState = serde_json::from_value(json!({"tab": "Home"})).unwrap();
|
||
assert_eq!(old.qat.len(), 6);
|
||
}
|
||
|
||
#[test]
|
||
fn opening_a_file_with_missing_fonts_shows_a_toast_once() {
|
||
use egui_kittest::kittest::Queryable;
|
||
let mut p = deckcraft_model::Presentation::default();
|
||
let slide = std::sync::Arc::make_mut(&mut p.slides[0]);
|
||
let mut body = deckcraft_model::text::TextBody::from_text("Hello");
|
||
body.paragraphs[0].runs[0].props.font = Some("Qqq Nonexistent Sans".into());
|
||
slide.shapes[0].text = Some(body);
|
||
let data = deckcraft_engine::cmd::base64_encode(&deckcraft_engine::cmd::file::save_bytes(&p, "pptx").unwrap());
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
assert!(harness.state().toast.is_none(), "a new presentation has nothing to say");
|
||
harness.state_mut().session.execute("file.openBytes", &json!({"name": "a.pptx", "data": data})).unwrap();
|
||
harness.run_steps(2);
|
||
let text = harness.state().toast.as_ref().map(|t| t.text.clone()).unwrap_or_default();
|
||
assert!(text.starts_with("Qqq Nonexistent Sans isn't installed"), "{text}");
|
||
assert!(harness.query_by_label_contains("Qqq Nonexistent Sans isn't installed").is_some());
|
||
// Closed, it stays closed for that document.
|
||
harness.get_by_label("Close").click();
|
||
harness.run_steps(2);
|
||
assert!(harness.state().toast.is_none());
|
||
harness.run_steps(2);
|
||
assert!(harness.state().toast.is_none());
|
||
}
|
||
|
||
/// #17: Home created a new blank presentation instead of going to the start screen.
|
||
#[test]
|
||
fn home_shows_the_start_screen_over_the_open_presentation() {
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
// The app keeps requesting repaints, so step frames instead of run().
|
||
harness.run_steps(2);
|
||
let title = harness.state().session.active().unwrap().doc.slides[0].shapes[0].id.0;
|
||
harness.state_mut().session.execute("text.edit", &json!({"id": title})).unwrap();
|
||
|
||
harness.state_mut().run("app.home", json!({})).unwrap();
|
||
harness.run_steps(2);
|
||
assert!(harness.state().backstage_open());
|
||
assert_eq!(harness.state().session.documents().len(), 1, "Home doesn't create a presentation");
|
||
|
||
// Typing on the start screen doesn't reach the presentation behind it; Escape goes back.
|
||
harness.event(egui::Event::Text("a".into()));
|
||
harness.key_press(egui::Key::Backspace);
|
||
harness.run_steps(2);
|
||
assert_eq!(title_text(harness.state()), "");
|
||
assert!(!harness.state().session.active().unwrap().is_dirty());
|
||
harness.key_press(egui::Key::Escape);
|
||
harness.run_steps(2);
|
||
assert!(!harness.state().backstage_open());
|
||
|
||
// Home again toggles; picking a theme on the start screen (a new presentation) leaves it.
|
||
harness.state_mut().run("app.home", json!({})).unwrap();
|
||
harness.run_steps(2);
|
||
assert!(harness.state().backstage_open());
|
||
harness.state_mut().run("app.home", json!({})).unwrap();
|
||
assert!(!harness.state().backstage_open());
|
||
harness.state_mut().run("app.home", json!({"on": true})).unwrap();
|
||
harness.state_mut().run("file.new", json!({})).unwrap();
|
||
harness.run_steps(2);
|
||
assert!(!harness.state().backstage_open(), "a new presentation leaves Home");
|
||
assert_eq!(harness.state().session.documents().len(), 2);
|
||
}
|
||
|
||
/// #268: Ctrl+Backspace, Ctrl+Delete, Ctrl+arrows and Ctrl+Shift+arrows in text, through real
|
||
/// egui key events (Windows keys).
|
||
#[test]
|
||
fn ctrl_word_keys_edit_text() {
|
||
use egui::{Key, Modifiers};
|
||
let mut session = Session::with_new();
|
||
session.mac_keys = false;
|
||
session.prefs.autocorrect = false;
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(session, Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
let title = harness.state().session.active().unwrap().doc.slides[0].shapes[0].id.0;
|
||
harness.state_mut().session.execute("text.edit", &json!({"id": title})).unwrap();
|
||
harness.event(egui::Event::Text("Hello, world. Foo bar".into()));
|
||
harness.run_steps(1);
|
||
assert_eq!(title_text(harness.state()), "Hello, world. Foo bar");
|
||
let caret = |h: &egui_kittest::Harness<'_, SlideApp>| h.state().session.active().unwrap().selection.text.clone().unwrap();
|
||
let ctrl = Modifiers::COMMAND;
|
||
let ctrl_shift = Modifiers::COMMAND | Modifiers::SHIFT;
|
||
|
||
// Ctrl+Left stops at every word and punctuation run, as in PowerPoint.
|
||
let mut stops = vec![];
|
||
for _ in 0..6 {
|
||
harness.key_press_modifiers(ctrl, Key::ArrowLeft);
|
||
harness.run_steps(1);
|
||
stops.push(caret(&harness).caret.1);
|
||
}
|
||
assert_eq!(stops, vec![19, 15, 12, 7, 5, 0]);
|
||
harness.key_press_modifiers(ctrl, Key::ArrowRight);
|
||
harness.run_steps(1);
|
||
assert_eq!(caret(&harness).caret, (0, 5));
|
||
|
||
// Ctrl+Shift+Right selects to the next stops.
|
||
harness.key_press_modifiers(ctrl_shift, Key::ArrowRight);
|
||
harness.key_press_modifiers(ctrl_shift, Key::ArrowRight);
|
||
harness.run_steps(1);
|
||
let t = caret(&harness);
|
||
assert_eq!((t.anchor, t.caret), ((0, 5), (0, 12)));
|
||
|
||
// Ctrl+Delete deletes the next word from the selection's start; Ctrl+Backspace the one
|
||
// before the caret.
|
||
harness.key_press_modifiers(ctrl, Key::Delete);
|
||
harness.run_steps(1);
|
||
assert_eq!(title_text(harness.state()), "Helloworld. Foo bar");
|
||
harness.key_press(Key::End);
|
||
harness.key_press_modifiers(ctrl, Key::Backspace);
|
||
harness.run_steps(1);
|
||
assert_eq!(title_text(harness.state()), "Helloworld. Foo ");
|
||
|
||
// Ctrl+Up/Down go by paragraph, Ctrl+Home/End to the text's ends.
|
||
harness.key_press(Key::Enter);
|
||
harness.event(egui::Event::Text("Next".into()));
|
||
harness.key_press_modifiers(ctrl, Key::ArrowUp);
|
||
harness.run_steps(1);
|
||
assert_eq!(caret(&harness).caret, (1, 0));
|
||
harness.key_press_modifiers(ctrl, Key::ArrowUp);
|
||
harness.run_steps(1);
|
||
assert_eq!(caret(&harness).caret, (0, 0));
|
||
harness.key_press_modifiers(ctrl, Key::ArrowDown);
|
||
harness.run_steps(1);
|
||
assert_eq!(caret(&harness).caret, (1, 0));
|
||
harness.key_press_modifiers(ctrl_shift, Key::Home);
|
||
harness.run_steps(1);
|
||
let t = caret(&harness);
|
||
assert_eq!((t.anchor, t.caret), ((1, 0), (0, 0)));
|
||
|
||
// Ctrl+Shift+> (egui reports the Period key) grows the selected text's font.
|
||
let size = |h: &mut egui_kittest::Harness<'_, SlideApp>| h.state_mut().session.execute("format.state", &json!({})).unwrap()["size"].as_f64();
|
||
let before = size(&mut harness);
|
||
harness.key_press_modifiers(ctrl_shift, Key::Period);
|
||
harness.run_steps(1);
|
||
let after = size(&mut harness).unwrap();
|
||
assert!(after > before.unwrap_or(0.0), "{before:?} → {after}");
|
||
harness.key_press_modifiers(ctrl, Key::OpenBracket);
|
||
harness.run_steps(1);
|
||
assert!(size(&mut harness).unwrap_or(f64::MAX) < after, "Ctrl+[ shrinks");
|
||
}
|
||
|
||
/// Export… had no visible control: only the command palette reached it.
|
||
#[test]
|
||
fn title_bar_export_opens_the_export_dialog() {
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
assert!(harness.state().dialog.is_none());
|
||
// Quick access: Home, Save, Export, each 24 points wide with 2 between, from x = 10.
|
||
let pos = egui::pos2(10.0 + 2.0 * 26.0 + 12.0, ribbon::TITLE_H / 2.0);
|
||
harness.hover_at(pos);
|
||
harness.run_steps(1);
|
||
harness.event(egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE });
|
||
harness.event(egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE });
|
||
harness.run_steps(2);
|
||
assert_eq!(harness.state().dialog.as_ref().map(|d| d.id.as_str()), Some("export"));
|
||
}
|
||
|
||
#[test]
|
||
fn home_needs_an_open_presentation() {
|
||
let mut app = SlideApp::new(Session::new(), Services::default());
|
||
app.run("app.home", json!({})).unwrap();
|
||
assert!(!app.backstage_open(), "with nothing open the start screen shows anyway");
|
||
}
|
||
|
||
/// View › New Window is a second window on the open presentation. Its slide is its own;
|
||
/// the editor's selection stays where it was. Closing the window leaves the document open.
|
||
#[test]
|
||
fn new_window_shows_the_same_document_on_its_own_slide() {
|
||
let mut app = SlideApp::new(Session::with_new(), Services::default());
|
||
app.session.execute("slide.new", &json!({})).unwrap();
|
||
app.session.execute("slide.go", &json!({"index": 1})).unwrap();
|
||
let err = {
|
||
let mut empty = SlideApp::new(Session::new(), Services::default());
|
||
empty.run("view.newWindow", json!({})).unwrap_err()
|
||
};
|
||
assert!(err.contains("presentation"), "{err}");
|
||
|
||
let name = app.session.active().unwrap().title();
|
||
let opened = app.run("view.newWindow", json!({})).unwrap();
|
||
assert_eq!(opened["open"], true);
|
||
assert_eq!(opened["window"], 2);
|
||
assert_eq!(opened["slide"], 1);
|
||
assert_eq!(opened["title"], format!("{name}:2"));
|
||
assert_eq!(app.session.active().unwrap().selection.slide, 1);
|
||
|
||
let moved = app.run("view.newWindow", json!({"delta": -1})).unwrap();
|
||
assert_eq!(moved["slide"], 0);
|
||
assert_eq!(app.doc_window.as_ref().unwrap().slide, 0);
|
||
assert_eq!(app.session.active().unwrap().selection.slide, 1, "the editor stays on its slide");
|
||
|
||
let again = app.run("view.newWindow", json!({})).unwrap();
|
||
assert_eq!(again["window"], 2);
|
||
assert_eq!(again["slide"], 0, "opening again keeps the window's slide");
|
||
|
||
app.session.execute("file.close", &json!({})).unwrap();
|
||
doc_window::show(&mut app, &egui::Context::default());
|
||
assert!(app.doc_window.is_none(), "closing the presentation closes the extra window");
|
||
assert!(app.session.active().is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn grid_options_sets_spacing_and_display_or_opens_the_dialog() {
|
||
let mut app = SlideApp::new(Session::with_new(), Services::default());
|
||
assert!((app.session.prefs.grid_spacing - 6.0).abs() < 1e-9);
|
||
let v =
|
||
app.run("view.gridOptions", json!({"spacing": 72.0, "snap": false, "smartGuides": false, "gridlines": true, "guides": true})).unwrap();
|
||
assert_eq!(v["spacing"], 72.0);
|
||
assert_eq!(v["snap"], false);
|
||
assert_eq!(v["smartGuides"], false);
|
||
assert_eq!(v["gridlines"], true);
|
||
assert_eq!(v["guides"], true);
|
||
assert!(app.dialog.is_none());
|
||
assert!(app.ui.gridlines && app.ui.guides);
|
||
assert!(!app.session.prefs.snap_to_grid && !app.ui.smart_guides);
|
||
|
||
app.run("view.gridOptions", json!({"snap": true})).unwrap();
|
||
assert!(app.session.prefs.snap_to_grid);
|
||
assert!((app.session.prefs.grid_spacing - 72.0).abs() < 1e-9);
|
||
assert!(app.dialog.is_none());
|
||
|
||
for bad in [json!({"spacing": 0}), json!({"spacing": 289}), json!({"spacing": "72"}), json!({"spacing": null}), json!({"snap": 1})] {
|
||
assert!(app.run("view.gridOptions", bad).is_err(), "rejected a bad grid option");
|
||
}
|
||
assert!((app.session.prefs.grid_spacing - 72.0).abs() < 1e-9);
|
||
assert!(app.session.prefs.snap_to_grid);
|
||
|
||
app.run("view.gridOptions", json!({})).unwrap();
|
||
assert_eq!(app.dialog.as_ref().map(|d| d.id.as_str()), Some("gridOptions"));
|
||
assert!((app.session.prefs.grid_spacing - 72.0).abs() < 1e-9);
|
||
}
|
||
|
||
#[test]
|
||
fn grid_options_dialog_lists_spacing_and_display() {
|
||
use egui_kittest::kittest::Queryable;
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
harness.state_mut().run("view.gridOptions", json!({})).unwrap();
|
||
harness.run_steps(2);
|
||
assert!(harness.query_by_label_contains("Display grid on screen").is_some());
|
||
assert!(harness.query_by_label_contains("Snap objects to grid").is_some());
|
||
assert!(harness.query_by_label_contains("Spacing").is_some());
|
||
let show_grid = harness
|
||
.query_all_by_role_and_label(egui::accesskit::Role::CheckBox, "Display grid on screen")
|
||
.next()
|
||
.unwrap_or_else(|| panic!("no grid checkbox"));
|
||
show_grid.click_accesskit();
|
||
harness.run_steps(2);
|
||
harness.query_all_by_role_and_label(egui::accesskit::Role::Button, "OK").next().unwrap_or_else(|| panic!("no OK button")).click_accesskit();
|
||
harness.run_steps(2);
|
||
assert!(harness.state().dialog.is_none(), "OK closes Grid Options");
|
||
assert!(harness.state().ui.gridlines, "OK applies the grid checkbox");
|
||
assert!((harness.state().session.prefs.grid_spacing - 6.0).abs() < 1e-9);
|
||
|
||
harness.state_mut().run("view.gridOptions", json!({})).unwrap();
|
||
harness.run_steps(2);
|
||
harness
|
||
.query_all_by_role_and_label(egui::accesskit::Role::Button, "Cancel")
|
||
.next()
|
||
.unwrap_or_else(|| panic!("no Cancel button"))
|
||
.click_accesskit();
|
||
harness.run_steps(2);
|
||
assert!(harness.state().dialog.is_none(), "Cancel closes Grid Options");
|
||
assert!(harness.state().ui.gridlines, "Cancel leaves the grid on");
|
||
assert!((harness.state().session.prefs.grid_spacing - 6.0).abs() < 1e-9);
|
||
}
|
||
|
||
fn canvas_harness() -> egui_kittest::Harness<'static, SlideApp> {
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
let app = harness.state_mut();
|
||
// Zoomed out, the canvas shows plenty of pasteboard around the slide.
|
||
app.ui.zoom = Some(0.4);
|
||
app.session.prefs.snap_to_grid = false;
|
||
app.session.prefs.smart_guides = false;
|
||
harness
|
||
}
|
||
|
||
fn selected(app: &SlideApp) -> Vec<u64> {
|
||
app.session.active().unwrap().selection.shapes.iter().map(|i| i.0 as u64).collect()
|
||
}
|
||
|
||
fn shape_x(app: &SlideApp, id: u64) -> f64 {
|
||
let st = app.session.active().unwrap();
|
||
st.shape(deckcraft_model::ShapeId(id as u32)).and_then(|s| s.xfrm).unwrap().x
|
||
}
|
||
|
||
/// #270: PowerPoint's Normal view draws objects off the slide on the area around it, where
|
||
/// they can be selected and moved.
|
||
#[test]
|
||
fn off_slide_objects_show_on_the_pasteboard_and_can_be_selected_and_moved() {
|
||
let mut harness = canvas_harness();
|
||
let off =
|
||
harness.state_mut().session.execute("shape.insert", &json!({"preset": "rect", "rect": [1000.0, 100.0, 120.0, 80.0]})).unwrap()["id"]
|
||
.as_u64()
|
||
.unwrap();
|
||
harness.state_mut().session.execute("edit.select", &json!({"ids": []})).unwrap();
|
||
harness.run_steps(3);
|
||
|
||
let app = harness.state();
|
||
let (slide, region, k) = (app.slide_rect.unwrap(), app.canvas_region.unwrap(), app.canvas_scale);
|
||
// The texture reaches past the slide's right edge to the shape's, and no further left/up.
|
||
assert!(region.max.x >= slide.min.x + 1120.0 * k - 1.0, "{region:?} {slide:?}");
|
||
assert!((region.min.x - slide.min.x).abs() < 1.0 && (region.min.y - slide.min.y).abs() < 1.0, "{region:?} {slide:?}");
|
||
let centre = slide.min + egui::vec2(1060.0 * k, 140.0 * k);
|
||
assert!(app.canvas_rect.unwrap().contains(centre));
|
||
|
||
// Drawn at full strength on the pasteboard (when a GPU renderer is available here).
|
||
if let Ok(img) = harness.render() {
|
||
let px = |p: egui::Pos2| img.get_pixel(p.x as u32, p.y as u32).0;
|
||
let shape = px(centre);
|
||
let board = px(slide.min + egui::vec2(1060.0 * k, 400.0 * k));
|
||
let doc = &harness.state().session.active().unwrap().doc;
|
||
let accent = doc.masters[0].theme.colors.get(deckcraft_color::SchemeSlot::Accent1);
|
||
let close = |a: u8, b: u8| (a as i32 - b as i32).abs() <= 4;
|
||
assert!(close(shape[0], accent.r) && close(shape[1], accent.g) && close(shape[2], accent.b), "{shape:?} vs {accent:?}");
|
||
assert_ne!(shape, board);
|
||
}
|
||
|
||
// Click selects it.
|
||
harness.hover_at(centre);
|
||
harness.run_steps(1);
|
||
harness.drag_at(centre);
|
||
harness.run_steps(1);
|
||
harness.drop_at(centre);
|
||
harness.run_steps(2);
|
||
assert_eq!(selected(harness.state()), vec![off]);
|
||
|
||
// Drag moves it, further off the slide.
|
||
let to = centre + egui::vec2(40.0, 0.0);
|
||
harness.hover_at(centre);
|
||
harness.run_steps(1);
|
||
harness.drag_at(centre);
|
||
harness.run_steps(1);
|
||
for i in 1..=4 {
|
||
harness.hover_at(centre + egui::vec2(10.0 * i as f32, 0.0));
|
||
harness.run_steps(1);
|
||
}
|
||
harness.drop_at(to);
|
||
harness.run_steps(2);
|
||
let x = shape_x(harness.state(), off);
|
||
assert!((x - (1000.0 + 40.0 / k as f64)).abs() < 1.5, "{x}");
|
||
// The pasteboard followed it.
|
||
let (slide, region) = (harness.state().slide_rect.unwrap(), harness.state().canvas_region.unwrap());
|
||
assert!(region.max.x >= slide.min.x + (x as f32 + 120.0) * k - 1.0, "{region:?}");
|
||
|
||
// Idle frames don't render the canvas again.
|
||
let n = harness.state().textures.canvas_renders;
|
||
harness.run_steps(3);
|
||
assert_eq!(harness.state().textures.canvas_renders, n);
|
||
}
|
||
|
||
/// A slide with nothing off it renders just the slide, as before.
|
||
#[test]
|
||
fn the_canvas_renders_only_the_slide_when_nothing_is_off_it() {
|
||
let mut harness = canvas_harness();
|
||
harness.run_steps(3);
|
||
let app = harness.state();
|
||
let (slide, region) = (app.slide_rect.unwrap(), app.canvas_region.unwrap());
|
||
assert!((region.min - slide.min).length() < 0.5 && (region.max - slide.max).length() < 1.0, "{region:?} {slide:?}");
|
||
let n = app.textures.canvas_renders;
|
||
harness.run_steps(3);
|
||
assert_eq!(harness.state().textures.canvas_renders, n, "an unchanged slide isn't rendered again");
|
||
}
|
||
|
||
/// #431: the ribbon's Copy and Cut, the slide's context menu, the menus and the control
|
||
/// channel all run the commands; they put the text on the system clipboard, as Ctrl+C and
|
||
/// Ctrl+X do.
|
||
#[test]
|
||
fn copy_and_cut_commands_reach_the_system_clipboard() {
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
let copied = |h: &egui_kittest::Harness<'_, SlideApp>| {
|
||
h.output().platform_output.commands.iter().find_map(|c| match c {
|
||
egui::OutputCommand::CopyText(t) => Some(t.clone()),
|
||
_ => None,
|
||
})
|
||
};
|
||
let title = harness.state().session.active().unwrap().doc.slides[0].shapes[0].id.0;
|
||
harness.state_mut().session.execute("text.edit", &json!({"id": title})).unwrap();
|
||
harness.state_mut().session.type_text("Aurora").unwrap();
|
||
harness.state_mut().session.key("Escape", Mods::default()).unwrap();
|
||
harness.run_steps(1);
|
||
assert_eq!(copied(&harness), None);
|
||
|
||
harness.state_mut().run("edit.copy", json!({})).unwrap();
|
||
harness.run_steps(1);
|
||
assert_eq!(copied(&harness).as_deref(), Some("Aurora"), "Copy puts the text on the clipboard");
|
||
harness.run_steps(1);
|
||
assert_eq!(copied(&harness), None, "only once");
|
||
|
||
harness.state_mut().run("edit.cut", json!({})).unwrap();
|
||
harness.run_steps(1);
|
||
assert_eq!(copied(&harness).as_deref(), Some("Aurora"), "Cut does too");
|
||
assert!(harness.state().session.active().unwrap().doc.slides[0].shapes.iter().all(|s| s.id.0 != title), "and removes the shape");
|
||
}
|
||
|
||
/// #182: Ctrl+C then Ctrl+V did nothing for objects without text (a rectangle), because
|
||
/// egui-winit drops Ctrl+V when the system clipboard is empty; the context menu worked.
|
||
#[test]
|
||
fn copy_then_paste_shortcut_duplicates_an_object_without_text() {
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
harness.state_mut().session.execute("shape.insert", &json!({"preset": "rect", "rect": [10, 10, 50, 50]})).unwrap();
|
||
let count = |h: &egui_kittest::Harness<'_, SlideApp>| h.state().session.doc().unwrap().current_slide().unwrap().shapes.len();
|
||
let before = count(&harness);
|
||
|
||
// What the copy leaves on the system clipboard is what egui-winit hands back on Ctrl+V.
|
||
assert_eq!(system_clipboard_text(""), OBJECTS_MARKER);
|
||
assert_eq!(system_clipboard_text("hello"), "hello");
|
||
harness.event(egui::Event::Copy);
|
||
harness.run_steps(2);
|
||
harness.event(egui::Event::Paste(OBJECTS_MARKER.to_string()));
|
||
harness.run_steps(2);
|
||
assert_eq!(count(&harness), before + 1, "the shortcut pastes a copy of the rectangle");
|
||
let d = harness.state().session.active().unwrap();
|
||
let pasted = d.doc.slides[0].shapes.last().unwrap();
|
||
assert!(pasted.text.as_ref().is_none_or(|t| t.text().is_empty()), "a copy of the rectangle, not a text box holding the marker");
|
||
}
|
||
|
||
/// #188: Ctrl/Cmd+A with the slide thumbnail pane focused selects every slide; with the
|
||
/// canvas focused it still selects shapes.
|
||
#[test]
|
||
fn select_all_follows_the_focused_pane() {
|
||
let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
|
||
|ui, app: &mut SlideApp| {
|
||
app.logic(ui.ctx());
|
||
app.ui(ui);
|
||
},
|
||
SlideApp::new(Session::with_new(), Services::default()),
|
||
);
|
||
harness.run_steps(2);
|
||
for _ in 0..2 {
|
||
harness.state_mut().run("slide.new", json!({})).unwrap();
|
||
}
|
||
harness.state_mut().run("slide.go", json!({"index": 0})).unwrap();
|
||
harness.run_steps(3);
|
||
let click = |h: &mut egui_kittest::Harness<'_, SlideApp>, pos: egui::Pos2| {
|
||
h.event(egui::Event::PointerMoved(pos));
|
||
for pressed in [true, false] {
|
||
h.event(egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
|
||
}
|
||
h.run_steps(2);
|
||
};
|
||
// Press in the thumbnail pane, then Cmd+A.
|
||
let w = harness.state().ui.thumbs_width;
|
||
click(&mut harness, egui::pos2(w / 2.0, 300.0));
|
||
assert!(harness.state().slides_focused);
|
||
harness.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::A);
|
||
harness.run_steps(2);
|
||
let st = harness.state().session.active().unwrap();
|
||
assert_eq!(st.selection.slides.len(), 3, "every slide is selected");
|
||
|
||
// A press on the canvas moves focus away: Cmd+A selects shapes again.
|
||
click(&mut harness, egui::pos2(700.0, 400.0));
|
||
assert!(!harness.state().slides_focused);
|
||
harness.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::A);
|
||
harness.run_steps(2);
|
||
let st = harness.state().session.active().unwrap();
|
||
assert!(!st.selection.shapes.is_empty(), "canvas select all picks the shapes");
|
||
}
|
||
}
|