from typing import List, Dict import gi gi.require_version('IBus', '1.0') from gi.repository import IBus from gi.repository import GLib import os import sys import re import logging import pathlib from jaconv import jaconv from comb import combromkan from comb.engine import Comb from comb.node import Node from comb.user_language_model import UserLanguageModel from comb.system_dict import SystemDict from comb.user_dict import load_user_dict_from_json_config MODE_KANA = 1 MODE_ALPHA = 2 num_keys = [] for n in range(1, 10): num_keys.append(getattr(IBus, str(n))) num_keys.append(getattr(IBus, '0')) del n numpad_keys = [] for n in range(1, 10): numpad_keys.append(getattr(IBus, 'KP_' + str(n))) numpad_keys.append(getattr(IBus, 'KP_0')) del n configdir = os.path.join(GLib.get_user_config_dir(), 'ibus-comb') pathlib.Path(os.path.join(configdir, 'user-dict')).mkdir(parents=True, exist_ok=True) logging.info(f"Loading user dictionary: {configdir}") user_language_model = UserLanguageModel(os.path.join(configdir, 'user-dict')) logging.info("Loaded user dictionary") system_dict = SystemDict.create() logging.info("Loaded system dictionary") try: user_dict_conf_path = os.path.join(configdir, 'user-dict.json') logging.info(f"user_dict_conf_path={user_dict_conf_path}") user_dict = None if os.path.exists(user_dict_conf_path): logging.info(f"Loading '{user_dict_conf_path}'") try: user_dict = load_user_dict_from_json_config(user_dict_conf_path) except: logging.error("Cannot load user dictionary", exc_info=True) else: logging.info(f"'{user_dict_conf_path}' does not exist.") comb = Comb(user_language_model, system_dict, user_dict) logging.info("Finished Comb.") except: logging.error("Cannot initialize.", exc_info=True) sys.exit(1) # ---------------------------------------------------------------------- # the engine # ---------------------------------------------------------------------- class CombIBusEngine(IBus.Engine): user_language_model: UserLanguageModel current_clause: int node_selected: Dict[int, int] clauses: List[List[Node]] prop_list: IBus.PropList comb: Comb mode: int force_selected_clause: List[slice] __gtype_name__ = 'CombIBusEngine' def __init__(self): super(CombIBusEngine, self).__init__() self.is_invalidate = False # 未確定文字列。 self.preedit_string = '' # 候補文字列 self.lookup_table = IBus.LookupTable.new(page_size=10, cursor_pos=0, cursor_visible=True, round=True) self.prop_list = IBus.PropList() self.comb = comb self.user_language_model = user_language_model self.user_dict = user_dict self.logger = logging.getLogger(__name__) self.mode = MODE_KANA # 変換候補。文節ごとの配列。 self.clauses = [] # 現在選択されている、文節。 self.current_clause = 0 # key は、clause 番号。value は、node の index。 self.node_selected = {} # 文節を選びなおしたもの。 self.force_selected_clause = [] # カーソル変更をしたばっかりかどうかを、みるフラグ。 self.cursor_moved = False self.logger.debug("Create Comb engine OK") def set_lookup_table_cursor_pos_in_current_page(self, index): """Sets the cursor in the lookup table to index in the current page Returns True if successful, False if not. """ self.logger.info(f"set_lookup_table_cursor_pos_in_current_page: {index}") page_size = self.lookup_table.get_page_size() if index > page_size: self.logger.info(f"index too big: {index} > {page_size}") return False page, pos_in_page = divmod(self.lookup_table.get_cursor_pos(), page_size) new_pos = page * page_size + index if new_pos > self.lookup_table.get_number_of_candidates(): self.logger.info(f"new_pos too big: {new_pos} > {self.lookup_table.get_number_of_candidates()}") return False self.lookup_table.set_cursor_pos(new_pos) self.node_selected[self.current_clause] = self.lookup_table.get_cursor_pos() return True def do_candidate_clicked(self, index, dummy_button, dummy_state): if self.set_lookup_table_cursor_pos_in_current_page(index): self.commit_candidate() def do_process_key_event(self, keyval, keycode, state): try: return self._do_process_key_event(keyval, keycode, state) except: self.logger.error(f"Cannot process key event: keyval={keyval} keycode={keycode} state={state}", exc_info=True) return False def _do_process_key_event(self, keyval, keycode, state): # self.logger.debug("process_key_event(%04x, %04x, %04x)" % (keyval, keycode, state)) # ignore key release events is_press = ((state & IBus.ModifierType.RELEASE_MASK) == 0) if not is_press: return False # 入力モードの切り替え機能。 if keyval == IBus.Henkan: self.logger.info("Switch to kana mode") self.mode = MODE_KANA return True elif keyval == IBus.Muhenkan: self.logger.info("Switch to alpha mode") self.mode = MODE_ALPHA return True if self.preedit_string: if keyval in (IBus.Return, IBus.KP_Enter): if self.in_henkan_mode(): self.commit_candidate() else: # 無変換状態では、ひらがなに変換してコミットします。 self.commit_string(combromkan.to_hiragana(self.preedit_string)) return True elif keyval == IBus.Escape: self.preedit_string = '' self.update_candidates() return True elif keyval == IBus.BackSpace: if self.in_henkan_mode(): # 変換中の場合、無変換モードにもどす。 self.lookup_table.clear() self.hide_auxiliary_text() self.hide_lookup_table() else: # サイゴの一文字をけずるが、子音が先行しているばあいは、子音もついでにとる。 self.preedit_string = re.sub('(?:z[hjkl.-]|n+|[kstnhmyrwgzjdbp]?[aiueo]|.)$', '', self.preedit_string) # 変換していないときのレンダリングをする。 self.update_preedit_text_before_henkan() return True elif keyval in num_keys and self.in_henkan_mode(): # TODO: 変換候補が表示されている状態の時にのみハンドリングされるべき。 index = num_keys.index(keyval) if self.set_lookup_table_cursor_pos_in_current_page(index): self.refresh() return True return False elif keyval in numpad_keys and self.in_henkan_mode(): # TODO: 変換候補が表示されている状態の時にのみハンドリングされるべき。 index = numpad_keys.index(keyval) if self.set_lookup_table_cursor_pos_in_current_page(index): self.refresh() return True return False elif keyval in (IBus.Page_Up, IBus.KP_Page_Up): self.page_up() return True elif keyval in (IBus.Page_Down, IBus.KP_Page_Down): self.page_down() return True elif keyval in (IBus.Up, IBus.KP_Up): self.cursor_up() return True elif keyval in (IBus.Down, IBus.KP_Down): self.cursor_down() return True elif keyval in (IBus.Right, IBus.KP_Right): if state & IBus.ModifierType.SHIFT_MASK == 0: self.cursor_right() else: self.extend_clause_right() return True elif keyval in (IBus.Left, IBus.KP_Left): if state & IBus.ModifierType.SHIFT_MASK == 0: self.cursor_left() else: self.extend_clause_left() return True elif keyval == IBus.F6: # F6 convert selected word/characters to full-width hiragana (standard hiragana): ホワイト → ほわいと self.convert_to_full_hiragana() return True elif keyval == IBus.F7: # F7 convert to full-width katakana (standard katakana): ほわいと → ホワイト self.convert_to_full_katakana() return True elif keyval == IBus.F8: # F8 convert to half-width katakana (katakana for specific purpose): ホワイト → ﾎﾜｲﾄ self.convert_to_half_katakana() return True elif keyval == IBus.F9: # F9 convert to full-width romaji, all-capitals, proper noun capitalization (latin script inside # Japanese text): ホワイト → ｈｏｗａｉｔｏ → ＨＯＷＡＩＴＯ → Ｈｏｗａｉｔｏ self.convert_to_full_romaji() return True elif keyval == IBus.F10: # F10 convert to half-width romaji, all-capitals, proper noun capitalization (latin script like # standard English): ホワイト → howaito → HOWAITO → Howaito self.convert_to_half_romaji() return True # スペース if keyval == IBus.space: if len(self.preedit_string) == 0: # もし、まだなにもはいっていなければ、ただの空白をそのままいれる。 return False else: if self.in_henkan_mode(): self.logger.debug("cursor down.") self.cursor_down() else: # 実際に変換していく。 self.logger.debug("update_candidates.") self.update_candidates() return True if self.mode == MODE_KANA: # Allow typing all ASCII letters and punctuation if ord('!') <= keyval <= ord('~'): if state & (IBus.ModifierType.CONTROL_MASK | IBus.ModifierType.MOD1_MASK) == 0: if self.in_henkan_mode(): self.commit_candidate() self.preedit_string += chr(keyval) # この時点では、preedit string にだけ、追加して表示するひつようがあります。 self.update_preedit_text_before_henkan() return True else: if keyval < 128 and self.preedit_string: self.commit_string(self.preedit_string) else: return False return False def in_henkan_mode(self): return self.lookup_table.get_number_of_candidates() > 0 def convert_to_full_katakana(self): self.logger.info("Convert to full katakana") # カタカナ候補のみを表示するようにする。 hira = combromkan.to_hiragana(self.preedit_string) kata = jaconv.hira2kata(hira) self.convert_to_single(hira, kata) def convert_to_full_hiragana(self): self.logger.info("Convert to full hiragana") # カタカナ候補のみを表示するようにする。 hira = combromkan.to_hiragana(self.preedit_string) self.convert_to_single(hira, hira) def convert_to_half_katakana(self): self.logger.info("Convert to half katakana") # 半角カタカナ候補のみを表示するようにする。 hira = combromkan.to_hiragana(self.preedit_string) kata = jaconv.hira2kata(hira) kata = jaconv.z2h(kata) self.convert_to_single(hira, kata) def convert_to_half_romaji(self): self.logger.info("Convert to half romaji") # 半角カタカナ候補のみを表示するようにする。 hira = combromkan.to_hiragana(self.preedit_string) romaji = jaconv.z2h(self.preedit_string) self.convert_to_single(hira, romaji) def convert_to_full_romaji(self): self.logger.info("Convert to full romaji") hira = combromkan.to_hiragana(self.preedit_string) romaji = jaconv.h2z(self.preedit_string, kana=True, digit=True, ascii=True) self.convert_to_single(hira, romaji) def convert_to_single(self, yomi, word) -> None: """ 特定の1文節の文章を候補として表示する。 F6 などを押した時用。 """ # 候補を設定 self.clauses = [[Node(start_pos=0, word=word, yomi=yomi)]] self.current_clause = 0 self.node_selected = {} self.force_selected_clause = [] # ルックアップテーブルに候補を設定 self.lookup_table.clear() candidate = IBus.Text.new_from_string(word) self.lookup_table.append_candidate(candidate) # 表示を更新 self.refresh() def invalidate(self): if self.is_invalidate: return self.is_invalidate = True GLib.idle_add(self.update_candidates) def page_up(self): if self.lookup_table.page_up(): self.node_selected[self.current_clause] = self.lookup_table.get_cursor_pos() self.cursor_moved = True self.refresh() return True return False def page_down(self): if self.lookup_table.page_down(): self.node_selected[self.current_clause] = self.lookup_table.get_cursor_pos() self.cursor_moved = True self.refresh() return True return False def cursor_up(self): if self.lookup_table.cursor_up(): self.node_selected[self.current_clause] = self.lookup_table.get_cursor_pos() self.cursor_moved = True self.refresh() return True return False def cursor_down(self): """ 次の変換候補を選択する。 """ if self.lookup_table.cursor_down(): self.node_selected[self.current_clause] = self.lookup_table.get_cursor_pos() self.cursor_moved = True self.refresh() return True return False # 選択する分節を右にずらす。 def cursor_right(self): """ 選択する分節を右にずらす。 """ self.logger.info(f"right cursor") # いっこしか分節がない場合は、何もせぬ if len(self.clauses) == 0: self.logger.info(f"right cursor：no clauses") return False # 既に一番右だった場合、一番左にいく。 if self.current_clause == len(self.clauses) - 1: self.current_clause = 0 else: self.current_clause += 1 self.cursor_moved = True self.create_lookup_table() self.refresh() # 選択する分節を左にずらす。 def cursor_left(self): self.logger.info(f"left cursor") # いっこしか分節がない場合は、何もせぬ if len(self.clauses) == 0: self.logger.info(f"left cursor：no clauses") return False # 既に一番左だった場合、一番右にいく。 if self.current_clause == 0: self.current_clause = len(self.clauses) - 1 else: self.current_clause -= 1 self.cursor_moved = True self.create_lookup_table() self.refresh() def extend_clause_right(self): """ 文節の選択範囲を広げることを支持する """ if len(self.clauses) == 0: return False max_len = max([clause[0].start_pos + len(clause[0].yomi) for clause in self.clauses]) self.force_selected_clause = [] for i, clause in enumerate(self.clauses): node = clause[0] if self.current_clause == i: # 現在選択中の文節の場合、伸ばす。 self.force_selected_clause.append( slice(node.start_pos, min(node.start_pos + len(node.yomi) + 1, max_len))) elif self.current_clause + 1 == i: # 次の分節を一文字ヘラス self.force_selected_clause.append( slice(node.start_pos + 1, node.start_pos + len(node.yomi))) else: # それ以外は現在指定の分節のまま self.force_selected_clause.append( slice(node.start_pos, node.start_pos + len(node.yomi))) self.force_selected_clause = [x for x in self.force_selected_clause if x.start != x.stop] self._update_candidates() def extend_clause_left(self): """ 文節の選択範囲を広げることを支持する """ if len(self.clauses) == 0: return False # 一番左の文節にフォーカスがある場合、一番左の文節が短くなるべき。 target_clause = 1 if self.current_clause == 0 and len(self.clauses) > 1 else self.current_clause self.force_selected_clause = [] for i, clause in enumerate(self.clauses): node = clause[0] if target_clause == i: # 現在選択中の文節の場合、伸ばす。 self.force_selected_clause.append( slice(node.start_pos - 1, node.start_pos + len(node.yomi))) elif target_clause - 1 == i: # 前の分節を一文字ヘラス self.force_selected_clause.append( slice(node.start_pos, node.start_pos + len(node.yomi) - 1)) else: # それ以外は現在指定の分節のまま self.force_selected_clause.append( slice(node.start_pos, node.start_pos + len(node.yomi))) self.force_selected_clause = [x for x in self.force_selected_clause if x.start != x.stop] self._update_candidates() def commit_string(self, text): self.cursor_moved = False if self.in_henkan_mode(): # 変換モードのときのみ学習を実施する。 candidate_nodes = [] for clauseid, nodes in enumerate(self.clauses): candidate_nodes.append(nodes[self.node_selected.get(clauseid, 0)]) self.user_language_model.add_entry(candidate_nodes) # user language model の書き出しは、バックグラウンドスレッドでやりたい。 self.user_language_model.save() self.commit_text(IBus.Text.new_from_string(text)) self.preedit_string = '' self.clauses = [] self.current_clause = 0 self.node_selected = {} self.force_selected_clause = [] self.update_candidates() def build_string(self): result = '' for clauseid, nodes in enumerate(self.clauses): result += nodes[self.node_selected.get(clauseid, 0)].word return result def commit_candidate(self): s = self.build_string() self.logger.info(f"Committing {s}") self.commit_string(s) def update_candidates(self): self.logger.info("update_candidates") try: self._update_candidates() except: self.logger.error(f"cannot get kanji candidates {sys.exc_info()[0]}", exc_info=True) def _update_candidates(self): if len(self.preedit_string) > 0: # 変換をかける self.clauses = self.comb.convert(self.preedit_string, self.force_selected_clause) else: self.clauses = [] self.create_lookup_table() self.current_clause = 0 self.node_selected = {} self.refresh() def refresh(self): preedit_len = len(self.preedit_string) if len(self.clauses) == 0: self.hide_auxiliary_text() self.hide_lookup_table() self.hide_preedit_text() return current_clause = self.clauses[self.current_clause] current_node = current_clause[0] # -- auxiliary text(ポップアップしてるやつのほう) first_candidate = current_node.yomi auxiliary_text = IBus.Text.new_from_string(first_candidate) auxiliary_text.set_attributes(IBus.AttrList()) self.update_auxiliary_text(auxiliary_text, preedit_len > 0) text = self.build_string() preedit_attrs = IBus.AttrList() # 全部に下線をひく。 preedit_attrs.append(IBus.Attribute.new(IBus.AttrType.UNDERLINE, IBus.AttrUnderline.SINGLE, 0, len(text))) bgstart = sum([len(self.clauses[i][0].word) for i in range(0, self.current_clause)]) # 背景色を設定する。 preedit_attrs.append(IBus.Attribute.new( IBus.AttrType.BACKGROUND, 0x00333333, bgstart, bgstart + len(current_node.word))) preedit_text = IBus.Text.new_from_string(text) preedit_text.set_attributes(preedit_attrs) self.update_preedit_text(preedit_text, len(text), len(text) > 0) # 候補があれば、選択肢を表示させる。 self._update_lookup_table() self.is_invalidate = False def update_preedit_text_before_henkan(self): """ 無変換状態で、どんどん入力していくフェーズ。 """ if len(self.preedit_string) == 0: self.hide_preedit_text() return # 平仮名にする。 text = combromkan.to_hiragana(self.preedit_string) self.clauses = [ [Node(word=text, yomi=text, start_pos=3)] ] self.current_clause = 0 preedit_attrs = IBus.AttrList() preedit_attrs.append(IBus.Attribute.new(IBus.AttrType.UNDERLINE, IBus.AttrUnderline.SINGLE, 0, len(text))) preedit_text = IBus.Text.new_from_string(text) preedit_text.set_attributes(preedit_attrs) self.update_preedit_text(preedit_text, len(text), len(text) > 0) def create_lookup_table(self): """ 現在の候補選択状態から、 lookup table を構築する。 """ # 一旦、ルックアップテーブルをクリアする self.lookup_table.clear() # 現在の未変換情報を元に、候補を産出していく。 if len(self.clauses) > 0: # lookup table に候補を詰め込んでいく。 for node in self.clauses[self.current_clause]: candidate = IBus.Text.new_from_string(node.word) self.lookup_table.append_candidate(candidate) def _update_lookup_table(self): """ 候補があれば lookup table を表示。なければ非表示にする。 """ visible = self.lookup_table.get_number_of_candidates() > 0 self.update_lookup_table(self.lookup_table, visible) def do_focus_in(self): # self.logger.debug("focus_in") self.register_properties(self.prop_list) def do_focus_out(self): # self.logger.debug("focus_out") self.do_reset() def do_reset(self): # self.logger.debug("reset") self.preedit_string = '' self.force_selected_clause = [] self.clauses = [] self.current_clause = 0 self.lookup_table.clear() self.hide_auxiliary_text() self.hide_lookup_table() def do_property_activate(self, prop_name): self.logger.debug("PropertyActivate(%s)" % prop_name) def do_page_up(self): return self.page_up() def do_page_down(self): return self.page_down() def do_cursor_up(self): return self.cursor_up() def do_cursor_down(self): return self.cursor_down()