Merge branch 'master' of git://github.com/hidegit/ibus-anthy

Conflicts:
	engine/engine.py

Fixed merge conflict

3 files changed, 285 insertions, 5 deletions

diff --git a/engine/engine.py b/engine/engine.py
index 0c770b8..bcf2992 100644
--- a/engine/engine.py
+++ b/engine/engine.py
@@ -107,7 +107,7 @@ class Engine(ibus.EngineBase):
         self.__input_mode_activate(mode, ibus.PROP_STATE_CHECKED)
 
         mode = self.__prefs.get_value('common', 'typing_method')
-        mode = 'TypingMode.' + ['Romaji', 'Kana'][mode]
+        mode = 'TypingMode.' + ['Romaji', 'Kana', 'ThumbShift'][mode]
         self.__typing_mode_activate(mode, ibus.PROP_STATE_CHECKED)
 
         # use reset to init values
@@ -123,6 +123,9 @@ class Engine(ibus.EngineBase):
         self.__segments = list()
         self.__lookup_table.clean()
         self.__lookup_table_visible = False
+        self._MM = 0
+        self._SS = 0
+        self._H = 0
 
     def __init_props(self):
         anthy_props = ibus.PropList()
@@ -173,9 +176,9 @@ class Engine(ibus.EngineBase):
         props.append(ibus.Property(key=u"TypingMode.Kana",
                                    type=ibus.PROP_TYPE_RADIO,
                                    label=_(u"Kana")))
-        # props.append(ibus.Property(name = u"TypingMode.ThumbShift",
-        #                     type = ibus.PROP_TYPE_RADIO,
-        #                     label = _(u"Thumb shift")))
+        props.append(ibus.Property(key=u"TypingMode.ThumbShift",
+                                   type=ibus.PROP_TYPE_RADIO,
+                                   label=_(u"Thumb shift")))
         props[Engine.__typing_mode].set_state(ibus.PROP_STATE_CHECKED)
 
         for prop in props:
@@ -422,6 +425,7 @@ class Engine(ibus.EngineBase):
         typing_modes = {
             u"TypingMode.Romaji" : (jastring.TYPING_MODE_ROMAJI, u"R"),
             u"TypingMode.Kana" : (jastring.TYPING_MODE_KANA, u"か"),
+            u"TypingMode.ThumbShift" : (jastring.TYPING_MODE_THUMB_SHIFT, u"親"),
         }
 
         if prop_name not in typing_modes:
@@ -444,6 +448,7 @@ class Engine(ibus.EngineBase):
         modes = {
             jastring.TYPING_MODE_ROMAJI : (u"TypingMode.Romaji", u"R"),
             jastring.TYPING_MODE_KANA : (u"TypingMode.Kana", u"か"),
+            jastring.TYPING_MODE_THUMB_SHIFT : (u"TypingMode.ThumbShift", u"親"),
         }
         prop_name, label = modes.get(Engine.__typing_mode, (None, None))
         if prop_name == None or label == None:
@@ -1004,7 +1009,125 @@ class Engine(ibus.EngineBase):
 
         return repr([int(state), int(keyval)])
 
+    def process_key_event_thumb(self, keyval, keycode, state):
+        import gtk
+        import thumb
+
+        def on_timeout(keyval):
+            if self._MM:
+                insert(thumb.table[self._MM][self._SS])
+            else:
+                cmd_exec([0, RS(), LS()][self._SS])
+            self._H = None
+
+        def start(t):
+            self._H = gobject.timeout_add(t, on_timeout, keyval)
+
+        def stop():
+            if self._H:
+                gobject.source_remove(self._H)
+                self._H = None
+                return True
+            return False
+
+        def insert(keyval):
+            try:
+                ret = self.__on_key_common(ord(keyval))
+                if (keyval in u',.、。' and
+                    self.__prefs.get_value('common', 'behivior_on_period')):
+                    return self.__cmd_convert(keyval, state)
+                return ret
+            except:
+                pass
+
+        def cmd_exec(keyval, state=0):
+            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
+            return False
+
+        def RS():
+            return self.__prefs.get_value('common', 'thumb_rs')
+
+        def LS():
+            return self.__prefs.get_value('common', 'thumb_ls')
+
+        def T1():
+            return self.__prefs.get_value('common', 'thumb_t1')
+
+        def T2():
+            return self.__prefs.get_value('common', 'thumb_t2')
+
+        state = state & (modifier.SHIFT_MASK |
+                         modifier.CONTROL_MASK |
+                         modifier.MOD1_MASK |
+                         modifier.RELEASE_MASK)
+
+        if keyval in KP_Table and self.__prefs.get_value('common',
+                                                         'ten_key_mode'):
+            keyval = KP_Table[keyval]
+
+        if state & modifier.RELEASE_MASK:
+            if keyval == self._MM:
+                if stop():
+                    insert(thumb.table[self._MM][self._SS])
+                self._MM = 0
+            elif (1 if keyval == RS() else 2) == self._SS:
+                if stop():
+                    cmd_exec([0, RS(), LS()][self._SS])
+                self._SS = 0
+        else:
+            if keyval in [LS(), RS()] and state == 0:
+                if self._SS:
+                    stop()
+                    cmd_exec([0, RS(), LS()][self._SS])
+                    self._SS = 1 if keyval == RS() else 2
+                    start(T1())
+                elif self._MM:
+                    stop()
+                    insert(thumb.table[self._MM][1 if keyval == RS() else 2])
+                else:
+                    self._SS = 1 if keyval == RS() else 2
+                    start(T1())
+            elif keyval in thumb.table.keys() and state == 0:
+                if self._MM:
+                    stop()
+                    insert(thumb.table[self._MM][self._SS])
+                    start(T2())
+                    self._MM = keyval
+                elif self._SS:
+                    stop()
+                    insert(thumb.table[keyval][self._SS])
+                else:
+                    if cmd_exec(keyval, state):
+                        return True
+                    start(T2())
+                    self._MM = keyval
+            else:
+                if self._MM:
+                    stop()
+                    insert(thumb.table[self._MM][self._SS])
+                elif self._SS:
+                    stop()
+                    cmd_exec([0, RS(), LS()][self._SS])
+                if 0x21 <= keyval <= 0x7e and state & (modifier.CONTROL_MASK | modifier.MOD1_MASK) == 0:
+                    insert(thumb.shift_table.get(keyval, unichr(keyval)))
+                else:
+                    ret = cmd_exec(keyval, state)
+                    if ret or not self.__preedit_ja_string.is_empty():
+                        return True
+                    return False
+        return True
+
     def process_key_event_internal2(self, keyval, keycode, state):
+        if self.__typing_mode == jastring.TYPING_MODE_THUMB_SHIFT and \
+           self.__input_mode not in [INPUT_MODE_LATIN, INPUT_MODE_WIDE_LATIN]:
+            return self.process_key_event_thumb(keyval, keycode, state)
 
         is_press = (state & modifier.RELEASE_MASK) == 0
 
@@ -1129,7 +1252,8 @@ class Engine(ibus.EngineBase):
             return False
 
         modes = {
-            jastring.TYPING_MODE_KANA: u"TypingMode.Romaji",
+            jastring.TYPING_MODE_THUMB_SHIFT: u"TypingMode.Romaji",
+            jastring.TYPING_MODE_KANA: u"TypingMode.ThumbShift",
             jastring.TYPING_MODE_ROMAJI: u"TypingMode.Kana",
         }
         self.__typing_mode_activate(modes[self.__typing_mode],
diff --git a/engine/jastring.py b/engine/jastring.py
index f913d0d..9898490 100644
--- a/engine/jastring.py
+++ b/engine/jastring.py
@@ -21,6 +21,7 @@
 
 import romaji
 import kana
+import thumb
 
 from segment import unichar_half_to_full
 
@@ -71,6 +72,8 @@ class JaString:
                     new_segments = [romaji.RomajiSegment(c)]
                 elif self.__mode == TYPING_MODE_KANA:
                     new_segments = [kana.KanaSegment(c)]
+                elif self.__mode == TYPING_MODE_THUMB_SHIFT:
+                    new_segments = [thumb.ThumbShiftSegment(c)]
         if new_segments:
             self.__segments[self.__cursor:self.__cursor] = new_segments
             self.__cursor += len(new_segments)
diff --git a/engine/thumb.py b/engine/thumb.py
new file mode 100644
index 0000000..ecdb523
--- /dev/null
+++ b/engine/thumb.py
@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+
+import gtk
+import gobject
+import time
+
+import segment
+
+
+_table = {
+    'q': [u'。', u'',   u'ぁ'],
+    'w': [u'か', u'が', u'え'],
+    'e': [u'た', u'だ', u'り'],
+    'r': [u'こ', u'ご', u'ゃ'],
+    't': [u'さ', u'ざ', u'れ'],
+
+    'y': [u'ら', u'よ', u'ぱ'],
+    'u': [u'ち', u'に', u'ぢ'],
+    'i': [u'く', u'る', u'ぐ'],
+    'o': [u'つ', u'ま', u'づ'],
+    'p': [u',',  u'ぇ', u'ぴ'],
+    '@': [u'、', u'',   u''],
+    '[': [u'゛', u'゜', u''],
+
+    'a': [u'う', u'',   u'を'],
+    's': [u'し', u'じ', u'あ'],
+    'd': [u'て', u'で', u'な'],
+    'f': [u'け', u'げ', u'ゅ'],
+    'g': [u'せ', u'ぜ', u'も'],
+
+    'h': [u'は', u'み', u'ば'],
+    'j': [u'と', u'お', u'ど'],
+    'k': [u'き', u'の', u'ぎ'],
+    'l': [u'い', u'ょ', u'ぽ'],
+    ';': [u'ん', u'っ', u''],
+
+    'z': [u'.',  u'',   u'ぅ'],
+    'x': [u'ひ', u'び', u'ー'],
+    'c': [u'す', u'ず', u'ろ'],
+    'v': [u'ふ', u'ぶ', u'や'],
+    'b': [u'へ', u'べ', u'ぃ'],
+
+    'n': [u'め', u'ぬ', u'ぷ'],
+    'm': [u'そ', u'ゆ', u'ぞ'],
+    ',': [u'ね', u'む', u'ぺ'],
+    '.': [u'ほ', u'わ', u'ぼ'],
+    '/': [u'・', u'ぉ', u''],
+
+    '1': [u'1',  u'',   u'?'],
+    '2': [u'2',  u'',   u'/'],
+    '4': [u'4',  u'',   u'「'],
+    '5': [u'5',  u'',   u'」'],
+
+    '6': [u'6',  u'[',  u''],
+    '7': [u'7',  u']',  u''],
+    '8': [u'8',  u'(',  u''],
+    '9': [u'9',  u')',  u''],
+}
+
+_shift_table = {
+    'H': u'ぱ',
+    'X': u'ぴ',
+    'V': u'ぷ',
+    'B': u'ぺ',
+    '>': u'ぽ',
+}
+
+table = {}
+shift_table = {}
+r_table = {}
+
+for k in _table.keys():
+    table[ord(k)] = _table[k]
+    for c in _table[k]:
+        r_table[c] = k
+
+for k in _shift_table.keys():
+    shift_table[ord(k)] = _shift_table[k]
+    r_table[_shift_table[k]] = k
+
+kana_voiced_consonant_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"ぽ",
+}
+
+_UNFINISHED_HIRAGANA = set(u"かきくけこさしすせそたちつてとはひふへほ")
+
+class ThumbShiftSegment(segment.Segment):
+    
+    def __init__(self, enchars=u"", jachars=u""):
+        if not jachars:
+            if u'!' <= enchars <= u'~':
+                jachars = segment.unichar_half_to_full(enchars)
+            else:
+                jachars = enchars
+                enchars = r_table.get(jachars, u'')
+        super(ThumbShiftSegment, self).__init__(enchars, jachars)
+
+    def is_finished(self):
+        return not (self._jachars in _UNFINISHED_HIRAGANA)
+
+    def append(self, enchar):
+        if enchar == u"\0" or enchar == u"":
+            return []
+        text = self._jachars + enchar
+        jachars = kana_voiced_consonant_rule.get(text, None)
+        if jachars:
+            self._enchars = self._enchars + r_table.get(enchar, u'')
+            self._jachars = jachars
+            return []
+        return [ThumbShiftSegment(enchar)]
+
+    def prepend(self, enchar):
+        if enchar == u"\0" or enchar == u"":
+            return []
+        if self._jachars == u"":
+            if 0x21 <= enchars <= 0x7e:
+                self._enchars = enchar
+                self._jachars = segment.unichar_half_to_full(enchars)
+            else:
+                self._enchars = r_table.get(enchar, u'')
+                self._jachars = enchar
+            return []
+        return [ThumbShiftSegment(enchar)]
+
+    def pop(self, index=-1):
+        self._enchars = u''
+        self._jachars = u''
+        return
+