Merge pull request #207 from imachus/pr/ja-ime
Type: input method composition (Japanese IME) in the Type tool
This commit is contained in:
Brandon Thomas
GitHub
commit
ce9f3aa7c6
|
|
@ -4220,6 +4220,8 @@ dependencies = [
|
|||
"image",
|
||||
"log",
|
||||
"muda",
|
||||
"objc2 0.6.4",
|
||||
"objc2-app-kit 0.3.2",
|
||||
"rfd",
|
||||
"serde_json",
|
||||
"vectorcraft-engine",
|
||||
|
|
|
|||
|
|
@ -147,7 +147,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
|
|||
| M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, polish | 3–6 |
|
||||
| M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
|
||||
| M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder edge erase, large-offset bug open) | 3–6 |
|
||||
| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable) and found by name on open/import, CJK names in the UI, Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel done; tab leaders, spell check, vertical type pending | 45–60 |
|
||||
| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable) and found by name on open/import, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel done; tab leaders, spell check, vertical type pending | 45–60 |
|
||||
| M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
|
||||
| M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
|
||||
| M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
|
||||
|
|
|
|||
|
|
@ -30,6 +30,8 @@ clipboard-win = { workspace = true }
|
|||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
muda = { version = "0.21", default-features = false }
|
||||
objc2 = "0.6"
|
||||
objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSTextInputContext"] }
|
||||
|
||||
[build-dependencies]
|
||||
# Icon + VERSIONINFO for vectorcraft.exe; build.rs only uses it when targeting Windows.
|
||||
|
|
|
|||
|
|
@ -42,12 +42,27 @@ impl eframe::App for App {
|
|||
}
|
||||
fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
|
||||
self.0.ui(ui);
|
||||
#[cfg(target_os = "macos")]
|
||||
if self.0.take_ime_discard() {
|
||||
discard_marked_text();
|
||||
}
|
||||
}
|
||||
fn on_exit(&mut self) {
|
||||
save_prefs(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// Tell the macOS input method to drop its composition (the Type tool kept the marked text as
|
||||
/// typed). winit's IME toggle only clears its own copy, so the IME would type it again.
|
||||
#[cfg(target_os = "macos")]
|
||||
fn discard_marked_text() {
|
||||
if let Some(mtm) = objc2::MainThreadMarker::new()
|
||||
&& let Some(ic) = objc2_app_kit::NSTextInputContext::currentInputContext(mtm)
|
||||
{
|
||||
ic.discardMarkedText();
|
||||
}
|
||||
}
|
||||
|
||||
/// Where UI preferences live: ~/Library/Application Support/VectorCraft (macOS),
|
||||
/// %APPDATA%\VectorCraft (Windows), $XDG_CONFIG_HOME or ~/.config/vectorcraft (Linux).
|
||||
fn prefs_path() -> Option<std::path::PathBuf> {
|
||||
|
|
|
|||
|
|
@ -116,10 +116,21 @@ fn set_units(s: &mut Session, p: &Value) -> Result<Value> {
|
|||
ok()
|
||||
}
|
||||
|
||||
/// A typing session in progress (the Type tool previews the whole session as one interaction).
|
||||
fn typing_in_progress(s: &Session) -> bool {
|
||||
s.active().and_then(|d| d.interaction.as_ref()).is_some_and(|it| it.label == "Typing" && it.preview.is_some())
|
||||
}
|
||||
|
||||
fn undo(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
// What is still in progress (typing, a drag) is the step to undo: keep it first, so Undo takes
|
||||
// back only that and Redo brings it back, instead of dropping it and undoing the step before.
|
||||
// A typing session also ends in the Type tool, whose caret and marked text (IME) must follow
|
||||
// the document.
|
||||
let typing = typing_in_progress(s);
|
||||
s.commit_interaction()?;
|
||||
if typing {
|
||||
s.set_tool_option("endTyping", &Value::Bool(true));
|
||||
}
|
||||
let st = s.doc_mut()?;
|
||||
let e = st.history.undo.pop().ok_or_else(|| EngineError::Other("nothing to undo".into()))?;
|
||||
let label = e.label.clone();
|
||||
|
|
|
|||
|
|
@ -157,6 +157,98 @@ fn undo_during_a_drag_takes_back_only_the_drag() {
|
|||
assert_eq!(b.x0, 100.0, "back where it was: {b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ime_composition_shows_in_place_and_commits_as_one_step() {
|
||||
// Romaji → kana → conversion → commit, as the macOS Japanese IME sends it.
|
||||
let mut s = session();
|
||||
let v = ViewInfo::default();
|
||||
s.select_tool("type", v).unwrap();
|
||||
click(&mut s, 200.0, 200.0);
|
||||
let id = s.doc().unwrap().selection.objects[0];
|
||||
let created = undo_labels(&s).len();
|
||||
s.tool_text("曲:", v).unwrap();
|
||||
for (t, r) in [("g", 1..1), ("が", 1..1), ("がg", 2..2), ("ががく", 3..3)] {
|
||||
s.tool_preedit(t, Some(r), v).unwrap();
|
||||
assert_eq!(obj(&s, id).plain_text(), format!("曲:{t}"), "marked text lays out in place");
|
||||
assert!(s.tool_composing());
|
||||
}
|
||||
// Conversion: the active clause is the whole word.
|
||||
s.tool_preedit("雅楽", Some(0..2), v).unwrap();
|
||||
assert_eq!(obj(&s, id).plain_text(), "曲:雅楽");
|
||||
assert_eq!(s.tool_options()["composing"], json!(true));
|
||||
// macOS clears the marked text, then commits.
|
||||
s.tool_preedit("", None, v).unwrap();
|
||||
s.tool_text("雅楽", v).unwrap();
|
||||
assert!(!s.tool_composing());
|
||||
assert_eq!(obj(&s, id).plain_text(), "曲:雅楽");
|
||||
assert_eq!(s.tool_options()["caret"], json!("曲:雅楽".len()));
|
||||
// Typing goes on after the commit, in the same session.
|
||||
s.tool_text("。", v).unwrap();
|
||||
key(&mut s, ToolKey::Escape, Mods::default());
|
||||
assert_eq!(obj(&s, id).plain_text(), "曲:雅楽。");
|
||||
assert_eq!(undo_labels(&s).len(), created + 1, "one undo step for the session");
|
||||
s.execute("edit.undo", &json!({})).unwrap();
|
||||
assert_eq!(obj(&s, id).plain_text(), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ime_cancel_leaves_no_undo_step_and_keeps_the_text() {
|
||||
let mut s = session();
|
||||
let v = ViewInfo::default();
|
||||
let id = text(&mut s, "雅楽");
|
||||
s.select_tool("type", v).unwrap();
|
||||
let t = obj(&s, id);
|
||||
let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
|
||||
let (a, b) = vectorcraft_text::caret_position(&lay, "雅楽".len());
|
||||
let p = t.xf * a.midpoint(b);
|
||||
click(&mut s, p.x - 0.1, p.y);
|
||||
assert!(s.tool_wants_text());
|
||||
s.set_tool_option("select", &json!({"start": 6, "end": 6}));
|
||||
let before = undo_labels(&s).len();
|
||||
s.tool_preedit("えんそう", Some(4..4), v).unwrap();
|
||||
assert_eq!(obj(&s, id).plain_text(), "雅楽えんそう");
|
||||
// Escape in the IME: the marked text goes, nothing else changes.
|
||||
s.tool_preedit("", None, v).unwrap();
|
||||
assert!(!s.tool_composing());
|
||||
assert!(!s.in_interaction(), "a cancelled composition leaves no typing session");
|
||||
assert_eq!(obj(&s, id).plain_text(), "雅楽");
|
||||
assert_eq!(undo_labels(&s).len(), before);
|
||||
// A stray clear (no composition) never deletes the selection.
|
||||
s.set_tool_option("select", &json!({"start": 0, "end": 3}));
|
||||
s.tool_preedit("", None, v).unwrap();
|
||||
assert_eq!(obj(&s, id).plain_text(), "雅楽");
|
||||
// A composition over a selection replaces it.
|
||||
s.tool_preedit("が", Some(1..1), v).unwrap();
|
||||
s.tool_preedit("", None, v).unwrap();
|
||||
s.tool_text("我", v).unwrap();
|
||||
assert_eq!(obj(&s, id).plain_text(), "我楽");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clicking_away_keeps_marked_text_as_typed_and_undo_mid_composition_is_safe() {
|
||||
let mut s = session();
|
||||
let v = ViewInfo::default();
|
||||
s.select_tool("type", v).unwrap();
|
||||
click(&mut s, 200.0, 200.0);
|
||||
let id = s.doc().unwrap().selection.objects[0];
|
||||
s.tool_preedit("しょうこ", Some(4..4), v).unwrap();
|
||||
// Keys belong to the IME while it composes.
|
||||
key(&mut s, ToolKey::Backspace, Mods::default());
|
||||
assert_eq!(obj(&s, id).plain_text(), "しょうこ");
|
||||
click(&mut s, 600.0, 500.0);
|
||||
assert!(!s.tool_composing());
|
||||
assert_eq!(obj(&s, id).plain_text(), "しょうこ", "the marked text stays, committed");
|
||||
// The UI holds Undo back while composing; if it comes anyway, the session is committed first.
|
||||
click(&mut s, 50.0, 50.0);
|
||||
let id2 = s.doc().unwrap().selection.objects[0];
|
||||
s.tool_preedit("ひちりき", Some(4..4), v).unwrap();
|
||||
s.execute("edit.undo", &json!({})).unwrap();
|
||||
assert!(!s.tool_composing());
|
||||
assert_eq!(obj(&s, id2).plain_text(), "");
|
||||
s.execute("edit.redo", &json!({})).unwrap();
|
||||
assert_eq!(obj(&s, id2).plain_text(), "ひちりき");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn type_tool_selection_replace_and_delete() {
|
||||
let mut s = session();
|
||||
|
|
|
|||
|
|
@ -214,6 +214,24 @@ impl Session {
|
|||
self.tool.wants_text()
|
||||
}
|
||||
|
||||
/// IME marked text for the active tool (see `Tool::ime_preedit`; `active_chars` counts
|
||||
/// characters).
|
||||
pub fn tool_preedit(&mut self, text: &str, active_chars: Option<std::ops::Range<usize>>, view: ViewInfo) -> Result<Vec<UiRequest>> {
|
||||
let acts = self.with_tool_cx(view, |t, cx| t.ime_preedit(cx, text, active_chars));
|
||||
self.take_tool_panic()?;
|
||||
self.apply_actions(acts)
|
||||
}
|
||||
|
||||
/// Is the active tool showing uncommitted IME text?
|
||||
pub fn tool_composing(&self) -> bool {
|
||||
self.tool.composing()
|
||||
}
|
||||
|
||||
/// The caret line (document space) the IME candidate window follows.
|
||||
pub fn tool_ime_caret(&mut self, view: ViewInfo) -> Option<(Point, Point)> {
|
||||
self.with_tool_cx(view, |t, cx| t.ime_caret(cx))
|
||||
}
|
||||
|
||||
pub fn tool_busy(&self) -> bool {
|
||||
self.tool.busy()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -385,6 +385,21 @@ pub trait Tool: Send {
|
|||
fn text_input(&mut self, _cx: &ToolContext, _s: &str) -> Vec<Action> {
|
||||
vec![]
|
||||
}
|
||||
/// IME composition (marked text) for the tool that wants text: `text` replaces the previous
|
||||
/// marked text (or the selection); an empty `text` ends the composition. `active_chars` is the
|
||||
/// clause being converted, in characters of `text`. The committed result arrives through
|
||||
/// [`Tool::text_input`].
|
||||
fn ime_preedit(&mut self, _cx: &ToolContext, _text: &str, _active_chars: Option<std::ops::Range<usize>>) -> Vec<Action> {
|
||||
vec![]
|
||||
}
|
||||
/// Is uncommitted IME text being shown? Keys, shortcuts and Undo wait while it is.
|
||||
fn composing(&self) -> bool {
|
||||
false
|
||||
}
|
||||
/// Where the IME candidate window goes: the caret line (top, bottom) in document space.
|
||||
fn ime_caret(&self, _cx: &ToolContext) -> Option<(Point, Point)> {
|
||||
None
|
||||
}
|
||||
fn notify(&mut self, _cx: &ToolContext, _what: &str) {}
|
||||
/// Called when the user switches away (finish pending work).
|
||||
fn deactivate(&mut self, _cx: &ToolContext) -> Vec<Action> {
|
||||
|
|
|
|||
|
|
@ -12,7 +12,11 @@
|
|||
//! `text.editRange` (the changed span, with its styled runs) against the session snapshot.
|
||||
//! Styling a selected range goes through `text.setRangeStyle` (the Character panel reads the
|
||||
//! selection from [`Tool::options`]).
|
||||
//!
|
||||
//! IME: the marked text of a composition is part of the typing session (so it lays out in place),
|
||||
//! 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 serde_json::{Value, json};
|
||||
|
|
@ -38,6 +42,15 @@ struct Typing {
|
|||
cur: Vec<TextRun>,
|
||||
}
|
||||
|
||||
/// IME marked text inside the typing session, not yet committed.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
struct Preedit {
|
||||
/// Byte range of the marked text in the session's runs.
|
||||
range: Range<usize>,
|
||||
/// The clause being converted, in bytes relative to `range.start` (empty: the IME's cursor).
|
||||
active: Option<Range<usize>>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct TypeTool {
|
||||
vertical: bool,
|
||||
|
|
@ -52,6 +65,7 @@ pub struct TypeTool {
|
|||
/// Horizontal position kept by Up/Down (text space).
|
||||
goal_x: Option<f64>,
|
||||
typing: Option<Typing>,
|
||||
preedit: Option<Preedit>,
|
||||
press: Option<Point>,
|
||||
drag: Option<Point>,
|
||||
/// The press landed in the edited text: dragging selects.
|
||||
|
|
@ -113,8 +127,10 @@ impl TypeTool {
|
|||
(self.caret.min(self.anchor), self.caret.max(self.anchor))
|
||||
}
|
||||
|
||||
/// End the typing session (one undo step).
|
||||
/// End the typing session (one undo step). Marked text left by an IME stays as typed (as
|
||||
/// clicking away from a composition does in macOS text views); the UI interrupts the IME.
|
||||
fn commit(&mut self) -> Vec<Action> {
|
||||
self.preedit = None;
|
||||
if self.typing.take().is_some() { vec![Action::Commit] } else { vec![] }
|
||||
}
|
||||
|
||||
|
|
@ -187,6 +203,7 @@ impl TypeTool {
|
|||
self.anchor = caret;
|
||||
self.goal_x = None;
|
||||
self.typing = None;
|
||||
self.preedit = None;
|
||||
}
|
||||
|
||||
/// Byte under `p` in the edited text if `p` is inside it (frame, path band or layout bounds).
|
||||
|
|
@ -277,6 +294,14 @@ impl TypeTool {
|
|||
}
|
||||
}
|
||||
|
||||
/// Byte range in `s` of the characters `r` (IME ranges count characters; carets count bytes).
|
||||
/// `None` when `r` runs past the end of `s` or backwards.
|
||||
fn char_range_to_bytes(s: &str, r: Range<usize>) -> Option<Range<usize>> {
|
||||
let byte = |c: usize| if c == s.chars().count() { Some(s.len()) } else { s.char_indices().nth(c).map(|(i, _)| i) };
|
||||
let (a, b) = (byte(r.start)?, byte(r.end)?);
|
||||
(a <= b).then_some(a..b)
|
||||
}
|
||||
|
||||
/// Lengths of the common prefix and suffix of `a` and `b` (on char boundaries, not overlapping).
|
||||
fn common_affixes(a: &str, b: &str) -> (usize, usize) {
|
||||
let mut p = 0;
|
||||
|
|
@ -371,6 +396,15 @@ impl Tool for TypeTool {
|
|||
return vec![];
|
||||
}
|
||||
let s: String = s.chars().filter(|c| !c.is_control() || matches!(c, '\n' | '\t')).map(|c| if c == '\r' { '\n' } else { c }).collect();
|
||||
// An IME commit replaces its marked text (an empty commit just removes it).
|
||||
let committing = self.preedit.is_some();
|
||||
if committing && s.is_empty() {
|
||||
return self.ime_preedit(cx, "", None);
|
||||
}
|
||||
if let Some(p) = self.preedit.take() {
|
||||
self.anchor = p.range.start;
|
||||
self.caret = p.range.end;
|
||||
}
|
||||
if s.is_empty() {
|
||||
return vec![];
|
||||
}
|
||||
|
|
@ -387,13 +421,17 @@ impl Tool for TypeTool {
|
|||
self.clicks = (None, 0);
|
||||
// Pasting what we copied keeps its formatting (unless pasted text is kept plain).
|
||||
let clip: String = self.clipboard.iter().map(|r| r.text.as_str()).collect();
|
||||
if s.len() > 1 && s == clip && !cx.paste_plain_text {
|
||||
if !committing && s.len() > 1 && s == clip && !cx.paste_plain_text {
|
||||
let runs = self.clipboard.clone();
|
||||
return self.replace(cx, "", Some(runs));
|
||||
}
|
||||
self.replace(cx, &s, None)
|
||||
}
|
||||
fn key(&mut self, cx: &ToolContext, key: ToolKey, mods: Mods) -> Vec<Action> {
|
||||
// The IME owns the keys while it composes (the UI doesn't send them; this is a guard).
|
||||
if self.preedit.is_some() {
|
||||
return vec![];
|
||||
}
|
||||
let Some(t) = self.current(cx) else {
|
||||
self.editing = None;
|
||||
return vec![];
|
||||
|
|
@ -485,6 +523,51 @@ impl Tool for TypeTool {
|
|||
_ => vec![],
|
||||
}
|
||||
}
|
||||
fn ime_preedit(&mut self, cx: &ToolContext, text: &str, active_chars: Option<Range<usize>>) -> Vec<Action> {
|
||||
if self.editing.is_none() {
|
||||
return vec![];
|
||||
}
|
||||
// A clear with nothing marked (some integrations send one when the IME is enabled) must
|
||||
// not delete the selection.
|
||||
if text.is_empty() && self.preedit.is_none() {
|
||||
return vec![];
|
||||
}
|
||||
let text: String = text.chars().filter(|c| !c.is_control()).collect();
|
||||
// The new marked text replaces the previous one, or the selection when it starts.
|
||||
if let Some(p) = self.preedit.take() {
|
||||
self.anchor = p.range.start;
|
||||
self.caret = p.range.end;
|
||||
}
|
||||
self.clicks = (None, 0);
|
||||
let mut out = self.replace(cx, &text, None);
|
||||
if text.is_empty() {
|
||||
// Cancelled before anything else was typed: no empty undo step.
|
||||
if self.typing.as_ref().is_some_and(|ty| ty.cur == ty.base) {
|
||||
self.typing = None;
|
||||
out.push(Action::Cancel);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
let end = self.caret;
|
||||
let start = end.saturating_sub(text.len());
|
||||
self.preedit = Some(Preedit { range: start..end, active: active_chars.and_then(|r| char_range_to_bytes(&text, r)) });
|
||||
out
|
||||
}
|
||||
fn composing(&self) -> bool {
|
||||
self.preedit.is_some()
|
||||
}
|
||||
fn ime_caret(&self, cx: &ToolContext) -> Option<(Point, Point)> {
|
||||
let t = self.current(cx)?;
|
||||
let lay = self.layout(&t);
|
||||
let len = t.plain_text().len();
|
||||
// The candidate window follows the clause being converted, else the caret.
|
||||
let at = match &self.preedit {
|
||||
Some(p) => p.range.start + p.active.as_ref().map_or(0, |r| r.start),
|
||||
None => self.caret.min(self.anchor),
|
||||
};
|
||||
let (a, b) = vectorcraft_text::caret_position(&lay, at.min(len));
|
||||
Some((t.xf * a, t.xf * b))
|
||||
}
|
||||
fn deactivate(&mut self, cx: &ToolContext) -> Vec<Action> {
|
||||
self.finish(cx)
|
||||
}
|
||||
|
|
@ -510,13 +593,14 @@ impl Tool for TypeTool {
|
|||
self.fresh = Self::text(cx, id).filter(|t| matches!(t.kind, TextKind::Point)).map(|_| id);
|
||||
}
|
||||
}
|
||||
/// `{editing, start, end, caret, anchor, typing}` — the Character panel styles `start..end`.
|
||||
/// `{editing, start, end, caret, anchor, typing, composing}` — the Character panel styles
|
||||
/// `start..end`.
|
||||
fn options(&self) -> Value {
|
||||
match self.editing {
|
||||
Some(id) => {
|
||||
// Offsets may exceed the text after Select All; callers clamp to the text length.
|
||||
let (a, b) = self.sel();
|
||||
json!({"editing": id.0, "start": a, "end": b, "caret": self.caret, "anchor": self.anchor, "typing": self.typing.is_some()})
|
||||
json!({"editing": id.0, "start": a, "end": b, "caret": self.caret, "anchor": self.anchor, "typing": self.typing.is_some(), "composing": self.preedit.is_some()})
|
||||
}
|
||||
None => json!({"editing": null}),
|
||||
}
|
||||
|
|
@ -525,7 +609,10 @@ impl Tool for TypeTool {
|
|||
/// `commitTyping` (the caller commits the engine interaction).
|
||||
fn set_option(&mut self, key: &str, v: &Value) {
|
||||
match key {
|
||||
"commitTyping" | "endTyping" => self.typing = None,
|
||||
"commitTyping" | "endTyping" => {
|
||||
self.typing = None;
|
||||
self.preedit = None;
|
||||
}
|
||||
"selectAll" if self.editing.is_some() => {
|
||||
self.anchor = 0;
|
||||
self.caret = usize::MAX / 4;
|
||||
|
|
@ -544,6 +631,7 @@ impl Tool for TypeTool {
|
|||
}
|
||||
"stopEditing" => {
|
||||
self.typing = None;
|
||||
self.preedit = None;
|
||||
self.editing = None;
|
||||
}
|
||||
_ => {}
|
||||
|
|
@ -578,7 +666,24 @@ impl Tool for TypeTool {
|
|||
o.push(Overlay::Path { path: f, color: [79, 128, 255], width: 1.0, dashed: false });
|
||||
}
|
||||
let (a, b) = (self.caret.min(self.anchor).min(len), self.caret.max(self.anchor).min(len));
|
||||
if a == b {
|
||||
if let Some(pe) = &self.preedit {
|
||||
// Marked text: a thin underline, a thick one under the clause being converted.
|
||||
let under = |o: &mut Vec<Overlay>, r: Range<usize>, width: f32| {
|
||||
for q in vectorcraft_text::selection_quads(&lay, r.start.min(len), r.end.min(len)) {
|
||||
let (l, rr) = (t.xf * q[3], t.xf * q[2]);
|
||||
o.push(Overlay::Path { path: vectorcraft_geom::Line::new(l, rr).to_path(0.1), color: [0, 0, 0], width, dashed: false });
|
||||
}
|
||||
};
|
||||
under(&mut o, pe.range.clone(), 1.0);
|
||||
match &pe.active {
|
||||
Some(r) if !r.is_empty() => under(&mut o, pe.range.start + r.start..pe.range.start + r.end, 2.5),
|
||||
_ => {
|
||||
let at = pe.range.start + pe.active.as_ref().map_or(pe.range.len(), |r| r.start);
|
||||
let (p, q) = vectorcraft_text::caret_position(&lay, at.min(len));
|
||||
o.push(Overlay::Line { a: t.xf * p, b: t.xf * q, color: [0, 0, 0], dashed: false });
|
||||
}
|
||||
}
|
||||
} else if a == b {
|
||||
let (p, q) = vectorcraft_text::caret_position(&lay, self.caret.min(len));
|
||||
o.push(Overlay::Line { a: t.xf * p, b: t.xf * q, color: [0, 0, 0], dashed: false });
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -227,3 +227,49 @@ fn vertical_tools_preserve_their_ids_and_create_vertical_text() {
|
|||
assert!(tool.vertical);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ime_ranges_convert_characters_to_bytes() {
|
||||
assert_eq!(char_range_to_bytes("ががく", 1..3), Some(3..9));
|
||||
assert_eq!(char_range_to_bytes("ががく", 3..3), Some(9..9));
|
||||
assert_eq!(char_range_to_bytes("a雅b", 1..2), Some(1..4));
|
||||
assert_eq!(char_range_to_bytes("ががく", 2..4), None, "past the end");
|
||||
#[allow(clippy::reversed_empty_ranges)]
|
||||
let backwards = 2..1;
|
||||
assert_eq!(char_range_to_bytes("ががく", backwards), None, "backwards");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn marked_text_is_underlined_with_the_converting_clause_thick() {
|
||||
let (mut d, id, mut tool) = editing("曲");
|
||||
let snap = d.clone();
|
||||
let (sel, p) = (Selection::default(), paint());
|
||||
tool.caret = 3;
|
||||
tool.anchor = 3;
|
||||
let acts = tool.ime_preedit(&cx(&d, &sel, &p), "雅楽演奏", Some(2..4));
|
||||
apply(&mut d, &snap, &acts);
|
||||
let NodeKind::Text(t) = &d.node(id).unwrap().kind else { panic!() };
|
||||
assert_eq!(t.plain_text(), "曲雅楽演奏");
|
||||
assert_eq!(tool.preedit, Some(Preedit { range: 3..15, active: Some(6..12) }));
|
||||
let widths: Vec<f32> = tool
|
||||
.overlays(&cx(&d, &sel, &p))
|
||||
.iter()
|
||||
.filter_map(|o| match o {
|
||||
Overlay::Path { width, .. } => Some(*width),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(widths, vec![1.0, 2.5], "a thin underline, then the thick one under 演奏");
|
||||
// The candidate window follows the converting clause.
|
||||
let (top, _) = tool.ime_caret(&cx(&d, &sel, &p)).unwrap();
|
||||
let lay = vectorcraft_text::layout(FontDb::global(), t);
|
||||
let (at, _) = vectorcraft_text::caret_position(&lay, 9);
|
||||
assert!((top - t.xf * at).hypot() < 1e-6);
|
||||
// Keys wait for the IME; a commit replaces the marked text.
|
||||
assert!(key(&mut tool, &d, ToolKey::Backspace, Mods::default()).is_empty());
|
||||
let acts = tool.text_input(&cx(&d, &sel, &p), "雅楽演奏会");
|
||||
apply(&mut d, &snap, &acts);
|
||||
let NodeKind::Text(t) = &d.node(id).unwrap().kind else { panic!() };
|
||||
assert_eq!(t.plain_text(), "曲雅楽演奏会");
|
||||
assert!(!tool.composing());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -337,6 +337,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
|
|||
let overlays = app.session.overlays(view_info);
|
||||
draw_overlays(&painter, &xf, &overlays, &t);
|
||||
}
|
||||
ime_output(app, ui.ctx(), &xf);
|
||||
crate::place::paint_drop_highlight(app, ui.ctx(), &painter, rect);
|
||||
|
||||
if app.ui.view.rulers && app.ui.screen_mode < 3 {
|
||||
|
|
@ -1170,6 +1171,28 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
|
|||
}
|
||||
}
|
||||
|
||||
/// While the Type tool edits, let the system IME compose (egui-winit allows it only in frames that
|
||||
/// set `ime`) and keep its candidate window under the caret.
|
||||
fn ime_output(app: &mut VectorcraftApp, ctx: &egui::Context, xf: &Xf) {
|
||||
let ours = app.session.tool_wants_text() && !ctx.egui_wants_keyboard_input() && app.ui.dialog.is_none() && !app.ui.palette_open;
|
||||
let caret = if ours { app.session.tool_ime_caret(app.view_info()) } else { None };
|
||||
let Some((a, b)) = caret else {
|
||||
// The IME goes away with its marked text: keep that text as typed, like a click away.
|
||||
crate::shortcuts::keep_marked_text(app);
|
||||
return;
|
||||
};
|
||||
let r = egui::Rect::from_two_pos(xf.to_screen(a), xf.to_screen(b)).expand2(vec2(1.0, 0.0));
|
||||
// The tool ended the composition itself: the IME must drop what it still has marked.
|
||||
let interrupt = app.ime_marked.is_some() && !app.session.tool_composing();
|
||||
if interrupt {
|
||||
app.ime_marked = None;
|
||||
app.ime_discard = true;
|
||||
}
|
||||
ctx.output_mut(|o| {
|
||||
o.ime = Some(egui::output::IMEOutput { purpose: egui::IMEPurpose::Normal, rect: r, cursor_rect: r, should_interrupt_composition: interrupt });
|
||||
});
|
||||
}
|
||||
|
||||
fn draw_overlays(p: &egui::Painter, xf: &Xf, overlays: &[Overlay], t: &Tokens) {
|
||||
for o in overlays {
|
||||
match o {
|
||||
|
|
@ -1543,4 +1566,136 @@ mod tests {
|
|||
assert_eq!(*st.doc, *before);
|
||||
assert_eq!(st.history.undo.len(), undo);
|
||||
}
|
||||
|
||||
/// One frame of keyboard handling and canvas, as the app runs them; returns the IME output.
|
||||
fn typing_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> Option<egui::output::IMEOutput> {
|
||||
let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), events, ..Default::default() };
|
||||
let mut out = ctx.run_ui(raw, |ui| {
|
||||
crate::shortcuts::handle(app, ui.ctx());
|
||||
show(app, ui);
|
||||
});
|
||||
out.textures_delta.clear();
|
||||
out.platform_output.ime
|
||||
}
|
||||
|
||||
fn preedit(t: &str, chars: usize) -> egui::Event {
|
||||
egui::Event::Ime(egui::ImeEvent::Preedit { text: t.into(), active_range_chars: Some(chars..chars) })
|
||||
}
|
||||
|
||||
fn plain(app: &VectorcraftApp, id: u64) -> String {
|
||||
match &app.session.active().unwrap().doc.node(vectorcraft_doc::NodeId(id)).unwrap().kind {
|
||||
NodeKind::Text(t) => t.plain_text(),
|
||||
_ => panic!("not text"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn japanese_ime_composes_on_the_canvas_with_its_window_at_the_caret() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
// Not editing: the IME stays off (single-key tool shortcuts keep working).
|
||||
assert!(typing_frame(&mut app, &ctx, vec![]).is_none());
|
||||
app.select_tool("type");
|
||||
let xf = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap());
|
||||
let at = xf.to_screen(Point::new(100.0, 100.0));
|
||||
let click =
|
||||
|p: Pos2, pressed| egui::Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at), click(at, true)]);
|
||||
typing_frame(&mut app, &ctx, vec![click(at, false)]);
|
||||
assert!(app.session.tool_wants_text());
|
||||
let id = app.session.active().unwrap().selection.objects[0].0;
|
||||
// Editing: the IME is allowed, its window at the caret (the text's baseline at y = 100).
|
||||
let ime = typing_frame(&mut app, &ctx, vec![]).expect("IME allowed while editing");
|
||||
assert!(ime.rect.contains(pos2(ime.rect.center().x, at.y)) && (ime.rect.center().x - at.x).abs() < 2.0, "{:?} vs {at:?}", ime.rect);
|
||||
assert!(!ime.should_interrupt_composition);
|
||||
// gagaku → がが → 雅楽, then commit (the macOS sequence).
|
||||
typing_frame(&mut app, &ctx, vec![preedit("g", 1)]);
|
||||
typing_frame(&mut app, &ctx, vec![preedit("が", 1), preedit("がg", 2)]);
|
||||
typing_frame(&mut app, &ctx, vec![preedit("ががく", 3)]);
|
||||
assert_eq!(plain(&app, id), "ががく");
|
||||
// While composing: plain text events, the clipboard and Undo (the native menu's ⌘Z
|
||||
// reaches `menus::invoke`) all wait.
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::Text("x".into()), egui::Event::Paste("y".into())]);
|
||||
crate::menus::invoke(&mut app, "edit.undo", json!({}));
|
||||
assert!(!crate::menus::enabled(&app, "edit.undo"));
|
||||
assert_eq!(plain(&app, id), "ががく");
|
||||
let ime2 =
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "雅楽".into(), active_range_chars: Some(0..2) })])
|
||||
.unwrap();
|
||||
assert!(ime2.rect.center().x <= ime.rect.center().x + 1.0, "the window stays at the clause being converted");
|
||||
typing_frame(&mut app, &ctx, vec![preedit("", 0), egui::Event::Ime(egui::ImeEvent::Commit("雅楽".into()))]);
|
||||
assert_eq!(plain(&app, id), "雅楽");
|
||||
assert!(!app.session.tool_composing());
|
||||
// After the commit, text and Undo work again.
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::Text("!".into())]);
|
||||
assert_eq!(plain(&app, id), "雅楽!");
|
||||
crate::menus::invoke(&mut app, "edit.undo", json!({}));
|
||||
assert_eq!(plain(&app, id), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clicking_away_mid_composition_keeps_the_text_and_interrupts_the_ime() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
typing_frame(&mut app, &ctx, vec![]);
|
||||
app.select_tool("type");
|
||||
let xf = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap());
|
||||
let (a, b) = (xf.to_screen(Point::new(100.0, 100.0)), xf.to_screen(Point::new(300.0, 250.0)));
|
||||
let click =
|
||||
|p: Pos2, pressed| egui::Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(a), click(a, true)]);
|
||||
typing_frame(&mut app, &ctx, vec![click(a, false)]);
|
||||
let id = app.session.active().unwrap().selection.objects[0].0;
|
||||
typing_frame(&mut app, &ctx, vec![preedit("しょうこ", 4)]);
|
||||
// macOS sends nothing for a click away; the tool keeps the marked text and the IME is
|
||||
// told to drop its composition.
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(b), click(b, true)]);
|
||||
let ime = typing_frame(&mut app, &ctx, vec![click(b, false)]);
|
||||
assert_eq!(plain(&app, id), "しょうこ");
|
||||
assert!(!app.session.tool_composing());
|
||||
assert!(ime.expect("editing the new text").should_interrupt_composition);
|
||||
assert!(app.ime_marked.is_none());
|
||||
assert!(app.take_ime_discard(), "the host tells the system IME to drop its marked text");
|
||||
// Interrupted once, not every frame.
|
||||
assert!(!typing_frame(&mut app, &ctx, vec![]).unwrap().should_interrupt_composition);
|
||||
assert!(!app.take_ime_discard());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ime_edge_orders_never_eat_committed_text_or_lose_the_composition() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
typing_frame(&mut app, &ctx, vec![]);
|
||||
app.select_tool("type");
|
||||
let xf = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap());
|
||||
let at = xf.to_screen(Point::new(100.0, 100.0));
|
||||
let click =
|
||||
|p: Pos2, pressed| egui::Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at), click(at, true)]);
|
||||
typing_frame(&mut app, &ctx, vec![click(at, false)]);
|
||||
let id = app.session.active().unwrap().selection.objects[0].0;
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::Text("雅".into())]);
|
||||
let backspace =
|
||||
|pressed| egui::Event::Key { key: egui::Key::Backspace, physical_key: None, pressed, repeat: false, modifiers: Default::default() };
|
||||
// The IME empties its marked text and the Backspace comes in the same frame.
|
||||
typing_frame(&mut app, &ctx, vec![preedit("が", 1)]);
|
||||
typing_frame(&mut app, &ctx, vec![preedit("", 0), backspace(true), backspace(false)]);
|
||||
assert_eq!(plain(&app, id), "雅", "the committed character stays");
|
||||
// A bare line-break commit ends the composition with the marked text, no newline.
|
||||
typing_frame(&mut app, &ctx, vec![preedit("がく", 2)]);
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::Ime(egui::ImeEvent::Commit("\n".into()))]);
|
||||
assert!(!app.session.tool_composing());
|
||||
assert_eq!(plain(&app, id), "雅がく");
|
||||
assert!(app.take_ime_discard());
|
||||
// Switching apps mid-composition: the composition goes on when the window comes back.
|
||||
typing_frame(&mut app, &ctx, vec![preedit("らく", 2)]);
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::WindowFocused(false)]);
|
||||
typing_frame(&mut app, &ctx, vec![egui::Event::WindowFocused(true), preedit("らくか", 3)]);
|
||||
assert!(app.session.tool_composing());
|
||||
assert!(!app.take_ime_discard());
|
||||
assert_eq!(plain(&app, id), "雅がくらくか");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -303,6 +303,11 @@ pub struct VectorcraftApp {
|
|||
host_modifiers: egui::Modifiers,
|
||||
/// Synthetic input set the modifiers egui holds (see [`Self::raw_input_hook`]).
|
||||
synthetic_modifiers: bool,
|
||||
/// The marked text the system IME last sent (`None` once it commits or clears). When the Type
|
||||
/// tool stops composing on its own (a click, a tool switch), the IME is told to drop it.
|
||||
pub(crate) ime_marked: Option<String>,
|
||||
/// The IME must drop its marked text (see [`Self::take_ime_discard`]).
|
||||
pub(crate) ime_discard: bool,
|
||||
}
|
||||
|
||||
/// Seconds between two looks at the system clipboard for [`VectorcraftApp::system_paste`].
|
||||
|
|
@ -362,6 +367,8 @@ impl VectorcraftApp {
|
|||
recovery: Default::default(),
|
||||
host_modifiers: Default::default(),
|
||||
synthetic_modifiers: false,
|
||||
ime_marked: None,
|
||||
ime_discard: false,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -577,6 +584,13 @@ impl VectorcraftApp {
|
|||
});
|
||||
}
|
||||
|
||||
/// Did the Type tool end an IME composition on its own this frame? Interrupting the IME
|
||||
/// through egui (`should_interrupt_composition`) doesn't reach the macOS input context, which
|
||||
/// keeps the marked text and types it again into the next composition: the host discards it.
|
||||
pub fn take_ime_discard(&mut self) -> bool {
|
||||
std::mem::take(&mut self.ime_discard)
|
||||
}
|
||||
|
||||
/// Show a transient status message.
|
||||
pub fn status(&mut self, s: impl Into<String>) {
|
||||
self.ui.status = s.into();
|
||||
|
|
|
|||
|
|
@ -1372,7 +1372,21 @@ pub fn shortcut_of(id: &str) -> Option<&'static str> {
|
|||
}
|
||||
|
||||
/// Is a command currently enabled?
|
||||
/// Commands that would act on the text being typed, held back while an IME composes in the Type
|
||||
/// tool (its marked text isn't committed yet): Undo/Redo — the native menu takes ⌘Z ahead of the
|
||||
/// IME —, the clipboard and the selection.
|
||||
pub(crate) fn waits_for_ime(app: &VectorcraftApp, id: &str) -> bool {
|
||||
app.session.tool_composing()
|
||||
&& (matches!(
|
||||
id,
|
||||
"edit.undo" | "edit.redo" | "edit.cut" | "edit.copy" | "edit.clear" | "edit.duplicate" | "select.all" | "select.none" | "select.inverse"
|
||||
) || id.starts_with("edit.paste"))
|
||||
}
|
||||
|
||||
pub fn enabled(app: &VectorcraftApp, id: &str) -> bool {
|
||||
if waits_for_ime(app, id) {
|
||||
return false;
|
||||
}
|
||||
if let Some(c) = vectorcraft_engine::find_command(id) {
|
||||
// The system clipboard's contents can be pasted with an empty internal clipboard.
|
||||
return (c.enabled)(&app.session).is_ok() || app.system_paste && id.starts_with("edit.paste");
|
||||
|
|
@ -2344,6 +2358,9 @@ fn menu_dialog(id: &str) -> Option<(&'static str, Value)> {
|
|||
|
||||
/// Invoke a menu/command id with UI side effects (dialogs for "…" commands that need input).
|
||||
pub fn invoke(app: &mut VectorcraftApp, id: &str, p: Value) {
|
||||
if waits_for_ime(app, id) {
|
||||
return;
|
||||
}
|
||||
if let Some((kind, fields)) = menu_dialog(id)
|
||||
&& p.as_object().is_none_or(|o| o.is_empty())
|
||||
{
|
||||
|
|
|
|||
|
|
@ -129,6 +129,49 @@ impl PasteChord {
|
|||
}
|
||||
}
|
||||
|
||||
/// 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());
|
||||
}
|
||||
}
|
||||
|
||||
/// Typed text and IME events, in the order they came, to the Type tool.
|
||||
fn type_text(app: &mut VectorcraftApp, ctx: &egui::Context) {
|
||||
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 events: Vec<egui::Event> =
|
||||
ctx.input(|i| i.events.iter().filter(|e| matches!(e, egui::Event::Text(_) | egui::Event::Ime(_))).cloned().collect());
|
||||
for e in events {
|
||||
// Errors are already reported by the engine's interaction (a failed preview keeps it).
|
||||
let _ = match e {
|
||||
// Keys the IME passed through come as text only when nothing is marked.
|
||||
egui::Event::Text(t) if !app.session.tool_composing() => app.session.tool_text(&t, view),
|
||||
egui::Event::Ime(egui::ImeEvent::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.
|
||||
egui::Event::Ime(egui::ImeEvent::Commit(t)) if t == "\n" || t == "\r" => {
|
||||
keep_marked_text(app);
|
||||
Ok(vec![])
|
||||
}
|
||||
egui::Event::Ime(egui::ImeEvent::Commit(t)) => {
|
||||
app.ime_marked = None;
|
||||
app.session.tool_text(&t, view)
|
||||
}
|
||||
// `DeleteSurrounding` isn't sent by egui-winit (desktop); the web host has no IME
|
||||
// path to the canvas yet.
|
||||
_ => Ok(vec![]),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
|
||||
// Followed before anything returns, so a key typed in a field isn't taken for a paste.
|
||||
let textless_paste = ctx.input(|i| app.paste_chord.textless_paste(&i.events));
|
||||
|
|
@ -144,10 +187,12 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
|
|||
}
|
||||
let typing = ctx.egui_wants_keyboard_input();
|
||||
let view = app.view_info();
|
||||
// While an IME composes, Enter and Escape are its own (confirm / cancel).
|
||||
let composing = app.session.tool_composing();
|
||||
// Tool keys first (Enter/Escape end paths; arrows change polygon sides while dragging).
|
||||
let busy = app.session.tool_busy();
|
||||
for (k, tk) in [(Key::Enter, ToolKey::Enter), (Key::Escape, ToolKey::Escape)] {
|
||||
if !typing && ctx.input(|i| i.key_pressed(k)) {
|
||||
if !typing && !composing && ctx.input(|i| i.key_pressed(k)) {
|
||||
// A key the tool claims (Esc with a loaded place cursor) is only the tool's.
|
||||
let claimed = app.session.tool_claims_key(tk, view);
|
||||
let r = app.session.tool_key(tk, Mods::default(), view);
|
||||
|
|
@ -168,12 +213,17 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
|
|||
if typing {
|
||||
return;
|
||||
}
|
||||
// Type tool editing: text and editing keys go to the tool.
|
||||
// Type tool editing: text, IME composition and editing keys go to the tool.
|
||||
if app.session.tool_wants_text() {
|
||||
let texts: Vec<String> =
|
||||
ctx.input(|i| i.events.iter().filter_map(|e| if let egui::Event::Text(t) = e { Some(t.clone()) } else { None }).collect());
|
||||
for t in texts {
|
||||
let _ = app.session.tool_text(&t, view);
|
||||
type_text(app, ctx);
|
||||
// Keys of a frame that began composing are the IME's too (a Backspace that empties the
|
||||
// marked text must not delete the committed character before it).
|
||||
if composing || app.session.tool_composing() {
|
||||
// The IME owns the keyboard until it commits: no editing keys, clipboard or shortcuts.
|
||||
ctx.input_mut(|i| {
|
||||
i.events.retain(|e| !matches!(e, egui::Event::Key { .. } | egui::Event::Copy | egui::Event::Cut | egui::Event::Paste(_)))
|
||||
});
|
||||
return;
|
||||
}
|
||||
// Editing keys with modifiers, clipboard and Cmd+A.
|
||||
crate::panels::character::route_type_input(app, ctx);
|
||||
|
|
|
|||
Loading…
Reference in New Issue