From 31d9991e166847d03e888f2e777de141f8d1e80f Mon Sep 17 00:00:00 2001 From: John Kao Date: Fri, 13 Nov 2026 09:56:06 +0800 Subject: [PATCH] Insert and delete syllables at the composition cursor MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The ← → cursor is now an editing position (key index), not just a candidate stop. It can move to the start; typing Zhuyin there composes a syllable at the cursor and splices it in on its tone key; Backspace removes the character before the cursor. Picked phrases before the edit point are kept. Co-Authored-By: Claude Opus 5.5 --- README.md | 3 +- .../AutoZhuyinCore/CompositionEngine.swift | 216 ++++++++++++++--- .../AutoZhuyinCoreTests.swift | 47 +++- windows/autozhuyin/core/engine.py | 224 +++++++++++++++--- windows/installer/README.txt | 3 +- windows/tests/test_core.py | 43 +++- 6 files changed, 452 insertions(+), 84 deletions(-) diff --git a/README.md b/README.md index a996272..468b1d4 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,7 @@ - **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小) - **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」 - **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來 +- **中間補字、刪字**:游標移到前面後直接打注音,會插在游標處;Backspace 刪掉游標前的那個字 - **全形標點**:中文語境下 `?` `!` `<` 自動變成 `?` `!` `,`;任何時候按 `` ` `` 再按標點鍵,一定得到全形標點(例如 `` `< `` = `,`) - **完整詞庫**:約 17 萬筆,來自小麥注音 McBopomofo(MIT 授權) @@ -51,7 +52,7 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安 | 空白 | 注音:一聲;音節已完成時送出中文。英文:送出單字加空白 | | Enter | 送出目前組字 | | **Tab** | 判斷錯了?按 Tab 把整段翻轉成另一種語言,輸入法會**記住**這次修正 | -| ← → | 在組字區移動游標,選要改哪個字 | +| ← → | 在組字區移動游標(可移到最前面)。游標在中間時:直接打注音會**插入**新字,Backspace 刪掉游標前的字,↓ 選游標前的字 | | ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 | | Esc | 取消組字 | | **單按 Shift** | 沒在打字時:切換**英文模式**,按鍵直接送出、保持小寫、沒有底線,一直維持到再單按一次 Shift 才回到中英自動判斷。打到一半時:同 Tab,整段翻轉 | diff --git a/Sources/AutoZhuyinCore/CompositionEngine.swift b/Sources/AutoZhuyinCore/CompositionEngine.swift index ade483b..83a4c37 100644 --- a/Sources/AutoZhuyinCore/CompositionEngine.swift +++ b/Sources/AutoZhuyinCore/CompositionEngine.swift @@ -45,9 +45,11 @@ 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. + /// Composition cursor: a key index into `keys` (nil = at the end). ← → move it between + /// syllables; ↓ shows candidates for the phrase before it; typing there inserts a + /// syllable (kept in `inserting` until its tone key, then spliced into `keys`). private var cursor: Int? + private var inserting: [Character] = [] public var candidateIndex = 0 public var isShowingCandidates: Bool { !candidates.isEmpty } @@ -117,14 +119,35 @@ public final class CompositionEngine { public var markedText: String { markedPieces.map(\.text).joined() } public var markedPieces: [MarkedPiece] { - let segs = segments - var pieces = segs.enumerated().map { i, seg in - MarkedPiece(text: render(seg, final: i < segs.count - 1), mode: seg.mode) + var pieces = segmentPieces + if !inserting.isEmpty { + // Show the syllable being inserted at the cursor. + var at = baseCursorOffset, out: [MarkedPiece] = [], done = false + for piece in pieces { + if !done && at <= piece.text.count { + let i = piece.text.index(piece.text.startIndex, offsetBy: at) + out.append(MarkedPiece(text: String(piece.text[.. String { guard seg.mode == .zhuyin else { return String(keys[seg.range]) } @@ -148,43 +171,151 @@ public final class CompositionEngine { // MARK: - Cursor - /// A place the cursor can stop: after the `local`-th syllable of Zhuyin segment `segIndex`. + /// Absolute key index after each syllable of a Zhuyin segment. + private func syllableEnds(_ seg: Segment) -> [Int] { + ZhuyinParser.parse(Array(keys[seg.range])).syllables.map { seg.range.lowerBound + $0.keyRange.upperBound } + } + + /// Key indices the cursor can stop at: the start, after every Zhuyin syllable, and at + /// every segment boundary. + private var cursorPositions: [Int] { + var out: Set = [0, keys.count] + for seg in segments { + out.insert(seg.range.upperBound) + if seg.mode == .zhuyin { out.formUnion(syllableEnds(seg)) } + } + return out.sorted() + } + + /// A place to open candidates: after the `local`-th syllable of Zhuyin segment `segIndex`. private struct CursorStop { let segIndex: Int; let local: Int } - private var cursorStops: [CursorStop] { + private func stop(at pos: Int) -> CursorStop? { let segs = segments - var out: [CursorStop] = [] - for (i, seg) in segs.enumerated() where seg.mode == .zhuyin { + for (i, seg) in segs.enumerated() where seg.mode == .zhuyin + && seg.range.lowerBound < pos && pos <= seg.range.upperBound { 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 local = syllableEnds(seg).filter { $0 <= pos }.count + return local > 0 ? CursorStop(segIndex: i, local: min(local, n)) : nil } - return out + return nil + } + + /// Where ↓ opens candidates: before the cursor, or the last syllable. + private var candidateStop: CursorStop? { + if let c = cursor { return stop(at: c) } + let segs = segments + for i in segs.indices.reversed() where segs[i].mode == .zhuyin { + let n = convertibleSyllables(segs[i], final: i < segs.count - 1).syllables.count + if n > 0 { return CursorStop(segIndex: i, local: n) } + } + return nil + } + + /// Cursor position in the rendered segments (without the syllable being inserted). + private var baseCursorOffset: Int { + let pieces = segmentPieces + guard let c = cursor else { return pieces.reduce(0) { $0 + $1.text.count } } + let segs = segments + for (i, seg) in segs.enumerated() where seg.range.lowerBound < c && c <= seg.range.upperBound { + var offset = pieces[..= stops.count - 1 ? nil : max(0, next) + inserting = [] + let stops = cursorPositions + let here = cursor ?? keys.count + let next = delta < 0 ? (stops.last { $0 < here } ?? here) : (stops.first { $0 > here } ?? here) + cursor = next >= keys.count ? nil : next + } + + // MARK: - Editing in the middle + + /// Keeps picked phrases that end at or before key index `pos` (they don't move). + private func trimFixed(at pos: Int) { + var kept: [Int: [Range: String]] = [:] + for seg in segments where seg.mode == .zhuyin { + guard let picks = fixed[seg.range.lowerBound] else { continue } + if seg.range.upperBound <= pos { + kept[seg.range.lowerBound] = picks + } else if seg.range.lowerBound < pos { + let ends = syllableEnds(seg) + let here = picks.filter { $0.key.upperBound <= ends.count && ends[$0.key.upperBound - 1] <= pos } + if !here.isEmpty { kept[seg.range.lowerBound] = here } + } + } + fixed = kept + } + + /// Inserts keys at the cursor and moves the cursor after them. + private func splice(_ newKeys: [Character]) { + guard let pos = cursor else { keys += newKeys; return } + trimFixed(at: pos) + keys.insert(contentsOf: newKeys, at: pos) + if let h = held, h >= pos { held = h + newKeys.count } + let next = pos + newKeys.count + cursor = next >= keys.count ? nil : next + } + + /// Backspace in the middle: removes the syllable (or literal key) before the cursor. + private func deleteBeforeCursor(_ pos: Int) { + var start = pos - 1 + for seg in segments where seg.mode == .zhuyin && seg.range.lowerBound < pos && pos <= seg.range.upperBound { + for ps in ZhuyinParser.parse(Array(keys[seg.range])).syllables + where seg.range.lowerBound + ps.keyRange.upperBound == pos { + start = seg.range.lowerBound + ps.keyRange.lowerBound + } + } + trimFixed(at: start) + keys.removeSubrange(start..= start && h < pos { held = nil } else if h >= pos { held = h - (pos - start) } + } + cursor = start + if keys.isEmpty { reset() } + } + + /// Typing with the cursor in the middle: compose one syllable, splice it in on its tone. + private func insertKey(_ c: Character) -> KeyResult { + if c == " " { + if inserting.isEmpty { return KeyResult(handled: true, commit: commitCurrent()) } + splice(inserting + [" "]) + inserting = [] + return .consumed + } + inserting.append(c) + let p = ZhuyinParser.parse(inserting) + if p.strayTones > 0 || p.foreignKeys > 0 { + inserting.removeLast() // a tone with nothing to attach to + } else if p.syllables.count == 1, p.syllables[0].toned { + splice(inserting) + inserting = [] + } else if p.syllables.count > 1 { + // A new syllable started without a tone: splice the first one as it is. + let first = p.syllables[0].keyRange.upperBound + splice(Array(inserting[.. KeyResult { if isShowingCandidates { return handleCandidateKey(key) } if pendingBacktick { return afterBacktick(key) } + if !inserting.isEmpty && (key == .backspace || key == .escape) { + if key == .backspace { inserting.removeLast() } else { inserting = [] } + return .consumed + } switch key { case .character(let c): return handleCharacter(c) case .backspace: guard !keys.isEmpty else { return .passThrough } - cursor = nil + if let c = cursor { + if c > 0 { deleteBeforeCursor(c) } + return .consumed + } keys.removeLast() if let h = held, keys.count <= h { held = nil } fixed = fixed.filter { $0.key < keys.count } @@ -206,6 +344,7 @@ public final class CompositionEngine { return .consumed case .enter: guard !keys.isEmpty else { return .passThrough } + if !inserting.isEmpty { splice(inserting); inserting = [] } return KeyResult(handled: true, commit: commitCurrent()) case .escape: guard !keys.isEmpty else { return .passThrough } @@ -227,7 +366,7 @@ public final class CompositionEngine { return .consumed case .down: guard !keys.isEmpty else { return .passThrough } - openCandidates() + if inserting.isEmpty { openCandidates() } return .consumed case .left: guard !keys.isEmpty else { return .passThrough } @@ -248,7 +387,11 @@ public final class CompositionEngine { } private func handleCharacter(_ c: Character) -> KeyResult { - cursor = nil // typing always continues at the end + if cursor != nil, !keys.isEmpty, c == " " || DachenLayout.isZhuyinKey(c) { + return insertKey(c) + } + if !inserting.isEmpty { splice(inserting); inserting = [] } + cursor = nil // anything else continues at the end // English mode: every key goes to the app as typed. if isEnglishMode && keys.isEmpty { return .passThrough } if c == "`" { @@ -329,9 +472,7 @@ public final class CompositionEngine { /// 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)] + guard let stop = candidateStop else { return } let segs = segments let seg = segs[stop.segIndex] let syl = convertibleSyllables(seg, final: stop.segIndex < segs.count - 1).syllables @@ -392,6 +533,7 @@ public final class CompositionEngine { public func reset() { keys = [] + inserting = [] held = nil pendingBacktick = false cursor = nil diff --git a/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift b/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift index f4300c4..e9cc86c 100644 --- a/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift +++ b/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift @@ -369,7 +369,8 @@ final class CursorTests: XCTestCase { 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 key: KeyInput = c == "←" ? .left : c == "→" ? .right : c == "↓" ? .down : c == "\n" ? .enter + : c == "\u{8}" ? .backspace : .character(c) let r = e.handle(key) if let t = r.commit { out += t } else if !r.handled { out.append(c) } } @@ -383,7 +384,7 @@ final class CursorTests: XCTestCase { _ = type("←", into: e) XCTAssertEqual(e.cursorOffset, 3) _ = type("←←←←", into: e) - XCTAssertEqual(e.cursorOffset, 1) // stops after the first character + XCTAssertEqual(e.cursorOffset, 0) // stops at the start _ = type("→→→→", into: e) XCTAssertEqual(e.cursorOffset, 4) } @@ -399,12 +400,48 @@ final class CursorTests: XCTestCase { XCTAssertEqual(type("\n", into: e), "今添天氣") } - func testTypingReturnsCursorToEnd() { + func testPunctuationCommitsFromTheMiddle() { let e = engine() _ = type("rup wu0 ←", into: e) XCTAssertEqual(e.cursorOffset, 1) - _ = type("wu0 ", into: e) - XCTAssertEqual(e.cursorOffset, e.markedText.count) + _ = type("?", into: e) + XCTAssertEqual(e.markedText, "") + } + + func testInsertSyllable() { + let e = engine() + _ = type("rup fu4←wu", into: e) + XCTAssertEqual(e.markedText, "今ㄊㄧ氣") + XCTAssertEqual(e.cursorOffset, 3) + _ = type("0 ", into: e) + XCTAssertEqual(e.markedText, "今天氣") + XCTAssertEqual(e.cursorOffset, 2) + XCTAssertEqual(type("\n", into: e), "今天氣") + } + + func testInsertAtStart() { + XCTAssertEqual(type("su3cl3←←ji3\n", into: engine()), "我你好") + } + + func testBackspaceDeletesCharacterBeforeCursor() { + let e = engine() + _ = type("rup wu0 wu0 fu4←←\u{8}", into: e) + XCTAssertEqual(e.markedText, "今天氣") + XCTAssertEqual(e.cursorOffset, 1) + } + + func testBackspaceInsideInsertedSyllable() { + let e = engine() + _ = type("rup fu4←wu\u{8}", into: e) + XCTAssertEqual(e.markedText, "今ㄊ氣") + } + + func testKeepsPickedPhraseBeforeCursor() { + let e = engine() + _ = type("rup wu0 ↓", into: e) + e.selectCandidate(e.candidates.firstIndex { $0.text == "添" }!) + _ = type("fu4←wu0 ", into: e) // insert 天 between 添 and 氣 + XCTAssertEqual(String(e.markedText.prefix(3)), "今添天") } func testCandidatesForChineseBeforeEnglish() { diff --git a/windows/autozhuyin/core/engine.py b/windows/autozhuyin/core/engine.py index e2351f4..7aec1bd 100644 --- a/windows/autozhuyin/core/engine.py +++ b/windows/autozhuyin/core/engine.py @@ -55,8 +55,11 @@ class CompositionEngine: self.candidates = [] self.candidate_index = 0 self._candidate_segment_start = 0 - # Composition cursor for choosing candidates: index into _cursor_stops(), None = end. + # Composition cursor: a key index into self.keys (None = at the end). ← → move it + # between syllables; ↓ opens candidates for the phrase before it; typing there + # inserts a syllable (kept in self.inserting until its tone key, then spliced in). self.cursor = None + self.inserting = [] # Index of a held space (see HOLD_MIN_SCORE), or None. self.held = None self._previous_mode = None @@ -144,48 +147,180 @@ class CompositionEngine: # --- 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): + def _syllable_ends(self, seg): + """Absolute key index after each syllable of a Zhuyin segment.""" + return [seg[0] + ps.end for ps in bopomofo.parse(self.keys[seg[0]:seg[1]]).syllables] + + def _cursor_positions(self): + """Key indices the cursor can stop at: the start, after every Zhuyin syllable, + and at every segment boundary.""" + out = {0, len(self.keys)} + for seg in self.segments: + out.add(seg[1]) if seg[2] == ZHUYIN: + out.update(self._syllable_ends(seg)) + return sorted(out) + + def _stop_at(self, pos): + """(segment index, syllables before pos) for the Zhuyin segment pos is in.""" + segs = self.segments + for i, seg in enumerate(segs): + if seg[2] == ZHUYIN and seg[0] < pos <= seg[1]: n = len(self._convertible(seg, i < len(segs) - 1)[0]) - out.extend((i, k) for k in range(1, n + 1)) - return out + local = sum(1 for e in self._syllable_ends(seg) if e <= pos) + return (i, min(local, n)) if local else None + return None + + def _candidate_stop(self): + """Where ↓ opens candidates: before the cursor, or the last syllable.""" + if self.cursor is not None: + return self._stop_at(self.cursor) + segs = self.segments + for i in range(len(segs) - 1, -1, -1): + if segs[i][2] == ZHUYIN: + n = len(self._convertible(segs[i], i < len(segs) - 1)[0]) + if n: + return i, n + return None + + def _base_cursor_offset(self): + """Cursor position in the rendered segments (without the syllable being inserted).""" + pieces = self._segment_pieces() + if self.cursor is None: + return sum(len(t) for t, _ in pieces) + segs = self.segments + for i, seg in enumerate(segs): + if not seg[0] < self.cursor <= seg[1]: + continue + offset = sum(len(t) for t, _ in pieces[:i]) + if seg[2] == LITERAL: + return offset + self.cursor - seg[0] + stop = self._stop_at(self.cursor) + local = stop[1] if stop else 0 + for (a, b), text in self._conversion(seg, i < len(segs) - 1)[0]: + if b <= local: + offset += len(text) + elif a < local: + offset += min(local - a, len(text)) + return offset + return 0 @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 + return self._base_cursor_offset() + len(self._inserting_text()) 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) + self.inserting = [] + stops = self._cursor_positions() + here = len(self.keys) if self.cursor is None else self.cursor + if delta < 0: + before = [p for p in stops if p < here] + nxt = before[-1] if before else here + else: + after = [p for p in stops if p > here] + nxt = after[0] if after else here + self.cursor = None if nxt >= len(self.keys) else nxt + + def _inserting_text(self): + if not self.inserting: + return "" + return "".join(ps.syllable.reading for ps in bopomofo.parse(self.inserting).syllables) + + # --- editing in the middle --- + + def _trim_fixed(self, pos): + """Keeps picked phrases that end at or before key index pos (they don't move).""" + kept = {} + for seg in self.segments: + picks = self.fixed.get(seg[0]) + if not picks or seg[2] != ZHUYIN: + continue + if seg[1] <= pos: + kept[seg[0]] = picks + elif seg[0] < pos: + ends = self._syllable_ends(seg) + here = {r: t for r, t in picks.items() if r[1] <= len(ends) and ends[r[1] - 1] <= pos} + if here: + kept[seg[0]] = here + self.fixed = kept + + def _splice(self, new_keys): + """Inserts keys at the cursor and moves the cursor after them.""" + pos = self.cursor + self._trim_fixed(pos) + self.keys[pos:pos] = new_keys + if self.held is not None and self.held >= pos: + self.held += len(new_keys) + self.cursor = pos + len(new_keys) + if self.cursor >= len(self.keys): + self.cursor = None + + def _delete_before_cursor(self): + """Backspace in the middle: removes the syllable (or literal key) before the cursor.""" + pos = self.cursor + start = pos - 1 + for seg in self.segments: + if seg[2] == ZHUYIN and seg[0] < pos <= seg[1]: + for ps in bopomofo.parse(self.keys[seg[0]:seg[1]]).syllables: + if seg[0] + ps.end == pos: + start = seg[0] + ps.start + self._trim_fixed(start) + del self.keys[start:pos] + if self.held is not None: + if start <= self.held < pos: + self.held = None + elif self.held >= pos: + self.held -= pos - start + self.cursor = start + if not self.keys: + self.reset() + + def _insert_key(self, c): + """Typing with the cursor in the middle: compose one syllable, splice it in on its tone.""" + if c == " ": + if not self.inserting: + return True, self._commit() + self._splice(self.inserting + [" "]) + self.inserting = [] + return CONSUMED + self.inserting.append(c) + p = bopomofo.parse(self.inserting) + if p.stray_tones or p.foreign_keys: + self.inserting.pop() # a tone with nothing to attach to + return CONSUMED + if p.syllables and p.syllables[-1].toned and len(p.syllables) == 1: + self._splice(self.inserting) + self.inserting = [] + elif len(p.syllables) > 1: + # A new syllable started without a tone: splice the first one as it is. + first = p.syllables[0].end + self._splice(self.inserting[:first]) + self.inserting = self.inserting[first:] + return CONSUMED @property def marked_pieces(self): - segs = self.segments - pieces = [(self._render(s, i < len(segs) - 1), s[2]) for i, s in enumerate(segs)] + pieces = self._segment_pieces() + if self.inserting: + # Show the syllable being inserted at the cursor. + at, out, done = self._base_cursor_offset(), [], False + for text, mode in pieces: + if not done and at <= len(text): + out += [(text[:at], mode), (self._inserting_text(), ZHUYIN), (text[at:], mode)] + done = True + else: + out.append((text, mode)) + at -= len(text) + pieces = [(t, m) for t, m in out if t] if self.backtick: pieces.append((BACKTICK, LITERAL)) return pieces + def _segment_pieces(self): + segs = self.segments + return [(self._render(s, i < len(segs) - 1), s[2]) for i, s in enumerate(segs)] + @property def marked_text(self): return "".join(t for t, _ in self.marked_pieces) @@ -198,7 +333,7 @@ class CompositionEngine: def wants(self, key): """Whether handle(key) would consume the key, without changing state.""" - if self.candidates or key == SHIFT_TAP or self.backtick: + if self.candidates or key == SHIFT_TAP or self.backtick or self.inserting: return True if self.english_mode and not self.keys: return False # English mode: everything goes to the app as typed @@ -217,10 +352,19 @@ class CompositionEngine: return self._handle_candidate_key(key) if self.backtick: return self._after_backtick(key) + if self.inserting and key in (BACKSPACE, ESCAPE): + if key == BACKSPACE: + self.inserting.pop() + else: + self.inserting = [] + return CONSUMED if key == BACKSPACE: if not self.keys: return PASS - self.cursor = None + if self.cursor is not None: + if self.cursor > 0: + self._delete_before_cursor() + return CONSUMED self.keys.pop() if self.held is not None and len(self.keys) <= self.held: self.held = None @@ -232,6 +376,9 @@ class CompositionEngine: if key == ENTER: if not self.keys: return PASS + if self.inserting: + self._splice(self.inserting) + self.inserting = [] return True, self._commit() if key == ESCAPE: if not self.keys: @@ -255,7 +402,8 @@ class CompositionEngine: if key == DOWN: if not self.keys: return PASS - self._open_candidates() + if not self.inserting: + self._open_candidates() return CONSUMED if key in (LEFT, RIGHT): if not self.keys: @@ -286,7 +434,12 @@ class CompositionEngine: return bopomofo.parse(self.keys[start:end]) def _handle_character(self, c): - self.cursor = None # typing always continues at the end + if self.cursor is not None and self.keys and (c == " " or bopomofo.is_zhuyin_key(c)): + return self._insert_key(c) + if self.inserting: + self._splice(self.inserting) + self.inserting = [] + self.cursor = None # anything else continues at the end if self.english_mode and not self.keys: return PASS # English mode: every key goes to the app as typed if c == BACKTICK: @@ -330,10 +483,10 @@ class CompositionEngine: def _open_candidates(self): """Candidates for the phrase ending at the cursor (default: the last syllable).""" - stops = self._cursor_stops() - if not stops: + stop = self._candidate_stop() + if stop is None: return - seg_index, local = stops[min(len(stops) - 1 if self.cursor is None else self.cursor, len(stops) - 1)] + seg_index, local = stop segs = self.segments seg = segs[seg_index] syl = self._convertible(seg, seg_index < len(segs) - 1)[0] @@ -386,6 +539,7 @@ class CompositionEngine: def reset(self): self.keys = [] + self.inserting = [] self.held = None self.backtick = False self.cursor = None diff --git a/windows/installer/README.txt b/windows/installer/README.txt index b1a4a24..c351a92 100644 --- a/windows/installer/README.txt +++ b/windows/installer/README.txt @@ -26,7 +26,8 @@ 空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白 Enter 送出目前組字 Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正 - ← → 在組字區移動游標,選要改哪個字 + ← → 在組字區移動游標,選要改哪個字;游標在中間時直接打注音 + 會插入新字,Backspace 刪掉游標前的字 ↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字 Esc 取消組字 單按 Shift 切換英文模式(按鍵直接送出、保持小寫、沒有底線), diff --git a/windows/tests/test_core.py b/windows/tests/test_core.py index 3f0ea30..d10ac02 100644 --- a/windows/tests/test_core.py +++ b/windows/tests/test_core.py @@ -42,7 +42,7 @@ def make_engine(): def type_keys(s, e): out = "" for c in s: - key = {"\n": ENTER, "\t": TAB, "⇧": SHIFT_TAP, "←": LEFT, "→": RIGHT, "↓": DOWN}.get(c, c) + key = {"\n": ENTER, "\t": TAB, "⇧": SHIFT_TAP, "←": LEFT, "→": RIGHT, "↓": DOWN, "\b": BACKSPACE}.get(c, c) handled, commit = e.handle(key) if commit is not None: out += commit @@ -246,7 +246,7 @@ class CursorTests(unittest.TestCase): type_keys("←", e) self.assertEqual(e.cursor_offset, 3) type_keys("←←←←", e) - self.assertEqual(e.cursor_offset, 1) + self.assertEqual(e.cursor_offset, 0) type_keys("→→→→", e) self.assertEqual(e.cursor_offset, 4) @@ -258,12 +258,45 @@ class CursorTests(unittest.TestCase): e.select_candidate([t for _, t in e.candidates].index("添")) self.assertEqual(type_keys("\n", e), "今添天氣") - def test_typing_returns_cursor_to_end(self): + def test_english_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)) + type_keys("?", e) + self.assertEqual(e.marked_text, "") + + +class InsertInMiddleTests(unittest.TestCase): + def test_insert_syllable(self): + e = make_engine() + type_keys("rup fu4←wu", e) + self.assertEqual(e.marked_text, "今ㄊㄧ氣") + self.assertEqual(e.cursor_offset, 3) + type_keys("0 ", e) + self.assertEqual(e.marked_text, "今天氣") + self.assertEqual(e.cursor_offset, 2) + self.assertEqual(type_keys("\n", e), "今天氣") + + def test_insert_at_start(self): + self.assertEqual(type_keys("su3cl3←←ji3\n", make_engine()), "我你好") + + def test_backspace_deletes_character_before_cursor(self): + e = make_engine() + type_keys("rup wu0 wu0 fu4←←\b", e) + self.assertEqual(e.marked_text, "今天氣") + self.assertEqual(e.cursor_offset, 1) + + def test_backspace_inside_inserted_syllable(self): + e = make_engine() + type_keys("rup fu4←wu\b", e) + self.assertEqual(e.marked_text, "今ㄊ氣") + + def test_keeps_picked_phrase_before_cursor(self): + e = make_engine() + type_keys("rup wu0 ↓", e) + e.select_candidate([t for _, t in e.candidates].index("添")) + type_keys("fu4←wu0 ", e) # insert 天 between 添 and 氣 + self.assertEqual(e.marked_text[:3], "今添天") def test_candidates_for_chinese_before_english(self): e = make_engine()