VectorCraft: An open-source, vector art tool written by scratch in pure Rust
M0: preserve IME typing sessions and simplify input handling
skylartaylor349dafc0bd55
diff --git a/crates/tools/src/text.rs b/crates/tools/src/text.rsindex 4b59f3892..f982add4a 100644--- a/crates/tools/src/text.rs+++ b/crates/tools/src/text.rs@@ -21,7 +21,7 @@//! underlined, until the IME commits it (it then goes through [`Tool::text_input`]) or clears it.use std::ops::Range;-use std::sync::{Arc, Mutex};+use std::sync::{Arc, Mutex, PoisonError};use serde_json::{Value, json};use vectorcraft_doc::hit::hit_test;@@ -74,7 +74,7 @@ type CachedLayout = ((u64, TextObject), Arc<TextLayout>);static NEXT_EDIT_SESSION: Mutex<u64> = Mutex::new(0);fn next_edit_session() -> u64 {- let mut next = NEXT_EDIT_SESSION.lock().unwrap_or_else(|e| e.into_inner());+ let mut next = NEXT_EDIT_SESSION.lock().unwrap_or_else(PoisonError::into_inner);let session = next.checked_add(1).unwrap_or(u64::MAX);*next = session;session@@ -103,8 +103,8 @@ pub struct TypeTool {typing: Option<Typing>,preedit: Option<Preedit>,/// A command from outside the tool (`settle_interaction`, an external edit while typing) ended- /// the typing session, while the text stays open for editing. The next IME commit then starts- /// a fresh session over that edit, so it is application-origin, never `InputMethod`.+ /// the typing session, while the text stays open for editing. A commit over that edit is+ /// application-origin unless an IME deletion has already begun a fresh typing session.typing_ended: bool,/// Where the button went down, and where new type goes from there (snapped to Smart Guides).press: Option<(Point, Point)>,@@ -434,6 +434,7 @@ impl TypeTool {}if self.typing.is_none() {out.push(Action::Begin("Typing".into()));+ self.typing_ended = false;}let len = match &self.typing {Some(ty) => edit::runs_len(&ty.cur),@@ -928,15 +929,18 @@ impl Tool for TypeTool {if self.editing.is_none() {return true;}- let normalized: String =- s.chars().filter(|c| !c.is_control() || matches!(c, '\n' | '\t')).map(|c| if c == '\r' { '\n' } else { c }).collect();- if normalized != s {- return false;- }- if normalized.is_empty() {+ if s.is_empty() {return true;}- if cx.doc.setup.typographers_quotes && matches!(normalized.as_str(), "\"" | "'") {+ // A straight quote's direction depends on the character before the insertion. During a+ // commit this check still sees the pre-edit at the caret, while `text_input` replaces it+ // from its start; with a custom pair whose opening quote is straight, that can look+ // verbatim here and then be rewritten. Never claim verbatim for one.+ if cx.doc.setup.typographers_quotes && matches!(s, "\"" | "'") {+ return false;+ }+ let Some(normalized) = self.input_text(cx, s) else { return false };+ if normalized != s {return false;}let clip: String = self.clipboard.iter().map(|r| r.text.as_str()).collect();@@ -1211,78 +1215,7 @@ impl Tool for TypeTool {}None => None,};- let removed = preedit.as_ref().map_or(0, |r| r.end - r.start);- let logical_len = len - removed;- let to_logical = |byte: usize| -> usize {- match &preedit {- Some(r) if byte > r.start && byte < r.end => r.start,- Some(r) if byte >= r.end => byte - removed,- _ => byte,- }- };- let cursor = to_logical(caret);- let anchor = to_logical(anchor);- let selection_start = cursor.min(anchor);- let selection_end = cursor.max(anchor);- let selection_len = selection_end - selection_start;- if selection_len > max_bytes {- return ImeSurrounding::Unavailable("the selection is wider than the IME surrounding-text limit");- }- let budget = max_bytes - selection_len;- let before_available = selection_start;- let after_available = logical_len - selection_end;- let mut before = (budget / 2).min(before_available);- let mut after = (budget - before).min(after_available);- before = (budget - after).min(before_available);- after = (budget - before).min(after_available);- let mut window_start = selection_start - before;- let mut window_end = selection_end + after;- let logical_boundary = |byte: usize| -> bool {- match &preedit {- Some(r) if byte == r.start => true,- Some(r) if byte < r.start => plain_is_boundary(&segments, byte),- Some(_) => plain_is_boundary(&segments, byte + removed),- None => plain_is_boundary(&segments, byte),- }- };- while window_start < selection_start && !logical_boundary(window_start) {- window_start += 1;- }- while selection_end < window_end && !logical_boundary(window_end) {- window_end -= 1;- }- let to_original = |byte: usize| -> usize {- match &preedit {- Some(r) if byte > r.start => byte + removed,- _ => byte,- }- };- let original_start = to_original(window_start);- let original_end = to_original(window_end);- let mut text = String::with_capacity(window_end - window_start);- match &preedit {- Some(r) => {- if window_start < r.start {- let first_end = original_end.min(r.start);- if original_start < first_end {- copy_plain_range(&segments, original_start, first_end, &mut text);- }- }- if r.start < window_end {- let second_start = r.end.max(original_start);- if second_start < original_end {- copy_plain_range(&segments, second_start, original_end, &mut text);- }- }- }- None => {- if original_start < original_end {- copy_plain_range(&segments, original_start, original_end, &mut text);- }- }- }- debug_assert_eq!(text.len(), window_end - window_start, "removing the pre-edit must preserve the logical window length");- ImeSurrounding::Available { text, cursor: cursor - window_start, anchor: anchor - window_start }+ ime_surrounding_window(&segments, preedit, len, caret, anchor, max_bytes)}fn composing(&self) -> bool {self.preedit.is_some()@@ -1485,6 +1418,90 @@ impl Tool for TypeTool {}}+/// The logical IME surrounding window: the pre-edit is removed and the caret/anchor offsets+/// are remapped around it. `preedit` has already been validated against `segments`.+fn ime_surrounding_window(+ segments: &[&str],+ preedit: Option<Range<usize>>,+ len: usize,+ caret: usize,+ anchor: usize,+ max_bytes: usize,+) -> ImeSurrounding {+ let removed = preedit.as_ref().map_or(0, |r| r.end - r.start);+ let logical_len = len - removed;+ let to_logical = |byte: usize| -> usize {+ match &preedit {+ Some(r) if byte > r.start && byte < r.end => r.start,+ Some(r) if byte >= r.end => byte - removed,+ _ => byte,+ }+ };+ let cursor = to_logical(caret);+ let anchor = to_logical(anchor);+ let selection_start = cursor.min(anchor);+ let selection_end = cursor.max(anchor);+ let selection_len = selection_end - selection_start;+ if selection_len > max_bytes {+ return ImeSurrounding::Unavailable("the selection is wider than the IME surrounding-text limit");+ }+ let budget = max_bytes - selection_len;+ let before_available = selection_start;+ let after_available = logical_len - selection_end;+ let mut before = (budget / 2).min(before_available);+ let mut after = (budget - before).min(after_available);+ before = (budget - after).min(before_available);+ after = (budget - before).min(after_available);+ let mut window_start = selection_start - before;+ let mut window_end = selection_end + after;+ let logical_boundary = |byte: usize| -> bool {+ match &preedit {+ Some(r) if byte == r.start => true,+ Some(r) if byte < r.start => plain_is_boundary(segments, byte),+ Some(_) => plain_is_boundary(segments, byte + removed),+ None => plain_is_boundary(segments, byte),+ }+ };+ while window_start < selection_start && !logical_boundary(window_start) {+ window_start += 1;+ }+ while selection_end < window_end && !logical_boundary(window_end) {+ window_end -= 1;+ }+ let to_original = |byte: usize| -> usize {+ match &preedit {+ Some(r) if byte > r.start => byte + removed,+ _ => byte,+ }+ };+ let original_start = to_original(window_start);+ let original_end = to_original(window_end);+ let mut text = String::with_capacity(window_end - window_start);+ match &preedit {+ Some(r) => {+ if window_start < r.start {+ let first_end = original_end.min(r.start);+ if original_start < first_end {+ copy_plain_range(segments, original_start, first_end, &mut text);+ }+ }+ if r.start < window_end {+ let second_start = r.end.max(original_start);+ if second_start < original_end {+ copy_plain_range(segments, second_start, original_end, &mut text);+ }+ }+ }+ None => {+ if original_start < original_end {+ copy_plain_range(segments, original_start, original_end, &mut text);+ }+ }+ }+ debug_assert_eq!(text.len(), window_end - window_start, "removing the pre-edit must preserve the logical window length");+ ImeSurrounding::Available { text, cursor: cursor - window_start, anchor: anchor - window_start }+}+#[cfg(test)]#[path = "text_tests.rs"]mod tests;diff --git a/crates/ui-egui/src/dialogs/tests_accessibility.rs b/crates/ui-egui/src/dialogs/tests_accessibility.rsindex 1c0f4a826..a86087b26 100644--- a/crates/ui-egui/src/dialogs/tests_accessibility.rs+++ b/crates/ui-egui/src/dialogs/tests_accessibility.rs@@ -8,7 +8,8 @@ use egui_kittest::kittest::Queryable;use serde_json::json;use vectorcraft_engine::Session;-use super::*;+use super::show;+use crate::VectorcraftApp;type Harness = egui_kittest::Harness<'static, VectorcraftApp>;diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rsindex ec7a5e4b2..ab1dc15be 100644--- a/crates/ui-egui/src/shortcuts.rs+++ b/crates/ui-egui/src/shortcuts.rs@@ -6,6 +6,7 @@ use craft_keymap::{Active, CommandRef};use egui::{Key, KeyboardShortcut, Modifiers};use serde_json::json;use vectorcraft_engine::cmd::clipboard::{Flavour, TEXT};+use vectorcraft_engine::{Result as EngineResult, UiRequest, ViewInfo};use vectorcraft_tools::{Mods, SurroundingUnit, ToolKey};use crate::VectorcraftApp;@@ -219,6 +220,22 @@ 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();@@ -233,21 +250,55 @@ fn type_text(app: &mut VectorcraftApp, ctx: &egui::Context) -> bool {// 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.- 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),+ 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@@ -321,159 +372,130 @@ fn type_text(app: &mut VectorcraftApp, ctx: &egui::Context) -> bool {}i.events = kept;});- 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;+ 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![])}- 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,- _ => {}+ 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![])}- // 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,- _ => {}+ Seq::InterruptCommand => {+ if crate::ime::blocked(app, ctx) {+ *old_composition_retired |= crate::ime::defer_interrupt(app, ctx);}+ Ok(vec![])}- 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 = 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);}- 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() {+ 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);}- 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),+ 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}- 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+ 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),}- };- if result.is_ok() && from_ime {- if terminal_commit {- app.ime_compositions.remove(&viewport);- } else {- crate::ime::remember_incoming(app, ctx, preedit_empty);+ 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}}- old_composition_retired}pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {diff --git a/crates/ui-egui/src/tests_lifecycle.rs b/crates/ui-egui/src/tests_lifecycle.rsindex d5cc6267b..8dbdd503d 100644--- a/crates/ui-egui/src/tests_lifecycle.rs+++ b/crates/ui-egui/src/tests_lifecycle.rs@@ -1158,6 +1158,63 @@ fn an_ime_commit_the_document_rewrites_is_other() {assert_eq!(filtered.change_cause, egui::output::ImeChangeCause::Other, "filtering is not an IME insertion");}+#[test]+fn an_ime_quote_commit_uses_the_character_before_its_pre_edit() {+ let (mut app, id) = app_with_text("a");+ // The pre-edit ends in an opening quote, but replacement starts after the letter `a`.+ app.run("document.setup", json!({"quotes": {"double": ["\"", "”"]}})).unwrap();+ let ctx = egui::Context::default();+ ime_frame(&mut app, &ctx, vec![], |_| {});+ ime_frame(&mut app, &ctx, vec![], |_| {});+ begin_typing(&mut app, &ctx, id);+ app.session.set_tool_option("select", &json!({"start": 1, "end": 1}));+ ime_frame(&mut app, &ctx, vec![], |_| {});+ ime_frame(&mut app, &ctx, vec![preedit("\"", 1)], |_| {});+ let committed = ime_frame(&mut app, &ctx, vec![Event::Ime(egui::ImeEvent::Commit("\"".into()))], |_| {}).expect("still editing");+ assert_eq!(plain(&app, id), "a”", "the document inserts its closing quote");+ assert_eq!(committed.change_cause, egui::output::ImeChangeCause::Other, "a rewritten quote is not an unchanged IME insertion");+}++/// An outside command can end the typing session (`endTyping`) while the Type tool still owns+/// the IME. The IME's following `DeleteSurrounding` starts a new typing session; that session+/// must clear the ended marker, so after its commit and a caret move the next ordinary IME+/// commit is an accepted `InputMethod` mutation, not an application edit.+#[test]+fn ime_delete_surrounding_after_end_typing_keeps_the_next_commit_input_method() {+ let (mut app, id) = app_with_text("abc");+ let ctx = egui::Context::default();+ ime_frame(&mut app, &ctx, vec![], |_| {});+ ime_frame(&mut app, &ctx, vec![], |_| {});+ begin_typing(&mut app, &ctx, id);+ app.session.set_tool_option("select", &json!({"start": 3, "end": 3}));+ ime_frame(&mut app, &ctx, vec![], |_| {});+ // A real typing session, settled by an outside command as `settle_interaction` does.+ ime_frame(&mut app, &ctx, vec![Event::Text("x".into())], |_| {}).expect("typing owns the IME");+ assert_eq!(plain(&app, id), "abcx");+ ime_frame(&mut app, &ctx, vec![], |app| {+ app.session.commit_interaction().expect("the typing preview is committed");+ app.session.set_tool_option("endTyping", &json!(true));+ });+ // The IME deletes the typed character and commits its replacement in the new session.+ let deleted = ime_frame(+ &mut app,+ &ctx,+ vec![Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 1, after_bytes: 0 }), Event::Ime(egui::ImeEvent::Commit("Z".into()))],+ |_| {},+ )+ .expect("the Type tool still owns the IME");+ assert_eq!(plain(&app, id), "abcZ");+ assert_eq!(deleted.change_cause, egui::output::ImeChangeCause::InputMethod);+ // A caret move ends the deletion's session. The following IME commit starts a fresh session;+ // because no outside command ended that session, the commit is InputMethod.+ let left = egui::Event::Key { key: egui::Key::ArrowLeft, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };+ ime_frame(&mut app, &ctx, vec![left], |_| {});+ let committed =+ ime_frame(&mut app, &ctx, vec![Event::Ime(egui::ImeEvent::Commit("Q".into()))], |_| {}).expect("the Type tool still owns the IME");+ assert_eq!(plain(&app, id), "abcQZ");+ assert_eq!(committed.change_cause, egui::output::ImeChangeCause::InputMethod, "a caret move is not an application-side reset");+}+#[test]fn a_reloaded_document_gets_a_new_ime_replacement_epoch() {let (mut app, id) = app_with_text("Same");