WIP port setup ui to gtk3

7 files changed, 265 insertions, 249 deletions

diff --git a/setup/engineabout.py b/setup/engineabout.py
index 3c8d7afb..7e2813a2 100644
--- a/setup/engineabout.py
+++ b/setup/engineabout.py
@@ -38,7 +38,7 @@ class EngineAbout(Gtk.Dialog):
         self.__init_ui()
 
     def __init_ui(self):
-        self.set_icon_name("gtk-about")
+        self.set_icon_name(Gtk.STOCK_ABOUT)
         sw = Gtk.ScrolledWindow()
         sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
         sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
@@ -105,7 +105,7 @@ class EngineAbout(Gtk.Dialog):
             theme = Gtk.IconTheme.get_default()
             icon = theme.lookup_icon("ibus-engine", 48, 0)
             if icon == None:
-                icon = theme.lookup_icon("gtk-missing-image", 48, 0)
+                icon = theme.lookup_icon(Gtk.STOCK_MISSING_IMAGE, 48, 0)
             pixbuf = icon.load_icon()
         return pixbuf
 
diff --git a/setup/enginecombobox.py b/setup/enginecombobox.py
index db444e8f..881b0418 100644
--- a/setup/enginecombobox.py
+++ b/setup/enginecombobox.py
@@ -66,6 +66,8 @@ class EngineComboBox(Gtk.ComboBox):
         lang = {}
         for e in engines:
             l = IBus.get_language_name(e.get_language())
+            if l == None:
+                l = ""
             if l not in lang:
                 lang[l] = []
             lang[l].append(e)
@@ -107,7 +109,7 @@ class EngineComboBox(Gtk.ComboBox):
             if pixbuf == None:
                 pixbuf = load_icon("ibus-engine", Gtk.IconSize.LARGE_TOOLBAR)
             if pixbuf == None:
-                pixbuf = load_icon("gtk-missing-image",
+                pixbuf = load_icon(Gtk.STOCK_MISSING_IMAGE,
                         Gtk.IconSize.LARGE_TOOLBAR)
             renderer.set_property("pixbuf", pixbuf)
 
diff --git a/setup/enginetreeview.py b/setup/enginetreeview.py
index f6203617..23f66a1d 100644
--- a/setup/enginetreeview.py
+++ b/setup/enginetreeview.py
@@ -20,28 +20,28 @@
 # Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 # Boston, MA  02111-1307  USA
 
-import gtk
-import glib
-import gobject
-import pango
-import ibus
+from gi.repository import GLib
+from gi.repository import GObject
+from gi.repository import Gtk
+from gi.repository import IBus
+from gi.repository import Pango
 
 from icon import load_icon
 from i18n import _, N_
 
-class EngineTreeView(gtk.TreeView):
+class EngineTreeView(Gtk.TreeView):
     __gtype_name__ = 'EngineTreeView'
     __gproperties__ = {
         'active-engine' : (
-            gobject.TYPE_PYOBJECT,
+            object,
             'selected engine',
             'selected engine',
-            gobject.PARAM_READABLE),
+            GObject.PARAM_READWRITE),
         'engines' : (
-            gobject.TYPE_PYOBJECT,
+            object,
             'engines',
             'engines',
-            gobject.PARAM_READABLE)
+            GObject.PARAM_READWRITE)
     }
 
     def __init__(self):
@@ -53,7 +53,7 @@ class EngineTreeView(gtk.TreeView):
         # self.set_headers_visible(True)
         self.set_reorderable(True)
 
-        self.__model = gtk.ListStore(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING)
+        self.__model = Gtk.ListStore(GObject.TYPE_PYOBJECT, GObject.TYPE_STRING)
         self.set_model(self.__model)
         self.__model.connect("row-changed", self.__emit_changed_delay_cb, "row-changed")
         self.__model.connect("row-deleted", self.__emit_changed_delay_cb, "row-deleted")
@@ -61,24 +61,24 @@ class EngineTreeView(gtk.TreeView):
         self.__model.connect("rows-reordered", self.__emit_changed_delay_cb, "rows-reordered")
 
         # create im name & icon column
-        column = gtk.TreeViewColumn(_("Input Method"))
+        column = Gtk.TreeViewColumn(_("Input Method"))
         column.set_min_width(220)
 
-        renderer = gtk.CellRendererPixbuf()
+        renderer = Gtk.CellRendererPixbuf()
         renderer.set_property("xalign", 0)
         column.pack_start(renderer, False)
         column.set_cell_data_func(renderer, self.__icon_cell_data_cb)
 
-        renderer = gtk.CellRendererText()
+        renderer = Gtk.CellRendererText()
         renderer.set_property("xalign", 0)
-        renderer.set_property("ellipsize", pango.ELLIPSIZE_END)
+        renderer.set_property("ellipsize", Pango.EllipsizeMode.END)
         column.pack_start(renderer, True)
         column.set_cell_data_func(renderer, self.__name_cell_data_cb)
         self.append_column(column)
 
         # create im keyboard layout column
-        renderer = gtk.CellRendererCombo()
-        model = gtk.ListStore(gobject.TYPE_STRING)
+        renderer = Gtk.CellRendererCombo()
+        model = Gtk.ListStore(GObject.TYPE_STRING)
         model.append(("us",))
         model.append(("jp",))
         model.append(("xkb",))
@@ -89,10 +89,10 @@ class EngineTreeView(gtk.TreeView):
         renderer.set_property("editable", True)
         renderer.connect("changed", self.__engine_layout_changed_cb)
 
-        column = gtk.TreeViewColumn(_("Kbd"))
+        column = Gtk.TreeViewColumn(_("Kbd"))
         column.set_expand(False)
         column.set_fixed_width(32)
-        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
         column.pack_start(renderer, False)
         column.set_cell_data_func(renderer, self.__layout_cell_data_cb)
         # self.append_column(column)
@@ -107,45 +107,47 @@ class EngineTreeView(gtk.TreeView):
     def __emit_changed_delay_cb(self, *args):
         if not self.__changed:
             self.__changed = True
-            glib.idle_add(self.__emit_changed)
+            GLib.idle_add(self.__emit_changed)
 
 
-    def __icon_cell_data_cb(self, celllayout, renderer, model, iter):
+    def __icon_cell_data_cb(self, celllayout, renderer, model, iter, data):
         engine = self.__model.get_value(iter, 0)
 
-        icon_size = gtk.icon_size_lookup(gtk.ICON_SIZE_LARGE_TOOLBAR)[0]
-        pixbuf = load_icon(engine.icon, gtk.ICON_SIZE_LARGE_TOOLBAR)
+        icon_size = Gtk.icon_size_lookup(Gtk.IconSize.LARGE_TOOLBAR)[0]
+        pixbuf = load_icon(engine.get_icon(), Gtk.IconSize.LARGE_TOOLBAR)
 
         if pixbuf == None:
-            pixbuf = load_icon("ibus-engine", gtk.ICON_SIZE_LARGE_TOOLBAR)
+            pixbuf = load_icon("ibus-engine", Gtk.IconSize.LARGE_TOOLBAR)
         if pixbuf == None:
-            pixbuf = load_icon("gtk-missing-image", gtk.ICON_SIZE_LARGE_TOOLBAR)
+            pixbuf = load_icon(Gtk.STOCK_MISSING_IMAGE,
+                               Gtk.IconSize.LARGE_TOOLBAR)
 
         renderer.set_property("pixbuf", pixbuf)
 
-    def __name_cell_data_cb(self, celllayout, renderer, model, iter):
+    def __name_cell_data_cb(self, celllayout, renderer, model, iter, data):
         engine = self.__model.get_value(iter, 0)
         renderer.set_property("sensitive", True)
-        language = ibus.get_language_name(engine.language)
-        renderer.set_property("text", "%s - %s" % (language, engine.longname))
-        if self.__model.get_path(iter)[0] == 0:
+        language = IBus.get_language_name(engine.get_language())
+        renderer.set_property("text",
+                "%s - %s" % (language, engine.get_longname()))
+        if self.__model.get_path(iter).get_indices()[0] == 0:
             # default engine
-            renderer.set_property("weight", pango.WEIGHT_BOLD)
+            renderer.set_property("weight", Pango.Weight.BOLD)
         else:
-            renderer.set_property("weight", pango.WEIGHT_NORMAL)
+            renderer.set_property("weight", Pango.Weight.NORMAL)
 
-    def __layout_cell_data_cb(self, celllayout, renderer, model, iter):
+    def __layout_cell_data_cb(self, celllayout, renderer, model, iter, data):
         engine = self.__model.get_value(iter, 0)
         layout = self.__model.get_value(iter, 1)
         renderer.set_property("sensitive", True)
         if not layout:
             layout = engine.layout
         renderer.set_property("text", layout)
-        if self.__model.get_path(iter)[0] == 0:
+        if self.__model.get_path(iter).get_indices()[0] == 0:
             #default engine
-            renderer.set_property("weight", pango.WEIGHT_BOLD)
+            renderer.set_property("weight", Pango.WEIGHT_BOLD)
         else:
-            renderer.set_property("weight", pango.WEIGHT_NORMAL)
+            renderer.set_property("weight", Pango.WEIGHT_NORMAL)
 
     def __engine_layout_changed_cb(self, combo, path, iter):
         return
@@ -153,14 +155,15 @@ class EngineTreeView(gtk.TreeView):
         layout = combo.get_property("model").get_value(iter, 0)
         self.__model.set_value(i, 1, layout)
 
-    def do_get_property(self, property):
-        if property.name == "active-engine":
+    def do_get_property(self, prop):
+        print "do_get_property ", prop
+        if prop.name == "active-engine":
             iter = self.get_selected_iter()
             if iter == None:
                 return None
             row = self.__model.get(iter, 0)
             return row[0]
-        elif property.name == "engines":
+        elif prop.name == "engines":
             engines = [ r[0] for r in self.__model if r[0] != None]
             return engines
         else:
@@ -244,4 +247,12 @@ class EngineTreeView(gtk.TreeView):
         self.__model.swap(iter, self.__model[index + 1].iter)
         self.scroll_to_cell(row.path, None)
 
-gobject.type_register(EngineTreeView)
+GObject.type_register(EngineTreeView)
+
+if __name__ == "__main__":
+    tree = EngineTreeView()
+    tree.set_engines([IBus.EngineDesc(language="zh")])
+    w = Gtk.Window()
+    w.add(tree)
+    w.show_all()
+    Gtk.main()
diff --git a/setup/icon.py b/setup/icon.py
index 5d2752e8..18989c03 100644
--- a/setup/icon.py
+++ b/setup/icon.py
@@ -51,15 +51,16 @@ def load_icon(icon, size):
         h = int(h / rate)
         pixbuf = pixbuf.scale_simple(w, h, GdkPixbuf.InterpType.BILINEAR)
     except:
-        import traceback
-        traceback.print_exc()
+        # import traceback
+        # traceback.print_exc()
         pass
     if pixbuf == None:
         try:
             theme = Gtk.IconTheme.get_default()
             pixbuf = theme.load_icon(icon, icon_size, 0)
         except:
-            import traceback
-            traceback.print_exc()
+            # import traceback
+            # traceback.print_exc()
+            pass
     icon_cache[(icon, size)] = pixbuf
     return pixbuf
diff --git a/setup/keyboardshortcut.py b/setup/keyboardshortcut.py
index dc9ce5d4..b9e49fd7 100644
--- a/setup/keyboardshortcut.py
+++ b/setup/keyboardshortcut.py
@@ -25,71 +25,73 @@ __all__ = (
     "KeyboardShortcutSelectionDialog",
 );
 
-import gobject
-import gtk
-from gtk import gdk
-from gtk import keysyms
+from gi.repository import Gdk
+from gi.repository import GObject
+from gi.repository import Gtk
+from gi.repository import IBus
+from gi.repository import Pango
+
 from i18n import _, N_
 
 MAX_HOTKEY = 6
 
-class KeyboardShortcutSelection(gtk.VBox):
+class KeyboardShortcutSelection(Gtk.VBox):
     def __init__(self, shortcuts = None):
         super(KeyboardShortcutSelection, self).__init__()
         self.__init_ui()
         self.set_shortcuts(shortcuts)
 
     def __init_ui(self):
-        # label = gtk.Label(_("Keyboard shortcuts:"))
-        # label.set_justify(gtk.JUSTIFY_LEFT)
+        # label = Gtk.Label(_("Keyboard shortcuts:"))
+        # label.set_justify(Gtk.Justification.LEFT)
         # label.set_alignment(0.0, 0.5)
         # self.pack_start(label, False, True, 4)
 
         # shortcuts view
-        self.__shortcut_view = gtk.TreeView(gtk.ListStore(gobject.TYPE_STRING))
+        self.__shortcut_view = Gtk.TreeView(Gtk.ListStore(GObject.TYPE_STRING))
         self.__shortcut_view.set_size_request(-1, 100)
-        renderer = gtk.CellRendererText()
-        column = gtk.TreeViewColumn(_("Keyboard shortcuts"), renderer, text = 0)
+        renderer = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn(_("Keyboard shortcuts"), renderer, text = 0)
         self.__shortcut_view.append_column(column)
         self.__shortcut_view.connect("cursor-changed", self.__shortcut_view_cursor_changed_cb)
-        scrolledwindow = gtk.ScrolledWindow()
-        scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        scrolledwindow = Gtk.ScrolledWindow()
+        scrolledwindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         scrolledwindow.add(self.__shortcut_view)
-        scrolledwindow.set_shadow_type(gtk.SHADOW_IN)
+        scrolledwindow.set_shadow_type(Gtk.ShadowType.IN)
         self.pack_start(scrolledwindow, True, True, 4)
 
         # key code
-        hbox = gtk.HBox()
-        label = gtk.Label(_("Key code:"))
-        label.set_justify(gtk.JUSTIFY_LEFT)
+        hbox = Gtk.HBox()
+        label = Gtk.Label(_("Key code:"))
+        label.set_justify(Gtk.Justification.LEFT)
         label.set_alignment(0.0, 0.5)
         hbox.pack_start(label, False, True, 4)
 
-        self.__keycode_entry = gtk.Entry()
+        self.__keycode_entry = Gtk.Entry()
         self.__keycode_entry.connect("notify::text", self.__keycode_entry_notify_cb)
         hbox.pack_start(self.__keycode_entry, True, True, 4)
-        self.__keycode_button = gtk.Button("...")
+        self.__keycode_button = Gtk.Button("...")
         self.__keycode_button.connect("clicked", self.__keycode_button_clicked_cb)
         hbox.pack_start(self.__keycode_button, False, True, 4)
         self.pack_start(hbox, False, True, 4)
 
         # modifiers
-        hbox = gtk.HBox()
-        label = gtk.Label(_("Modifiers:"))
-        label.set_justify(gtk.JUSTIFY_LEFT)
+        hbox = Gtk.HBox()
+        label = Gtk.Label(_("Modifiers:"))
+        label.set_justify(Gtk.Justification.LEFT)
         label.set_alignment(0.0, 0.5)
         hbox.pack_start(label, False, True, 4)
 
-        table = gtk.Table(4, 2)
+        table = Gtk.Table(4, 2)
         self.__modifier_buttons = []
-        self.__modifier_buttons.append(("Control",     gtk.CheckButton("_Control"),       gdk.CONTROL_MASK))
-        self.__modifier_buttons.append(("Alt",      gtk.CheckButton("A_lt"),        gdk.MOD1_MASK))
-        self.__modifier_buttons.append(("Shift",    gtk.CheckButton("_Shift"),      gdk.SHIFT_MASK))
-        self.__modifier_buttons.append(("Meta",     gtk.CheckButton("_Meta"),       gdk.META_MASK))
-        self.__modifier_buttons.append(("Super",    gtk.CheckButton("S_uper"),      gdk.SUPER_MASK))
-        self.__modifier_buttons.append(("Hyper",    gtk.CheckButton("_Hyper"),      gdk.HYPER_MASK))
-        self.__modifier_buttons.append(("Capslock", gtk.CheckButton("Capsloc_k"),   gdk.LOCK_MASK))
-        self.__modifier_buttons.append(("Release",  gtk.CheckButton("_Release"),    gdk.RELEASE_MASK))
+        self.__modifier_buttons.append(("Control",  Gtk.CheckButton("_Control"),    Gdk.ModifierType.CONTROL_MASK))
+        self.__modifier_buttons.append(("Alt",      Gtk.CheckButton("A_lt"),        Gdk.ModifierType.MOD1_MASK))
+        self.__modifier_buttons.append(("Shift",    Gtk.CheckButton("_Shift"),      Gdk.ModifierType.SHIFT_MASK))
+        self.__modifier_buttons.append(("Meta",     Gtk.CheckButton("_Meta"),       Gdk.ModifierType.META_MASK))
+        self.__modifier_buttons.append(("Super",    Gtk.CheckButton("S_uper"),      Gdk.ModifierType.SUPER_MASK))
+        self.__modifier_buttons.append(("Hyper",    Gtk.CheckButton("_Hyper"),      Gdk.ModifierType.HYPER_MASK))
+        self.__modifier_buttons.append(("Capslock", Gtk.CheckButton("Capsloc_k"),   Gdk.ModifierType.LOCK_MASK))
+        self.__modifier_buttons.append(("Release",  Gtk.CheckButton("_Release"),    Gdk.ModifierType.RELEASE_MASK))
         for name, button, mask in self.__modifier_buttons:
             button.connect("toggled", self.__modifier_button_toggled_cb, name)
 
@@ -105,22 +107,22 @@ class KeyboardShortcutSelection(gtk.VBox):
         self.pack_start(hbox, False, True, 4)
 
         # buttons
-        hbox = gtk.HBox()
+        hbox = Gtk.HBox()
         # add button
-        self.__add_button = gtk.Button(stock = gtk.STOCK_ADD)
+        self.__add_button = Gtk.Button(stock = Gtk.STOCK_ADD)
         self.__add_button.set_sensitive(False)
         self.__add_button.connect("clicked", self.__add_button_clicked_cb)
-        hbox.pack_start(self.__add_button)
+        hbox.pack_start(self.__add_button, False, True, 0)
         # apply button
-        self.__apply_button = gtk.Button(stock = gtk.STOCK_APPLY)
+        self.__apply_button = Gtk.Button(stock = Gtk.STOCK_APPLY)
         self.__apply_button.set_sensitive(False)
         self.__apply_button.connect("clicked", self.__apply_button_clicked_cb)
-        hbox.pack_start(self.__apply_button)
+        hbox.pack_start(self.__apply_button, False, True, 0)
         # delete button
-        self.__delete_button = gtk.Button(stock = gtk.STOCK_DELETE)
+        self.__delete_button = Gtk.Button(stock = Gtk.STOCK_DELETE)
         self.__delete_button.set_sensitive(False)
         self.__delete_button.connect("clicked", self.__delete_button_clicked_cb)
-        hbox.pack_start(self.__delete_button)
+        hbox.pack_start(self.__delete_button, False, True, 0)
         self.pack_start(hbox, False, True, 4)
 
     def set_shortcuts(self, shortcuts = None):
@@ -148,15 +150,16 @@ class KeyboardShortcutSelection(gtk.VBox):
             return
         if shortcut in self.get_shortcuts():
             return
-        iter = model.insert(-1, (shortcut,))
+        iter = model.insert(0)
+        model[iter][0] = shortcut
         self.__add_button.set_sensitive(False)
         path = model.get_path(iter)
-        self.__shortcut_view.set_cursor(path)
+        self.__shortcut_view.set_cursor(path, None, False)
 
     def __get_shortcut_from_buttons(self):
         modifiers = []
         keycode = self.__keycode_entry.get_text()
-        if gdk.keyval_from_name(keycode) == 0:
+        if Gdk.keyval_from_name(keycode) == 0:
             return None
 
         for name, button, mask in self.__modifier_buttons:
@@ -183,7 +186,7 @@ class KeyboardShortcutSelection(gtk.VBox):
         path, column = self.__shortcut_view.get_cursor()
         if path == None:
             return None
-        return model[path[0]][0]
+        return model[path.get_indices()[0]][0]
 
     def __set_selected_shortcut(self, shortcut):
         model = self.__shortcut_view.get_model()
@@ -227,7 +230,7 @@ class KeyboardShortcutSelection(gtk.VBox):
 
     def __keycode_button_clicked_cb(self, button):
         out = []
-        dlg = gtk.MessageDialog(parent = self.get_toplevel(), buttons = gtk.BUTTONS_CLOSE)
+        dlg = Gtk.MessageDialog(parent = self.get_toplevel(), buttons = Gtk.BUTTONS_CLOSE)
         message = _("Please press a key (or a key combination).\nThe dialog will be closed when the key is released.")
         dlg.set_markup(message)
         dlg.set_title(_("Please press a key (or a key combination)"))
@@ -236,42 +239,42 @@ class KeyboardShortcutSelection(gtk.VBox):
             out.append(k.copy())
 
         def __key_release_event(d, k, out):
-            d.response(gtk.RESPONSE_OK)
+            d.response(Gtk.RESPONSE_OK)
 
         dlg.connect("key-press-event", __key_press_event, out)
         dlg.connect("key-release-event", __key_release_event, None)
         id = dlg.run()
         dlg.destroy()
-        if id != gtk.RESPONSE_OK or not out:
+        if id != Gtk.RESPONSE_OK or not out:
             return
         keyevent = out[len(out) - 1]
-        state = keyevent.state & (gdk.CONTROL_MASK | \
-                                  gdk.SHIFT_MASK   | \
-                                  gdk.MOD1_MASK    | \
-                                  gdk.META_MASK    | \
-                                  gdk.SUPER_MASK   | \
-                                  gdk.HYPER_MASK)
+        state = keyevent.state & (Gdk.CONTROL_MASK | \
+                                  Gdk.SHIFT_MASK   | \
+                                  Gdk.MOD1_MASK    | \
+                                  Gdk.META_MASK    | \
+                                  Gdk.SUPER_MASK   | \
+                                  Gdk.HYPER_MASK)
         if state == 0:
-            state = state | gdk.RELEASE_MASK
-        elif keyevent.keyval in (keysyms.Control_L, keysyms.Control_R) and state == gdk.CONTROL_MASK:
-            state = state | gdk.RELEASE_MASK
-        elif keyevent.keyval in (keysyms.Shift_L, keysyms.Shift_R) and state == gdk.SHIFT_MASK:
-            state = state | gdk.RELEASE_MASK
-        elif keyevent.keyval in (keysyms.Alt_L, keysyms.Alt_R) and state == gdk.MOD1_MASK:
-            state = state | gdk.RELEASE_MASK
-        elif keyevent.keyval in (keysyms.Meta_L, keysyms.Meta_R) and state == gdk.META_MASK:
-            state = state | gdk.RELEASE_MASK
-        elif keyevent.keyval in (keysyms.Super_L, keysyms.Super_R) and state == gdk.SUPER_MASK:
-            state = state | gdk.RELEASE_MASK
-        elif keyevent.keyval in (keysyms.Hyper_L, keysyms.Hyper_R) and state == gdk.HYPER_MASK:
-            state = state | gdk.RELEASE_MASK
+            state = state | Gdk.RELEASE_MASK
+        elif keyevent.keyval in (keysyms.Control_L, keysyms.Control_R) and state == Gdk.CONTROL_MASK:
+            state = state | Gdk.RELEASE_MASK
+        elif keyevent.keyval in (keysyms.Shift_L, keysyms.Shift_R) and state == Gdk.SHIFT_MASK:
+            state = state | Gdk.RELEASE_MASK
+        elif keyevent.keyval in (keysyms.Alt_L, keysyms.Alt_R) and state == Gdk.MOD1_MASK:
+            state = state | Gdk.RELEASE_MASK
+        elif keyevent.keyval in (keysyms.Meta_L, keysyms.Meta_R) and state == Gdk.META_MASK:
+            state = state | Gdk.RELEASE_MASK
+        elif keyevent.keyval in (keysyms.Super_L, keysyms.Super_R) and state == Gdk.SUPER_MASK:
+            state = state | Gdk.RELEASE_MASK
+        elif keyevent.keyval in (keysyms.Hyper_L, keysyms.Hyper_R) and state == Gdk.HYPER_MASK:
+            state = state | Gdk.RELEASE_MASK
 
         for name, button, mask in self.__modifier_buttons:
             if state & mask:
                 button.set_active(True)
             else:
                 button.set_active(False)
-        self.__keycode_entry.set_text(gdk.keyval_name(keyevent.keyval))
+        self.__keycode_entry.set_text(Gdk.keyval_name(keyevent.keyval))
 
     def __add_button_clicked_cb(self, button):
         shortcut = self.__get_shortcut_from_buttons()
@@ -286,11 +289,11 @@ class KeyboardShortcutSelection(gtk.VBox):
         self.__delete_button.set_sensitive(False)
         self.__apply_button.set_sensitive(False)
 
-class KeyboardShortcutSelectionDialog(gtk.Dialog):
+class KeyboardShortcutSelectionDialog(Gtk.Dialog):
     def __init__(self, title = None, parent = None, flags = 0, buttons = None):
         super(KeyboardShortcutSelectionDialog, self).__init__(title, parent, flags, buttons)
         self.__selection_view = KeyboardShortcutSelection()
-        self.vbox.pack_start(self.__selection_view)
+        self.vbox.pack_start(self.__selection_view, False, True, 0)
         self.vbox.show_all()
 
     def set_shortcuts(self, shotrcuts = None):
@@ -307,7 +310,8 @@ class KeyboardShortcutSelectionDialog(gtk.Dialog):
 if __name__ == "__main__":
     dlg = KeyboardShortcutSelectionDialog(
         title = "Select test",
-        buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK))
+        buttons = (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+                   Gtk.STOCK_OK, Gtk.ResponseType.OK))
     dlg.add_shortcut("Control+Shift+space")
     dlg.set_shortcuts(None)
     print dlg.run()
diff --git a/setup/main.py b/setup/main.py
index cf2f84bf..1d9f0255 100644
--- a/setup/main.py
+++ b/setup/main.py
@@ -24,12 +24,15 @@ import os
 import signal
 import sys
 import time
-import gtk
-import ibus
-import keyboardshortcut
-import locale
+
+from gi.repository import GLib
+from gi.repository import Gtk
+from gi.repository import IBus
 from os import path
 from xdg import BaseDirectory
+
+import keyboardshortcut
+import locale
 from enginecombobox import EngineComboBox
 from enginetreeview import EngineTreeView
 from engineabout import EngineAbout
@@ -58,154 +61,125 @@ from i18n import DOMAINNAME, _, N_, init as i18n_init
 
 class Setup(object):
     def __flush_gtk_events(self):
-        while gtk.events_pending():
-            gtk.main_iteration()
+        while Gtk.events_pending():
+            Gtk.main_iteration()
 
     def __init__(self):
         super(Setup, self).__init__()
         gtk_builder_file = path.join(path.dirname(__file__), "./setup.ui")
-        self.__builder = gtk.Builder()
+        self.__builder = Gtk.Builder()
         self.__builder.set_translation_domain(DOMAINNAME)
         self.__builder.add_from_file(gtk_builder_file);
         self.__bus = None
         self.__init_bus()
         self.__init_ui()
 
-    def __init_ui(self):
-        # add icon search path
-        self.__window = self.__builder.get_object("window_preferences")
-        self.__window.connect("delete-event", gtk.main_quit)
+    def __init_hotkey(self):
+        default_values = {
+            "trigger" : (N_("trigger"), ["Control+space"]),
+            "enable_unconditional" : (N_("enable"), []),
+            "disable_unconditional" : (N_("disable"), [])
+        }
 
-        self.__button_close = self.__builder.get_object("button_close")
-        self.__button_close.connect("clicked", gtk.main_quit)
+        values = dict(self.__config.get_values("general/hotkey"))
 
-        # auto start ibus
-        self.__checkbutton_auto_start = self.__builder.get_object("checkbutton_auto_start")
-        self.__checkbutton_auto_start.set_active(self.__is_auto_start())
-        self.__checkbutton_auto_start.connect("toggled", self.__checkbutton_auto_start_toggled_cb)
+        for name, (label, shortcuts) in default_values.items():
+            shortcuts = values.get(name, shortcuts)
+            button = self.__builder.get_object("button_%s" % name)
+            entry = self.__builder.get_object("entry_%s" % name)
+            entry.set_text("; ".join(shortcuts))
+            entry.set_tooltip_text("\n".join(shortcuts))
+            button.connect("clicked", self.__shortcut_button_clicked_cb,
+                    label, "general/hotkey", name, entry)
 
-        # keyboard shortcut
-        # trigger
-        self.__config = self.__bus.get_config()
-        shortcuts = self.__config.get_value(
-                        "general/hotkey", "trigger",
-                        ibus.CONFIG_GENERAL_SHORTCUT_TRIGGER_DEFAULT)
-        button = self.__builder.get_object("button_trigger")
-        entry = self.__builder.get_object("entry_trigger")
-        entry.set_text("; ".join(shortcuts))
-        entry.set_tooltip_text("\n".join(shortcuts))
-        button.connect("clicked", self.__shortcut_button_clicked_cb,
-                    N_("trigger"), "general/hotkey", "trigger", entry)
-
-        # enable (unconditional)
-        shortcuts = self.__config.get_value(
-                        "general/hotkey", "enable_unconditional",
-                        ibus.CONFIG_GENERAL_SHORTCUT_ENABLE_DEFAULT)
-        button = self.__builder.get_object("button_enable")
-        entry = self.__builder.get_object("entry_enable")
-        entry.set_text("; ".join(shortcuts))
-        entry.set_tooltip_text("\n".join(shortcuts))
-        button.connect("clicked", self.__shortcut_button_clicked_cb,
-                    N_("enable"), "general/hotkey", "enable_unconditional", entry)
-
-        # disable (unconditional)
-        shortcuts = self.__config.get_value(
-                        "general/hotkey", "disable_unconditional",
-                        ibus.CONFIG_GENERAL_SHORTCUT_DISABLE_DEFAULT)
-        button = self.__builder.get_object("button_disable")
-        entry = self.__builder.get_object("entry_disable")
-        entry.set_text("; ".join(shortcuts))
-        entry.set_tooltip_text("\n".join(shortcuts))
-        button.connect("clicked", self.__shortcut_button_clicked_cb,
-                    N_("disable"), "general/hotkey", "disable_unconditional", entry)
-
-        # next engine
-        shortcuts = self.__config.get_value(
-                        "general/hotkey", "next_engine_in_menu",
-                        ibus.CONFIG_GENERAL_SHORTCUT_NEXT_ENGINE_DEFAULT)
-        button = self.__builder.get_object("button_next_engine")
-        entry = self.__builder.get_object("entry_next_engine")
-        entry.set_text("; ".join(shortcuts))
-        entry.set_tooltip_text("\n".join(shortcuts))
-        button.connect("clicked", self.__shortcut_button_clicked_cb,
-                    N_("next input method"), "general/hotkey", "next_engine_in_menu", entry)
-
-        # prev engine
-        shortcuts = self.__config.get_value(
-                        "general/hotkey", "previous_engine",
-                        ibus.CONFIG_GENERAL_SHORTCUT_PREV_ENGINE_DEFAULT)
-        button = self.__builder.get_object("button_prev_engine")
-        entry = self.__builder.get_object("entry_prev_engine")
-        entry.set_text("; ".join(shortcuts))
-        entry.set_tooltip_text("\n".join(shortcuts))
-        button.connect("clicked", self.__shortcut_button_clicked_cb,
-                    N_("previous input method"), "general/hotkey", "previous_engine", entry)
+    def __init_panel(self):
+        values = dict(self.__config.get_values("panel"))
 
         # lookup table orientation
-        self.__combobox_lookup_table_orientation = self.__builder.get_object("combobox_lookup_table_orientation")
+        self.__combobox_lookup_table_orientation = self.__builder.get_object(
+                "combobox_lookup_table_orientation")
         self.__combobox_lookup_table_orientation.set_active(
-            self.__config.get_value("panel", "lookup_table_orientation", 0))
+                values.get("lookup_table_orientation", 0))
         self.__combobox_lookup_table_orientation.connect("changed",
-            self.__combobox_lookup_table_orientation_changed_cb)
+                self.__combobox_lookup_table_orientation_changed_cb)
 
         # auto hide
-        self.__combobox_panel_show = self.__builder.get_object("combobox_panel_show")
-        self.__combobox_panel_show.set_active(
-            self.__config.get_value("panel", "show", 0))
-        self.__combobox_panel_show.connect("changed", self.__combobox_panel_show_changed_cb)
+        self.__combobox_panel_show = self.__builder.get_object(
+                "combobox_panel_show")
+        self.__combobox_panel_show.set_active(values.get("show", 0))
+        self.__combobox_panel_show.connect("changed",
+                self.__combobox_panel_show_changed_cb)
 
         # panel position
-        self.__combobox_panel_position = self.__builder.get_object("combobox_panel_position")
-        self.__combobox_panel_position.set_active(
-            self.__config.get_value("panel", "position", 3))
-        self.__combobox_panel_position.connect("changed", self.__combobox_panel_position_changed_cb)
+        self.__combobox_panel_position = self.__builder.get_object(
+                "combobox_panel_position")
+        self.__combobox_panel_position.set_active(values.get("position", 3))
+        self.__combobox_panel_position.connect("changed",
+                self.__combobox_panel_position_changed_cb)
 
         # custom font
-        self.__checkbutton_custom_font = self.__builder.get_object("checkbutton_custom_font")
+        self.__checkbutton_custom_font = self.__builder.get_object(
+                "checkbutton_custom_font")
         self.__checkbutton_custom_font.set_active(
-            self.__config.get_value("panel", "use_custom_font", False))
-        self.__checkbutton_custom_font.connect("toggled", self.__checkbutton_custom_font_toggled_cb)
+                values.get("use_custom_font", False))
+        self.__checkbutton_custom_font.connect("toggled",
+                self.__checkbutton_custom_font_toggled_cb)
 
-        self.__fontbutton_custom_font = self.__builder.get_object("fontbutton_custom_font")
-        if self.__config.get_value("panel", "use_custom_font", False):
+        self.__fontbutton_custom_font = self.__builder.get_object(
+                "fontbutton_custom_font")
+        if values.get("use_custom_font", False):
             self.__fontbutton_custom_font.set_sensitive(True)
         else:
             self.__fontbutton_custom_font.set_sensitive(False)
-        font_name = gtk.settings_get_default().get_property("gtk-font-name")
+        font_name = Gtk.Settings.get_default().get_property("gtk-font-name")
         font_name = unicode(font_name, "utf-8")
-        font_name = self.__config.get_value("panel", "custom_font", font_name)
-        self.__fontbutton_custom_font.connect("notify::font-name", self.__fontbutton_custom_font_notify_cb)
+        font_name = values.get("custom_font", font_name)
+        self.__fontbutton_custom_font.connect("notify::font-name",
+                self.__fontbutton_custom_font_notify_cb)
         self.__fontbutton_custom_font.set_font_name(font_name)
 
         # show icon on system tray
-        self.__checkbutton_show_icon_on_systray = self.__builder.get_object("checkbutton_show_icon_on_systray")
+        self.__checkbutton_show_icon_on_systray = self.__builder.get_object(
+                "checkbutton_show_icon_on_systray")
         self.__checkbutton_show_icon_on_systray.set_active(
-            self.__config.get_value("panel", "show_icon_on_systray", True))
-        self.__checkbutton_show_icon_on_systray.connect("toggled", self.__checkbutton_show_icon_on_systray_toggled_cb)
+                values.get("show_icon_on_systray", True))
+        self.__checkbutton_show_icon_on_systray.connect("toggled",
+                self.__checkbutton_show_icon_on_systray_toggled_cb)
 
         # show ime name
-        self.__checkbutton_show_im_name = self.__builder.get_object("checkbutton_show_im_name")
+        self.__checkbutton_show_im_name = self.__builder.get_object(
+                "checkbutton_show_im_name")
         self.__checkbutton_show_im_name.set_active(
-            self.__config.get_value("panel", "show_im_name", False))
-        self.__checkbutton_show_im_name.connect("toggled", self.__checkbutton_show_im_name_toggled_cb)
+                values.get("show_im_name", False))
+        self.__checkbutton_show_im_name.connect("toggled",
+                self.__checkbutton_show_im_name_toggled_cb)
+
+    def __init_general(self):
+        values = dict(self.__config.get_values("general"))
 
         # embed preedit text
-        self.__checkbutton_embed_preedit_text = self.__builder.get_object("checkbutton_embed_preedit_text")
+        self.__checkbutton_embed_preedit_text = self.__builder.get_object(
+                "checkbutton_embed_preedit_text")
         self.__checkbutton_embed_preedit_text.set_active(
-            self.__config.get_value("general", "embed_preedit_text", True))
-        self.__checkbutton_embed_preedit_text.connect("toggled", self.__checkbutton_embed_preedit_text_toggled_cb)
+                values.get("embed_preedit_text", True))
+        self.__checkbutton_embed_preedit_text.connect("toggled",
+                self.__checkbutton_embed_preedit_text_toggled_cb)
 
         # use system keyboard layout setting
-        self.__checkbutton_use_sys_layout = self.__builder.get_object("checkbutton_use_sys_layout")
+        self.__checkbutton_use_sys_layout = self.__builder.get_object(
+                "checkbutton_use_sys_layout")
         self.__checkbutton_use_sys_layout.set_active(
-            self.__config.get_value("general", "use_system_keyboard_layout", True))
-        self.__checkbutton_use_sys_layout.connect("toggled", self.__checkbutton_use_sys_layout_toggled_cb)
+                values.get("use_system_keyboard_layout", True))
+        self.__checkbutton_use_sys_layout.connect("toggled",
+                self.__checkbutton_use_sys_layout_toggled_cb)
 
         # use global ime setting
-        self.__checkbutton_use_global_engine = self.__builder.get_object("checkbutton_use_global_engine")
+        self.__checkbutton_use_global_engine = self.__builder.get_object(
+                "checkbutton_use_global_engine")
         self.__checkbutton_use_global_engine.set_active(
-            self.__config.get_value("general", "use_global_engine", False))
-        self.__checkbutton_use_global_engine.connect("toggled", self.__checkbutton_use_global_engine_toggled_cb)
+                values.get("use_global_engine", False))
+        self.__checkbutton_use_global_engine.connect("toggled",
+                self.__checkbutton_use_global_engine_toggled_cb)
 
         # init engine page
         self.__engines = self.__bus.list_engines()
@@ -214,8 +188,8 @@ class Setup(object):
 
         tmp_dict = {}
         for e in self.__engines:
-            tmp_dict[e.name] = e
-        engine_names = self.__config.get_value("general", "preload_engines", [])
+            tmp_dict[e.get_name()] = e
+        engine_names = values.get("preload_engines", [])
         engines = [tmp_dict[name] for name in engine_names if name in tmp_dict]
 
         self.__treeview = self.__builder.get_object("treeview_engines")
@@ -229,7 +203,8 @@ class Setup(object):
         button.connect("clicked", lambda *args:self.__treeview.move_up_engine())
 
         button = self.__builder.get_object("button_engine_down")
-        button.connect("clicked", lambda *args:self.__treeview.move_down_engine())
+        button.connect("clicked",
+                lambda *args:self.__treeview.move_down_engine())
 
         button = self.__builder.get_object("button_engine_about")
         button.connect("clicked", self.__button_engine_about_cb)
@@ -238,13 +213,36 @@ class Setup(object):
         button = self.__builder.get_object("button_engine_preferences")
         button.connect("clicked", self.__button_engine_preferences_cb)
 
-        self.__combobox.connect("notify::active-engine", self.__combobox_notify_active_engine_cb)
+        self.__combobox.connect("notify::active-engine",
+                self.__combobox_notify_active_engine_cb)
         self.__treeview.connect("notify", self.__treeview_notify_cb)
 
+    def __init_ui(self):
+        # add icon search path
+        self.__window = self.__builder.get_object("window_preferences")
+        self.__window.connect("delete-event", Gtk.main_quit)
+
+        self.__button_close = self.__builder.get_object("button_close")
+        self.__button_close.connect("clicked", Gtk.main_quit)
+
+        # auto start ibus
+        self.__checkbutton_auto_start = self.__builder.get_object(
+                "checkbutton_auto_start")
+        self.__checkbutton_auto_start.set_active(self.__is_auto_start())
+        self.__checkbutton_auto_start.connect("toggled",
+                self.__checkbutton_auto_start_toggled_cb)
+
+        self.__config = self.__bus.get_config()
+
+        self.__init_hotkey()
+        self.__init_panel()
+        self.__init_general()
+
     def __combobox_notify_active_engine_cb(self, combobox, property):
         engine = self.__combobox.get_active_engine()
         button = self.__builder.get_object("button_engine_add")
-        button.set_sensitive(engine != None and engine not in self.__treeview.get_engines())
+        button.set_sensitive(
+                engine != None and engine not in self.__treeview.get_engines())
 
     def __get_engine_setup_exec_args(self, engine):
         args = []
@@ -264,8 +262,8 @@ class Setup(object):
             args.append(path.basename(setup_path))
         return args
 
-    def __treeview_notify_cb(self, treeview, property):
-        if property.name != "active-engine" and property.name != "engines":
+    def __treeview_notify_cb(self, treeview, name):
+        if name != "active-engine" and name != "engines":
             return
 
         engines = self.__treeview.get_engines()
@@ -317,7 +315,7 @@ class Setup(object):
 
     def __init_bus(self):
         try:
-            self.__bus = ibus.Bus()
+            self.__bus = IBus.Bus()
             # self.__bus.connect("config-value-changed", self.__config_value_changed_cb)
             # self.__bus.connect("config-reloaded", self.__config_reloaded_cb)
             # self.__bus.config_add_watch("/general")
@@ -326,18 +324,18 @@ class Setup(object):
         except:
             while self.__bus == None:
                 message = _("IBus daemon is not started. Do you want to start it now?")
-                dlg = gtk.MessageDialog(type = gtk.MESSAGE_QUESTION,
-                        buttons = gtk.BUTTONS_YES_NO,
+                dlg = Gtk.MessageDialog(type = Gtk.MESSAGE_QUESTION,
+                        buttons = Gtk.BUTTONS_YES_NO,
                         message_format = message)
                 id = dlg.run()
                 dlg.destroy()
                 self.__flush_gtk_events()
-                if id != gtk.RESPONSE_YES:
+                if id != Gtk.RESPONSE_YES:
                     sys.exit(0)
                 pid = os.spawnlp(os.P_NOWAIT, "ibus-daemon", "ibus-daemon", "--xim")
                 time.sleep(1)
                 try:
-                    self.__bus = ibus.Bus()
+                    self.__bus = IBus.Bus()
                 except:
                     continue
                 message = _("IBus has been started! "
@@ -346,15 +344,15 @@ class Setup(object):
                     "  export XMODIFIERS=@im=ibus\n"
                     "  export QT_IM_MODULE=ibus"
                     )
-                dlg = gtk.MessageDialog(type = gtk.MESSAGE_INFO,
-                                        buttons = gtk.BUTTONS_OK,
+                dlg = Gtk.MessageDialog(type = Gtk.MESSAGE_INFO,
+                                        buttons = Gtk.BUTTONS_OK,
                                         message_format = message)
                 id = dlg.run()
                 dlg.destroy()
                 self.__flush_gtk_events()
 
     def __shortcut_button_clicked_cb(self, button, name, section, _name, entry):
-        buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)
+        buttons = (Gtk.STOCK_CANCEL, Gtk.RESPONSE_CANCEL, Gtk.STOCK_OK, Gtk.RESPONSE_OK)
         title = _("Select keyboard shortcut for %s") %  _(name)
         dialog = keyboardshortcut.KeyboardShortcutSelectionDialog(buttons = buttons, title = title)
         text = entry.get_text()
@@ -366,7 +364,7 @@ class Setup(object):
         id = dialog.run()
         shortcuts = dialog.get_shortcuts()
         dialog.destroy()
-        if id != gtk.RESPONSE_OK:
+        if id != Gtk.RESPONSE_OK:
             return
         self.__config.set_list(section, _name, shortcuts, "s")
         text = "; ".join(shortcuts)
@@ -385,8 +383,8 @@ class Setup(object):
             try:
                 self.__bus.register_start_engine(data[DATA_LANG], data[DATA_NAME])
             except Exception, e:
-                dlg = gtk.MessageDialog(type = gtk.MESSAGE_ERROR,
-                        buttons = gtk.BUTTONS_CLOSE,
+                dlg = Gtk.MessageDialog(type = Gtk.MESSAGE_ERROR,
+                        buttons = Gtk.BUTTONS_CLOSE,
                         message_format = str(e))
                 dlg.run()
                 dlg.destroy()
@@ -396,8 +394,8 @@ class Setup(object):
             try:
                 self.__bus.register_stop_engine(data[DATA_LANG], data[DATA_NAME])
             except Exception, e:
-                dlg = gtk.MessageDialog(type = gtk.MESSAGE_ERROR,
-                        buttons = gtk.BUTTONS_CLOSE,
+                dlg = Gtk.MessageDialog(type = Gtk.MESSAGE_ERROR,
+                        buttons = Gtk.BUTTONS_CLOSE,
                         message_format = str(e))
                 dlg.run()
                 dlg.destroy()
@@ -430,8 +428,8 @@ class Setup(object):
         model.set(iter, COLUMN_PRELOAD, data[DATA_PRELOAD])
 
     def __is_auto_start(self):
-        link_file = path.join(BaseDirectory.xdg_config_home, "autostart/ibus.desktop")
-        ibus_desktop = path.join(os.getenv("IBUS_PREFIX"), "share/applications/ibus.desktop")
+        link_file = path.join(BaseDirectory.xdg_config_home, "autostart/IBus.desktop")
+        ibus_desktop = path.join(os.getenv("IBUS_PREFIX"), "share/applications/IBus.desktop")
 
         if not path.exists(link_file):
             return False
@@ -446,8 +444,8 @@ class Setup(object):
         if not path.isdir(auto_start_dir):
             os.makedirs(auto_start_dir)
 
-        link_file = path.join(BaseDirectory.xdg_config_home, "autostart/ibus.desktop")
-        ibus_desktop = path.join(os.getenv("IBUS_PREFIX"), "share/applications/ibus.desktop")
+        link_file = path.join(BaseDirectory.xdg_config_home, "autostart/IBus.desktop")
+        ibus_desktop = path.join(os.getenv("IBUS_PREFIX"), "share/applications/IBus.desktop")
         # unlink file
         try:
             os.unlink(link_file)
@@ -516,7 +514,7 @@ class Setup(object):
     def run(self):
         self.__window.show_all()
         signal.signal(signal.SIGUSR1, self.__sigusr1_cb)
-        gtk.main()
+        Gtk.main()
 
 if __name__ == "__main__":
     locale.setlocale(locale.LC_ALL, '')
diff --git a/setup/setup.ui b/setup/setup.ui
index c7ff5640..e37cb323 100644
--- a/setup/setup.ui
+++ b/setup/setup.ui
@@ -264,7 +264,7 @@
                                     <property name="visible">True</property>
                                     <property name="spacing">6</property>
                                     <child>
-                                      <object class="GtkEntry" id="entry_enable">
+                                      <object class="GtkEntry" id="entry_enable_unconditional">
                                         <property name="visible">True</property>
                                         <property name="can_focus">True</property>
                                         <property name="editable">False</property>
@@ -274,7 +274,7 @@
                                       </packing>
                                     </child>
                                     <child>
-                                      <object class="GtkButton" id="button_enable">
+                                      <object class="GtkButton" id="button_enable_unconditional">
                                         <property name="label" translatable="yes">...</property>
                                         <property name="visible">True</property>
                                         <property name="can_focus">True</property>
@@ -312,7 +312,7 @@
                                     <property name="visible">True</property>
                                     <property name="spacing">6</property>
                                     <child>
-                                      <object class="GtkEntry" id="entry_disable">
+                                      <object class="GtkEntry" id="entry_disable_unconditional">
                                         <property name="visible">True</property>
                                         <property name="can_focus">True</property>
                                         <property name="editable">False</property>
@@ -322,7 +322,7 @@
                                       </packing>
                                     </child>
                                     <child>
-                                      <object class="GtkButton" id="button_disable">
+                                      <object class="GtkButton" id="button_disable_unconditional">
                                         <property name="label" translatable="yes">...</property>
                                         <property name="visible">True</property>
                                         <property name="can_focus">True</property>