Compare commits

..
4 Commits
Author SHA1 Message Date
ays953 fcc0f9d2db Release v0.8.0 2026-11-13 09:56:18 +08:00
ays953andClaude Opus 5.5 31d9991e16 Insert and delete syllables at the composition cursor
The ← → cursor is now an editing position (key index), not just a candidate
stop. It can move to the start; typing Zhuyin there composes a syllable at the
cursor and splices it in on its tone key; Backspace removes the character before
the cursor. Picked phrases before the edit point are kept.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 09:56:06 +08:00
ays953 6b4ec39dc1 Release v0.7.1 2026-11-11 17:01:37 +08:00
ays953andClaude Opus 5.5 955b0ca5c3 Ship third-party notices with both installers
THIRD_PARTY_LICENSES.txt carries McBopomofo's full MIT notice (required when the
converted lexicon is distributed) plus notes on the public-domain word list and
PIME. It goes into AutoZhuyin.app/Contents/Resources and the Windows zip.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 17:01:26 +08:00
11 changed files with 512 additions and 87 deletions
+5 -1
View File
@@ -16,6 +16,7 @@
- **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小) - **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小)
- **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」 - **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」
- **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來 - **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來
- **中間補字、刪字**:游標移到前面後直接打注音,會插在游標處;Backspace 刪掉游標前的那個字
- **全形標點**:中文語境下 `?` `!` `<` 自動變成 `?` `!` `,`;任何時候按 `` ` `` 再按標點鍵,一定得到全形標點(例如 `` `< `` = `,`) - **全形標點**:中文語境下 `?` `!` `<` 自動變成 `?` `!` `,`;任何時候按 `` ` `` 再按標點鍵,一定得到全形標點(例如 `` `< `` = `,`)
- **完整詞庫**:約 17 萬筆,來自小麥注音 McBopomofo(MIT 授權) - **完整詞庫**:約 17 萬筆,來自小麥注音 McBopomofo(MIT 授權)
@@ -51,7 +52,7 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安
| 空白 | 注音:一聲;音節已完成時送出中文。英文:送出單字加空白 | | 空白 | 注音:一聲;音節已完成時送出中文。英文:送出單字加空白 |
| Enter | 送出目前組字 | | Enter | 送出目前組字 |
| **Tab** | 判斷錯了?按 Tab 把整段翻轉成另一種語言,輸入法會**記住**這次修正 | | **Tab** | 判斷錯了?按 Tab 把整段翻轉成另一種語言,輸入法會**記住**這次修正 |
| ← → | 在組字區移動游標,選要改哪個字 | | ← → | 在組字區移動游標(可移到最前面)。游標在中間時:直接打注音會**插入**新字,Backspace 刪掉游標前的字,↓ 選游標前的字 |
| ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 | | ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 |
| Esc | 取消組字 | | Esc | 取消組字 |
| **單按 Shift** | 沒在打字時:切換**英文模式**,按鍵直接送出、保持小寫、沒有底線,一直維持到再單按一次 Shift 才回到中英自動判斷。打到一半時:同 Tab,整段翻轉 | | **單按 Shift** | 沒在打字時:切換**英文模式**,按鍵直接送出、保持小寫、沒有底線,一直維持到再單按一次 Shift 才回到中英自動判斷。打到一半時:同 Tab,整段翻轉 |
@@ -212,6 +213,7 @@ windows/
tests/ Python 測試 tests/ Python 測試
tools/ 產生資料檔、圖示 tools/ 產生資料檔、圖示
training/ 合成資料、訓練權重、Swift/Python 一致性測試資料 training/ 合成資料、訓練權重、Swift/Python 一致性測試資料
THIRD_PARTY_LICENSES.txt 第三方授權聲明(會打包進兩個安裝檔)
``` ```
## 已知限制 ## 已知限制
@@ -238,3 +240,5 @@ training/ 合成資料、訓練權重、Swift/Python 一致
- 詞庫資料:[小麥注音 McBopomofo](https://github.com/openvanilla/McBopomofo)(MIT License) - 詞庫資料:[小麥注音 McBopomofo](https://github.com/openvanilla/McBopomofo)(MIT License)
- Windows 輸入法框架:[PIME](https://github.com/EasyIME/PIME)(LGPL 2.1,使用者自行安裝,本專案不包含其程式碼) - Windows 輸入法框架:[PIME](https://github.com/EasyIME/PIME)(LGPL 2.1,使用者自行安裝,本專案不包含其程式碼)
- 英文字典:Webster's Second International Dictionary(公有領域,macOS 的 `/usr/share/dict/words`) - 英文字典: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` 資料夾。
+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.7.0</string> <string>0.8.0</string>
<key>CFBundleVersion</key> <key>CFBundleVersion</key>
<string>12</string> <string>14</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>
+175 -33
View File
@@ -45,9 +45,11 @@ public final class CompositionEngine {
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] = []
private var candidateSegmentStart = 0 private var candidateSegmentStart = 0
/// Composition cursor for choosing candidates: index into `cursorStops`, nil = at the end. /// Composition cursor: a key index into `keys` (nil = at the end). ← → move it between
/// ← → move it; ↓ shows candidates for the phrase ending at the cursor. /// 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 cursor: Int?
private var inserting: [Character] = []
public var candidateIndex = 0 public var candidateIndex = 0
public var isShowingCandidates: Bool { !candidates.isEmpty } public var isShowingCandidates: Bool { !candidates.isEmpty }
@@ -117,14 +119,35 @@ public final class CompositionEngine {
public var markedText: String { markedPieces.map(\.text).joined() } public var markedText: String { markedPieces.map(\.text).joined() }
public var markedPieces: [MarkedPiece] { public var markedPieces: [MarkedPiece] {
let segs = segments var pieces = segmentPieces
var pieces = segs.enumerated().map { i, seg in if !inserting.isEmpty {
MarkedPiece(text: render(seg, final: i < segs.count - 1), mode: seg.mode) // 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)) } if pendingBacktick { pieces.append(MarkedPiece(text: "`", mode: .literal)) }
return pieces 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. /// Text for one segment. A non-final Zhuyin segment shows its unfinished syllable as Bopomofo.
private func render(_ seg: Segment, final: Bool) -> String { private func render(_ seg: Segment, final: Bool) -> String {
guard seg.mode == .zhuyin else { return String(keys[seg.range]) } guard seg.mode == .zhuyin else { return String(keys[seg.range]) }
@@ -148,43 +171,151 @@ public final class CompositionEngine {
// MARK: - Cursor // 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 struct CursorStop { let segIndex: Int; let local: Int }
private var cursorStops: [CursorStop] { private func stop(at pos: Int) -> CursorStop? {
let segs = segments 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 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
} }
/// Cursor position in `markedText`, in Characters. /// Where ↓ opens candidates: before the cursor, or the last syllable.
public var cursorOffset: Int { private var candidateStop: CursorStop? {
let pieces = markedPieces if let c = cursor { return stop(at: c) }
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 let segs = segments
for conv in conversion(of: segs[stop.segIndex], final: stop.segIndex < segs.count - 1).segments { for i in segs.indices.reversed() where segs[i].mode == .zhuyin {
if conv.range.upperBound <= stop.local { 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 offset += conv.text.count
} else if conv.range.lowerBound < stop.local { } else if conv.range.lowerBound < local {
offset += min(stop.local - conv.range.lowerBound, conv.text.count) offset += min(local - conv.range.lowerBound, conv.text.count)
} }
} }
return offset return offset
} }
return 0
}
/// Cursor position in `markedText`, in Characters.
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) { private func moveCursor(by delta: Int) {
let stops = cursorStops inserting = []
guard !stops.isEmpty else { return } let stops = cursorPositions
let next = (cursor ?? stops.count - 1) + delta let here = cursor ?? keys.count
cursor = next >= stops.count - 1 ? nil : max(0, next) 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 // MARK: - Key handling
@@ -192,13 +323,20 @@ public final class CompositionEngine {
public func handle(_ key: KeyInput) -> KeyResult { public func handle(_ key: KeyInput) -> KeyResult {
if isShowingCandidates { return handleCandidateKey(key) } if isShowingCandidates { return handleCandidateKey(key) }
if pendingBacktick { return afterBacktick(key) } if pendingBacktick { return afterBacktick(key) }
if !inserting.isEmpty && (key == .backspace || key == .escape) {
if key == .backspace { inserting.removeLast() } else { inserting = [] }
return .consumed
}
switch key { switch key {
case .character(let c): case .character(let c):
return handleCharacter(c) return handleCharacter(c)
case .backspace: case .backspace:
guard !keys.isEmpty else { return .passThrough } guard !keys.isEmpty else { return .passThrough }
cursor = nil if let c = cursor {
if c > 0 { deleteBeforeCursor(c) }
return .consumed
}
keys.removeLast() keys.removeLast()
if let h = held, keys.count <= h { held = nil } if let h = held, keys.count <= h { held = nil }
fixed = fixed.filter { $0.key < keys.count } fixed = fixed.filter { $0.key < keys.count }
@@ -206,6 +344,7 @@ public final class CompositionEngine {
return .consumed return .consumed
case .enter: case .enter:
guard !keys.isEmpty else { return .passThrough } guard !keys.isEmpty else { return .passThrough }
if !inserting.isEmpty { splice(inserting); inserting = [] }
return KeyResult(handled: true, commit: commitCurrent()) return KeyResult(handled: true, commit: commitCurrent())
case .escape: case .escape:
guard !keys.isEmpty else { return .passThrough } guard !keys.isEmpty else { return .passThrough }
@@ -227,7 +366,7 @@ public final class CompositionEngine {
return .consumed return .consumed
case .down: case .down:
guard !keys.isEmpty else { return .passThrough } guard !keys.isEmpty else { return .passThrough }
openCandidates() if inserting.isEmpty { openCandidates() }
return .consumed return .consumed
case .left: case .left:
guard !keys.isEmpty else { return .passThrough } guard !keys.isEmpty else { return .passThrough }
@@ -248,7 +387,11 @@ public final class CompositionEngine {
} }
private func handleCharacter(_ c: Character) -> KeyResult { 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. // English mode: every key goes to the app as typed.
if isEnglishMode && keys.isEmpty { return .passThrough } if isEnglishMode && keys.isEmpty { return .passThrough }
if c == "`" { if c == "`" {
@@ -329,9 +472,7 @@ public final class CompositionEngine {
/// Opens candidates for the phrase ending at the cursor (default: the last syllable). /// Opens candidates for the phrase ending at the cursor (default: the last syllable).
private func openCandidates() { private func openCandidates() {
let stops = cursorStops guard let stop = candidateStop else { return }
guard !stops.isEmpty else { return }
let stop = stops[min(cursor ?? stops.count - 1, stops.count - 1)]
let segs = segments let segs = segments
let seg = segs[stop.segIndex] let seg = segs[stop.segIndex]
let syl = convertibleSyllables(seg, final: stop.segIndex < segs.count - 1).syllables let syl = convertibleSyllables(seg, final: stop.segIndex < segs.count - 1).syllables
@@ -392,6 +533,7 @@ public final class CompositionEngine {
public func reset() { public func reset() {
keys = [] keys = []
inserting = []
held = nil held = nil
pendingBacktick = false pendingBacktick = false
cursor = nil cursor = nil
+50
View File
@@ -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 { func type(_ s: String, into e: CompositionEngine) -> String {
var out = "" var out = ""
for c in s { 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) let r = e.handle(key)
if let t = r.commit { out += t } else if !r.handled { out.append(c) } 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) _ = type("←", into: e)
XCTAssertEqual(e.cursorOffset, 3) XCTAssertEqual(e.cursorOffset, 3)
_ = type("←←←←", into: e) _ = type("←←←←", into: e)
XCTAssertEqual(e.cursorOffset, 1) // stops after the first character XCTAssertEqual(e.cursorOffset, 0) // stops at the start
_ = type("→→→→", into: e) _ = type("→→→→", into: e)
XCTAssertEqual(e.cursorOffset, 4) XCTAssertEqual(e.cursorOffset, 4)
} }
@@ -399,12 +400,48 @@ final class CursorTests: XCTestCase {
XCTAssertEqual(type("\n", into: e), "今添天氣") XCTAssertEqual(type("\n", into: e), "今添天氣")
} }
func testTypingReturnsCursorToEnd() { func testPunctuationCommitsFromTheMiddle() {
let e = engine() let e = engine()
_ = type("rup wu0 ←", into: e) _ = type("rup wu0 ←", into: e)
XCTAssertEqual(e.cursorOffset, 1) XCTAssertEqual(e.cursorOffset, 1)
_ = type("wu0 ", into: e) _ = type("?", into: e)
XCTAssertEqual(e.cursorOffset, e.markedText.count) 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() { func testCandidatesForChineseBeforeEnglish() {
+1
View File
@@ -19,6 +19,7 @@ mkdir -p "$APP/Contents/MacOS" "$APP/Contents/Resources"
cp "$BIN" "$APP/Contents/MacOS/AutoZhuyin" cp "$BIN" "$APP/Contents/MacOS/AutoZhuyin"
cp Resources/Info.plist "$APP/Contents/Info.plist" cp Resources/Info.plist "$APP/Contents/Info.plist"
cp Resources/lexicon.txt Resources/english-common.txt Resources/classifier-weights.json "$APP/Contents/Resources/" 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). # Precomputed English dictionary and bigram table (shared with the Windows build).
python3 -I windows/tools/build_data.py >/dev/null 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/" cp windows/autozhuyin/data/english-dict.txt windows/autozhuyin/data/english-bigram.json "$APP/Contents/Resources/"
+3
View File
@@ -26,6 +26,9 @@ rsync -a --exclude __pycache__ --exclude '*.pyc' windows/autozhuyin "$OUT/"
for f in install.bat uninstall.bat README.txt; do for f in install.bat uninstall.bat README.txt; do
sed 's/$/\r/' "windows/installer/$f" > "$OUT/$f" sed 's/$/\r/' "windows/installer/$f" > "$OUT/$f"
done 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") (cd build && zip -qr -X "$NAME.zip" "$NAME")
echo "Built build/$NAME.zip" echo "Built build/$NAME.zip"
+187 -33
View File
@@ -55,8 +55,11 @@ class CompositionEngine:
self.candidates = [] self.candidates = []
self.candidate_index = 0 self.candidate_index = 0
self._candidate_segment_start = 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.cursor = None
self.inserting = []
# Index of a held space (see HOLD_MIN_SCORE), or None. # Index of a held space (see HOLD_MIN_SCORE), or None.
self.held = None self.held = None
self._previous_mode = None self._previous_mode = None
@@ -144,48 +147,180 @@ class CompositionEngine:
# --- cursor --- # --- cursor ---
def _cursor_stops(self): def _syllable_ends(self, seg):
"""[(segment index, syllables before the stop)] for every Zhuyin syllable.""" """Absolute key index after each syllable of a Zhuyin segment."""
segs = self.segments return [seg[0] + ps.end for ps in bopomofo.parse(self.keys[seg[0]:seg[1]]).syllables]
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_positions(self):
def cursor_offset(self): """Key indices the cursor can stop at: the start, after every Zhuyin syllable,
"""Cursor position in marked_text (characters).""" and at every segment boundary."""
pieces = self.marked_pieces out = {0, len(self.keys)}
stops = self._cursor_stops() for seg in self.segments:
if self.cursor is None or not 0 <= self.cursor < len(stops): out.add(seg[1])
return sum(len(t) for t, _ in pieces) if seg[2] == ZHUYIN:
seg_index, local = stops[self.cursor] out.update(self._syllable_ends(seg))
offset = sum(len(t) for t, _ in pieces[:seg_index]) return sorted(out)
def _stop_at(self, pos):
"""(segment index, syllables before pos) for the Zhuyin segment pos is in."""
segs = self.segments segs = self.segments
for (a, b), text in self._conversion(segs[seg_index], seg_index < len(segs) - 1)[0]: 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])
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: if b <= local:
offset += len(text) offset += len(text)
elif a < local: elif a < local:
offset += min(local - a, len(text)) offset += min(local - a, len(text))
return offset return offset
return 0
@property
def cursor_offset(self):
"""Cursor position in marked_text (characters)."""
return self._base_cursor_offset() + len(self._inserting_text())
def _move_cursor(self, delta): def _move_cursor(self, delta):
stops = self._cursor_stops() self.inserting = []
if not stops: stops = self._cursor_positions()
return here = len(self.keys) if self.cursor is None else self.cursor
nxt = (len(stops) - 1 if self.cursor is None else self.cursor) + delta if delta < 0:
self.cursor = None if nxt >= len(stops) - 1 else max(0, nxt) 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 @property
def marked_pieces(self): def marked_pieces(self):
segs = self.segments pieces = self._segment_pieces()
pieces = [(self._render(s, i < len(segs) - 1), s[2]) for i, s in enumerate(segs)] 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: if self.backtick:
pieces.append((BACKTICK, LITERAL)) pieces.append((BACKTICK, LITERAL))
return pieces 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 @property
def marked_text(self): def marked_text(self):
return "".join(t for t, _ in self.marked_pieces) return "".join(t for t, _ in self.marked_pieces)
@@ -198,7 +333,7 @@ class CompositionEngine:
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.backtick: if self.candidates or key == SHIFT_TAP or self.backtick or self.inserting:
return True return True
if self.english_mode and not self.keys: if self.english_mode and not self.keys:
return False # English mode: everything goes to the app as typed return False # English mode: everything goes to the app as typed
@@ -217,10 +352,19 @@ class CompositionEngine:
return self._handle_candidate_key(key) return self._handle_candidate_key(key)
if self.backtick: if self.backtick:
return self._after_backtick(key) 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 key == BACKSPACE:
if not self.keys: if not self.keys:
return PASS return PASS
self.cursor = None if self.cursor is not None:
if self.cursor > 0:
self._delete_before_cursor()
return CONSUMED
self.keys.pop() self.keys.pop()
if self.held is not None and len(self.keys) <= self.held: if self.held is not None and len(self.keys) <= self.held:
self.held = None self.held = None
@@ -232,6 +376,9 @@ class CompositionEngine:
if key == ENTER: if key == ENTER:
if not self.keys: if not self.keys:
return PASS return PASS
if self.inserting:
self._splice(self.inserting)
self.inserting = []
return True, self._commit() return True, self._commit()
if key == ESCAPE: if key == ESCAPE:
if not self.keys: if not self.keys:
@@ -255,6 +402,7 @@ class CompositionEngine:
if key == DOWN: if key == DOWN:
if not self.keys: if not self.keys:
return PASS return PASS
if not self.inserting:
self._open_candidates() self._open_candidates()
return CONSUMED return CONSUMED
if key in (LEFT, RIGHT): if key in (LEFT, RIGHT):
@@ -286,7 +434,12 @@ class CompositionEngine:
return bopomofo.parse(self.keys[start:end]) return bopomofo.parse(self.keys[start:end])
def _handle_character(self, c): 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: if self.english_mode and not self.keys:
return PASS # English mode: every key goes to the app as typed return PASS # English mode: every key goes to the app as typed
if c == BACKTICK: if c == BACKTICK:
@@ -330,10 +483,10 @@ class CompositionEngine:
def _open_candidates(self): def _open_candidates(self):
"""Candidates for the phrase ending at the cursor (default: the last syllable).""" """Candidates for the phrase ending at the cursor (default: the last syllable)."""
stops = self._cursor_stops() stop = self._candidate_stop()
if not stops: if stop is None:
return 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 segs = self.segments
seg = segs[seg_index] seg = segs[seg_index]
syl = self._convertible(seg, seg_index < len(segs) - 1)[0] syl = self._convertible(seg, seg_index < len(segs) - 1)[0]
@@ -386,6 +539,7 @@ class CompositionEngine:
def reset(self): def reset(self):
self.keys = [] self.keys = []
self.inserting = []
self.held = None self.held = None
self.backtick = False self.backtick = False
self.cursor = None self.cursor = None
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "自動注音 AutoZhuyin", "name": "自動注音 AutoZhuyin",
"version": "0.7.0", "version": "0.8.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",
+2 -1
View File
@@ -26,7 +26,8 @@
空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白 空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白
Enter 送出目前組字 Enter 送出目前組字
Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正 Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正
← → 在組字區移動游標,選要改哪個字 ← → 在組字區移動游標,選要改哪個字;游標在中間時直接打注音
會插入新字,Backspace 刪掉游標前的字
↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字 ↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字
Esc 取消組字 Esc 取消組字
單按 Shift 切換英文模式(按鍵直接送出、保持小寫、沒有底線), 單按 Shift 切換英文模式(按鍵直接送出、保持小寫、沒有底線),
+38 -5
View File
@@ -42,7 +42,7 @@ def make_engine():
def type_keys(s, e): def type_keys(s, e):
out = "" out = ""
for c in s: 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) handled, commit = e.handle(key)
if commit is not None: if commit is not None:
out += commit out += commit
@@ -246,7 +246,7 @@ class CursorTests(unittest.TestCase):
type_keys("←", e) type_keys("←", e)
self.assertEqual(e.cursor_offset, 3) self.assertEqual(e.cursor_offset, 3)
type_keys("←←←←", e) type_keys("←←←←", e)
self.assertEqual(e.cursor_offset, 1) self.assertEqual(e.cursor_offset, 0)
type_keys("→→→→", e) type_keys("→→→→", e)
self.assertEqual(e.cursor_offset, 4) self.assertEqual(e.cursor_offset, 4)
@@ -258,12 +258,45 @@ class CursorTests(unittest.TestCase):
e.select_candidate([t for _, t in e.candidates].index("添")) e.select_candidate([t for _, t in e.candidates].index("添"))
self.assertEqual(type_keys("\n", e), "今添天氣") 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() e = make_engine()
type_keys("rup wu0 ←", e) type_keys("rup wu0 ←", e)
self.assertEqual(e.cursor_offset, 1) self.assertEqual(e.cursor_offset, 1)
type_keys("wu0 ", e) type_keys("?", e)
self.assertEqual(e.cursor_offset, len(e.marked_text)) 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): def test_candidates_for_chinese_before_english(self):
e = make_engine() e = make_engine()