Compare commits

..
4 Commits
Author SHA1 Message Date
ays953 9cac3467a0 Release v0.9.0 2026-11-13 11:59:53 +08:00
ays953andClaude Opus 5.5 49e0b52fd5 Add a Linux version (IBus) for Bazzite / SteamOS desktop mode
linux/autozhuyin_ibus.py is an IBus engine on top of the shared Python core:
preedit with the cursor and blue English segments, lookup table, Shift tap for
English mode, candidate clicks. install.sh puts everything in the home folder
(works on read-only systems) and an autostart entry registers the engine with
ibus-daemon and selects it. Tested with a stand-in IBus module.

Also fixes Windows: wants() did not claim the backtick, so backtick + punctuation
never reached the engine under PIME.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 11:59:40 +08:00
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
16 changed files with 1150 additions and 98 deletions
+39 -9
View File
@@ -1,6 +1,6 @@
# 自動注音 AutoZhuyin # 自動注音 AutoZhuyin
給繁體中文使用者的輸入法(macOS、Windows):**不用按切換鍵**,直接用大千注音鍵盤打字,輸入法會自動判斷你打的是注音還是英文。 給繁體中文使用者的輸入法(macOS、Windows、Linux):**不用按切換鍵**,直接用大千注音鍵盤打字,輸入法會自動判斷你打的是注音還是英文。
``` ```
按鍵: ji3 hello world su3cl3␣ 按鍵: ji3 hello world su3cl3␣
@@ -16,6 +16,7 @@
- **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小) - **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小)
- **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」 - **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」
- **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來 - **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來
- **中間補字、刪字**:游標移到前面後直接打注音,會插在游標處;Backspace 刪掉游標前的那個字
- **全形標點**:中文語境下 `?` `!` `<` 自動變成 `?` `!` `,`;任何時候按 `` ` `` 再按標點鍵,一定得到全形標點(例如 `` `< `` = `,`) - **全形標點**:中文語境下 `?` `!` `<` 自動變成 `?` `!` `,`;任何時候按 `` ` `` 再按標點鍵,一定得到全形標點(例如 `` `< `` = `,`)
- **完整詞庫**:約 17 萬筆,來自小麥注音 McBopomofo(MIT 授權) - **完整詞庫**:約 17 萬筆,來自小麥注音 McBopomofo(MIT 授權)
@@ -44,6 +45,16 @@ PKG 會裝到 `/Library/Input Methods/`,系統上所有使用者都能用。
SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安裝:以系統管理員身分執行 `uninstall.bat`。 SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安裝:以系統管理員身分執行 `uninstall.bat`。
### Linux(Bazzite、SteamOS 桌面模式、Fedora…)
需求:系統內建 IBus 輸入法框架(Bazzite、Fedora 預設就有)。只在桌面模式可用,Steam 遊戲模式不支援系統輸入法。
1. 解壓縮 `AutoZhuyin-Linux-<版本>.tar.gz`,在終端機進到資料夾執行 `./install.sh`。不需要 sudo,只會裝在家目錄(`~/.local/share/autozhuyin`),所以唯讀系統也能用。
2. KDE(Bazzite / SteamOS 預設):系統設定 → 鍵盤 → 虛擬鍵盤,選 **IBus Wayland** → 套用,登出再登入。GNOME 不用設定。
3. 之後每次登入會自動切換到自動注音(`~/.config/autostart/autozhuyin.desktop`)。
暫時改回一般鍵盤:`ibus engine xkb:us::eng`;切回:`ibus engine autozhuyin`;移除:`./uninstall.sh`。
## 按鍵 ## 按鍵
| 按鍵 | 作用 | | 按鍵 | 作用 |
@@ -51,7 +62,7 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安
| 空白 | 注音:一聲;音節已完成時送出中文。英文:送出單字加空白 | | 空白 | 注音:一聲;音節已完成時送出中文。英文:送出單字加空白 |
| Enter | 送出目前組字 | | Enter | 送出目前組字 |
| **Tab** | 判斷錯了?按 Tab 把整段翻轉成另一種語言,輸入法會**記住**這次修正 | | **Tab** | 判斷錯了?按 Tab 把整段翻轉成另一種語言,輸入法會**記住**這次修正 |
| ← → | 在組字區移動游標,選要改哪個字 | | ← → | 在組字區移動游標(可移到最前面)。游標在中間時:直接打注音會**插入**新字,Backspace 刪掉游標前的字,↓ 選游標前的字 |
| ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 | | ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 |
| Esc | 取消組字 | | Esc | 取消組字 |
| **單按 Shift** | 沒在打字時:切換**英文模式**,按鍵直接送出、保持小寫、沒有底線,一直維持到再單按一次 Shift 才回到中英自動判斷。打到一半時:同 Tab,整段翻轉 | | **單按 Shift** | 沒在打字時:切換**英文模式**,按鍵直接送出、保持小寫、沒有底線,一直維持到再單按一次 Shift 才回到中英自動判斷。打到一半時:同 Tab,整段翻轉 |
@@ -86,10 +97,10 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安
## 個人資料 ## 個人資料
| | macOS | Windows | | | macOS | Windows | Linux |
|---|---|---| |---|---|---|---|
| 學習紀錄(Tab 修正) | `UserDefaults`(`com.autozhuyin.inputmethod.AutoZhuyin`) | `%APPDATA%\PIME\autozhuyin\learned.json` | | 學習紀錄(Tab 修正) | `UserDefaults`(`com.autozhuyin.inputmethod.AutoZhuyin`) | `%APPDATA%\PIME\autozhuyin\learned.json` | `~/.config/autozhuyin/learned.json` |
| 自訂詞 | `~/Library/Application Support/AutoZhuyin/user-phrases.txt` | `%APPDATA%\PIME\autozhuyin\user-phrases.txt` | | 自訂詞 | `~/Library/Application Support/AutoZhuyin/user-phrases.txt` | `%APPDATA%\PIME\autozhuyin\user-phrases.txt` | `~/.config/autozhuyin/user-phrases.txt` |
自訂詞的格式和 `lexicon.txt` 一樣,每行一個詞:`ㄗˋ-ㄉㄨㄥˋ-ㄓㄨˋ-ㄧㄣ 自動注音 -4`(讀音、詞、分數;分數越大越優先)。 自訂詞的格式和 `lexicon.txt` 一樣,每行一個詞:`ㄗˋ-ㄉㄨㄥˋ-ㄓㄨˋ-ㄧㄣ 自動注音 -4`(讀音、詞、分數;分數越大越優先)。
Mac 版可以在輸入法選單選「清除學習紀錄」。 Mac 版可以在輸入法選單選「清除學習紀錄」。
@@ -125,6 +136,18 @@ scripts/package-windows.sh # 產生 build/AutoZhuyin-Wi
- `windows/autozhuyin/data/` 是產生出來的,不進版本控制。 - `windows/autozhuyin/data/` 是產生出來的,不進版本控制。
- 版本號在 `windows/autozhuyin/ime.json`。 - 版本號在 `windows/autozhuyin/ime.json`。
### Linux
Linux 版是 IBus 輸入法(`linux/autozhuyin_ibus.py`),直接使用 Windows 版的 Python 核心(`windows/autozhuyin/core/`)和資料。
```bash
python3 -m unittest discover -s linux/tests # 用假的 IBus 模組測試外殼
scripts/package-linux.sh # 產生 build/AutoZhuyin-Linux-<版本>.tar.gz(會先跑測試)
```
- 安裝在使用者目錄,不寫入 `/usr`:開機時由 autostart 啟動 `autozhuyin_ibus.py --activate`,它會把引擎動態註冊給 ibus-daemon 並切換過去。
- 也支援由 ibus-daemon 啟動(`--ibus`,配合 `/usr/share/ibus/component` 的 XML),之後要做 RPM 時可以用。
> 修改核心邏輯時,Swift(`Sources/AutoZhuyinCore/`)和 Python(`windows/autozhuyin/core/`)兩邊都要改,並在兩邊的測試加上相同案例。 > 修改核心邏輯時,Swift(`Sources/AutoZhuyinCore/`)和 Python(`windows/autozhuyin/core/`)兩邊都要改,並在兩邊的測試加上相同案例。
### 訓練判斷權重 ### 訓練判斷權重
@@ -178,12 +201,12 @@ scripts/release.sh minor --push # 同時 push commit 和 tag
`release.sh` 會自動: `release.sh` 會自動:
1. 遞增版本號(`Resources/Info.plist` 的版本與 build 號、`windows/autozhuyin/ime.json`) 1. 遞增版本號(`Resources/Info.plist` 的版本與 build 號、`windows/autozhuyin/ime.json`)
2. 跑 Swift 和 Python 全部測試 2. 跑 Swift 和 Python 全部測試
3. 產生 `build/AutoZhuyin-<版本>.pkg` 和 `build/AutoZhuyin-Windows-<版本>.zip` 3. 產生 `build/AutoZhuyin-<版本>.pkg`、`build/AutoZhuyin-Windows-<版本>.zip`、`build/AutoZhuyin-Linux-<版本>.tar.gz`
4. commit「Release v<版本>」並打上 `v<版本>` tag 4. commit「Release v<版本>」並打上 `v<版本>` tag
任何一步失敗都會把版本號改回去。只想改版本號不打包:`scripts/bump-version.sh [patch|minor|major]`。 任何一步失敗都會把版本號改回去。只想改版本號不打包:`scripts/bump-version.sh [patch|minor|major]`。
最後在 Gitea 用這個 tag 建立 Release,附上 `build/` 裡的 `.pkg` 和 `.zip`。 最後在 Gitea 用這個 tag 建立 Release,附上 `build/` 裡的 `.pkg`、`.zip` 和 `.tar.gz`。
## 專案結構 ## 專案結構
@@ -211,13 +234,18 @@ windows/
installer/ install.bat、uninstall.bat、給使用者的 README.txt installer/ install.bat、uninstall.bat、給使用者的 README.txt
tests/ Python 測試 tests/ Python 測試
tools/ 產生資料檔、圖示 tools/ 產生資料檔、圖示
linux/
autozhuyin_ibus.py IBus 外殼(共用 windows/autozhuyin/core)
installer/ install.sh、uninstall.sh、給使用者的 README.txt
tests/ 用假 IBus 模組的外殼測試
training/ 合成資料、訓練權重、Swift/Python 一致性測試資料 training/ 合成資料、訓練權重、Swift/Python 一致性測試資料
THIRD_PARTY_LICENSES.txt 第三方授權聲明(會打包進兩個安裝檔) THIRD_PARTY_LICENSES.txt 第三方授權聲明(會打包進兩個安裝檔)
``` ```
## 已知限制 ## 已知限制
- Windows 版還沒在實機上測試過。 - Windows 版、Linux 版還沒在實機上測試過。
- Linux 版只支援 IBus。KDE 上有些 Flatpak 程式(例如 Flatpak 版 Chrome)在 IBus Wayland 下可能打不出字。
- 聲調鍵打在注音符號中間(例如 `uv3l`)無法自動修正。 - 聲調鍵打在注音符號中間(例如 `uv3l`)無法自動修正。
- 很短的字串本質上就有歧義。像 `up`(也是 ㄧㄣ 因)這種常用的,按空白後會先保留,看下一個詞再決定(`up jo4` = 因為、`up the` = up the);其他判斷錯的可以按 Tab 修正,修正後會記住。 - 很短的字串本質上就有歧義。像 `up`(也是 ㄧㄣ 因)這種常用的,按空白後會先保留,看下一個詞再決定(`up jo4` = 因為、`up the` = up the);其他判斷錯的可以按 Tab 修正,修正後會記住。
- 安裝檔沒有簽章(macOS 沒有 Developer ID,Windows 沒有程式碼簽章憑證)。 - 安裝檔沒有簽章(macOS 沒有 Developer ID,Windows 沒有程式碼簽章憑證)。
@@ -227,6 +255,8 @@ THIRD_PARTY_LICENSES.txt 第三方授權聲明(會打包進兩個安裝
- [x] 匯入完整詞庫 - [x] 匯入完整詞庫
- [x] 注音順序錯誤修正 - [x] 注音順序錯誤修正
- [x] Windows 版 - [x] Windows 版
- [x] Linux 版(IBus)
- [ ] Linux Fcitx5 版(KDE 上相容性較好)
- [x] 用資料訓練判斷權重(合成資料) - [x] 用資料訓練判斷權重(合成資料)
- [ ] 加入真實打字資料一起訓練 - [ ] 加入真實打字資料一起訓練
- [ ] 已送出的英文單字若判斷錯誤,可以「事後翻轉」 - [ ] 已送出的英文單字若判斷錯誤,可以「事後翻轉」
+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.1</string> <string>0.9.0</string>
<key>CFBundleVersion</key> <key>CFBundleVersion</key>
<string>13</string> <string>15</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>
+179 -37
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
}
/// 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. /// Cursor position in `markedText`, in Characters.
public var cursorOffset: Int { public var cursorOffset: Int { baseCursorOffset + insertingText.count }
let pieces = markedPieces
let total = pieces.reduce(0) { $0 + $1.text.count } private var insertingText: String {
let stops = cursorStops inserting.isEmpty ? "" : ZhuyinParser.parse(inserting).syllables.map(\.syllable.reading).joined()
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) { 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
@@ -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() {
+315
View File
@@ -0,0 +1,315 @@
#!/usr/bin/env python3
"""IBus engine for AutoZhuyin (自動注音) on Linux.
All the logic lives in autozhuyin.core (shared with Windows and the tests); this file
only translates IBus key events and draws the preedit / candidate table.
Run modes:
autozhuyin_ibus.py --ibus started by ibus-daemon (from the component XML)
autozhuyin_ibus.py [--activate] started by the user/autostart: registers the engine
itself if ibus-daemon does not know it, and with
--activate makes it the current input method
"""
import json
import os
import sys
import time
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import gi # noqa: E402
gi.require_version("IBus", "1.0")
from gi.repository import GLib, GObject, IBus # noqa: E402
import autozhuyin # noqa: E402
from autozhuyin.core.classifier import LITERAL, Classifier, LearnedPreferences # noqa: E402
from autozhuyin.core.engine import ( # noqa: E402
BACKSPACE, DOWN, ENTER, ESCAPE, LEFT, RIGHT, SHIFT_TAP, TAB, UP, CompositionEngine,
)
from autozhuyin.core.english import EnglishModel # noqa: E402
from autozhuyin.core.lexicon import Lexicon # noqa: E402
from autozhuyin.core.shift_tap import ShiftTapDetector # noqa: E402
ENGINE_NAME = "autozhuyin"
BUS_NAME = "org.freedesktop.IBus.AutoZhuyin"
VERSION = "0.0.0"
_DATA = os.path.join(os.path.dirname(os.path.abspath(autozhuyin.__file__)), "data")
_USER_DIR = os.path.join(os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config"), "autozhuyin")
_LEARNED_FILE = os.path.join(_USER_DIR, "learned.json")
_USER_PHRASES = os.path.join(_USER_DIR, "user-phrases.txt")
try:
with open(os.path.join(HERE, "version.txt"), encoding="utf-8") as _f:
VERSION = _f.read().strip() or VERSION
except OSError:
pass
_classifier = None
def _save_learned(weights):
try:
os.makedirs(_USER_DIR, exist_ok=True)
with open(_LEARNED_FILE, "w", encoding="utf-8") as f:
json.dump(weights, f, ensure_ascii=False)
except OSError:
pass
def shared_classifier():
"""Loads the lexicon and English model once per process."""
global _classifier
if _classifier is None:
lexicon = Lexicon.from_file(os.path.join(_DATA, "lexicon.txt"))
if os.path.exists(_USER_PHRASES):
with open(_USER_PHRASES, encoding="utf-8") as f:
lexicon.load(f)
english = EnglishModel.from_files(
os.path.join(_DATA, "english-common.txt"),
os.path.join(_DATA, "english-dict.txt"),
os.path.join(_DATA, "english-bigram.json"),
)
weights = {}
try:
with open(_LEARNED_FILE, encoding="utf-8") as f:
weights = json.load(f)
except (OSError, ValueError):
pass
trained = Classifier.load_weights(os.path.join(_DATA, "classifier-weights.json"))
_classifier = Classifier(lexicon, english, LearnedPreferences(weights, _save_learned), trained)
return _classifier
_SPECIAL = {
IBus.KEY_BackSpace: BACKSPACE, IBus.KEY_Return: ENTER, IBus.KEY_KP_Enter: ENTER,
IBus.KEY_Escape: ESCAPE, IBus.KEY_Tab: TAB,
IBus.KEY_Up: UP, IBus.KEY_Down: DOWN, IBus.KEY_Left: LEFT, IBus.KEY_Right: RIGHT,
}
_SHIFT_KEYS = (IBus.KEY_Shift_L, IBus.KEY_Shift_R)
_SHORTCUT_MASK = (IBus.ModifierType.CONTROL_MASK | IBus.ModifierType.MOD1_MASK
| IBus.ModifierType.SUPER_MASK | IBus.ModifierType.MOD4_MASK)
_LITERAL_COLOR = 0x1E64DC # blue hint for English segments
class AutoZhuyinEngine(IBus.Engine):
__gtype_name__ = "AutoZhuyinEngine"
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._setup()
def _setup(self):
if getattr(self, "engine", None) is not None:
return
self.engine = CompositionEngine(shared_classifier())
self.shift_tap = ShiftTapDetector()
self.table = IBus.LookupTable.new(self.engine.page_size, 0, True, False)
self.table.set_orientation(IBus.Orientation.VERTICAL)
self.mode_prop = IBus.Property(
key="mode", prop_type=IBus.PropType.NORMAL,
label=IBus.Text.new_from_string("中英自動"),
symbol=IBus.Text.new_from_string("自"),
tooltip=IBus.Text.new_from_string("單按 Shift 切換英文模式"),
sensitive=True, visible=True, state=IBus.PropState.UNCHECKED)
self.props = IBus.PropList()
self.props.append(self.mode_prop)
# --- keys ---
def do_process_key_event(self, keyval, keycode, state):
self._setup()
released = bool(state & IBus.ModifierType.RELEASE_MASK)
# Shift pressed and released alone: English mode (or flip the current word).
if keyval in _SHIFT_KEYS:
now = time.monotonic()
if not released:
if state & _SHORTCUT_MASK:
self.shift_tap.key_pressed()
else:
self.shift_tap.shift_down(now)
return False
if self.shift_tap.shift_up(now):
self.engine.handle(SHIFT_TAP)
self._update(None)
self._update_mode()
return False
if released:
return False
self.shift_tap.key_pressed()
# Shortcuts (Ctrl/Alt/Super) go to the app; commit any composition first.
if state & _SHORTCUT_MASK:
if self.engine.keys:
self._update(self.engine.commit_all())
return False
key = self._key(keyval, state)
if key is None:
return self._busy() # swallow other keys (Delete, Home…) while composing
if not self.engine.wants(key):
return False
handled, commit = self.engine.handle(key)
self._update(commit)
return handled
def _key(self, keyval, state):
if keyval in _SPECIAL:
return _SPECIAL[keyval]
if keyval == IBus.KEY_space:
return " "
code = IBus.keyval_to_unicode(keyval)
if not code or not code.isprintable():
return None
# Caps Lock without Shift: keep Zhuyin working by using lowercase.
if state & IBus.ModifierType.LOCK_MASK and not state & IBus.ModifierType.SHIFT_MASK:
code = code.lower()
return code
def _busy(self):
return bool(self.engine.keys or self.engine.candidates)
# --- candidate panel (mouse) ---
def do_candidate_clicked(self, index, button, state):
self.engine.select_candidate(self.engine.page_start + index)
self._update(None)
def do_page_up(self):
return self._move_candidate(-self.engine.page_size)
def do_page_down(self):
return self._move_candidate(self.engine.page_size)
def do_cursor_up(self):
return self._move_candidate(-1)
def do_cursor_down(self):
return self._move_candidate(1)
def _move_candidate(self, delta):
if not self.engine.candidates:
return False
e = self.engine
e.candidate_index = max(0, min(len(e.candidates) - 1, e.candidate_index + delta))
self._update(None)
return True
# --- lifecycle ---
def do_focus_in(self):
self._setup()
self.register_properties(self.props)
self._update_mode()
def do_focus_out(self):
self._setup()
# PreeditFocusMode.COMMIT: IBus commits the shown text itself on focus out.
self.engine.reset()
self.hide_lookup_table()
def do_reset(self):
self._setup()
self.engine.reset()
self.hide_preedit_text()
self.hide_lookup_table()
def do_disable(self):
self.do_reset()
# --- drawing ---
def _update(self, commit):
if commit:
self.commit_text(IBus.Text.new_from_string(commit))
pieces = self.engine.marked_pieces
text = "".join(t for t, _ in pieces)
if text:
ibus_text = IBus.Text.new_from_string(text)
attrs = IBus.AttrList()
attrs.append(IBus.attr_underline_new(IBus.AttrUnderline.SINGLE, 0, len(text)))
pos = 0
for piece, mode in pieces:
if mode == LITERAL and piece:
attrs.append(IBus.attr_foreground_new(_LITERAL_COLOR, pos, pos + len(piece)))
pos += len(piece)
ibus_text.set_attributes(attrs)
self.update_preedit_text_with_mode(ibus_text, self.engine.cursor_offset, True,
IBus.PreeditFocusMode.COMMIT)
else:
self.hide_preedit_text()
if self.engine.candidates:
self.table.clear()
for _, candidate in self.engine.candidates:
self.table.append_candidate(IBus.Text.new_from_string(candidate))
self.table.set_cursor_pos(self.engine.candidate_index)
self.update_lookup_table(self.table, True)
else:
self.hide_lookup_table()
def _update_mode(self):
english = self.engine.english_mode
self.mode_prop.set_label(IBus.Text.new_from_string("英文" if english else "中英自動"))
self.mode_prop.set_symbol(IBus.Text.new_from_string("英" if english else "自"))
self.update_property(self.mode_prop)
# --- process setup ---
def make_component(exec_path):
component = IBus.Component(
name=BUS_NAME, description="自動注音 AutoZhuyin", version=VERSION,
license="Private", author="AutoZhuyin", homepage="",
command_line=f"{sys.executable} {exec_path} --ibus", textdomain="")
icon = os.path.join(HERE, "icon.png")
component.add_engine(IBus.EngineDesc(
name=ENGINE_NAME, longname="自動注音", description="大千注音+英文,自動判斷中英",
language="zh_TW", license="Private", author="AutoZhuyin",
icon=icon if os.path.exists(icon) else "", layout="us", symbol="自", rank=0))
return component
def main(argv):
IBus.init()
bus = IBus.Bus()
loop = GLib.MainLoop()
started_by_ibus = "--ibus" in argv
activate = "--activate" in argv
factory = None
def on_connected(*_):
nonlocal factory
factory = IBus.Factory.new(bus.get_connection())
factory.add_engine(ENGINE_NAME, GObject.type_from_name("AutoZhuyinEngine"))
if started_by_ibus:
bus.request_name(BUS_NAME, 0)
else:
known = any(e.get_name() == ENGINE_NAME for e in bus.list_engines())
if not known:
bus.register_component(make_component(os.path.abspath(__file__)))
if activate:
bus.set_global_engine(ENGINE_NAME)
def on_disconnected(*_):
if started_by_ibus:
loop.quit()
# Otherwise wait: IBus.Bus reconnects (and emits "connected") when ibus-daemon restarts.
bus.connect("connected", on_connected)
bus.connect("disconnected", on_disconnected)
shared_classifier() # load data before the first key
if bus.is_connected():
on_connected()
elif started_by_ibus:
print("autozhuyin: cannot connect to ibus-daemon", file=sys.stderr)
return 1
loop.run()
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
+57
View File
@@ -0,0 +1,57 @@
自動注音 AutoZhuyin(Linux 測試版,IBus)
=========================================
用大千注音鍵盤直接打字,不用切換中英文,輸入法會自動判斷你打的是注音還是英文。
按鍵: ji3 hello world su3cl3 (最後按空白)
輸出: 我hello world 你好
適用:Bazzite、SteamOS 桌面模式、Fedora 等有 IBus 的系統(KDE 或 GNOME)。
只在桌面模式可用;Steam 遊戲模式不支援系統輸入法。
安裝
----
1. 解壓縮,在終端機(Konsole)進到這個資料夾,執行:
./install.sh
不需要 sudo,檔案只會裝在你的家目錄(~/.local/share/autozhuyin)。
2. KDE(Bazzite / SteamOS 預設):
系統設定 → 鍵盤 → 虛擬鍵盤,選「IBus Wayland」→ 套用,然後登出再登入。
GNOME:IBus 是內建的,不用另外設定。
3. 之後每次登入都會自動切換到自動注音。
使用方式
--------
空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白
Enter 送出目前組字
Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正
← → 在組字區移動游標;游標在中間時直接打注音會插入新字,
Backspace 刪掉游標前的字
↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字
Esc 取消組字
單按 Shift 切換英文模式(按鍵直接送出),再單按一次回到中英自動判斷
Shift+字母 打大寫字母(也會強制英文)
` + 標點 強制全形標點,例如 `< 或 `, = , `. = 。 `/ = ? `; = ;
注音符號的順序打錯也沒關係,例如 ㄧㄒㄠˇ 會自動變成 ㄒㄧㄠˇ(小)。
切換與移除
----------
暫時改回一般鍵盤: ibus engine xkb:us::eng
切回自動注音: ibus engine autozhuyin
移除: ./uninstall.sh
個人資料(學習紀錄、自訂詞)在 ~/.config/autozhuyin/:
learned.json 按 Tab 修正的學習紀錄
user-phrases.txt 自訂詞,一行一個,例如:ㄗˋ-ㄉㄨㄥˋ 自動 -1
有問題時
--------
在終端機手動執行看看錯誤訊息:
/usr/bin/python3 ~/.local/share/autozhuyin/autozhuyin_ibus.py --activate
把畫面上的訊息回報給我。
+63
View File
@@ -0,0 +1,63 @@
#!/bin/bash
# Installs AutoZhuyin (自動注音) for the current user as an IBus input method.
# Nothing outside your home folder is touched, so it works on read-only systems
# (Bazzite, SteamOS, Fedora Atomic). No sudo needed.
set -euo pipefail
cd "$(dirname "$0")"
DEST="${XDG_DATA_HOME:-$HOME/.local/share}/autozhuyin"
AUTOSTART="${XDG_CONFIG_HOME:-$HOME/.config}/autostart"
PY=/usr/bin/python3
echo "== 自動注音 AutoZhuyin 安裝 =="
# 1. IBus and its Python bindings must come with the system.
if ! command -v ibus >/dev/null 2>&1; then
echo "找不到 IBus(ibus 指令)。這個系統沒有內建 IBus,自動注音目前只支援 IBus。" >&2
exit 1
fi
if ! "$PY" -c 'import gi; gi.require_version("IBus", "1.0"); from gi.repository import IBus' 2>/dev/null; then
echo "系統的 Python 缺少 IBus 模組(python3-gobject / IBus-1.0 typelib)。" >&2
exit 1
fi
# 2. Copy the program.
pkill -f "autozhuyin/autozhuyin_ibus.py" 2>/dev/null || true
rm -rf "$DEST"
mkdir -p "$DEST"
cp -R autozhuyin autozhuyin_ibus.py version.txt "$DEST/"
[ -f icon.png ] && cp icon.png "$DEST/"
[ -f THIRD_PARTY_LICENSES.txt ] && cp THIRD_PARTY_LICENSES.txt "$DEST/"
chmod +x "$DEST/autozhuyin_ibus.py"
# 3. Start with the desktop session: registers the engine with IBus and selects it.
mkdir -p "$AUTOSTART"
cat > "$AUTOSTART/autozhuyin.desktop" <<DESKTOP
[Desktop Entry]
Type=Application
Name=自動注音 AutoZhuyin
Comment=Registers the AutoZhuyin input method with IBus
Exec=$PY $DEST/autozhuyin_ibus.py --activate
Icon=$DEST/icon.png
X-GNOME-Autostart-enabled=true
X-KDE-autostart-phase=2
NoDisplay=true
DESKTOP
# 4. Start it now as well.
if pgrep -x ibus-daemon >/dev/null 2>&1; then
nohup "$PY" "$DEST/autozhuyin_ibus.py" --activate >/dev/null 2>&1 &
sleep 1
echo "已啟動並切換到自動注音。"
else
echo "IBus 目前沒有在執行,請照下面的步驟啟用 IBus 後登出再登入。"
fi
cat <<'MSG'
安裝完成。
- KDE(Bazzite / SteamOS 桌面模式):系統設定 → 鍵盤 → 虛擬鍵盤,選「IBus Wayland」,
按套用後登出再登入。之後每次登入都會自動切換到自動注音。
- 想暫時改回一般鍵盤:ibus engine xkb:us::eng ;切回自動注音:ibus engine autozhuyin
- 移除:執行 uninstall.sh
MSG
+14
View File
@@ -0,0 +1,14 @@
#!/bin/bash
# Removes AutoZhuyin (自動注音) for the current user. Your learned corrections and
# user phrases in ~/.config/autozhuyin are kept (delete that folder to remove them).
set -uo pipefail
DEST="${XDG_DATA_HOME:-$HOME/.local/share}/autozhuyin"
AUTOSTART="${XDG_CONFIG_HOME:-$HOME/.config}/autostart/autozhuyin.desktop"
if command -v ibus >/dev/null 2>&1 && [ "$(ibus engine 2>/dev/null)" = "autozhuyin" ]; then
ibus engine xkb:us::eng 2>/dev/null
fi
pkill -f "autozhuyin/autozhuyin_ibus.py" 2>/dev/null
rm -rf "$DEST" "$AUTOSTART"
echo "已移除自動注音。學習紀錄留在 ~/.config/autozhuyin,不需要可以自行刪除。"
+167
View File
@@ -0,0 +1,167 @@
"""Drives autozhuyin_ibus.AutoZhuyinEngine through a minimal stand-in for
gi.repository.IBus, to catch wrapper bugs without Linux. Run from the repo root:
python3 -m unittest discover -s linux/tests
"""
import os
import sys
import types
import unittest
LINUX = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, os.path.join(os.path.dirname(LINUX), "windows")) # autozhuyin package
sys.path.insert(0, LINUX)
# --- stand-in for gi / IBus (only what the wrapper uses) ---
class Flag(int):
def __or__(self, o): return Flag(int(self) | int(o))
def __and__(self, o): return Flag(int(self) & int(o))
IBus = types.SimpleNamespace()
for i, name in enumerate(["BackSpace", "Return", "KP_Enter", "Escape", "Tab", "Up", "Down", "Left",
"Right", "space", "Shift_L", "Shift_R", "Delete"]):
setattr(IBus, "KEY_" + name, 0xff00 + i)
IBus.KEY_space = 0x20
IBus.ModifierType = types.SimpleNamespace(
SHIFT_MASK=Flag(1), LOCK_MASK=Flag(2), CONTROL_MASK=Flag(4), MOD1_MASK=Flag(8),
SUPER_MASK=Flag(1 << 26), MOD4_MASK=Flag(64), RELEASE_MASK=Flag(1 << 30))
IBus.keyval_to_unicode = lambda k: chr(k) if 0x20 <= k < 0x7f else "\x00"
class Text:
def __init__(self, s): self.text, self.attrs = s, None
@staticmethod
def new_from_string(s): return Text(s)
def set_attributes(self, a): self.attrs = a
class AttrList(list):
pass
class LookupTable:
def __init__(self): self.items, self.cursor = [], 0
@staticmethod
def new(*a): return LookupTable()
def set_orientation(self, o): pass
def clear(self): self.items = []
def append_candidate(self, t): self.items.append(t.text)
def set_cursor_pos(self, p): self.cursor = p
class Property:
def __init__(self, **kw): self.label = kw["label"].text
def set_label(self, t): self.label = t.text
def set_symbol(self, t): pass
class Engine:
def __init__(self, *a, **kw):
self.committed, self.preedit, self.cursor, self.shown = "", "", 0, None
self.preedit_attrs = None
def commit_text(self, t): self.committed += t.text
def update_preedit_text_with_mode(self, t, cursor, visible, mode):
self.preedit, self.cursor, self.preedit_attrs = t.text, cursor, t.attrs
def hide_preedit_text(self): self.preedit = ""
def update_lookup_table(self, table, visible): self.shown = list(table.items)
def hide_lookup_table(self): self.shown = None
def register_properties(self, p): pass
def update_property(self, p): self.mode_label = p.label
IBus.Text, IBus.AttrList, IBus.LookupTable, IBus.Property, IBus.Engine = Text, AttrList, LookupTable, Property, Engine
IBus.PropList = lambda: types.SimpleNamespace(append=lambda p: None)
IBus.attr_underline_new = lambda kind, a, b: ("underline", a, b)
IBus.attr_foreground_new = lambda color, a, b: ("color", a, b)
IBus.AttrUnderline = types.SimpleNamespace(SINGLE=1)
IBus.Orientation = types.SimpleNamespace(VERTICAL=1)
IBus.PropType = types.SimpleNamespace(NORMAL=0)
IBus.PropState = types.SimpleNamespace(UNCHECKED=0)
IBus.PreeditFocusMode = types.SimpleNamespace(COMMIT=1)
gi = types.ModuleType("gi")
gi.require_version = lambda *a: None
repo = types.ModuleType("gi.repository")
repo.IBus, repo.GLib, repo.GObject = IBus, types.SimpleNamespace(), types.SimpleNamespace()
gi.repository = repo
sys.modules["gi"], sys.modules["gi.repository"] = gi, repo
import autozhuyin_ibus # noqa: E402
M = IBus.ModifierType
def press(e, keys):
"""Types keys; returns the list of 'handled' results."""
names = {"\n": IBus.KEY_Return, "\b": IBus.KEY_BackSpace, "\t": IBus.KEY_Tab, "←": IBus.KEY_Left,
"→": IBus.KEY_Right, "↓": IBus.KEY_Down, " ": IBus.KEY_space}
out = []
for c in keys:
kv = names.get(c, ord(c))
out.append(e.do_process_key_event(kv, 0, Flag(0)))
e.do_process_key_event(kv, 0, M.RELEASE_MASK)
return out
class IBusEngineTests(unittest.TestCase):
def setUp(self):
self.e = autozhuyin_ibus.AutoZhuyinEngine()
def test_mixed_sentence(self):
press(self.e, "ji3 hello world su3cl3 ")
self.assertEqual(self.e.committed, "我hello world 你好")
self.assertEqual(self.e.preedit, "")
def test_preedit_marks_english_blue(self):
press(self.e, "ji3hello")
self.assertEqual(self.e.preedit, "我hello")
self.assertIn(("color", 1, 6), self.e.preedit_attrs)
self.assertEqual(self.e.cursor, 6)
def test_space_passes_through_when_idle(self):
self.assertEqual(press(self.e, " "), [False])
def test_candidates_and_click(self):
press(self.e, "su3↓")
self.assertTrue(self.e.shown)
second = self.e.shown[1]
self.e.do_candidate_clicked(1, 1, 0)
self.assertIsNone(self.e.shown)
press(self.e, "\n")
self.assertEqual(self.e.committed, second)
def test_shift_tap_toggles_english(self):
self.e.do_process_key_event(IBus.KEY_Shift_L, 0, Flag(0))
self.e.do_process_key_event(IBus.KEY_Shift_L, 0, M.SHIFT_MASK | M.RELEASE_MASK)
self.assertEqual(self.e.mode_label, "英文")
self.assertEqual(press(self.e, "a"), [False]) # goes to the app as typed
def test_shift_as_modifier_is_not_a_tap(self):
self.e.do_process_key_event(IBus.KEY_Shift_L, 0, Flag(0))
self.e.do_process_key_event(ord("A"), 0, M.SHIFT_MASK)
self.e.do_process_key_event(IBus.KEY_Shift_L, 0, M.SHIFT_MASK | M.RELEASE_MASK)
self.assertFalse(self.e.engine.english_mode)
def test_ctrl_shortcut_commits_and_passes(self):
press(self.e, "su3")
self.assertFalse(self.e.do_process_key_event(ord("c"), 0, M.CONTROL_MASK))
self.assertEqual(self.e.committed, "你")
def test_backtick_symbol(self):
press(self.e, "`<")
self.assertEqual(self.e.committed, ",")
def test_insert_in_middle(self):
press(self.e, "rup fu4←wu0 \n")
self.assertEqual(self.e.committed, "今天氣")
def test_focus_out_resets(self):
press(self.e, "su3")
self.e.do_focus_out()
self.assertEqual(self.e.engine.keys, [])
if __name__ == "__main__":
unittest.main()
+31
View File
@@ -0,0 +1,31 @@
#!/bin/bash
# Builds build/AutoZhuyin-Linux-<version>.tar.gz: the IBus engine, the shared Python
# core and data, and install/uninstall scripts (per-user install, no root needed).
set -euo pipefail
cd "$(dirname "$0")/.."
VERSION="$(python3 -I -c 'import json,sys; print(json.load(open(sys.argv[1]))["version"])' windows/autozhuyin/ime.json)"
NAME="AutoZhuyin-Linux-$VERSION"
OUT="build/$NAME"
python3 -I windows/tools/build_data.py
(cd windows && python3 -m unittest discover -q tests)
python3 -m unittest discover -q -s linux/tests
if [ ! -f build/icon.tiff ]; then
DEVELOPER_DIR="${DEVELOPER_DIR:-/Applications/Xcode.app/Contents/Developer}" xcrun swift scripts/make-icon.swift build/icon.tiff
fi
rm -rf "$OUT" "$OUT.tar.gz"
mkdir -p "$OUT/autozhuyin"
rsync -a --exclude __pycache__ --exclude '*.pyc' \
windows/autozhuyin/__init__.py windows/autozhuyin/core windows/autozhuyin/data "$OUT/autozhuyin/"
cp linux/autozhuyin_ibus.py linux/installer/install.sh linux/installer/uninstall.sh linux/installer/README.txt \
THIRD_PARTY_LICENSES.txt "$OUT/"
echo "$VERSION" > "$OUT/version.txt"
sips -s format png -z 64 64 build/icon.tiff --out "$OUT/icon.png" >/dev/null
chmod +x "$OUT/install.sh" "$OUT/uninstall.sh" "$OUT/autozhuyin_ibus.py"
# Plain ustar without macOS extended attributes, so GNU tar doesn't warn.
(cd build && COPYFILE_DISABLE=1 tar --no-xattrs --format ustar -czf "$NAME.tar.gz" "$NAME")
echo "Built build/$NAME.tar.gz"
+5 -3
View File
@@ -1,5 +1,5 @@
#!/bin/bash #!/bin/bash
# One-step release: bump the version, run all tests, build both installers, then # One-step release: bump the version, run all tests, build all installers, then
# commit the version change and tag it. # commit the version change and tag it.
# #
# Usage: scripts/release.sh [patch|minor|major] [--push] (default: patch) # Usage: scripts/release.sh [patch|minor|major] [--push] (default: patch)
@@ -38,14 +38,16 @@ xcrun swift test -q 2>&1 | tail -3
echo "==> Packaging (runs the Python tests too)" echo "==> Packaging (runs the Python tests too)"
scripts/package.sh >/dev/null scripts/package.sh >/dev/null
scripts/package-windows.sh >/dev/null scripts/package-windows.sh >/dev/null
scripts/package-linux.sh >/dev/null
trap - ERR trap - ERR
git add Resources/Info.plist windows/autozhuyin/ime.json git add Resources/Info.plist windows/autozhuyin/ime.json
git commit -q -m "Release v$VERSION" git commit -q -m "Release v$VERSION"
git tag -a "v$VERSION" -m "AutoZhuyin v$VERSION" git tag -a "v$VERSION" -m "AutoZhuyin v$VERSION"
echo "==> Tagged v$VERSION" echo "==> Tagged v$VERSION"
ls -lh "build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip" FILES=("build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip" "build/AutoZhuyin-Linux-$VERSION.tar.gz")
shasum -a 256 "build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip" ls -lh "${FILES[@]}"
shasum -a 256 "${FILES[@]}"
if [ "$PUSH" = 1 ]; then if [ "$PUSH" = 1 ]; then
git push origin HEAD "v$VERSION" git push origin HEAD "v$VERSION"
+191 -35
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): 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: 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]) n = len(self._convertible(seg, i < len(segs) - 1)[0])
out.extend((i, k) for k in range(1, n + 1)) local = sum(1 for e in self._syllable_ends(seg) if e <= pos)
return out 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 @property
def cursor_offset(self): def cursor_offset(self):
"""Cursor position in marked_text (characters).""" """Cursor position in marked_text (characters)."""
pieces = self.marked_pieces return self._base_cursor_offset() + len(self._inserting_text())
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): 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,12 +333,14 @@ 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
if key in SPECIAL_KEYS: if key in SPECIAL_KEYS:
return bool(self.keys) return bool(self.keys)
if key == BACKTICK:
return True
if self.keys: if self.keys:
return True return True
if key == " ": if key == " ":
@@ -217,10 +354,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 +378,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,7 +404,8 @@ class CompositionEngine:
if key == DOWN: if key == DOWN:
if not self.keys: if not self.keys:
return PASS return PASS
self._open_candidates() if not self.inserting:
self._open_candidates()
return CONSUMED return CONSUMED
if key in (LEFT, RIGHT): if key in (LEFT, RIGHT):
if not self.keys: if not self.keys:
@@ -286,7 +436,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 +485,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 +541,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.1", "version": "0.9.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()
+4
View File
@@ -105,6 +105,10 @@ class WrapperTests(unittest.TestCase):
def test_mixed_sentence(self): def test_mixed_sentence(self):
self.assertEqual(type_text(self.svc, "ji3 hello world su3cl3 "), "我hello world 你好") self.assertEqual(type_text(self.svc, "ji3 hello world su3cl3 "), "我hello world 你好")
def test_backtick_symbol(self):
self.assertEqual(type_text(self.svc, "`<"), ",")
self.assertEqual(type_text(self.svc, "ji3`."), "我。")
def test_composition_shown(self): def test_composition_shown(self):
type_text(self.svc, "su3c") type_text(self.svc, "su3c")
self.assertEqual(self.svc.reply["compositionString"], "你ㄏ") self.assertEqual(self.svc.reply["compositionString"], "你ㄏ")