Add a composition cursor so candidates can be chosen for any character
Left/Right move a cursor between Zhuyin syllables in the composition; Down opens candidates for the phrase ending at the cursor instead of always the last syllable. Typing or backspace returns the cursor to the end. Candidates also work for Chinese that is followed by English in the same buffer. The Mac caret and PIME composition cursor follow it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -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 + 字母 | 打大寫字母(也會強制英文) |
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -45,6 +45,9 @@ public final class CompositionEngine {
|
||||
private var fixed: [Int: [Range<Int>: 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
|
||||
}
|
||||
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 ?? "")
|
||||
|
||||
/// 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)) }
|
||||
}
|
||||
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[..<stop.segIndex].reduce(0) { $0 + $1.text.count }
|
||||
let segs = segments
|
||||
for conv in conversion(of: segs[stop.segIndex], final: stop.segIndex < segs.count - 1).segments {
|
||||
if conv.range.upperBound <= stop.local {
|
||||
offset += conv.text.count
|
||||
} else if conv.range.lowerBound < stop.local {
|
||||
offset += min(stop.local - conv.range.lowerBound, conv.text.count)
|
||||
}
|
||||
}
|
||||
return offset
|
||||
}
|
||||
|
||||
private func moveCursor(by delta: Int) {
|
||||
let stops = cursorStops
|
||||
guard !stops.isEmpty else { return }
|
||||
let next = (cursor ?? stops.count - 1) + delta
|
||||
cursor = next >= 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 = [:]
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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 = {}
|
||||
|
||||
@@ -26,7 +26,8 @@
|
||||
空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白
|
||||
Enter 送出目前組字
|
||||
Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正
|
||||
↓ 開啟候選字,按數字鍵 1–9 選字
|
||||
← → 在組字區移動游標,選要改哪個字
|
||||
↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字
|
||||
Esc 取消組字
|
||||
單按 Shift 下一個字強制英文(保持小寫),送出後恢復自動判斷;
|
||||
打到一半時按,同 Tab 整段翻轉。會出現「英文」小提示
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user