diff --git a/README.md b/README.md index 61b5770..239eeb1 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ - **單按 Shift 強制英文**:要打英文時先單按一下 Shift,接下來這個字照打、保持小寫 - **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小) - **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」 -- **候選字**:按 ↓ 選最後一個字或詞,選過的會固定下來 +- **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來 - **全形標點**:中文語境下 `?` `!` `<` 自動變成 `?` `!` `,` - **完整詞庫**:約 17 萬筆,來自小麥注音 McBopomofo(MIT 授權) @@ -51,7 +51,8 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安 | 空白 | 注音:一聲;音節已完成時送出中文。英文:送出單字加空白 | | Enter | 送出目前組字 | | **Tab** | 判斷錯了?按 Tab 把整段翻轉成另一種語言,輸入法會**記住**這次修正 | -| ↓ | 開啟候選字(選最後一個字或詞),數字鍵 1–9 選字,Esc 關閉 | +| ← → | 在組字區移動游標,選要改哪個字 | +| ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 | | Esc | 取消組字 | | **單按 Shift** | 沒在打字時:下一個字強制英文(保持小寫),送出後恢復自動判斷,再按一次取消。打到一半時:同 Tab,整段翻轉 | | Shift + 字母 | 打大寫字母(也會強制英文) | diff --git a/Sources/AutoZhuyin/InputController.swift b/Sources/AutoZhuyin/InputController.swift index 103c7aa..3f956a0 100644 --- a/Sources/AutoZhuyin/InputController.swift +++ b/Sources/AutoZhuyin/InputController.swift @@ -117,8 +117,10 @@ final class InputController: IMKInputController { ])) } let text = marked.string + // Caret at the candidate cursor (UTF-16 offset of the first `cursorOffset` characters). + let caret = String(text.prefix(engine.cursorOffset)).utf16.count client.setMarkedText(marked, - selectionRange: NSRange(location: (text as NSString).length, length: 0), + selectionRange: NSRange(location: caret, length: 0), replacementRange: NSRange(location: NSNotFound, length: 0)) if engine.isShowingCandidates { diff --git a/Sources/AutoZhuyinCore/CompositionEngine.swift b/Sources/AutoZhuyinCore/CompositionEngine.swift index d734686..e08f57d 100644 --- a/Sources/AutoZhuyinCore/CompositionEngine.swift +++ b/Sources/AutoZhuyinCore/CompositionEngine.swift @@ -45,6 +45,9 @@ public final class CompositionEngine { private var fixed: [Int: [Range: String]] = [:] public private(set) var candidates: [Candidate] = [] private var candidateSegmentStart = 0 + /// Composition cursor for choosing candidates: index into `cursorStops`, nil = at the end. + /// ← → move it; ↓ shows candidates for the phrase ending at the cursor. + private var cursor: Int? public var candidateIndex = 0 public var isShowingCandidates: Bool { !candidates.isEmpty } @@ -89,17 +92,64 @@ public final class CompositionEngine { /// Text for one segment. A non-final Zhuyin segment shows its unfinished syllable as Bopomofo. private func render(_ seg: Segment, final: Bool) -> String { - let segKeys = Array(keys[seg.range]) - guard seg.mode == .zhuyin else { return String(segKeys) } - let p = ZhuyinParser.parse(segKeys) - let fixedHere = (fixed[seg.range.lowerBound] ?? [:]) - if final { - let all = p.syllables.map(\.syllable) - return converter.convert(all, fixed: fixedHere.filter { $0.key.upperBound <= all.count }).map(\.text).joined() + guard seg.mode == .zhuyin else { return String(keys[seg.range]) } + let (converted, pending) = conversion(of: seg, final: final) + return converted.map(\.text).joined() + pending + } + + /// Syllables of a Zhuyin segment that are converted to Chinese (all of them when + /// final, otherwise the finished ones). + private func convertibleSyllables(_ seg: Segment, final: Bool) -> (syllables: [Syllable], pending: String) { + let p = ZhuyinParser.parse(Array(keys[seg.range])) + if final { return (p.syllables.map(\.syllable), "") } + return (p.completed.map(\.syllable), p.pending?.syllable.reading ?? "") + } + + private func conversion(of seg: Segment, final: Bool) -> (segments: [ConvertedSegment], pending: String) { + let (syl, pending) = convertibleSyllables(seg, final: final) + let fixedHere = (fixed[seg.range.lowerBound] ?? [:]).filter { $0.key.upperBound <= syl.count } + return (converter.convert(syl, fixed: fixedHere), pending) + } + + // MARK: - Cursor + + /// A place the cursor can stop: after the `local`-th syllable of Zhuyin segment `segIndex`. + private struct CursorStop { let segIndex: Int; let local: Int } + + private var cursorStops: [CursorStop] { + let segs = segments + var out: [CursorStop] = [] + for (i, seg) in segs.enumerated() where seg.mode == .zhuyin { + let n = convertibleSyllables(seg, final: i < segs.count - 1).syllables.count + for k in stride(from: 1, through: n, by: 1) { out.append(CursorStop(segIndex: i, local: k)) } } - let done = p.completed.map(\.syllable) - let text = converter.convert(done, fixed: fixedHere.filter { $0.key.upperBound <= done.count }).map(\.text).joined() - return text + (p.pending?.syllable.reading ?? "") + return out + } + + /// Cursor position in `markedText`, in Characters. + public var cursorOffset: Int { + let pieces = markedPieces + let total = pieces.reduce(0) { $0 + $1.text.count } + let stops = cursorStops + guard let c = cursor, stops.indices.contains(c) else { return total } + let stop = stops[c] + var offset = pieces[..= stops.count - 1 ? nil : max(0, next) } // MARK: - Key handling @@ -112,6 +162,7 @@ public final class CompositionEngine { return handleCharacter(c) case .backspace: guard !keys.isEmpty else { return .passThrough } + cursor = nil keys.removeLast() fixed = fixed.filter { $0.key < keys.count } if keys.isEmpty { @@ -144,7 +195,15 @@ public final class CompositionEngine { guard !keys.isEmpty else { return .passThrough } openCandidates() return .consumed - case .up, .left, .right: + case .left: + guard !keys.isEmpty else { return .passThrough } + moveCursor(by: -1) + return .consumed + case .right: + guard !keys.isEmpty else { return .passThrough } + moveCursor(by: 1) + return .consumed + case .up: return keys.isEmpty ? .passThrough : .consumed } } @@ -159,6 +218,7 @@ public final class CompositionEngine { public var isEnglishArmed: Bool { keys.isEmpty && forcedMode == .literal } private func handleCharacter(_ c: Character) -> KeyResult { + cursor = nil // typing always continues at the end if c == " " { guard !keys.isEmpty else { return .passThrough } let segs = segments(of: keys, finishing: true) @@ -206,13 +266,16 @@ public final class CompositionEngine { // MARK: - Candidates (for the last Zhuyin segment) + /// Opens candidates for the phrase ending at the cursor (default: the last syllable). private func openCandidates() { + let stops = cursorStops + guard !stops.isEmpty else { return } + let stop = stops[min(cursor ?? stops.count - 1, stops.count - 1)] let segs = segments - guard let last = segs.last, last.mode == .zhuyin else { return } - let done = ZhuyinParser.parse(Array(keys[last.range])).completed.map(\.syllable) - guard !done.isEmpty else { return } - candidates = converter.candidates(done, endingAt: done.count) - candidateSegmentStart = last.range.lowerBound + let seg = segs[stop.segIndex] + let syl = convertibleSyllables(seg, final: stop.segIndex < segs.count - 1).syllables + candidates = converter.candidates(syl, endingAt: stop.local) + candidateSegmentStart = seg.range.lowerBound candidateIndex = 0 } @@ -268,6 +331,7 @@ public final class CompositionEngine { public func reset() { keys = [] + cursor = nil forcedMode = nil forcedIsCorrection = false fixed = [:] diff --git a/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift b/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift index cc44031..6a19657 100644 --- a/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift +++ b/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift @@ -351,3 +351,57 @@ final class ShiftTapTests: XCTestCase { XCTAssertFalse(d.modifiersChanged(shift: false, otherModifiers: false, time: 4.2)) } } + +final class CursorTests: XCTestCase { + func engine() -> CompositionEngine { + CompositionEngine(classifier: Classifier(lexicon: sharedLexicon, english: sharedEnglish, weights: sharedWeights)) + } + + func type(_ s: String, into e: CompositionEngine) -> String { + var out = "" + for c in s { + let key: KeyInput = c == "←" ? .left : c == "→" ? .right : c == "↓" ? .down : c == "\n" ? .enter : .character(c) + let r = e.handle(key) + if let t = r.commit { out += t } else if !r.handled { out.append(c) } + } + return out + } + + func testCursorMovesAndClamps() { + let e = engine() + _ = type("rup wu0 wu0 fu4", into: e) // 今天天氣 + XCTAssertEqual(e.cursorOffset, 4) + _ = type("←", into: e) + XCTAssertEqual(e.cursorOffset, 3) + _ = type("←←←←", into: e) + XCTAssertEqual(e.cursorOffset, 1) // stops after the first character + _ = type("→→→→", into: e) + XCTAssertEqual(e.cursorOffset, 4) + } + + func testChooseCandidateInTheMiddle() { + let e = engine() + _ = type("rup wu0 wu0 fu4", into: e) + _ = type("←←↓", into: e) // cursor after the 2nd syllable (天) + XCTAssertTrue(e.isShowingCandidates) + XCTAssertTrue(e.candidates.allSatisfy { $0.range.upperBound == 2 }) + let i = e.candidates.firstIndex { $0.text == "添" }! + e.selectCandidate(i) + XCTAssertEqual(type("\n", into: e), "今添天氣") + } + + func testTypingReturnsCursorToEnd() { + let e = engine() + _ = type("rup wu0 ←", into: e) + XCTAssertEqual(e.cursorOffset, 1) + _ = type("wu0 ", into: e) + XCTAssertEqual(e.cursorOffset, e.markedText.count) + } + + func testCandidatesForChineseBeforeEnglish() { + let e = engine() + _ = type("su3cl3hello", into: e) // 你好hello + _ = type("↓", into: e) // last Chinese syllable, not the English word + XCTAssertTrue(e.isShowingCandidates) + } +} diff --git a/windows/autozhuyin/autozhuyin_ime.py b/windows/autozhuyin/autozhuyin_ime.py index fee4064..39bf40a 100644 --- a/windows/autozhuyin/autozhuyin_ime.py +++ b/windows/autozhuyin/autozhuyin_ime.py @@ -153,7 +153,7 @@ class AutoZhuyinTextService(TextService): self.setCommitString(commit) marked = self.engine.marked_text self.setCompositionString(marked) - self.setCompositionCursor(len(marked)) + self.setCompositionCursor(self.engine.cursor_offset) if self.engine.showing_candidates: page, cursor = self.engine.page() self.setCandidateList(page) diff --git a/windows/autozhuyin/core/engine.py b/windows/autozhuyin/core/engine.py index 15bb9d8..b73aef1 100644 --- a/windows/autozhuyin/core/engine.py +++ b/windows/autozhuyin/core/engine.py @@ -41,6 +41,8 @@ class CompositionEngine: self.candidates = [] self.candidate_index = 0 self._candidate_segment_start = 0 + # Composition cursor for choosing candidates: index into _cursor_stops(), None = end. + self.cursor = None self._previous_mode = None self._previous_time = float("-inf") self._cache_key = None @@ -81,19 +83,61 @@ class CompositionEngine: def page_start(self): return (self.candidate_index // self.page_size) * self.page_size + def _convertible(self, seg, final): + """(syllables converted to Chinese, pending Bopomofo) for a Zhuyin segment.""" + start, end, _ = seg + p = bopomofo.parse(self.keys[start:end]) + if final: + return [s.syllable for s in p.syllables], "" + return [s.syllable for s in p.completed], (p.pending.syllable.reading if p.pending else "") + + def _conversion(self, seg, final): + syl, pending = self._convertible(seg, final) + fx = {k: v for k, v in self.fixed.get(seg[0], {}).items() if k[1] <= len(syl)} + return self.converter.convert(syl, fx), pending + def _render(self, seg, final): start, end, mode = seg - seg_keys = self.keys[start:end] if mode == LITERAL: - return "".join(seg_keys) - p = bopomofo.parse(seg_keys) - fixed_here = self.fixed.get(start, {}) - syl = [s.syllable for s in (p.syllables if final else p.completed)] - fx = {k: v for k, v in fixed_here.items() if k[1] <= len(syl)} - text = "".join(t for _, t in self.converter.convert(syl, fx)) - if not final and p.pending: - text += p.pending.syllable.reading - return text + return "".join(self.keys[start:end]) + converted, pending = self._conversion(seg, final) + return "".join(t for _, t in converted) + pending + + # --- cursor --- + + def _cursor_stops(self): + """[(segment index, syllables before the stop)] for every Zhuyin syllable.""" + segs = self.segments + out = [] + for i, seg in enumerate(segs): + if seg[2] == ZHUYIN: + n = len(self._convertible(seg, i < len(segs) - 1)[0]) + out.extend((i, k) for k in range(1, n + 1)) + return out + + @property + def cursor_offset(self): + """Cursor position in marked_text (characters).""" + pieces = self.marked_pieces + stops = self._cursor_stops() + if self.cursor is None or not 0 <= self.cursor < len(stops): + return sum(len(t) for t, _ in pieces) + seg_index, local = stops[self.cursor] + offset = sum(len(t) for t, _ in pieces[:seg_index]) + segs = self.segments + for (a, b), text in self._conversion(segs[seg_index], seg_index < len(segs) - 1)[0]: + if b <= local: + offset += len(text) + elif a < local: + offset += min(local - a, len(text)) + return offset + + def _move_cursor(self, delta): + stops = self._cursor_stops() + if not stops: + return + nxt = (len(stops) - 1 if self.cursor is None else self.cursor) + delta + self.cursor = None if nxt >= len(stops) - 1 else max(0, nxt) @property def marked_pieces(self): @@ -135,6 +179,7 @@ class CompositionEngine: if key == BACKSPACE: if not self.keys: return PASS + self.cursor = None self.keys.pop() self.fixed = {k: v for k, v in self.fixed.items() if k < len(self.keys)} if not self.keys: @@ -169,7 +214,12 @@ class CompositionEngine: return PASS self._open_candidates() return CONSUMED - if key in (UP, LEFT, RIGHT): + if key in (LEFT, RIGHT): + if not self.keys: + return PASS + self._move_cursor(-1 if key == LEFT else 1) + return CONSUMED + if key == UP: return CONSUMED if self.keys else PASS return self._handle_character(key) @@ -180,6 +230,7 @@ class CompositionEngine: return bopomofo.parse(self.keys[start:end]) def _handle_character(self, c): + self.cursor = None # typing always continues at the end if c == " ": if not self.keys: return PASS @@ -212,15 +263,16 @@ class CompositionEngine: # --- candidates (for the last Zhuyin segment) --- def _open_candidates(self): + """Candidates for the phrase ending at the cursor (default: the last syllable).""" + stops = self._cursor_stops() + if not stops: + return + seg_index, local = stops[min(len(stops) - 1 if self.cursor is None else self.cursor, len(stops) - 1)] segs = self.segments - if not segs or segs[-1][2] != ZHUYIN: - return - start, end, _ = segs[-1] - syl = [s.syllable for s in bopomofo.parse(self.keys[start:end]).completed] - if not syl: - return - self.candidates = self.converter.candidates(syl, len(syl)) - self._candidate_segment_start = start + seg = segs[seg_index] + syl = self._convertible(seg, seg_index < len(segs) - 1)[0] + self.candidates = self.converter.candidates(syl, local) + self._candidate_segment_start = seg[0] self.candidate_index = 0 def page(self): @@ -268,6 +320,7 @@ class CompositionEngine: def reset(self): self.keys = [] + self.cursor = None self.forced_mode = None self._forced_is_correction = False self.fixed = {} diff --git a/windows/installer/README.txt b/windows/installer/README.txt index dede5bc..10f52ed 100644 --- a/windows/installer/README.txt +++ b/windows/installer/README.txt @@ -26,7 +26,8 @@ 空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白 Enter 送出目前組字 Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正 - ↓ 開啟候選字,按數字鍵 1–9 選字 + ← → 在組字區移動游標,選要改哪個字 + ↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字 Esc 取消組字 單按 Shift 下一個字強制英文(保持小寫),送出後恢復自動判斷; 打到一半時按,同 Tab 整段翻轉。會出現「英文」小提示 diff --git a/windows/tests/test_core.py b/windows/tests/test_core.py index 190723e..d6b78ae 100644 --- a/windows/tests/test_core.py +++ b/windows/tests/test_core.py @@ -11,7 +11,7 @@ sys.path.insert(0, os.path.dirname(HERE)) from autozhuyin.core import bopomofo # noqa: E402 from autozhuyin.core.classifier import LITERAL, ZHUYIN, Classifier, LearnedPreferences # noqa: E402 -from autozhuyin.core.engine import DOWN, ENTER, SHIFT_TAP, TAB, BACKSPACE, CompositionEngine # noqa: E402 +from autozhuyin.core.engine import DOWN, ENTER, LEFT, RIGHT, SHIFT_TAP, TAB, BACKSPACE, CompositionEngine # noqa: E402 from autozhuyin.core.shift_tap import ShiftTapDetector # noqa: E402 from autozhuyin.core.english import EnglishModel # noqa: E402 from autozhuyin.core.lexicon import Converter, Lexicon # noqa: E402 @@ -42,7 +42,7 @@ def make_engine(): def type_keys(s, e): out = "" for c in s: - key = ENTER if c == "\n" else TAB if c == "\t" else SHIFT_TAP if c == "⇧" else c + key = {"\n": ENTER, "\t": TAB, "⇧": SHIFT_TAP, "←": LEFT, "→": RIGHT, "↓": DOWN}.get(c, c) handled, commit = e.handle(key) if commit is not None: out += commit @@ -234,5 +234,38 @@ class ShiftTapTests(unittest.TestCase): self.assertFalse(d.shift_up(3)) +class CursorTests(unittest.TestCase): + def test_moves_and_clamps(self): + e = make_engine() + type_keys("rup wu0 wu0 fu4", e) + self.assertEqual(e.cursor_offset, 4) + type_keys("←", e) + self.assertEqual(e.cursor_offset, 3) + type_keys("←←←←", e) + self.assertEqual(e.cursor_offset, 1) + type_keys("→→→→", e) + self.assertEqual(e.cursor_offset, 4) + + def test_choose_candidate_in_the_middle(self): + e = make_engine() + type_keys("rup wu0 wu0 fu4←←↓", e) + self.assertTrue(e.showing_candidates) + self.assertTrue(all(r[1] == 2 for r, _ in e.candidates)) + e.select_candidate([t for _, t in e.candidates].index("添")) + self.assertEqual(type_keys("\n", e), "今添天氣") + + def test_typing_returns_cursor_to_end(self): + e = make_engine() + type_keys("rup wu0 ←", e) + self.assertEqual(e.cursor_offset, 1) + type_keys("wu0 ", e) + self.assertEqual(e.cursor_offset, len(e.marked_text)) + + def test_candidates_for_chinese_before_english(self): + e = make_engine() + type_keys("su3cl3hello↓", e) + self.assertTrue(e.showing_candidates) + + if __name__ == "__main__": unittest.main()