If the current engine is removed, then switch to another engine automatically.

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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
 
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <locale.h>
-#include <strings.h>
+#include <string.h>
 #include "ibusimpl.h"
 #include "dbusimpl.h"
 #include "server.h"
 #include "connection.h"
 #include "registry.h"
 #include "factoryproxy.h"
 #include "panelproxy.h"
 #include "inputcontext.h"
 #include "option.h"
 
@@ skipping 34 matching lines @@
                                                  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_set_global_engine_by_name
+                                                (BusIBusImpl        *ibus,
+                                                 const gchar        *name);
+static void     bus_ibus_impl_engines_maybe_removed
+                                                (BusIBusImpl        *ibus);
 
 static void     bus_ibus_impl_registry_changed  (BusIBusImpl        *ibus);
 static void     bus_ibus_impl_global_engine_changed
                                                 (BusIBusImpl        *ibus);
 
 static void     _factory_destroy_cb             (BusFactoryProxy    *factory,
                                                  BusIBusImpl        *ibus);
 
 static void     bus_ibus_impl_set_context_engine_from_desc
                                                 (BusIBusImpl        *ibus,
@@ skipping 158 matching lines @@
 
     if (ibus->engine_list) {
         IBusComponent *component;
 
         component = ibus_component_get_from_engine ((IBusEngineDesc *) ibus->engine_list->data);
         if (component && !ibus_component_is_running (component)) {
             ibus_component_start (component, g_verbose);
         }
     }
 
+    bus_ibus_impl_engines_maybe_removed (ibus);
     bus_ibus_impl_update_engines_hotkey_profile (ibus);
 }
 
 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);
     }
@@ skipping 574 matching lines @@
 
     g_object_ref (factory);
     engine = bus_factory_proxy_create_engine (factory, engine_desc);
     g_object_unref (factory);
 
     return engine;
 }
 
 static IBusEngineDesc *
 _find_engine_desc_by_name(BusIBusImpl *ibus,
-                          gchar *engine_name)
+                          const gchar *engine_name)
 {
     IBusEngineDesc *engine_desc = NULL;
     GList *p;
 
     /* find engine in registered engine list */
     for (p = ibus->register_engine_list; p != NULL; p = p->next) {
         engine_desc = (IBusEngineDesc *)p->data;
         if (g_strcmp0 (engine_desc->name, engine_name) == 0)
             return engine_desc;
     }
 
     /* find engine in preload engine list */
     for (p = ibus->engine_list; p != NULL; p = p->next) {
         engine_desc = (IBusEngineDesc *)p->data;
         if (g_strcmp0 (engine_desc->name, engine_name) == 0)
             return engine_desc;
     }
 
     return NULL;
 }
 
 static void
 _context_request_engine_cb (BusInputContext *context,
-                            gchar           *engine_name,
+                            const 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);
+                gchar *global_name = bus_ibus_impl_load_global_engine_name_from_config (ibus);
+                if (global_name) {
+                    engine_desc = _find_engine_desc_by_name (ibus, global_name);
+                    g_free (global_name);
                 }
             }
         }
-        /* request default engine */
-        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);
     }
 
+    /* request default engine */
+    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;
+        }
+    }
+
     bus_ibus_impl_set_context_engine_from_desc (ibus, context, engine_desc);
 }
 
 static void
 bus_ibus_impl_context_request_next_engine_in_menu (BusIBusImpl     *ibus,
                                                    BusInputContext *context)
 {
     BusEngineProxy *engine;
     IBusEngineDesc *desc;
     IBusEngineDesc *next_desc = NULL;
@@ skipping 100 matching lines @@
         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);
     bus_ibus_impl_global_engine_changed (ibus);
 }
 
 static void
+bus_ibus_impl_set_global_engine_by_name (BusIBusImpl *ibus,
+                                         const gchar *name)
+{
+    gchar *old_engine_name = NULL;
+
+    if (!ibus->use_global_engine)
+        return;
+
+    if (ibus->global_engine) {
+        old_engine_name = bus_engine_proxy_get_desc (ibus->global_engine)->name;
+    }
+
+    if (g_strcmp0 (name, old_engine_name) == 0) {
+        /* If the user requested the same global engine, then we just enable the
+         * original one. */
+        if (ibus->focused_context) {
+            bus_input_context_enable (ibus->focused_context);
+        }
+        else if (ibus->global_engine) {
+            bus_engine_proxy_enable (ibus->global_engine);
+        }
+        return;
+    }
+
+    /* If there is a focused input context, then we just change the engine of
+     * the focused context, which will then change the global engine
+     * automatically. Otherwise, we need to change the global engine directly.
+     */
+    if (ibus->focused_context) {
+        _context_request_engine_cb (ibus->focused_context, name, ibus);
+    }
+    else {
+        IBusEngineDesc *engine_desc = _find_engine_desc_by_name (ibus, name);
+        if (engine_desc != NULL) {
+            BusEngineProxy *new_engine = bus_ibus_impl_create_engine (engine_desc);
+            if (new_engine != NULL) {
+                /* Enable the global engine by default, because the user
+                 * selected it explicitly. */
+                bus_engine_proxy_enable (new_engine);
+
+                /* Assume the ownership of the new global engine. Normally it's
+                 * done by the input context. But as we need to change the global
+                 * engine directly, so we need to do it here. */
+                g_object_ref_sink (new_engine);
+                bus_ibus_impl_set_global_engine (ibus, new_engine);
+
+                /* The global engine should already be referenced. */
+                g_object_unref (new_engine);
+            }
+        }
+    }
+}
+
+static void
+bus_ibus_impl_engines_maybe_removed (BusIBusImpl *ibus)
+{
+    gchar *old_engine_name = NULL;

[satorux1, 2010/05/27 05:29:02]

const gchar * if possible?

+    GList *engine_list = NULL;
+
+    if (!ibus->use_global_engine || !ibus->global_engine)
+        return;
+
+    old_engine_name = bus_engine_proxy_get_desc (ibus->global_engine)->name;
+
+    /* The current global engine is not removed, so do nothing. */
+    if (_find_engine_desc_by_name (ibus, old_engine_name))
+        return;
+
+    /* If the previous engine is available, then just switch to it. */
+    if (ibus->global_previous_engine_name &&
+        _find_engine_desc_by_name (ibus, ibus->global_previous_engine_name)) {
+        bus_ibus_impl_set_global_engine_by_name (
+            ibus, ibus->global_previous_engine_name);
+        return;
+    }
+
+    /* Just choose one in the list. */
+    engine_list = ibus->register_engine_list;
+    if (!engine_list)
+        engine_list = ibus->engine_list;
+
+    if (engine_list) {
+        IBusEngineDesc *engine_desc = (IBusEngineDesc *)engine_list->data;
+        bus_ibus_impl_set_global_engine_by_name (ibus, engine_desc->name);
+        return;
+    }
+
+    /* No engine available? Just disable global engine. */
+    bus_ibus_impl_set_global_engine (ibus, NULL);
+}
+
+static void
 bus_ibus_impl_set_context_engine_from_desc (BusIBusImpl     *ibus,
                                             BusInputContext *context,
                                             IBusEngineDesc  *engine_desc)
 {
     if (engine_desc != NULL) {
         BusEngineProxy *engine = bus_ibus_impl_create_engine (engine_desc);
         if (engine != NULL) {
             bus_ibus_impl_set_context_engine (ibus, context, engine);
         }
     }
@@ skipping 266 matching lines @@
             if (g_list_find (ibus->register_engine_list, p->data)) {
                 ibus->register_engine_list = g_list_remove (ibus->register_engine_list, p->data);
                 g_object_unref (p->data);
             }
         }
         g_list_free (engines);
     }
 
     g_object_unref (factory);
 
+    bus_ibus_impl_engines_maybe_removed (ibus);
     bus_ibus_impl_update_engines_hotkey_profile (ibus);
 }
 
 static void
 bus_ibus_impl_add_factory (BusIBusImpl     *ibus,
                            BusFactoryProxy *factory)
 {
     g_assert (BUS_IS_IBUS_IMPL (ibus));
     g_assert (BUS_IS_FACTORY_PROXY (factory));
 
@@ skipping 240 matching lines @@
                                     "No global engine.");
     return reply;
 }
 
 static IBusMessage *
 _ibus_set_global_engine (BusIBusImpl     *ibus,
                          IBusMessage     *message,
                          BusConnection   *connection)
 {
     gboolean retval;
-    IBusMessage *reply;
     IBusError *error;
-    gchar *new_engine_name;
-    gchar *old_engine_name;
+    gchar *new_engine_name = NULL;
 
     if (!ibus->use_global_engine) {
-        reply = ibus_message_new_error (message, DBUS_ERROR_FAILED,
-                                        "Global engine feature is disable.");
-        return reply;
+        return ibus_message_new_error (message, DBUS_ERROR_FAILED,
+                                       "Global engine feature is disable.");
     }
 
     retval = ibus_message_get_args (message,
                                     &error,
                                     G_TYPE_STRING, &new_engine_name,
                                     G_TYPE_INVALID);
     if (!retval) {
-        reply = ibus_message_new_error (message,
-                                        error->name,
-                                        error->message);
+        IBusMessage *reply = ibus_message_new_error (message,
+                                                     error->name,
+                                                     error->message);
         ibus_error_free (error);
         return reply;
     }
 
-    reply = ibus_message_new_method_return (message);
-    old_engine_name = NULL;
-
-    if (ibus->global_engine) {
-        old_engine_name = bus_engine_proxy_get_desc (ibus->global_engine)->name;
+    if (!new_engine_name || !new_engine_name[0] ||
+        !_find_engine_desc_by_name (ibus, new_engine_name)) {
+        return ibus_message_new_error (message, DBUS_ERROR_FAILED,
+                                       "Invalid engine name.");
     }
 
-    if (g_strcmp0 (new_engine_name, old_engine_name) == 0) {
-        /* If the user requested the same global engine, then we just enable the
-         * original one. */
-        if (ibus->focused_context) {
-            bus_input_context_enable (ibus->focused_context);
-        }
-        else if (ibus->global_engine) {
-            bus_engine_proxy_enable (ibus->global_engine);
-        }
-        return reply;
-    }
+    bus_ibus_impl_set_global_engine_by_name (ibus, new_engine_name);
 
-    /* If there is a focused input context, then we just change the engine of
-     * the focused context, which will then change the global engine
-     * automatically. Otherwise, we need to change the global engine directly.
-     */
-    if (ibus->focused_context) {
-        _context_request_engine_cb (ibus->focused_context, new_engine_name, ibus);
-    }
-    else {
-        IBusEngineDesc *engine_desc = _find_engine_desc_by_name (ibus, new_engine_name);
-        if (engine_desc != NULL) {
-            BusEngineProxy *new_engine = bus_ibus_impl_create_engine (engine_desc);
-            if (new_engine != NULL) {
-                /* Enable the global engine by default, because the user
-                 * selected it explicitly. */
-                bus_engine_proxy_enable (new_engine);
-
-                /* Assume the ownership of the new global engine. Normally it's
-                 * done by the input context. But as we need to change the global
-                 * engine directly, so we need to do it here. */
-                g_object_ref_sink (new_engine);
-                bus_ibus_impl_set_global_engine (ibus, new_engine);
-
-                /* The global engine should already be referenced. */
-                g_object_unref (new_engine);
-            }
-        }
-    }
-
-    return reply;
+    return ibus_message_new_method_return (message);
 }
 
 static IBusMessage *
 _ibus_is_global_engine_enabled (BusIBusImpl     *ibus,
                                 IBusMessage     *message,
                                 BusConnection   *connection)
 {
     IBusMessage *reply;
     gboolean enabled = (ibus->use_global_engine && ibus->global_engine &&
                         bus_engine_proxy_is_enabled (ibus->global_engine));
@@ skipping 383 matching lines @@
         g_hash_table_unref (ibus->hotkey_to_engines_map);
     }
 
     ibus->engines_hotkey_profile = ibus_hotkey_profile_new();
     ibus->hotkey_to_engines_map =
         g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_list_free);
 
     g_list_foreach (ibus->register_engine_list, (GFunc) _add_engine_hotkey, ibus);
     g_list_foreach (ibus->engine_list, (GFunc) _add_engine_hotkey, ibus);
 }