From 20291bf5152b476fabee1f6f9c485c8072fb9364 Mon Sep 17 00:00:00 2001 From: John Kao Date: Wed, 11 Nov 2026 09:57:18 +0800 Subject: [PATCH] Add Shift tap to force English for the next word MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pressing and releasing Shift on its own arms literal mode for the next word, so lowercase English can be typed without it being read as Zhuyin; it resets after the word is committed and a second tap cancels it. While typing, a Shift tap flips the buffer like Tab. Forcing before typing is not recorded as a learned correction; flipping is. Mac: listens for flagsChanged events. Windows: Shift key-up via PIME's filterKeyUp/onKeyUp, with a short "英文" tooltip. The tap detection lives in the core (ShiftTapDetector / shift_tap.py) with tests on both sides. Co-Authored-By: Claude Opus 5.5 --- README.md | 4 +- Sources/AutoZhuyin/InputController.swift | 21 +++++- .../AutoZhuyinCore/CompositionEngine.swift | 37 ++++++++-- Sources/AutoZhuyinCore/ShiftTapDetector.swift | 32 +++++++++ .../AutoZhuyinCoreTests.swift | 70 +++++++++++++++++++ windows/autozhuyin/autozhuyin_ime.py | 27 ++++++- windows/autozhuyin/core/engine.py | 35 ++++++++-- windows/autozhuyin/core/shift_tap.py | 24 +++++++ windows/installer/README.txt | 4 +- windows/tests/test_core.py | 46 +++++++++++- windows/tests/test_pime_wrapper.py | 35 +++++++++- 11 files changed, 317 insertions(+), 18 deletions(-) create mode 100644 Sources/AutoZhuyinCore/ShiftTapDetector.swift create mode 100644 windows/autozhuyin/core/shift_tap.py diff --git a/README.md b/README.md index 1efb5a2..61b5770 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,7 @@ - **中英自動判斷**:每按一個鍵就重新判斷,組字區即時顯示結果(Mac 版英文以藍字顯示) - **中英混打不用空白**:`ji3hello` → 我hello、`hellosu3cl3` → hello你好,同一段內會自動切分 - **判斷錯了按 Tab**:在中/英之間翻轉,輸入法會記住這組按鍵,下次自動判斷對 +- **單按 Shift 強制英文**:要打英文時先單按一下 Shift,接下來這個字照打、保持小寫 - **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小) - **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」 - **候選字**:按 ↓ 選最後一個字或詞,選過的會固定下來 @@ -52,7 +53,8 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安 | **Tab** | 判斷錯了?按 Tab 把整段翻轉成另一種語言,輸入法會**記住**這次修正 | | ↓ | 開啟候選字(選最後一個字或詞),數字鍵 1–9 選字,Esc 關閉 | | Esc | 取消組字 | -| Shift + 字母 | 強制英文 | +| **單按 Shift** | 沒在打字時:下一個字強制英文(保持小寫),送出後恢復自動判斷,再按一次取消。打到一半時:同 Tab,整段翻轉 | +| Shift + 字母 | 打大寫字母(也會強制英文) | | `< > ? ! : ( ) [ ]` | 中文語境下自動轉成全形 `,。?!:()「」` | | `, . / ; -` | 英文單字後是標點;在注音中是 ㄝ ㄡ ㄥ ㄤ ㄦ(例如 `2;3` = 檔) | diff --git a/Sources/AutoZhuyin/InputController.swift b/Sources/AutoZhuyin/InputController.swift index ae28167..103c7aa 100644 --- a/Sources/AutoZhuyin/InputController.swift +++ b/Sources/AutoZhuyin/InputController.swift @@ -34,15 +34,32 @@ enum Shared { @objc(AutoZhuyinInputController) final class InputController: IMKInputController { private let engine = CompositionEngine(classifier: Shared.classifier) + private var shiftTap = ShiftTapDetector() // MARK: - Key events override func recognizedEvents(_ sender: Any!) -> Int { - Int(NSEvent.EventTypeMask.keyDown.rawValue) + Int(NSEvent.EventTypeMask.keyDown.rawValue | NSEvent.EventTypeMask.flagsChanged.rawValue) } override func handle(_ event: NSEvent!, client sender: Any!) -> Bool { - guard let event, event.type == .keyDown, let client = sender as? IMKTextInput else { return false } + guard let event, let client = sender as? IMKTextInput else { return false } + + // Shift pressed and released alone: next word is English (or flip the current one). + if event.type == .flagsChanged { + let flags = event.modifierFlags + let tapped = shiftTap.modifiersChanged( + shift: flags.contains(.shift), + otherModifiers: !flags.intersection([.command, .control, .option, .function]).isEmpty, + time: event.timestamp) + if tapped { + _ = engine.handle(.shiftTap) + updateComposition(client) + } + return false + } + guard event.type == .keyDown else { return false } + shiftTap.keyPressed() // Shortcuts (⌘C, ⌃A, ⌥…) go to the app; commit any composition first. if !event.modifierFlags.intersection([.command, .control, .option]).isEmpty { diff --git a/Sources/AutoZhuyinCore/CompositionEngine.swift b/Sources/AutoZhuyinCore/CompositionEngine.swift index d4a5dda..d734686 100644 --- a/Sources/AutoZhuyinCore/CompositionEngine.swift +++ b/Sources/AutoZhuyinCore/CompositionEngine.swift @@ -4,6 +4,8 @@ public enum KeyInput: Equatable { case character(Character) case backspace, enter, escape, tab case up, down, left, right + /// Shift pressed and released on its own. + case shiftTap } public struct KeyResult: Equatable { @@ -33,8 +35,12 @@ public final class CompositionEngine { public let converter: Converter public private(set) var keys: [Character] = [] - /// Set by Tab: overrides the classifier for the whole buffer. + /// Set by Tab / Shift tap: overrides the classifier for the whole buffer. 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 /// User-picked phrases: Zhuyin segment start (key index) → syllable range → text. private var fixed: [Int: [Range: String]] = [:] public private(set) var candidates: [Candidate] = [] @@ -108,7 +114,11 @@ public final class CompositionEngine { guard !keys.isEmpty else { return .passThrough } keys.removeLast() fixed = fixed.filter { $0.key < keys.count } - if keys.isEmpty { forcedMode = nil; fixed = [:] } + if keys.isEmpty { + // A Shift-tap "next word is English" stays armed; a correction is dropped. + if forcedIsCorrection { forcedMode = nil; forcedIsCorrection = false } + fixed = [:] + } return .consumed case .enter: guard !keys.isEmpty else { return .passThrough } @@ -119,7 +129,16 @@ public final class CompositionEngine { return .consumed case .tab: guard !keys.isEmpty else { return .passThrough } - forcedMode = (mode == .zhuyin) ? .literal : .zhuyin + 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 + } else { + flip() + } return .consumed case .down: guard !keys.isEmpty else { return .passThrough } @@ -130,6 +149,15 @@ 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 before typing anything (Shift tap). + public var isEnglishArmed: Bool { keys.isEmpty && forcedMode == .literal } + private func handleCharacter(_ c: Character) -> KeyResult { if c == " " { guard !keys.isEmpty else { return .passThrough } @@ -224,7 +252,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 { + if let forced = forcedMode, forcedIsCorrection { classifier.learned.record(String(keys), as: forced) } previousMode = segs.last?.mode @@ -241,6 +269,7 @@ public final class CompositionEngine { public func reset() { keys = [] forcedMode = nil + forcedIsCorrection = false fixed = [:] candidates = [] } diff --git a/Sources/AutoZhuyinCore/ShiftTapDetector.swift b/Sources/AutoZhuyinCore/ShiftTapDetector.swift new file mode 100644 index 0000000..92c1276 --- /dev/null +++ b/Sources/AutoZhuyinCore/ShiftTapDetector.swift @@ -0,0 +1,32 @@ +import Foundation + +/// Detects Shift pressed and released on its own (no other key in between, released +/// within `maxDuration`), as opposed to Shift used for capitals or shortcuts. +/// +/// Python twin: windows/autozhuyin/core/shift_tap.py +public struct ShiftTapDetector { + public var maxDuration: TimeInterval = 0.5 + private var pressedAt: TimeInterval? + private var used = false + + public init() {} + + /// Call when the modifier state changes. Returns true when a Shift tap completed. + public mutating func modifiersChanged(shift: Bool, otherModifiers: Bool, time: TimeInterval) -> Bool { + if shift && !otherModifiers { + if pressedAt == nil { + pressedAt = time + used = false + } + return false + } + defer { pressedAt = nil } + guard let start = pressedAt, !shift, !otherModifiers, !used else { return false } + return time - start <= maxDuration + } + + /// Call for every other key press: Shift was used as a modifier, not tapped. + public mutating func keyPressed() { + if pressedAt != nil { used = true } + } +} diff --git a/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift b/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift index 2b7112b..cc44031 100644 --- a/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift +++ b/Tests/AutoZhuyinCoreTests/AutoZhuyinCoreTests.swift @@ -281,3 +281,73 @@ final class ParityTests: XCTestCase { XCTAssertEqual(out.count, 1, out) } } + +final class ShiftTapTests: 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 == "⇧" ? .shiftTap : 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 testShiftTapForcesNextWordEnglishLowercase() { + 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), "你好") + } + + func testShiftTapTwiceCancels() { + XCTAssertEqual(type("⇧⇧su3cl3\n", into: engine()), "你好") + } + + func testShiftTapMidWordFlips() { + let e = engine() + _ = type("so", into: e) + XCTAssertEqual(e.mode, .literal) + _ = e.handle(.shiftTap) + XCTAssertEqual(e.mode, .zhuyin) + _ = type("\n", into: e) + XCTAssertEqual(e.classifier.learned.weights["so"], 1) // a correction is learned + } + + func testForcingBeforeTypingIsNotLearned() { + let e = engine() + _ = type("⇧hello ", into: e) + XCTAssertNil(e.classifier.learned.weights["hello"]) + } + + func testArmingSurvivesBackspace() { + let e = engine() + _ = type("⇧r", into: e) + _ = e.handle(.backspace) + XCTAssertTrue(e.isEnglishArmed) + XCTAssertEqual(type("ru ", into: e), "ru ") + } + + func testDetector() { + var d = ShiftTapDetector() + XCTAssertFalse(d.modifiersChanged(shift: true, otherModifiers: false, time: 0)) + XCTAssertTrue(d.modifiersChanged(shift: false, otherModifiers: false, time: 0.1)) + // Shift used for a capital letter: not a tap. + _ = d.modifiersChanged(shift: true, otherModifiers: false, time: 1) + d.keyPressed() + XCTAssertFalse(d.modifiersChanged(shift: false, otherModifiers: false, time: 1.1)) + // Held too long: not a tap. + _ = d.modifiersChanged(shift: true, otherModifiers: false, time: 2) + XCTAssertFalse(d.modifiersChanged(shift: false, otherModifiers: false, time: 3)) + // Shift + Command: not a tap. + _ = d.modifiersChanged(shift: true, otherModifiers: false, time: 4) + _ = d.modifiersChanged(shift: true, otherModifiers: true, time: 4.1) + XCTAssertFalse(d.modifiersChanged(shift: false, otherModifiers: false, time: 4.2)) + } +} diff --git a/windows/autozhuyin/autozhuyin_ime.py b/windows/autozhuyin/autozhuyin_ime.py index cc485d0..fee4064 100644 --- a/windows/autozhuyin/autozhuyin_ime.py +++ b/windows/autozhuyin/autozhuyin_ime.py @@ -6,14 +6,16 @@ tests); this file only translates PIME key events and replies. """ import json import os +import time from keycodes import * # noqa: F401,F403 (VK_* constants, provided by PIME) from textService import TextService from .core.classifier import Classifier, LearnedPreferences -from .core.engine import BACKSPACE, DOWN, ENTER, ESCAPE, LEFT, RIGHT, TAB, UP, CompositionEngine +from .core.engine import BACKSPACE, DOWN, ENTER, ESCAPE, LEFT, RIGHT, SHIFT_TAP, TAB, UP, CompositionEngine from .core.english import EnglishModel from .core.lexicon import Lexicon +from .core.shift_tap import ShiftTapDetector _HERE = os.path.dirname(os.path.abspath(__file__)) _DATA = os.path.join(_HERE, "data") @@ -67,6 +69,7 @@ class AutoZhuyinTextService(TextService): def __init__(self, client): TextService.__init__(self, client) self.engine = CompositionEngine(_shared_classifier()) + self.shift_tap = ShiftTapDetector() # --- lifecycle --- @@ -105,6 +108,13 @@ class AutoZhuyinTextService(TextService): return bool(self.engine.keys or self.engine.candidates) def filterKeyDown(self, ev): + if ev.keyCode == VK_SHIFT: # noqa: F405 + if ev.isKeyDown(VK_CONTROL) or ev.isKeyDown(VK_MENU): # noqa: F405 + self.shift_tap.key_pressed() + else: + self.shift_tap.shift_down(time.monotonic()) + return False + self.shift_tap.key_pressed() # Shortcuts (Ctrl/Alt) go to the app. if ev.isKeyDown(VK_CONTROL) or ev.isKeyDown(VK_MENU): # noqa: F405 return False @@ -121,6 +131,21 @@ class AutoZhuyinTextService(TextService): self._update(commit) return handled + def filterKeyUp(self, ev): + # Shift pressed and released alone: next word is English (or flip the current one). + if ev.keyCode == VK_SHIFT: # noqa: F405 + return self.shift_tap.shift_up(time.monotonic()) + return False + + def onKeyUp(self, ev): + if ev.keyCode != VK_SHIFT: # noqa: F405 + return False + self.engine.handle(SHIFT_TAP) + self._update(None) + if self.engine.english_armed: + self.showMessage("英文", 1) + return True + # --- replies --- def _update(self, commit): diff --git a/windows/autozhuyin/core/engine.py b/windows/autozhuyin/core/engine.py index f4930bc..15bb9d8 100644 --- a/windows/autozhuyin/core/engine.py +++ b/windows/autozhuyin/core/engine.py @@ -12,7 +12,8 @@ from .lexicon import Converter BACKSPACE, ENTER, ESCAPE, TAB = "", "", "", "" UP, DOWN, LEFT, RIGHT = "", "", "", "" -SPECIAL_KEYS = {BACKSPACE, ENTER, ESCAPE, TAB, UP, DOWN, LEFT, RIGHT} +SHIFT_TAP = "" # Shift pressed and released on its own +SPECIAL_KEYS = {BACKSPACE, ENTER, ESCAPE, TAB, UP, DOWN, LEFT, RIGHT, SHIFT_TAP} FULLWIDTH = { "<": ",", ">": "。", "?": "?", "!": "!", ":": ":", '"': "「", "(": "(", ")": ")", @@ -33,6 +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 self.fixed = {} # zhuyin segment start -> {(syl_start, syl_end): text} self.candidates = [] self.candidate_index = 0 @@ -102,9 +106,18 @@ class CompositionEngine: # --- key handling --- + @property + def english_armed(self): + """True while the user has forced English before typing anything (Shift tap).""" + return not self.keys and self.forced_mode == LITERAL + + def _flip(self): + 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: + if self.candidates or key == SHIFT_TAP: return True if key in SPECIAL_KEYS: return bool(self.keys) @@ -125,7 +138,10 @@ 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: - self.forced_mode = None + # 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.fixed = {} return CONSUMED if key == ENTER: @@ -138,7 +154,15 @@ class CompositionEngine: if key == TAB: if not self.keys: return PASS - self.forced_mode = LITERAL if self.mode == ZHUYIN else ZHUYIN + 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 + else: + self._flip() return CONSUMED if key == DOWN: if not self.keys: @@ -232,7 +256,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: + if self.forced_mode and self._forced_is_correction: 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() @@ -245,5 +269,6 @@ class CompositionEngine: def reset(self): self.keys = [] self.forced_mode = None + self._forced_is_correction = False self.fixed = {} self.candidates = [] diff --git a/windows/autozhuyin/core/shift_tap.py b/windows/autozhuyin/core/shift_tap.py new file mode 100644 index 0000000..8709458 --- /dev/null +++ b/windows/autozhuyin/core/shift_tap.py @@ -0,0 +1,24 @@ +"""Detects Shift pressed and released on its own. Port of ShiftTapDetector.swift.""" + + +class ShiftTapDetector: + max_duration = 0.5 + + def __init__(self): + self._pressed_at = None + self._used = False + + def shift_down(self, time): + if self._pressed_at is None: # ignore auto-repeat + self._pressed_at = time + self._used = False + + def key_pressed(self): + """Any other key while Shift is held: Shift was used as a modifier.""" + if self._pressed_at is not None: + self._used = True + + def shift_up(self, time): + """Returns True when this release completes a Shift tap.""" + start, self._pressed_at = self._pressed_at, None + return start is not None and not self._used and time - start <= self.max_duration diff --git a/windows/installer/README.txt b/windows/installer/README.txt index f7752ae..dede5bc 100644 --- a/windows/installer/README.txt +++ b/windows/installer/README.txt @@ -28,7 +28,9 @@ Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正 ↓ 開啟候選字,按數字鍵 1–9 選字 Esc 取消組字 - Shift+字母 強制英文 + 單按 Shift 下一個字強制英文(保持小寫),送出後恢復自動判斷; + 打到一半時按,同 Tab 整段翻轉。會出現「英文」小提示 + Shift+字母 打大寫字母(也會強制英文) < > ? ! : 中文語境下自動變成全形 ,。?!: 注音符號的順序打錯也沒關係,例如 ㄧㄒㄠˇ 會自動變成 ㄒㄧㄠˇ(小)。 diff --git a/windows/tests/test_core.py b/windows/tests/test_core.py index edf7d67..190723e 100644 --- a/windows/tests/test_core.py +++ b/windows/tests/test_core.py @@ -11,7 +11,8 @@ 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, TAB, CompositionEngine # noqa: E402 +from autozhuyin.core.engine import DOWN, ENTER, 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 @@ -41,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 c + key = ENTER if c == "\n" else TAB if c == "\t" else SHIFT_TAP if c == "⇧" else c handled, commit = e.handle(key) if commit is not None: out += commit @@ -192,5 +193,46 @@ class MixedSegmentTests(unittest.TestCase): self.assertLess(per_key, 0.05) +class ShiftTapTests(unittest.TestCase): + def test_forces_next_word_english_lowercase(self): + e = make_engine() + self.assertEqual(type_keys("⇧ru ", e), "ru ") + self.assertFalse(e.english_armed) + self.assertEqual(type_keys("su3cl3\n", e), "你好") + + def test_tap_twice_cancels(self): + self.assertEqual(type_keys("⇧⇧su3cl3\n", make_engine()), "你好") + + def test_mid_word_flips_and_learns(self): + e = make_engine() + type_keys("so", e) + e.handle(SHIFT_TAP) + self.assertEqual(e.mode, ZHUYIN) + type_keys("\n", e) + self.assertEqual(e.classifier.learned.weights["so"], 1) + + def test_forcing_before_typing_not_learned(self): + e = make_engine() + type_keys("⇧hello ", e) + self.assertNotIn("hello", e.classifier.learned.weights) + + def test_arming_survives_backspace(self): + e = make_engine() + type_keys("⇧r", e) + e.handle(BACKSPACE) + self.assertTrue(e.english_armed) + self.assertEqual(type_keys("ru ", e), "ru ") + + def test_detector(self): + d = ShiftTapDetector() + d.shift_down(0) + self.assertTrue(d.shift_up(0.1)) + d.shift_down(1) + d.key_pressed() + self.assertFalse(d.shift_up(1.1)) + d.shift_down(2) + self.assertFalse(d.shift_up(3)) + + if __name__ == "__main__": unittest.main() diff --git a/windows/tests/test_pime_wrapper.py b/windows/tests/test_pime_wrapper.py index e7aeefc..1c518f3 100644 --- a/windows/tests/test_pime_wrapper.py +++ b/windows/tests/test_pime_wrapper.py @@ -36,6 +36,8 @@ class FakeTextService: def setCandidateList(self, c): self.reply["candidateList"] = c def setCandidateCursor(self, p): self.reply["candidateCursor"] = p + def showMessage(self, message, duration=3): self.reply["showMessage"] = message + def setShowCandidates(self, show): self.showCandidates = show self.reply["showCandidates"] = show @@ -51,8 +53,8 @@ VK = {"\n": 0x0D, "\t": 0x09, " ": 0x20, "\b": 0x08, "↓": 0x28} class FakeKeyEvent: def __init__(self, ch, shift=False, ctrl=False): - self.keyCode = VK.get(ch, ord(ch.upper()) if ch.isalnum() else 0xBA) - self.charCode = 0 if ch in ("\n", "\t", "\b", "↓") else ord(ch) + self.keyCode = 0x10 if ch == "⇧" else VK.get(ch, ord(ch.upper()) if ch.isalnum() else 0xBA) + self.charCode = 0 if ch in ("\n", "\t", "\b", "↓", "⇧") else ord(ch) self.keyStates = [0] * 256 if shift: self.keyStates[0x10] = 0x80 @@ -74,6 +76,17 @@ def press(svc, ch, **kw): return True, svc.reply +def tap_shift(svc): + """Shift down then up with nothing in between, as PIME delivers it.""" + svc.reply = {} + down = FakeKeyEvent("⇧", shift=True) + assert not svc.filterKeyDown(down) + up = FakeKeyEvent("⇧") + if svc.filterKeyUp(up): + svc.onKeyUp(up) + return svc.reply + + def type_text(svc, text): out = "" for ch in text: @@ -123,5 +136,23 @@ class WrapperTests(unittest.TestCase): self.assertEqual(out + reply.get("commitString", ""), "Hi ") +class ShiftTapWrapperTests(unittest.TestCase): + def setUp(self): + self.svc = AutoZhuyinTextService(client=None) + self.svc.onActivate() + + 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 ") + + 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) + + if __name__ == "__main__": unittest.main()