From 7e173a1da8de858bef1fb0413becb4d02aaddca9 Mon Sep 17 00:00:00 2001 From: John Kao Date: Wed, 11 Nov 2026 11:44:25 +0800 Subject: [PATCH] Make the Shift tap a persistent English-mode toggle MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A Shift tap with nothing composed now switches English mode on until the next tap, instead of forcing only the next word: space, Enter and other keys no longer drop back to automatic detection. In English mode every key goes straight to the app, so there is no composition or underline. A Shift tap while typing still flips the buffer like Tab. Windows shows "英文" / "中英自動" when toggling. Co-Authored-By: Claude Opus 5.5 --- README.md | 4 +- .../AutoZhuyinCore/CompositionEngine.swift | 61 +++++-------------- .../AutoZhuyinCoreTests.swift | 53 +++++----------- windows/autozhuyin/autozhuyin_ime.py | 4 +- windows/autozhuyin/core/engine.py | 53 +++++----------- windows/installer/README.txt | 6 +- windows/tests/test_core.py | 46 +++++--------- windows/tests/test_pime_wrapper.py | 5 +- 8 files changed, 72 insertions(+), 160 deletions(-) diff --git a/README.md b/README.md index 573f9af..0c6d61d 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ - **中英自動判斷**:每按一個鍵就重新判斷,組字區即時顯示結果(Mac 版英文以藍字顯示) - **中英混打不用空白**:`ji3hello` → 我hello、`hellosu3cl3` → hello你好,同一段內會自動切分 - **判斷錯了按 Tab**:在中/英之間翻轉,輸入法會記住這組按鍵,下次自動判斷對 -- **單按 Shift 強制英文**:要打英文時先單按一下 Shift,接下來這個字照打、保持小寫,而且直接送出、不顯示底線 +- **單按 Shift 切換英文模式**:英文模式下按鍵直接送出、保持小寫、不顯示底線,再單按一次 Shift 回到中英自動判斷 - **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小) - **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」 - **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來 @@ -54,7 +54,7 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安 | ← → | 在組字區移動游標,選要改哪個字 | | ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 | | Esc | 取消組字 | -| **單按 Shift** | 沒在打字時:下一個字強制英文(保持小寫),字母直接送出、沒有底線;按空白、Enter 或其他符號後恢復自動判斷,再按一次 Shift 取消。打到一半時:同 Tab,整段翻轉 | +| **單按 Shift** | 沒在打字時:切換**英文模式**,按鍵直接送出、保持小寫、沒有底線,一直維持到再單按一次 Shift 才回到中英自動判斷。打到一半時:同 Tab,整段翻轉 | | Shift + 字母 | 打大寫字母(也會強制英文) | | `< > ? ! : ( ) [ ]` | 中文語境下自動轉成全形 `,。?!:()「」` | | `, . / ; -` | 英文單字後是標點;在注音中是 ㄝ ㄡ ㄥ ㄤ ㄦ(例如 `2;3` = 檔) | diff --git a/Sources/AutoZhuyinCore/CompositionEngine.swift b/Sources/AutoZhuyinCore/CompositionEngine.swift index ab9c0d4..b29d313 100644 --- a/Sources/AutoZhuyinCore/CompositionEngine.swift +++ b/Sources/AutoZhuyinCore/CompositionEngine.swift @@ -35,12 +35,12 @@ public final class CompositionEngine { public let converter: Converter public private(set) var keys: [Character] = [] - /// Set by Tab / Shift tap: overrides the classifier for the whole buffer. + /// Set by Tab / a Shift tap while typing: overrides the classifier for the whole + /// buffer. It is a correction, learned on commit. public private(set) var forcedMode: InputMode? - /// True when forcedMode corrects the classifier (learned on commit); false when the - /// user forced English before typing (Shift tap on an empty buffer), which is not a - /// correction and is not learned. - private var forcedIsCorrection = false + /// English mode, toggled by a Shift tap when nothing is being typed. Keys go straight + /// to the app (no composition, no underline) until Shift is tapped again. + public private(set) var isEnglishMode = false /// User-picked phrases: Zhuyin segment start (key index) → syllable range → text. private var fixed: [Int: [Range: String]] = [:] public private(set) var candidates: [Candidate] = [] @@ -165,28 +165,25 @@ public final class CompositionEngine { cursor = nil keys.removeLast() fixed = fixed.filter { $0.key < keys.count } - if keys.isEmpty { - // A Shift-tap "next word is English" stays armed; a correction is dropped. - if forcedIsCorrection { forcedMode = nil; forcedIsCorrection = false } - fixed = [:] - } + if keys.isEmpty { forcedMode = nil; fixed = [:] } return .consumed case .enter: - guard !keys.isEmpty else { endDirectEnglish(); return .passThrough } + guard !keys.isEmpty else { return .passThrough } return KeyResult(handled: true, commit: commitCurrent()) case .escape: - guard !keys.isEmpty else { endDirectEnglish(); return .passThrough } + guard !keys.isEmpty else { return .passThrough } reset() return .consumed case .tab: - guard !keys.isEmpty else { endDirectEnglish(); return .passThrough } + guard !keys.isEmpty else { return .passThrough } flip() return .consumed case .shiftTap: if keys.isEmpty { - // Next word is English, typed as-is (lowercase stays lowercase). Tap again to cancel. - forcedMode = forcedMode == .literal ? nil : .literal - forcedIsCorrection = false + // Toggle English mode; it stays on until the next Shift tap. + isEnglishMode.toggle() + previousMode = isEnglishMode ? .literal : nil + previousCommitTime = now() } else { flip() } @@ -211,37 +208,12 @@ public final class CompositionEngine { /// Forces the whole buffer into the other mode (a correction that is learned). private func flip() { forcedMode = (mode == .zhuyin) ? .literal : .zhuyin - forcedIsCorrection = true } - /// True while the user has forced English for the next word (Shift tap). In this - /// mode keys go straight to the app with no composition (no underline). - public var isEnglishArmed: Bool { keys.isEmpty && forcedMode == .literal && !forcedIsCorrection } - - /// Leaves forced-English mode once the word is done. - private func endDirectEnglish() { - guard isEnglishArmed else { return } - forcedMode = nil - previousMode = .literal - previousCommitTime = now() - } - - private static let englishWordPunctuation: Set = ["'", ".", ",", "-", "/", ";"] - private func handleCharacter(_ c: Character) -> KeyResult { cursor = nil // typing always continues at the end - if isEnglishArmed { - // Forced English: insert directly. Space ends the word; other symbols end it too. - if c == " " { - endDirectEnglish() - return KeyResult(handled: true, commit: " ") - } - if c.isASCII && (c.isLetter || c.isNumber || CompositionEngine.englishWordPunctuation.contains(c)) { - return KeyResult(handled: true, commit: String(c)) - } - endDirectEnglish() - return .passThrough - } + // English mode: every key goes to the app as typed. + if isEnglishMode && keys.isEmpty { return .passThrough } if c == " " { guard !keys.isEmpty else { return .passThrough } let segs = segments(of: keys, finishing: true) @@ -338,7 +310,7 @@ public final class CompositionEngine { private func commitCurrent(_ given: [Segment]? = nil) -> String { let segs = given ?? segments let text = segs.map { render($0, final: true) }.joined() - if let forced = forcedMode, forcedIsCorrection { + if let forced = forcedMode { classifier.learned.record(String(keys), as: forced) } previousMode = segs.last?.mode @@ -356,7 +328,6 @@ public final class CompositionEngine { keys = [] cursor = nil forcedMode = nil - forcedIsCorrection = false fixed = [:] candidates = [] } diff --git a/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift b/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift index c5b0864..e185085 100644 --- a/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift +++ b/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift @@ -297,13 +297,16 @@ final class ShiftTapTests: XCTestCase { return out } - func testShiftTapForcesNextWordEnglishLowercase() { + func testShiftTapTogglesEnglishMode() { let e = engine() - // "ru" alone would be ㄐㄧ (機); after a Shift tap it stays English, lowercase. - XCTAssertEqual(type("⇧ru ", into: e), "ru ") - // Automatic detection resumes after the word. - XCTAssertFalse(e.isEnglishArmed) - XCTAssertEqual(type("su3cl3\n", into: e), "你好") + // "ru" alone would be ㄐㄧ (機); in English mode keys pass straight through, lowercase. + XCTAssertEqual(type("⇧ru su ", into: e), "ru su ") + XCTAssertTrue(e.isEnglishMode) // still English after spaces + XCTAssertEqual(e.markedText, "") // never composed: no underline + XCTAssertEqual(type("\n", into: e), "\n") // Enter goes to the app, mode stays + XCTAssertTrue(e.isEnglishMode) + XCTAssertEqual(type("⇧su3cl3\n", into: e), "你好") // tap again: automatic again + XCTAssertFalse(e.isEnglishMode) } func testShiftTapTwiceCancels() { @@ -316,22 +319,22 @@ final class ShiftTapTests: XCTestCase { XCTAssertEqual(e.mode, .literal) _ = e.handle(.shiftTap) XCTAssertEqual(e.mode, .zhuyin) + XCTAssertFalse(e.isEnglishMode) // a flip, not English mode _ = type("\n", into: e) XCTAssertEqual(e.classifier.learned.weights["so"], 1) // a correction is learned } - func testForcingBeforeTypingIsNotLearned() { + func testEnglishModeIsNotLearned() { let e = engine() _ = type("⇧hello ", into: e) - XCTAssertNil(e.classifier.learned.weights["hello"]) + XCTAssertTrue(e.classifier.learned.weights.isEmpty) } - func testArmingSurvivesBackspace() { + func testBackspaceInEnglishModeGoesToApp() { let e = engine() - _ = type("⇧r", into: e) - _ = e.handle(.backspace) - XCTAssertTrue(e.isEnglishArmed) - XCTAssertEqual(type("ru ", into: e), "ru ") + _ = type("⇧", into: e) + XCTAssertFalse(e.handle(.backspace).handled) + XCTAssertTrue(e.isEnglishMode) } func testDetector() { @@ -405,27 +408,3 @@ final class CursorTests: XCTestCase { XCTAssertTrue(e.isShowingCandidates) } } - -final class DirectEnglishTests: XCTestCase { - func testForcedEnglishHasNoComposition() { - let e = CompositionEngine(classifier: Classifier(lexicon: sharedLexicon, english: sharedEnglish, weights: sharedWeights)) - _ = e.handle(.shiftTap) - let r = e.handle(.character("r")) - XCTAssertEqual(r.commit, "r") // inserted right away - XCTAssertEqual(e.markedText, "") // nothing underlined - XCTAssertEqual(e.handle(.character("u")).commit, "u") - XCTAssertEqual(e.handle(.character("'")).commit, "'") - XCTAssertFalse(e.handle(.backspace).handled) // the app deletes it - XCTAssertTrue(e.isEnglishArmed) - XCTAssertEqual(e.handle(.character(" ")).commit, " ") - XCTAssertFalse(e.isEnglishArmed) // back to automatic - } - - func testEnterEndsForcedEnglish() { - let e = CompositionEngine(classifier: Classifier(lexicon: sharedLexicon, english: sharedEnglish, weights: sharedWeights)) - _ = e.handle(.shiftTap) - _ = e.handle(.character("a")) - XCTAssertFalse(e.handle(.enter).handled) - XCTAssertFalse(e.isEnglishArmed) - } -} diff --git a/windows/autozhuyin/autozhuyin_ime.py b/windows/autozhuyin/autozhuyin_ime.py index 39bf40a..6601d66 100644 --- a/windows/autozhuyin/autozhuyin_ime.py +++ b/windows/autozhuyin/autozhuyin_ime.py @@ -142,8 +142,8 @@ class AutoZhuyinTextService(TextService): return False self.engine.handle(SHIFT_TAP) self._update(None) - if self.engine.english_armed: - self.showMessage("英文", 1) + if not self.engine.keys: + self.showMessage("英文" if self.engine.english_mode else "中英自動", 1) return True # --- replies --- diff --git a/windows/autozhuyin/core/engine.py b/windows/autozhuyin/core/engine.py index a4a3d3a..858bf92 100644 --- a/windows/autozhuyin/core/engine.py +++ b/windows/autozhuyin/core/engine.py @@ -34,9 +34,9 @@ class CompositionEngine: self.now = now self.keys = [] self.forced_mode = None - # True when forced_mode corrects the classifier (learned on commit); False when the - # user forced English before typing (Shift tap on an empty buffer). - self._forced_is_correction = False + # English mode, toggled by a Shift tap when nothing is being typed: keys go straight + # to the app (no composition, no underline) until Shift is tapped again. + self.english_mode = False self.fixed = {} # zhuyin segment start -> {(syl_start, syl_end): text} self.candidates = [] self.candidate_index = 0 @@ -150,26 +150,16 @@ class CompositionEngine: # --- key handling --- - @property - def english_armed(self): - """True while the user has forced English for the next word (Shift tap). In this - mode keys go straight to the app with no composition (no underline).""" - return not self.keys and self.forced_mode == LITERAL and not self._forced_is_correction - - def _end_direct_english(self): - if self.english_armed: - self.forced_mode = None - self._previous_mode = LITERAL - self._previous_time = self.now() - def _flip(self): + """Forces the whole buffer into the other mode (a correction that is learned).""" self.forced_mode = LITERAL if self.mode == ZHUYIN else ZHUYIN - self._forced_is_correction = True def wants(self, key): """Whether handle(key) would consume the key, without changing state.""" - if self.candidates or key == SHIFT_TAP or self.english_armed: + if self.candidates or key == SHIFT_TAP: return True + if self.english_mode and not self.keys: + return False # English mode: everything goes to the app as typed if key in SPECIAL_KEYS: return bool(self.keys) if self.keys: @@ -190,34 +180,29 @@ class CompositionEngine: self.keys.pop() self.fixed = {k: v for k, v in self.fixed.items() if k < len(self.keys)} if not self.keys: - # A Shift-tap "next word is English" stays armed; a correction is dropped. - if self._forced_is_correction: - self.forced_mode = None - self._forced_is_correction = False + self.forced_mode = None self.fixed = {} return CONSUMED if key == ENTER: if not self.keys: - self._end_direct_english() return PASS return True, self._commit() if key == ESCAPE: if not self.keys: - self._end_direct_english() return PASS self.reset() return CONSUMED if key == TAB: if not self.keys: - self._end_direct_english() return PASS self._flip() return CONSUMED if key == SHIFT_TAP: if not self.keys: - # Next word is English, typed as-is. Tap again to cancel. - self.forced_mode = None if self.forced_mode == LITERAL else LITERAL - self._forced_is_correction = False + # Toggle English mode; it stays on until the next Shift tap. + self.english_mode = not self.english_mode + self._previous_mode = LITERAL if self.english_mode else None + self._previous_time = self.now() else: self._flip() return CONSUMED @@ -243,15 +228,8 @@ class CompositionEngine: def _handle_character(self, c): self.cursor = None # typing always continues at the end - if self.english_armed: - # Forced English: insert directly. Space ends the word; other symbols end it too. - if c == " ": - self._end_direct_english() - return True, " " - if c.isascii() and (c.isalnum() or c in "'.,-/;"): - return True, c - self._end_direct_english() - return PASS + if self.english_mode and not self.keys: + return PASS # English mode: every key goes to the app as typed if c == " ": if not self.keys: return PASS @@ -329,7 +307,7 @@ class CompositionEngine: def _commit(self, segs=None): segs = segs if segs is not None else self.segments text = "".join(self._render(s, True) for s in segs) - if self.forced_mode and self._forced_is_correction: + if self.forced_mode: self.classifier.learned.record("".join(self.keys), self.forced_mode) self._previous_mode = segs[-1][2] if segs else None self._previous_time = self.now() @@ -343,6 +321,5 @@ class CompositionEngine: self.keys = [] self.cursor = None self.forced_mode = None - self._forced_is_correction = False self.fixed = {} self.candidates = [] diff --git a/windows/installer/README.txt b/windows/installer/README.txt index fe0a58f..f9b1289 100644 --- a/windows/installer/README.txt +++ b/windows/installer/README.txt @@ -29,9 +29,9 @@ ← → 在組字區移動游標,選要改哪個字 ↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字 Esc 取消組字 - 單按 Shift 下一個字強制英文(保持小寫、直接送出、沒有底線), - 按空白或 Enter 後恢復自動判斷; - 打到一半時按,同 Tab 整段翻轉。會出現「英文」小提示 + 單按 Shift 切換英文模式(按鍵直接送出、保持小寫、沒有底線), + 再單按一次回到中英自動判斷,會出現「英文」/「中英自動」小提示; + 打到一半時按,同 Tab 整段翻轉 Shift+字母 打大寫字母(也會強制英文) < > ? ! : 中文語境下自動變成全形 ,。?!: diff --git a/windows/tests/test_core.py b/windows/tests/test_core.py index 377802b..e520a85 100644 --- a/windows/tests/test_core.py +++ b/windows/tests/test_core.py @@ -194,11 +194,15 @@ class MixedSegmentTests(unittest.TestCase): class ShiftTapTests(unittest.TestCase): - def test_forces_next_word_english_lowercase(self): + def test_toggles_english_mode(self): e = make_engine() - self.assertEqual(type_keys("⇧ru ", e), "ru ") - self.assertFalse(e.english_armed) - self.assertEqual(type_keys("su3cl3\n", e), "你好") + self.assertEqual(type_keys("⇧ru su ", e), "ru su ") + self.assertTrue(e.english_mode) + self.assertEqual(e.marked_text, "") + self.assertEqual(e.handle(ENTER), (False, None)) + self.assertTrue(e.english_mode) + self.assertEqual(type_keys("⇧su3cl3\n", e), "你好") + self.assertFalse(e.english_mode) def test_tap_twice_cancels(self): self.assertEqual(type_keys("⇧⇧su3cl3\n", make_engine()), "你好") @@ -208,20 +212,20 @@ class ShiftTapTests(unittest.TestCase): type_keys("so", e) e.handle(SHIFT_TAP) self.assertEqual(e.mode, ZHUYIN) + self.assertFalse(e.english_mode) type_keys("\n", e) self.assertEqual(e.classifier.learned.weights["so"], 1) - def test_forcing_before_typing_not_learned(self): + def test_english_mode_not_learned(self): e = make_engine() type_keys("⇧hello ", e) - self.assertNotIn("hello", e.classifier.learned.weights) + self.assertEqual(e.classifier.learned.weights, {}) - def test_arming_survives_backspace(self): + def test_backspace_goes_to_app(self): e = make_engine() - type_keys("⇧r", e) - e.handle(BACKSPACE) - self.assertTrue(e.english_armed) - self.assertEqual(type_keys("ru ", e), "ru ") + e.handle(SHIFT_TAP) + self.assertEqual(e.handle(BACKSPACE), (False, None)) + self.assertTrue(e.english_mode) def test_detector(self): d = ShiftTapDetector() @@ -267,25 +271,5 @@ class CursorTests(unittest.TestCase): self.assertTrue(e.showing_candidates) -class DirectEnglishTests(unittest.TestCase): - def test_forced_english_has_no_composition(self): - e = make_engine() - e.handle(SHIFT_TAP) - self.assertEqual(e.handle("r"), (True, "r")) - self.assertEqual(e.marked_text, "") - self.assertEqual(e.handle("'"), (True, "'")) - self.assertEqual(e.handle(BACKSPACE), (False, None)) - self.assertTrue(e.english_armed) - self.assertEqual(e.handle(" "), (True, " ")) - self.assertFalse(e.english_armed) - - def test_enter_ends_forced_english(self): - e = make_engine() - e.handle(SHIFT_TAP) - e.handle("a") - self.assertEqual(e.handle(ENTER), (False, None)) - self.assertFalse(e.english_armed) - - if __name__ == "__main__": unittest.main() diff --git a/windows/tests/test_pime_wrapper.py b/windows/tests/test_pime_wrapper.py index 1c518f3..e332b12 100644 --- a/windows/tests/test_pime_wrapper.py +++ b/windows/tests/test_pime_wrapper.py @@ -144,14 +144,15 @@ class ShiftTapWrapperTests(unittest.TestCase): def test_tap_forces_english_lowercase(self): reply = tap_shift(self.svc) self.assertEqual(reply.get("showMessage"), "英文") - self.assertEqual(type_text(self.svc, "ru "), "ru ") + self.assertEqual(type_text(self.svc, "ru su "), "ru su ") + self.assertEqual(tap_shift(self.svc).get("showMessage"), "中英自動") def test_shift_with_letter_is_not_a_tap(self): self.svc.filterKeyDown(FakeKeyEvent("⇧", shift=True)) press(self.svc, "H", shift=True) up = FakeKeyEvent("⇧") self.assertFalse(self.svc.filterKeyUp(up)) - self.assertFalse(self.svc.engine.english_armed) + self.assertFalse(self.svc.engine.english_mode) if __name__ == "__main__":