Support changing the global input method engine without focus.

ui/gtk/panel.py

 # vim:set et sts=4 sw=4:
 #
 # ibus - The Input Bus
 #
 # Copyright(c) 2007-2010 Peng Huang <shawn.p.huang@gmail.com>
 # Copyright(c) 2007-2010 Red Hat, Inc.
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
 # License as published by the Free Software Foundation; either
@@ skipping 43 matching lines @@
     show_uri(about.get_screen(), "mailto:%s" % email)
 
 gtk.about_dialog_set_url_hook(url_hook, None)
 gtk.about_dialog_set_email_hook(email_hook, None)
 
 class Panel(ibus.PanelBase):
     __gtype_name__ = "IBusPanel"
     def __init__(self, bus):
         super(Panel, self).__init__(bus)
         self.__bus = bus
+        self.__bus.connect("global-engine-changed",
+                           self.__global_engine_changed_cb)
         self.__config = self.__bus.get_config()
         self.__focus_ic = None
         self.__setup_pid = 0
         self.__prefix = os.getenv("IBUS_PREFIX")
         self.__data_dir = path.join(self.__prefix, "share", "ibus")
         # self.__icons_dir = path.join(self.__data_dir, "icons")
         self.__setup_cmd = path.join(self.__prefix, "bin", "ibus-setup")
         self.__setxkbmap_cmd = path.join(self.__prefix, "bin", "setxkbmap")
         self.__current_xkb_layout = ""
         self.__default_xkb_layout = "us"
@@ skipping 123 matching lines @@
             self.__status_icon.set_from_file(icon_name)
         else:
             self.__status_icon.set_from_icon_name(icon_name)
 
     def __set_im_name(self, name):
         self.__language_bar.set_im_name(name)
 
     def focus_in(self, ic):
         self.reset()
         self.__focus_ic = ibus.InputContext(self.__bus, ic)
-        enabled = self.__focus_ic.is_enabled()
-        self.__language_bar.set_enabled(enabled)
-
-        if not enabled:
-            self.__set_im_icon(ICON_KEYBOARD)
-            self.__set_im_name(None)
-            if self.__bus.get_use_sys_layout():
-                self.__set_xkb_layout(self.__default_xkb_layout)
-        else:
-            engine = self.__focus_ic.get_engine()
-            if engine:
-                self.__set_im_icon(engine.icon)
-                self.__set_im_name(engine.longname)
-                if self.__bus.get_use_sys_layout():
-                    self.__set_xkb_layout(engine.layout)
-            else:
-                self.__set_im_icon(ICON_KEYBOARD)
-                self.__set_im_name(None)
-                if self.__bus.get_use_sys_layout():
-                    self.__set_xkb_layout(self.__default_xkb_layout)
+        self.__update_ui_and_xkb_layout()
         self.__language_bar.focus_in()
 
     def focus_out(self, ic):
         self.reset()
         self.__focus_ic = None
-        self.__language_bar.set_enabled(False)
+        self.__update_ui_and_xkb_layout()
         self.__language_bar.focus_out()
-        self.__set_im_icon(ICON_KEYBOARD)
-        self.__set_im_name(None)
-        if self.__bus.get_use_sys_layout():
-            self.__set_xkb_layout(self.__default_xkb_layout)
 
     def state_changed(self):
         if not self.__focus_ic:
             return
-
-        enabled = self.__focus_ic.is_enabled()
-        self.__language_bar.set_enabled(enabled)
-
-        if enabled == False:
-            self.reset()
-            self.__set_im_icon(ICON_KEYBOARD)
-            self.__set_im_name(None)
-            if self.__bus.get_use_sys_layout():
-                self.__set_xkb_layout(self.__default_xkb_layout)
-        else:
-            engine = self.__focus_ic.get_engine()
-            if engine:
-                self.__set_im_icon(engine.icon)
-                self.__set_im_name(engine.longname)
-                if self.__bus.get_use_sys_layout():
-                    self.__set_xkb_layout(engine.layout)
-            else:
-                self.__set_im_icon(ICON_KEYBOARD)
-                self.__set_im_name(None)
-                if self.__bus.get_use_sys_layout():
-                    self.__set_xkb_layout(self.__default_xkb_layout)
+        self.__update_ui_and_xkb_layout()
 
     def reset(self):
         self.__candidate_panel.reset()
         self.__language_bar.reset()
 
     def start_setup(self):
         self.__start_setup()
 
     def do_destroy(self):
         gtk.main_quit()
@@ skipping 133 matching lines @@
     #     menu.add(item)
 
     #     menu.show_all()
     #     menu.set_take_focus(False)
     #     return menu
 
     def __create_im_menu(self):
         engines = self.__bus.list_active_engines()
         current_engine = \
             (self.__focus_ic != None and self.__focus_ic.get_engine()) or \
+            self.__bus.get_global_engine() or \
             (engines and engines[0]) or \
             None
 
         size = gtk.icon_size_lookup(gtk.ICON_SIZE_MENU)
         menu = gtk.Menu()
         for i, engine in enumerate(engines):
             lang = ibus.get_language_name(engine.language)
             item = gtk.ImageMenuItem("%s - %s" % (lang, engine.longname))
             if current_engine and current_engine.name == engine.name:
                 for widget in item.get_children():
@@ skipping 36 matching lines @@
 
     def __status_icon_popup_menu_cb(self, status_icon, button, active_time):
         menu = self.__create_sys_menu()
         menu.popup(None, None,
                 gtk.status_icon_position_menu,
                 button,
                 active_time,
                 self.__status_icon)
 
     def __status_icon_activate_cb(self, status_icon):
-        if not self.__focus_ic:
+        if not (self.__focus_ic or self.__bus.get_use_global_engine()):
             menu = gtk.Menu()
             item = gtk.ImageMenuItem(_("No input window"))
             size = gtk.icon_size_lookup(gtk.ICON_SIZE_MENU)
             item.set_image(_icon.IconWidget("gtk-info", size[0]))
             menu.add(item)
             menu.show_all()
         else:
             menu = self.__create_im_menu()
             self.__language_bar.create_im_menu(menu)
         menu.popup(None, None,
                 gtk.status_icon_position_menu,
                 0,
                 gtk.get_current_event_time(),
                 self.__status_icon)
 
     def __im_menu_item_activate_cb(self, item, engine):
-        if not self.__focus_ic:
-            return
-        if engine:
-            self.__focus_ic.set_engine(engine)
-        else:
-            self.__focus_ic.disable()
+        if self.__focus_ic:
+            if engine:
+                self.__focus_ic.set_engine(engine)
+            else:
+                self.__focus_ic.disable()
+        elif self.__bus.get_use_global_engine() and engine:
+            self.__bus.set_global_engine(engine)
 
     def __sys_menu_item_activate_cb(self, item, command):
         if command == gtk.STOCK_PREFERENCES:
             self.__start_setup()
         elif command == gtk.STOCK_ABOUT:
             about_dialog = gtk.AboutDialog()
             about_dialog.set_program_name("IBus")
             about_dialog.set_version(ibus.get_version())
             about_dialog.set_copyright(ibus.get_copyright())
             about_dialog.set_license(ibus.get_license())
@@ skipping 31 matching lines @@
         self.__setup_pid = os.spawnl(os.P_NOWAIT, self.__setup_cmd, "ibus-setup")
 
     def __set_xkb_layout(self, layout):
         # if it's not a us keyboard layout, then we need to load us layout
         # into the second group. Otherwise applications' key bindings may
         # not work correctly.
         if layout != "us" and not layout.startswith("us("):
             layout = layout + ",us"
 
         if self.__current_xkb_layout == layout:
-            return;
+            return
 
         self.__current_xkb_layout = layout
 
         # FIXME: It's an ugly hack. libxklavier might be used to make it more
         # reliable.
         try:
             os.spawnv(os.P_WAIT, self.__setxkbmap_cmd,
                       [ "setxkbmap", "-layout", layout ] )
         except:
             print >> sys.stderr, "Failed to run %s" % self.__setxkbmap_cmd
+
+    def __update_ui_and_xkb_layout(self):
+        engine = None
+        enabled = False
+        language_bar_enabled = False
+
+        if self.__focus_ic:
+            engine = self.__focus_ic.get_engine()
+            enabled = self.__focus_ic.is_enabled()
+            language_bar_enabled = enabled
+        elif self.__bus.get_use_global_engine():
+            engine = self.__bus.get_global_engine()
+            enabled = self.__bus.is_global_engine_enabled()
+
+        self.__language_bar.set_enabled(language_bar_enabled)
+
+        if engine and enabled:
+            self.__set_im_icon(engine.icon)
+            self.__set_im_name(engine.longname)
+            if self.__bus.get_use_sys_layout():
+                self.__set_xkb_layout(engine.layout)
+        else:
+            self.__set_im_icon(ICON_KEYBOARD)
+            self.__set_im_name(None)
+            if self.__bus.get_use_sys_layout():
+                self.__set_xkb_layout(self.__default_xkb_layout)
+
+    def __global_engine_changed_cb(self, bus):
+        if not self.__focus_ic:
+            self.__update_ui_and_xkb_layout()