/* GTK - The GIMP Toolkit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ #include "config.h" #include #include #include #include #include #include #include "gtkimmodule.h" #include "gtkimcontextsimple.h" #include "gtksettings.h" #include "gtkmain.h" #include "gtkrc.h" #include "gtkintl.h" #include "gtkalias.h" /* Do *not* include "gtkprivate.h" in this file. If you do, the * correct_libdir_prefix() and correct_localedir_prefix() functions * below will have to move somewhere else. */ #ifdef __GTK_PRIVATE_H__ #error gtkprivate.h should not be included in this file #endif #define SIMPLE_ID "gtk-im-context-simple" /** * GtkIMContextInfo: * @context_id: The unique identification string of the input method. * @context_name: The human-readable name of the input method. * @domain: Translation domain to be used with dgettext() * @domain_dirname: Name of locale directory for use with bindtextdomain() * @default_locales: A colon-separated list of locales where this input method * should be the default. The asterisk "*" sets the default for all locales. * * Bookkeeping information about a loadable input method. */ typedef struct _GtkIMModule GtkIMModule; typedef struct _GtkIMModuleClass GtkIMModuleClass; #define GTK_TYPE_IM_MODULE (gtk_im_module_get_type ()) #define GTK_IM_MODULE(im_module) (G_TYPE_CHECK_INSTANCE_CAST ((im_module), GTK_TYPE_IM_MODULE, GtkIMModule)) #define GTK_IS_IM_MODULE(im_module) (G_TYPE_CHECK_INSTANCE_TYPE ((im_module), GTK_TYPE_IM_MODULE)) struct _GtkIMModule { GTypeModule parent_instance; gboolean builtin; GModule *library; void (*list) (const GtkIMContextInfo ***contexts, guint *n_contexts); void (*init) (GTypeModule *module); void (*exit) (void); GtkIMContext *(*create) (const gchar *context_id); GtkIMContextInfo **contexts; guint n_contexts; gchar *path; }; struct _GtkIMModuleClass { GTypeModuleClass parent_class; }; static GType gtk_im_module_get_type (void); static gint n_loaded_contexts = 0; static GHashTable *contexts_hash = NULL; static GSList *modules_list = NULL; static GObjectClass *parent_class = NULL; static gboolean gtk_im_module_load (GTypeModule *module) { GtkIMModule *im_module = GTK_IM_MODULE (module); if (!im_module->builtin) { im_module->library = g_module_open (im_module->path, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL); if (!im_module->library) { g_warning ("%s", g_module_error()); return FALSE; } /* extract symbols from the lib */ if (!g_module_symbol (im_module->library, "im_module_init", (gpointer *)&im_module->init) || !g_module_symbol (im_module->library, "im_module_exit", (gpointer *)&im_module->exit) || !g_module_symbol (im_module->library, "im_module_list", (gpointer *)&im_module->list) || !g_module_symbol (im_module->library, "im_module_create", (gpointer *)&im_module->create)) { g_warning ("%s", g_module_error()); g_module_close (im_module->library); return FALSE; } } /* call the module's init function to let it */ /* setup anything it needs to set up. */ im_module->init (module); return TRUE; } static void gtk_im_module_unload (GTypeModule *module) { GtkIMModule *im_module = GTK_IM_MODULE (module); im_module->exit(); if (!im_module->builtin) { g_module_close (im_module->library); im_module->library = NULL; im_module->init = NULL; im_module->exit = NULL; im_module->list = NULL; im_module->create = NULL; } } /* This only will ever be called if an error occurs during * initialization */ static void gtk_im_module_finalize (GObject *object) { GtkIMModule *module = GTK_IM_MODULE (object); g_free (module->path); parent_class->finalize (object); } G_DEFINE_TYPE (GtkIMModule, gtk_im_module, G_TYPE_TYPE_MODULE) static void gtk_im_module_class_init (GtkIMModuleClass *class) { GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (class); GObjectClass *gobject_class = G_OBJECT_CLASS (class); parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (class)); module_class->load = gtk_im_module_load; module_class->unload = gtk_im_module_unload; gobject_class->finalize = gtk_im_module_finalize; } static void gtk_im_module_init (GtkIMModule* object) { } static void free_info (GtkIMContextInfo *info) { g_free ((char *)info->context_id); g_free ((char *)info->context_name); g_free ((char *)info->domain); g_free ((char *)info->domain_dirname); g_free ((char *)info->default_locales); g_free (info); } static void add_module (GtkIMModule *module, GSList *infos) { GSList *tmp_list = infos; gint i = 0; gint n = g_slist_length (infos); module->contexts = g_new (GtkIMContextInfo *, n); while (tmp_list) { GtkIMContextInfo *info = tmp_list->data; if (g_hash_table_lookup (contexts_hash, info->context_id)) { free_info (info); /* Duplicate */ } else { g_hash_table_insert (contexts_hash, (char *)info->context_id, module); module->contexts[i++] = tmp_list->data; n_loaded_contexts++; } tmp_list = tmp_list->next; } g_slist_free (infos); module->n_contexts = i; modules_list = g_slist_prepend (modules_list, module); } #ifdef G_OS_WIN32 static void correct_libdir_prefix (gchar **path) { /* GTK_LIBDIR here is supposed to still have the definition from * Makefile.am, i.e. the build-time value. Do *not* include gtkprivate.h * in this file. */ if (strncmp (*path, GTK_LIBDIR, strlen (GTK_LIBDIR)) == 0) { /* This is an entry put there by make install on the * packager's system. On Windows a prebuilt GTK+ * package can be installed in a random * location. The gtk.immodules file distributed in * such a package contains paths from the package * builder's machine. Replace the path with the real * one on this machine. */ extern const gchar *_gtk_get_libdir (); gchar *tem = *path; *path = g_strconcat (_gtk_get_libdir (), tem + strlen (GTK_LIBDIR), NULL); g_free (tem); } } static void correct_localedir_prefix (gchar **path) { /* As above, but for GTK_LOCALEDIR. Use separate function in case * GTK_LOCALEDIR isn't a subfolder of GTK_LIBDIR. */ if (strncmp (*path, GTK_LOCALEDIR, strlen (GTK_LOCALEDIR)) == 0) { extern const gchar *_gtk_get_localedir (); gchar *tem = *path; *path = g_strconcat (_gtk_get_localedir (), tem + strlen (GTK_LOCALEDIR), NULL); g_free (tem); } } #endif G_GNUC_UNUSED static GtkIMModule * add_builtin_module (const gchar *module_name, const GtkIMContextInfo **contexts, int n_contexts) { GtkIMModule *module = g_object_new (GTK_TYPE_IM_MODULE, NULL); GSList *infos = NULL; int i; for (i = 0; i < n_contexts; i++) { GtkIMContextInfo *info = g_new (GtkIMContextInfo, 1); info->context_id = g_strdup (contexts[i]->context_id); info->context_name = g_strdup (contexts[i]->context_name); info->domain = g_strdup (contexts[i]->domain); info->domain_dirname = g_strdup (contexts[i]->domain_dirname); #ifdef G_OS_WIN32 correct_localedir_prefix ((char **) &info->domain_dirname); #endif info->default_locales = g_strdup (contexts[i]->default_locales); infos = g_slist_prepend (infos, info); } module->builtin = TRUE; g_type_module_set_name (G_TYPE_MODULE (module), module_name); add_module (module, infos); return module; } static void gtk_im_module_initialize (void) { GString *line_buf = g_string_new (NULL); GString *tmp_buf = g_string_new (NULL); gchar *filename = gtk_rc_get_im_module_file(); FILE *file; gboolean have_error = FALSE; GtkIMModule *module = NULL; GSList *infos = NULL; contexts_hash = g_hash_table_new (g_str_hash, g_str_equal); #define do_builtin(m) \ { \ const GtkIMContextInfo **contexts; \ int n_contexts; \ extern void _gtk_immodule_ ## m ## _list (const GtkIMContextInfo ***contexts, \ guint *n_contexts); \ extern void _gtk_immodule_ ## m ## _init (GTypeModule *module); \ extern void _gtk_immodule_ ## m ## _exit (void); \ extern GtkIMContext *_gtk_immodule_ ## m ## _create (const gchar *context_id); \ \ _gtk_immodule_ ## m ## _list (&contexts, &n_contexts); \ module = add_builtin_module (#m, contexts, n_contexts); \ module->init = _gtk_immodule_ ## m ## _init; \ module->exit = _gtk_immodule_ ## m ## _exit; \ module->create = _gtk_immodule_ ## m ## _create; \ module = NULL; \ } #ifdef INCLUDE_IM_am_et do_builtin (am_et); #endif #ifdef INCLUDE_IM_cedilla do_builtin (cedilla); #endif #ifdef INCLUDE_IM_cyrillic_translit do_builtin (cyrillic_translit); #endif #ifdef INCLUDE_IM_ime do_builtin (ime); #endif #ifdef INCLUDE_IM_inuktitut do_builtin (inuktitut); #endif #ifdef INCLUDE_IM_ipa do_builtin (ipa); #endif #ifdef INCLUDE_IM_multipress do_builtin (multipress); #endif #ifdef INCLUDE_IM_thai do_builtin (thai); #endif #ifdef INCLUDE_IM_ti_er do_builtin (ti_er); #endif #ifdef INCLUDE_IM_ti_et do_builtin (ti_et); #endif #ifdef INCLUDE_IM_viqr do_builtin (viqr); #endif #ifdef INCLUDE_IM_xim do_builtin (xim); #endif #undef do_builtin file = g_fopen (filename, "r"); if (!file) { /* In case someone wants only the default input method, * we allow no file at all. */ g_string_free (line_buf, TRUE); g_string_free (tmp_buf, TRUE); g_free (filename); return; } while (!have_error && pango_read_line (file, line_buf)) { const char *p; p = line_buf->str; if (!pango_skip_space (&p)) { /* Blank line marking the end of a module */ if (module && *p != '#') { add_module (module, infos); module = NULL; infos = NULL; } continue; } if (!module) { /* Read a module location */ module = g_object_new (GTK_TYPE_IM_MODULE, NULL); if (!pango_scan_string (&p, tmp_buf) || pango_skip_space (&p)) { g_warning ("Error parsing context info in '%s'\n %s", filename, line_buf->str); have_error = TRUE; } module->path = g_strdup (tmp_buf->str); #ifdef G_OS_WIN32 correct_libdir_prefix (&module->path); #endif g_type_module_set_name (G_TYPE_MODULE (module), module->path); } else { GtkIMContextInfo *info = g_new0 (GtkIMContextInfo, 1); /* Read information about a context type */ if (!pango_scan_string (&p, tmp_buf)) goto context_error; info->context_id = g_strdup (tmp_buf->str); if (!pango_scan_string (&p, tmp_buf)) goto context_error; info->context_name = g_strdup (tmp_buf->str); if (!pango_scan_string (&p, tmp_buf)) goto context_error; info->domain = g_strdup (tmp_buf->str); if (!pango_scan_string (&p, tmp_buf)) goto context_error; info->domain_dirname = g_strdup (tmp_buf->str); #ifdef G_OS_WIN32 correct_localedir_prefix ((char **) &info->domain_dirname); #endif if (!pango_scan_string (&p, tmp_buf)) goto context_error; info->default_locales = g_strdup (tmp_buf->str); if (pango_skip_space (&p)) goto context_error; infos = g_slist_prepend (infos, info); continue; context_error: g_warning ("Error parsing context info in '%s'\n %s", filename, line_buf->str); have_error = TRUE; } } if (have_error) { GSList *tmp_list = infos; while (tmp_list) { free_info (tmp_list->data); tmp_list = tmp_list->next; } g_slist_free (infos); g_object_unref (module); } else if (module) add_module (module, infos); fclose (file); g_string_free (line_buf, TRUE); g_string_free (tmp_buf, TRUE); g_free (filename); } static gint compare_gtkimcontextinfo_name(const GtkIMContextInfo **a, const GtkIMContextInfo **b) { return g_utf8_collate ((*a)->context_name, (*b)->context_name); } /** * _gtk_im_module_list: * @contexts: location to store an array of pointers to #GtkIMContextInfo * this array should be freed with g_free() when you are finished. * The structures it points are statically allocated and should * not be modified or freed. * @n_contexts: the length of the array stored in @contexts * * List all available types of input method context */ void _gtk_im_module_list (const GtkIMContextInfo ***contexts, guint *n_contexts) { int n = 0; static #ifndef G_OS_WIN32 const #endif GtkIMContextInfo simple_context_info = { SIMPLE_ID, N_("Simple"), GETTEXT_PACKAGE, #ifdef GTK_LOCALEDIR GTK_LOCALEDIR, #else "", #endif "" }; #ifdef G_OS_WIN32 static gboolean beenhere = FALSE; #endif if (!contexts_hash) gtk_im_module_initialize (); #ifdef G_OS_WIN32 if (!beenhere) { beenhere = TRUE; /* correct_localedir_prefix() requires its parameter to be a * malloced string */ simple_context_info.domain_dirname = g_strdup (simple_context_info.domain_dirname); correct_localedir_prefix ((char **) &simple_context_info.domain_dirname); } #endif if (n_contexts) *n_contexts = (n_loaded_contexts + 1); if (contexts) { GSList *tmp_list; int i; *contexts = g_new (const GtkIMContextInfo *, n_loaded_contexts + 1); (*contexts)[n++] = &simple_context_info; tmp_list = modules_list; while (tmp_list) { GtkIMModule *module = tmp_list->data; for (i=0; in_contexts; i++) (*contexts)[n++] = module->contexts[i]; tmp_list = tmp_list->next; } /* fisrt element (Default) should always be at top */ qsort ((*contexts)+1, n-1, sizeof (GtkIMContextInfo *), (GCompareFunc)compare_gtkimcontextinfo_name); } } /** * _gtk_im_module_create: * @context_id: the context ID for the context type to create * * Create an IM context of a type specified by the string * ID @context_id. * * Return value: a newly created input context of or @context_id, or * if that could not be created, a newly created GtkIMContextSimple. */ GtkIMContext * _gtk_im_module_create (const gchar *context_id) { GtkIMModule *im_module; GtkIMContext *context = NULL; if (!contexts_hash) gtk_im_module_initialize (); if (strcmp (context_id, SIMPLE_ID) != 0) { im_module = g_hash_table_lookup (contexts_hash, context_id); if (!im_module) { g_warning ("Attempt to load unknown IM context type '%s'", context_id); } else { if (g_type_module_use (G_TYPE_MODULE (im_module))) { context = im_module->create (context_id); g_type_module_unuse (G_TYPE_MODULE (im_module)); } if (!context) g_warning ("Loading IM context type '%s' failed", context_id); } } if (!context) return gtk_im_context_simple_new (); else return context; } /* Match @locale against @against. * * 'en_US' against 'en_US' => 4 * 'en_US' against 'en' => 3 * 'en', 'en_UK' against 'en_US' => 2 * all locales, against '*' => 1 */ static gint match_locale (const gchar *locale, const gchar *against, gint against_len) { if (strcmp (against, "*") == 0) return 1; if (g_ascii_strcasecmp (locale, against) == 0) return 4; if (g_ascii_strncasecmp (locale, against, 2) == 0) return (against_len == 2) ? 3 : 2; return 0; } /** * _gtk_im_module_get_default_context_id: * @client_window: a window * * Return the context_id of the best IM context type * for the given window. * * Return value: the context ID (will never be %NULL) */ const gchar * _gtk_im_module_get_default_context_id (GdkWindow *client_window) { GSList *tmp_list; const gchar *context_id = NULL; gint best_goodness = 0; gint i; gchar *tmp_locale, *tmp; const gchar *envvar; GdkScreen *screen; GtkSettings *settings; if (!contexts_hash) gtk_im_module_initialize (); envvar = g_getenv ("GTK_IM_MODULE"); if (envvar && (strcmp (envvar, SIMPLE_ID) == 0 || g_hash_table_lookup (contexts_hash, envvar))) return envvar; /* Check if the certain immodule is set in XSETTINGS. */ if (GDK_IS_DRAWABLE (client_window)) { screen = gdk_window_get_screen (client_window); settings = gtk_settings_get_for_screen (screen); g_object_get (G_OBJECT (settings), "gtk-im-module", &tmp, NULL); if (tmp) { if (strcmp (tmp, SIMPLE_ID) == 0) context_id = SIMPLE_ID; else { GtkIMModule *module; module = g_hash_table_lookup (contexts_hash, tmp); if (module) context_id = module->contexts[0]->context_id; } g_free (tmp); if (context_id) return context_id; } } /* Strip the locale code down to the essentials */ tmp_locale = _gtk_get_lc_ctype (); tmp = strchr (tmp_locale, '.'); if (tmp) *tmp = '\0'; tmp = strchr (tmp_locale, '@'); if (tmp) *tmp = '\0'; tmp_list = modules_list; while (tmp_list) { GtkIMModule *module = tmp_list->data; for (i = 0; i < module->n_contexts; i++) { const gchar *p = module->contexts[i]->default_locales; while (p) { const gchar *q = strchr (p, ':'); gint goodness = match_locale (tmp_locale, p, q ? q - p : strlen (p)); if (goodness > best_goodness) { context_id = module->contexts[i]->context_id; best_goodness = goodness; } p = q ? q + 1 : NULL; } } tmp_list = tmp_list->next; } g_free (tmp_locale); return context_id ? context_id : SIMPLE_ID; }