Merge xkb related changes.

bus/ibusimpl.c

 /* vim:set et sts=4: */
 /* ibus - The Input Bus
  * Copyright (C) 2008-2010 Peng Huang <shawn.p.huang@gmail.com>
  * Copyright (C) 2008-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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 37 matching lines @@
 
 /* functions prototype */
 static void     bus_ibus_impl_destroy           (BusIBusImpl        *ibus);
 static gboolean bus_ibus_impl_ibus_message      (BusIBusImpl        *ibus,
                                                  BusConnection      *connection,
                                                  IBusMessage        *message);
 static void     bus_ibus_impl_add_factory       (BusIBusImpl        *ibus,
                                                  BusFactoryProxy    *factory);
 static void     bus_ibus_impl_set_trigger       (BusIBusImpl        *ibus,
                                                  GValue             *value);
+static void     bus_ibus_impl_set_next_engine_in_menu
+                                                (BusIBusImpl        *ibus,
+                                                 GValue             *value);
+static void     bus_ibus_impl_set_previous_engine
+                                                (BusIBusImpl        *ibus,
+                                                 GValue             *value);
+
 static void     bus_ibus_impl_set_preload_engines
                                                 (BusIBusImpl        *ibus,
                                                  GValue             *value);
 static void     bus_ibus_impl_set_use_sys_layout
                                                 (BusIBusImpl        *ibus,
                                                  GValue             *value);
 static void     bus_ibus_impl_set_embed_preedit_text
                                                 (BusIBusImpl        *ibus,
                                                  GValue             *value);
+static void     bus_ibus_impl_set_enable_by_default
+                                                (BusIBusImpl        *ibus,
+                                                 GValue             *value);
 
 static void     bus_ibus_impl_set_use_global_engine
                                                 (BusIBusImpl        *ibus,
                                                  GValue             *value);
 static void     bus_ibus_impl_set_global_engine (BusIBusImpl        *ibus,
                                                  BusEngineProxy     *engine);
 
 static void     bus_ibus_impl_registry_changed  (BusIBusImpl        *ibus);
 static void     _factory_destroy_cb             (BusFactoryProxy    *factory,
                                                  BusIBusImpl        *ibus);
 
+static void     bus_ibus_impl_set_context_engine(BusIBusImpl        *ibus,
+                                                 BusInputContext    *context,
+                                                 BusEngineProxy     *engine);
+
+static gchar   *bus_ibus_impl_load_global_engine_name_from_config
+                                                (BusIBusImpl        *ibus);
+static void     bus_ibus_impl_save_global_engine_name_to_config
+                                                (BusIBusImpl        *ibus);
+
+static gchar   *bus_ibus_impl_load_global_previous_engine_name_from_config
+                                                (BusIBusImpl        *ibus);
+static void     bus_ibus_impl_save_global_previous_engine_name_to_config
+                                                (BusIBusImpl        *ibus);
+
 G_DEFINE_TYPE(BusIBusImpl, bus_ibus_impl, IBUS_TYPE_SERVICE)
 
 BusIBusImpl *
 bus_ibus_impl_get_default (void)
 {
     static BusIBusImpl *ibus = NULL;
 
     if (ibus == NULL) {
         ibus = (BusIBusImpl *) g_object_new (BUS_TYPE_IBUS_IMPL,
                                              "path", IBUS_PATH_IBUS,
@@ skipping 68 matching lines @@
     bus_ibus_impl_set_hotkey (ibus, hotkey, value);
     if (value == NULL) {
         ibus_hotkey_profile_add_hotkey (ibus->hotkey_profile,
                                         IBUS_space,
                                         IBUS_CONTROL_MASK,
                                         hotkey);
     }
 }
 
 static void
-bus_ibus_impl_set_next_engine (BusIBusImpl *ibus,
-                               GValue      *value)
+bus_ibus_impl_set_next_engine_in_menu (BusIBusImpl *ibus,
+                                       GValue      *value)
 {
-    GQuark hotkey = g_quark_from_static_string ("next-engine");
+    GQuark hotkey = g_quark_from_static_string ("next-engine-in-menu");
     bus_ibus_impl_set_hotkey (ibus, hotkey, value);
 }
 
 static void
-bus_ibus_impl_set_prev_engine (BusIBusImpl *ibus,
-                               GValue      *value)
+bus_ibus_impl_set_previous_engine (BusIBusImpl *ibus,
+                                   GValue      *value)
 {
-    GQuark hotkey = g_quark_from_static_string ("prev-engine");
+    GQuark hotkey = g_quark_from_static_string ("previous-engine");
     bus_ibus_impl_set_hotkey (ibus, hotkey, value);
 }
 
 static void
 bus_ibus_impl_set_preload_engines (BusIBusImpl *ibus,
                                    GValue      *value)
 {
     GList *engine_list = NULL;
 
     g_list_foreach (ibus->engine_list, (GFunc) g_object_unref, NULL);
@@ skipping 38 matching lines @@
 static void
 bus_ibus_impl_set_use_sys_layout (BusIBusImpl *ibus,
                                   GValue      *value)
 {
     if (value != NULL && G_VALUE_TYPE (value) == G_TYPE_BOOLEAN) {
         ibus->use_sys_layout = g_value_get_boolean (value);
     }
 }
 
 static void
-bus_ibus_impl_set_embed_preedit_text (BusIBusImpl        *ibus,
-                                                             GValue             *value){
+bus_ibus_impl_set_embed_preedit_text (BusIBusImpl *ibus,
+                                      GValue      *value)
+{
     if (value != NULL && G_VALUE_TYPE (value) == G_TYPE_BOOLEAN) {
         ibus->embed_preedit_text = g_value_get_boolean (value);
     }
-
 }
 
 static void
+bus_ibus_impl_set_enable_by_default (BusIBusImpl *ibus,
+                                     GValue      *value)
+{
+    if (value != NULL && G_VALUE_TYPE (value) == G_TYPE_BOOLEAN) {
+        ibus->enable_by_default = g_value_get_boolean (value);
+    }
+}
+
+static void
 bus_ibus_impl_set_use_global_engine (BusIBusImpl *ibus,
                                      GValue      *value)
 {
     gboolean new_value;
 
     if (value == NULL || G_VALUE_TYPE (value) != G_TYPE_BOOLEAN) {
         return;
     }
 
     new_value = g_value_get_boolean (value);
     if (ibus->use_global_engine == new_value) {
         return;
     }
 
     if (new_value == TRUE) {
         BusEngineProxy *engine;
         /* turn on use_global_engine option */
         ibus->use_global_engine = TRUE;
         engine = ibus->focused_context != NULL ?
                     bus_input_context_get_engine (ibus->focused_context) : NULL;
         if (engine) {
             bus_ibus_impl_set_global_engine (ibus, engine);
         }
     }
     else {
         /* turn off use_global_engine option */
         bus_ibus_impl_set_global_engine (ibus, NULL);
         ibus->use_global_engine = FALSE;
+
+        g_free (ibus->global_previous_engine_name);
     }
 }
 
 static gint
 _engine_desc_cmp (IBusEngineDesc *desc1,
                   IBusEngineDesc *desc2)
 {
     return - ((gint) desc1->rank) + ((gint) desc2->rank);
 }
 
@@ skipping 65 matching lines @@
 
     gint i;
     GValue value = { 0 };
 
     const static struct {
         gchar *section;
         gchar *key;
         void ( *func) (BusIBusImpl *, GValue *);
     } entries [] = {
         { "general/hotkey", "trigger", bus_ibus_impl_set_trigger },
-        { "general/hotkey", "next_engine", bus_ibus_impl_set_next_engine },
-        { "general/hotkey", "prev_engine", bus_ibus_impl_set_prev_engine },
+        { "general/hotkey", "next_engine_in_menu", bus_ibus_impl_set_next_engine_in_menu },
+        { "general/hotkey", "previous_engine", bus_ibus_impl_set_previous_engine },
         { "general", "preload_engines", bus_ibus_impl_set_preload_engines },
         { "general", "use_system_keyboard_layout", bus_ibus_impl_set_use_sys_layout },
         { "general", "use_global_engine", bus_ibus_impl_set_use_global_engine },
         { "general", "embed_preedit_text", bus_ibus_impl_set_embed_preedit_text },
+        { "general", "enable_by_default", bus_ibus_impl_set_enable_by_default },
     };
 
     for (i = 0; i < G_N_ELEMENTS (entries); i++) {
         if (ibus->config != NULL &&
             ibus_config_get_value (ibus->config,
                                    entries[i].section,
                                    entries[i].key,
                                    &value)) {
             entries[i].func (ibus, &value);
             g_value_unset (&value);
@@ skipping 17 matching lines @@
     g_assert (value);
     g_assert (BUS_IS_IBUS_IMPL (ibus));
 
     gint i;
 
     const static struct {
         gchar *section;
         gchar *key;
         void ( *func) (BusIBusImpl *, GValue *);
     } entries [] = {
-        { "general/hotkey", "trigger",     bus_ibus_impl_set_trigger },
-        { "general/hotkey", "next_engine", bus_ibus_impl_set_next_engine },
-        { "general/hotkey", "prev_engine", bus_ibus_impl_set_prev_engine },
+        { "general/hotkey", "trigger", bus_ibus_impl_set_trigger },
+        { "general/hotkey", "next_engine_in_menu", bus_ibus_impl_set_next_engine_in_menu },
+        { "general/hotkey", "previous_engine", bus_ibus_impl_set_previous_engine },
         { "general", "preload_engines",    bus_ibus_impl_set_preload_engines },
         { "general", "use_system_keyboard_layout", bus_ibus_impl_set_use_sys_layout },
         { "general", "use_global_engine", bus_ibus_impl_set_use_global_engine },
         { "general", "embed_preedit_text", bus_ibus_impl_set_embed_preedit_text },
+        { "general", "enable_by_default", bus_ibus_impl_set_enable_by_default },
     };
 
     for (i = 0; i < G_N_ELEMENTS (entries); i++) {
         if (g_strcmp0 (entries[i].section, section) == 0 &&
             g_strcmp0 (entries[i].key, key) == 0) {
             entries[i].func (ibus, value);
             break;
         }
     }
 }
@@ skipping 126 matching lines @@
 #ifdef G_THREADS_ENABLED
     extern gint g_monitor_timeout;
     if (g_monitor_timeout != 0) {
         bus_registry_start_monitor_changes (ibus->registry);
     }
 #endif
 
     ibus->hotkey_profile = ibus_hotkey_profile_new ();
     ibus->keymap = ibus_keymap_get ("us");
 
-    ibus->use_sys_layout = FALSE;
+    ibus->use_sys_layout = TRUE;
     ibus->embed_preedit_text = TRUE;
-    ibus->use_global_engine = FALSE;
+    ibus->enable_by_default = TRUE;
+    ibus->use_global_engine = TRUE;
     ibus->global_engine = NULL;
+    ibus->global_previous_engine_name = NULL;
 
     bus_ibus_impl_reload_config (ibus);
 
     g_signal_connect (BUS_DEFAULT_DBUS,
                       "name-owner-changed",
                       G_CALLBACK (_dbus_name_owner_changed_cb),
                       ibus);
 }
 
 static void
@@ skipping 55 matching lines @@
     if (ibus->keymap != NULL) {
         g_object_unref (ibus->keymap);
         ibus->keymap = NULL;
     }
 
     if (ibus->global_engine) {
         g_object_unref (ibus->global_engine);
         ibus->global_engine = NULL;
     }
 
+    g_free (ibus->global_previous_engine_name);
+
     bus_server_quit (BUS_DEFAULT_SERVER);
     ibus_object_destroy ((IBusObject *) BUS_DEFAULT_SERVER);
     IBUS_OBJECT_CLASS(bus_ibus_impl_parent_class)->destroy (IBUS_OBJECT (ibus));
 }
 
 /* introspectable interface */
 static IBusMessage *
 _ibus_introspect (BusIBusImpl     *ibus,
                   IBusMessage     *message,
                   BusConnection   *connection)
@@ skipping 26 matching lines @@
         "    <method name=\"ListActiveEngines\">\n"
         "      <arg name=\"engines\" direction=\"out\" type=\"av\"/>\n"
         "    </method>\n"
         "    <method name=\"Exit\">\n"
         "      <arg name=\"restart\" direction=\"in\" type=\"b\"/>\n"
         "    </method>\n"
         "    <method name=\"Ping\">\n"
         "      <arg name=\"data\" direction=\"in\" type=\"v\"/>\n"
         "      <arg name=\"data\" direction=\"out\" type=\"v\"/>\n"
         "    </method>\n"
+        "    <method name=\"GetUseSysLayout\">\n"
+        "      <arg name=\"enable\" direction=\"out\" type=\"b\"/>\n"
+        "    </method>\n"
         "    <signal name=\"RegistryChanged\">\n"
         "    </signal>\n"
         "  </interface>\n"
         "</node>\n";
 
     IBusMessage *reply_message;
     reply_message = ibus_message_new_method_return (message);
     ibus_message_append_args (reply_message,
                               G_TYPE_STRING, &introspect,
                               G_TYPE_INVALID);
@@ skipping 97 matching lines @@
                             gchar           *engine_name,
                             BusIBusImpl     *ibus)
 {
     IBusEngineDesc *engine_desc = NULL;
     BusEngineProxy *engine;
 
     /* context should has focus before request an engine */
     g_return_if_fail (bus_input_context_has_focus (context));
 
     if (engine_name == NULL || engine_name[0] == '\0') {
+        /* Use global engine if possible. */
+        if (ibus->use_global_engine) {
+            if (ibus->global_engine) {
+                bus_ibus_impl_set_context_engine (ibus, context, ibus->global_engine);
+                return;
+            }
+            else {
+                engine_name = bus_ibus_impl_load_global_engine_name_from_config (ibus);
+                if (engine_name) {
+                    engine_desc = _find_engine_desc_by_name (ibus, engine_name);
+                    g_free (engine_name);
+                }
+            }
+        }
         /* request default engine */
-        if (ibus->register_engine_list) {
-            engine_desc = (IBusEngineDesc *)ibus->register_engine_list->data;
-        }
-        else if (ibus->engine_list) {
-            engine_desc = (IBusEngineDesc *)ibus->engine_list->data;
-        }
+        if (!engine_desc) {
+            if (ibus->register_engine_list) {
+                engine_desc = (IBusEngineDesc *)ibus->register_engine_list->data;
+            }
+            else if (ibus->engine_list) {
+                engine_desc = (IBusEngineDesc *)ibus->engine_list->data;
+            }
+         }
     }
     else {
         /* request engine by name */
         engine_desc = _find_engine_desc_by_name (ibus, engine_name);
     }
 
     if (engine_desc != NULL) {
         engine = bus_ibus_impl_create_engine (engine_desc);
         if (engine != NULL) {
-            bus_input_context_set_engine (context, engine);
+            bus_ibus_impl_set_context_engine (ibus, context, engine);
         }
     }
 }
 
 static void
-_context_request_next_engine_cb (BusInputContext *context,
-                                 BusIBusImpl     *ibus)
+bus_ibus_impl_context_request_next_engine_in_menu (BusIBusImpl     *ibus,
+                                                   BusInputContext *context)
 {
     BusEngineProxy *engine;
     IBusEngineDesc *desc;
     IBusEngineDesc *next_desc = NULL;
     GList *p;
 
     engine = bus_input_context_get_engine (context);
     if (engine == NULL) {
         _context_request_engine_cb (context, NULL, ibus);
         return;
@@ skipping 20 matching lines @@
             next_desc = (IBusEngineDesc *)ibus->register_engine_list->data;
         }
         else if (ibus->engine_list) {
             next_desc = (IBusEngineDesc *)ibus->engine_list->data;
         }
     }
 
     if (next_desc != NULL) {
         engine = bus_ibus_impl_create_engine (next_desc);
         if (engine != NULL) {
-            bus_input_context_set_engine (context, engine);
+            bus_ibus_impl_set_context_engine (ibus, context, engine);
         }
     }
 }
 
 static void
-_context_request_prev_engine_cb (BusInputContext *context,
-                                 BusIBusImpl     *ibus)
+bus_ibus_impl_context_request_previous_engine (BusIBusImpl     *ibus,
+                                               BusInputContext *context)
 {
+    gchar *engine_name = NULL;
+    if (!ibus->use_global_engine) {
+        engine_name = (gchar *) g_object_get_data (G_OBJECT (context), "previous-engine-name");
+    }
+    else {
+        if (!ibus->global_previous_engine_name) {
+            ibus->global_previous_engine_name = bus_ibus_impl_load_global_previous_engine_name_from_config (ibus);
+        }
+        engine_name = ibus->global_previous_engine_name;
+    }
 
+    _context_request_engine_cb (context, engine_name, ibus);
 }
 
 static void
 _global_engine_destroy_cb (BusEngineProxy *engine,
                            BusIBusImpl    *ibus)
 {
     if (ibus->global_engine != engine) {
         return;
     }
 
     g_signal_handlers_disconnect_by_func (ibus->global_engine,
                 G_CALLBACK (_global_engine_destroy_cb), ibus);
     g_object_unref (ibus->global_engine);
     ibus->global_engine = NULL;
 }
 
 static void
 bus_ibus_impl_set_global_engine (BusIBusImpl    *ibus,
                                  BusEngineProxy *engine)
 {
     g_assert (ibus->use_global_engine == TRUE);
 
     if (ibus->global_engine == engine) {
         return;
     }
 
+    g_free (ibus->global_previous_engine_name);
+    ibus->global_previous_engine_name = NULL;
     if (ibus->global_engine) {
+        /* Save the current global engine's name as previous engine. */
+        ibus->global_previous_engine_name = g_strdup (bus_engine_proxy_get_desc (ibus->global_engine)->name);
+
         ibus_object_destroy ((IBusObject *)ibus->global_engine);
         /* global_engine should be NULL */
         g_assert (ibus->global_engine == NULL);
     }
 
     if (engine != NULL && !IBUS_OBJECT_DESTROYED (engine)) {
         g_object_ref (engine);
         ibus->global_engine = engine;
         g_signal_connect (ibus->global_engine, "destroy",
                 G_CALLBACK (_global_engine_destroy_cb), ibus);
     }
+
+    bus_ibus_impl_save_global_engine_name_to_config (ibus);
+    bus_ibus_impl_save_global_previous_engine_name_to_config (ibus);
 }
 
 static void
+bus_ibus_impl_set_context_engine (BusIBusImpl     *ibus,
+                                  BusInputContext *context,
+                                  BusEngineProxy  *engine) {
+  g_object_set_data (G_OBJECT (context), "previous-engine-name", NULL);
+
+  /* If use_global_engine is disabled, then we need to save the previous engine
+   * of each input context. */
+  if (!ibus->use_global_engine) {
+      BusEngineProxy *previous_engine = bus_input_context_get_engine (context);
+      if (previous_engine) {
+          g_object_set_data_full (G_OBJECT (context), "previous-engine-name",
+                                  g_strdup (bus_engine_proxy_get_desc (previous_engine)->name),
+                                  g_free);
+      }
+  }
+
+  bus_input_context_set_engine (context, engine);
+}
+
+static void
 _context_engine_changed_cb (BusInputContext *context,
                             BusIBusImpl     *ibus)
 {
     BusEngineProxy *engine;
 
-    if (context != ibus->focused_context ||
-        ibus->use_global_engine != TRUE) {
+    if (context != ibus->focused_context || !ibus->use_global_engine) {
         return;
     }
 
     engine = bus_input_context_get_engine (context);
     if (engine != NULL) {
         /* only set global engine if engine is not NULL */
         bus_ibus_impl_set_global_engine (ibus, engine);
     }
 }
 
@@ skipping 17 matching lines @@
 
     ibus->focused_context = NULL;
 
     if (ibus->panel != NULL) {
         bus_panel_proxy_focus_out (ibus->panel, context);
     }
 
     /* If the use_global_engine option is enabled,
      * the global engine shoule be detached from the focused context. */
     if (ibus->use_global_engine) {
-        bus_input_context_set_engine (context, NULL);
+        bus_ibus_impl_set_context_engine (ibus, context, NULL);
     }
 
     g_object_unref (context);
 }
 
 static void
 _context_focus_in_cb (BusInputContext *context,
                       BusIBusImpl     *ibus)
 {
     g_assert (BUS_IS_IBUS_IMPL (ibus));
@@ skipping 15 matching lines @@
         bus_input_context_focus_out (ibus->focused_context);
         g_assert (ibus->focused_context == NULL);
     }
 
     /* If the use_global_engine option is enabled, then we need:
      * - Switch the context to use the global engine or save the context's
      *   existing engine as global engine.
      * - Set the context's enabled state according to the saved state.
      * Note: we get this signal only if the context supports IBUS_CAP_FOCUS. */
     if (ibus->use_global_engine) {
-        bus_input_context_set_engine (context, ibus->global_engine);
-        if (ibus->global_engine &&
-            bus_engine_proxy_is_enabled (ibus->global_engine)) {
-            bus_input_context_enable (context);
+        if (!ibus->global_engine) {
+            bus_ibus_impl_set_global_engine (ibus, bus_input_context_get_engine (context));
+        }
+        else {
+            bus_ibus_impl_set_context_engine (ibus, context, ibus->global_engine);
+            if (ibus->global_engine && bus_engine_proxy_is_enabled (ibus->global_engine)) {
+                bus_input_context_enable (context);
+            }
         }
     }
 
     if (ibus->panel != NULL) {
         bus_panel_proxy_focus_in (ibus->panel, context);
     }
 
     g_object_ref (context);
     ibus->focused_context = context;
 }
 
 static void
 _context_destroy_cb (BusInputContext    *context,
                      BusIBusImpl        *ibus)
 {
     g_assert (BUS_IS_IBUS_IMPL (ibus));
     g_assert (BUS_IS_INPUT_CONTEXT (context));
 
     if (context == ibus->focused_context) {
         /* focus out context */
         bus_input_context_focus_out (ibus->focused_context);
         g_assert (ibus->focused_context == NULL);
     }
 
     ibus->contexts = g_list_remove (ibus->contexts, context);
     g_object_unref (context);
 }
 
-#if 0
-static void
-_context_enabled_cb (BusInputContext    *context,
-                     BusIBusImpl        *ibus)
-{
-}
-
-static void
-_context_disabled_cb (BusInputContext    *context,
-                      BusIBusImpl        *ibus)
-{
-}
-#endif
-
 static IBusMessage *
 _ibus_create_input_context (BusIBusImpl     *ibus,
                             IBusMessage     *message,
                             BusConnection   *connection)
 {
     g_assert (BUS_IS_IBUS_IMPL (ibus));
     g_assert (message != NULL);
     g_assert (BUS_IS_CONNECTION (connection));
 
     gint i;
@@ skipping 16 matching lines @@
 
     context = bus_input_context_new (connection, client);
     g_object_ref_sink (context);
     ibus->contexts = g_list_append (ibus->contexts, context);
 
     static const struct {
         gchar *name;
         GCallback callback;
     } signals [] = {
         { "request-engine",      G_CALLBACK (_context_request_engine_cb) },
-        { "request-next-engine", G_CALLBACK (_context_request_next_engine_cb) },
-        { "request-prev-engine", G_CALLBACK (_context_request_prev_engine_cb) },
         { "engine-changed", G_CALLBACK (_context_engine_changed_cb) },
         { "focus-in",       G_CALLBACK (_context_focus_in_cb) },
         { "focus-out",      G_CALLBACK (_context_focus_out_cb) },
         { "destroy",        G_CALLBACK (_context_destroy_cb) },
-    #if 0
-        { "enabled",        G_CALLBACK (_context_enabled_cb) },
-        { "disabled",       G_CALLBACK (_context_disabled_cb) },
-    #endif
     };
 
     for (i = 0; i < G_N_ELEMENTS (signals); i++) {
         g_signal_connect (context,
                           signals[i].name,
                           signals[i].callback,
                           ibus);
     }
 
+    if (ibus->enable_by_default) {
+        bus_input_context_enable (context);
+    }
+
     path = ibus_service_get_path ((IBusService *) context);
     reply = ibus_message_new_method_return (message);
     ibus_message_append_args (reply,
                               IBUS_TYPE_OBJECT_PATH, &path,
                               G_TYPE_INVALID);
 
     bus_dbus_impl_register_object (BUS_DEFAULT_DBUS,
                                    (IBusService *)context);
     return reply;
 }
@@ skipping 235 matching lines @@
     reply = ibus_message_new_method_return (message);
 
     ibus_message_iter_init (message, &src);
     ibus_message_iter_init_append (reply, &dst);
 
     ibus_message_iter_copy_data (&dst, &src);
 
     return reply;
 }
 
+static IBusMessage *
+_ibus_get_use_sys_layout (BusIBusImpl     *ibus,
+                          IBusMessage     *message,
+                          BusConnection   *connection)
+{
+    IBusMessage *reply;
+    IBusMessageIter src, dst;
+
+    reply = ibus_message_new_method_return (message);
+    ibus_message_append_args (reply,
+            G_TYPE_BOOLEAN, &ibus->use_sys_layout,
+            G_TYPE_INVALID);
+
+    return reply;
+}
+
 static gboolean
 bus_ibus_impl_ibus_message (BusIBusImpl     *ibus,
                             BusConnection   *connection,
                             IBusMessage     *message)
 {
     g_assert (BUS_IS_IBUS_IMPL (ibus));
     g_assert (BUS_IS_CONNECTION (connection));
     g_assert (message != NULL);
 
     gint i;
     IBusMessage *reply_message = NULL;
 
     static const struct {
         const gchar *interface;
         const gchar *name;
         IBusMessage *(* handler) (BusIBusImpl *, IBusMessage *, BusConnection *);
     } handlers[] =  {
         /* Introspectable interface */
         { DBUS_INTERFACE_INTROSPECTABLE,
                                "Introspect",            _ibus_introspect },
         /* IBus interface */
         { IBUS_INTERFACE_IBUS, "GetAddress",            _ibus_get_address },
         { IBUS_INTERFACE_IBUS, "CreateInputContext",    _ibus_create_input_context },
         { IBUS_INTERFACE_IBUS, "CurrentInputContext",   _ibus_current_input_context },
         { IBUS_INTERFACE_IBUS, "RegisterComponent",     _ibus_register_component },
         { IBUS_INTERFACE_IBUS, "ListEngines",           _ibus_list_engines },
         { IBUS_INTERFACE_IBUS, "ListActiveEngines",     _ibus_list_active_engines },
         { IBUS_INTERFACE_IBUS, "Exit",                  _ibus_exit },
         { IBUS_INTERFACE_IBUS, "Ping",                  _ibus_ping },
+        { IBUS_INTERFACE_IBUS, "GetUseSysLayout",       _ibus_get_use_sys_layout },
     };
 
     ibus_message_set_sender (message, bus_connection_get_unique_name (connection));
     ibus_message_set_destination (message, DBUS_SERVICE_DBUS);
 
     if (ibus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL) {
         for (i = 0; i < G_N_ELEMENTS (handlers); i++) {
             if (ibus_message_is_method_call (message,
                                              handlers[i].interface,
                                              handlers[i].name)) {
@@ skipping 72 matching lines @@
                                        "RegistryChanged");
     ibus_message_append_args (message,
                               G_TYPE_INVALID);
     ibus_message_set_sender (message, IBUS_SERVICE_IBUS);
 
     bus_dbus_impl_dispatch_message_by_rule (BUS_DEFAULT_DBUS, message, NULL);
 
     ibus_message_unref (message);
 
 }
+
+
+gboolean
+bus_ibus_impl_filter_keyboard_shortcuts (BusIBusImpl     *ibus,
+                                         BusInputContext *context,
+                                         guint           keyval,
+                                         guint           modifiers,
+                                         guint           prev_keyval,
+                                         guint           prev_modifiers)
+{
+    static GQuark trigger = 0;
+    static GQuark next = 0;
+    static GQuark previous = 0;
+
+    if (trigger == 0) {
+        trigger = g_quark_from_static_string ("trigger");
+        next = g_quark_from_static_string ("next-engine-in-menu");
+        previous = g_quark_from_static_string ("previous-engine");
+    }
+
+    GQuark event = ibus_hotkey_profile_filter_key_event (ibus->hotkey_profile,
+                                                         keyval,
+                                                         modifiers,
+                                                         prev_keyval,
+                                                         prev_modifiers,
+                                                         0);
+
+    if (event == trigger) {
+        gboolean enabled = bus_input_context_is_enabled (context);
+
+        if (context->enabled) {
+            bus_input_context_disable (context);
+        }
+        else {
+            bus_input_context_enable (context);
+        }
+
+        return (enabled != bus_input_context_is_enabled (context));
+    }
+    if (event == next) {
+        bus_ibus_impl_context_request_next_engine_in_menu (ibus, context);
+        return TRUE;
+    }
+    if (event == previous) {
+        bus_ibus_impl_context_request_previous_engine (ibus, context);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static gchar*
+bus_ibus_impl_load_global_engine_name_from_config (BusIBusImpl *ibus)
+{
+    GValue value = { 0 };
+    gchar *global_engine_name = NULL;
+
+    g_assert (IBUS_IS_CONFIG (ibus->config));
+
+    if (ibus_config_get_value (ibus->config, "general", "global_engine", &value) &&
+        G_VALUE_TYPE (&value) == G_TYPE_STRING) {
+        global_engine_name = g_value_dup_string (&value);
+        g_value_unset (&value);
+    }
+
+    return global_engine_name;
+}
+
+static void
+bus_ibus_impl_save_global_engine_name_to_config (BusIBusImpl *ibus)
+{
+    g_assert (IBUS_IS_CONFIG (ibus->config));
+
+    if (ibus->use_global_engine && ibus->global_engine) {
+        GValue value = { 0 };
+        g_value_init (&value, G_TYPE_STRING);
+        g_value_set_static_string (&value, bus_engine_proxy_get_desc (ibus->global_engine)->name);
+
+        ibus_config_set_value (ibus->config, "general", "global_engine", &value);
+        g_value_unset (&value);
+    }
+}
+
+static gchar*
+bus_ibus_impl_load_global_previous_engine_name_from_config (BusIBusImpl *ibus)
+{
+    GValue value = { 0 };
+    gchar *global_previous_engine_name = NULL;
+
+    g_assert (IBUS_IS_CONFIG (ibus->config));
+
+    if (ibus_config_get_value (ibus->config, "general", "global_previous_engine", &value) &&
+        G_VALUE_TYPE (&value) == G_TYPE_STRING) {
+        global_previous_engine_name = g_value_dup_string (&value);
+        g_value_unset (&value);
+    }
+
+    return global_previous_engine_name;
+}
+
+static void
+bus_ibus_impl_save_global_previous_engine_name_to_config (BusIBusImpl *ibus)
+{
+    g_assert (IBUS_IS_CONFIG (ibus->config));
+
+    if (ibus->use_global_engine && ibus->global_previous_engine_name) {
+        GValue value = { 0 };
+        g_value_init (&value, G_TYPE_STRING);
+        g_value_set_static_string (&value, ibus->global_previous_engine_name);
+
+        ibus_config_set_value (ibus->config, "general", "global_previous_engine", &value);
+        g_value_unset (&value);
+    }
+}