Compare commits
4
Commits
v0.7.0
...
fcc0f9d2db
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
fcc0f9d2db | ||
|
|
31d9991e16 | ||
|
|
6b4ec39dc1 | ||
|
|
955b0ca5c3 |
@@ -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,整段翻轉 |
|
||||
@@ -212,6 +213,7 @@ windows/
|
||||
tests/ Python 測試
|
||||
tools/ 產生資料檔、圖示
|
||||
training/ 合成資料、訓練權重、Swift/Python 一致性測試資料
|
||||
THIRD_PARTY_LICENSES.txt 第三方授權聲明(會打包進兩個安裝檔)
|
||||
```
|
||||
|
||||
## 已知限制
|
||||
@@ -238,3 +240,5 @@ training/ 合成資料、訓練權重、Swift/Python 一致
|
||||
- 詞庫資料:[小麥注音 McBopomofo](https://github.com/openvanilla/McBopomofo)(MIT License)
|
||||
- Windows 輸入法框架:[PIME](https://github.com/EasyIME/PIME)(LGPL 2.1,使用者自行安裝,本專案不包含其程式碼)
|
||||
- 英文字典:Webster's Second International Dictionary(公有領域,macOS 的 `/usr/share/dict/words`)
|
||||
|
||||
完整的第三方授權聲明(含小麥注音 MIT 授權全文)見 [THIRD_PARTY_LICENSES.txt](THIRD_PARTY_LICENSES.txt),Mac 版放在 `AutoZhuyin.app/Contents/Resources/`,Windows 版放在 zip 根目錄和安裝後的 `autozhuyin` 資料夾。
|
||||
|
||||
@@ -15,9 +15,9 @@
|
||||
<key>CFBundlePackageType</key>
|
||||
<string>APPL</string>
|
||||
<key>CFBundleShortVersionString</key>
|
||||
<string>0.7.0</string>
|
||||
<string>0.8.0</string>
|
||||
<key>CFBundleVersion</key>
|
||||
<string>12</string>
|
||||
<string>14</string>
|
||||
<key>InputMethodConnectionName</key>
|
||||
<string>com.autozhuyin.inputmethod.AutoZhuyin_Connection</string>
|
||||
<key>InputMethodServerControllerClass</key>
|
||||
|
||||
@@ -45,9 +45,11 @@ 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.
|
||||
/// 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[..<i]), mode: piece.mode))
|
||||
out.append(MarkedPiece(text: insertingText, mode: .zhuyin))
|
||||
out.append(MarkedPiece(text: String(piece.text[i...]), mode: piece.mode))
|
||||
done = true
|
||||
} else {
|
||||
out.append(piece)
|
||||
at -= piece.text.count
|
||||
}
|
||||
}
|
||||
pieces = out.filter { !$0.text.isEmpty }
|
||||
}
|
||||
if pendingBacktick { pieces.append(MarkedPiece(text: "`", mode: .literal)) }
|
||||
return pieces
|
||||
}
|
||||
|
||||
private var segmentPieces: [MarkedPiece] {
|
||||
let segs = segments
|
||||
return segs.enumerated().map { i, seg in
|
||||
MarkedPiece(text: render(seg, final: i < segs.count - 1), mode: seg.mode)
|
||||
}
|
||||
}
|
||||
|
||||
/// Text for one segment. A non-final Zhuyin segment shows its unfinished syllable as Bopomofo.
|
||||
private func render(_ seg: Segment, final: Bool) -> 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<Int> = [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[..<i].reduce(0) { $0 + $1.text.count }
|
||||
if seg.mode == .literal { return offset + c - seg.range.lowerBound }
|
||||
let local = stop(at: c)?.local ?? 0
|
||||
for conv in conversion(of: seg, final: i < segs.count - 1).segments {
|
||||
if conv.range.upperBound <= local {
|
||||
offset += conv.text.count
|
||||
} else if conv.range.lowerBound < local {
|
||||
offset += min(local - conv.range.lowerBound, conv.text.count)
|
||||
}
|
||||
}
|
||||
return offset
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
/// 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
|
||||
public var cursorOffset: Int { baseCursorOffset + insertingText.count }
|
||||
|
||||
private var insertingText: String {
|
||||
inserting.isEmpty ? "" : ZhuyinParser.parse(inserting).syllables.map(\.syllable.reading).joined()
|
||||
}
|
||||
|
||||
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)
|
||||
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<Int>: 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..<pos)
|
||||
if let h = held {
|
||||
if h >= 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[..<first]))
|
||||
inserting = Array(inserting[first...])
|
||||
}
|
||||
return .consumed
|
||||
}
|
||||
|
||||
// MARK: - Key handling
|
||||
@@ -192,13 +323,20 @@ public final class CompositionEngine {
|
||||
public func handle(_ key: KeyInput) -> 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
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
自動注音 AutoZhuyin — 第三方授權聲明 / Third-party notices
|
||||
==========================================================
|
||||
|
||||
本軟體包含或使用下列第三方資料。
|
||||
This software includes or uses the following third-party material.
|
||||
|
||||
|
||||
1. 小麥注音 McBopomofo — 詞庫資料 (lexicon data)
|
||||
------------------------------------------------
|
||||
https://github.com/openvanilla/McBopomofo
|
||||
|
||||
lexicon.txt is converted from McBopomofo's data files (BPMFBase.txt,
|
||||
BPMFMappings.txt, phrase.occ) by scripts/convert-mcbopomofo.py. No McBopomofo
|
||||
program code is included.
|
||||
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2011-2026 Mengjuei Hsieh et al.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
|
||||
2. Webster's Second International Dictionary — 英文字典 (English word list)
|
||||
--------------------------------------------------------------------------
|
||||
english-dict.txt is filtered from /usr/share/dict/words (Webster's Second
|
||||
International Dictionary, 1934), which is in the public domain.
|
||||
|
||||
|
||||
3. PIME — Windows 輸入法框架 (input method framework)
|
||||
----------------------------------------------------
|
||||
https://github.com/EasyIME/PIME — GNU LGPL 2.1
|
||||
|
||||
The Windows version runs as a module inside PIME, which users install
|
||||
separately. No PIME code is included in this software.
|
||||
@@ -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() {
|
||||
|
||||
@@ -19,6 +19,7 @@ mkdir -p "$APP/Contents/MacOS" "$APP/Contents/Resources"
|
||||
cp "$BIN" "$APP/Contents/MacOS/AutoZhuyin"
|
||||
cp Resources/Info.plist "$APP/Contents/Info.plist"
|
||||
cp Resources/lexicon.txt Resources/english-common.txt Resources/classifier-weights.json "$APP/Contents/Resources/"
|
||||
cp THIRD_PARTY_LICENSES.txt "$APP/Contents/Resources/"
|
||||
# Precomputed English dictionary and bigram table (shared with the Windows build).
|
||||
python3 -I windows/tools/build_data.py >/dev/null
|
||||
cp windows/autozhuyin/data/english-dict.txt windows/autozhuyin/data/english-bigram.json "$APP/Contents/Resources/"
|
||||
|
||||
@@ -26,6 +26,9 @@ rsync -a --exclude __pycache__ --exclude '*.pyc' windows/autozhuyin "$OUT/"
|
||||
for f in install.bat uninstall.bat README.txt; do
|
||||
sed 's/$/\r/' "windows/installer/$f" > "$OUT/$f"
|
||||
done
|
||||
# Third-party notices: next to the installer and inside the installed folder.
|
||||
sed 's/$/\r/' THIRD_PARTY_LICENSES.txt > "$OUT/THIRD_PARTY_LICENSES.txt"
|
||||
cp "$OUT/THIRD_PARTY_LICENSES.txt" "$OUT/autozhuyin/"
|
||||
|
||||
(cd build && zip -qr -X "$NAME.zip" "$NAME")
|
||||
echo "Built build/$NAME.zip"
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "自動注音 AutoZhuyin",
|
||||
"version": "0.7.0",
|
||||
"version": "0.8.0",
|
||||
"guid": "{3895C6E3-6D40-4B4B-B4EA-CEEC75382D23}",
|
||||
"locale": "zh-Hant-TW",
|
||||
"fallbackLocale": "zh-TW",
|
||||
|
||||
@@ -26,7 +26,8 @@
|
||||
空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白
|
||||
Enter 送出目前組字
|
||||
Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正
|
||||
← → 在組字區移動游標,選要改哪個字
|
||||
← → 在組字區移動游標,選要改哪個字;游標在中間時直接打注音
|
||||
會插入新字,Backspace 刪掉游標前的字
|
||||
↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字
|
||||
Esc 取消組字
|
||||
單按 Shift 切換英文模式(按鍵直接送出、保持小寫、沒有底線),
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user