floraachy
/
vChewing-macOS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1.8.0 // Improved handling. Merge Gitee PR!59 from upd/1.8.0

This commit is contained in:
ShikiSuen 2022-07-12 15:48:03 +00:00 committed by Gitee
parent f0a33c08ea 4a313947fe
commit 54a6be7257
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
42 changed files with 892 additions and 793 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
FAQ.md
View File

@ -55,7 +55,7 @@ xattr -dr com.apple.quarantine ~/Downloads/vChewingInstaller.app
### 5. 選字窗位置不對欸。 ### 5. 選字窗位置不對欸。
這往往是您在打字時使用的應用程式，並沒有正確地將正確的游標位置告知 IMK、導致輸入法無法得知相關的資訊使然。您在某個應用程式中打字，輸入游標的位置到底在哪裡，一開始只有那個應用程式知道，然後，那個應用程式必須把正確的位置告知輸入法，輸入法才知道應該在什麼位置，顯示像是選字窗這樣的使用者介面元件。某些應用完全沒有認真處理與 macOS 的 IMK 框架有關的內容，所以就通知了輸入法一個奇怪的位置資訊，有時候座標根本就在螢幕大小之外。威注音在使用的 Voltaire MK3 與上游使用的 Voltaire MK2 的判斷方法相同：如果某個應用程式將奇怪的位置（不在任何一個螢幕的範圍內）告知給 IMK，那麼輸入法就會想辦法把選字窗擺在螢幕範圍內最接近的位置。比方說：如果是 y 軸超過了螢幕尺寸，就會改在螢幕的最上方顯示。 這往往是您在敲字時使用的應用程式，並沒有正確地將正確的游標位置告知 IMK、導致輸入法無法得知相關的資訊使然。您在某個應用程式中敲字，輸入游標的位置到底在哪裡，一開始只有那個應用程式知道，然後，那個應用程式必須把正確的位置告知輸入法，輸入法才知道應該在什麼位置，顯示像是選字窗這樣的使用者介面元件。某些應用完全沒有認真處理與 macOS 的 IMK 框架有關的內容，所以就通知了輸入法一個奇怪的位置資訊，有時候座標根本就在螢幕大小之外。威注音在使用的 Voltaire MK3 與上游使用的 Voltaire MK2 的判斷方法相同：如果某個應用程式將奇怪的位置（不在任何一個螢幕的範圍內）告知給 IMK，那麼輸入法就會想辦法把選字窗擺在螢幕範圍內最接近的位置。比方說：如果是 y 軸超過了螢幕尺寸，就會改在螢幕的最上方顯示。
### 6. 自訂使用者語彙資料該怎麼管理？ ### 6. 自訂使用者語彙資料該怎麼管理？

2
Source/Data

@ -1 +1 @@
Subproject commit 9301650c6e27b31730e4f060f94c4cab0a28579c Subproject commit 50250d970a3481ec7653a71120413708a76224d8

41
Source/Modules/ControllerModules/InputState.swift
View File

@ -139,9 +139,9 @@ enum InputState {
/// 因為逐字選字模式不需要在組字區內存入任何東西，所以該狀態不受 .NotEmpty 的管轄。 /// 因為逐字選字模式不需要在組字區內存入任何東西，所以該狀態不受 .NotEmpty 的管轄。
class AssociatedPhrases: InputStateProtocol { class AssociatedPhrases: InputStateProtocol {
public var type: StateType { .ofAssociatedPhrases } public var type: StateType { .ofAssociatedPhrases }
private(set) var candidates: [String] = [] private(set) var candidates: [(String, String)] = []
private(set) var isTypingVertical: Bool = false private(set) var isTypingVertical: Bool = false
init(candidates: [String], isTypingVertical: Bool) { init(candidates: [(String, String)], isTypingVertical: Bool) {
self.candidates = candidates self.candidates = candidates
self.isTypingVertical = isTypingVertical self.isTypingVertical = isTypingVertical
} }
@ -228,6 +228,27 @@ enum InputState {
return lowerBoundLiteral..<upperBoundLiteral return lowerBoundLiteral..<upperBoundLiteral
} }
var literalReadingThread: String {
var arrOutput = [String]()
for neta in readings[literalMarkedRange] {
var neta = neta
if neta.isEmpty { continue }
if neta.contains("_") {
arrOutput.append("??")
continue
}
if mgrPrefs.showHanyuPinyinInCompositionBuffer { // 恢復陰平標記->注音轉拼音->轉教科書式標調
neta = Tekkon.restoreToneOneInZhuyinKey(target: neta)
neta = Tekkon.cnvPhonaToHanyuPinyin(target: neta)
neta = Tekkon.cnvHanyuPinyinToTextbookStyle(target: neta)
} else {
neta = Tekkon.cnvZhuyinChainToTextbookReading(target: neta)
}
arrOutput.append(neta)
}
return arrOutput.joined(separator: " ")
}
private var deleteTargetExists = false private var deleteTargetExists = false
var tooltip: String { var tooltip: String {
if composingBuffer.count != readings.count { if composingBuffer.count != readings.count {
@ -252,15 +273,14 @@ enum InputState {
return String( return String(
format: NSLocalizedString( format: NSLocalizedString(
"\"%@\" length must ≥ 2 for a user phrase.", comment: "" "\"%@\" length must ≥ 2 for a user phrase.", comment: ""
), text ) + "\n// " + literalReadingThread, text
) )
} else if literalMarkedRange.count > allowedMarkRange.upperBound { } else if literalMarkedRange.count > allowedMarkRange.upperBound {
ctlInputMethod.tooltipController.setColor(state: .denialOverflow) ctlInputMethod.tooltipController.setColor(state: .denialOverflow)
return String( return String(
format: NSLocalizedString( format: NSLocalizedString(
"\"%@\" length should ≤ %d for a user phrase.", comment: "" "\"%@\" length should ≤ %d for a user phrase.", comment: ""
), ) + "\n// " + literalReadingThread, text, allowedMarkRange.upperBound
text, allowedMarkRange.upperBound
) )
} }
@ -275,12 +295,13 @@ enum InputState {
return String( return String(
format: NSLocalizedString( format: NSLocalizedString(
"\"%@\" already exists: ENTER to boost, \n SHIFT+CMD+ENTER to exclude.", comment: "" "\"%@\" already exists: ENTER to boost, \n SHIFT+CMD+ENTER to exclude.", comment: ""
), text ) + "\n// " + literalReadingThread, text
) )
} }
ctlInputMethod.tooltipController.resetColor() ctlInputMethod.tooltipController.resetColor()
return String( return String(
format: NSLocalizedString("\"%@\" selected. ENTER to add user phrase.", comment: ""), format: NSLocalizedString("\"%@\" selected. ENTER to add user phrase.", comment: "") + "\n// "
+ literalReadingThread,
text text
) )
} }
@ -386,10 +407,10 @@ enum InputState {
/// .ChoosingCandidate: 叫出選字窗、允許使用者選字。 /// .ChoosingCandidate: 叫出選字窗、允許使用者選字。
class ChoosingCandidate: NotEmpty { class ChoosingCandidate: NotEmpty {
override public var type: StateType { .ofChooseCandidate } override public var type: StateType { .ofChooseCandidate }
private(set) var candidates: [String] private(set) var candidates: [(String, String)]
private(set) var isTypingVertical: Bool private(set) var isTypingVertical: Bool
init(composingBuffer: String, cursorIndex: Int, candidates: [String], isTypingVertical: Bool) { init(composingBuffer: String, cursorIndex: Int, candidates: [(String, String)], isTypingVertical: Bool) {
self.candidates = candidates self.candidates = candidates
self.isTypingVertical = isTypingVertical self.isTypingVertical = isTypingVertical
super.init(composingBuffer: composingBuffer, cursorIndex: cursorIndex) super.init(composingBuffer: composingBuffer, cursorIndex: cursorIndex)
@ -411,7 +432,7 @@ enum InputState {
self.node = node self.node = node
let candidates = node.children?.map(\.title) ?? [String]() let candidates = node.children?.map(\.title) ?? [String]()
super.init( super.init(
composingBuffer: "", cursorIndex: 0, candidates: candidates, composingBuffer: "", cursorIndex: 0, candidates: candidates.map { ("", $0) },
isTypingVertical: isTypingVertical isTypingVertical: isTypingVertical
) )
} }

196
Source/Modules/ControllerModules/KeyHandler_Core.swift
View File

@ -56,7 +56,7 @@ class KeyHandler {
var compositor: Megrez.Compositor // 組字器 var compositor: Megrez.Compositor // 組字器
var currentLM: vChewing.LMInstantiator = .init() // 當前主語言模組 var currentLM: vChewing.LMInstantiator = .init() // 當前主語言模組
var currentUOM: vChewing.LMUserOverride = .init() // 當前半衰記憶模組 var currentUOM: vChewing.LMUserOverride = .init() // 當前半衰記憶模組
var walkedAnchors: [Megrez.NodeAnchor] = [] // 用以記錄爬過的節錨的陣列 var walkedAnchors: [Megrez.NodeAnchor] { compositor.walkedAnchors } // 用以記錄爬過的節錨的陣列
/// 委任物件 (ctlInputMethod)，以便呼叫其中的函式。 /// 委任物件 (ctlInputMethod)，以便呼叫其中的函式。
var delegate: KeyHandlerDelegate? var delegate: KeyHandlerDelegate?
@ -95,7 +95,6 @@ class KeyHandler {
func clear() { func clear() {
composer.clear() composer.clear()
compositor.clear() compositor.clear()
walkedAnchors.removeAll()
} }
// MARK: - Functions dealing with Megrez. // MARK: - Functions dealing with Megrez.
@ -103,7 +102,7 @@ class KeyHandler {
/// 實際上要拿給 Megrez 使用的的滑鼠游標位址，以方便在組字器最開頭或者最末尾的時候始終能抓取候選字節點陣列。 /// 實際上要拿給 Megrez 使用的的滑鼠游標位址，以方便在組字器最開頭或者最末尾的時候始終能抓取候選字節點陣列。
/// ///
/// 威注音對游標前置與游標後置模式採取的候選字節點陣列抓取方法是分離的，且不使用 Node Crossing。 /// 威注音對游標前置與游標後置模式採取的候選字節點陣列抓取方法是分離的，且不使用 Node Crossing。
var actualCandidateCursorIndex: Int { var actualCandidateCursor: Int {
mgrPrefs.useRearCursorMode ? min(compositorCursorIndex, compositorLength - 1) : max(compositorCursorIndex, 1) mgrPrefs.useRearCursorMode ? min(compositorCursorIndex, compositorLength - 1) : max(compositorCursorIndex, 1)
} }
@ -113,11 +112,11 @@ class KeyHandler {
/// ///
/// 該函式的爬取順序是從頭到尾。 /// 該函式的爬取順序是從頭到尾。
func walk() { func walk() {
walkedAnchors = compositor.walk() compositor.walk()
// 在偵錯模式開啟時，將 GraphViz 資料寫入至指定位置。 // 在偵錯模式開啟時，將 GraphViz 資料寫入至指定位置。
if mgrPrefs.isDebugModeEnabled { if mgrPrefs.isDebugModeEnabled {
let result = compositor.grid.dumpDOT let result = compositor.dumpDOT
do { do {
try result.write( try result.write(
toFile: "/private/var/tmp/vChewing-visualization.dot", toFile: "/private/var/tmp/vChewing-visualization.dot",
@ -137,12 +136,10 @@ class KeyHandler {
/// 估算對象範圍。用比較形象且生動卻有點噁心的解釋的話，蒼蠅一邊吃一邊屙。 /// 估算對象範圍。用比較形象且生動卻有點噁心的解釋的話，蒼蠅一邊吃一邊屙。
var commitOverflownCompositionAndWalk: String { var commitOverflownCompositionAndWalk: String {
var textToCommit = "" var textToCommit = ""
if compositor.grid.width > mgrPrefs.composingBufferSize, !walkedAnchors.isEmpty { if compositor.width > mgrPrefs.composingBufferSize, !walkedAnchors.isEmpty {
let anchor: Megrez.NodeAnchor = walkedAnchors[0] let anchor: Megrez.NodeAnchor = walkedAnchors[0]
if let theNode = anchor.node { textToCommit = anchor.node.currentPair.value
textToCommit = theNode.currentKeyValue.value compositor.removeHeadReadings(count: anchor.spanLength)
}
compositor.removeHeadReadings(count: anchor.spanningLength)
} }
walk() walk()
return textToCommit return textToCommit
@ -152,10 +149,10 @@ class KeyHandler {
/// - Parameter key: 給定的聯想詞的開頭字。 /// - Parameter key: 給定的聯想詞的開頭字。
/// - Returns: 抓取到的聯想詞陣列。 /// - Returns: 抓取到的聯想詞陣列。
/// 不會是 nil，但那些負責接收結果的函式會對空白陣列結果做出正確的處理。 /// 不會是 nil，但那些負責接收結果的函式會對空白陣列結果做出正確的處理。
func buildAssociatePhraseArray(withKey key: String) -> [String] { func buildAssociatePhraseArray(withKey key: String) -> [(String, String)] {
var arrResult: [String] = [] var arrResult: [(String, String)] = []
if currentLM.hasAssociatedPhrasesFor(key: key) { if currentLM.hasAssociatedPhrasesFor(key: key) {
arrResult.append(contentsOf: currentLM.associatedPhrasesFor(key: key)) arrResult = currentLM.associatedPhrasesFor(key: key).map { ("", $0) }
} }
return arrResult return arrResult
} }
@ -165,35 +162,32 @@ class KeyHandler {
/// - Parameters: /// - Parameters:
/// - value: 給定之候選字字串。 /// - value: 給定之候選字字串。
/// - respectCursorPushing: 若該選項為 true，則會在選字之後始終將游標推送至選字厚的節錨的前方。 /// - respectCursorPushing: 若該選項為 true，則會在選字之後始終將游標推送至選字厚的節錨的前方。
func fixNode(value: String, respectCursorPushing: Bool = true) { func fixNode(candidate: (String, String), respectCursorPushing: Bool = true) {
let cursorIndex = min(actualCandidateCursorIndex + (mgrPrefs.useRearCursorMode ? 1 : 0), compositorLength) let theCandidate: Megrez.KeyValuePaired = .init(key: candidate.0, value: candidate.1)
let adjustedCursor = max(0, min(actualCandidateCursor + (mgrPrefs.useRearCursorMode ? 1 : 0), compositorLength))
// 開始讓半衰模組觀察目前的狀況。 // 開始讓半衰模組觀察目前的狀況。
let selectedNode: Megrez.NodeAnchor = compositor.grid.fixNodeSelectedCandidate( let selectedNode: Megrez.NodeAnchor = compositor.fixNodeWithCandidate(theCandidate, at: adjustedCursor)
location: cursorIndex, value: value
)
// 不要針對逐字選字模式啟用臨時半衰記憶模型。 // 不要針對逐字選字模式啟用臨時半衰記憶模型。
if !mgrPrefs.useSCPCTypingMode { if !mgrPrefs.useSCPCTypingMode {
var addToUserOverrideModel = true var addToUserOverrideModel = true
// 所有讀音數與字符數不匹配的情況均不得塞入半衰記憶模組。 // 所有讀音數與字符數不匹配的情況均不得塞入半衰記憶模組。
if selectedNode.spanningLength != value.count { if selectedNode.spanLength != theCandidate.value.count {
IME.prtDebugIntel("UOM: SpanningLength != value.count, dismissing.") IME.prtDebugIntel("UOM: SpanningLength != value.count, dismissing.")
addToUserOverrideModel = false addToUserOverrideModel = false
} }
if addToUserOverrideModel { if addToUserOverrideModel {
if let theNode = selectedNode.node { // 威注音的 SymbolLM 的 Score 是 -12，符合該條件的內容不得塞入半衰記憶模組。
// 威注音的 SymbolLM 的 Score 是 -12，符合該條件的內容不得塞入半衰記憶模組。 if selectedNode.node.scoreForPaired(candidate: theCandidate) <= -12 {
if theNode.scoreFor(candidate: value) <= -12 { IME.prtDebugIntel("UOM: Score <= -12, dismissing.")
IME.prtDebugIntel("UOM: Score <= -12, dismissing.") addToUserOverrideModel = false
addToUserOverrideModel = false
}
} }
} }
if addToUserOverrideModel { if addToUserOverrideModel {
IME.prtDebugIntel("UOM: Start Observation.") IME.prtDebugIntel("UOM: Start Observation.")
// 令半衰記憶模組觀測給定的 trigram。 // 令半衰記憶模組觀測給定的三元圖。
// 這個過程會讓半衰引擎根據當前上下文生成 trigram 索引鍵。 // 這個過程會讓半衰引擎根據當前上下文生成三元圖索引鍵。
currentUOM.observe( currentUOM.observe(
walkedAnchors: walkedAnchors, cursorIndex: cursorIndex, candidate: value, walkedAnchors: walkedAnchors, cursorIndex: adjustedCursor, candidate: theCandidate.value,
timestamp: NSDate().timeIntervalSince1970 timestamp: NSDate().timeIntervalSince1970
) )
} }
@ -204,70 +198,57 @@ class KeyHandler {
/// 若偏好設定內啟用了相關選項，則會在選字之後始終將游標推送至選字厚的節錨的前方。 /// 若偏好設定內啟用了相關選項，則會在選字之後始終將游標推送至選字厚的節錨的前方。
if mgrPrefs.moveCursorAfterSelectingCandidate, respectCursorPushing { if mgrPrefs.moveCursorAfterSelectingCandidate, respectCursorPushing {
var nextPosition = 0 compositor.jumpCursorBySpan(to: .front)
for theAnchor in walkedAnchors {
if nextPosition >= cursorIndex { break }
nextPosition += theAnchor.spanningLength
}
if nextPosition <= compositorLength {
compositorCursorIndex = nextPosition
}
} }
} }
/// 組字器內超出最大動態爬軌範圍的節錨都會被自動標記為「已經手動選字過」，減少爬軌運算負擔。 /// 組字器內超出最大動態爬軌範圍的節錨都會被自動標記為「已經手動選字過」，減少爬軌運算負擔。
func markNodesFixedIfNecessary() { func markNodesFixedIfNecessary() {
let width = compositor.grid.width let width = compositor.width
if width <= kMaxComposingBufferNeedsToWalkSize { if width <= kMaxComposingBufferNeedsToWalkSize {
return return
} }
var index = 0 var index = 0
for anchor in walkedAnchors { for anchor in walkedAnchors {
guard let node = anchor.node else { break }
if index >= width - kMaxComposingBufferNeedsToWalkSize { break } if index >= width - kMaxComposingBufferNeedsToWalkSize { break }
if node.score < node.kSelectedCandidateScore { if anchor.node.score < Megrez.Node.kSelectedCandidateScore {
compositor.grid.fixNodeSelectedCandidate( compositor.fixNodeWithCandidate(anchor.node.currentPair, at: index + anchor.spanLength)
location: index + anchor.spanningLength, value: node.currentKeyValue.value
)
} }
index += anchor.spanningLength index += anchor.spanLength
} }
} }
/// 獲取候選字詞陣列資料內容。 /// 獲取候選字詞（包含讀音）陣列資料內容。
func getCandidatesArray(fixOrder: Bool = true) -> [String] { func getCandidatesArray(fixOrder: Bool = true) -> [(String, String)] {
var arrAnchors: [Megrez.NodeAnchor] = rawAnchorsOfNodes var arrAnchors: [Megrez.NodeAnchor] = rawAnchorsOfNodes
var arrCandidates: [String] = [] var arrCandidates: [Megrez.KeyValuePaired] = .init()
/// 原理：nodes 這個回饋結果包含一堆子陣列，分別對應不同詞長的候選字。 /// 原理：nodes 這個回饋結果包含一堆子陣列，分別對應不同詞長的候選字。
/// 這裡先對陣列排序、讓最長候選字的子陣列的優先權最高。 /// 這裡先對陣列排序、讓最長候選字的子陣列的優先權最高。
/// 這個過程不會傷到子陣列內部的排序。 /// 這個過程不會傷到子陣列內部的排序。
if arrAnchors.isEmpty { return arrCandidates } if arrAnchors.isEmpty { return .init() }
// 讓更長的節錨排序靠前。 // 讓更長的節錨排序靠前。
arrAnchors = arrAnchors.stableSort { $0.keyLength > $1.keyLength } arrAnchors = arrAnchors.stableSort { $0.keyLength > $1.keyLength }
// 將節錨內的候選字詞資料拓印到輸出陣列內。 // 將節錨內的候選字詞資料拓印到輸出陣列內。
for currentNodeAnchor in arrAnchors { for currentCandidate in arrAnchors.map(\.node.candidates).joined() {
guard let currentNode = currentNodeAnchor.node else { continue } // 選字窗的內容的康熙轉換 / JIS 轉換不能放在這裡處理，會影響選字有效性。
for currentCandidate in currentNode.candidates { // 選字的原理是拿著具體的候選字詞的字串去當前的節錨下找出對應的候選字詞（Ｘ元圖）。
// 選字窗的內容的康熙轉換 / JIS 轉換不能放在這裡處理，會影響選字有效性。 // 一旦在這裡轉換了，節錨內的某些元圖就無法被選中。
// 選字的原理是拿著具體的候選字詞的字串去當前的節錨下找出對應的候選字詞（Ｘ元圖）。 arrCandidates.append(.init(key: currentCandidate.key, value: currentCandidate.value))
// 一旦在這裡轉換了，節錨內的某些元圖就無法被選中。
arrCandidates.append(currentCandidate.value)
}
} }
// 決定是否根據半衰記憶模組的建議來調整候選字詞的順序。 // 決定是否根據半衰記憶模組的建議來調整候選字詞的順序。
if !mgrPrefs.fetchSuggestionsFromUserOverrideModel || mgrPrefs.useSCPCTypingMode || fixOrder { if !mgrPrefs.fetchSuggestionsFromUserOverrideModel || mgrPrefs.useSCPCTypingMode || fixOrder {
return arrCandidates return arrCandidates.map { ($0.key, $0.value) }
} }
let arrSuggestedUnigrams: [Megrez.Unigram] = fetchSuggestedCandidates().stableSort { $0.score > $1.score } let arrSuggestedUnigrams: [Megrez.Unigram] = fetchSuggestedCandidates().stableSort { $0.score > $1.score }
let arrSuggestedCandidates: [String] = arrSuggestedUnigrams.map(\.keyValue.value) let arrSuggestedCandidates: [Megrez.KeyValuePaired] = arrSuggestedUnigrams.map(\.keyValue)
arrCandidates = arrSuggestedCandidates.filter { arrCandidates.contains($0) } + arrCandidates arrCandidates = arrSuggestedCandidates.filter { arrCandidates.contains($0) } + arrCandidates
arrCandidates = arrCandidates.deduplicate arrCandidates = arrCandidates.deduplicate
arrCandidates = arrCandidates.stableSort { $0.count > $1.count } arrCandidates = arrCandidates.stableSort { $0.key.split(separator: "-").count > $1.key.split(separator: "-").count }
return arrCandidates return arrCandidates.map { ($0.key, $0.value) }
} }
/// 向半衰引擎詢問可能的選字建議。拿到的結果會是一個單元圖陣列。 /// 向半衰引擎詢問可能的選字建議。拿到的結果會是一個單元圖陣列。
@ -284,17 +265,17 @@ class KeyHandler {
if mgrPrefs.useSCPCTypingMode { return } if mgrPrefs.useSCPCTypingMode { return }
/// 如果這個開關沒打開的話，直接放棄執行這個函式。 /// 如果這個開關沒打開的話，直接放棄執行這個函式。
if !mgrPrefs.fetchSuggestionsFromUserOverrideModel { return } if !mgrPrefs.fetchSuggestionsFromUserOverrideModel { return }
/// 先就當前上下文讓半衰引擎重新生成 trigram 索引鍵。 /// 先就當前上下文讓半衰引擎重新生成三元圖索引鍵。
let overrideValue = fetchSuggestedCandidates().first?.keyValue.value ?? "" let overrideValue = fetchSuggestedCandidates().first?.keyValue.value ?? ""
/// 再拿著索引鍵去問半衰模組有沒有選字建議。有的話就遵循之、讓天權星引擎對指定節錨下的節點複寫權重。 /// 再拿著索引鍵去問半衰模組有沒有選字建議。有的話就遵循之、讓天權星引擎對指定節錨下的節點複寫權重。
if !overrideValue.isEmpty { if !overrideValue.isEmpty {
IME.prtDebugIntel( IME.prtDebugIntel(
"UOM: Suggestion retrieved, overriding the node score of the selected candidate.") "UOM: Suggestion retrieved, overriding the node score of the selected candidate.")
compositor.grid.overrideNodeScoreForSelectedCandidate( compositor.overrideNodeScoreForSelectedCandidate(
location: min(actualCandidateCursorIndex + (mgrPrefs.useRearCursorMode ? 1 : 0), compositorLength), location: min(actualCandidateCursor + (mgrPrefs.useRearCursorMode ? 1 : 0), compositorLength),
value: overrideValue, value: overrideValue,
overridingScore: findHighestScore(nodes: rawAnchorsOfNodes, epsilon: kEpsilon) overridingScore: findHighestScore(nodeAnchors: rawAnchorsOfNodes, epsilon: kEpsilon)
) )
} else { } else {
IME.prtDebugIntel("UOM: Blank suggestion retrieved, dismissing.") IME.prtDebugIntel("UOM: Blank suggestion retrieved, dismissing.")
@ -306,14 +287,8 @@ class KeyHandler {
/// - nodes: 給定的節錨陣列。 /// - nodes: 給定的節錨陣列。
/// - epsilon: 半衰模組的衰減指數。 /// - epsilon: 半衰模組的衰減指數。
/// - Returns: 尋獲的最高權重數值。 /// - Returns: 尋獲的最高權重數值。
func findHighestScore(nodes: [Megrez.NodeAnchor], epsilon: Double) -> Double { func findHighestScore(nodeAnchors: [Megrez.NodeAnchor], epsilon: Double) -> Double {
var highestScore: Double = 0 return nodeAnchors.map(\.node.highestUnigramScore).max() ?? 0 + epsilon
for currentAnchor in nodes {
if let theNode = currentAnchor.node {
highestScore = max(theNode.highestUnigramScore, highestScore)
}
}
return highestScore + epsilon
} }
// MARK: - Extracted methods and functions (Tekkon). // MARK: - Extracted methods and functions (Tekkon).
@ -359,41 +334,6 @@ class KeyHandler {
composer.clear() composer.clear()
} }
/// 用於網頁 Ruby 的注音需要按照教科書印刷的方式來顯示輕聲。該函式負責這種轉換。
/// - Parameters:
/// - target: 要拿來做轉換處理的讀音鏈。
/// - newSeparator: 新的讀音分隔符。
/// - Returns: 經過轉換處理的讀音鏈。
func cnvZhuyinKeyToTextbookReading(target: String, newSeparator: String = "-") -> String {
var arrReturn: [String] = []
for neta in target.split(separator: "-") {
var newString = String(neta)
if String(neta.reversed()[0]) == "˙" {
newString = String(neta.dropLast())
newString.insert("˙", at: newString.startIndex)
}
arrReturn.append(newString)
}
return arrReturn.joined(separator: newSeparator)
}
/// 用於網頁 Ruby 的拼音的陰平必須顯示，這裡處理一下。
/// - Parameters:
/// - target: 要拿來做轉換處理的讀音鏈。
/// - newSeparator: 新的讀音分隔符。
/// - Returns: 經過轉換處理的讀音鏈。
func restoreToneOneInZhuyinKey(target: String, newSeparator: String = "-") -> String {
var arrReturn: [String] = []
for neta in target.split(separator: "-") {
var newNeta = String(neta)
if !"ˊˇˋ˙".contains(String(neta.reversed()[0])), !neta.contains("_") {
newNeta += "1"
}
arrReturn.append(newNeta)
}
return arrReturn.joined(separator: newSeparator)
}
// MARK: - Extracted methods and functions (Megrez). // MARK: - Extracted methods and functions (Megrez).
/// 組字器是否為空。 /// 組字器是否為空。
@ -404,8 +344,8 @@ class KeyHandler {
/// 警告：不要對游標前置風格使用 nodesCrossing，否則會導致游標行為與 macOS 內建注音輸入法不一致。 /// 警告：不要對游標前置風格使用 nodesCrossing，否則會導致游標行為與 macOS 內建注音輸入法不一致。
/// 微軟新注音輸入法的游標後置風格也是不允許 nodeCrossing 的。 /// 微軟新注音輸入法的游標後置風格也是不允許 nodeCrossing 的。
mgrPrefs.useRearCursorMode mgrPrefs.useRearCursorMode
? compositor.grid.nodesBeginningAt(location: actualCandidateCursorIndex) ? compositor.nodesBeginningAt(location: actualCandidateCursor)
: compositor.grid.nodesEndingAt(location: actualCandidateCursorIndex) : compositor.nodesEndingAt(location: actualCandidateCursor)
} }
/// 將輸入法偏好設定同步至語言模組內。 /// 將輸入法偏好設定同步至語言模組內。
@ -431,13 +371,13 @@ class KeyHandler {
/// 在組字器的給定游標位置內插入讀音。 /// 在組字器的給定游標位置內插入讀音。
func insertToCompositorAtCursor(reading: String) { func insertToCompositorAtCursor(reading: String) {
compositor.insertReadingAtCursor(reading: reading) compositor.insertReading(reading)
} }
/// 組字器的游標位置。 /// 組字器的游標位置。
var compositorCursorIndex: Int { var compositorCursorIndex: Int {
get { compositor.cursorIndex } get { compositor.cursor }
set { compositor.cursorIndex = newValue } set { compositor.cursor = newValue }
} }
/// 組字器的目前的長度。 /// 組字器的目前的長度。
@ -449,13 +389,43 @@ class KeyHandler {
/// ///
/// 在威注音的術語體系當中，「與文字輸入方向相反的方向」為向後（Rear）。 /// 在威注音的術語體系當中，「與文字輸入方向相反的方向」為向後（Rear）。
func deleteCompositorReadingAtTheRearOfCursor() { func deleteCompositorReadingAtTheRearOfCursor() {
compositor.deleteReadingAtTheRearOfCursor() compositor.dropReading(direction: .rear)
} }
/// 在組字器內，朝著往文字輸入方向、砍掉一個與游標相鄰的讀音。 /// 在組字器內，朝著往文字輸入方向、砍掉一個與游標相鄰的讀音。
/// ///
/// 在威注音的術語體系當中，「文字輸入方向」為向前（Front）。 /// 在威注音的術語體系當中，「文字輸入方向」為向前（Front）。
func deleteCompositorReadingToTheFrontOfCursor() { func deleteCompositorReadingToTheFrontOfCursor() {
compositor.deleteReadingToTheFrontOfCursor() compositor.dropReading(direction: .front)
}
/// 獲取指定游標位置的鍵值長度。
/// - Returns: 指定游標位置的鍵值長度。
var keyLengthAtCurrentIndex: Int {
walkedAnchors[compositorCursorIndex].node.key.split(separator: "-").count
}
var nextPhrasePosition: Int {
var nextPosition = 0
for theAnchor in walkedAnchors {
if nextPosition > actualCandidateCursor { break }
nextPosition += theAnchor.spanLength
}
return min(nextPosition, compositorLength)
}
/// 生成標點符號索引鍵。
/// - Parameter input: 輸入的按鍵訊號。
/// - Returns: 生成的標點符號索引鍵。
func generatePunctuationNamePrefix(withKeyCondition input: InputSignal) -> String {
if mgrPrefs.halfWidthPunctuationEnabled {
return "_half_punctuation_"
}
switch (input.isControlHold, input.isOptionHold) {
case (true, true): return "_alt_ctrl_punctuation_"
case (true, false): return "_ctrl_punctuation_"
case (false, true): return "_alt_punctuation_"
case (false, false): return "_punctuation_"
}
} }
} }

82
Source/Modules/ControllerModules/KeyHandler_HandleCandidate.swift
View File

@ -154,18 +154,14 @@ extension KeyHandler {
if input.isLeft { if input.isLeft {
switch ctlCandidateCurrent.currentLayout { switch ctlCandidateCurrent.currentLayout {
case .horizontal: case .horizontal:
do { if !ctlCandidateCurrent.highlightPreviousCandidate() {
if !ctlCandidateCurrent.highlightPreviousCandidate() { IME.prtDebugIntel("1145148D")
IME.prtDebugIntel("1145148D") errorCallback()
errorCallback()
}
} }
case .vertical: case .vertical:
do { if !ctlCandidateCurrent.showPreviousPage() {
if !ctlCandidateCurrent.showPreviousPage() { IME.prtDebugIntel("1919810D")
IME.prtDebugIntel("1919810D") errorCallback()
errorCallback()
}
} }
} }
return true return true
@ -187,18 +183,14 @@ extension KeyHandler {
if input.isRight { if input.isRight {
switch ctlCandidateCurrent.currentLayout { switch ctlCandidateCurrent.currentLayout {
case .horizontal: case .horizontal:
do { if !ctlCandidateCurrent.highlightNextCandidate() {
if !ctlCandidateCurrent.highlightNextCandidate() { IME.prtDebugIntel("9B65138D")
IME.prtDebugIntel("9B65138D") errorCallback()
errorCallback()
}
} }
case .vertical: case .vertical:
do { if !ctlCandidateCurrent.showNextPage() {
if !ctlCandidateCurrent.showNextPage() { IME.prtDebugIntel("9244908D")
IME.prtDebugIntel("9244908D") errorCallback()
errorCallback()
}
} }
} }
return true return true
@ -220,18 +212,14 @@ extension KeyHandler {
if input.isUp { if input.isUp {
switch ctlCandidateCurrent.currentLayout { switch ctlCandidateCurrent.currentLayout {
case .horizontal: case .horizontal:
do { if !ctlCandidateCurrent.showPreviousPage() {
if !ctlCandidateCurrent.showPreviousPage() { IME.prtDebugIntel("9B614524")
IME.prtDebugIntel("9B614524") errorCallback()
errorCallback()
}
} }
case .vertical: case .vertical:
do { if !ctlCandidateCurrent.highlightPreviousCandidate() {
if !ctlCandidateCurrent.highlightPreviousCandidate() { IME.prtDebugIntel("ASD9908D")
IME.prtDebugIntel("ASD9908D") errorCallback()
errorCallback()
}
} }
} }
return true return true
@ -242,18 +230,14 @@ extension KeyHandler {
if input.isDown { if input.isDown {
switch ctlCandidateCurrent.currentLayout { switch ctlCandidateCurrent.currentLayout {
case .horizontal: case .horizontal:
do { if !ctlCandidateCurrent.showNextPage() {
if !ctlCandidateCurrent.showNextPage() { IME.prtDebugIntel("92B990DD")
IME.prtDebugIntel("92B990DD") errorCallback()
errorCallback()
}
} }
case .vertical: case .vertical:
do { if !ctlCandidateCurrent.highlightNextCandidate() {
if !ctlCandidateCurrent.highlightNextCandidate() { IME.prtDebugIntel("6B99908D")
IME.prtDebugIntel("6B99908D") errorCallback()
errorCallback()
}
} }
} }
return true return true
@ -274,7 +258,7 @@ extension KeyHandler {
// MARK: End Key // MARK: End Key
var candidates: [String]! var candidates: [(String, String)]!
if let state = state as? InputState.ChoosingCandidate { if let state = state as? InputState.ChoosingCandidate {
candidates = state.candidates candidates = state.candidates
@ -334,22 +318,8 @@ extension KeyHandler {
/// - 是否是針對當前注音排列/拼音輸入種類專門提供的標點符號。 /// - 是否是針對當前注音排列/拼音輸入種類專門提供的標點符號。
/// - 是否是需要摁修飾鍵才可以輸入的那種標點符號。 /// - 是否是需要摁修飾鍵才可以輸入的那種標點符號。
var punctuationNamePrefix = "" let punctuationNamePrefix: String = generatePunctuationNamePrefix(withKeyCondition: input)
if input.isOptionHold && !input.isControlHold {
punctuationNamePrefix = "_alt_punctuation_"
} else if input.isControlHold && !input.isOptionHold {
punctuationNamePrefix = "_ctrl_punctuation_"
} else if input.isControlHold && input.isOptionHold {
punctuationNamePrefix = "_alt_ctrl_punctuation_"
} else if mgrPrefs.halfWidthPunctuationEnabled {
punctuationNamePrefix = "_half_punctuation_"
} else {
punctuationNamePrefix = "_punctuation_"
}
let parser = currentMandarinParser let parser = currentMandarinParser
let arrCustomPunctuations: [String] = [ let arrCustomPunctuations: [String] = [
punctuationNamePrefix, parser, String(format: "%c", CChar(charCode)), punctuationNamePrefix, parser, String(format: "%c", CChar(charCode)),
] ]

17
Source/Modules/ControllerModules/KeyHandler_HandleInput.swift
View File

@ -225,7 +225,7 @@ extension KeyHandler {
) )
if choosingCandidates.candidates.count == 1 { if choosingCandidates.candidates.count == 1 {
clear() clear()
let text: String = choosingCandidates.candidates.first ?? "" let text: String = choosingCandidates.candidates.first?.1 ?? ""
stateCallback(InputState.Committing(textToCommit: text)) stateCallback(InputState.Committing(textToCommit: text))
if !mgrPrefs.associatedPhrasesEnabled { if !mgrPrefs.associatedPhrasesEnabled {
@ -414,20 +414,7 @@ extension KeyHandler {
/// - 是否是針對當前注音排列/拼音輸入種類專門提供的標點符號。 /// - 是否是針對當前注音排列/拼音輸入種類專門提供的標點符號。
/// - 是否是需要摁修飾鍵才可以輸入的那種標點符號。 /// - 是否是需要摁修飾鍵才可以輸入的那種標點符號。
var punctuationNamePrefix = "" let punctuationNamePrefix: String = generatePunctuationNamePrefix(withKeyCondition: input)
if input.isOptionHold && !input.isControlHold {
punctuationNamePrefix = "_alt_punctuation_"
} else if input.isControlHold && !input.isOptionHold {
punctuationNamePrefix = "_ctrl_punctuation_"
} else if input.isControlHold && input.isOptionHold {
punctuationNamePrefix = "_alt_ctrl_punctuation_"
} else if mgrPrefs.halfWidthPunctuationEnabled {
punctuationNamePrefix = "_half_punctuation_"
} else {
punctuationNamePrefix = "_punctuation_"
}
let parser = currentMandarinParser let parser = currentMandarinParser
let arrCustomPunctuations: [String] = [ let arrCustomPunctuations: [String] = [
punctuationNamePrefix, parser, String(format: "%c", CChar(charCode)), punctuationNamePrefix, parser, String(format: "%c", CChar(charCode)),

103
Source/Modules/ControllerModules/KeyHandler_States.swift
View File

@ -45,15 +45,15 @@ extension KeyHandler {
/// 所以在這裡必須做糾偏處理。因為在用 Swift，所以可以用「.utf16」取代「NSString.length()」。 /// 所以在這裡必須做糾偏處理。因為在用 Swift，所以可以用「.utf16」取代「NSString.length()」。
/// 這樣就可以免除不必要的類型轉換。 /// 這樣就可以免除不必要的類型轉換。
for theAnchor in walkedAnchors { for theAnchor in walkedAnchors {
guard let theNode = theAnchor.node else { continue } let theNode = theAnchor.node
let strNodeValue = theNode.currentKeyValue.value let strNodeValue = theNode.currentPair.value
composingBuffer += strNodeValue composingBuffer += strNodeValue
let arrSplit: [String] = Array(strNodeValue).map { String($0) } let arrSplit: [String] = Array(strNodeValue).map { String($0) }
let codepointCount = arrSplit.count let codepointCount = arrSplit.count
/// 藉下述步驟重新將「可見游標位置」對齊至「組字器內的游標所在的讀音位置」。 /// 藉下述步驟重新將「可見游標位置」對齊至「組字器內的游標所在的讀音位置」。
/// 每個節錨（NodeAnchor）都有自身的幅位長度（spanningLength），可以用來 /// 每個節錨（NodeAnchor）都有自身的幅位長度（spanningLength），可以用來
/// 累加、以此為依據，來校正「可見游標位置」。 /// 累加、以此為依據，來校正「可見游標位置」。
let spanningLength: Int = theAnchor.spanningLength let spanningLength: Int = theAnchor.spanLength
if readingCursorIndex + spanningLength <= compositorCursorIndex { if readingCursorIndex + spanningLength <= compositorCursorIndex {
composedStringCursorIndex += strNodeValue.utf16.count composedStringCursorIndex += strNodeValue.utf16.count
readingCursorIndex += spanningLength readingCursorIndex += spanningLength
@ -81,10 +81,20 @@ extension KeyHandler {
case 0: case 0:
tooltipParameterRef[1] = compositor.readings[compositorCursorIndex] tooltipParameterRef[1] = compositor.readings[compositorCursorIndex]
default: default:
do { tooltipParameterRef[0] = compositor.readings[compositorCursorIndex - 1]
tooltipParameterRef[0] = compositor.readings[compositorCursorIndex - 1] tooltipParameterRef[1] = compositor.readings[compositorCursorIndex]
tooltipParameterRef[1] = compositor.readings[compositorCursorIndex] }
} /// 注音轉拼音
for (i, _) in tooltipParameterRef.enumerated() {
if tooltipParameterRef[i].isEmpty { continue }
if tooltipParameterRef[i].contains("_") { continue }
if mgrPrefs.showHanyuPinyinInCompositionBuffer { // 恢復陰平標記->注音轉拼音->轉教科書式標調
tooltipParameterRef[i] = Tekkon.restoreToneOneInZhuyinKey(target: tooltipParameterRef[i])
tooltipParameterRef[i] = Tekkon.cnvPhonaToHanyuPinyin(target: tooltipParameterRef[i])
tooltipParameterRef[i] = Tekkon.cnvHanyuPinyinToTextbookStyle(target: tooltipParameterRef[i])
} else {
tooltipParameterRef[i] = Tekkon.cnvZhuyinChainToTextbookReading(target: tooltipParameterRef[i])
}
} }
} }
} }
@ -318,8 +328,8 @@ extension KeyHandler {
) )
if candidateState.candidates.count == 1 { if candidateState.candidates.count == 1 {
clear() clear()
if let strtextToCommit: String = candidateState.candidates.first { if let candidateToCommit: (String, String) = candidateState.candidates.first {
stateCallback(InputState.Committing(textToCommit: strtextToCommit)) stateCallback(InputState.Committing(textToCommit: candidateToCommit.1))
stateCallback(InputState.Empty()) stateCallback(InputState.Empty())
} else { } else {
stateCallback(candidateState) stateCallback(candidateState)
@ -364,7 +374,7 @@ extension KeyHandler {
var composingBuffer = currentReadings.joined(separator: "-") var composingBuffer = currentReadings.joined(separator: "-")
if mgrPrefs.inlineDumpPinyinInLieuOfZhuyin { if mgrPrefs.inlineDumpPinyinInLieuOfZhuyin {
composingBuffer = restoreToneOneInZhuyinKey(target: composingBuffer) // 恢復陰平標記 composingBuffer = Tekkon.restoreToneOneInZhuyinKey(target: composingBuffer) // 恢復陰平標記
composingBuffer = Tekkon.cnvPhonaToHanyuPinyin(target: composingBuffer) // 注音轉拼音 composingBuffer = Tekkon.cnvPhonaToHanyuPinyin(target: composingBuffer) // 注音轉拼音
} }
@ -394,22 +404,20 @@ extension KeyHandler {
var composed = "" var composed = ""
for theAnchor in walkedAnchors { for node in walkedAnchors.map(\.node) {
if let node = theAnchor.node { var key = node.key
var key = node.key if mgrPrefs.inlineDumpPinyinInLieuOfZhuyin {
if mgrPrefs.inlineDumpPinyinInLieuOfZhuyin { key = Tekkon.restoreToneOneInZhuyinKey(target: key) // 恢復陰平標記
key = restoreToneOneInZhuyinKey(target: key) // 恢復陰平標記 key = Tekkon.cnvPhonaToHanyuPinyin(target: key) // 注音轉拼音
key = Tekkon.cnvPhonaToHanyuPinyin(target: key) // 注音轉拼音 key = Tekkon.cnvHanyuPinyinToTextbookStyle(target: key) // 轉教科書式標調
key = Tekkon.cnvHanyuPinyinToTextbookStyle(target: key) // 轉教科書式標調 key = key.replacingOccurrences(of: "-", with: " ")
key = key.replacingOccurrences(of: "-", with: " ") } else {
} else { key = Tekkon.cnvZhuyinChainToTextbookReading(target: key, newSeparator: " ")
key = cnvZhuyinKeyToTextbookReading(target: key, newSeparator: " ")
}
let value = node.currentKeyValue.value
// 不要給標點符號等特殊元素加注音
composed += key.contains("_") ? value : "<ruby>\(value)<rp>(</rp><rt>\(key)</rt><rp>)</rp></ruby>"
} }
let value = node.currentPair.value
// 不要給標點符號等特殊元素加注音
composed += key.contains("_") ? value : "<ruby>\(value)<rp>(</rp><rt>\(key)</rt><rp>)</rp></ruby>"
} }
clear() clear()
@ -651,6 +659,18 @@ extension KeyHandler {
errorCallback() errorCallback()
stateCallback(state) stateCallback(state)
} }
} else if input.isOptionHold {
if input.isControlHold {
return handleEnd(state: state, stateCallback: stateCallback, errorCallback: errorCallback)
}
// 游標跳轉動作無論怎樣都會執行，但如果出了執行失敗的結果的話則觸發報錯流程。
if !compositor.jumpCursorBySpan(to: .front) {
IME.prtDebugIntel("33C3B580")
errorCallback()
stateCallback(state)
return true
}
stateCallback(buildInputtingState)
} else { } else {
if compositorCursorIndex < compositorLength { if compositorCursorIndex < compositorLength {
compositorCursorIndex += 1 compositorCursorIndex += 1
@ -707,6 +727,18 @@ extension KeyHandler {
errorCallback() errorCallback()
stateCallback(state) stateCallback(state)
} }
} else if input.isOptionHold {
if input.isControlHold {
return handleHome(state: state, stateCallback: stateCallback, errorCallback: errorCallback)
}
// 游標跳轉動作無論怎樣都會執行，但如果出了執行失敗的結果的話則觸發報錯流程。
if !compositor.jumpCursorBySpan(to: .rear) {
IME.prtDebugIntel("8D50DD9E")
errorCallback()
stateCallback(state)
return true
}
stateCallback(buildInputtingState)
} else { } else {
if compositorCursorIndex > 0 { if compositorCursorIndex > 0 {
compositorCursorIndex -= 1 compositorCursorIndex -= 1
@ -763,26 +795,21 @@ extension KeyHandler {
var length = 0 var length = 0
var currentAnchor = Megrez.NodeAnchor() var currentAnchor = Megrez.NodeAnchor()
let cursorIndex = min( let cursorIndex = min(
actualCandidateCursorIndex + (mgrPrefs.useRearCursorMode ? 1 : 0), compositorLength actualCandidateCursor + (mgrPrefs.useRearCursorMode ? 1 : 0), compositorLength
) )
for anchor in walkedAnchors { for anchor in walkedAnchors {
length += anchor.spanningLength length += anchor.spanLength
if length >= cursorIndex { if length >= cursorIndex {
currentAnchor = anchor currentAnchor = anchor
break break
} }
} }
guard let currentNode = currentAnchor.node else { let currentNode = currentAnchor.node
IME.prtDebugIntel("4F2DEC2F") let currentPaired: Megrez.KeyValuePaired = currentNode.currentPair
errorCallback()
return true
}
let currentValue = currentNode.currentKeyValue.value
var currentIndex = 0 var currentIndex = 0
if currentNode.score < currentNode.kSelectedCandidateScore { if currentNode.score < Megrez.Node.kSelectedCandidateScore {
/// 只要是沒有被使用者手動選字過的（節錨下的）節點， /// 只要是沒有被使用者手動選字過的（節錨下的）節點，
/// 就從第一個候選字詞開始，這樣使用者在敲字時就會優先匹配 /// 就從第一個候選字詞開始，這樣使用者在敲字時就會優先匹配
/// 那些字詞長度不小於 2 的單元圖。換言之，如果使用者敲了兩個 /// 那些字詞長度不小於 2 的單元圖。換言之，如果使用者敲了兩個
@ -791,14 +818,14 @@ extension KeyHandler {
/// 選中的話，則使用者可以直接摁下本函式對應的按鍵來輪替候選字即可。 /// 選中的話，則使用者可以直接摁下本函式對應的按鍵來輪替候選字即可。
/// （預設情況下是 (Shift+)Tab 來做正 (反) 向切換，但也可以用 /// （預設情況下是 (Shift+)Tab 來做正 (反) 向切換，但也可以用
/// Shift(+CMD)+Space 來切換、以應對臉書綁架 Tab 鍵的情況。 /// Shift(+CMD)+Space 來切換、以應對臉書綁架 Tab 鍵的情況。
if candidates[0] == currentValue { if candidates[0].0 == currentPaired.key, candidates[0].1 == currentPaired.value {
/// 如果第一個候選字詞是當前節點的候選字詞的值的話， /// 如果第一個候選字詞是當前節點的候選字詞的值的話，
/// 那就切到下一個（或上一個，也就是最後一個）候選字詞。 /// 那就切到下一個（或上一個，也就是最後一個）候選字詞。
currentIndex = reverseModifier ? candidates.count - 1 : 1 currentIndex = reverseModifier ? candidates.count - 1 : 1
} }
} else { } else {
for candidate in candidates { for candidate in candidates {
if candidate == currentValue { if candidate.0 == currentPaired.key, candidate.1 == currentPaired.value {
if reverseModifier { if reverseModifier {
if currentIndex == 0 { if currentIndex == 0 {
currentIndex = candidates.count - 1 currentIndex = candidates.count - 1
@ -818,7 +845,7 @@ extension KeyHandler {
currentIndex = 0 currentIndex = 0
} }
fixNode(value: candidates[currentIndex], respectCursorPushing: false) fixNode(candidate: candidates[currentIndex], respectCursorPushing: false)
stateCallback(buildInputtingState) stateCallback(buildInputtingState)
return true return true

50
Source/Modules/ControllerModules/SyllableComposer.swift
View File

@ -236,18 +236,11 @@ public struct Tekkon {
public func getComposition(isHanyuPinyin: Bool = false, isTextBookStyle: Bool = false) -> String { public func getComposition(isHanyuPinyin: Bool = false, isTextBookStyle: Bool = false) -> String {
switch isHanyuPinyin { switch isHanyuPinyin {
case false: // 注音輸出的場合 case false: // 注音輸出的場合
var valReturnZhuyin = value.replacingOccurrences(of: " ", with: "") let valReturnZhuyin = value.replacingOccurrences(of: " ", with: "")
if isTextBookStyle, valReturnZhuyin.contains("˙") { return isTextBookStyle ? cnvZhuyinChainToTextbookReading(target: valReturnZhuyin) : valReturnZhuyin
valReturnZhuyin = String(valReturnZhuyin.dropLast())
valReturnZhuyin.insert("˙", at: valReturnZhuyin.startIndex)
}
return valReturnZhuyin
case true: // 拼音輸出的場合 case true: // 拼音輸出的場合
var valReturnPinyin = Tekkon.cnvPhonaToHanyuPinyin(target: value) let valReturnPinyin = Tekkon.cnvPhonaToHanyuPinyin(target: value)
if isTextBookStyle { return isTextBookStyle ? Tekkon.cnvHanyuPinyinToTextbookStyle(target: valReturnPinyin) : valReturnPinyin
valReturnPinyin = Tekkon.cnvHanyuPinyinToTextbookStyle(target: valReturnPinyin)
}
return valReturnPinyin
} }
} }
@ -852,6 +845,41 @@ public struct Tekkon {
return targetConverted return targetConverted
} }
/// 該函式負責將注音轉為教科書印刷的方式（先寫輕聲）。
/// - Parameters:
/// - target: 要拿來做轉換處理的讀音鏈，以英文減號來分隔每個讀音。
/// - newSeparator: 新的讀音分隔符。
/// - Returns: 經過轉換處理的讀音鏈。
static func cnvZhuyinChainToTextbookReading(target: String, newSeparator: String = "-") -> String {
var arrReturn: [String] = []
for neta in target.split(separator: "-") {
var newString = String(neta)
if String(neta.reversed()[0]) == "˙" {
newString = String(neta.dropLast())
newString.insert("˙", at: newString.startIndex)
}
arrReturn.append(newString)
}
return arrReturn.joined(separator: newSeparator)
}
/// 該函式用來恢復注音當中的陰平聲調，恢復之後會以「1」表示陰平。
/// - Parameters:
/// - target: 要拿來做轉換處理的讀音鏈，以英文減號來分隔每個讀音。
/// - newSeparator: 新的讀音分隔符。
/// - Returns: 經過轉換處理的讀音鏈。
static func restoreToneOneInZhuyinKey(target: String, newSeparator: String = "-") -> String {
var arrReturn: [String] = []
for neta in target.split(separator: "-") {
var newNeta = String(neta)
if !"ˊˇˋ˙".contains(String(neta.reversed()[0])), !neta.contains("_") {
newNeta += "1"
}
arrReturn.append(newNeta)
}
return arrReturn.joined(separator: newSeparator)
}
/// 原始轉換對照表資料貯存專用佇列（數字標調格式） /// 原始轉換對照表資料貯存專用佇列（數字標調格式）
static let arrPhonaToHanyuPinyin = [ // 排序很重要。先處理最長的，再處理短的。不然會出亂子。 static let arrPhonaToHanyuPinyin = [ // 排序很重要。先處理最長的，再處理短的。不然會出亂子。
[" ", "1"], ["ˊ", "2"], ["ˇ", "3"], ["ˋ", "4"], ["˙", "5"], [" ", "1"], ["ˊ", "2"], ["ˇ", "3"], ["ˋ", "4"], ["˙", "5"],

10
Source/Modules/ControllerModules/ctlInputMethod_Delegates.swift
View File

@ -81,7 +81,7 @@ extension ctlInputMethod: ctlCandidateDelegate {
} }
func ctlCandidate(_ controller: ctlCandidate, candidateAtIndex index: Int) func ctlCandidate(_ controller: ctlCandidate, candidateAtIndex index: Int)
-> String -> (String, String)
{ {
_ = controller // 防止格式整理工具毀掉與此對應的參數。 _ = controller // 防止格式整理工具毀掉與此對應的參數。
if let state = state as? InputState.ChoosingCandidate { if let state = state as? InputState.ChoosingCandidate {
@ -89,7 +89,7 @@ extension ctlInputMethod: ctlCandidateDelegate {
} else if let state = state as? InputState.AssociatedPhrases { } else if let state = state as? InputState.AssociatedPhrases {
return state.candidates[index] return state.candidates[index]
} }
return "" return ("", "")
} }
func ctlCandidate(_ controller: ctlCandidate, didSelectCandidateAtIndex index: Int) { func ctlCandidate(_ controller: ctlCandidate, didSelectCandidateAtIndex index: Int) {
@ -112,7 +112,7 @@ extension ctlInputMethod: ctlCandidateDelegate {
if let state = state as? InputState.ChoosingCandidate { if let state = state as? InputState.ChoosingCandidate {
let selectedValue = state.candidates[index] let selectedValue = state.candidates[index]
keyHandler.fixNode(value: selectedValue, respectCursorPushing: true) keyHandler.fixNode(candidate: selectedValue, respectCursorPushing: true)
let inputting = keyHandler.buildInputtingState let inputting = keyHandler.buildInputtingState
@ -137,10 +137,10 @@ extension ctlInputMethod: ctlCandidateDelegate {
if let state = state as? InputState.AssociatedPhrases { if let state = state as? InputState.AssociatedPhrases {
let selectedValue = state.candidates[index] let selectedValue = state.candidates[index]
handle(state: InputState.Committing(textToCommit: selectedValue)) handle(state: InputState.Committing(textToCommit: selectedValue.1))
if mgrPrefs.associatedPhrasesEnabled, if mgrPrefs.associatedPhrasesEnabled,
let associatePhrases = keyHandler.buildAssociatePhraseState( let associatePhrases = keyHandler.buildAssociatePhraseState(
withKey: selectedValue, isTypingVertical: state.isTypingVertical withKey: selectedValue.1, isTypingVertical: state.isTypingVertical
), !associatePhrases.candidates.isEmpty ), !associatePhrases.candidates.isEmpty
{ {
handle(state: associatePhrases) handle(state: associatePhrases)

8
Source/Modules/ControllerModules/ctlInputMethod_HandleDisplay.swift
View File

@ -55,7 +55,7 @@ extension ctlInputMethod {
return false return false
} }
var isCandidateWindowVertical: Bool { var isCandidateWindowVertical: Bool {
var candidates: [String] = [] var candidates: [(String, String)] = .init()
if let state = state as? InputState.ChoosingCandidate { if let state = state as? InputState.ChoosingCandidate {
candidates = state.candidates candidates = state.candidates
} else if let state = state as? InputState.AssociatedPhrases { } else if let state = state as? InputState.AssociatedPhrases {
@ -63,13 +63,11 @@ extension ctlInputMethod {
} }
if isTypingVertical { return true } if isTypingVertical { return true }
// 以上是通用情形。接下來決定橫排輸入時是否使用縱排選字窗。 // 以上是通用情形。接下來決定橫排輸入時是否使用縱排選字窗。
candidates.sort { // 因為在拿候選字陣列時已經排序過了，所以這裡不用再多排序。
$0.count > $1.count
}
// 測量每頁顯示候選字的累計總長度。如果太長的話就強制使用縱排候選字窗。 // 測量每頁顯示候選字的累計總長度。如果太長的話就強制使用縱排候選字窗。
// 範例：「屬實牛逼」（會有一大串各種各樣的「鼠食牛Beer」的 emoji）。 // 範例：「屬實牛逼」（會有一大串各種各樣的「鼠食牛Beer」的 emoji）。
let maxCandidatesPerPage = mgrPrefs.candidateKeys.count let maxCandidatesPerPage = mgrPrefs.candidateKeys.count
let firstPageCandidates = candidates[0..<min(maxCandidatesPerPage, candidates.count)] let firstPageCandidates = candidates[0..<min(maxCandidatesPerPage, candidates.count)].map(\.1)
return firstPageCandidates.joined().count > Int(round(Double(maxCandidatesPerPage) * 1.8)) return firstPageCandidates.joined().count > Int(round(Double(maxCandidatesPerPage) * 1.8))
// 上面這句如果是 true 的話，就會是縱排；反之則為橫排。 // 上面這句如果是 true 的話，就會是縱排；反之則為橫排。
} }

11
Source/Modules/ControllerModules/ctlInputMethod_Menu.swift
View File

@ -143,6 +143,10 @@ extension ctlInputMethod {
withTitle: NSLocalizedString("Optimize Memorized Phrases", comment: ""), withTitle: NSLocalizedString("Optimize Memorized Phrases", comment: ""),
action: #selector(removeUnigramsFromUOM(_:)), keyEquivalent: "" action: #selector(removeUnigramsFromUOM(_:)), keyEquivalent: ""
) )
menu.addItem(
withTitle: NSLocalizedString("Clear Memorized Phrases", comment: ""),
action: #selector(clearUOM(_:)), keyEquivalent: ""
)
menu.addItem(NSMenuItem.separator()) // --------------------- menu.addItem(NSMenuItem.separator()) // ---------------------
@ -362,6 +366,13 @@ extension ctlInputMethod {
} }
} }
@objc func clearUOM(_: Any?) {
mgrLangModel.clearUserOverrideModelData(IME.getInputMode())
if NSEvent.modifierFlags.contains(.option) {
mgrLangModel.clearUserOverrideModelData(IME.getInputMode(isReversed: true))
}
}
@objc func showAbout(_: Any?) { @objc func showAbout(_: Any?) {
(NSApp.delegate as? AppDelegate)?.showAbout() (NSApp.delegate as? AppDelegate)?.showAbout()
NSApp.activate(ignoringOtherApps: true) NSApp.activate(ignoringOtherApps: true)

6
Source/Modules/LangModelRelated/LMInstantiator.swift
View File

@ -28,7 +28,7 @@ import Foundation
extension vChewing { extension vChewing {
/// 語言模組副本化模組（LMInstantiator，下稱「LMI」）自身為符合天權星組字引擎內 /// 語言模組副本化模組（LMInstantiator，下稱「LMI」）自身為符合天權星組字引擎內
/// 的 LanguageModelProtocol 協定的模組、統籌且整理來自其它子模組的資料（包括使 /// 的 LangModelProtocol 協定的模組、統籌且整理來自其它子模組的資料（包括使
/// 用者語彙、繪文字模組、語彙濾除表、原廠語言模組等）。 /// 用者語彙、繪文字模組、語彙濾除表、原廠語言模組等）。
/// ///
/// LMI 型別為與輸入法按鍵調度模組直接溝通之唯一語言模組。當組字器開始根據給定的 /// LMI 型別為與輸入法按鍵調度模組直接溝通之唯一語言模組。當組字器開始根據給定的
@ -44,7 +44,7 @@ extension vChewing {
/// ///
/// LMI 會根據需要分別載入原廠語言模組和其他個別的子語言模組。LMI 本身不會記錄這些 /// LMI 會根據需要分別載入原廠語言模組和其他個別的子語言模組。LMI 本身不會記錄這些
/// 語言模組的相關資料的存放位置，僅藉由參數來讀取相關訊息。 /// 語言模組的相關資料的存放位置，僅藉由參數來讀取相關訊息。
public class LMInstantiator: LanguageModelProtocol { public class LMInstantiator: LangModelProtocol {
// 在函式內部用以記錄狀態的開關。 // 在函式內部用以記錄狀態的開關。
public var isPhraseReplacementEnabled = false public var isPhraseReplacementEnabled = false
public var isCNSEnabled = false public var isCNSEnabled = false
@ -256,7 +256,7 @@ extension vChewing {
lmAssociates.hasValuesFor(key: key) lmAssociates.hasValuesFor(key: key)
} }
/// 該函式不起作用，僅用來滿足 LanguageModelProtocol 協定的要求。 /// 該函式不起作用，僅用來滿足 LangModelProtocol 協定的要求。
public func bigramsForKeys(precedingKey _: String, key _: String) -> [Megrez.Bigram] { .init() } public func bigramsForKeys(precedingKey _: String, key _: String) -> [Megrez.Bigram] { .init() }
// MARK: - 核心函式（對內） // MARK: - 核心函式（對內）

30
Source/Modules/LangModelRelated/SubLMs/lmUserOverride.swift
View File

@ -130,13 +130,12 @@ extension vChewing {
func convertKeyFrom( func convertKeyFrom(
walkedAnchors: [Megrez.NodeAnchor], cursorIndex: Int, readingOnly: Bool = false walkedAnchors: [Megrez.NodeAnchor], cursorIndex: Int, readingOnly: Bool = false
) -> String { ) -> String {
let arrEndingPunctuation = ["，", "。", "！", "？", "」", "』", "”", "’"]
let whiteList = "你他妳她祢衪它牠再在" let whiteList = "你他妳她祢衪它牠再在"
var arrNodes: [Megrez.NodeAnchor] = [] var arrNodes: [Megrez.NodeAnchor] = []
var intLength = 0 var intLength = 0
for theNodeAnchor in walkedAnchors { for theNodeAnchor in walkedAnchors {
arrNodes.append(theNodeAnchor) arrNodes.append(theNodeAnchor)
intLength += theNodeAnchor.spanningLength intLength += theNodeAnchor.spanLength
if intLength >= cursorIndex { if intLength >= cursorIndex {
break break
} }
@ -146,9 +145,8 @@ extension vChewing {
arrNodes = Array(arrNodes.reversed()) arrNodes = Array(arrNodes.reversed())
guard let kvCurrent = arrNodes[0].node?.currentKeyValue, let kvCurrent = arrNodes[0].node.currentPair
!arrEndingPunctuation.contains(kvCurrent.value) guard !kvCurrent.key.contains("_") else {
else {
return "" return ""
} }
@ -173,20 +171,18 @@ extension vChewing {
} }
if arrNodes.count >= 2, if arrNodes.count >= 2,
let kvPreviousThisOne = arrNodes[1].node?.currentKeyValue, !kvPrevious.key.contains("_"),
!arrEndingPunctuation.contains(kvPrevious.value),
kvPrevious.key.split(separator: "-").count == kvPrevious.value.count kvPrevious.key.split(separator: "-").count == kvPrevious.value.count
{ {
kvPrevious = kvPreviousThisOne kvPrevious = arrNodes[1].node.currentPair
readingStack = kvPrevious.key + readingStack readingStack = kvPrevious.key + readingStack
} }
if arrNodes.count >= 3, if arrNodes.count >= 3,
let kvAnteriorThisOne = arrNodes[2].node?.currentKeyValue, !kvAnterior.key.contains("_"),
!arrEndingPunctuation.contains(kvAnterior.value),
kvAnterior.key.split(separator: "-").count == kvAnterior.value.count kvAnterior.key.split(separator: "-").count == kvAnterior.value.count
{ {
kvAnterior = kvAnteriorThisOne kvAnterior = arrNodes[2].node.currentPair
readingStack = kvAnterior.key + readingStack readingStack = kvAnterior.key + readingStack
} }
@ -290,6 +286,18 @@ extension vChewing.LMUserOverride {
} }
} }
public func clearData(withURL fileURL: URL) {
mutLRUMap = .init()
mutLRUList = .init()
do {
let nullData = "{}"
try nullData.write(to: fileURL, atomically: false, encoding: .utf8)
} catch {
IME.prtDebugIntel("UOM Error: Unable to clear data. Details: \(error)")
return
}
}
public func saveData(toURL fileURL: URL) { public func saveData(toURL fileURL: URL) {
let encoder = JSONEncoder() let encoder = JSONEncoder()
do { do {

34
Source/Modules/LangModelRelated/mgrLangModel.swift
View File

@ -224,39 +224,60 @@ enum mgrLangModel {
// Swift 的 appendingPathComponent 需要藉由 URL 完成，最後再用 .path 轉為路徑。 // Swift 的 appendingPathComponent 需要藉由 URL 完成，最後再用 .path 轉為路徑。
/// 使用者語彙辭典資料路徑。
/// - Parameter mode: 簡繁體輸入模式。
/// - Returns: 資料路徑（URL）。
static func userPhrasesDataURL(_ mode: InputMode) -> URL { static func userPhrasesDataURL(_ mode: InputMode) -> URL {
let fileName = (mode == InputMode.imeModeCHT) ? "userdata-cht.txt" : "userdata-chs.txt" let fileName = (mode == InputMode.imeModeCHT) ? "userdata-cht.txt" : "userdata-chs.txt"
return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName) return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName)
} }
/// 使用者繪文字符號辭典資料路徑。
/// - Parameter mode: 簡繁體輸入模式。
/// - Returns: 資料路徑（URL）。
static func userSymbolDataURL(_ mode: InputMode) -> URL { static func userSymbolDataURL(_ mode: InputMode) -> URL {
let fileName = (mode == InputMode.imeModeCHT) ? "usersymbolphrases-cht.txt" : "usersymbolphrases-chs.txt" let fileName = (mode == InputMode.imeModeCHT) ? "usersymbolphrases-cht.txt" : "usersymbolphrases-chs.txt"
return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName) return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName)
} }
/// 使用者聯想詞資料路徑。
/// - Parameter mode: 簡繁體輸入模式。
/// - Returns: 資料路徑（URL）。
static func userAssociatesDataURL(_ mode: InputMode) -> URL { static func userAssociatesDataURL(_ mode: InputMode) -> URL {
let fileName = (mode == InputMode.imeModeCHT) ? "associatedPhrases-cht.txt" : "associatedPhrases-chs.txt" let fileName = (mode == InputMode.imeModeCHT) ? "associatedPhrases-cht.txt" : "associatedPhrases-chs.txt"
return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName) return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName)
} }
/// 使用者語彙濾除表資料路徑。
/// - Parameter mode: 簡繁體輸入模式。
/// - Returns: 資料路徑（URL）。
static func userFilteredDataURL(_ mode: InputMode) -> URL { static func userFilteredDataURL(_ mode: InputMode) -> URL {
let fileName = (mode == InputMode.imeModeCHT) ? "exclude-phrases-cht.txt" : "exclude-phrases-chs.txt" let fileName = (mode == InputMode.imeModeCHT) ? "exclude-phrases-cht.txt" : "exclude-phrases-chs.txt"
return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName) return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName)
} }
/// 使用者語彙置換表資料路徑。
/// - Parameter mode: 簡繁體輸入模式。
/// - Returns: 資料路徑（URL）。
static func userReplacementsDataURL(_ mode: InputMode) -> URL { static func userReplacementsDataURL(_ mode: InputMode) -> URL {
let fileName = (mode == InputMode.imeModeCHT) ? "phrases-replacement-cht.txt" : "phrases-replacement-chs.txt" let fileName = (mode == InputMode.imeModeCHT) ? "phrases-replacement-cht.txt" : "phrases-replacement-chs.txt"
return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName) return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName)
} }
/// 使用者波浪符號選單資料路徑。
/// - Returns: 資料路徑（URL）。
static func userSymbolNodeDataURL() -> URL { static func userSymbolNodeDataURL() -> URL {
let fileName = "symbols.dat" let fileName = "symbols.dat"
return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName) return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName)
} }
/// 使用者半衰記憶模組資料的存取頻次特別高，且資料新陳代謝速度快，所以只適合放在預設的使用者資料目錄下。
/// 也就是「~/Library/Application Support/vChewing/」目錄下，且不會隨著使用者辭典目錄的改變而改變。
/// - Parameter mode: 簡繁體輸入模式。
/// - Returns: 資料路徑（URL）。
static func userOverrideModelDataURL(_ mode: InputMode) -> URL { static func userOverrideModelDataURL(_ mode: InputMode) -> URL {
let fileName = (mode == InputMode.imeModeCHT) ? "override-model-data-cht.dat" : "override-model-data-chs.dat" let fileName = (mode == InputMode.imeModeCHT) ? "override-model-data-cht.dat" : "override-model-data-chs.dat"
return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: false)).appendingPathComponent(fileName) return URL(fileURLWithPath: dataFolderPath(isDefaultFolder: true)).appendingPathComponent(fileName)
} }
// MARK: - 檢查具體的使用者語彙檔案是否存在 // MARK: - 檢查具體的使用者語彙檔案是否存在
@ -463,4 +484,15 @@ enum mgrLangModel {
break break
} }
} }
static func clearUserOverrideModelData(_ mode: InputMode = .imeModeNULL) {
switch mode {
case .imeModeCHS:
gUserOverrideModelCHS.clearData(withURL: userOverrideModelDataURL(InputMode.imeModeCHS))
case .imeModeCHT:
gUserOverrideModelCHT.clearData(withURL: userOverrideModelDataURL(InputMode.imeModeCHT))
case .imeModeNULL:
break
}
}
} }

253
Source/Modules/LanguageParsers/Megrez/1_Compositor.swift
View File

@ -25,89 +25,106 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
extension Megrez { extension Megrez {
/// 組字器。 /// 組字器。
public class Compositor { public class Compositor: Grid {
/// 文字輸入方向
public enum TypingDirection { case front, rear }
/// 給被丟掉的節點路徑施加的負權重。 /// 給被丟掉的節點路徑施加的負權重。
private let kDroppedPathScore: Double = -999 private let kDroppedPathScore: Double = -999
/// 該組字器的游標位置。 /// 該組字器的游標位置。
private var mutCursorIndex: Int = 0 public var cursor: Int = 0 { didSet { cursor = max(0, min(cursor, readings.count)) } }
/// 該組字器的讀音陣列。 /// 該組字器的讀音陣列。
private var mutReadings: [String] = [] private(set) var readings: [String] = []
/// 該組字器的軌格。
private var mutGrid: Grid = .init()
/// 該組字器所使用的語言模型。 /// 該組字器所使用的語言模型。
private var mutLM: LanguageModelProtocol private var langModel: LangModelProtocol
/// 允許查詢當前游標位置屬於第幾個幅位座標（從 0 開始算）。
private(set) var cursorRegionMap: [Int: Int] = .init()
private(set) var walkedAnchors: [Megrez.NodeAnchor] = [] // 用以記錄爬過的節錨的陣列
/// 公開：該組字器內可以允許的最大詞長。
public var maxBuildSpanLength: Int { mutGrid.maxBuildSpanLength }
/// 公開：多字讀音鍵當中用以分割漢字讀音的記號，預設為空。 /// 公開：多字讀音鍵當中用以分割漢字讀音的記號，預設為空。
public var joinSeparator: String = "" public var joinSeparator: String = "-"
/// 公開：該組字器的游標位置。
public var cursorIndex: Int {
get { mutCursorIndex }
set { mutCursorIndex = (newValue < 0) ? 0 : min(newValue, mutReadings.count) }
}
/// 公開：該組字器是否為空。
public var isEmpty: Bool { mutGrid.isEmpty }
/// 公開：該組字器的軌格（唯讀）。
public var grid: Grid { mutGrid }
/// 公開：該組字器的長度，也就是內建漢字讀音的數量（唯讀）。 /// 公開：該組字器的長度，也就是內建漢字讀音的數量（唯讀）。
public var length: Int { mutReadings.count } public var length: Int { readings.count }
/// 公開：該組字器的讀音陣列（唯讀）。
public var readings: [String] { mutReadings } /// 按幅位來前後移動游標。
/// - Parameter direction: 移動方向
/// - Returns: 該操作是否順利完成。
@discardableResult public func jumpCursorBySpan(to direction: TypingDirection) -> Bool {
switch direction {
case .front:
if cursor == width { return false }
case .rear:
if cursor == 0 { return false }
}
guard let currentRegion = cursorRegionMap[cursor] else { return false }
let aRegionForward = max(currentRegion - 1, 0)
let currentRegionBorderRear: Int = walkedAnchors[0..<currentRegion].map(\.spanLength).reduce(0, +)
switch cursor {
case currentRegionBorderRear:
switch direction {
case .front:
cursor =
(currentRegion > walkedAnchors.count)
? readings.count : walkedAnchors[0...currentRegion].map(\.spanLength).reduce(0, +)
case .rear:
cursor = walkedAnchors[0..<aRegionForward].map(\.spanLength).reduce(0, +)
}
default:
switch direction {
case .front:
cursor = currentRegionBorderRear + walkedAnchors[currentRegion].spanLength
case .rear:
cursor = currentRegionBorderRear
}
}
return true
}
/// 組字器。 /// 組字器。
/// - Parameters: /// - Parameters:
/// - lm: 語言模型。可以是任何基於 Megrez.LanguageModel 的衍生型別。 /// - lm: 語言模型。可以是任何基於 Megrez.LangModel 的衍生型別。
/// - length: 指定該組字器內可以允許的最大詞長，預設為 10 字。 /// - length: 指定該組字器內可以允許的最大詞長，預設為 10 字。
/// - separator: 多字讀音鍵當中用以分割漢字讀音的記號，預設為空。 /// - separator: 多字讀音鍵當中用以分割漢字讀音的記號，預設為空。
public init(lm: LanguageModelProtocol, length: Int = 10, separator: String = "") { public init(lm: LangModelProtocol, length: Int = 10, separator: String = "-") {
mutLM = lm langModel = lm
mutGrid = .init(spanLength: abs(length)) // 防呆 super.init(spanLength: abs(length)) // 防呆
joinSeparator = separator joinSeparator = separator
} }
/// 組字器自我清空專用函式。 /// 組字器自我清空專用函式。
public func clear() { override public func clear() {
mutCursorIndex = 0 super.clear()
mutReadings.removeAll() cursor = 0
mutGrid.clear() readings.removeAll()
walkedAnchors.removeAll()
} }
/// 在游標位置插入給定的讀音。 /// 在游標位置插入給定的讀音。
/// - Parameters: /// - Parameters:
/// - reading: 要插入的讀音。 /// - reading: 要插入的讀音。
public func insertReadingAtCursor(reading: String) { @discardableResult public func insertReading(_ reading: String) -> Bool {
mutReadings.insert(reading, at: mutCursorIndex) guard !reading.isEmpty, langModel.hasUnigramsFor(key: reading) else { return false }
mutGrid.expandGridByOneAt(location: mutCursorIndex) readings.insert(reading, at: cursor)
build() resizeGridByOneAt(location: cursor, to: .expand)
mutCursorIndex += 1
}
/// 朝著與文字輸入方向相反的方向、砍掉一個與游標相鄰的讀音。
/// 在威注音的術語體系當中，「與文字輸入方向相反的方向」為向後（Rear）。
@discardableResult public func deleteReadingAtTheRearOfCursor() -> Bool {
if mutCursorIndex == 0 {
return false
}
mutReadings.remove(at: mutCursorIndex - 1)
mutCursorIndex -= 1
mutGrid.shrinkGridByOneAt(location: mutCursorIndex)
build() build()
cursor += 1
return true return true
} }
/// 朝著往文字輸入方向、砍掉一個與游標相鄰的讀音。 /// 朝著指定方向砍掉一個與游標相鄰的讀音。
/// 在威注音的術語體系當中，「文字輸入方向」為向前（Front）。 ///
@discardableResult public func deleteReadingToTheFrontOfCursor() -> Bool { /// 在威注音的術語體系當中，「與文字輸入方向相反的方向」為向後（Rear），反之則為向前（Front）。
if mutCursorIndex == mutReadings.count { /// - Parameter direction: 指定方向。
/// - Returns: 該操作是否順利完成。
@discardableResult public func dropReading(direction: TypingDirection) -> Bool {
let isBackSpace = direction == .rear
if cursor == (isBackSpace ? 0 : readings.count) {
return false return false
} }
readings.remove(at: cursor - (isBackSpace ? 1 : 0))
mutReadings.remove(at: mutCursorIndex) cursor -= (isBackSpace ? 1 : 0)
mutGrid.shrinkGridByOneAt(location: mutCursorIndex) resizeGridByOneAt(location: cursor, to: .shrink)
build() build()
return true return true
} }
@ -118,98 +135,84 @@ extension Megrez {
/// 將該位置要溢出的敲字內容遞交之後、再執行這個函式。 /// 將該位置要溢出的敲字內容遞交之後、再執行這個函式。
@discardableResult public func removeHeadReadings(count: Int) -> Bool { @discardableResult public func removeHeadReadings(count: Int) -> Bool {
let count = abs(count) // 防呆 let count = abs(count) // 防呆
if count > length { if count > length { return false }
return false
}
for _ in 0..<count { for _ in 0..<count {
if mutCursorIndex > 0 { cursor = max(cursor - 1, 0)
mutCursorIndex -= 1 if !readings.isEmpty {
} readings.removeFirst()
if !mutReadings.isEmpty { resizeGridByOneAt(location: 0, to: .shrink)
mutReadings.removeFirst()
mutGrid.shrinkGridByOneAt(location: 0)
} }
build() build()
} }
return true return true
} }
// MARK: - Walker
/// 對已給定的軌格按照給定的位置與條件進行正向爬軌。 /// 對已給定的軌格按照給定的位置與條件進行正向爬軌。
/// - Parameters: /// - Returns: 一個包含有效結果的節錨陣列。
/// - location: 開始爬軌的位置。 @discardableResult public func walk() -> [NodeAnchor] {
/// - accumulatedScore: 給定累計權重，非必填參數。預設值為 0。 let newLocation = width
/// - joinedPhrase: 用以統計累計長詞的內部參數，請勿主動使用。 // 這裡把所有空節點都過濾掉。
/// - longPhrases: 用以統計累計長詞的內部參數，請勿主動使用。 walkedAnchors = Array(
public func walk( reverseWalk(at: newLocation).reversed()
at location: Int = 0, ).lazy.filter { !$0.isEmpty }
score accumulatedScore: Double = 0.0, updateCursorJumpingTables(walkedAnchors)
joinedPhrase: String = "", return walkedAnchors
longPhrases: [String] = .init()
) -> [NodeAnchor] {
let newLocation = (mutGrid.width) - abs(location) // 防呆
return Array(
reverseWalk(
at: newLocation, score: accumulatedScore,
joinedPhrase: joinedPhrase, longPhrases: longPhrases
).reversed())
} }
/// 對已給定的軌格按照給定的位置與條件進行反向爬軌。 // MARK: - Private functions
/// 內部專用反芻函式，對已給定的軌格按照給定的位置與條件進行反向爬軌。
/// - Parameters: /// - Parameters:
/// - location: 開始爬軌的位置。 /// - location: 開始爬軌的位置。
/// - accumulatedScore: 給定累計權重，非必填參數。預設值為 0。 /// - mass: 給定累計權重，非必填參數。預設值為 0。
/// - joinedPhrase: 用以統計累計長詞的內部參數，請勿主動使用。 /// - joinedPhrase: 用以統計累計長詞的內部參數，請勿主動使用。
/// - longPhrases: 用以統計累計長詞的內部參數，請勿主動使用。 /// - longPhrases: 用以統計累計長詞的內部參數，請勿主動使用。
public func reverseWalk( /// - Returns: 一個包含結果的節錨陣列。
private func reverseWalk(
at location: Int, at location: Int,
score accumulatedScore: Double = 0.0, mass: Double = 0.0,
joinedPhrase: String = "", joinedPhrase: String = "",
longPhrases: [String] = .init() longPhrases: [String] = .init()
) -> [NodeAnchor] { ) -> [NodeAnchor] {
let location = abs(location) // 防呆 let location = abs(location) // 防呆
if location == 0 || location > mutGrid.width { if location == 0 || location > width {
return .init() return .init()
} }
var paths = [[NodeAnchor]]() var paths = [[NodeAnchor]]()
var nodes = mutGrid.nodesEndingAt(location: location) let nodes = nodesEndingAt(location: location).stableSorted {
nodes = nodes.stableSorted {
$0.scoreForSort > $1.scoreForSort $0.scoreForSort > $1.scoreForSort
} }
if let nodeZero = nodes[0].node, nodeZero.score >= nodeZero.kSelectedCandidateScore { guard !nodes.isEmpty else { return .init() } // 防止下文出現範圍外索引的錯誤
if nodes[0].node.score >= Node.kSelectedCandidateScore {
// 在使用者有選過候選字詞的情況下，摒棄非依此據而成的節點路徑。 // 在使用者有選過候選字詞的情況下，摒棄非依此據而成的節點路徑。
var anchorZero = nodes[0] var theAnchor = nodes[0]
anchorZero.accumulatedScore = accumulatedScore + nodeZero.score theAnchor.mass = mass + nodes[0].node.score
var path: [NodeAnchor] = reverseWalk( var path: [NodeAnchor] = reverseWalk(
at: location - anchorZero.spanningLength, score: anchorZero.accumulatedScore at: location - theAnchor.spanLength, mass: theAnchor.mass
) )
path.insert(anchorZero, at: 0) path.insert(theAnchor, at: 0)
paths.append(path) paths.append(path)
} else if !longPhrases.isEmpty { } else if !longPhrases.isEmpty {
var path = [NodeAnchor]() var path = [NodeAnchor]()
for theAnchor in nodes { for theAnchor in nodes {
guard let theNode = theAnchor.node else { continue }
var theAnchor = theAnchor var theAnchor = theAnchor
let joinedValue = theNode.currentKeyValue.value + joinedPhrase let joinedValue = theAnchor.node.currentPair.value + joinedPhrase
// 如果只是一堆單漢字的節點組成了同樣的長詞的話，直接棄用這個節點路徑。 // 如果只是一堆單漢字的節點組成了同樣的長詞的話，直接棄用這個節點路徑。
// 打比方說「八/月/中/秋/山/林/涼」與「八月/中秋/山林/涼」在使用者來看 // 打比方說「八/月/中/秋/山/林/涼」與「八月/中秋/山林/涼」在使用者來看
// 是「結果等價」的，那就扔掉前者。 // 是「結果等價」的，那就扔掉前者。
if longPhrases.contains(joinedValue) { if longPhrases.contains(joinedValue) {
theAnchor.accumulatedScore = kDroppedPathScore theAnchor.mass = kDroppedPathScore
path.insert(theAnchor, at: 0) path.insert(theAnchor, at: 0)
paths.append(path) paths.append(path)
continue continue
} }
theAnchor.accumulatedScore = accumulatedScore + theNode.score theAnchor.mass = mass + theAnchor.node.score
path = reverseWalk( path = reverseWalk(
at: location - theAnchor.spanningLength, at: location - theAnchor.spanLength,
score: theAnchor.accumulatedScore, mass: theAnchor.mass,
joinedPhrase: (joinedValue.count >= longPhrases[0].count) ? "" : joinedValue, joinedPhrase: (joinedValue.count >= longPhrases[0].count) ? "" : joinedValue,
longPhrases: .init() longPhrases: .init()
) )
@ -219,9 +222,8 @@ extension Megrez {
} else { } else {
// 看看當前格位有沒有更長的候選字詞。 // 看看當前格位有沒有更長的候選字詞。
var longPhrases = [String]() var longPhrases = [String]()
for theAnchor in nodes.lazy.filter({ $0.spanningLength > 1 }) { for theAnchor in nodes.lazy.filter({ $0.spanLength > 1 }) {
guard let theNode = theAnchor.node else { continue } longPhrases.append(theAnchor.node.currentPair.value)
longPhrases.append(theNode.currentKeyValue.value)
} }
longPhrases = longPhrases.stableSorted { longPhrases = longPhrases.stableSorted {
@ -229,12 +231,11 @@ extension Megrez {
} }
for theAnchor in nodes { for theAnchor in nodes {
var theAnchor = theAnchor var theAnchor = theAnchor
guard let theNode = theAnchor.node else { continue } theAnchor.mass = mass + theAnchor.node.score
theAnchor.accumulatedScore = accumulatedScore + theNode.score
var path = [NodeAnchor]() var path = [NodeAnchor]()
path = reverseWalk( path = reverseWalk(
at: location - theAnchor.spanningLength, score: theAnchor.accumulatedScore, at: location - theAnchor.spanLength, mass: theAnchor.mass,
joinedPhrase: (theAnchor.spanningLength > 1) ? "" : theNode.currentKeyValue.value, joinedPhrase: (theAnchor.spanLength > 1) ? "" : theAnchor.node.currentPair.value,
longPhrases: .init() longPhrases: .init()
) )
path.insert(theAnchor, at: 0) path.insert(theAnchor, at: 0)
@ -248,31 +249,29 @@ extension Megrez {
var result: [NodeAnchor] = paths[0] var result: [NodeAnchor] = paths[0]
for neta in paths.lazy.filter({ for neta in paths.lazy.filter({
$0.last!.accumulatedScore > result.last!.accumulatedScore $0.last!.mass > result.last!.mass
}) { }) {
result = neta result = neta
} }
return result return result // 空節點過濾的步驟交給 walk() 這個對外函式，以避免重複執行清理步驟。
} }
// MARK: - Private functions
private func build() { private func build() {
let itrBegin: Int = let itrBegin: Int =
(mutCursorIndex < maxBuildSpanLength) ? 0 : mutCursorIndex - maxBuildSpanLength (cursor < maxBuildSpanLength) ? 0 : cursor - maxBuildSpanLength
let itrEnd: Int = min(mutCursorIndex + maxBuildSpanLength, mutReadings.count) let itrEnd: Int = min(cursor + maxBuildSpanLength, readings.count)
for p in itrBegin..<itrEnd { for p in itrBegin..<itrEnd {
for q in 1..<maxBuildSpanLength { for q in 1..<maxBuildSpanLength {
if p + q > itrEnd { break } if p + q > itrEnd { break }
let arrSlice = mutReadings[p..<(p + q)] let arrSlice = readings[p..<(p + q)]
let combinedReading: String = join(slice: arrSlice, separator: joinSeparator) let combinedReading: String = join(slice: arrSlice, separator: joinSeparator)
if mutGrid.hasMatchedNode(location: p, spanningLength: q, key: combinedReading) { continue } if hasMatchedNode(location: p, spanLength: q, key: combinedReading) { continue }
let unigrams: [Unigram] = mutLM.unigramsFor(key: combinedReading) let unigrams: [Unigram] = langModel.unigramsFor(key: combinedReading)
if unigrams.isEmpty { continue } if unigrams.isEmpty { continue }
let n = Node(key: combinedReading, unigrams: unigrams) let n = Node(key: combinedReading, unigrams: unigrams)
mutGrid.insertNode(node: n, location: p, spanningLength: q) insertNode(node: n, location: p, spanLength: q)
} }
} }
} }
@ -280,6 +279,20 @@ extension Megrez {
private func join(slice arrSlice: ArraySlice<String>, separator: String) -> String { private func join(slice arrSlice: ArraySlice<String>, separator: String) -> String {
arrSlice.joined(separator: separator) arrSlice.joined(separator: separator)
} }
internal func updateCursorJumpingTables(_ anchors: [NodeAnchor]) {
var cursorRegionMapDict = [Int: Int]()
var counter = 0
for (i, anchor) in anchors.enumerated() {
for _ in 0..<anchor.spanLength {
cursorRegionMapDict[counter] = i
counter += 1
}
}
cursorRegionMapDict[counter] = anchors.count
cursorRegionMapDict[-1] = 0 // 防呆
cursorRegionMap = cursorRegionMapDict
}
} }
} }

215
Source/Modules/LanguageParsers/Megrez/2_Grid.swift
View File

@ -24,93 +24,82 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ */
extension Megrez { extension Megrez {
/// 軌格。 /// 軌格，會被組字器作為原始型別來繼承。
public class Grid { public class Grid {
/// 軌格增減行為。
public enum ResizeBehavior { case expand, shrink }
/// 幅位陣列。 /// 幅位陣列。
private var mutSpans: [Megrez.Span] private(set) var spans: [Megrez.SpanUnit]
/// 該幅位內可以允許的最大詞長。 /// 該軌格內可以允許的最大幅位長度。
private var mutMaxBuildSpanLength = 10 private(set) var maxBuildSpanLength = 10
/// 公開：該軌格內可以允許的最大幅位長度。
public var maxBuildSpanLength: Int { mutMaxBuildSpanLength }
/// 公開：軌格的寬度，也就是其內的幅位陣列當中的幅位數量。 /// 公開：軌格的寬度，也就是其內的幅位陣列當中的幅位數量。
public var width: Int { mutSpans.count } public var width: Int { spans.count }
/// 公開：軌格是否為空。 /// 公開：軌格是否為空。
public var isEmpty: Bool { mutSpans.isEmpty } public var isEmpty: Bool { spans.isEmpty }
/// 初期化轨格。 /// 初期化轨格。
public init(spanLength: Int = 10) { public init(spanLength: Int = 10) {
mutMaxBuildSpanLength = spanLength maxBuildSpanLength = spanLength
mutSpans = [Megrez.Span]() spans = [Megrez.SpanUnit]()
} }
/// 自我清空該軌格的內容。 /// 自我清空該軌格的內容。
public func clear() { public func clear() {
mutSpans.removeAll() spans.removeAll()
} }
/// 往該軌格的指定位置插入指定幅位長度的指定節點。 /// 往該軌格的指定位置插入指定幅位長度的指定節點。
/// - Parameters: /// - Parameters:
/// - node: 節點。 /// - node: 節點。
/// - location: 位置。 /// - location: 位置。
/// - spanningLength: 給定的幅位長度。 /// - spanLength: 給定的幅位長度。
public func insertNode(node: Node, location: Int, spanningLength: Int) { public func insertNode(node: Node, location: Int, spanLength: Int) {
let location = abs(location) // 防呆 let location = abs(location) // 防呆
let spanningLength = abs(spanningLength) // 防呆 let spanLength = abs(spanLength) // 防呆
if location >= mutSpans.count { if location >= spans.count {
let diff = location - mutSpans.count + 1 let diff = location - spans.count + 1
for _ in 0..<diff { for _ in 0..<diff {
mutSpans.append(Span()) spans.append(SpanUnit())
} }
} }
mutSpans[location].insert(node: node, length: spanningLength) spans[location].insert(node: node, length: spanLength)
} }
/// 給定索引鍵、位置、幅位長度，在該軌格內確認是否有對應的節點存在。 /// 給定索引鍵、位置、幅位長度，在該軌格內確認是否有對應的節點存在。
/// - Parameters: /// - Parameters:
/// - location: 位置。 /// - location: 位置。
/// - spanningLength: 給定的幅位長度。 /// - spanLength: 給定的幅位長度。
/// - key: 索引鍵。 /// - key: 索引鍵。
public func hasMatchedNode(location: Int, spanningLength: Int, key: String) -> Bool { public func hasMatchedNode(location: Int, spanLength: Int, key: String) -> Bool {
let location = abs(location) // 防呆 let location = abs(location) // 防呆
let spanningLength = abs(spanningLength) // 防呆 let spanLength = abs(spanLength) // 防呆
if location > mutSpans.count { if location > spans.count {
return false return false
} }
let n = mutSpans[location].node(length: spanningLength) let n = spans[location].nodeOf(length: spanLength)
return n != nil && key == n?.key return n != nil && key == n?.key
} }
/// 在該軌格的指定位置擴增一個幅位。 /// 在該軌格的指定位置擴增或減少一個幅位。
/// - Parameters: /// - Parameters:
/// - location: 位置。 /// - location: 位置。
public func expandGridByOneAt(location: Int) { public func resizeGridByOneAt(location: Int, to behavior: ResizeBehavior) {
let location = abs(location) // 防呆 let location = max(0, min(width, location)) // 防呆
mutSpans.insert(Span(), at: location) switch behavior {
if location == 0 || location == mutSpans.count { return } case .expand:
spans.insert(SpanUnit(), at: location)
if [spans.count, 0].contains(location) { return }
case .shrink:
if location >= spans.count { return }
spans.remove(at: location)
}
for i in 0..<location { for i in 0..<location {
// zaps overlapping spans // zaps overlapping spans
mutSpans[i].removeNodeOfLengthGreaterThan(location - i) spans[i].dropNodesBeyond(length: location - i)
}
}
/// 在該軌格的指定位置減少一個幅位。
/// - Parameters:
/// - location: 位置。
public func shrinkGridByOneAt(location: Int) {
let location = abs(location) // 防呆
if location >= mutSpans.count {
return
}
mutSpans.remove(at: location)
for i in 0..<location {
// zaps overlapping spans
mutSpans[i].removeNodeOfLengthGreaterThan(location - i)
} }
} }
@ -120,21 +109,21 @@ extension Megrez {
public func nodesBeginningAt(location: Int) -> [NodeAnchor] { public func nodesBeginningAt(location: Int) -> [NodeAnchor] {
let location = abs(location) // 防呆 let location = abs(location) // 防呆
var results = [NodeAnchor]() var results = [NodeAnchor]()
if location >= mutSpans.count { return results } if location >= spans.count { return results }
// 此時 mutSpans 必然不為空，因為 location 不可能小於 0。 // 此時 spans 必然不為空，因為 location 不可能小於 0。
let span = mutSpans[location] let span = spans[location]
for i in 1...maxBuildSpanLength { for i in 1...maxBuildSpanLength {
if let np = span.node(length: i) { if let np = span.nodeOf(length: i) {
results.append( results.append(
.init( .init(
node: np, node: np,
location: location, location: location,
spanningLength: i spanLength: i
) )
) )
} }
} }
return results return results // 已證實不會有空節點產生。
} }
/// 給定位置，枚舉出所有在這個位置結尾的節點。 /// 給定位置，枚舉出所有在這個位置結尾的節點。
@ -143,21 +132,21 @@ extension Megrez {
public func nodesEndingAt(location: Int) -> [NodeAnchor] { public func nodesEndingAt(location: Int) -> [NodeAnchor] {
let location = abs(location) // 防呆 let location = abs(location) // 防呆
var results = [NodeAnchor]() var results = [NodeAnchor]()
if mutSpans.isEmpty || location > mutSpans.count { return results } if spans.isEmpty || location > spans.count { return results }
for i in 0..<location { for i in 0..<location {
let span = mutSpans[i] let span = spans[i]
if i + span.maximumLength < location { continue } if i + span.maxLength < location { continue }
if let np = span.node(length: location - i) { if let np = span.nodeOf(length: location - i) {
results.append( results.append(
.init( .init(
node: np, node: np,
location: i, location: i,
spanningLength: location - i spanLength: location - i
) )
) )
} }
} }
return results return results // 已證實不會有空節點產生。
} }
/// 給定位置，枚舉出所有在這個位置結尾、或者橫跨該位置的節點。 /// 給定位置，枚舉出所有在這個位置結尾、或者橫跨該位置的節點。
@ -166,46 +155,76 @@ extension Megrez {
public func nodesCrossingOrEndingAt(location: Int) -> [NodeAnchor] { public func nodesCrossingOrEndingAt(location: Int) -> [NodeAnchor] {
let location = abs(location) // 防呆 let location = abs(location) // 防呆
var results = [NodeAnchor]() var results = [NodeAnchor]()
if mutSpans.isEmpty || location > mutSpans.count { return results } if spans.isEmpty || location > spans.count { return results }
for i in 0..<location { for i in 0..<location {
let span = mutSpans[i] let span = spans[i]
if i + span.maximumLength < location { continue } if i + span.maxLength < location { continue }
for j in 1...span.maximumLength { for j in 1...span.maxLength {
if i + j < location { continue } if i + j < location { continue }
if let np = span.node(length: j) { if let np = span.nodeOf(length: j) {
results.append( results.append(
.init( .init(
node: np, node: np,
location: i, location: i,
spanningLength: location - i spanLength: location - i
) )
) )
} }
} }
} }
return results return results // 已證實不會有空節點產生。
} }
/// 將給定位置的節點的候選字詞改為與給定的字串一致的候選字詞。 /// 給定位置，枚舉出所有在這個位置結尾或開頭或者橫跨該位置的節點。
///
/// ⚠︎ 注意：排序可能失真。
/// - Parameters:
/// - location: 位置。
public func nodesOverlappedAt(location: Int) -> [NodeAnchor] {
Array(Set(nodesBeginningAt(location: location) + nodesCrossingOrEndingAt(location: location)))
}
/// 使用給定的候選字字串，將給定位置的節點的候選字詞改為與給定的字串一致的候選字詞。
///
/// 該函式可以僅用作過程函式，但準確度不如用於處理候選字鍵值配對的 fixNodeWithCandidate()。
/// - Parameters:
/// - location: 位置。
/// - value: 給定字串。
@discardableResult public func fixNodeWithCandidateLiteral(_ value: String, at location: Int) -> NodeAnchor {
let location = abs(location) // 防呆
var node = NodeAnchor()
for theAnchor in nodesOverlappedAt(location: location) {
let candidates = theAnchor.node.candidates
// 將該位置的所有節點的候選字詞鎖定狀態全部重設。
theAnchor.node.resetCandidate()
for (i, candidate) in candidates.enumerated() {
if candidate.value == value {
theAnchor.node.selectCandidateAt(index: i)
node = theAnchor
break
}
}
}
return node
}
/// 使用給定的候選字鍵值配對，將給定位置的節點的候選字詞改為與給定的字串一致的候選字詞。
/// ///
/// 該函式可以僅用作過程函式。 /// 該函式可以僅用作過程函式。
/// - Parameters: /// - Parameters:
/// - location: 位置。 /// - location: 位置。
/// - value: 給定字串。 /// - value: 給定候選字鍵值配對。
@discardableResult public func fixNodeSelectedCandidate(location: Int, value: String) -> NodeAnchor { @discardableResult public func fixNodeWithCandidate(_ pair: KeyValuePaired, at location: Int) -> NodeAnchor {
let location = abs(location) // 防呆 let location = abs(location) // 防呆
var node = NodeAnchor() var node = NodeAnchor()
for nodeAnchor in nodesCrossingOrEndingAt(location: location) { for theAnchor in nodesOverlappedAt(location: location) {
guard let theNode = nodeAnchor.node else { let candidates = theAnchor.node.candidates
continue
}
let candidates = theNode.candidates
// 將該位置的所有節點的候選字詞鎖定狀態全部重設。 // 將該位置的所有節點的候選字詞鎖定狀態全部重設。
theNode.resetCandidate() theAnchor.node.resetCandidate()
for (i, candidate) in candidates.enumerated() { for (i, candidate) in candidates.enumerated() {
if candidate.value == value { if candidate == pair {
theNode.selectCandidateAt(index: i) theAnchor.node.selectCandidateAt(index: i)
node = nodeAnchor node = theAnchor
break break
} }
} }
@ -220,16 +239,13 @@ extension Megrez {
/// - overridingScore: 給定權重數值。 /// - overridingScore: 給定權重數值。
public func overrideNodeScoreForSelectedCandidate(location: Int, value: String, overridingScore: Double) { public func overrideNodeScoreForSelectedCandidate(location: Int, value: String, overridingScore: Double) {
let location = abs(location) // 防呆 let location = abs(location) // 防呆
for nodeAnchor in nodesCrossingOrEndingAt(location: location) { for theAnchor in nodesOverlappedAt(location: location) {
guard let theNode = nodeAnchor.node else { let candidates = theAnchor.node.candidates
continue
}
let candidates = theNode.candidates
// 將該位置的所有節點的候選字詞鎖定狀態全部重設。 // 將該位置的所有節點的候選字詞鎖定狀態全部重設。
theNode.resetCandidate() theAnchor.node.resetCandidate()
for (i, candidate) in candidates.enumerated() { for (i, candidate) in candidates.enumerated() {
if candidate.value == value { if candidate.value == value {
theNode.selectFloatingCandidateAt(index: i, score: overridingScore) theAnchor.node.selectFloatingCandidateAt(index: i, score: overridingScore)
break break
} }
} }
@ -244,29 +260,22 @@ extension Megrez.Grid {
/// 生成用以交給 GraphViz 診斷的資料檔案內容，純文字。 /// 生成用以交給 GraphViz 診斷的資料檔案內容，純文字。
public var dumpDOT: String { public var dumpDOT: String {
var strOutput = "digraph {\ngraph [ rankdir=LR ];\nBOS;\n" var strOutput = "digraph {\ngraph [ rankdir=LR ];\nBOS;\n"
for (p, span) in mutSpans.enumerated() { for (p, span) in spans.enumerated() {
for ni in 0...(span.maximumLength) { for ni in 0...(span.maxLength) {
guard let np: Megrez.Node = span.node(length: ni) else { guard let np = span.nodeOf(length: ni) else { continue }
continue
}
if p == 0 { if p == 0 {
strOutput += "BOS -> \(np.currentKeyValue.value);\n" strOutput += "BOS -> \(np.currentPair.value);\n"
} }
strOutput += "\(np.currentPair.value);\n"
strOutput += "\(np.currentKeyValue.value);\n" if (p + ni) < spans.count {
let destinationSpan = spans[p + ni]
if (p + ni) < mutSpans.count { for q in 0...(destinationSpan.maxLength) {
let destinationSpan = mutSpans[p + ni] guard let dn = destinationSpan.nodeOf(length: q) else { continue }
for q in 0...(destinationSpan.maximumLength) { strOutput += np.currentPair.value + " -> " + dn.currentPair.value + ";\n"
if let dn = destinationSpan.node(length: q) {
strOutput += np.currentKeyValue.value + " -> " + dn.currentKeyValue.value + ";\n"
}
} }
} }
guard (p + ni) == spans.count else { continue }
if (p + ni) == mutSpans.count { strOutput += np.currentPair.value + " -> EOS;\n"
strOutput += np.currentKeyValue.value + " -> EOS;\n"
}
} }
} }
strOutput += "EOS;\n}\n" strOutput += "EOS;\n}\n"

39
Source/Modules/LanguageParsers/Megrez/3_NodeAnchor.swift
View File

@ -25,25 +25,34 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
extension Megrez { extension Megrez {
/// 節锚。 /// 節锚。
@frozen public struct NodeAnchor: CustomStringConvertible { @frozen public struct NodeAnchor: Hashable {
/// 用來判斷該節錨是否為空。
public var isEmpty: Bool { node.key.isEmpty }
/// 節點。一個節锚內不一定有節點。 /// 節點。一個節锚內不一定有節點。
public var node: Node? public var node: Node = .init()
/// 節锚所在的位置。 /// 節锚所在的位置。
public var location: Int = 0 public var location: Int = 0
/// 幅位長度。 /// 指定的幅位長度。
public var spanningLength: Int = 0 public var spanLength: Int = 0
/// 累計權重。 /// 累計權重。
public var accumulatedScore: Double = 0.0 public var mass: Double = 0.0
/// 索引鍵的長度。 /// 索引鍵的長度。
public var keyLength: Int { public var keyLength: Int {
node?.key.count ?? 0 isEmpty ? node.key.count : 0
}
public func hash(into hasher: inout Hasher) {
hasher.combine(node)
hasher.combine(location)
hasher.combine(spanLength)
hasher.combine(mass)
} }
/// 將當前節锚列印成一個字串。 /// 將當前節锚列印成一個字串。
public var description: String { public var description: String {
var stream = "" var stream = ""
stream += "{@(" + String(location) + "," + String(spanningLength) + ")," stream += "{@(" + String(location) + "," + String(spanLength) + "),"
if let node = node { if node.key.isEmpty {
stream += node.description stream += node.description
} else { } else {
stream += "null" stream += "null"
@ -54,12 +63,12 @@ extension Megrez {
/// 獲取用來比較的權重。 /// 獲取用來比較的權重。
public var scoreForSort: Double { public var scoreForSort: Double {
node?.score ?? 0 isEmpty ? node.score : 0
} }
} }
} }
// MARK: - DumpDOT-related functions. // MARK: - Array Extensions.
extension Array where Element == Megrez.NodeAnchor { extension Array where Element == Megrez.NodeAnchor {
/// 將節锚陣列列印成一個字串。 /// 將節锚陣列列印成一個字串。
@ -70,4 +79,14 @@ extension Array where Element == Megrez.NodeAnchor {
} }
return arrOutputContent.joined(separator: "<-") return arrOutputContent.joined(separator: "<-")
} }
/// 從一個節錨陣列當中取出目前的自動選字字串陣列。
public var values: [String] {
map(\.node.currentPair.value)
}
/// 從一個節錨陣列當中取出目前的索引鍵陣列。
public var keys: [String] {
map(\.node.currentPair.key)
}
} }

37
Source/Modules/LanguageParsers/Megrez/3_Span.swift
View File

@ -25,21 +25,16 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
extension Megrez { extension Megrez {
/// 幅位。 /// 幅位。
@frozen public struct Span { @frozen public struct SpanUnit {
/// 辭典：以節點長度為索引，以節點為資料值。 /// 辭典：以節點長度為索引，以節點為資料值。
private var mutLengthNodeMap: [Int: Megrez.Node] = [:] private var lengthNodeMap: [Int: Megrez.Node] = [:]
/// 最大節點長度。 /// 最長幅距。
private var mutMaximumLength: Int = 0 private(set) var maxLength: Int = 0
/// 公開：最長幅距（唯讀）。
public var maximumLength: Int {
mutMaximumLength
}
/// 自我清空，各項參數歸零。 /// 自我清空，各項參數歸零。
mutating func clear() { mutating func clear() {
mutLengthNodeMap.removeAll() lengthNodeMap.removeAll()
mutMaximumLength = 0 maxLength = 0
} }
/// 往自身插入一個節點、及給定的節點長度。 /// 往自身插入一個節點、及給定的節點長度。
@ -48,37 +43,37 @@ extension Megrez {
/// - length: 給定的節點長度。 /// - length: 給定的節點長度。
mutating func insert(node: Node, length: Int) { mutating func insert(node: Node, length: Int) {
let length = abs(length) // 防呆 let length = abs(length) // 防呆
mutLengthNodeMap[length] = node lengthNodeMap[length] = node
mutMaximumLength = max(mutMaximumLength, length) maxLength = max(maxLength, length)
} }
/// 移除任何比給定的長度更長的節點。 /// 移除任何比給定的長度更長的節點。
/// - Parameters: /// - Parameters:
/// - length: 給定的節點長度。 /// - length: 給定的節點長度。
mutating func removeNodeOfLengthGreaterThan(_ length: Int) { mutating func dropNodesBeyond(length: Int) {
let length = abs(length) // 防呆 let length = abs(length) // 防呆
if length > mutMaximumLength { return } if length > maxLength { return }
var lenMax = 0 var lenMax = 0
var removalList: [Int: Megrez.Node] = [:] var removalList: [Int: Megrez.Node] = [:]
for key in mutLengthNodeMap.keys { for key in lengthNodeMap.keys {
if key > length { if key > length {
removalList[key] = mutLengthNodeMap[key] removalList[key] = lengthNodeMap[key]
} else { } else {
lenMax = max(lenMax, key) lenMax = max(lenMax, key)
} }
} }
for key in removalList.keys { for key in removalList.keys {
mutLengthNodeMap.removeValue(forKey: key) lengthNodeMap.removeValue(forKey: key)
} }
mutMaximumLength = lenMax maxLength = lenMax
} }
/// 給定節點長度，獲取節點。 /// 給定節點長度，獲取節點。
/// - Parameters: /// - Parameters:
/// - length: 給定的節點長度。 /// - length: 給定的節點長度。
public func node(length: Int) -> Node? { public func nodeOf(length: Int) -> Node? {
// 防呆 Abs() // 防呆 Abs()
mutLengthNodeMap.keys.contains(abs(length)) ? mutLengthNodeMap[abs(length)] : nil lengthNodeMap.keys.contains(abs(length)) ? lengthNodeMap[abs(length)] : nil
} }
} }
} }

150
Source/Modules/LanguageParsers/Megrez/4_Node.swift
View File

@ -25,76 +25,86 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
extension Megrez { extension Megrez {
/// 節點。 /// 節點。
public class Node { public class Node: Equatable, Hashable {
/// 鍵。 public static func == (lhs: Megrez.Node, rhs: Megrez.Node) -> Bool {
private var mutKey: String = "" lhs.key == rhs.key && lhs.score == rhs.score && lhs.unigrams == rhs.unigrams && lhs.bigrams == rhs.bigrams
/// 當前節點的當前被選中的候選字詞「在該節點內的」目前的權重。 && lhs.candidates == rhs.candidates && lhs.valueUnigramIndexMap == rhs.valueUnigramIndexMap
private var mutScore: Double = 0 && lhs.precedingBigramMap == rhs.precedingBigramMap && lhs.isCandidateFixed == rhs.isCandidateFixed
/// 單元圖陣列。 && lhs.selectedUnigramIndex == rhs.selectedUnigramIndex
private var mutUnigrams: [Unigram]
/// 雙元圖陣列。
private var mutBigrams: [Bigram]
/// 候選字詞陣列，以鍵值陣列的形式存在。
private var mutCandidates: [KeyValuePaired] = []
/// 專門「用單元圖資料值來調查索引值」的辭典。
private var mutValueUnigramIndexMap: [String: Int] = [:]
/// 專門「用給定鍵值來取對應的雙元圖陣列」的辭典。
private var mutPrecedingBigramMap: [KeyValuePaired: [Megrez.Bigram]] = [:]
/// 狀態標記變數，用來記載當前節點是否處於候選字詞鎖定狀態。
private var mutCandidateFixed: Bool = false
/// 用來登記「當前選中的單元圖」的索引值的變數。
private var mutSelectedUnigramIndex: Int = 0
/// 用來登記要施加給「『被標記為選中狀態』的候選字詞」的複寫權重的數值。
public let kSelectedCandidateScore: Double = 99
/// 將當前節點列印成一個字串。
public var description: String {
"(node,key:\(mutKey),fixed:\(mutCandidateFixed ? "true" : "false"),selected:\(mutSelectedUnigramIndex),\(mutUnigrams))"
} }
/// 公開：候選字詞陣列（唯讀），以鍵值陣列的形式存在。 public func hash(into hasher: inout Hasher) {
public var candidates: [KeyValuePaired] { mutCandidates } hasher.combine(key)
/// 公開：用來登記「當前選中的單元圖」的索引值的變數（唯讀）。 hasher.combine(score)
public var isCandidateFixed: Bool { mutCandidateFixed } hasher.combine(unigrams)
hasher.combine(bigrams)
hasher.combine(candidates)
hasher.combine(valueUnigramIndexMap)
hasher.combine(precedingBigramMap)
hasher.combine(isCandidateFixed)
hasher.combine(selectedUnigramIndex)
}
/// 鍵。
private(set) var key: String = ""
/// 當前節點的當前被選中的候選字詞「在該節點內的」目前的權重。
private(set) var score: Double = 0
/// 單元圖陣列。
private var unigrams: [Unigram]
/// 雙元圖陣列。
private var bigrams: [Bigram]
/// 候選字詞陣列，以鍵值陣列的形式存在。
private(set) var candidates: [KeyValuePaired] = []
/// 專門「用單元圖資料值來調查索引值」的辭典。
private var valueUnigramIndexMap: [String: Int] = [:]
/// 專門「用給定鍵值來取對應的雙元圖陣列」的辭典。
private var precedingBigramMap: [KeyValuePaired: [Megrez.Bigram]] = [:]
/// 狀態標記變數，用來記載當前節點是否處於候選字詞鎖定狀態。
private(set) var isCandidateFixed: Bool = false
/// 用來登記「當前選中的單元圖」的索引值的變數。
private var selectedUnigramIndex: Int = 0
/// 用來登記要施加給「『被標記為選中狀態』的候選字詞」的複寫權重的數值。
public static let kSelectedCandidateScore: Double = 99
/// 將當前節點列印成一個字串。
public var description: String {
"(node,key:\(key),fixed:\(isCandidateFixed ? "true" : "false"),selected:\(selectedUnigramIndex),\(unigrams))"
}
/// 公開：鍵（唯讀）。
public var key: String { mutKey }
/// 公開：當前節點的當前被選中的候選字詞「在該節點內的」目前的權重（唯讀）。
public var score: Double { mutScore }
/// 公開：當前被選中的候選字詞的鍵值配對。 /// 公開：當前被選中的候選字詞的鍵值配對。
public var currentKeyValue: KeyValuePaired { public var currentPair: KeyValuePaired {
mutSelectedUnigramIndex >= mutUnigrams.count ? KeyValuePaired() : mutCandidates[mutSelectedUnigramIndex] selectedUnigramIndex >= unigrams.count ? KeyValuePaired() : candidates[selectedUnigramIndex]
} }
/// 公開：給出當前單元圖陣列內最高的權重數值。 /// 公開：給出當前單元圖陣列內最高的權重數值。
public var highestUnigramScore: Double { mutUnigrams.isEmpty ? 0.0 : mutUnigrams[0].score } public var highestUnigramScore: Double { unigrams.isEmpty ? 0.0 : unigrams[0].score }
/// 初期化一個節點。 /// 初期化一個節點。
/// - Parameters: /// - Parameters:
/// - key: 索引鍵。 /// - key: 索引鍵。
/// - unigrams: 單元圖陣列。 /// - unigrams: 單元圖陣列。
/// - bigrams: 雙元圖陣列（非必填）。 /// - bigrams: 雙元圖陣列（非必填）。
public init(key: String, unigrams: [Megrez.Unigram], bigrams: [Megrez.Bigram] = []) { public init(key: String = "", unigrams: [Megrez.Unigram] = [], bigrams: [Megrez.Bigram] = []) {
mutKey = key self.key = key
mutUnigrams = unigrams self.unigrams = unigrams
mutBigrams = bigrams self.bigrams = bigrams
mutUnigrams.sort { self.unigrams.sort {
$0.score > $1.score $0.score > $1.score
} }
if !mutUnigrams.isEmpty { if !self.unigrams.isEmpty {
mutScore = mutUnigrams[0].score score = unigrams[0].score
} }
for (i, gram) in mutUnigrams.enumerated() { for (i, gram) in self.unigrams.enumerated() {
mutValueUnigramIndexMap[gram.keyValue.value] = i valueUnigramIndexMap[gram.keyValue.value] = i
mutCandidates.append(gram.keyValue) candidates.append(gram.keyValue)
} }
for gram in bigrams.lazy.filter({ [self] in for gram in bigrams.lazy.filter({ [self] in
mutPrecedingBigramMap.keys.contains($0.precedingKeyValue) precedingBigramMap.keys.contains($0.precedingKeyValue)
}) { }) {
mutPrecedingBigramMap[gram.precedingKeyValue]?.append(gram) precedingBigramMap[gram.precedingKeyValue]?.append(gram)
} }
} }
@ -102,22 +112,22 @@ extension Megrez {
/// - Parameters: /// - Parameters:
/// - precedingKeyValues: 前述鍵值陣列。 /// - precedingKeyValues: 前述鍵值陣列。
public func primeNodeWith(precedingKeyValues: [KeyValuePaired]) { public func primeNodeWith(precedingKeyValues: [KeyValuePaired]) {
var newIndex = mutSelectedUnigramIndex var newIndex = selectedUnigramIndex
var max = mutScore var max = score
if !isCandidateFixed { if !isCandidateFixed {
for neta in precedingKeyValues { for neta in precedingKeyValues {
let bigrams = mutPrecedingBigramMap[neta] ?? [] let bigrams = precedingBigramMap[neta] ?? []
for bigram in bigrams.lazy.filter({ [self] in for bigram in bigrams.lazy.filter({ [self] in
$0.score > max && mutValueUnigramIndexMap.keys.contains($0.keyValue.value) $0.score > max && valueUnigramIndexMap.keys.contains($0.keyValue.value)
}) { }) {
newIndex = mutValueUnigramIndexMap[bigram.keyValue.value] ?? newIndex newIndex = valueUnigramIndexMap[bigram.keyValue.value] ?? newIndex
max = bigram.score max = bigram.score
} }
} }
} }
mutScore = max score = max
mutSelectedUnigramIndex = newIndex selectedUnigramIndex = newIndex
} }
/// 選中位於給定索引位置的候選字詞。 /// 選中位於給定索引位置的候選字詞。
@ -126,17 +136,17 @@ extension Megrez {
/// - fix: 是否將當前解點標記為「候選詞已鎖定」的狀態。 /// - fix: 是否將當前解點標記為「候選詞已鎖定」的狀態。
public func selectCandidateAt(index: Int = 0, fix: Bool = false) { public func selectCandidateAt(index: Int = 0, fix: Bool = false) {
let index = abs(index) let index = abs(index)
mutSelectedUnigramIndex = index >= mutUnigrams.count ? 0 : index selectedUnigramIndex = index >= unigrams.count ? 0 : index
mutCandidateFixed = fix isCandidateFixed = fix
mutScore = kSelectedCandidateScore score = Megrez.Node.kSelectedCandidateScore
} }
/// 重設該節點的候選字詞狀態。 /// 重設該節點的候選字詞狀態。
public func resetCandidate() { public func resetCandidate() {
mutSelectedUnigramIndex = 0 selectedUnigramIndex = 0
mutCandidateFixed = false isCandidateFixed = false
if !mutUnigrams.isEmpty { if !unigrams.isEmpty {
mutScore = mutUnigrams[0].score score = unigrams[0].score
} }
} }
@ -146,16 +156,26 @@ extension Megrez {
/// - score: 給定權重條件。 /// - score: 給定權重條件。
public func selectFloatingCandidateAt(index: Int, score: Double) { public func selectFloatingCandidateAt(index: Int, score: Double) {
let index = abs(index) // 防呆 let index = abs(index) // 防呆
mutSelectedUnigramIndex = index >= mutUnigrams.count ? 0 : index selectedUnigramIndex = index >= unigrams.count ? 0 : index
mutCandidateFixed = false isCandidateFixed = false
mutScore = score self.score = score
} }
/// 藉由給定的候選字詞字串，找出在庫的單元圖權重數值。沒有的話就找零。 /// 藉由給定的候選字詞字串，找出在庫的單元圖權重數值。沒有的話就找零。
/// - Parameters: /// - Parameters:
/// - candidate: 給定的候選字詞字串。 /// - candidate: 給定的候選字詞字串。
public func scoreFor(candidate: String) -> Double { public func scoreFor(candidate: String) -> Double {
for unigram in mutUnigrams.lazy.filter({ $0.keyValue.value == candidate }) { for unigram in unigrams.lazy.filter({ $0.keyValue.value == candidate }) {
return unigram.score
}
return 0.0
}
/// 藉由給定的候選字詞鍵值配對，找出在庫的單元圖權重數值。沒有的話就找零。
/// - Parameters:
/// - candidate: 給定的候選字詞字串。
public func scoreForPaired(candidate: KeyValuePaired) -> Double {
for unigram in unigrams.lazy.filter({ $0.keyValue == candidate }) {
return unigram.score return unigram.score
} }
return 0.0 return 0.0

4
Source/Modules/LanguageParsers/Megrez/5_LanguageModel.swift
View File

@ -23,7 +23,7 @@ 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. CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ */
public protocol LanguageModelProtocol { public protocol LangModelProtocol {
/// 給定鍵，讓語言模型找給一組單元圖陣列。 /// 給定鍵，讓語言模型找給一組單元圖陣列。
func unigramsFor(key: String) -> [Megrez.Unigram] func unigramsFor(key: String) -> [Megrez.Unigram]
@ -36,7 +36,7 @@ public protocol LanguageModelProtocol {
extension Megrez { extension Megrez {
/// 語言模型框架，回頭實際使用時需要派生一個型別、且重寫相關函式。 /// 語言模型框架，回頭實際使用時需要派生一個型別、且重寫相關函式。
open class LanguageModel: LanguageModelProtocol { open class LangModel: LangModelProtocol {
public init() {} public init() {}
// 這裡寫了一點假內容，不然有些 Swift 格式化工具會破壞掉函式的參數設計。 // 這裡寫了一點假內容，不然有些 Swift 格式化工具會破壞掉函式的參數設計。

4
Source/Modules/LanguageParsers/Megrez/6_Bigram.swift
View File

@ -25,7 +25,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
extension Megrez { extension Megrez {
/// 雙元圖。 /// 雙元圖。
@frozen public struct Bigram: Equatable, CustomStringConvertible { @frozen public struct Bigram: Equatable, CustomStringConvertible, Hashable {
/// 當前鍵值。 /// 當前鍵值。
public var keyValue: KeyValuePaired public var keyValue: KeyValuePaired
/// 前述鍵值。 /// 前述鍵值。
@ -61,7 +61,7 @@ extension Megrez {
public static func < (lhs: Bigram, rhs: Bigram) -> Bool { public static func < (lhs: Bigram, rhs: Bigram) -> Bool {
lhs.precedingKeyValue < rhs.precedingKeyValue lhs.precedingKeyValue < rhs.precedingKeyValue
|| (lhs.keyValue < rhs.keyValue || (lhs.keyValue == rhs.keyValue && lhs.keyValue < rhs.keyValue)) || (lhs.keyValue < rhs.keyValue || (lhs.keyValue == rhs.keyValue && lhs.score < rhs.score))
} }
} }
} }

4
Source/Modules/LanguageParsers/Megrez/6_Unigram.swift
View File

@ -25,7 +25,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
extension Megrez { extension Megrez {
/// 單元圖。 /// 單元圖。
@frozen public struct Unigram: Equatable, CustomStringConvertible { @frozen public struct Unigram: Equatable, CustomStringConvertible, Hashable {
/// 鍵值。 /// 鍵值。
public var keyValue: KeyValuePaired public var keyValue: KeyValuePaired
/// 權重。 /// 權重。
@ -54,7 +54,7 @@ extension Megrez {
} }
public static func < (lhs: Unigram, rhs: Unigram) -> Bool { public static func < (lhs: Unigram, rhs: Unigram) -> Bool {
lhs.keyValue < rhs.keyValue || (lhs.keyValue == rhs.keyValue && lhs.keyValue < rhs.keyValue) lhs.keyValue < rhs.keyValue || (lhs.keyValue == rhs.keyValue && lhs.score < rhs.score)
} }
} }
} }

2
Source/Modules/LanguageParsers/Megrez/7_KeyValuePaired.swift
View File

@ -52,7 +52,7 @@ extension Megrez {
} }
public static func == (lhs: KeyValuePaired, rhs: KeyValuePaired) -> Bool { public static func == (lhs: KeyValuePaired, rhs: KeyValuePaired) -> Bool {
lhs.key.count == rhs.key.count && lhs.value == rhs.value lhs.key == rhs.key && lhs.value == rhs.value
} }
public static func < (lhs: KeyValuePaired, rhs: KeyValuePaired) -> Bool { public static func < (lhs: KeyValuePaired, rhs: KeyValuePaired) -> Bool {

30
Source/Modules/main.swift
View File

@ -32,24 +32,18 @@ let kConnectionName = "vChewing_1_Connection"
switch max(CommandLine.arguments.count - 1, 0) { switch max(CommandLine.arguments.count - 1, 0) {
case 0: break case 0: break
case 1, 2: case 1, 2:
do { switch CommandLine.arguments[1] {
switch CommandLine.arguments[1] { case "install":
case "install": if CommandLine.arguments[1] == "install" {
do { let exitCode = IME.registerInputMethod()
if CommandLine.arguments[1] == "install" { exit(exitCode)
let exitCode = IME.registerInputMethod() }
exit(exitCode) case "uninstall":
} if CommandLine.arguments[1] == "uninstall" {
} let exitCode = IME.uninstall(isSudo: IME.isSudoMode)
case "uninstall": exit(exitCode)
do { }
if CommandLine.arguments[1] == "uninstall" { default: break
let exitCode = IME.uninstall(isSudo: IME.isSudoMode)
exit(exitCode)
}
}
default: break
}
} }
exit(0) exit(0)
default: exit(0) default: exit(0)

3
Source/Resources/Base.lproj/Localizable.strings
View File

@ -63,6 +63,7 @@
"Loading CHT Core Dict..." = "Loading CHT Core Dict..."; "Loading CHT Core Dict..." = "Loading CHT Core Dict...";
"Core Dict loading complete." = "Core Dict loading complete."; "Core Dict loading complete." = "Core Dict loading complete.";
"Optimize Memorized Phrases" = "Optimize Memorized Phrases"; "Optimize Memorized Phrases" = "Optimize Memorized Phrases";
"Clear Memorized Phrases" = "Clear Memorized Phrases";
// The followings are the category names used in the Symbol menu. // The followings are the category names used in the Symbol menu.
"catCommonSymbols" = "CommonSymbols"; "catCommonSymbols" = "CommonSymbols";
@ -146,7 +147,7 @@
"Push the cursor in front of the phrase after selection" = "Push the cursor in front of the phrase after selection"; "Push the cursor in front of the phrase after selection" = "Push the cursor in front of the phrase after selection";
"Secondary Pinyin with Numeral Intonation" = "Secondary Pinyin with Numeral Intonation"; "Secondary Pinyin with Numeral Intonation" = "Secondary Pinyin with Numeral Intonation";
"Selection Keys:" = "Selection Keys:"; "Selection Keys:" = "Selection Keys:";
"Show Hanyu-Pinyin in the inline composition buffer" = "Show Hanyu-Pinyin in the inline composition buffer"; "Show Hanyu-Pinyin in the inline composition buffer & tooltip" = "Show Hanyu-Pinyin in the inline composition buffer & tooltip";
"Show page buttons in candidate window" = "Show page buttons in candidate window"; "Show page buttons in candidate window" = "Show page buttons in candidate window";
"Simplified Chinese" = "Simplified Chinese"; "Simplified Chinese" = "Simplified Chinese";
"Space & ESC Key:" = "Space & ESC Key:"; "Space & ESC Key:" = "Space & ESC Key:";

3
Source/Resources/en.lproj/Localizable.strings
View File

@ -63,6 +63,7 @@
"Loading CHT Core Dict..." = "Loading CHT Core Dict..."; "Loading CHT Core Dict..." = "Loading CHT Core Dict...";
"Core Dict loading complete." = "Core Dict loading complete."; "Core Dict loading complete." = "Core Dict loading complete.";
"Optimize Memorized Phrases" = "Optimize Memorized Phrases"; "Optimize Memorized Phrases" = "Optimize Memorized Phrases";
"Clear Memorized Phrases" = "Clear Memorized Phrases";
// The followings are the category names used in the Symbol menu. // The followings are the category names used in the Symbol menu.
"catCommonSymbols" = "CommonSymbols"; "catCommonSymbols" = "CommonSymbols";
@ -146,7 +147,7 @@
"Push the cursor in front of the phrase after selection" = "Push the cursor in front of the phrase after selection"; "Push the cursor in front of the phrase after selection" = "Push the cursor in front of the phrase after selection";
"Secondary Pinyin with Numeral Intonation" = "Secondary Pinyin with Numeral Intonation"; "Secondary Pinyin with Numeral Intonation" = "Secondary Pinyin with Numeral Intonation";
"Selection Keys:" = "Selection Keys:"; "Selection Keys:" = "Selection Keys:";
"Show Hanyu-Pinyin in the inline composition buffer" = "Show Hanyu-Pinyin in the inline composition buffer"; "Show Hanyu-Pinyin in the inline composition buffer & tooltip" = "Show Hanyu-Pinyin in the inline composition buffer & tooltip";
"Show page buttons in candidate window" = "Show page buttons in candidate window"; "Show page buttons in candidate window" = "Show page buttons in candidate window";
"Simplified Chinese" = "Simplified Chinese"; "Simplified Chinese" = "Simplified Chinese";
"Space & ESC Key:" = "Space & ESC Key:"; "Space & ESC Key:" = "Space & ESC Key:";

3
Source/Resources/ja.lproj/Localizable.strings
View File

@ -63,6 +63,7 @@
"Loading CHT Core Dict..." = "繁体中国語核心辞書読込中…"; "Loading CHT Core Dict..." = "繁体中国語核心辞書読込中…";
"Core Dict loading complete." = "核心辞書読込完了"; "Core Dict loading complete." = "核心辞書読込完了";
"Optimize Memorized Phrases" = "臨時記憶資料を整う"; "Optimize Memorized Phrases" = "臨時記憶資料を整う";
"Clear Memorized Phrases" = "臨時記憶資料を削除";
// The followings are the category names used in the Symbol menu. // The followings are the category names used in the Symbol menu.
"catCommonSymbols" = "常用"; "catCommonSymbols" = "常用";
@ -146,7 +147,7 @@
"Push the cursor in front of the phrase after selection" = "候補選択の直後、すぐカーソルを単語の向こうに推し進める"; "Push the cursor in front of the phrase after selection" = "候補選択の直後、すぐカーソルを単語の向こうに推し進める";
"Secondary Pinyin with Numeral Intonation" = "国音二式 (ローマ字+数字音調)"; "Secondary Pinyin with Numeral Intonation" = "国音二式 (ローマ字+数字音調)";
"Selection Keys:" = "言選り用キー:"; "Selection Keys:" = "言選り用キー:";
"Show Hanyu-Pinyin in the inline composition buffer" = "弁音合併入力（入力緩衝列で代わりに漢語弁音の音読み）"; "Show Hanyu-Pinyin in the inline composition buffer & tooltip" = "弁音合併入力（入力緩衝列とヒントで音読みを漢語弁音に）";
"Show page buttons in candidate window" = "入力候補陳列の側にページボタンを表示"; "Show page buttons in candidate window" = "入力候補陳列の側にページボタンを表示";
"Simplified Chinese" = "簡体中国語"; "Simplified Chinese" = "簡体中国語";
"Space & ESC Key:" = "ESC と Space:"; "Space & ESC Key:" = "ESC と Space:";

3
Source/Resources/zh-Hans.lproj/Localizable.strings
View File

@ -63,6 +63,7 @@
"Loading CHT Core Dict..." = "载入繁体中文核心辞典…"; "Loading CHT Core Dict..." = "载入繁体中文核心辞典…";
"Core Dict loading complete." = "核心辞典载入完毕"; "Core Dict loading complete." = "核心辞典载入完毕";
"Optimize Memorized Phrases" = "精简临时记忆语汇资料"; "Optimize Memorized Phrases" = "精简临时记忆语汇资料";
"Clear Memorized Phrases" = "清除临时记忆语汇资料";
// The followings are the category names used in the Symbol menu. // The followings are the category names used in the Symbol menu.
"catCommonSymbols" = "常用"; "catCommonSymbols" = "常用";
@ -147,7 +148,7 @@
"Push the cursor in front of the phrase after selection" = "在选字后将游标置于该字词的前方"; "Push the cursor in front of the phrase after selection" = "在选字后将游标置于该字词的前方";
"Secondary Pinyin with Numeral Intonation" = "国音二式+数字标调"; "Secondary Pinyin with Numeral Intonation" = "国音二式+数字标调";
"Selection Keys:" = "选字键:"; "Selection Keys:" = "选字键:";
"Show Hanyu-Pinyin in the inline composition buffer" = "拼音并击模式（组字区内看到的是汉语拼音）"; "Show Hanyu-Pinyin in the inline composition buffer & tooltip" = "拼音并击（组字区与工具提示内显示汉语拼音）";
"Show page buttons in candidate window" = "在选字窗内显示翻页按钮"; "Show page buttons in candidate window" = "在选字窗内显示翻页按钮";
"Simplified Chinese" = "简体中文"; "Simplified Chinese" = "简体中文";
"Space & ESC Key:" = "ESC 与空格键:"; "Space & ESC Key:" = "ESC 与空格键:";

3
Source/Resources/zh-Hant.lproj/Localizable.strings
View File

@ -63,6 +63,7 @@
"Loading CHT Core Dict..." = "載入繁體中文核心辭典…"; "Loading CHT Core Dict..." = "載入繁體中文核心辭典…";
"Core Dict loading complete." = "核心辭典載入完畢"; "Core Dict loading complete." = "核心辭典載入完畢";
"Optimize Memorized Phrases" = "精簡臨時記憶語彙資料"; "Optimize Memorized Phrases" = "精簡臨時記憶語彙資料";
"Clear Memorized Phrases" = "清除臨時記憶語彙資料";
// The followings are the category names used in the Symbol menu. // The followings are the category names used in the Symbol menu.
"catCommonSymbols" = "常用"; "catCommonSymbols" = "常用";
@ -146,7 +147,7 @@
"Push the cursor in front of the phrase after selection" = "在選字後將游標置於該字詞的前方"; "Push the cursor in front of the phrase after selection" = "在選字後將游標置於該字詞的前方";
"Secondary Pinyin with Numeral Intonation" = "國音二式+數字標調"; "Secondary Pinyin with Numeral Intonation" = "國音二式+數字標調";
"Selection Keys:" = "選字鍵:"; "Selection Keys:" = "選字鍵:";
"Show Hanyu-Pinyin in the inline composition buffer" = "拼音並擊模式（組字區內看到的是漢語拼音）"; "Show Hanyu-Pinyin in the inline composition buffer & tooltip" = "拼音並擊（組字區與工具提示內顯示漢語拼音）";
"Show page buttons in candidate window" = "在選字窗內顯示翻頁按鈕"; "Show page buttons in candidate window" = "在選字窗內顯示翻頁按鈕";
"Simplified Chinese" = "簡體中文"; "Simplified Chinese" = "簡體中文";
"Space & ESC Key:" = "ESC 與空格鍵:"; "Space & ESC Key:" = "ESC 與空格鍵:";

2
Source/UI/CandidateUI/ctlCandidate.swift
View File

@ -40,7 +40,7 @@ public class CandidateKeyLabel: NSObject {
public protocol ctlCandidateDelegate: AnyObject { public protocol ctlCandidateDelegate: AnyObject {
func candidateCountForController(_ controller: ctlCandidate) -> Int func candidateCountForController(_ controller: ctlCandidate) -> Int
func ctlCandidate(_ controller: ctlCandidate, candidateAtIndex index: Int) func ctlCandidate(_ controller: ctlCandidate, candidateAtIndex index: Int)
-> String -> (String, String)
func ctlCandidate( func ctlCandidate(
_ controller: ctlCandidate, didSelectCandidateAtIndex index: Int _ controller: ctlCandidate, didSelectCandidateAtIndex index: Int
) )

276
Source/UI/CandidateUI/ctlCandidateUniversal.swift
View File

@ -162,146 +162,142 @@ private class vwrCandidateUniversal: NSView {
switch isVerticalLayout { switch isVerticalLayout {
case true: case true:
do { var accuHeight: CGFloat = 0
var accuHeight: CGFloat = 0 for (index, elementHeight) in elementHeights.enumerated() {
for (index, elementHeight) in elementHeights.enumerated() { let currentHeight = elementHeight
let currentHeight = elementHeight let rctCandidateArea = NSRect(
let rctCandidateArea = NSRect( x: 0.0, y: accuHeight, width: windowWidth, height: candidateTextHeight + cellPadding
x: 0.0, y: accuHeight, width: windowWidth, height: candidateTextHeight + cellPadding )
) let rctLabel = NSRect(
let rctLabel = NSRect( x: cellPadding / 2 - 1, y: accuHeight + cellPadding / 2, width: keyLabelWidth,
x: cellPadding / 2 - 1, y: accuHeight + cellPadding / 2, width: keyLabelWidth, height: keyLabelHeight * 2.0
height: keyLabelHeight * 2.0 )
) let rctCandidatePhrase = NSRect(
let rctCandidatePhrase = NSRect( x: cellPadding / 2 - 1 + keyLabelWidth, y: accuHeight + cellPadding / 2 - 1,
x: cellPadding / 2 - 1 + keyLabelWidth, y: accuHeight + cellPadding / 2 - 1, width: windowWidth - keyLabelWidth, height: candidateTextHeight
width: windowWidth - keyLabelWidth, height: candidateTextHeight )
)
var activeCandidateIndexAttr = keyLabelAttrDict var activeCandidateIndexAttr = keyLabelAttrDict
var activeCandidateAttr = candidateAttrDict var activeCandidateAttr = candidateAttrDict
if index == highlightedIndex { if index == highlightedIndex {
let colorBlendAmount: CGFloat = IME.isDarkMode() ? 0.25 : 0 let colorBlendAmount: CGFloat = IME.isDarkMode() ? 0.25 : 0
// The background color of the highlightened candidate // The background color of the highlightened candidate
switch IME.currentInputMode {
case InputMode.imeModeCHS:
NSColor.systemRed.blended(
withFraction: colorBlendAmount,
of: NSColor.controlBackgroundColor
)!
.setFill()
case InputMode.imeModeCHT:
NSColor.systemBlue.blended(
withFraction: colorBlendAmount,
of: NSColor.controlBackgroundColor
)!
.setFill()
default:
NSColor.alternateSelectedControlColor.setFill()
}
// Highlightened index text color
activeCandidateIndexAttr[.foregroundColor] = NSColor.selectedMenuItemTextColor
.withAlphaComponent(0.84)
// Highlightened phrase text color
activeCandidateAttr[.foregroundColor] = NSColor.selectedMenuItemTextColor
} else {
NSColor.controlBackgroundColor.setFill()
}
switch IME.currentInputMode { switch IME.currentInputMode {
case InputMode.imeModeCHS: case InputMode.imeModeCHS:
if #available(macOS 12.0, *) { NSColor.systemRed.blended(
activeCandidateAttr[.languageIdentifier] = "zh-Hans" as AnyObject withFraction: colorBlendAmount,
} of: NSColor.controlBackgroundColor
)!
.setFill()
case InputMode.imeModeCHT: case InputMode.imeModeCHT:
if #available(macOS 12.0, *) { NSColor.systemBlue.blended(
activeCandidateAttr[.languageIdentifier] = withFraction: colorBlendAmount,
(mgrPrefs.shiftJISShinjitaiOutputEnabled || mgrPrefs.chineseConversionEnabled) of: NSColor.controlBackgroundColor
? "ja" as AnyObject : "zh-Hant" as AnyObject )!
} .setFill()
default: default:
break NSColor.alternateSelectedControlColor.setFill()
} }
NSBezierPath.fill(rctCandidateArea) // Highlightened index text color
(keyLabels[index] as NSString).draw( activeCandidateIndexAttr[.foregroundColor] = NSColor.selectedMenuItemTextColor
in: rctLabel, withAttributes: activeCandidateIndexAttr .withAlphaComponent(0.84)
) // Highlightened phrase text color
(displayedCandidates[index] as NSString).draw( activeCandidateAttr[.foregroundColor] = NSColor.selectedMenuItemTextColor
in: rctCandidatePhrase, withAttributes: activeCandidateAttr } else {
) NSColor.controlBackgroundColor.setFill()
accuHeight += currentHeight
} }
switch IME.currentInputMode {
case InputMode.imeModeCHS:
if #available(macOS 12.0, *) {
activeCandidateAttr[.languageIdentifier] = "zh-Hans" as AnyObject
}
case InputMode.imeModeCHT:
if #available(macOS 12.0, *) {
activeCandidateAttr[.languageIdentifier] =
(mgrPrefs.shiftJISShinjitaiOutputEnabled || mgrPrefs.chineseConversionEnabled)
? "ja" as AnyObject : "zh-Hant" as AnyObject
}
default:
break
}
NSBezierPath.fill(rctCandidateArea)
(keyLabels[index] as NSString).draw(
in: rctLabel, withAttributes: activeCandidateIndexAttr
)
(displayedCandidates[index] as NSString).draw(
in: rctCandidatePhrase, withAttributes: activeCandidateAttr
)
accuHeight += currentHeight
} }
case false: case false:
do { var accuWidth: CGFloat = 0
var accuWidth: CGFloat = 0 for (index, elementWidth) in elementWidths.enumerated() {
for (index, elementWidth) in elementWidths.enumerated() { let currentWidth = elementWidth
let currentWidth = elementWidth let rctCandidateArea = NSRect(
let rctCandidateArea = NSRect( x: accuWidth, y: 0.0, width: currentWidth + 1.0,
x: accuWidth, y: 0.0, width: currentWidth + 1.0, height: candidateTextHeight + cellPadding
height: candidateTextHeight + cellPadding )
) let rctLabel = NSRect(
let rctLabel = NSRect( x: accuWidth + cellPadding / 2 - 1, y: cellPadding / 2, width: keyLabelWidth,
x: accuWidth + cellPadding / 2 - 1, y: cellPadding / 2, width: keyLabelWidth, height: keyLabelHeight * 2.0
height: keyLabelHeight * 2.0 )
) let rctCandidatePhrase = NSRect(
let rctCandidatePhrase = NSRect( x: accuWidth + keyLabelWidth - 1, y: cellPadding / 2 - 1,
x: accuWidth + keyLabelWidth - 1, y: cellPadding / 2 - 1, width: currentWidth - keyLabelWidth,
width: currentWidth - keyLabelWidth, height: candidateTextHeight
height: candidateTextHeight )
)
var activeCandidateIndexAttr = keyLabelAttrDict var activeCandidateIndexAttr = keyLabelAttrDict
var activeCandidateAttr = candidateAttrDict var activeCandidateAttr = candidateAttrDict
if index == highlightedIndex { if index == highlightedIndex {
let colorBlendAmount: CGFloat = IME.isDarkMode() ? 0.25 : 0 let colorBlendAmount: CGFloat = IME.isDarkMode() ? 0.25 : 0
// The background color of the highlightened candidate // The background color of the highlightened candidate
switch IME.currentInputMode {
case InputMode.imeModeCHS:
NSColor.systemRed.blended(
withFraction: colorBlendAmount,
of: NSColor.controlBackgroundColor
)!
.setFill()
case InputMode.imeModeCHT:
NSColor.systemBlue.blended(
withFraction: colorBlendAmount,
of: NSColor.controlBackgroundColor
)!
.setFill()
default:
NSColor.alternateSelectedControlColor.setFill()
}
// Highlightened index text color
activeCandidateIndexAttr[.foregroundColor] = NSColor.selectedMenuItemTextColor
.withAlphaComponent(0.84)
// Highlightened phrase text color
activeCandidateAttr[.foregroundColor] = NSColor.selectedMenuItemTextColor
} else {
NSColor.controlBackgroundColor.setFill()
}
switch IME.currentInputMode { switch IME.currentInputMode {
case InputMode.imeModeCHS: case InputMode.imeModeCHS:
if #available(macOS 12.0, *) { NSColor.systemRed.blended(
activeCandidateAttr[.languageIdentifier] = "zh-Hans" as AnyObject withFraction: colorBlendAmount,
} of: NSColor.controlBackgroundColor
)!
.setFill()
case InputMode.imeModeCHT: case InputMode.imeModeCHT:
if #available(macOS 12.0, *) { NSColor.systemBlue.blended(
activeCandidateAttr[.languageIdentifier] = withFraction: colorBlendAmount,
(mgrPrefs.shiftJISShinjitaiOutputEnabled || mgrPrefs.chineseConversionEnabled) of: NSColor.controlBackgroundColor
? "ja" as AnyObject : "zh-Hant" as AnyObject )!
} .setFill()
default: default:
break NSColor.alternateSelectedControlColor.setFill()
} }
NSBezierPath.fill(rctCandidateArea) // Highlightened index text color
(keyLabels[index] as NSString).draw( activeCandidateIndexAttr[.foregroundColor] = NSColor.selectedMenuItemTextColor
in: rctLabel, withAttributes: activeCandidateIndexAttr .withAlphaComponent(0.84)
) // Highlightened phrase text color
(displayedCandidates[index] as NSString).draw( activeCandidateAttr[.foregroundColor] = NSColor.selectedMenuItemTextColor
in: rctCandidatePhrase, withAttributes: activeCandidateAttr } else {
) NSColor.controlBackgroundColor.setFill()
accuWidth += currentWidth + 1.0
} }
switch IME.currentInputMode {
case InputMode.imeModeCHS:
if #available(macOS 12.0, *) {
activeCandidateAttr[.languageIdentifier] = "zh-Hans" as AnyObject
}
case InputMode.imeModeCHT:
if #available(macOS 12.0, *) {
activeCandidateAttr[.languageIdentifier] =
(mgrPrefs.shiftJISShinjitaiOutputEnabled || mgrPrefs.chineseConversionEnabled)
? "ja" as AnyObject : "zh-Hant" as AnyObject
}
default:
break
}
NSBezierPath.fill(rctCandidateArea)
(keyLabels[index] as NSString).draw(
in: rctLabel, withAttributes: activeCandidateIndexAttr
)
(displayedCandidates[index] as NSString).draw(
in: rctCandidatePhrase, withAttributes: activeCandidateAttr
)
accuWidth += currentWidth + 1.0
} }
} }
} }
@ -313,28 +309,24 @@ private class vwrCandidateUniversal: NSView {
} }
switch isVerticalLayout { switch isVerticalLayout {
case true: case true:
do { var accuHeight: CGFloat = 0.0
var accuHeight: CGFloat = 0.0 for (index, elementHeight) in elementHeights.enumerated() {
for (index, elementHeight) in elementHeights.enumerated() { let currentHeight = elementHeight
let currentHeight = elementHeight
if location.y >= accuHeight, location.y <= accuHeight + currentHeight { if location.y >= accuHeight, location.y <= accuHeight + currentHeight {
return index return index
}
accuHeight += currentHeight
} }
accuHeight += currentHeight
} }
case false: case false:
do { var accuWidth: CGFloat = 0.0
var accuWidth: CGFloat = 0.0 for (index, elementWidth) in elementWidths.enumerated() {
for (index, elementWidth) in elementWidths.enumerated() { let currentWidth = elementWidth
let currentWidth = elementWidth
if location.x >= accuWidth, location.x <= accuWidth + currentWidth { if location.x >= accuWidth, location.x <= accuWidth + currentWidth {
return index return index
}
accuWidth += currentWidth + 1.0
} }
accuWidth += currentWidth + 1.0
} }
} }
return NSNotFound return NSNotFound
@ -559,7 +551,7 @@ extension ctlCandidateUniversal {
} }
candidateView.set(keyLabelFont: keyLabelFont, candidateFont: candidateFont) candidateView.set(keyLabelFont: keyLabelFont, candidateFont: candidateFont)
var candidates = [String]() var candidates = [(String, String)]()
let count = delegate.candidateCountForController(self) let count = delegate.candidateCountForController(self)
let keyLabelCount = keyLabels.count let keyLabelCount = keyLabels.count
@ -569,7 +561,7 @@ extension ctlCandidateUniversal {
candidates.append(candidate) candidates.append(candidate)
} }
candidateView.set( candidateView.set(
keyLabels: keyLabels.map(\.displayedText), displayedCandidates: candidates keyLabels: keyLabels.map(\.displayedText), displayedCandidates: candidates.map(\.1)
) )
var newSize = candidateView.sizeForView var newSize = candidateView.sizeForView
var frameRect = candidateView.frame var frameRect = candidateView.frame

2
Source/UI/PrefUI/suiPrefPaneGeneral.swift
View File

@ -158,7 +158,7 @@ struct suiPrefPaneGeneral: View {
} }
} }
Toggle( Toggle(
LocalizedStringKey("Show Hanyu-Pinyin in the inline composition buffer"), LocalizedStringKey("Show Hanyu-Pinyin in the inline composition buffer & tooltip"),
isOn: $selShowHanyuPinyinInCompositionBuffer isOn: $selShowHanyuPinyinInCompositionBuffer
).onChange(of: selShowHanyuPinyinInCompositionBuffer) { value in ).onChange(of: selShowHanyuPinyinInCompositionBuffer) { value in
mgrPrefs.showHanyuPinyinInCompositionBuffer = value mgrPrefs.showHanyuPinyinInCompositionBuffer = value

2
Source/WindowNIBs/Base.lproj/frmPrefWindow.xib
View File

@ -269,7 +269,7 @@
</button> </button>
<button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="vwf-Kq-s8M" userLabel="chkShowHanyuPinyinInCompositionBuffer"> <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="vwf-Kq-s8M" userLabel="chkShowHanyuPinyinInCompositionBuffer">
<rect key="frame" x="19" y="42.5" width="406" height="16"/> <rect key="frame" x="19" y="42.5" width="406" height="16"/>
<buttonCell key="cell" type="check" title="Show Hanyu-Pinyin in the inline composition buffer" bezelStyle="regularSquare" imagePosition="left" controlSize="small" inset="2" id="wFR-zX-M8H"> <buttonCell key="cell" type="check" title="Show Hanyu-Pinyin in the inline composition buffer &amp; tooltip" bezelStyle="regularSquare" imagePosition="left" controlSize="small" inset="2" id="wFR-zX-M8H">
<behavior key="behavior" changeContents="YES" doesNotDimImage="YES" lightByContents="YES"/> <behavior key="behavior" changeContents="YES" doesNotDimImage="YES" lightByContents="YES"/>
<font key="font" metaFont="cellTitle"/> <font key="font" metaFont="cellTitle"/>
</buttonCell> </buttonCell>

2
Source/WindowNIBs/en.lproj/frmPrefWindow.strings
View File

@ -74,7 +74,7 @@
"ueU-Rz-a1C.title" = "Choose the behavior of (Shift+)Tab key in the candidate window."; "ueU-Rz-a1C.title" = "Choose the behavior of (Shift+)Tab key in the candidate window.";
"Uyz-xL-TVN.title" = "Output Settings"; "Uyz-xL-TVN.title" = "Output Settings";
"W24-T4-cg0.title" = "Enable CNS11643 Support (2022-06-15)"; "W24-T4-cg0.title" = "Enable CNS11643 Support (2022-06-15)";
"wFR-zX-M8H.title" = "Show Hanyu-Pinyin in the inline composition buffer"; "wFR-zX-M8H.title" = "Show Hanyu-Pinyin in the inline composition buffer & tooltip";
"wN3-k3-b2a.title" = "Choose your desired user data folder path. Will be omitted if invalid."; "wN3-k3-b2a.title" = "Choose your desired user data folder path. Will be omitted if invalid.";
"wQ9-px-b07.title" = "Apple Dynamic Bopomofo Basic Keyboard Layouts (Dachen & Eten Traditional) must match the Dachen parser in order to be functional."; "wQ9-px-b07.title" = "Apple Dynamic Bopomofo Basic Keyboard Layouts (Dachen & Eten Traditional) must match the Dachen parser in order to be functional.";
"Wvt-HE-LOv.title" = "Keyboard Layout"; "Wvt-HE-LOv.title" = "Keyboard Layout";

2
Source/WindowNIBs/ja.lproj/frmPrefWindow.strings
View File

@ -74,7 +74,7 @@
"ueU-Rz-a1C.title" = "入力候補陳列での (Shift+)Tab キーの輪番切替対象をご指定ください。"; "ueU-Rz-a1C.title" = "入力候補陳列での (Shift+)Tab キーの輪番切替対象をご指定ください。";
"Uyz-xL-TVN.title" = "出力設定"; "Uyz-xL-TVN.title" = "出力設定";
"W24-T4-cg0.title" = "全字庫モード // 入力可能の漢字数倍増 (2022-06-15)"; "W24-T4-cg0.title" = "全字庫モード // 入力可能の漢字数倍増 (2022-06-15)";
"wFR-zX-M8H.title" = "弁音合併入力（入力緩衝列で代わりに漢語弁音の音読み）"; "wFR-zX-M8H.title" = "弁音合併入力（入力緩衝列とヒントで音読みを漢語弁音に）";
"wN3-k3-b2a.title" = "欲しがるユーザー辞書保存先をご指定ください。無効の保存先設定は効かぬ。"; "wN3-k3-b2a.title" = "欲しがるユーザー辞書保存先をご指定ください。無効の保存先設定は効かぬ。";
"wQ9-px-b07.title" = "Apple 動態注音キーボード (大千と倚天伝統) を使うには、共通語分析器の注音配列を大千と設定すべきである。"; "wQ9-px-b07.title" = "Apple 動態注音キーボード (大千と倚天伝統) を使うには、共通語分析器の注音配列を大千と設定すべきである。";
"Wvt-HE-LOv.title" = "キーボード"; "Wvt-HE-LOv.title" = "キーボード";

2
Source/WindowNIBs/zh-Hans.lproj/frmPrefWindow.strings
View File

@ -74,7 +74,7 @@
"ueU-Rz-a1C.title" = "指定 (Shift+)Tab 热键在选字窗内的轮替操作对象。"; "ueU-Rz-a1C.title" = "指定 (Shift+)Tab 热键在选字窗内的轮替操作对象。";
"Uyz-xL-TVN.title" = "输出设定"; "Uyz-xL-TVN.title" = "输出设定";
"W24-T4-cg0.title" = "启用 CNS11643 全字库支援 (2022-06-15)"; "W24-T4-cg0.title" = "启用 CNS11643 全字库支援 (2022-06-15)";
"wFR-zX-M8H.title" = "拼音并击模式（组字区内看到的是汉语拼音）"; "wFR-zX-M8H.title" = "拼音并击（组字区与工具提示内显示汉语拼音）";
"wN3-k3-b2a.title" = "请在此指定您想指定的使用者语汇档案目录。无效值会被忽略。"; "wN3-k3-b2a.title" = "请在此指定您想指定的使用者语汇档案目录。无效值会被忽略。";
"wQ9-px-b07.title" = "Apple 动态注音键盘布局（大千与倚天）要求普通话/国音分析器的注音排列得配置为大千排列。"; "wQ9-px-b07.title" = "Apple 动态注音键盘布局（大千与倚天）要求普通话/国音分析器的注音排列得配置为大千排列。";
"Wvt-HE-LOv.title" = "键盘布局"; "Wvt-HE-LOv.title" = "键盘布局";

2
Source/WindowNIBs/zh-Hant.lproj/frmPrefWindow.strings
View File

@ -74,7 +74,7 @@
"ueU-Rz-a1C.title" = "指定 (Shift+)Tab 熱鍵在選字窗內的輪替操作對象。"; "ueU-Rz-a1C.title" = "指定 (Shift+)Tab 熱鍵在選字窗內的輪替操作對象。";
"Uyz-xL-TVN.title" = "輸出設定"; "Uyz-xL-TVN.title" = "輸出設定";
"W24-T4-cg0.title" = "啟用 CNS11643 全字庫支援 (2022-06-15)"; "W24-T4-cg0.title" = "啟用 CNS11643 全字庫支援 (2022-06-15)";
"wFR-zX-M8H.title" = "拼音並擊模式（組字區內看到的是漢語拼音）"; "wFR-zX-M8H.title" = "拼音並擊（組字區與工具提示內顯示漢語拼音）";
"wN3-k3-b2a.title" = "請在此指定您想指定的使用者語彙檔案目錄。無效值會被忽略。"; "wN3-k3-b2a.title" = "請在此指定您想指定的使用者語彙檔案目錄。無效值會被忽略。";
"wQ9-px-b07.title" = "Apple 動態注音鍵盤佈局（大千與倚天）要求普通話/國音分析器的注音排列得配置為大千排列。"; "wQ9-px-b07.title" = "Apple 動態注音鍵盤佈局（大千與倚天）要求普通話/國音分析器的注音排列得配置為大千排列。";
"Wvt-HE-LOv.title" = "鍵盤佈局"; "Wvt-HE-LOv.title" = "鍵盤佈局";

4
Update-Info.plist
View File

@ -3,9 +3,9 @@
<plist version="1.0"> <plist version="1.0">
<dict> <dict>
<key>CFBundleShortVersionString</key> <key>CFBundleShortVersionString</key>
<string>1.7.4</string> <string>1.8.0</string>
<key>CFBundleVersion</key> <key>CFBundleVersion</key>
<string>1974</string> <string>1980</string>
<key>UpdateInfoEndpoint</key> <key>UpdateInfoEndpoint</key>
<string>https://gitee.com/vchewing/vChewing-macOS/raw/main/Update-Info.plist</string> <string>https://gitee.com/vchewing/vChewing-macOS/raw/main/Update-Info.plist</string>
<key>UpdateInfoSite</key> <key>UpdateInfoSite</key>

2
vChewing.pkgproj
View File

@ -726,7 +726,7 @@
<key>USE_HFS+_COMPRESSION</key> <key>USE_HFS+_COMPRESSION</key>
<false/> <false/>
<key>VERSION</key> <key>VERSION</key>
<string>1.7.4</string> <string>1.8.0</string>
</dict> </dict>
<key>TYPE</key> <key>TYPE</key>
<integer>0</integer> <integer>0</integer>

32
vChewing.xcodeproj/project.pbxproj
View File

@ -1365,7 +1365,7 @@
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
CURRENT_PROJECT_VERSION = 1974; CURRENT_PROJECT_VERSION = 1980;
GCC_C_LANGUAGE_STANDARD = gnu11; GCC_C_LANGUAGE_STANDARD = gnu11;
GCC_DYNAMIC_NO_PIC = NO; GCC_DYNAMIC_NO_PIC = NO;
GCC_PREPROCESSOR_DEFINITIONS = ( GCC_PREPROCESSOR_DEFINITIONS = (
@ -1375,7 +1375,7 @@
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GENERATE_INFOPLIST_FILE = YES; GENERATE_INFOPLIST_FILE = YES;
MARKETING_VERSION = 1.7.4; MARKETING_VERSION = 1.8.0;
MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.vChewingTests; PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.vChewingTests;
@ -1404,13 +1404,13 @@
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
CURRENT_PROJECT_VERSION = 1974; CURRENT_PROJECT_VERSION = 1980;
ENABLE_NS_ASSERTIONS = NO; ENABLE_NS_ASSERTIONS = NO;
GCC_C_LANGUAGE_STANDARD = gnu11; GCC_C_LANGUAGE_STANDARD = gnu11;
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GENERATE_INFOPLIST_FILE = YES; GENERATE_INFOPLIST_FILE = YES;
MARKETING_VERSION = 1.7.4; MARKETING_VERSION = 1.8.0;
MTL_ENABLE_DEBUG_INFO = NO; MTL_ENABLE_DEBUG_INFO = NO;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.vChewingTests; PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.vChewingTests;
@ -1441,7 +1441,7 @@
CODE_SIGN_IDENTITY = "-"; CODE_SIGN_IDENTITY = "-";
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES; COMBINE_HIDPI_IMAGES = YES;
CURRENT_PROJECT_VERSION = 1974; CURRENT_PROJECT_VERSION = 1980;
DEAD_CODE_STRIPPING = YES; DEAD_CODE_STRIPPING = YES;
GCC_C_LANGUAGE_STANDARD = gnu11; GCC_C_LANGUAGE_STANDARD = gnu11;
GCC_DYNAMIC_NO_PIC = NO; GCC_DYNAMIC_NO_PIC = NO;
@ -1462,7 +1462,7 @@
"$(inherited)", "$(inherited)",
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
); );
MARKETING_VERSION = 1.7.4; MARKETING_VERSION = 1.8.0;
MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.vChewing.vChewingPhraseEditor; PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.vChewing.vChewingPhraseEditor;
@ -1491,7 +1491,7 @@
CODE_SIGN_IDENTITY = "-"; CODE_SIGN_IDENTITY = "-";
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES; COMBINE_HIDPI_IMAGES = YES;
CURRENT_PROJECT_VERSION = 1974; CURRENT_PROJECT_VERSION = 1980;
DEAD_CODE_STRIPPING = YES; DEAD_CODE_STRIPPING = YES;
ENABLE_NS_ASSERTIONS = NO; ENABLE_NS_ASSERTIONS = NO;
GCC_C_LANGUAGE_STANDARD = gnu11; GCC_C_LANGUAGE_STANDARD = gnu11;
@ -1508,7 +1508,7 @@
"$(inherited)", "$(inherited)",
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
); );
MARKETING_VERSION = 1.7.4; MARKETING_VERSION = 1.8.0;
MTL_ENABLE_DEBUG_INFO = NO; MTL_ENABLE_DEBUG_INFO = NO;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.vChewing.vChewingPhraseEditor; PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.vChewing.vChewingPhraseEditor;
@ -1618,7 +1618,7 @@
CODE_SIGN_IDENTITY = "-"; CODE_SIGN_IDENTITY = "-";
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES; COMBINE_HIDPI_IMAGES = YES;
CURRENT_PROJECT_VERSION = 1974; CURRENT_PROJECT_VERSION = 1980;
DEAD_CODE_STRIPPING = YES; DEAD_CODE_STRIPPING = YES;
DEVELOPMENT_ASSET_PATHS = ""; DEVELOPMENT_ASSET_PATHS = "";
DEVELOPMENT_TEAM = ""; DEVELOPMENT_TEAM = "";
@ -1649,7 +1649,7 @@
"$(inherited)", "$(inherited)",
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
); );
MARKETING_VERSION = 1.7.4; MARKETING_VERSION = 1.8.0;
ONLY_ACTIVE_ARCH = YES; ONLY_ACTIVE_ARCH = YES;
PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.inputmethod.vChewing; PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.inputmethod.vChewing;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -1676,7 +1676,7 @@
CODE_SIGN_IDENTITY = "-"; CODE_SIGN_IDENTITY = "-";
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES; COMBINE_HIDPI_IMAGES = YES;
CURRENT_PROJECT_VERSION = 1974; CURRENT_PROJECT_VERSION = 1980;
DEAD_CODE_STRIPPING = YES; DEAD_CODE_STRIPPING = YES;
DEVELOPMENT_ASSET_PATHS = ""; DEVELOPMENT_ASSET_PATHS = "";
DEVELOPMENT_TEAM = ""; DEVELOPMENT_TEAM = "";
@ -1701,7 +1701,7 @@
"$(inherited)", "$(inherited)",
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
); );
MARKETING_VERSION = 1.7.4; MARKETING_VERSION = 1.8.0;
PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.inputmethod.vChewing; PRODUCT_BUNDLE_IDENTIFIER = org.atelierInmu.inputmethod.vChewing;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
PROVISIONING_PROFILE_SPECIFIER = ""; PROVISIONING_PROFILE_SPECIFIER = "";
@ -1723,7 +1723,7 @@
CODE_SIGN_IDENTITY = "-"; CODE_SIGN_IDENTITY = "-";
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES; COMBINE_HIDPI_IMAGES = YES;
CURRENT_PROJECT_VERSION = 1974; CURRENT_PROJECT_VERSION = 1980;
DEAD_CODE_STRIPPING = YES; DEAD_CODE_STRIPPING = YES;
DEVELOPMENT_TEAM = ""; DEVELOPMENT_TEAM = "";
GCC_C_LANGUAGE_STANDARD = gnu99; GCC_C_LANGUAGE_STANDARD = gnu99;
@ -1744,7 +1744,7 @@
"$(inherited)", "$(inherited)",
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
); );
MARKETING_VERSION = 1.7.4; MARKETING_VERSION = 1.8.0;
ONLY_ACTIVE_ARCH = YES; ONLY_ACTIVE_ARCH = YES;
PRODUCT_BUNDLE_IDENTIFIER = "org.atelierInmu.vChewing.${PRODUCT_NAME:rfc1034identifier}"; PRODUCT_BUNDLE_IDENTIFIER = "org.atelierInmu.vChewing.${PRODUCT_NAME:rfc1034identifier}";
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -1766,7 +1766,7 @@
CODE_SIGN_IDENTITY = "-"; CODE_SIGN_IDENTITY = "-";
CODE_SIGN_STYLE = Automatic; CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES; COMBINE_HIDPI_IMAGES = YES;
CURRENT_PROJECT_VERSION = 1974; CURRENT_PROJECT_VERSION = 1980;
DEAD_CODE_STRIPPING = YES; DEAD_CODE_STRIPPING = YES;
DEVELOPMENT_TEAM = ""; DEVELOPMENT_TEAM = "";
GCC_C_LANGUAGE_STANDARD = gnu99; GCC_C_LANGUAGE_STANDARD = gnu99;
@ -1781,7 +1781,7 @@
"$(inherited)", "$(inherited)",
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
); );
MARKETING_VERSION = 1.7.4; MARKETING_VERSION = 1.8.0;
PRODUCT_BUNDLE_IDENTIFIER = "org.atelierInmu.vChewing.${PRODUCT_NAME:rfc1034identifier}"; PRODUCT_BUNDLE_IDENTIFIER = "org.atelierInmu.vChewing.${PRODUCT_NAME:rfc1034identifier}";
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
PROVISIONING_PROFILE_SPECIFIER = ""; PROVISIONING_PROFILE_SPECIFIER = "";

6
vChewingTests/KeyHandlerTestsNormalCHS.swift
View File

@ -365,7 +365,7 @@ class KeyHandlerTestsNormalCHS: XCTestCase {
XCTAssertTrue(state is InputState.ChoosingCandidate, "\(state)") XCTAssertTrue(state is InputState.ChoosingCandidate, "\(state)")
if let state = state as? InputState.ChoosingCandidate { if let state = state as? InputState.ChoosingCandidate {
XCTAssertTrue(state.candidates.contains("！")) XCTAssertTrue(state.candidates.map(\.1).contains("！"))
} }
mgrPrefs.halfWidthPunctuationEnabled = enabled mgrPrefs.halfWidthPunctuationEnabled = enabled
} }
@ -993,7 +993,7 @@ class KeyHandlerTestsNormalCHS: XCTestCase {
XCTAssertEqual(state.composingBuffer, "你") XCTAssertEqual(state.composingBuffer, "你")
XCTAssertEqual(state.cursorIndex, 1) XCTAssertEqual(state.cursorIndex, 1)
let candidates = state.candidates let candidates = state.candidates
XCTAssertTrue(candidates.contains("你")) XCTAssertTrue(candidates.map(\.1).contains("你"))
} }
} }
@ -1030,7 +1030,7 @@ class KeyHandlerTestsNormalCHS: XCTestCase {
XCTAssertEqual(state.composingBuffer, "你") XCTAssertEqual(state.composingBuffer, "你")
XCTAssertEqual(state.cursorIndex, 1) XCTAssertEqual(state.cursorIndex, 1)
let candidates = state.candidates let candidates = state.candidates
XCTAssertTrue(candidates.contains("你")) XCTAssertTrue(candidates.map(\.1).contains("你"))
} }
mgrPrefs.chooseCandidateUsingSpace = enabled mgrPrefs.chooseCandidateUsingSpace = enabled
} }

6
vChewingTests/KeyHandlerTestsSCPCCHT.swift
View File

@ -85,7 +85,7 @@ class KeyHandlerTestsSCPCCHT: XCTestCase {
XCTAssertTrue(state is InputState.ChoosingCandidate, "\(state)") XCTAssertTrue(state is InputState.ChoosingCandidate, "\(state)")
if let state = state as? InputState.ChoosingCandidate { if let state = state as? InputState.ChoosingCandidate {
XCTAssertTrue(state.candidates.contains("，")) XCTAssertTrue(state.candidates.map(\.1).contains("，"))
} }
} }
@ -238,7 +238,7 @@ class KeyHandlerTestsSCPCCHT: XCTestCase {
XCTAssertTrue(state is InputState.ChoosingCandidate, "\(state)") XCTAssertTrue(state is InputState.ChoosingCandidate, "\(state)")
if let state = state as? InputState.ChoosingCandidate { if let state = state as? InputState.ChoosingCandidate {
XCTAssertTrue(state.candidates.contains("你")) XCTAssertTrue(state.candidates.map(\.1).contains("你"))
} }
} }
@ -315,7 +315,7 @@ class KeyHandlerTestsSCPCCHT: XCTestCase {
print("\(state)") print("\(state)")
// XCTAssertTrue(state is InputState.AssociatedPhrases, "\(state)") // XCTAssertTrue(state is InputState.AssociatedPhrases, "\(state)")
// if let state = state as? InputState.AssociatedPhrases { // if let state = state as? InputState.AssociatedPhrases {
// XCTAssertTrue(state.candidates.contains("百五")) // XCTAssertTrue(state.candidates.map(\.1).contains("百五"))
// } // }
mgrPrefs.associatedPhrasesEnabled = enabled mgrPrefs.associatedPhrasesEnabled = enabled
} }