def __init__(self, keyval, keycode, state):
self.val = keyval
self.code = keycode
self.state = state
self.name = IBus.keyval_name(self.val)
self.unicode = IBus.keyval_to_unicode(self.val)
self.shift = self.state & IBus.ModifierType.SHIFT_MASK != 0
self.lock = self.state & IBus.ModifierType.LOCK_MASK != 0
self.control = self.state & IBus.ModifierType.CONTROL_MASK != 0
self.mod1 = self.state & IBus.ModifierType.MOD1_MASK != 0
self.mod2 = self.state & IBus.ModifierType.MOD2_MASK != 0
self.mod3 = self.state & IBus.ModifierType.MOD3_MASK != 0
self.mod4 = self.state & IBus.ModifierType.MOD4_MASK != 0
self.mod5 = self.state & IBus.ModifierType.MOD5_MASK != 0
self.button1 = self.state & IBus.ModifierType.BUTTON1_MASK != 0
self.button2 = self.state & IBus.ModifierType.BUTTON2_MASK != 0
self.button3 = self.state & IBus.ModifierType.BUTTON3_MASK != 0
self.button4 = self.state & IBus.ModifierType.BUTTON4_MASK != 0
self.button5 = self.state & IBus.ModifierType.BUTTON5_MASK != 0
self.super = self.state & IBus.ModifierType.SUPER_MASK != 0
self.hyper = self.state & IBus.ModifierType.HYPER_MASK != 0
self.meta = self.state & IBus.ModifierType.META_MASK != 0
self.release = self.state & IBus.ModifierType.RELEASE_MASK != 0
# MODIFIER_MASK: Modifier mask for the all the masks above
self.modifier = self.state & IBus.ModifierType.MODIFIER_MASK != 0
def __init__(self, keyval, keycode, state):
self.val = keyval
self.code = keycode
self.state = state
self.name = IBus.keyval_name(self.val)
self.unicode = IBus.keyval_to_unicode(self.val)
self.shift = self.state & IBus.ModifierType.SHIFT_MASK != 0
self.lock = self.state & IBus.ModifierType.LOCK_MASK != 0
self.control = self.state & IBus.ModifierType.CONTROL_MASK != 0
self.super = self.state & IBus.ModifierType.SUPER_MASK != 0
self.hyper = self.state & IBus.ModifierType.HYPER_MASK != 0
self.meta = self.state & IBus.ModifierType.META_MASK != 0
# mod1: Usually Alt_L (0x40), Alt_R (0x6c), Meta_L (0xcd)
self.mod1 = self.state & IBus.ModifierType.MOD1_MASK != 0
# mod2: Usually Num_Lock (0x4d)
self.mod2 = self.state & IBus.ModifierType.MOD2_MASK != 0
self.mod3 = self.state & IBus.ModifierType.MOD3_MASK != 0
# mod4: Usually Super_L (0xce), Hyper_L (0xcf)
self.mod4 = self.state & IBus.ModifierType.MOD4_MASK != 0
# mod5: ISO_Level3_Shift (0x5c), Mode_switch (0xcb)
self.mod5 = self.state & IBus.ModifierType.MOD5_MASK != 0
self.button1 = self.state & IBus.ModifierType.BUTTON1_MASK != 0
self.button2 = self.state & IBus.ModifierType.BUTTON2_MASK != 0
self.button3 = self.state & IBus.ModifierType.BUTTON3_MASK != 0
self.button4 = self.state & IBus.ModifierType.BUTTON4_MASK != 0
self.button5 = self.state & IBus.ModifierType.BUTTON5_MASK != 0
self.release = self.state & IBus.ModifierType.RELEASE_MASK != 0
# MODIFIER_MASK: Modifier mask for the all the masks above
self.modifier = self.state & IBus.ModifierType.MODIFIER_MASK != 0
def process_key_event(self, keyval, keycode, state):
logger.debug(
"process_key_event(%s, %04x, %04x) %02x" %
(IBus.keyval_name(keyval), keycode, state, self.__modifiers))
# Ignore XFree86 anomaly.
if keyval == keysyms.ISO_Left_Tab:
keyval = keysyms.Tab
elif keyval == 0x1008ff81:
keyval = keysyms.F13
elif keyval == 0x1008ff45:
keyval = keysyms.F14
self.__modifiers &= ~bits.Dual_Bits
is_press = ((state & IBus.ModifierType.RELEASE_MASK) == 0)
if is_press:
if keyval == keysyms.space:
self.__modifiers |= bits.Space_Bit
self.__modifiers &= ~bits.Not_Dual_Space_Bit
elif keyval == keysyms.Shift_L:
self.__modifiers |= bits.ShiftL_Bit
self.__modifiers &= ~bits.Not_Dual_ShiftL_Bit
elif keyval == keysyms.Shift_R:
self.__modifiers |= bits.ShiftR_Bit
self.__modifiers &= ~bits.Not_Dual_ShiftR_Bit
elif keyval == keysyms.Control_L:
self.__modifiers |= bits.ControlL_Bit
elif keyval == keysyms.Control_R:
self.__modifiers |= bits.ControlR_Bit
self.__modifiers &= ~bits.Not_Dual_ControlR_Bit
elif keyval == keysyms.Alt_R:
self.__modifiers |= bits.AltR_Bit
self.__modifiers &= ~bits.Not_Dual_AltR_Bit
if (self.__modifiers & bits.Space_Bit) and keyval != keysyms.space:
self.__modifiers |= bits.Not_Dual_Space_Bit
if (self.__modifiers
& bits.ShiftL_Bit) and keyval != keysyms.Shift_L:
self.__modifiers |= bits.Not_Dual_ShiftL_Bit
if (self.__modifiers
& bits.ShiftR_Bit) and keyval != keysyms.Shift_R:
self.__modifiers |= bits.Not_Dual_ShiftR_Bit
if (self.__modifiers
& bits.ControlR_Bit) and keyval != keysyms.Control_R:
self.__modifiers |= bits.Not_Dual_ControlR_Bit
if (self.__modifiers & bits.AltR_Bit) and keyval != keysyms.Alt_R:
self.__modifiers |= bits.Not_Dual_AltR_Bit
# Check CAPS LOCK for IME on/off
if self.__OnOffByCaps:
if keyval == keysyms.Caps_Lock:
# Note CAPS LOCK LED is turned off after the key release event.
if state & IBus.ModifierType.LOCK_MASK:
self.__engine.disable_ime()
else:
self.__engine.enable_ime()
return True
elif not self.__engine.is_overridden():
if state & IBus.ModifierType.LOCK_MASK:
self.__engine.enable_ime()
else:
self.__engine.disable_ime()
elif keyval == self.__Eisuu or keyval == keysyms.Zenkaku_Hankaku:
if self.__engine.is_enabled():
self.__engine.disable_ime()
else:
self.__engine.enable_ime()
return True
if self.__engine.is_enabled():
if keyval == keysyms.Muhenkan:
self.__engine.disable_ime()
return True
elif keyval == keysyms.Henkan:
self.__engine.enable_ime()
return True
else:
if keyval == keysyms.space:
if not (self.__modifiers & bits.Not_Dual_Space_Bit):
self.__modifiers |= bits.Dual_Space_Bit
self.__modifiers &= ~bits.Space_Bit
elif keyval == keysyms.Shift_L:
if not (self.__modifiers & bits.Not_Dual_ShiftL_Bit):
self.__modifiers |= bits.Dual_ShiftL_Bit
self.__modifiers &= ~bits.ShiftL_Bit
elif keyval == keysyms.Shift_R:
if not (self.__modifiers & bits.Not_Dual_ShiftR_Bit):
self.__modifiers |= bits.Dual_ShiftR_Bit
self.__modifiers &= ~bits.ShiftR_Bit
elif keyval == keysyms.Control_L:
self.__modifiers &= ~bits.ControlL_Bit
elif keyval == keysyms.Control_R:
if not (self.__modifiers & bits.Not_Dual_ControlR_Bit):
self.__modifiers |= bits.Dual_ControlR_Bit
self.__modifiers &= ~bits.ControlR_Bit
elif keyval == keysyms.Alt_R:
if not (self.__modifiers & bits.Not_Dual_AltR_Bit):
self.__modifiers |= bits.Dual_AltR_Bit
self.__modifiers &= ~bits.AltR_Bit
if self.__engine.is_enabled():
if self.__SandS:
if (self.__modifiers
& bits.Space_Bit) and keyval == keysyms.space:
return True
elif self.__Prefix:
if (self.__modifiers
& bits.Space_Bit) and keyval == keysyms.space:
return True
if self.__modifiers & bits.Dual_Space_Bit:
self.__modifiers ^= bits.Prefix_Bit
return True
# Ignore normal key release events
if not is_press and not (self.__modifiers & self.__DualBits):
self.__modifiers &= ~bits.Prefix_Bit
return False
if self.__engine.is_enabled():
if 0 < self.__delay:
GLib.timeout_add(self.__delay, self.handle_key_event_timeout,
keyval, keycode, state)
return True
return self.handle_key_event(keyval, keycode, state)
if not is_press:
return False
if state & (IBus.ModifierType.CONTROL_MASK
| IBus.ModifierType.MOD1_MASK):
return False
self.update_key_event(keyval, keycode, state)
c = self.chr()
if c:
# Commit a remapped character
if c == '¥' and not self.__HasYen:
c = '\\'
if c != chr(self.__keyval):
# Note self.__engine.forward_key_event does not seem to work with Qt applications.
self.__engine.commit_text(IBus.Text.new_from_string(c))
return True
return False
def handle_key_event(self, keyval, keycode, state, modifiers):
logger.debug("handle_key_event(%s, %04x, %04x, %04x)" %
(IBus.keyval_name(keyval), keycode, state, modifiers))
if self._event.is_dual_role():
pass
elif self._event.is_modifier():
# Ignore modifier keys
return False
elif state & (IBus.ModifierType.CONTROL_MASK
| IBus.ModifierType.MOD1_MASK):
self._commit()
return False
# Handle Candidate window
if 0 < self._lookup_table.get_number_of_candidates():
if keyval == keysyms.Page_Up or keyval == keysyms.KP_Page_Up:
return self.do_page_up()
elif keyval == keysyms.Page_Down or keyval == keysyms.KP_Page_Down:
return self.do_page_down()
elif keyval == keysyms.Up or self._event.is_muhenkan():
return self.do_cursor_up()
elif keyval == keysyms.Down or self._event.is_henkan():
return self.do_cursor_down()
elif keyval == keysyms.Escape:
return self.handle_escape(state)
elif keyval == keysyms.Return:
self._commit()
return True
if self._preedit_string:
if keyval == keysyms.Return:
if self._preedit_string == 'n':
self._preedit_string = 'ん'
self._commit_string(self._preedit_string)
self._preedit_string = ''
self._update()
return True
if keyval == keysyms.Escape:
self._preedit_string = ''
self._update()
return True
# Handle Japanese text
if self._event.is_henkan():
return self.handle_replace(keyval, state)
if self._event.is_shrink():
return self.handle_shrink(keyval, state)
self._commit()
yomi = ''
if self._event.is_katakana():
if self._event.is_shift():
self.switch_katakana()
else:
self.handle_katakana()
return True
if self._event.is_backspace():
if 1 <= len(self._preedit_string):
self._preedit_string = self._preedit_string[:-1]
self._update()
return True
elif 0 < len(self._previous_text):
self._previous_text = self._previous_text[:-1]
return False
if self._event.is_ascii():
if self.get_mode() == 'Ａ':
yomi = to_zenkaku(self._event.chr())
else:
yomi, self._preedit_string = self._to_kana(
self._preedit_string, keyval, state, modifiers)
elif keyval == keysyms.hyphen:
yomi = '―'
else:
self._previous_text = ''
return False
if yomi:
if self.get_mode() == 'ア':
yomi = to_katakana(yomi)
elif self.get_mode() == 'ｱ':
yomi = to_hankaku(to_katakana(yomi))
self._commit_string(yomi)
self._update()
return True
def process_key_event(self, keyval, keycode, state):
logger.debug(
"process_key_event(%s, %04x, %04x) %02x" %
(IBus.keyval_name(keyval), keycode, state, self._modifiers))
# Ignore XFree86 anomaly.
if keyval == keysyms.ISO_Left_Tab:
keyval = keysyms.Tab
elif keyval == 0x1008ff81:
keyval = keysyms.F13
elif keyval == 0x1008ff45:
keyval = keysyms.F14
elif keyval == keysyms.Meta_R: # [Shift]-[Alt_R]
keyval = keysyms.Alt_R
self._modifiers &= ~DUAL_BITS
is_press = ((state & IBus.ModifierType.RELEASE_MASK) == 0)
if is_press:
if keyval == keysyms.space:
self._modifiers |= SPACE_BIT
self._modifiers &= ~NOT_DUAL_SPACE_BIT
elif keyval == keysyms.Shift_L:
self._modifiers |= SHIFT_L_BIT
self._modifiers &= ~NOT_DUAL_SHIFT_L_BIT
elif keyval == keysyms.Shift_R:
self._modifiers |= SHIFT_R_BIT
self._modifiers &= ~NOT_DUAL_SHIFT_R_BIT
elif keyval == keysyms.Control_L:
self._modifiers |= CONTROL_L_BIT
elif keyval == keysyms.Control_R:
self._modifiers |= CONTROL_R_BIT
self._modifiers &= ~NOT_DUAL_CONTROL_R_BIT
elif keyval == keysyms.Alt_R:
self._modifiers |= ALT_R_BIT
self._modifiers &= ~NOT_DUAL_ALT_R_BIT
if (self._modifiers & SPACE_BIT) and keyval != keysyms.space:
self._modifiers |= NOT_DUAL_SPACE_BIT
if (self._modifiers & SHIFT_L_BIT) and keyval != keysyms.Shift_L:
self._modifiers |= NOT_DUAL_SHIFT_L_BIT
if (self._modifiers & SHIFT_R_BIT) and keyval != keysyms.Shift_R:
self._modifiers |= NOT_DUAL_SHIFT_R_BIT
if (self._modifiers
& CONTROL_R_BIT) and keyval != keysyms.Control_R:
self._modifiers |= NOT_DUAL_CONTROL_R_BIT
if (self._modifiers & ALT_R_BIT) and keyval != keysyms.Alt_R:
self._modifiers |= NOT_DUAL_ALT_R_BIT
# Check CAPS LOCK for IME on/off
if self._OnOffByCaps:
if keyval == keysyms.Caps_Lock:
# Note CAPS LOCK LED is turned off after the key release event.
if state & IBus.ModifierType.LOCK_MASK:
self._engine.disable_ime()
else:
self._engine.enable_ime()
return True
elif not self._engine.is_overridden():
if state & IBus.ModifierType.LOCK_MASK:
self._engine.enable_ime()
else:
self._engine.disable_ime()
elif keyval == self._Eisuu:
if self._engine.is_enabled():
self._engine.disable_ime()
else:
self._engine.enable_ime()
return True
elif keyval == keysyms.Zenkaku_Hankaku:
self._engine.switch_zenkaku_hankaku()
return True
if self._engine.is_enabled():
if keyval == keysyms.Muhenkan:
self._engine.disable_ime()
return True
elif keyval == keysyms.Henkan:
self._engine.enable_ime()
return True
else:
if keyval == keysyms.space:
if not (self._modifiers & NOT_DUAL_SPACE_BIT):
self._modifiers |= DUAL_SPACE_BIT
self._modifiers &= ~SPACE_BIT
elif keyval == keysyms.Shift_L:
if not (self._modifiers & NOT_DUAL_SHIFT_L_BIT):
self._modifiers |= DUAL_SHIFT_L_BIT
self._modifiers &= ~SHIFT_L_BIT
elif keyval == keysyms.Shift_R:
if not (self._modifiers & NOT_DUAL_SHIFT_R_BIT):
self._modifiers |= DUAL_SHIFT_R_BIT
self._modifiers &= ~SHIFT_R_BIT
elif keyval == keysyms.Control_L:
self._modifiers &= ~CONTROL_L_BIT
elif keyval == keysyms.Control_R:
if not (self._modifiers & NOT_DUAL_CONTROL_R_BIT):
self._modifiers |= DUAL_CONTROL_R_BIT
self._modifiers &= ~CONTROL_R_BIT
elif keyval == keysyms.Alt_R:
if not (self._modifiers & NOT_DUAL_ALT_R_BIT):
self._modifiers |= DUAL_ALT_R_BIT
self._modifiers &= ~ALT_R_BIT
if self._engine.is_enabled():
if self._SandS:
if (self._modifiers & SPACE_BIT) and keyval == keysyms.space:
return True
elif self._Prefix:
if (self._modifiers & SPACE_BIT) and keyval == keysyms.space:
return True
if self._modifiers & DUAL_SPACE_BIT:
self._modifiers ^= PREFIX_BIT
return True
# Ignore normal key release events
if not is_press and not (self._modifiers & self._DualBits):
self._modifiers &= ~PREFIX_BIT
return False
if self._engine.is_enabled():
if 0 < self._delay:
GLib.timeout_add(self._delay, self.handle_key_event_timeout,
keyval, keycode, state)
return True
return self.handle_key_event(keyval, keycode, state)
if not is_press:
return False
if state & (IBus.ModifierType.CONTROL_MASK
| IBus.ModifierType.MOD1_MASK):
return False
self.update_key_event(keyval, keycode, state)
c = self.chr()
if c:
# Commit a remapped character
if c == '¥' and not self._HasYen:
c = '\\'
if c != chr(self._keyval):
# Note self._engine.forward_key_event does not seem to work with Qt applications.
self._engine.commit_text(IBus.Text.new_from_string(c))
return True
return False
