VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(ui-egui): move shortcuts.rs items to shortcuts/{paste,presentation,typing}.rs
aionggb3789b280cf9
diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rsindex 378590131..251617931 100644--- a/crates/ui-egui/src/shortcuts.rs+++ b/crates/ui-egui/src/shortcuts.rs@@ -11,6 +11,19 @@ use vectorcraft_tools::{Mods, SurroundingUnit, ToolKey};use crate::VectorcraftApp;+mod paste;+mod presentation;+mod typing;++use paste::unclip_chords;+pub(crate) use paste::{PasteChord, paste_command};+pub(crate) use presentation::presentation_step;+use presentation::{escape_pair_id, escape_press, escape_resets_rotation, presentation_keys};+#[cfg(test)]+use typing::is_shortcut_chord;+pub(crate) use typing::keep_marked_text;+use typing::{drop_typing_presses, type_text};+/// Parse "Cmd+Shift+]" into an egui shortcut. `Cmd` is Command on macOS and Ctrl elsewhere./// `+` and `=` name one chord key ([`Key::Equals`]): `+` is Shift+`=` on many layouts, so a/// `Cmd+=` chord also answers `+` however it is typed.@@ -91,18 +104,6 @@ pub(crate) fn all_shortcuts() -> Vec<(KeyboardShortcut, &'static str, serde_jsonv}-/// Keys that paste with Cmd, or alone. (Shift+Insert is left out: Ctrl+Insert copies.)-const PASTE_KEYS: [Key; 2] = [Key::V, Key::Paste];--/// The paste command whose V chord `held` holds (Paste in Place for Cmd+Shift+V by default), else-/// Paste: egui reports every Cmd+V chord as a paste, never as its key.-pub(crate) fn paste_command(held: Modifiers) -> &'static str {- all_shortcuts()- .into_iter()- .find(|(sc, id, _)| sc.logical_key == Key::V && id.starts_with("edit.paste") && held.matches_logically(sc.modifiers))- .map_or("edit.paste", |(_, id, _)| id)-}-/// Does every press of `key` this frame hold a chord with modifiers that a command shortcut is bound/// to, matched as [`consume`] matches it? `cmd_only`: only chords with Cmd count. False when `key`/// isn't pressed.@@ -140,380 +141,6 @@ pub fn runs_a_shortcut(key: &str, code: &str, modifiers: Modifiers) -> bool {craft_keymap::Layout::default().candidates(&input).iter().any(|c| mirror.keymap.lookup(c, false, &Active::NONE) != craft_keymap::Lookup::None)}-/// Give a copy or cut chord held with more modifiers its key back when it has a shortcut of its own:-/// egui reports every Cmd+C and Cmd+X chord as Copy or Cut, Shift and Alt held too, so Cmd+Shift+C-/// (Align center) copied instead (#1940).-fn unclip_chords(i: &mut egui::InputState) {- if !i.events.iter().any(|e| matches!(e, egui::Event::Copy | egui::Event::Cut)) {- return;- }- let (held, shortcuts) = (i.modifiers, all_shortcuts());- for e in &mut i.events {- let (key, own) = match e {- egui::Event::Copy => (Key::C, "edit.copy"),- egui::Event::Cut => (Key::X, "edit.cut"),- _ => continue,- };- if shortcuts.iter().any(|(sc, id, _)| sc.logical_key == key && *id != own && held.matches_exact(sc.modifiers)) {- *e = egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: held };- }- }-}--/// Drop each key press made with Ctrl and Alt held that is followed by the text it typed. Firefox-/// on Windows reports AltGr as Ctrl and Alt held, so AltGr+L on a Polish layout arrives as a-/// Ctrl+Alt+L press and then the text "ł", which the Type tool types. Without the press no command-/// chord runs for it: neither Cmd+Alt+L nor Cmd+L, which egui matches with the extra Alt held.-fn drop_typing_presses(i: &mut egui::InputState) {- let next = i.events.iter().skip(1).map(Some).chain([None]);- let typed: Vec<bool> = i- .events- .iter()- .zip(next)- .map(|(e, next)| {- matches!(e, egui::Event::Key { pressed: true, modifiers, .. } if modifiers.ctrl && modifiers.alt)- && matches!(next, Some(egui::Event::Text(t)) if !t.is_empty())- })- .collect();- let mut typed = typed.into_iter();- i.events.retain(|_| !typed.next().unwrap_or(false));-}--/// Keyboard pastes of something other than text. egui swallows a paste chord's key press and-/// sends a Paste event only when the clipboard holds text, so a paste key released without its-/// press (or a Paste event) reported was a paste of a bitmap or a PDF.-#[derive(Clone, Default)]-pub(crate) struct PasteChord {- /// Paste keys whose press was reported (typed, not pasting).- pressed: Vec<Key>,- /// A Paste event came since the last paste key was released.- pasted: bool,-}--impl PasteChord {- /// Follow one frame's `events` → the modifiers of a paste egui sent no event for (the chord's,- /// as its key is released).- pub(crate) fn textless_paste(&mut self, events: &[egui::Event]) -> Option<Modifiers> {- let mut fire = None;- for e in events {- match e {- egui::Event::Paste(_) => self.pasted = true,- // A release that comes while the window is away is never seen.- egui::Event::WindowFocused(false) => *self = Self::default(),- egui::Event::Key { key, pressed: true, .. } if PASTE_KEYS.contains(key) && !self.pressed.contains(key) => self.pressed.push(*key),- egui::Event::Key { key, pressed: false, modifiers, .. } if PASTE_KEYS.contains(key) => {- match self.pressed.iter().position(|k| k == key) {- Some(i) => {- self.pressed.swap_remove(i);- }- // Unless a Paste event came (the guard takes it either way).- None if !std::mem::take(&mut self.pasted) => fire = Some(*modifiers),- None => {}- }- }- _ => {}- }- }- fire- }-}--/// End an IME composition outside the IME (a click away, the IME going away): the-/// marked text stays as typed, and the system IME is told to drop it.-pub(crate) fn keep_marked_text(app: &mut VectorcraftApp) {- let Some(m) = app.ime_marked.take() else { return };- app.ime_discard = true;- if app.session.tool_composing() {- // Errors are already reported by the engine's interaction.- let _ = app.session.tool_text(&m, app.view_info());- }-}--/// Cmd/Ctrl chords are shortcuts (Create Outlines, Bold, …): their letter is never typed into the-/// text if a host still emits `Text` for them (#2094). Alt is left to type: Option+key on macOS-/// and AltGr (Ctrl+Alt) on Windows keyboards type characters such as é, ø and @.-fn is_shortcut_chord(m: egui::Modifiers) -> bool {- (m.command || m.ctrl) && !m.alt-}--enum Seq {- Text(String),- Preedit(String, Option<std::ops::Range<usize>>),- Commit(String),- Erase(ToolKey, Mods),- /// An input method replaces text around the composition (upstream's character counts or- /// the fork's exact UTF-8 byte counts), then commits.- DeleteSurrounding(usize, usize, SurroundingUnit),- // The actual pointer/key still belongs to its existing handler. Its position in this- // sequence must nevertheless interrupt an old composition before later terminal input.- InterruptPointer,- InterruptNavigation,- InterruptCommand,- ResetCompleted(egui::ImeResetId),-}--/// Typed text and IME events, in the order they came, to the Type tool.-fn type_text(app: &mut VectorcraftApp, ctx: &egui::Context) -> bool {- let view = app.view_info();- // Switching apps mid-composition needs nothing: the macOS IME keeps its marked text and goes- // on with it when the window comes back (measured with Kotoeri), as the tool does.- let shortcut_mods = ctx.input(|i| is_shortcut_chord(i.modifiers));- // A frame that began composing keeps its editing keys for the IME: a Backspace that empties the- // marked text must not then delete the committed character before it.- let was_composing = app.session.tool_composing();- // Text, IME events and plain Backspace/Delete are taken together, in the order they arrived, so- // a keyboard-hook IME (UniKey/OpenKey) whose tone key sends Backspace(s) and then re-injects- // characters in one frame interleaves correctly. Taken as two passes (all text, then the keys)- // the deletes land after the inserts and the diacritics are lost. Each handled event is removed- // so `route_type_input` below does not process the same Backspace/Delete again.- let seq = type_sequence(ctx);- let viewport = ctx.viewport_id();- let mut old_composition_retired = false;- for e in seq {- // Before the UI, a changed composition or guard is settled `pending`: a token bound here- // could outlive a route this pass invalidates later (a palette/dialog/Home) and attach to- // the stock descriptor. The post-UI finalizer binds the confirmed replacement.- crate::ime::sync_incoming_before_ui(app, ctx);- if let Seq::ResetCompleted(request) = &e {- old_composition_retired |= crate::ime::complete(app, ctx, *request);- continue;- }- if matches!(app.ime_compositions.get(&viewport), Some(crate::ime::IncomingComposition::Stale)) {- match &e {- // Accepted old payloads precede the fence even when their terminal arrives.- // None of these events proves the local reset has reached its boundary.- Seq::Commit(_) | Seq::DeleteSurrounding(..) | Seq::Preedit(..) => continue,- _ => {}- }- }- // A pointer/navigation/command notice has not reached its real handler yet. Text and- // erases after it belong to the old caret, not to the destination it will establish.- if crate::ime::deferred(app, ctx) {- match &e {- Seq::Text(_) | Seq::Erase(..) => continue,- _ => {}- }- }- let preedit_empty = match &e {- Seq::Preedit(text, _) => Some(text.is_empty()),- _ => None,- };- let terminal_commit = matches!(&e, Seq::Commit(_));- let from_ime = matches!(&e, Seq::Preedit(..) | Seq::Commit(_) | Seq::DeleteSurrounding(..));- // Errors are already reported by the engine's interaction (a failed preview keeps it).- let result = apply_type_event(app, ctx, view, e, shortcut_mods, was_composing, &mut old_composition_retired);- if result.is_ok() && from_ime {- if terminal_commit {- app.ime_compositions.remove(&viewport);- } else {- crate::ime::remember_incoming(app, ctx, preedit_empty);- }- }- }- old_composition_retired-}--/// Take this frame's typed text, IME events and plain Backspace/Delete, in the order they arrived.-fn type_sequence(ctx: &egui::Context) -> Vec<Seq> {- let mut seq = vec![];- ctx.input_mut(|i| {- // Move the events out instead of cloning their strings: a keyboard hook that reinjects a- // batch keeps the batch in `seq` only, not in both the input list and a second copy.- let mut kept = Vec::with_capacity(i.events.len());- // InputState's held flag describes the end of the batch. Recover its initial state from- // the first transition, so a move before a later press cannot cancel an earlier commit.- let mut primary_down = i- .events- .iter()- .find_map(|e| match e {- egui::Event::PointerButton { button: egui::PointerButton::Primary, pressed, .. } => Some(!pressed),- _ => None,- })- .unwrap_or_else(|| i.pointer.primary_down());- for e in std::mem::take(&mut i.events) {- match e {- egui::Event::Text(t) => seq.push(Seq::Text(t)),- egui::Event::Ime(egui::ImeEvent::Preedit { text, active_range_chars }) => {- seq.push(Seq::Preedit(text, active_range_chars));- }- egui::Event::Ime(egui::ImeEvent::Commit(t)) => seq.push(Seq::Commit(t)),- egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars, after_chars }) => {- seq.push(Seq::DeleteSurrounding(before_chars, after_chars, SurroundingUnit::Chars));- }- egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes, after_bytes }) => {- seq.push(Seq::DeleteSurrounding(before_bytes, after_bytes, SurroundingUnit::Bytes));- }- egui::Event::ImeResetCompleted { request_id } => seq.push(Seq::ResetCompleted(request_id)),- // X11/Wayland PRIMARY middle-click: text at the pointer, inserted as typed text (never- // routed as a key or shortcut).- egui::Event::MiddleClickPaste { text, .. } => seq.push(Seq::Text(text)),- // Only unmodified Backspace/Delete interleave with injected text; word-delete and other- // modified forms stay with `route_type_input`.- egui::Event::Key { key: key @ (Key::Backspace | Key::Delete), pressed: true, modifiers: m, .. }- if !m.command && !m.alt && !m.ctrl =>- {- let tk = if key == Key::Backspace { ToolKey::Backspace } else { ToolKey::Delete };- seq.push(Seq::Erase(tk, Mods { shift: m.shift, ..Mods::default() }));- }- e @ egui::Event::PointerButton { button: egui::PointerButton::Primary, pressed, .. } => {- primary_down = pressed;- if pressed {- seq.push(Seq::InterruptPointer);- }- kept.push(e);- }- e @ egui::Event::PointerMoved(_) => {- if primary_down {- seq.push(Seq::InterruptPointer);- }- kept.push(e);- }- e @ egui::Event::Key { key, pressed: true, modifiers, .. }- if matches!(key, Key::ArrowLeft | Key::ArrowRight | Key::ArrowUp | Key::ArrowDown | Key::Home | Key::End)- || key == Key::A && modifiers.command =>- {- seq.push(Seq::InterruptNavigation);- kept.push(e);- }- e @ egui::Event::Key { pressed: true, modifiers, .. } if is_shortcut_chord(modifiers) => {- seq.push(Seq::InterruptCommand);- kept.push(e);- }- e @ (egui::Event::Cut | egui::Event::Paste(_)) => {- seq.push(Seq::InterruptCommand);- kept.push(e);- }- other => kept.push(other),- }- }- i.events = kept;- });- seq-}--/// Apply one sequence item to the active tool; the caller filters stale/deferred events and-/// turns a successful IME mutation into its receipt.-fn apply_type_event(- app: &mut VectorcraftApp,- ctx: &egui::Context,- view: ViewInfo,- e: Seq,- shortcut_mods: bool,- was_composing: bool,- old_composition_retired: &mut bool,-) -> EngineResult<Vec<UiRequest>> {- match e {- Seq::InterruptPointer => {- *old_composition_retired |= crate::ime::defer_interrupt(app, ctx);- Ok(vec![])- }- Seq::InterruptNavigation => {- // Active composition owns its navigation keys. Once cleared, application caret- // navigation interrupts its still-pending terminal event, even in this batch.- if !app.session.tool_composing() {- *old_composition_retired |= crate::ime::defer_interrupt(app, ctx);- }- Ok(vec![])- }- Seq::InterruptCommand => {- if crate::ime::blocked(app, ctx) {- *old_composition_retired |= crate::ime::defer_interrupt(app, ctx);- }- Ok(vec![])- }- Seq::ResetCompleted(_) => Ok(vec![]),- // Keys the IME passed through come as text only when nothing is marked. This is an- // application edit (also a hook IME's reinjected characters): `Other` dominates.- Seq::Text(t) if !app.session.tool_composing() && !shortcut_mods => {- let target_before = crate::ime::target(&mut app.session, view);- let before = crate::ime::stamp(&mut app.session, view);- let r = app.session.tool_text(&t, view);- if r.is_ok() {- crate::ime::note_application_edit(app, ctx, view, target_before, before);- }- r- }- Seq::Text(_) => Ok(vec![]),- // A pre-edit is not committed text: it changes neither the outgoing snapshot (the- // engine query removes it) nor the cause.- Seq::Preedit(text, active_range_chars) => {- app.ime_marked = Some(text.clone()).filter(|t| !t.is_empty());- app.session.tool_preedit(&text, active_range_chars, view)- }- // A bare line break confirms the composition (Enter): the marked text, not a newline.- // It is an accepted IME commit of that marked text when the tool inserts the marked- // text unchanged; a commit the tool rewrites (a quoted or filtered marked text) is an- // application edit instead.- Seq::Commit(t) if t == "\n" || t == "\r" => {- let target_before = crate::ime::target(&mut app.session, view);- let before = crate::ime::stamp(&mut app.session, view);- let composing = app.session.tool_composing();- let verbatim = app.session.tool_ime_session_matches(view)- && match app.ime_marked.as_deref() {- Some(m) => app.session.tool_text_is_verbatim(m, view),- None => true,- };- keep_marked_text(app);- if composing {- if verbatim {- crate::ime::note_ime_apply(app, ctx, view, target_before, before);- } else {- crate::ime::note_application_edit(app, ctx, view, target_before, before);- }- }- Ok(vec![])- }- // An accepted IME commit: stamp the bounded committed context immediately before and- // after, so only a real mutation (not a no-op, rejection or failure) earns the receipt.- // A commit the tool rewrites (Typographer's Quotes, a filtered control character) is an- // application edit and must never earn `InputMethod`.- Seq::Commit(t) => {- app.ime_marked = None;- let target_before = crate::ime::target(&mut app.session, view);- let before = crate::ime::stamp(&mut app.session, view);- // A document edit since the composition means this commit starts a fresh typing- // session: that reset is application-side, so it cannot earn `InputMethod`.- let verbatim = app.session.tool_ime_session_matches(view) && app.session.tool_text_is_verbatim(&t, view);- let r = app.session.tool_text(&t, view);- if r.is_ok() {- if verbatim {- crate::ime::note_ime_apply(app, ctx, view, target_before, before);- } else {- crate::ime::note_application_edit(app, ctx, view, target_before, before);- }- }- r- }- // While composing (or in a frame that began composing), editing keys belong to the IME.- Seq::Erase(tk, m) if !was_composing && !app.session.tool_composing() => {- // Mirror `route_type_input`/`text_key`: surface an erase error in the status bar- // instead of discarding it, and report the successful edit as application-origin.- let target_before = crate::ime::target(&mut app.session, view);- let before = crate::ime::stamp(&mut app.session, view);- let r = app.session.tool_key(tk, m, view);- match &r {- Err(e) => app.status(e.to_string()),- Ok(_) => crate::ime::note_application_edit(app, ctx, view, target_before, before),- }- r- }- Seq::Erase(..) => Ok(vec![]),- // Deleting around the composition starts the same typing session as the commit that- // follows, so the replacement is one undo step; an error reaches the status bar. The- // receipt covers only this accepted deletion.- Seq::DeleteSurrounding(before, after, unit) => {- let target_before = crate::ime::target(&mut app.session, view);- let stamp_before = crate::ime::stamp(&mut app.session, view);- let r = app.session.tool_ime_delete_surrounding(before, after, unit, view);- match &r {- Err(e) => app.status(e.to_string()),- Ok(_) => crate::ime::note_ime_apply(app, ctx, view, target_before, stamp_before),- }- r- }- }-}-/// Process one frame's events against the keymap at most once per context, viewport and frame, so/// reruns cannot fire a shortcut or tool key twice.pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {@@ -1036,108 +663,6 @@ fn settings_on_a_mac(app: &mut VectorcraftApp, ctx: &egui::Context, mac: bool) -pressed}-/// The second press of Escape pressed twice comes less than this many seconds after the first.-const ESCAPE_PAIR_SECONDS: f64 = 1.0;--/// The key of the last counted Escape's time in egui's temporary data.-fn escape_pair_id() -> egui::Id {- egui::Id::unique("escape-pair")-}--/// Reads this frame's presses for Escape pressed twice. `None` when the frame has no Escape press, or-/// has another key or pointer button press as well (a key repeat counts as another press, and the-/// modifier keys do not count). Otherwise, whether the last counted Escape came less than-/// [`ESCAPE_PAIR_SECONDS`] before. A press of Escape, another key or a pointer button removes the-/// last counted Escape's time.-fn escape_press(ctx: &egui::Context) -> Option<bool> {- let (escape, other, now) = ctx.input(|i| {- let (mut escape, mut other) = (false, false);- for e in &i.events {- match e {- egui::Event::Key { key: Key::Escape, pressed: true, repeat: false, .. } => escape = true,- egui::Event::Key { key, pressed: true, .. } if !is_modifier(*key) => other = true,- egui::Event::PointerButton { pressed: true, .. } => other = true,- _ => {}- }- }- (escape, other, i.time)- });- if !escape && !other {- return None;- }- let counted = ctx.data_mut(|d| d.remove_temp::<f64>(escape_pair_id()));- (escape && !other).then(|| counted.is_some_and(|t| now - t < ESCAPE_PAIR_SECONDS))-}--/// Does this Escape reset the view's rotation? It does when the view is rotated, no popup is open,-/// the ruler origin is not being dragged, and the press is the second of a pair (`second`) or the-/// Rotate View tool is chosen.-fn escape_resets_rotation(app: &VectorcraftApp, ctx: &egui::Context, second: bool) -> bool {- app.view().is_some_and(|v| v.rotation != 0.0)- && (second || app.session.tool_id() == "rotateView")- && !egui::Popup::is_any_open(ctx)- && !crate::canvas::ruler_origin_dragging(ctx)-}--/// The keys in Presentation Mode, where nothing is edited: Escape leaves the mode, and ← and → go to-/// the previous and the next artboard ([`presentation_step`]). Every other key press, the text it-/// types and the clipboard keys are removed from the input, so no shortcut, tool or field acts on-/// them. The macOS menu bar's key equivalents arrive as key presses too ([`crate::native_menu`]).-fn presentation_keys(app: &mut VectorcraftApp, ctx: &egui::Context, escape_pair: Option<bool>) {- let (mut leave, mut steps) = (false, vec![]);- ctx.input_mut(|i| {- i.events.retain(|e| match e {- egui::Event::Key { key: Key::Escape, pressed: true, .. } => {- leave = true;- false- }- egui::Event::Key { key: Key::ArrowLeft, pressed: true, .. } => {- steps.push(false);- false- }- egui::Event::Key { key: Key::ArrowRight, pressed: true, .. } => {- steps.push(true);- false- }- egui::Event::Key { pressed: true, .. }- | egui::Event::Text(_)- | egui::Event::Ime(_)- | egui::Event::Copy- | egui::Event::Cut- | egui::Event::Paste(_)- | egui::Event::PasteImage(_)- | egui::Event::MiddleClickPaste { .. } => false,- _ => true,- })- });- for next in steps {- presentation_step(app, next);- }- if leave {- let _ = app.run("view.presentation", json!({}));- // The Escape that left the mode can start a pair, as in `handle`.- if escape_pair.is_some() && !egui::Popup::is_any_open(ctx) {- let now = ctx.input(|i| i.time);- ctx.data_mut(|d| d.insert_temp(escape_pair_id(), now));- }- }-}--/// Go to the next artboard (`next`) or the previous one with `view.goToArtboard`, as the status bar-/// navigator's Next and Previous buttons do, for the arrow keys and a click in Presentation Mode.-/// On the last artboard a step forward leaves the view as it is, and so does a step back on the-/// first.-pub(crate) fn presentation_step(app: &mut VectorcraftApp, next: bool) {- let n = app.session.active().map_or(0, |d| d.doc.artboards.len());- let at = crate::panels::artboards::selected(app, n);- let to = if next { (at + 1 < n).then_some("next") } else { (at > 0).then_some("previous") };- if let Some(to) = to- && let Err(e) = app.run("view.goToArtboard", json!({ "index": to }))- {- app.status(e);- }-}-/// What a single-key shortcut reads for `text`, typed by the key at `physical`: the text itself,/// or, when it holds no ASCII character (a layout without Latin letters), what that key types on a/// US layout, so V selects the Selection tool whatever the V key types.diff --git a/crates/ui-egui/src/shortcuts/paste.rs b/crates/ui-egui/src/shortcuts/paste.rsnew file mode 100644index 000000000..9f43e76c5--- /dev/null+++ b/crates/ui-egui/src/shortcuts/paste.rs@@ -0,0 +1,72 @@+use super::*;++/// Keys that paste with Cmd, or alone. (Shift+Insert is left out: Ctrl+Insert copies.)+const PASTE_KEYS: [Key; 2] = [Key::V, Key::Paste];++/// The paste command whose V chord `held` holds (Paste in Place for Cmd+Shift+V by default), else+/// Paste: egui reports every Cmd+V chord as a paste, never as its key.+pub(crate) fn paste_command(held: Modifiers) -> &'static str {+ all_shortcuts()+ .into_iter()+ .find(|(sc, id, _)| sc.logical_key == Key::V && id.starts_with("edit.paste") && held.matches_logically(sc.modifiers))+ .map_or("edit.paste", |(_, id, _)| id)+}++/// Give a copy or cut chord held with more modifiers its key back when it has a shortcut of its own:+/// egui reports every Cmd+C and Cmd+X chord as Copy or Cut, Shift and Alt held too, so Cmd+Shift+C+/// (Align center) copied instead (#1940).+pub(super) fn unclip_chords(i: &mut egui::InputState) {+ if !i.events.iter().any(|e| matches!(e, egui::Event::Copy | egui::Event::Cut)) {+ return;+ }+ let (held, shortcuts) = (i.modifiers, all_shortcuts());+ for e in &mut i.events {+ let (key, own) = match e {+ egui::Event::Copy => (Key::C, "edit.copy"),+ egui::Event::Cut => (Key::X, "edit.cut"),+ _ => continue,+ };+ if shortcuts.iter().any(|(sc, id, _)| sc.logical_key == key && *id != own && held.matches_exact(sc.modifiers)) {+ *e = egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: held };+ }+ }+}++/// Keyboard pastes of something other than text. egui swallows a paste chord's key press and+/// sends a Paste event only when the clipboard holds text, so a paste key released without its+/// press (or a Paste event) reported was a paste of a bitmap or a PDF.+#[derive(Clone, Default)]+pub(crate) struct PasteChord {+ /// Paste keys whose press was reported (typed, not pasting).+ pressed: Vec<Key>,+ /// A Paste event came since the last paste key was released.+ pasted: bool,+}++impl PasteChord {+ /// Follow one frame's `events` → the modifiers of a paste egui sent no event for (the chord's,+ /// as its key is released).+ pub(crate) fn textless_paste(&mut self, events: &[egui::Event]) -> Option<Modifiers> {+ let mut fire = None;+ for e in events {+ match e {+ egui::Event::Paste(_) => self.pasted = true,+ // A release that comes while the window is away is never seen.+ egui::Event::WindowFocused(false) => *self = Self::default(),+ egui::Event::Key { key, pressed: true, .. } if PASTE_KEYS.contains(key) && !self.pressed.contains(key) => self.pressed.push(*key),+ egui::Event::Key { key, pressed: false, modifiers, .. } if PASTE_KEYS.contains(key) => {+ match self.pressed.iter().position(|k| k == key) {+ Some(i) => {+ self.pressed.swap_remove(i);+ }+ // Unless a Paste event came (the guard takes it either way).+ None if !std::mem::take(&mut self.pasted) => fire = Some(*modifiers),+ None => {}+ }+ }+ _ => {}+ }+ }+ fire+ }+}diff --git a/crates/ui-egui/src/shortcuts/presentation.rs b/crates/ui-egui/src/shortcuts/presentation.rsnew file mode 100644index 000000000..691922ab7--- /dev/null+++ b/crates/ui-egui/src/shortcuts/presentation.rs@@ -0,0 +1,103 @@+use super::*;++/// The second press of Escape pressed twice comes less than this many seconds after the first.+const ESCAPE_PAIR_SECONDS: f64 = 1.0;++/// The key of the last counted Escape's time in egui's temporary data.+pub(super) fn escape_pair_id() -> egui::Id {+ egui::Id::unique("escape-pair")+}++/// Reads this frame's presses for Escape pressed twice. `None` when the frame has no Escape press, or+/// has another key or pointer button press as well (a key repeat counts as another press, and the+/// modifier keys do not count). Otherwise, whether the last counted Escape came less than+/// [`ESCAPE_PAIR_SECONDS`] before. A press of Escape, another key or a pointer button removes the+/// last counted Escape's time.+pub(super) fn escape_press(ctx: &egui::Context) -> Option<bool> {+ let (escape, other, now) = ctx.input(|i| {+ let (mut escape, mut other) = (false, false);+ for e in &i.events {+ match e {+ egui::Event::Key { key: Key::Escape, pressed: true, repeat: false, .. } => escape = true,+ egui::Event::Key { key, pressed: true, .. } if !is_modifier(*key) => other = true,+ egui::Event::PointerButton { pressed: true, .. } => other = true,+ _ => {}+ }+ }+ (escape, other, i.time)+ });+ if !escape && !other {+ return None;+ }+ let counted = ctx.data_mut(|d| d.remove_temp::<f64>(escape_pair_id()));+ (escape && !other).then(|| counted.is_some_and(|t| now - t < ESCAPE_PAIR_SECONDS))+}++/// Does this Escape reset the view's rotation? It does when the view is rotated, no popup is open,+/// the ruler origin is not being dragged, and the press is the second of a pair (`second`) or the+/// Rotate View tool is chosen.+pub(super) fn escape_resets_rotation(app: &VectorcraftApp, ctx: &egui::Context, second: bool) -> bool {+ app.view().is_some_and(|v| v.rotation != 0.0)+ && (second || app.session.tool_id() == "rotateView")+ && !egui::Popup::is_any_open(ctx)+ && !crate::canvas::ruler_origin_dragging(ctx)+}++/// The keys in Presentation Mode, where nothing is edited: Escape leaves the mode, and ← and → go to+/// the previous and the next artboard ([`presentation_step`]). Every other key press, the text it+/// types and the clipboard keys are removed from the input, so no shortcut, tool or field acts on+/// them. The macOS menu bar's key equivalents arrive as key presses too ([`crate::native_menu`]).+pub(super) fn presentation_keys(app: &mut VectorcraftApp, ctx: &egui::Context, escape_pair: Option<bool>) {+ let (mut leave, mut steps) = (false, vec![]);+ ctx.input_mut(|i| {+ i.events.retain(|e| match e {+ egui::Event::Key { key: Key::Escape, pressed: true, .. } => {+ leave = true;+ false+ }+ egui::Event::Key { key: Key::ArrowLeft, pressed: true, .. } => {+ steps.push(false);+ false+ }+ egui::Event::Key { key: Key::ArrowRight, pressed: true, .. } => {+ steps.push(true);+ false+ }+ egui::Event::Key { pressed: true, .. }+ | egui::Event::Text(_)+ | egui::Event::Ime(_)+ | egui::Event::Copy+ | egui::Event::Cut+ | egui::Event::Paste(_)+ | egui::Event::PasteImage(_)+ | egui::Event::MiddleClickPaste { .. } => false,+ _ => true,+ })+ });+ for next in steps {+ presentation_step(app, next);+ }+ if leave {+ let _ = app.run("view.presentation", json!({}));+ // The Escape that left the mode can start a pair, as in `handle`.+ if escape_pair.is_some() && !egui::Popup::is_any_open(ctx) {+ let now = ctx.input(|i| i.time);+ ctx.data_mut(|d| d.insert_temp(escape_pair_id(), now));+ }+ }+}++/// Go to the next artboard (`next`) or the previous one with `view.goToArtboard`, as the status bar+/// navigator's Next and Previous buttons do, for the arrow keys and a click in Presentation Mode.+/// On the last artboard a step forward leaves the view as it is, and so does a step back on the+/// first.+pub(crate) fn presentation_step(app: &mut VectorcraftApp, next: bool) {+ let n = app.session.active().map_or(0, |d| d.doc.artboards.len());+ let at = crate::panels::artboards::selected(app, n);+ let to = if next { (at + 1 < n).then_some("next") } else { (at > 0).then_some("previous") };+ if let Some(to) = to+ && let Err(e) = app.run("view.goToArtboard", json!({ "index": to }))+ {+ app.status(e);+ }+}diff --git a/crates/ui-egui/src/shortcuts/typing.rs b/crates/ui-egui/src/shortcuts/typing.rsnew file mode 100644index 000000000..c42e5d57d--- /dev/null+++ b/crates/ui-egui/src/shortcuts/typing.rs@@ -0,0 +1,316 @@+use super::*;++/// Drop each key press made with Ctrl and Alt held that is followed by the text it typed. Firefox+/// on Windows reports AltGr as Ctrl and Alt held, so AltGr+L on a Polish layout arrives as a+/// Ctrl+Alt+L press and then the text "ł", which the Type tool types. Without the press no command+/// chord runs for it: neither Cmd+Alt+L nor Cmd+L, which egui matches with the extra Alt held.+pub(super) fn drop_typing_presses(i: &mut egui::InputState) {+ let next = i.events.iter().skip(1).map(Some).chain([None]);+ let typed: Vec<bool> = i+ .events+ .iter()+ .zip(next)+ .map(|(e, next)| {+ matches!(e, egui::Event::Key { pressed: true, modifiers, .. } if modifiers.ctrl && modifiers.alt)+ && matches!(next, Some(egui::Event::Text(t)) if !t.is_empty())+ })+ .collect();+ let mut typed = typed.into_iter();+ i.events.retain(|_| !typed.next().unwrap_or(false));+}++/// End an IME composition outside the IME (a click away, the IME going away): the+/// marked text stays as typed, and the system IME is told to drop it.+pub(crate) fn keep_marked_text(app: &mut VectorcraftApp) {+ let Some(m) = app.ime_marked.take() else { return };+ app.ime_discard = true;+ if app.session.tool_composing() {+ // Errors are already reported by the engine's interaction.+ let _ = app.session.tool_text(&m, app.view_info());+ }+}++/// Cmd/Ctrl chords are shortcuts (Create Outlines, Bold, …): their letter is never typed into the+/// text if a host still emits `Text` for them (#2094). Alt is left to type: Option+key on macOS+/// and AltGr (Ctrl+Alt) on Windows keyboards type characters such as é, ø and @.+pub(super) fn is_shortcut_chord(m: egui::Modifiers) -> bool {+ (m.command || m.ctrl) && !m.alt+}++enum Seq {+ Text(String),+ Preedit(String, Option<std::ops::Range<usize>>),+ Commit(String),+ Erase(ToolKey, Mods),+ /// An input method replaces text around the composition (upstream's character counts or+ /// the fork's exact UTF-8 byte counts), then commits.+ DeleteSurrounding(usize, usize, SurroundingUnit),+ // The actual pointer/key still belongs to its existing handler. Its position in this+ // sequence must nevertheless interrupt an old composition before later terminal input.+ InterruptPointer,+ InterruptNavigation,+ InterruptCommand,+ ResetCompleted(egui::ImeResetId),+}++/// Typed text and IME events, in the order they came, to the Type tool.+pub(super) fn type_text(app: &mut VectorcraftApp, ctx: &egui::Context) -> bool {+ let view = app.view_info();+ // Switching apps mid-composition needs nothing: the macOS IME keeps its marked text and goes+ // on with it when the window comes back (measured with Kotoeri), as the tool does.+ let shortcut_mods = ctx.input(|i| is_shortcut_chord(i.modifiers));+ // A frame that began composing keeps its editing keys for the IME: a Backspace that empties the+ // marked text must not then delete the committed character before it.+ let was_composing = app.session.tool_composing();+ // Text, IME events and plain Backspace/Delete are taken together, in the order they arrived, so+ // a keyboard-hook IME (UniKey/OpenKey) whose tone key sends Backspace(s) and then re-injects+ // characters in one frame interleaves correctly. Taken as two passes (all text, then the keys)+ // the deletes land after the inserts and the diacritics are lost. Each handled event is removed+ // so `route_type_input` below does not process the same Backspace/Delete again.+ let seq = type_sequence(ctx);+ let viewport = ctx.viewport_id();+ let mut old_composition_retired = false;+ for e in seq {+ // Before the UI, a changed composition or guard is settled `pending`: a token bound here+ // could outlive a route this pass invalidates later (a palette/dialog/Home) and attach to+ // the stock descriptor. The post-UI finalizer binds the confirmed replacement.+ crate::ime::sync_incoming_before_ui(app, ctx);+ if let Seq::ResetCompleted(request) = &e {+ old_composition_retired |= crate::ime::complete(app, ctx, *request);+ continue;+ }+ if matches!(app.ime_compositions.get(&viewport), Some(crate::ime::IncomingComposition::Stale)) {+ match &e {+ // Accepted old payloads precede the fence even when their terminal arrives.+ // None of these events proves the local reset has reached its boundary.+ Seq::Commit(_) | Seq::DeleteSurrounding(..) | Seq::Preedit(..) => continue,+ _ => {}+ }+ }+ // A pointer/navigation/command notice has not reached its real handler yet. Text and+ // erases after it belong to the old caret, not to the destination it will establish.+ if crate::ime::deferred(app, ctx) {+ match &e {+ Seq::Text(_) | Seq::Erase(..) => continue,+ _ => {}+ }+ }+ let preedit_empty = match &e {+ Seq::Preedit(text, _) => Some(text.is_empty()),+ _ => None,+ };+ let terminal_commit = matches!(&e, Seq::Commit(_));+ let from_ime = matches!(&e, Seq::Preedit(..) | Seq::Commit(_) | Seq::DeleteSurrounding(..));+ // Errors are already reported by the engine's interaction (a failed preview keeps it).+ let result = apply_type_event(app, ctx, view, e, shortcut_mods, was_composing, &mut old_composition_retired);+ if result.is_ok() && from_ime {+ if terminal_commit {+ app.ime_compositions.remove(&viewport);+ } else {+ crate::ime::remember_incoming(app, ctx, preedit_empty);+ }+ }+ }+ old_composition_retired+}++/// Take this frame's typed text, IME events and plain Backspace/Delete, in the order they arrived.+fn type_sequence(ctx: &egui::Context) -> Vec<Seq> {+ let mut seq = vec![];+ ctx.input_mut(|i| {+ // Move the events out instead of cloning their strings: a keyboard hook that reinjects a+ // batch keeps the batch in `seq` only, not in both the input list and a second copy.+ let mut kept = Vec::with_capacity(i.events.len());+ // InputState's held flag describes the end of the batch. Recover its initial state from+ // the first transition, so a move before a later press cannot cancel an earlier commit.+ let mut primary_down = i+ .events+ .iter()+ .find_map(|e| match e {+ egui::Event::PointerButton { button: egui::PointerButton::Primary, pressed, .. } => Some(!pressed),+ _ => None,+ })+ .unwrap_or_else(|| i.pointer.primary_down());+ for e in std::mem::take(&mut i.events) {+ match e {+ egui::Event::Text(t) => seq.push(Seq::Text(t)),+ egui::Event::Ime(egui::ImeEvent::Preedit { text, active_range_chars }) => {+ seq.push(Seq::Preedit(text, active_range_chars));+ }+ egui::Event::Ime(egui::ImeEvent::Commit(t)) => seq.push(Seq::Commit(t)),+ egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars, after_chars }) => {+ seq.push(Seq::DeleteSurrounding(before_chars, after_chars, SurroundingUnit::Chars));+ }+ egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes, after_bytes }) => {+ seq.push(Seq::DeleteSurrounding(before_bytes, after_bytes, SurroundingUnit::Bytes));+ }+ egui::Event::ImeResetCompleted { request_id } => seq.push(Seq::ResetCompleted(request_id)),+ // X11/Wayland PRIMARY middle-click: text at the pointer, inserted as typed text (never+ // routed as a key or shortcut).+ egui::Event::MiddleClickPaste { text, .. } => seq.push(Seq::Text(text)),+ // Only unmodified Backspace/Delete interleave with injected text; word-delete and other+ // modified forms stay with `route_type_input`.+ egui::Event::Key { key: key @ (Key::Backspace | Key::Delete), pressed: true, modifiers: m, .. }+ if !m.command && !m.alt && !m.ctrl =>+ {+ let tk = if key == Key::Backspace { ToolKey::Backspace } else { ToolKey::Delete };+ seq.push(Seq::Erase(tk, Mods { shift: m.shift, ..Mods::default() }));+ }+ e @ egui::Event::PointerButton { button: egui::PointerButton::Primary, pressed, .. } => {+ primary_down = pressed;+ if pressed {+ seq.push(Seq::InterruptPointer);+ }+ kept.push(e);+ }+ e @ egui::Event::PointerMoved(_) => {+ if primary_down {+ seq.push(Seq::InterruptPointer);+ }+ kept.push(e);+ }+ e @ egui::Event::Key { key, pressed: true, modifiers, .. }+ if matches!(key, Key::ArrowLeft | Key::ArrowRight | Key::ArrowUp | Key::ArrowDown | Key::Home | Key::End)+ || key == Key::A && modifiers.command =>+ {+ seq.push(Seq::InterruptNavigation);+ kept.push(e);+ }+ e @ egui::Event::Key { pressed: true, modifiers, .. } if is_shortcut_chord(modifiers) => {+ seq.push(Seq::InterruptCommand);+ kept.push(e);+ }+ e @ (egui::Event::Cut | egui::Event::Paste(_)) => {+ seq.push(Seq::InterruptCommand);+ kept.push(e);+ }+ other => kept.push(other),+ }+ }+ i.events = kept;+ });+ seq+}++/// Apply one sequence item to the active tool; the caller filters stale/deferred events and+/// turns a successful IME mutation into its receipt.+fn apply_type_event(+ app: &mut VectorcraftApp,+ ctx: &egui::Context,+ view: ViewInfo,+ e: Seq,+ shortcut_mods: bool,+ was_composing: bool,+ old_composition_retired: &mut bool,+) -> EngineResult<Vec<UiRequest>> {+ match e {+ Seq::InterruptPointer => {+ *old_composition_retired |= crate::ime::defer_interrupt(app, ctx);+ Ok(vec![])+ }+ Seq::InterruptNavigation => {+ // Active composition owns its navigation keys. Once cleared, application caret+ // navigation interrupts its still-pending terminal event, even in this batch.+ if !app.session.tool_composing() {+ *old_composition_retired |= crate::ime::defer_interrupt(app, ctx);+ }+ Ok(vec![])+ }+ Seq::InterruptCommand => {+ if crate::ime::blocked(app, ctx) {+ *old_composition_retired |= crate::ime::defer_interrupt(app, ctx);+ }+ Ok(vec![])+ }+ Seq::ResetCompleted(_) => Ok(vec![]),+ // Keys the IME passed through come as text only when nothing is marked. This is an+ // application edit (also a hook IME's reinjected characters): `Other` dominates.+ Seq::Text(t) if !app.session.tool_composing() && !shortcut_mods => {+ let target_before = crate::ime::target(&mut app.session, view);+ let before = crate::ime::stamp(&mut app.session, view);+ let r = app.session.tool_text(&t, view);+ if r.is_ok() {+ crate::ime::note_application_edit(app, ctx, view, target_before, before);+ }+ r+ }+ Seq::Text(_) => Ok(vec![]),+ // A pre-edit is not committed text: it changes neither the outgoing snapshot (the+ // engine query removes it) nor the cause.+ Seq::Preedit(text, active_range_chars) => {+ app.ime_marked = Some(text.clone()).filter(|t| !t.is_empty());+ app.session.tool_preedit(&text, active_range_chars, view)+ }+ // A bare line break confirms the composition (Enter): the marked text, not a newline.+ // It is an accepted IME commit of that marked text when the tool inserts the marked+ // text unchanged; a commit the tool rewrites (a quoted or filtered marked text) is an+ // application edit instead.+ Seq::Commit(t) if t == "\n" || t == "\r" => {+ let target_before = crate::ime::target(&mut app.session, view);+ let before = crate::ime::stamp(&mut app.session, view);+ let composing = app.session.tool_composing();+ let verbatim = app.session.tool_ime_session_matches(view)+ && match app.ime_marked.as_deref() {+ Some(m) => app.session.tool_text_is_verbatim(m, view),+ None => true,+ };+ keep_marked_text(app);+ if composing {+ if verbatim {+ crate::ime::note_ime_apply(app, ctx, view, target_before, before);+ } else {+ crate::ime::note_application_edit(app, ctx, view, target_before, before);+ }+ }+ Ok(vec![])+ }+ // An accepted IME commit: stamp the bounded committed context immediately before and+ // after, so only a real mutation (not a no-op, rejection or failure) earns the receipt.+ // A commit the tool rewrites (Typographer's Quotes, a filtered control character) is an+ // application edit and must never earn `InputMethod`.+ Seq::Commit(t) => {+ app.ime_marked = None;+ let target_before = crate::ime::target(&mut app.session, view);+ let before = crate::ime::stamp(&mut app.session, view);+ // A document edit since the composition means this commit starts a fresh typing+ // session: that reset is application-side, so it cannot earn `InputMethod`.+ let verbatim = app.session.tool_ime_session_matches(view) && app.session.tool_text_is_verbatim(&t, view);+ let r = app.session.tool_text(&t, view);+ if r.is_ok() {+ if verbatim {+ crate::ime::note_ime_apply(app, ctx, view, target_before, before);+ } else {+ crate::ime::note_application_edit(app, ctx, view, target_before, before);+ }+ }+ r+ }+ // While composing (or in a frame that began composing), editing keys belong to the IME.+ Seq::Erase(tk, m) if !was_composing && !app.session.tool_composing() => {+ // Mirror `route_type_input`/`text_key`: surface an erase error in the status bar+ // instead of discarding it, and report the successful edit as application-origin.+ let target_before = crate::ime::target(&mut app.session, view);+ let before = crate::ime::stamp(&mut app.session, view);+ let r = app.session.tool_key(tk, m, view);+ match &r {+ Err(e) => app.status(e.to_string()),+ Ok(_) => crate::ime::note_application_edit(app, ctx, view, target_before, before),+ }+ r+ }+ Seq::Erase(..) => Ok(vec![]),+ // Deleting around the composition starts the same typing session as the commit that+ // follows, so the replacement is one undo step; an error reaches the status bar. The+ // receipt covers only this accepted deletion.+ Seq::DeleteSurrounding(before, after, unit) => {+ let target_before = crate::ime::target(&mut app.session, view);+ let stamp_before = crate::ime::stamp(&mut app.session, view);+ let r = app.session.tool_ime_delete_surrounding(before, after, unit, view);+ match &r {+ Err(e) => app.status(e.to_string()),+ Ok(_) => crate::ime::note_ime_apply(app, ctx, view, target_before, stamp_before),+ }+ r+ }+ }+}