Compare commits

..
2 Commits
Author SHA1 Message Date
ays953 17f7d6f50d Release v0.6.0 2026-11-11 11:44:38 +08:00
ays953andClaude Opus 5.5 7e173a1da8 Make the Shift tap a persistent English-mode toggle
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 <noreply@anthropic.com>
2026-11-11 11:44:25 +08:00
10 changed files with 75 additions and 163 deletions
+2 -2
View File
@@ -12,7 +12,7 @@
- **中英自動判斷**:每按一個鍵就重新判斷,組字區即時顯示結果(Mac 版英文以藍字顯示) - **中英自動判斷**:每按一個鍵就重新判斷,組字區即時顯示結果(Mac 版英文以藍字顯示)
- **中英混打不用空白**:`ji3hello` → 我hello、`hellosu3cl3` → hello你好,同一段內會自動切分 - **中英混打不用空白**:`ji3hello` → 我hello、`hellosu3cl3` → hello你好,同一段內會自動切分
- **判斷錯了按 Tab**:在中/英之間翻轉,輸入法會記住這組按鍵,下次自動判斷對 - **判斷錯了按 Tab**:在中/英之間翻轉,輸入法會記住這組按鍵,下次自動判斷對
- **單按 Shift 強制英文**:要打英文時先單按一下 Shift,接下來這個字照打、保持小寫,而且直接送出、不顯示底線 - **單按 Shift 切換英文模式**:英文模式下按鍵直接送出、保持小寫、不顯示底線,再單按一次 Shift 回到中英自動判斷
- **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小) - **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小)
- **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」 - **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」
- **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來 - **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來
@@ -54,7 +54,7 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安
| ← → | 在組字區移動游標,選要改哪個字 | | ← → | 在組字區移動游標,選要改哪個字 |
| ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 | | ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 |
| Esc | 取消組字 | | Esc | 取消組字 |
| **單按 Shift** | 沒在打字時:下一個字強制英文(保持小寫),字母直接送出、沒有底線;按空白、Enter 或其他符號後恢復自動判斷,再按一次 Shift 取消。打到一半時:同 Tab,整段翻轉 | | **單按 Shift** | 沒在打字時:切換**英文模式**,按鍵直接送出、保持小寫、沒有底線,一直維持到再單按一次 Shift 才回到中英自動判斷。打到一半時:同 Tab,整段翻轉 |
| Shift + 字母 | 打大寫字母(也會強制英文) | | Shift + 字母 | 打大寫字母(也會強制英文) |
| `< > ? ! : ( ) [ ]` | 中文語境下自動轉成全形 `,。?!:()「」` | | `< > ? ! : ( ) [ ]` | 中文語境下自動轉成全形 `,。?!:()「」` |
| `, . / ; -` | 英文單字後是標點;在注音中是 ㄝ ㄡ ㄥ ㄤ ㄦ(例如 `2;3` = 檔) | | `, . / ; -` | 英文單字後是標點;在注音中是 ㄝ ㄡ ㄥ ㄤ ㄦ(例如 `2;3` = 檔) |
+2 -2
View File
@@ -15,9 +15,9 @@
<key>CFBundlePackageType</key> <key>CFBundlePackageType</key>
<string>APPL</string> <string>APPL</string>
<key>CFBundleShortVersionString</key> <key>CFBundleShortVersionString</key>
<string>0.5.1</string> <string>0.6.0</string>
<key>CFBundleVersion</key> <key>CFBundleVersion</key>
<string>7</string> <string>8</string>
<key>InputMethodConnectionName</key> <key>InputMethodConnectionName</key>
<string>com.autozhuyin.inputmethod.AutoZhuyin_Connection</string> <string>com.autozhuyin.inputmethod.AutoZhuyin_Connection</string>
<key>InputMethodServerControllerClass</key> <key>InputMethodServerControllerClass</key>
+16 -45
View File
@@ -35,12 +35,12 @@ public final class CompositionEngine {
public let converter: Converter public let converter: Converter
public private(set) var keys: [Character] = [] 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? public private(set) var forcedMode: InputMode?
/// True when forcedMode corrects the classifier (learned on commit); false when the /// English mode, toggled by a Shift tap when nothing is being typed. Keys go straight
/// user forced English before typing (Shift tap on an empty buffer), which is not a /// to the app (no composition, no underline) until Shift is tapped again.
/// correction and is not learned. public private(set) var isEnglishMode = false
private var forcedIsCorrection = false
/// User-picked phrases: Zhuyin segment start (key index) → syllable range → text. /// User-picked phrases: Zhuyin segment start (key index) → syllable range → text.
private var fixed: [Int: [Range<Int>: String]] = [:] private var fixed: [Int: [Range<Int>: String]] = [:]
public private(set) var candidates: [Candidate] = [] public private(set) var candidates: [Candidate] = []
@@ -165,28 +165,25 @@ public final class CompositionEngine {
cursor = nil cursor = nil
keys.removeLast() keys.removeLast()
fixed = fixed.filter { $0.key < keys.count } fixed = fixed.filter { $0.key < keys.count }
if keys.isEmpty { if keys.isEmpty { forcedMode = nil; fixed = [:] }
// A Shift-tap "next word is English" stays armed; a correction is dropped.
if forcedIsCorrection { forcedMode = nil; forcedIsCorrection = false }
fixed = [:]
}
return .consumed return .consumed
case .enter: case .enter:
guard !keys.isEmpty else { endDirectEnglish(); return .passThrough } guard !keys.isEmpty else { return .passThrough }
return KeyResult(handled: true, commit: commitCurrent()) return KeyResult(handled: true, commit: commitCurrent())
case .escape: case .escape:
guard !keys.isEmpty else { endDirectEnglish(); return .passThrough } guard !keys.isEmpty else { return .passThrough }
reset() reset()
return .consumed return .consumed
case .tab: case .tab:
guard !keys.isEmpty else { endDirectEnglish(); return .passThrough } guard !keys.isEmpty else { return .passThrough }
flip() flip()
return .consumed return .consumed
case .shiftTap: case .shiftTap:
if keys.isEmpty { if keys.isEmpty {
// Next word is English, typed as-is (lowercase stays lowercase). Tap again to cancel. // Toggle English mode; it stays on until the next Shift tap.
forcedMode = forcedMode == .literal ? nil : .literal isEnglishMode.toggle()
forcedIsCorrection = false previousMode = isEnglishMode ? .literal : nil
previousCommitTime = now()
} else { } else {
flip() flip()
} }
@@ -211,37 +208,12 @@ public final class CompositionEngine {
/// Forces the whole buffer into the other mode (a correction that is learned). /// Forces the whole buffer into the other mode (a correction that is learned).
private func flip() { private func flip() {
forcedMode = (mode == .zhuyin) ? .literal : .zhuyin 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<Character> = ["'", ".", ",", "-", "/", ";"]
private func handleCharacter(_ c: Character) -> KeyResult { private func handleCharacter(_ c: Character) -> KeyResult {
cursor = nil // typing always continues at the end cursor = nil // typing always continues at the end
if isEnglishArmed { // English mode: every key goes to the app as typed.
// Forced English: insert directly. Space ends the word; other symbols end it too. if isEnglishMode && keys.isEmpty { return .passThrough }
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
}
if c == " " { if c == " " {
guard !keys.isEmpty else { return .passThrough } guard !keys.isEmpty else { return .passThrough }
let segs = segments(of: keys, finishing: true) let segs = segments(of: keys, finishing: true)
@@ -338,7 +310,7 @@ public final class CompositionEngine {
private func commitCurrent(_ given: [Segment]? = nil) -> String { private func commitCurrent(_ given: [Segment]? = nil) -> String {
let segs = given ?? segments let segs = given ?? segments
let text = segs.map { render($0, final: true) }.joined() 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) classifier.learned.record(String(keys), as: forced)
} }
previousMode = segs.last?.mode previousMode = segs.last?.mode
@@ -356,7 +328,6 @@ public final class CompositionEngine {
keys = [] keys = []
cursor = nil cursor = nil
forcedMode = nil forcedMode = nil
forcedIsCorrection = false
fixed = [:] fixed = [:]
candidates = [] candidates = []
} }
@@ -297,13 +297,16 @@ final class ShiftTapTests: XCTestCase {
return out return out
} }
func testShiftTapForcesNextWordEnglishLowercase() { func testShiftTapTogglesEnglishMode() {
let e = engine() let e = engine()
// "ru" alone would be ㄐㄧ (機); after a Shift tap it stays English, lowercase. // "ru" alone would be ㄐㄧ (機); in English mode keys pass straight through, lowercase.
XCTAssertEqual(type("⇧ru ", into: e), "ru ") XCTAssertEqual(type("⇧ru su ", into: e), "ru su ")
// Automatic detection resumes after the word. XCTAssertTrue(e.isEnglishMode) // still English after spaces
XCTAssertFalse(e.isEnglishArmed) XCTAssertEqual(e.markedText, "") // never composed: no underline
XCTAssertEqual(type("su3cl3\n", into: e), "你好") 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() { func testShiftTapTwiceCancels() {
@@ -316,22 +319,22 @@ final class ShiftTapTests: XCTestCase {
XCTAssertEqual(e.mode, .literal) XCTAssertEqual(e.mode, .literal)
_ = e.handle(.shiftTap) _ = e.handle(.shiftTap)
XCTAssertEqual(e.mode, .zhuyin) XCTAssertEqual(e.mode, .zhuyin)
XCTAssertFalse(e.isEnglishMode) // a flip, not English mode
_ = type("\n", into: e) _ = type("\n", into: e)
XCTAssertEqual(e.classifier.learned.weights["so"], 1) // a correction is learned XCTAssertEqual(e.classifier.learned.weights["so"], 1) // a correction is learned
} }
func testForcingBeforeTypingIsNotLearned() { func testEnglishModeIsNotLearned() {
let e = engine() let e = engine()
_ = type("⇧hello ", into: e) _ = type("⇧hello ", into: e)
XCTAssertNil(e.classifier.learned.weights["hello"]) XCTAssertTrue(e.classifier.learned.weights.isEmpty)
} }
func testArmingSurvivesBackspace() { func testBackspaceInEnglishModeGoesToApp() {
let e = engine() let e = engine()
_ = type("⇧r", into: e) _ = type("⇧", into: e)
_ = e.handle(.backspace) XCTAssertFalse(e.handle(.backspace).handled)
XCTAssertTrue(e.isEnglishArmed) XCTAssertTrue(e.isEnglishMode)
XCTAssertEqual(type("ru ", into: e), "ru ")
} }
func testDetector() { func testDetector() {
@@ -405,27 +408,3 @@ final class CursorTests: XCTestCase {
XCTAssertTrue(e.isShowingCandidates) 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)
}
}
+2 -2
View File
@@ -142,8 +142,8 @@ class AutoZhuyinTextService(TextService):
return False return False
self.engine.handle(SHIFT_TAP) self.engine.handle(SHIFT_TAP)
self._update(None) self._update(None)
if self.engine.english_armed: if not self.engine.keys:
self.showMessage("英文", 1) self.showMessage("英文" if self.engine.english_mode else "中英自動", 1)
return True return True
# --- replies --- # --- replies ---
+15 -38
View File
@@ -34,9 +34,9 @@ class CompositionEngine:
self.now = now self.now = now
self.keys = [] self.keys = []
self.forced_mode = None self.forced_mode = None
# True when forced_mode corrects the classifier (learned on commit); False when the # English mode, toggled by a Shift tap when nothing is being typed: keys go straight
# user forced English before typing (Shift tap on an empty buffer). # to the app (no composition, no underline) until Shift is tapped again.
self._forced_is_correction = False self.english_mode = False
self.fixed = {} # zhuyin segment start -> {(syl_start, syl_end): text} self.fixed = {} # zhuyin segment start -> {(syl_start, syl_end): text}
self.candidates = [] self.candidates = []
self.candidate_index = 0 self.candidate_index = 0
@@ -150,26 +150,16 @@ class CompositionEngine:
# --- key handling --- # --- 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): 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_mode = LITERAL if self.mode == ZHUYIN else ZHUYIN
self._forced_is_correction = True
def wants(self, key): def wants(self, key):
"""Whether handle(key) would consume the key, without changing state.""" """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 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: if key in SPECIAL_KEYS:
return bool(self.keys) return bool(self.keys)
if self.keys: if self.keys:
@@ -190,34 +180,29 @@ class CompositionEngine:
self.keys.pop() self.keys.pop()
self.fixed = {k: v for k, v in self.fixed.items() if k < len(self.keys)} self.fixed = {k: v for k, v in self.fixed.items() if k < len(self.keys)}
if not self.keys: if not self.keys:
# A Shift-tap "next word is English" stays armed; a correction is dropped. self.forced_mode = None
if self._forced_is_correction:
self.forced_mode = None
self._forced_is_correction = False
self.fixed = {} self.fixed = {}
return CONSUMED return CONSUMED
if key == ENTER: if key == ENTER:
if not self.keys: if not self.keys:
self._end_direct_english()
return PASS return PASS
return True, self._commit() return True, self._commit()
if key == ESCAPE: if key == ESCAPE:
if not self.keys: if not self.keys:
self._end_direct_english()
return PASS return PASS
self.reset() self.reset()
return CONSUMED return CONSUMED
if key == TAB: if key == TAB:
if not self.keys: if not self.keys:
self._end_direct_english()
return PASS return PASS
self._flip() self._flip()
return CONSUMED return CONSUMED
if key == SHIFT_TAP: if key == SHIFT_TAP:
if not self.keys: if not self.keys:
# Next word is English, typed as-is. Tap again to cancel. # Toggle English mode; it stays on until the next Shift tap.
self.forced_mode = None if self.forced_mode == LITERAL else LITERAL self.english_mode = not self.english_mode
self._forced_is_correction = False self._previous_mode = LITERAL if self.english_mode else None
self._previous_time = self.now()
else: else:
self._flip() self._flip()
return CONSUMED return CONSUMED
@@ -243,15 +228,8 @@ class CompositionEngine:
def _handle_character(self, c): def _handle_character(self, c):
self.cursor = None # typing always continues at the end self.cursor = None # typing always continues at the end
if self.english_armed: if self.english_mode and not self.keys:
# Forced English: insert directly. Space ends the word; other symbols end it too. return PASS # English mode: every key goes to the app as typed
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 c == " ": if c == " ":
if not self.keys: if not self.keys:
return PASS return PASS
@@ -329,7 +307,7 @@ class CompositionEngine:
def _commit(self, segs=None): def _commit(self, segs=None):
segs = segs if segs is not None else self.segments segs = segs if segs is not None else self.segments
text = "".join(self._render(s, True) for s in segs) 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.classifier.learned.record("".join(self.keys), self.forced_mode)
self._previous_mode = segs[-1][2] if segs else None self._previous_mode = segs[-1][2] if segs else None
self._previous_time = self.now() self._previous_time = self.now()
@@ -343,6 +321,5 @@ class CompositionEngine:
self.keys = [] self.keys = []
self.cursor = None self.cursor = None
self.forced_mode = None self.forced_mode = None
self._forced_is_correction = False
self.fixed = {} self.fixed = {}
self.candidates = [] self.candidates = []
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "自動注音 AutoZhuyin", "name": "自動注音 AutoZhuyin",
"version": "0.5.1", "version": "0.6.0",
"guid": "{3895C6E3-6D40-4B4B-B4EA-CEEC75382D23}", "guid": "{3895C6E3-6D40-4B4B-B4EA-CEEC75382D23}",
"locale": "zh-Hant-TW", "locale": "zh-Hant-TW",
"fallbackLocale": "zh-TW", "fallbackLocale": "zh-TW",
+3 -3
View File
@@ -29,9 +29,9 @@
← → 在組字區移動游標,選要改哪個字 ← → 在組字區移動游標,選要改哪個字
↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字 ↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字
Esc 取消組字 Esc 取消組字
單按 Shift 下一個字強制英文(保持小寫、直接送出、沒有底線), 單按 Shift 切換英文模式(按鍵直接送出、保持小寫、沒有底線),
按空白或 Enter 後恢復自動判斷; 再單按一次回到中英自動判斷,會出現「英文」/「中英自動」小提示;
打到一半時按,同 Tab 整段翻轉。會出現「英文」小提示 打到一半時按,同 Tab 整段翻轉
Shift+字母 打大寫字母(也會強制英文) Shift+字母 打大寫字母(也會強制英文)
< > ? ! : 中文語境下自動變成全形 ,。?!: < > ? ! : 中文語境下自動變成全形 ,。?!:
+15 -31
View File
@@ -194,11 +194,15 @@ class MixedSegmentTests(unittest.TestCase):
class ShiftTapTests(unittest.TestCase): class ShiftTapTests(unittest.TestCase):
def test_forces_next_word_english_lowercase(self): def test_toggles_english_mode(self):
e = make_engine() e = make_engine()
self.assertEqual(type_keys("⇧ru ", e), "ru ") self.assertEqual(type_keys("⇧ru su ", e), "ru su ")
self.assertFalse(e.english_armed) self.assertTrue(e.english_mode)
self.assertEqual(type_keys("su3cl3\n", e), "你好") 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): def test_tap_twice_cancels(self):
self.assertEqual(type_keys("⇧⇧su3cl3\n", make_engine()), "你好") self.assertEqual(type_keys("⇧⇧su3cl3\n", make_engine()), "你好")
@@ -208,20 +212,20 @@ class ShiftTapTests(unittest.TestCase):
type_keys("so", e) type_keys("so", e)
e.handle(SHIFT_TAP) e.handle(SHIFT_TAP)
self.assertEqual(e.mode, ZHUYIN) self.assertEqual(e.mode, ZHUYIN)
self.assertFalse(e.english_mode)
type_keys("\n", e) type_keys("\n", e)
self.assertEqual(e.classifier.learned.weights["so"], 1) 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() e = make_engine()
type_keys("⇧hello ", e) 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() e = make_engine()
type_keys("⇧r", e) e.handle(SHIFT_TAP)
e.handle(BACKSPACE) self.assertEqual(e.handle(BACKSPACE), (False, None))
self.assertTrue(e.english_armed) self.assertTrue(e.english_mode)
self.assertEqual(type_keys("ru ", e), "ru ")
def test_detector(self): def test_detector(self):
d = ShiftTapDetector() d = ShiftTapDetector()
@@ -267,25 +271,5 @@ class CursorTests(unittest.TestCase):
self.assertTrue(e.showing_candidates) 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__": if __name__ == "__main__":
unittest.main() unittest.main()
+3 -2
View File
@@ -144,14 +144,15 @@ class ShiftTapWrapperTests(unittest.TestCase):
def test_tap_forces_english_lowercase(self): def test_tap_forces_english_lowercase(self):
reply = tap_shift(self.svc) reply = tap_shift(self.svc)
self.assertEqual(reply.get("showMessage"), "英文") 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): def test_shift_with_letter_is_not_a_tap(self):
self.svc.filterKeyDown(FakeKeyEvent("⇧", shift=True)) self.svc.filterKeyDown(FakeKeyEvent("⇧", shift=True))
press(self.svc, "H", shift=True) press(self.svc, "H", shift=True)
up = FakeKeyEvent("⇧") up = FakeKeyEvent("⇧")
self.assertFalse(self.svc.filterKeyUp(up)) self.assertFalse(self.svc.filterKeyUp(up))
self.assertFalse(self.svc.engine.english_armed) self.assertFalse(self.svc.engine.english_mode)
if __name__ == "__main__": if __name__ == "__main__":