apply patch from Hideaki ABE.

5 files changed, 622 insertions, 58 deletions

diff --git a/engine/engine.py b/engine/engine.py
index de87b74..5ec772f 100644
--- a/engine/engine.py
+++ b/engine/engine.py
@@ -19,6 +19,8 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
+import os
+from os import path
 import sys
 import gobject
 import ibus
@@ -28,6 +30,9 @@ from ibus import keysyms
 from ibus import modifier
 import jastring
 
+sys.path.append(path.join(os.getenv('IBUS_ANTHY_PKGDATADIR'), 'setup'))
+from anthyprefs import AnthyPrefs
+
 from gettext import dgettext
 _  = lambda a : dgettext("ibus-anthy", a)
 N_ = lambda a : a
@@ -43,15 +48,34 @@ CONV_MODE_ANTHY, \
 CONV_MODE_HIRAGANA, \
 CONV_MODE_KATAKANA, \
 CONV_MODE_HALF_WIDTH_KATAKANA, \
+CONV_MODE_LATIN_0, \
 CONV_MODE_LATIN_1, \
 CONV_MODE_LATIN_2, \
 CONV_MODE_LATIN_3, \
+CONV_MODE_WIDE_LATIN_0, \
 CONV_MODE_WIDE_LATIN_1, \
 CONV_MODE_WIDE_LATIN_2, \
-CONV_MODE_WIDE_LATIN_3 = range(11)
+CONV_MODE_WIDE_LATIN_3 = range(13)
+
+KP_Table = {}
+for k, v in zip(['KP_Add', 'KP_Decimal', 'KP_Divide', 'KP_Enter', 'KP_Equal',
+                 'KP_Multiply', 'KP_Separator', 'KP_Space', 'KP_Subtract'],
+                ['plus', 'period', 'slash', 'Return', 'equal',
+                 'asterisk', 'comma', 'space', 'minus']):
+    KP_Table[keysyms.__getattribute__(k)] = keysyms.__getattribute__(v)
+for s in dir(keysyms):
+    if s.startswith('KP_'):
+        v = keysyms.name_to_keycode(s[3:])
+        if v:
+            KP_Table[keysyms.name_to_keycode(s)] = v
 
 class Engine(ibus.EngineBase):
     __typing_mode = jastring.TYPING_MODE_ROMAJI
+
+    __setup_pid = 0
+    __prefs = None
+    __keybind = {}
+
     def __init__(self, bus, object_path):
         super(Engine, self).__init__(bus, object_path)
 
@@ -63,9 +87,20 @@ class Engine(ibus.EngineBase):
         self.__input_mode = INPUT_MODE_HIRAGANA
         self.__prop_dict = {}
 
-        self.__lookup_table = ibus.LookupTable(page_size=9, round=True)
+#        self.__lookup_table = ibus.LookupTable(page_size=9, round=True)
+        size = self.__prefs.get_value('common', 'page_size')
+        self.__lookup_table = ibus.LookupTable(page_size=size, round=True)
         self.__prop_list = self.__init_props()
 
+        mode = self.__prefs.get_value('common', 'input_mode')
+        mode = 'InputMode.' + ['Hiragana', 'Katakana', 'HalfWidthKatakana',
+                               'Latin', 'WideLatin'][mode]
+        self.__input_mode_activate(mode, ibus.PROP_STATE_CHECKED)
+
+        mode = self.__prefs.get_value('common', 'typing_method')
+        mode = 'TypingMode.' + ['Romaji', 'Kana'][mode]
+        self.__input_mode_activate(mode, ibus.PROP_STATE_CHECKED)
+
         # use reset to init values
         self.__reset()
 
@@ -140,6 +175,9 @@ class Engine(ibus.EngineBase):
         typing_mode_prop.set_sub_props(props)
         anthy_props.append(typing_mode_prop)
 
+        anthy_props.append(ibus.Property(key=u"setup",
+                                         tooltip=_(u"Configure Anthy")))
+
         return anthy_props
 
     def update_preedit(self, string, attrs, cursor_pos, visible):
@@ -225,7 +263,8 @@ class Engine(ibus.EngineBase):
 
     def process_key_event(self, keyval, state):
         try:
-            return self.process_key_event_internal(keyval, state)
+#            return self.process_key_event_internal(keyval, state)
+            return self.process_key_event_internal2(keyval, state)
         except:
             import traceback
             traceback.print_exc()
@@ -234,8 +273,8 @@ class Engine(ibus.EngineBase):
     def process_key_event_internal(self, keyval, state):
         is_press = (state & modifier.RELEASE_MASK) == 0
 
-        state = state & (modifier.SHIFT_MASK | \
-                modifier.CONTROL_MASK | \
+        state = state & (modifier.SHIFT_MASK |
+                modifier.CONTROL_MASK |
                 modifier.MOD1_MASK)
 
         # ignore key release events
@@ -308,7 +347,10 @@ class Engine(ibus.EngineBase):
             if self.__typing_mode_activate(prop_name, state):
                 return
         else:
-            self.__prop_dict[prop_name].set_state(state)
+            if prop_name == 'setup':
+                self.__start_setup()
+            else:
+                self.__prop_dict[prop_name].set_state(state)
 
     def __input_mode_activate(self, prop_name, state):
         if not prop_name.startswith(u"InputMode."):
@@ -381,11 +423,16 @@ class Engine(ibus.EngineBase):
     def focus_in(self):
         self.register_properties(self.__prop_list)
         self.__refresh_typing_mode_property()
-        self.__reset()
-        self.__invalidate()
+#        self.__reset()
+#        self.__invalidate()
 
     def focus_out(self):
-        pass
+        mode = self.__prefs.get_value('common', 'behivior_on_focus_out')
+        if mode == 0:
+            self.__reset()
+            self.__invalidate()
+        elif mode == 1:
+            self.__on_key_return()
 
     # begine convert
     def __begin_anthy_convert(self):
@@ -393,9 +440,8 @@ class Engine(ibus.EngineBase):
             return
         self.__convert_mode = CONV_MODE_ANTHY
 
-        self.__preedit_ja_string.insert(u"\0")
-
-        text, cursor = self.__preedit_ja_string.get_hiragana()
+#        text, cursor = self.__preedit_ja_string.get_hiragana()
+        text, cursor = self.__preedit_ja_string.get_hiragana(True)
 
         self.__context.set_string(text.encode("utf8"))
         conv_stat = anthy.anthy_conv_stat()
@@ -443,13 +489,17 @@ class Engine(ibus.EngineBase):
         self.__need_update = True
         gobject.idle_add(self.__update, priority = gobject.PRIORITY_LOW)
 
-    def __get_preedit(self):
+#    def __get_preedit(self):
+    def __get_preedit(self, commit=False):
         if self.__input_mode == INPUT_MODE_HIRAGANA:
-            text, cursor = self.__preedit_ja_string.get_hiragana()
+#            text, cursor = self.__preedit_ja_string.get_hiragana()
+            text, cursor = self.__preedit_ja_string.get_hiragana(commit)
         elif self.__input_mode == INPUT_MODE_KATAKANA:
-            text, cursor = self.__preedit_ja_string.get_katakana()
+#            text, cursor = self.__preedit_ja_string.get_katakana()
+            text, cursor = self.__preedit_ja_string.get_katakana(commit)
         elif self.__input_mode == INPUT_MODE_HALF_WIDTH_KATAKANA:
-            text, cursor = self.__preedit_ja_string.get_half_width_katakana()
+#            text, cursor = self.__preedit_ja_string.get_half_width_katakana()
+            text, cursor = self.__preedit_ja_string.get_half_width_katakana(commit)
         else:
             text, cursor = u"", 0
         return text, cursor
@@ -472,11 +522,18 @@ class Engine(ibus.EngineBase):
             self.__update_anthy_convert_chars()
             return
         if self.__convert_mode == CONV_MODE_HIRAGANA:
-            text, cursor = self.__preedit_ja_string.get_hiragana()
+#            text, cursor = self.__preedit_ja_string.get_hiragana()
+            text, cursor = self.__preedit_ja_string.get_hiragana(True)
         elif self.__convert_mode == CONV_MODE_KATAKANA:
-            text, cursor = self.__preedit_ja_string.get_katakana()
+#            text, cursor = self.__preedit_ja_string.get_katakana()
+            text, cursor = self.__preedit_ja_string.get_katakana(True)
         elif self.__convert_mode == CONV_MODE_HALF_WIDTH_KATAKANA:
-            text, cursor = self.__preedit_ja_string.get_half_width_katakana()
+#            text, cursor = self.__preedit_ja_string.get_half_width_katakana()
+            text, cursor = self.__preedit_ja_string.get_half_width_katakana(True)
+        elif self.__convert_mode == CONV_MODE_LATIN_0:
+            text, cursor = self.__preedit_ja_string.get_latin()
+            if text == text.lower():
+                self.__convert_mode = CONV_MODE_LATIN_1
         elif self.__convert_mode == CONV_MODE_LATIN_1:
             text, cursor = self.__preedit_ja_string.get_latin()
             text = text.lower()
@@ -486,6 +543,10 @@ class Engine(ibus.EngineBase):
         elif self.__convert_mode == CONV_MODE_LATIN_3:
             text, cursor = self.__preedit_ja_string.get_latin()
             text = text.capitalize()
+        elif self.__convert_mode == CONV_MODE_WIDE_LATIN_0:
+            text, cursor = self.__preedit_ja_string.get_wide_latin()
+            if text == text.lower():
+                self.__convert_mode = CONV_MODE_WIDE_LATIN_1
         elif self.__convert_mode == CONV_MODE_WIDE_LATIN_1:
             text, cursor = self.__preedit_ja_string.get_wide_latin()
             text = text.lower()
@@ -545,7 +606,8 @@ class Engine(ibus.EngineBase):
             return False
 
         if self.__convert_mode == CONV_MODE_OFF:
-            text, cursor = self.__get_preedit()
+#            text, cursor = self.__get_preedit()
+            text, cursor = self.__get_preedit(True)
             self.__commit_string(text)
         elif self.__convert_mode == CONV_MODE_ANTHY:
             i = 0
@@ -638,8 +700,8 @@ class Engine(ibus.EngineBase):
             self.cursor_down()
         return True
 
-    def __on_key_space(self):
-        if self.__input_mode == INPUT_MODE_WIDE_LATIN:
+    def __on_key_space(self, wide=False):
+        if self.__input_mode == INPUT_MODE_WIDE_LATIN or wide:
             # Input Wide space U+3000
             wide_char = symbol_rule[unichr(keysyms.space)]
             self.__commit_string(wide_char)
@@ -740,7 +802,7 @@ class Engine(ibus.EngineBase):
             return False
 
         if keyval == keysyms._0:
-            return True
+            keyval = keysyms._9 + 1
         index = keyval - keysyms._1
 
         candidates = self.__lookup_table.get_candidates_in_current_page()
@@ -773,19 +835,26 @@ class Engine(ibus.EngineBase):
                 self.__convert_mode == CONV_MODE_ANTHY:
                 self.__convert_mode = CONV_MODE_HALF_WIDTH_KATAKANA
             else:
-                if self.__convert_mode >= CONV_MODE_LATIN_1 and self.__convert_mode <= CONV_MODE_LATIN_3:
+                if CONV_MODE_LATIN_0 <= self.__convert_mode <= CONV_MODE_LATIN_3:
                     self.__convert_mode += 1
                     if self.__convert_mode > CONV_MODE_LATIN_3:
                         self.__convert_mode = CONV_MODE_LATIN_1
                 else:
-                    self.__convert_mode = CONV_MODE_LATIN_1
+                    self.__convert_mode = CONV_MODE_LATIN_0
         elif mode == 3:
-            if self.__convert_mode >= CONV_MODE_WIDE_LATIN_1 and self.__convert_mode <= CONV_MODE_WIDE_LATIN_3:
+            if CONV_MODE_WIDE_LATIN_0 <= self.__convert_mode <= CONV_MODE_WIDE_LATIN_3:
                 self.__convert_mode += 1
                 if self.__convert_mode > CONV_MODE_WIDE_LATIN_3:
                     self.__convert_mode = CONV_MODE_WIDE_LATIN_1
             else:
-                self.__convert_mode = CONV_MODE_WIDE_LATIN_1
+                self.__convert_mode = CONV_MODE_WIDE_LATIN_0
+        elif mode == 4:
+            if CONV_MODE_LATIN_0 <= self.__convert_mode <= CONV_MODE_LATIN_3:
+                self.__convert_mode += 1
+                if self.__convert_mode > CONV_MODE_LATIN_3:
+                    self.__convert_mode = CONV_MODE_LATIN_1
+            else:
+                self.__convert_mode = CONV_MODE_LATIN_0
         else:
             print >> sys.stderr, "Unkown convert mode (%d)!" % mode
             return False
@@ -803,7 +872,7 @@ class Engine(ibus.EngineBase):
         elif self.__input_mode == INPUT_MODE_WIDE_LATIN:
             #  Input Wide Latin chars
             char = unichr(keyval)
-            wide_char = symbol_rule.get(char, None)
+            wide_char = None#symbol_rule.get(char, None)
             if wide_char == None:
                 wide_char = ibus.unichar_half_to_full(char)
             self.__commit_string(wide_char)
@@ -822,3 +891,424 @@ class Engine(ibus.EngineBase):
         self.__invalidate()
         return True
 
+#=======================================================================
+    @classmethod
+    def CONFIG_RELOADED(cls, bus):
+        print 'RELOADED'
+        if not cls.__prefs:
+            cls.__prefs = AnthyPrefs(bus)
+
+        keybind = {}
+        for k in cls.__prefs.keys('shortcut/default'):
+            cmd = '_Engine__cmd_' + k
+            for s in cls.__prefs.get_value('shortcut/default', k):
+                keybind.setdefault(cls._s_to_key(s), []).append(cmd)
+        cls.__keybind = keybind
+
+        jastring.JaString._prefs = cls.__prefs
+
+    @classmethod
+    def CONFIG_VALUE_CHANGED(cls, bus, section, name, value):
+        print 'VALUE_CHAMGED =', section, name, value
+        section = section[len(cls.__prefs._prefix) + 1:]
+        if section.startswith('shortcut/'):
+            cmd = '_Engine__cmd_' + name
+            old = cls.__prefs.get_value('shortcut/default', name)
+            value = value if value != [''] else []
+            for s in set(old).difference(value):
+                cls.__keybind.get(cls._s_to_key(s), []).remove(cmd)
+
+            keys = cls.__prefs.keys('shortcut/default')
+            for s in set(value).difference(old):
+                cls.__keybind.setdefault(cls._s_to_key(s), []).append(cmd)
+                cls.__keybind.get(cls._s_to_key(s)).sort(
+                    lambda a, b: cmp(keys.index(a[13:]), keys.index(b[13:])))
+
+            cls.__prefs.set_value('shortcut/default', name, value)
+        elif section == 'common':
+            cls.__prefs.set_value(section, name, value)
+
+    @classmethod
+    def _s_to_key(cls, s):
+        keyval = keysyms.name_to_keycode(s.split('+')[-1])
+        s = s.lower()
+        state = ('shift+' in s and modifier.SHIFT_MASK or 0) | (
+                 'ctrl+' in s and modifier.CONTROL_MASK or 0) | (
+                 'alt+' in s and modifier.MOD1_MASK or 0)
+        return cls._mk_key(keyval, state)
+
+    @staticmethod
+    def _mk_key(keyval, state):
+        if state & (modifier.CONTROL_MASK | modifier.MOD1_MASK):
+            if unichr(keyval) in u'!"#$%^\'()*+,-./:;<=>?@[\]^_`{|}~':
+                state |= modifier.SHIFT_MASK
+            elif keysyms.a <= keyval <= keysyms.z:
+                keyval -= (keysyms.a - keysyms.A)
+
+        return repr([int(state), int(keyval)])
+
+    def process_key_event_internal2(self, keyval, state):
+
+        is_press = (state & modifier.RELEASE_MASK) == 0
+
+        state = state & (modifier.SHIFT_MASK |
+                         modifier.CONTROL_MASK |
+                         modifier.MOD1_MASK)
+
+        # ignore key release events
+        if not is_press:
+            return False
+
+        if keyval in KP_Table and self.__prefs.get_value('common',
+                                                         'ten_key_mode'):
+            keyval = KP_Table[keyval]
+
+        key = self._mk_key(keyval, state)
+        for cmd in self.__keybind.get(key, []):
+            print 'cmd =', cmd
+            try:
+                if getattr(self, cmd)(keyval, state):
+                    return True
+            except:
+                print >> sys.stderr, 'Unknow command = %s' % cmd
+
+        if state & (modifier.CONTROL_MASK | modifier.MOD1_MASK):
+            return False
+
+        if (keysyms.exclam <= keyval <= keysyms.asciitilde or
+            keyval == keysyms.yen):
+            ret = self.__on_key_common(keyval)
+            if (unichr(keyval) in u',.' and
+                self.__prefs.get_value('common', 'behivior_on_period')):
+                return self.__cmd_convert(keyval, state)
+            return ret
+        else:
+            if not self.__preedit_ja_string.is_empty():
+                return True
+            return False
+
+    #mode_keys
+    def __set_input_mode(self, mode):
+        if not self.__preedit_ja_string.is_empty():
+            return False
+
+        self.__input_mode_activate(mode, ibus.PROP_STATE_CHECKED)
+
+        return True
+
+    def __cmd_on_off(self, keyval, state):
+        if self.__input_mode == INPUT_MODE_LATIN:
+            return self.__set_input_mode(u'InputMode.Hiragana')
+        else:
+            return self.__set_input_mode(u'InputMode.Latin')
+
+    def __cmd_circle_input_mode(self, keyval, state):
+        modes = {
+            INPUT_MODE_HIRAGANA: u"InputMode.Katakana",
+            INPUT_MODE_KATAKANA: u"InputMode.HalfWidthKatakana",
+            INPUT_MODE_HALF_WIDTH_KATAKANA: u"InputMode.Latin",
+            INPUT_MODE_LATIN: u"InputMode.WideLatin",
+            INPUT_MODE_WIDE_LATIN: u"InputMode.Hiragana"
+        }
+        return self.__set_input_mode(modes[self.__input_mode])
+
+    def __cmd_circle_kana_mode(self, keyval, state):
+        modes = {
+            INPUT_MODE_HIRAGANA: u"InputMode.Katakana",
+            INPUT_MODE_KATAKANA: u"InputMode.HalfWidthKatakana",
+            INPUT_MODE_HALF_WIDTH_KATAKANA: u"InputMode.Hiragana",
+            INPUT_MODE_LATIN: u"InputMode.Hiragana",
+            INPUT_MODE_WIDE_LATIN: u"InputMode.Hiragana"
+        }
+        return self.__set_input_mode(modes[self.__input_mode])
+
+    def __cmd_latin_mode(self, keyval, state):
+        return self.__set_input_mode(u'InputMode.Latin')
+
+    def __cmd_wide_latin_mode(self, keyval, state):
+        return self.__set_input_mode(u'InputMode.WideLatin')
+
+    def __cmd_hiragana_mode(self, keyval, state):
+        return self.__set_input_mode(u'InputMode.Hiragana')
+
+    def __cmd_katakana_mode(self, keyval, state):
+        return self.__set_input_mode(u'InputMode.Katakana')
+
+    def __cmd_half_katakana(self, keyval, state):
+        return self.__set_input_mode(u'InputMode.HalfWidthKatakana')
+
+    def __cmd_cancel_pseudo_ascii_mode_key(self, keyval, state):
+        pass
+
+    def __cmd_circle_typing_method(self, keyval, state):
+        if not self.__preedit_ja_string.is_empty():
+            return False
+
+        modes = {
+            jastring.TYPING_MODE_KANA: u"TypingMode.Romaji",
+            jastring.TYPING_MODE_ROMAJI: u"TypingMode.Kana",
+        }
+        self.__typing_mode_activate(modes[self.__typing_mode],
+                                    ibus.PROP_STATE_CHECKED)
+        return True
+
+    #edit_keys
+    def __cmd_insert_space(self, keyval, state):
+        if self.__input_mode in [INPUT_MODE_LATIN,
+                                 INPUT_MODE_HALF_WIDTH_KATAKANA]:
+            return self.__cmd_insert_half_space(keyval, state)
+        else:
+            return self.__cmd_insert_wide_space(keyval, state)
+
+    def __cmd_insert_alternate_space(self, keyval, state):
+        if not self.__input_mode in [INPUT_MODE_LATIN,
+                                     INPUT_MODE_HALF_WIDTH_KATAKANA]:
+            return self.__cmd_insert_half_space(keyval, state)
+        else:
+            return self.__cmd_insert_wide_space(keyval, state)
+
+    def __cmd_insert_half_space(self, keyval, state):
+        if not self.__preedit_ja_string.is_empty():
+            return False
+        self.__commit_string(unichr(keysyms.space))
+        return True
+
+    def __cmd_insert_wide_space(self, keyval, state):
+        if not self.__preedit_ja_string.is_empty():
+            return False
+        char = unichr(keysyms.space)
+        wide_char = symbol_rule.get(char, None)
+        if wide_char == None:
+            wide_char = ibus.unichar_half_to_full(char)
+        self.__commit_string(wide_char)
+        return True
+
+    def __cmd_backspace(self, keyval, state):
+        return self.__on_key_back_space()
+
+    def __cmd_delete(self, keyval, state):
+        return self.__on_key_delete()
+
+    def __cmd_commit(self, keyval, state):
+        return self.__on_key_return()
+
+    def __cmd_convert(self, keyval, state):
+        if self.__preedit_ja_string.is_empty() or \
+                self.__input_mode != INPUT_MODE_HIRAGANA:
+            return False
+        if self.__convert_mode != CONV_MODE_ANTHY:
+            self.__begin_anthy_convert()
+            self.__invalidate()
+        elif self.__convert_mode == CONV_MODE_ANTHY:
+            self.__lookup_table_visible = True
+            self.cursor_down()
+        return True
+
+    def __cmd_predict(self, keyval, state):
+        pass
+
+    def __cmd_cancel(self, keyval, state):
+        if not self.__preedit_ja_string.is_empty() and \
+                self.__convert_mode == CONV_MODE_OFF:
+            return self.__on_key_escape()
+        return False
+
+    def __cmd_cancel_all(self, keyval, state):
+        return self.__cmd_cancel(keyval, state)
+
+    def __cmd_reconvert(self, keyval, state):
+        pass
+
+    def __cmd_do_nothing(self, keyval, state):
+        return True
+
+    #caret_keys
+    def __move_caret(self, i):
+        if self.__lookup_table_visible:
+            return False
+
+        if self.__preedit_ja_string.is_empty():
+            return False
+
+        if self.__convert_mode == CONV_MODE_OFF:
+            self.__preedit_ja_string.move_cursor(
+                -len(self.__preedit_ja_string.get_latin()[0]) if i == 0 else
+                i if i in [-1, 1] else
+                len(self.__preedit_ja_string.get_latin()[0]))
+            self.__invalidate()
+            return True
+
+        return False
+
+    def __cmd_move_caret_first(self, keyval, state):
+        return self.__move_caret(0)
+
+    def __cmd_move_caret_last(self, keyval, state):
+        return self.__move_caret(2)
+
+    def __cmd_move_caret_forward(self, keyval, state):
+        return self.__move_caret(1)
+
+    def __cmd_move_caret_backward(self, keyval, state):
+        return self.__move_caret(-1)
+
+    #segments_keys
+    def __select_segment(self, i):
+        if self.__preedit_ja_string.is_empty():
+            return False
+
+        if self.__convert_mode == CONV_MODE_OFF:
+            return False
+        elif self.__convert_mode != CONV_MODE_ANTHY:
+            return True
+
+        pos = 0 if i == 0 else \
+              self.__cursor_pos + i if i in [-1, 1] else \
+              len(self.__segments) - 1
+
+        if 0 <= pos < len(self.__segments) and pos != self.__cursor_pos:
+            self.__cursor_pos = pos
+            self.__lookup_table_visible = False
+            self.__fill_lookup_table()
+            self.__invalidate()
+
+        return True
+
+    def __cmd_select_first_segment(self, keyval, state):
+        if self.__lookup_table_visible:
+            return False
+
+        return self.__select_segment(0)
+
+    def __cmd_select_last_segment(self, keyval, state):
+        if self.__lookup_table_visible:
+            return False
+
+        return self.__select_segment(2)
+
+    def __cmd_select_next_segment(self, keyval, state):
+        return self.__select_segment(1)
+
+    def __cmd_select_prev_segment(self, keyval, state):
+        return self.__select_segment(-1)
+
+    def __cmd_shrink_segment(self, keyval, state):
+        if self.__convert_mode == CONV_MODE_ANTHY:
+            self.__shrink_segment(-1)
+            return True
+
+    def __cmd_expand_segment(self, keyval, state):
+        if self.__convert_mode == CONV_MODE_ANTHY:
+            self.__shrink_segment(1)
+            return True
+
+    def __cmd_commit_first_segment(self, keyval, state):
+        pass
+
+    def __cmd_commit_selected_segment(self, keyval, state):
+        pass
+
+    #candidates_keys
+    def __select_candidate(self, pos):
+        if not self.__lookup_table_visible:
+            return False
+
+        if not self.__lookup_table.set_cursor_pos_in_current_page(pos):
+            return False
+
+        candidate = self.__lookup_table.get_current_candidate().text
+        index = self.__lookup_table.get_cursor_pos()
+        self.__segments[self.__cursor_pos] = index, candidate
+        self.__invalidate()
+        return True
+
+    def __cmd_select_first_candidate(self, keyval, state):
+        return self.__select_candidate(0)
+
+    def __cmd_select_last_candidate(self, keyval, state):
+        return self.__select_candidate(self.__lookup_table.get_page_size() - 1)
+
+    def __cmd_select_next_candidate(self, keyval, state):
+        return self.__on_key_down()
+
+    def __cmd_select_prev_candidate(self, keyval, state):
+        return self.__on_key_up()
+
+    def __cmd_candidates_page_up(self, keyval, state):
+        return self.__on_key_page_up()
+
+    def __cmd_candidates_page_down(self, keyval, state):
+        return self.__on_key_page_down()
+
+    #direct_select_keys
+    def __cmd_select_candidates_1(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_2(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_3(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_4(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_5(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_6(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_7(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_8(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_9(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    def __cmd_select_candidates_0(self, keyval, state):
+        return self.__on_key_number(keyval)
+
+    #convert_keys
+    def __cmd_convert_to_char_type_forward(self, keyval, state):
+        pass
+
+    def __cmd_convert_to_char_type_backward(self, keyval, state):
+        pass
+
+    def __cmd_convert_to_hiragana(self, keyval, state):
+        return self.__on_key_conv(0)
+
+    def __cmd_convert_to_katakana(self, keyval, state):
+        return self.__on_key_conv(1)
+
+    def __cmd_convert_to_half(self, keyval, state):
+        return self.__on_key_conv(2)
+
+    def __cmd_convert_to_half_katakana(self, keyval, state):
+        return self.__on_key_conv(2)
+
+    def __cmd_convert_to_wide_latin(self, keyval, state):
+        return self.__on_key_conv(3)
+
+    def __cmd_convert_to_latin(self, keyval, state):
+        return self.__on_key_conv(4)
+
+    #dictonary_keys
+    def __cmd_dict_admin(self, keyval, state):
+        pass
+
+    def __cmd_add_word(self, keyval, state):
+        pass
+
+    def __start_setup(self):
+        if Engine.__setup_pid != 0:
+            pid, state = os.waitpid(Engine.__setup_pid, os.P_NOWAIT)
+            if pid != Engine.__setup_pid:
+                return
+            Engine.__setup_pid = 0
+        setup_cmd = path.join(os.getenv('LIBEXECDIR'), "ibus-setup-anthy")
+        Engine.__setup_pid = os.spawnl(os.P_NOWAIT, setup_cmd, "ibus-setup-anthy")
+
diff --git a/engine/factory.py b/engine/factory.py
index d460bde..eee85dc 100644
--- a/engine/factory.py
+++ b/engine/factory.py
@@ -19,32 +19,45 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-import os
-from os import path
 import ibus
 import engine
+import os
 
 from gettext import dgettext
 _  = lambda a : dgettext("ibus-anthy", a)
 N_ = lambda a : a
 
-FACTORY_PATH = "/com/redhat/IBus/engines/Anthy/Factory"
-ENGINE_PATH = "/com/redhat/IBus/engines/Anthy/Engine/"
 
 class EngineFactory(ibus.EngineFactoryBase):
+    FACTORY_PATH = "/com/redhat/IBus/engines/Anthy/Factory"
+    ENGINE_PATH = "/com/redhat/IBus/engines/Anthy/Engine"
     NAME = _("Anthy")
     LANG = "ja"
-    ICON = path.join(os.getenv("IBUS_ANTHY_PKGDATADIR"), "icons/ibus-anthy.png")
+    ICON = os.getenv("IBUS_ANTHY_PKGDATADIR") + "/icons/ibus-anthy.png"
     AUTHORS = "Huang Peng <shawn.p.huang@gmail.com>"
     CREDITS = "GPLv2"
 
     def __init__(self, bus):
         self.__bus = bus
-        self.__id = 0
+        engine.Engine.CONFIG_RELOADED(bus)
         super(EngineFactory, self).__init__(bus)
 
+        self.__id = 0
+        self.__config = self.__bus.get_config()
+
+        self.__config.connect("reloaded", self.__config_reloaded_cb)
+        self.__config.connect("value-changed", self.__config_value_changed_cb)
+
     def create_engine(self, engine_name):
         if engine_name == "anthy":
             self.__id += 1
-            return engine.Engine(self.__bus, "/org/freedesktop/IBus/Anthy/%d" % self.__id)
+            return engine.Engine(self.__bus, "%s/%d" % (self.ENGINE_PATH, self.__id))
+
         return super(EngineFactory, self).create_engine(engine_name)
+
+    def __config_reloaded_cb(self, config):
+        engine.Engine.CONFIG_RELOADED(self.__bus)
+
+    def __config_value_changed_cb(self, config, section, name, value):
+        engine.Engine.CONFIG_VALUE_CHANGED(self.__bus, section, name, value)
+
diff --git a/engine/ibus-engine-anthy.in b/engine/ibus-engine-anthy.in
index 01b0b62..fb7c09a 100644
--- a/engine/ibus-engine-anthy.in
+++ b/engine/ibus-engine-anthy.in
@@ -21,9 +21,11 @@
 prefix=@prefix@
 datarootdir=@datarootdir@
 exec_prefix=@exec_prefix@
+libexecdir=@libexecdir@
 pyexecdir=@pyexecdir@
 export PYTHONPATH=@pyexecdir@:$PYTHONPATH
 export IBUS_PREFIX=@prefix@
 export IBUS_ANTHY_PKGDATADIR=@datarootdir@/@PACKAGE@
+export LIBEXECDIR=$libexecdir
 exec python @datarootdir@/@PACKAGE@/engine/main.py $@
 
diff --git a/engine/jastring.py b/engine/jastring.py
index db067ef..c9cd734 100644
--- a/engine/jastring.py
+++ b/engine/jastring.py
@@ -22,6 +22,19 @@
 import romaji
 import kana
 
+from ibus import unichar_half_to_full
+
+SymbolTable = {}
+for i in range(32, 127):
+    if not chr(i).isalnum():
+        SymbolTable[unichar_half_to_full(chr(i))] = chr(i)
+
+NumberTable = {}
+for i in range(10):
+    NumberTable[unichar_half_to_full(str(i))] = str(i)
+
+PeriodTable = {u'。': u'．', u'、': u'，', u'｡': u'.', u'､': u','}
+
 TYPING_MODE_ROMAJI, \
 TYPING_MODE_KANA, \
 TYPING_MODE_THUMB_SHIFT = range(3)
@@ -95,23 +108,38 @@ class JaString:
         elif self.__cursor > len(self.__segments):
             self.__cursor = len(self.__segments)
 
-    def get_hiragana(self):
+    def _chk_text(self, s):
+        period = self._prefs.get_value('common', 'period_style')
+        symbol = self._prefs.get_value('common', 'half_width_symbol')
+        number = self._prefs.get_value('common', 'half_width_number')
+        ret = ''
+        for c in s:
+            c = c if not period else PeriodTable.get(c, c)
+            c = c if not symbol else SymbolTable.get(c, c)
+            c = c if not number else NumberTable.get(c, c)
+            ret += c
+        return ret
+
+    def get_hiragana(self, commit=False):
         conv = lambda s: s.to_hiragana()
-        text_before = u"".join(map(conv, self.__segments[:self.__cursor]))
-        text_after = u"".join(map(conv, self.__segments[self.__cursor:]))
-        return text_before + text_after, len(text_before)
+        R = lambda s: s if not (commit and s[-1:] == u'n') else s[:-1] + u'ん'
+        text_before = R(u"".join(map(conv, self.__segments[:self.__cursor])))
+        text_after = R(u"".join(map(conv, self.__segments[self.__cursor:])))
+        return self._chk_text(text_before + text_after), len(text_before)
 
-    def get_katakana(self):
+    def get_katakana(self, commit=False):
         conv = lambda s: s.to_katakana()
-        text_before = u"".join(map(conv, self.__segments[:self.__cursor]))
-        text_after = u"".join(map(conv, self.__segments[self.__cursor:]))
-        return text_before + text_after, len(text_before)
+        R = lambda s: s if not (commit and s[-1:] == u'n') else s[:-1] + u'ン'
+        text_before = R(u"".join(map(conv, self.__segments[:self.__cursor])))
+        text_after = R(u"".join(map(conv, self.__segments[self.__cursor:])))
+        return self._chk_text(text_before + text_after), len(text_before)
 
-    def get_half_width_katakana(self):
+    def get_half_width_katakana(self, commit=False):
         conv = lambda s: s.to_half_width_katakana()
-        text_before = u"".join(map(conv, self.__segments[:self.__cursor]))
-        text_after = u"".join(map(conv, self.__segments[self.__cursor:]))
-        return text_before + text_after, len(text_before)
+        R = lambda s: s if not (commit and s[-1:] == u'n') else s[:-1] + u'ﾝ'
+        text_before = R(u"".join(map(conv, self.__segments[:self.__cursor])))
+        text_after = R(u"".join(map(conv, self.__segments[self.__cursor:])))
+        return self._chk_text(text_before + text_after), len(text_before)
 
     def get_latin(self):
         conv = lambda s: s.to_latin()
diff --git a/engine/tables.py b/engine/tables.py
index 6a19979..bd77920 100644
--- a/engine/tables.py
+++ b/engine/tables.py
@@ -21,7 +21,7 @@
 
 # string, result, cont
 romaji_typing_rule = {
-    u"-" : u"ー",
+    u"-" : u"－",
     u"a" : u"あ",
     u"i" : u"い",
     u"u" : u"う",
@@ -188,6 +188,11 @@ romaji_typing_rule = {
     u"fu" : u"ふ",
     u"fe" : u"ふぇ",
     u"fo" : u"ふぉ",
+    u"fya" : u"ふゃ",
+    u"fyi" : u"ふぃ",
+    u"fyu" : u"ふゅ",
+    u"fye" : u"ふぇ",
+    u"fyo" : u"ふょ",
     u"ma" : u"ま",
     u"mi" : u"み",
     u"mu" : u"む",
@@ -232,21 +237,21 @@ symbol_rule = {
     u","  : u"、",
     u"."  : u"。",
     u"!"  : u"！",
-    u"\"" : u"”",
+    u"\"" : u"＂",
     u"#"  : u"＃",
     u"$"  : u"＄",
     u"%"  : u"％",
     u"&"  : u"＆",
-    u"'"  : u"’",
+    u"'"  : u"＇",
     u"("  : u"（",
     u")"  : u"）",
-    u"~"  : u"〜",
-    u"-"  : u"ー",
+    u"~"  : u"～",
+    u"-"  : u"－",
     u"="  : u"＝",
     u"^"  : u"＾",
     u"\\" : u"＼",
     u"|"  : u"｜",
-    u"`"  : u"‘",
+    u"`"  : u"｀",
     u"@"  : u"＠",
     u"{"  : u"｛",
     u"["  : u"「",
@@ -262,6 +267,18 @@ symbol_rule = {
     u"/"  : u"／",
     u"_"  : u"＿",
     u"¥"  : u"￥",
+
+    # numbers
+    u'0': u'０',
+    u'1': u'１',
+    u'2': u'２',
+    u'3': u'３',
+    u'4': u'４',
+    u'5': u'５',
+    u'6': u'６',
+    u'7': u'７',
+    u'8': u'８',
+    u'9': u'９',
 }
 
 # this is only used with romaji_typing_rule
@@ -308,6 +325,8 @@ romaji_correction_rule = {
     u"nx" : (u"ん", u"x"),
     u"nz" : (u"ん", u"z"),
     u"n\0" : (u"ん", u""),
+    u"n," : (u"ん", u","),
+    u"n." : (u"ん", u"."),
 }
 
 # a port of 101kana.sty from scim-anthy
@@ -420,7 +439,7 @@ kana_typing_rule = {
     u"?" : u"・",
     u"_" : u"ろ",
 
-    u"¥" : u"ー",
+    u"¥" : u"－",
 }
 
 kana_voiced_consonant_rule = {
@@ -565,20 +584,20 @@ hiragana_katakana_table = {
     u"、" : (u"、", u"､"),
     u"。" : (u"。", u"｡"),
     u"！" : (u"！", u"!"),
-    u"”"  : (u"”", u"\""),
+    u"＂" : (u"＂", u"\""),
     u"＃" : (u"＃", u"#"),
     u"＄" : (u"＄", u"$"),
     u"％" : (u"％", u"%"),
     u"＆" : (u"＆", u"&"),
-    u"’"  : (u"’", u"'"),
+    u"＇" : (u"＇", u"'"),
     u"（" : (u"（", u"("),
     u"）" : (u"）", u")"),
-    u"〜" : (u"〜", u"~"),
+    u"～" : (u"～", u"~"),
     u"＝" : (u"＝", u"="),
     u"＾" : (u"＾", u"^"),
     u"＼" : (u"＼", u"\\"),
     u"｜" : (u"｜", u"|"),
-    u"‘"  : (u"‘", u"`"),
+    u"｀" : (u"｀", u"`"),
     u"＠" : (u"＠", u"@"),
     u"｛" : (u"｛", u"{"),
     u"「" : (u"「", u"｢"),
@@ -594,4 +613,16 @@ hiragana_katakana_table = {
     u"／" : (u"／", u"/"),
     u"＿" : (u"＿", u"_"),
     u"￥" : (u"￥", u"¥"),
+
+    # numbers
+    u'０': (u'０', u'0'),
+    u'１': (u'１', u'1'),
+    u'２': (u'２', u'2'),
+    u'３': (u'３', u'3'),
+    u'４': (u'４', u'4'),
+    u'５': (u'５', u'5'),
+    u'６': (u'６', u'6'),
+    u'７': (u'７', u'7'),
+    u'８': (u'８', u'8'),
+    u'９': (u'９', u'9'),
 }