* Boston, MA 02111-1307, USA.
*/
+#include <config.h>
#include "locale.h"
#include <string.h>
+#include <stdlib.h>
+#include "gtk/gtkintl.h"
+#include "gtk/gtklabel.h"
#include "gtk/gtksignal.h"
+#include "gtk/gtkwindow.h"
#include "gtkimcontextxim.h"
+typedef struct _StatusWindow StatusWindow;
+typedef struct _GtkXIMInfo GtkXIMInfo;
+
+struct _GtkIMContextXIM
+{
+ GtkIMContext object;
+
+ GtkXIMInfo *im_info;
+
+ gchar *locale;
+ gchar *mb_charset;
+
+ GdkWindow *client_window;
+ GtkWidget *client_widget;
+
+ /* The status window for this input context; we claim the
+ * status window when we are focused and have created an XIC
+ */
+ StatusWindow *status_window;
+
+ gint preedit_size;
+ gint preedit_length;
+ gunichar *preedit_chars;
+ XIMFeedback *feedbacks;
+
+ gint preedit_cursor;
+
+ XIMCallback preedit_start_callback;
+ XIMCallback preedit_done_callback;
+ XIMCallback preedit_draw_callback;
+ XIMCallback preedit_caret_callback;
+
+ XIMCallback status_start_callback;
+ XIMCallback status_done_callback;
+ XIMCallback status_draw_callback;
+
+ XIMCallback string_conversion_callback;
+
+ XIC ic;
+
+ guint filter_key_release : 1;
+ guint use_preedit : 1;
+ guint finalizing : 1;
+ guint in_toplevel : 1;
+ guint has_focus : 1;
+};
+
struct _GtkXIMInfo
{
+ GdkScreen *screen;
XIM im;
char *locale;
+ XIMStyle preedit_style_setting;
+ XIMStyle status_style_setting;
XIMStyle style;
+ GtkSettings *settings;
+ gulong status_set;
+ gulong preedit_set;
+ XIMStyles *xim_styles;
+ GSList *ics;
+
+ guint reconnecting :1;
+ guint supports_string_conversion;
+};
+
+/* A context status window; these are kept in the status_windows list. */
+struct _StatusWindow
+{
+ GtkWidget *window;
+
+ /* Toplevel window to which the status window corresponds */
+ GtkWidget *toplevel;
+
+ /* Currently focused GtkIMContextXIM for the toplevel, if any */
+ GtkIMContextXIM *context;
};
static void gtk_im_context_xim_class_init (GtkIMContextXIMClass *class);
static void gtk_im_context_xim_focus_out (GtkIMContext *context);
static void gtk_im_context_xim_set_cursor_location (GtkIMContext *context,
GdkRectangle *area);
+static void gtk_im_context_xim_set_use_preedit (GtkIMContext *context,
+ gboolean use_preedit);
static void gtk_im_context_xim_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
gint *cursor_pos);
+static void reinitialize_ic (GtkIMContextXIM *context_xim);
+static void set_ic_client_window (GtkIMContextXIM *context_xim,
+ GdkWindow *client_window);
+
+static void setup_styles (GtkXIMInfo *info);
+
+static void update_client_widget (GtkIMContextXIM *context_xim);
+static void update_status_window (GtkIMContextXIM *context_xim);
+
+static StatusWindow *status_window_get (GtkWidget *toplevel);
+static void status_window_free (StatusWindow *status_window);
+static void status_window_set_text (StatusWindow *status_window,
+ const gchar *text);
+
+static void xim_destroy_callback (XIM xim,
+ XPointer client_data,
+ XPointer call_data);
+
static XIC gtk_im_context_xim_get_ic (GtkIMContextXIM *context_xim);
static GObjectClass *parent_class;
static GSList *open_ims = NULL;
+/* List of status windows for different toplevels */
+static GSList *status_windows = NULL;
+
void
gtk_im_context_xim_register_type (GTypeModule *type_module)
{
NULL, /* class_data */
sizeof (GtkIMContextXIM),
0,
- (GtkObjectInitFunc) gtk_im_context_xim_init,
+ (GInstanceInitFunc) gtk_im_context_xim_init,
};
gtk_type_im_context_xim =
return (s1 == XIMPreeditArea) ? style1 : style2;
else if (u & XIMPreeditNothing)
return (s1 == XIMPreeditNothing) ? style1 : style2;
+ else if (u & XIMPreeditNone)
+ return (s1 == XIMPreeditNone) ? style1 : style2;
} else {
s1 = style1 & STATUS_MASK;
s2 = style2 & STATUS_MASK;
}
static void
-setup_im (GtkXIMInfo *info)
+reinitialize_all_ics (GtkXIMInfo *info)
{
- XIMStyles *xim_styles = NULL;
- XIMValuesList *ic_values = NULL;
- int i;
+ GSList *tmp_list;
+
+ for (tmp_list = info->ics; tmp_list; tmp_list = tmp_list->next)
+ reinitialize_ic (tmp_list->data);
+}
+
+static void
+status_style_change (GtkXIMInfo *info)
+{
+ GtkIMStatusStyle status_style;
- XGetIMValues (info->im,
- XNQueryInputStyle, &xim_styles,
- XNQueryICValuesList, &ic_values,
+ g_object_get (info->settings,
+ "gtk-im-status-style", &status_style,
NULL);
+ if (status_style == GTK_IM_STATUS_CALLBACK)
+ info->status_style_setting = XIMStatusCallbacks;
+ else if (status_style == GTK_IM_STATUS_NOTHING)
+ info->status_style_setting = XIMStatusNothing;
+ else if (status_style == GTK_IM_STATUS_NONE)
+ info->status_style_setting = XIMStatusNone;
+ else
+ return;
+
+ setup_styles (info);
+
+ reinitialize_all_ics (info);
+}
+
+static void
+preedit_style_change (GtkXIMInfo *info)
+{
+ GtkIMPreeditStyle preedit_style;
+ g_object_get (info->settings,
+ "gtk-im-preedit-style", &preedit_style,
+ NULL);
+ if (preedit_style == GTK_IM_PREEDIT_CALLBACK)
+ info->preedit_style_setting = XIMPreeditCallbacks;
+ else if (preedit_style == GTK_IM_PREEDIT_NOTHING)
+ info->preedit_style_setting = XIMPreeditNothing;
+ else if (preedit_style == GTK_IM_PREEDIT_NONE)
+ info->preedit_style_setting = XIMPreeditNone;
+ else
+ return;
+
+ setup_styles (info);
+
+ reinitialize_all_ics (info);
+}
+
+static void
+setup_styles (GtkXIMInfo *info)
+{
+ int i;
+ unsigned long settings_preference;
+ XIMStyles *xim_styles = info->xim_styles;
+ settings_preference = info->status_style_setting|info->preedit_style_setting;
info->style = 0;
if (xim_styles)
{
for (i = 0; i < xim_styles->count_styles; i++)
if ((xim_styles->supported_styles[i] & ALLOWED_MASK) == xim_styles->supported_styles[i])
- info->style = choose_better_style (info->style,
- xim_styles->supported_styles[i]);
+ {
+ if (settings_preference == xim_styles->supported_styles[i])
+ {
+ info->style = settings_preference;
+ break;
+ }
+ info->style = choose_better_style (info->style,
+ xim_styles->supported_styles[i]);
+ }
}
+ if (info->style == 0)
+ info->style = XIMPreeditNothing | XIMStatusNothing;
+}
+static void
+setup_im (GtkXIMInfo *info)
+{
+ XIMValuesList *ic_values = NULL;
+ XIMCallback im_destroy_callback;
-#if 0
+ if (info->im == NULL)
+ return;
+
+ im_destroy_callback.client_data = (XPointer)info;
+ im_destroy_callback.callback = (XIMProc)xim_destroy_callback;
+ XSetIMValues (info->im,
+ XNDestroyCallback, &im_destroy_callback,
+ NULL);
+
+ XGetIMValues (info->im,
+ XNQueryInputStyle, &info->xim_styles,
+ XNQueryICValuesList, &ic_values,
+ NULL);
+
+ info->settings = gtk_settings_get_for_screen (info->screen);
+
+ if (!g_object_class_find_property (G_OBJECT_GET_CLASS (info->settings),
+ "gtk-im-preedit-style"))
+ gtk_settings_install_property (g_param_spec_enum ("gtk-im-preedit-style",
+ P_("IM Preedit style"),
+ P_("How to draw the input method preedit string"),
+ GTK_TYPE_IM_PREEDIT_STYLE,
+ GTK_IM_PREEDIT_CALLBACK,
+ G_PARAM_READWRITE));
+
+ if (!g_object_class_find_property (G_OBJECT_GET_CLASS (info->settings),
+ "gtk-im-status-style"))
+ gtk_settings_install_property (g_param_spec_enum ("gtk-im-status-style",
+ P_("IM Status style"),
+ P_("How to draw the input method statusbar"),
+ GTK_TYPE_IM_STATUS_STYLE,
+ GTK_IM_STATUS_CALLBACK,
+ G_PARAM_READWRITE));
+
+ info->status_set = g_signal_connect_swapped (info->settings,
+ "notify::gtk-im-status-style",
+ G_CALLBACK (status_style_change),
+ info);
+ info->preedit_set = g_signal_connect_swapped (info->settings,
+ "notify::gtk-im-preedit-style",
+ G_CALLBACK (preedit_style_change),
+ info);
+
+ info->supports_string_conversion = FALSE;
if (ic_values)
{
+ int i;
+
+ for (i = 0; i < ic_values->count_values; i++)
+ if (strcmp (ic_values->supported_values[i],
+ XNStringConversionCallback) == 0)
+ {
+ info->supports_string_conversion = TRUE;
+ break;
+ }
+
+#if 0
for (i = 0; i < ic_values->count_values; i++)
g_print ("%s\n", ic_values->supported_values[i]);
for (i = 0; i < xim_styles->count_styles; i++)
g_print ("%#x\n", xim_styles->supported_styles[i]);
- }
#endif
+
+ XFree (ic_values);
+ }
- if (xim_styles)
- XFree (xim_styles);
- if (ic_values)
- XFree (ic_values);
+ status_style_change (info);
+ preedit_style_change (info);
}
-static GtkXIMInfo *
-get_im (const char *locale)
+static void
+xim_info_display_closed (GdkDisplay *display,
+ gboolean is_error,
+ GtkXIMInfo *info)
{
- GSList *tmp_list = open_ims;
- GtkXIMInfo *info;
+ GSList *ics, *tmp_list;
+
+ open_ims = g_slist_remove (open_ims, info);
+
+ ics = info->ics;
+ info->ics = NULL;
+
+ for (tmp_list = ics; tmp_list; tmp_list = tmp_list->next)
+ set_ic_client_window (tmp_list->data, NULL);
+
+ g_slist_free (ics);
+
+ g_signal_handler_disconnect (info->settings, info->status_set);
+ g_signal_handler_disconnect (info->settings, info->preedit_set);
+
+ XFree (info->xim_styles->supported_styles);
+ XFree (info->xim_styles);
+ g_free (info->locale);
+
+ if (info->im)
+ XCloseIM (info->im);
+
+ g_free (info);
+}
+
+static void
+xim_instantiate_callback (Display *display, XPointer client_data,
+ XPointer call_data)
+{
+ GtkXIMInfo *info = (GtkXIMInfo*)client_data;
XIM im = NULL;
- while (tmp_list)
- {
- info = tmp_list->data;
- if (!strcmp (info->locale, locale))
- return info;
+ im = XOpenIM (display, NULL, NULL, NULL);
- tmp_list = tmp_list->next;
- }
+ if (!im)
+ return;
- info = NULL;
+ info->im = im;
+ setup_im (info);
+
+ XUnregisterIMInstantiateCallback (display, NULL, NULL, NULL,
+ xim_instantiate_callback,
+ (XPointer)info);
+ info->reconnecting = FALSE;
+}
+
+/* initialize info->im */
+static void
+xim_info_try_im (GtkXIMInfo *info)
+{
+ GdkScreen *screen = info->screen;
+ GdkDisplay *display = gdk_screen_get_display (screen);
+
+ g_assert (info->im == NULL);
+ if (info->reconnecting)
+ return;
if (XSupportsLocale ())
{
if (!XSetLocaleModifiers (""))
- g_warning ("can not set locale modifiers");
-
- im = XOpenIM (GDK_DISPLAY(), NULL, NULL, NULL);
-
- if (im)
+ g_warning ("Unable to set locale modifiers with XSetLocaleModifiers()");
+ info->im = XOpenIM (GDK_DISPLAY_XDISPLAY (display), NULL, NULL, NULL);
+ if (!info->im)
{
- info = g_new (GtkXIMInfo, 1);
- open_ims = g_slist_prepend (open_ims, im);
-
- info->locale = g_strdup (locale);
- info->im = im;
+ XRegisterIMInstantiateCallback (GDK_DISPLAY_XDISPLAY(display),
+ NULL, NULL, NULL,
+ xim_instantiate_callback,
+ (XPointer)info);
+ info->reconnecting = TRUE;
+ return;
+ }
+ setup_im (info);
+
+ g_signal_connect (display, "closed",
+ G_CALLBACK (xim_info_display_closed), info);
+ }
+}
+
+static void
+xim_destroy_callback (XIM xim,
+ XPointer client_data,
+ XPointer call_data)
+{
+ GtkXIMInfo *info = (GtkXIMInfo*)client_data;
+
+ info->im = NULL;
- setup_im (info);
+ g_signal_handler_disconnect (info->settings, info->status_set);
+ g_signal_handler_disconnect (info->settings, info->preedit_set);
+
+ reinitialize_all_ics (info);
+ xim_info_try_im (info);
+ return;
+}
+
+static GtkXIMInfo *
+get_im (GdkWindow *client_window,
+ const char *locale)
+{
+ GSList *tmp_list;
+ GtkXIMInfo *info;
+ GdkScreen *screen = gdk_drawable_get_screen (client_window);
+
+ info = NULL;
+ tmp_list = open_ims;
+ while (tmp_list)
+ {
+ GtkXIMInfo *tmp_info = tmp_list->data;
+ if (tmp_info->screen == screen &&
+ strcmp (tmp_info->locale, locale) == 0)
+ {
+ if (tmp_info->im)
+ {
+ return tmp_info;
+ }
+ else
+ {
+ tmp_info = tmp_info;
+ break;
+ }
}
+ tmp_list = tmp_list->next;
}
+ if (info == NULL)
+ {
+ info = g_new (GtkXIMInfo, 1);
+ open_ims = g_slist_prepend (open_ims, info);
+
+ info->screen = screen;
+ info->locale = g_strdup (locale);
+ info->xim_styles = NULL;
+ info->preedit_style_setting = 0;
+ info->status_style_setting = 0;
+ info->settings = NULL;
+ info->preedit_set = 0;
+ info->status_set = 0;
+ info->ics = NULL;
+ info->reconnecting = FALSE;
+ info->im = NULL;
+ }
+
+ xim_info_try_im (info);
return info;
}
im_context_class->focus_in = gtk_im_context_xim_focus_in;
im_context_class->focus_out = gtk_im_context_xim_focus_out;
im_context_class->set_cursor_location = gtk_im_context_xim_set_cursor_location;
+ im_context_class->set_use_preedit = gtk_im_context_xim_set_use_preedit;
gobject_class->finalize = gtk_im_context_xim_finalize;
}
static void
gtk_im_context_xim_init (GtkIMContextXIM *im_context_xim)
{
+ im_context_xim->use_preedit = TRUE;
+ im_context_xim->filter_key_release = FALSE;
+ im_context_xim->finalizing = FALSE;
+ im_context_xim->has_focus = FALSE;
+ im_context_xim->in_toplevel = FALSE;
}
static void
{
GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (obj);
- if (context_xim->ic)
+ context_xim->finalizing = TRUE;
+
+ if (context_xim->im_info && !context_xim->im_info->ics->next)
{
- XDestroyIC (context_xim->ic);
- context_xim->ic = NULL;
+ if (context_xim->im_info->reconnecting)
+ {
+ GdkDisplay *display;
+
+ display = gdk_screen_get_display (context_xim->im_info->screen);
+ XUnregisterIMInstantiateCallback (GDK_DISPLAY_XDISPLAY (display),
+ NULL, NULL, NULL,
+ xim_instantiate_callback,
+ (XPointer)context_xim->im_info);
+ }
+ else
+ {
+ XIMCallback im_destroy_callback;
+
+ im_destroy_callback.client_data = NULL;
+ im_destroy_callback.callback = NULL;
+ XSetIMValues (context_xim->im_info->im,
+ XNDestroyCallback, &im_destroy_callback,
+ NULL);
+ }
}
-
+
+ set_ic_client_window (context_xim, NULL);
+
+ g_free (context_xim->locale);
g_free (context_xim->mb_charset);
+
+ G_OBJECT_CLASS (parent_class)->finalize (obj);
}
static void
-gtk_im_context_xim_set_client_window (GtkIMContext *context,
- GdkWindow *client_window)
+reinitialize_ic (GtkIMContextXIM *context_xim)
{
- GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
-
if (context_xim->ic)
{
XDestroyIC (context_xim->ic);
context_xim->ic = NULL;
+ update_status_window (context_xim);
+
+ if (context_xim->preedit_length)
+ {
+ context_xim->preedit_length = 0;
+ if (!context_xim->finalizing)
+ g_signal_emit_by_name (context_xim, "preedit_changed");
+ }
}
+ /*
+ reset filter_key_release flag, otherwise keystrokes will be doubled
+ until reconnecting to XIM.
+ */
+ context_xim->filter_key_release = FALSE;
+}
+static void
+set_ic_client_window (GtkIMContextXIM *context_xim,
+ GdkWindow *client_window)
+{
+ reinitialize_ic (context_xim);
+ if (context_xim->client_window)
+ {
+ context_xim->im_info->ics = g_slist_remove (context_xim->im_info->ics, context_xim);
+ context_xim->im_info = NULL;
+ }
+
context_xim->client_window = client_window;
+
+ if (context_xim->client_window)
+ {
+ context_xim->im_info = get_im (context_xim->client_window, context_xim->locale);
+ context_xim->im_info->ics = g_slist_prepend (context_xim->im_info->ics, context_xim);
+ }
+
+ update_client_widget (context_xim);
+}
+
+static void
+gtk_im_context_xim_set_client_window (GtkIMContext *context,
+ GdkWindow *client_window)
+{
+ GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
+
+ set_ic_client_window (context_xim, client_window);
}
GtkIMContext *
gtk_im_context_xim_new (void)
{
- GtkXIMInfo *info;
GtkIMContextXIM *result;
- gchar *charset;
-
- info = get_im (setlocale (LC_CTYPE, NULL));
- if (!info)
- return NULL;
+ const gchar *charset;
- result = GTK_IM_CONTEXT_XIM (gtk_type_new (GTK_TYPE_IM_CONTEXT_XIM));
+ result = g_object_new (GTK_TYPE_IM_CONTEXT_XIM, NULL);
- result->im_info = info;
+ result->locale = g_strdup (setlocale (LC_CTYPE, NULL));
g_get_charset (&charset);
result->mb_charset = g_strdup (charset);
GError *error = NULL;
gchar *result;
- result = g_convert (str, -1,
- "UTF-8", context_xim->mb_charset,
- NULL, NULL, &error);
-
- if (!result)
+ if (strcmp (context_xim->mb_charset, "UTF-8") == 0)
+ result = g_strdup (str);
+ else
{
- g_warning ("Error converting text from IM to UTF-8: %s\n", error->message);
- g_error_free (error);
+ result = g_convert (str, -1,
+ "UTF-8", context_xim->mb_charset,
+ NULL, NULL, &error);
+ if (!result)
+ {
+ g_warning ("Error converting text from IM to UTF-8: %s\n", error->message);
+ g_error_free (error);
+ }
}
return result;
KeySym keysym;
Status status;
gboolean result = FALSE;
+ GdkWindow *root_window = gdk_screen_get_root_window (gdk_drawable_get_screen (event->window));
XKeyPressedEvent xevent;
- if (!ic)
+ if (event->type == GDK_KEY_RELEASE && !context_xim->filter_key_release)
return FALSE;
- xevent.type = KeyPress;
+ xevent.type = (event->type == GDK_KEY_PRESS) ? KeyPress : KeyRelease;
xevent.serial = 0; /* hope it doesn't matter */
xevent.send_event = event->send_event;
xevent.display = GDK_DRAWABLE_XDISPLAY (event->window);
xevent.window = GDK_DRAWABLE_XID (event->window);
- xevent.root = GDK_ROOT_WINDOW();
+ xevent.root = GDK_DRAWABLE_XID (root_window);
xevent.subwindow = xevent.window;
xevent.time = event->time;
xevent.x = xevent.x_root = 0;
xevent.y = xevent.y_root = 0;
xevent.state = event->state;
- xevent.keycode = event->keyval ? XKeysymToKeycode (xevent.display, event->keyval) : 0;
+ xevent.keycode = event->hardware_keycode;
xevent.same_screen = True;
if (XFilterEvent ((XEvent *)&xevent, GDK_DRAWABLE_XID (context_xim->client_window)))
return TRUE;
again:
- num_bytes = XmbLookupString (ic, &xevent, buffer, buffer_size, &keysym, &status);
+ if (ic)
+ num_bytes = XmbLookupString (ic, &xevent, buffer, buffer_size, &keysym, &status);
+ else
+ {
+ num_bytes = XLookupString (&xevent, buffer, buffer_size, &keysym, NULL);
+ status = XLookupBoth;
+ }
if (status == XBufferOverflow)
{
buffer_size = num_bytes;
+ if (buffer != static_buffer)
+ g_free (buffer);
buffer = g_malloc (num_bytes + 1);
goto again;
}
result_utf8 = mb_to_utf8 (context_xim, buffer);
if (result_utf8)
{
- if ((guchar)result_utf8[0] >= 0x20) /* Some IM have a nasty habit of converting
- * control characters into strings
- */
+ if ((guchar)result_utf8[0] >= 0x20 &&
+ result_utf8[0] != 0x7f) /* Some IM have a nasty habit of converting
+ * control characters into strings
+ */
{
- gtk_signal_emit_by_name (GTK_OBJECT (context), "commit", result_utf8);
+ g_signal_emit_by_name (context, "commit", result_utf8);
result = TRUE;
}
}
}
- return FALSE;
+ if (buffer != static_buffer)
+ g_free (buffer);
+
+ return result;
}
static void
gtk_im_context_xim_focus_in (GtkIMContext *context)
{
GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
- XIC ic = gtk_im_context_xim_get_ic (context_xim);
- if (!ic)
- return;
+ if (!context_xim->has_focus)
+ {
+ XIC ic = gtk_im_context_xim_get_ic (context_xim);
+
+ context_xim->has_focus = TRUE;
+ update_status_window (context_xim);
+
+ if (ic)
+ XSetICFocus (ic);
+ }
- XSetICFocus (ic);
return;
}
gtk_im_context_xim_focus_out (GtkIMContext *context)
{
GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
- XIC ic = gtk_im_context_xim_get_ic (context_xim);
- if (!ic)
- return;
+ if (context_xim->has_focus)
+ {
+ XIC ic = gtk_im_context_xim_get_ic (context_xim);
+
+ context_xim->has_focus = FALSE;
+ update_status_window (context_xim);
+
+ if (ic)
+ XUnsetICFocus (ic);
+ }
- XUnsetICFocus (ic);
return;
}
preedit_attr = XVaCreateNestedList (0,
XNSpotLocation, &spot,
- 0);
+ NULL);
XSetICValues (ic,
XNPreeditAttributes, preedit_attr,
NULL);
return;
}
+static void
+gtk_im_context_xim_set_use_preedit (GtkIMContext *context,
+ gboolean use_preedit)
+{
+ GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
+
+ use_preedit = use_preedit != FALSE;
+
+ if (context_xim->use_preedit != use_preedit)
+ {
+ context_xim->use_preedit = use_preedit;
+ reinitialize_ic (context_xim);
+ }
+
+ return;
+}
+
static void
gtk_im_context_xim_reset (GtkIMContext *context)
{
return;
+ if (context_xim->preedit_length == 0)
+ return;
+
preedit_attr = XVaCreateNestedList(0,
XNPreeditState, &preedit_state,
- 0);
+ NULL);
if (!XGetICValues(ic,
XNPreeditAttributes, preedit_attr,
NULL))
preedit_attr = XVaCreateNestedList(0,
XNPreeditState, preedit_state,
- 0);
+ NULL);
if (have_preedit_state)
XSetICValues(ic,
XNPreeditAttributes, preedit_attr,
char *result_utf8 = mb_to_utf8 (context_xim, result);
if (result_utf8)
{
- gtk_signal_emit_by_name (GTK_OBJECT (context), "commit", result_utf8);
+ g_signal_emit_by_name (context, "commit", result_utf8);
g_free (result_utf8);
}
}
if (context_xim->preedit_length)
{
context_xim->preedit_length = 0;
- gtk_signal_emit_by_name (GTK_OBJECT (context), "preedit_changed");
+ g_signal_emit_by_name (context, "preedit_changed");
}
XFree (result);
*cursor_pos = context_xim->preedit_cursor;
}
-static void
+static int
preedit_start_callback (XIC xic,
XPointer client_data,
XPointer call_data)
{
GtkIMContext *context = GTK_IM_CONTEXT (client_data);
+ GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
- gtk_signal_emit_by_name (GTK_OBJECT (context), "preedit_start");
- g_print ("Starting preedit!\n");
+ if (!context_xim->finalizing)
+ g_signal_emit_by_name (context, "preedit_start");
+
+ return -1; /* No length limit */
}
static void
XPointer call_data)
{
GtkIMContext *context = GTK_IM_CONTEXT (client_data);
-
- gtk_signal_emit_by_name (GTK_OBJECT (context), "preedit_end");
- g_print ("Ending preedit!\n");
+ GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
+
+ if (context_xim->preedit_length)
+ {
+ context_xim->preedit_length = 0;
+ if (!context_xim->finalizing)
+ g_signal_emit_by_name (context_xim, "preedit_changed");
+ }
+
+ if (!context_xim->finalizing)
+ g_signal_emit_by_name (context, "preedit_end");
}
static gint
return 0;
}
- result = g_convert (xim_text->string.multi_byte,
- -1,
- "UTF-8",
- context->mb_charset,
- NULL, NULL, &error);
+ if (strcmp (context->mb_charset, "UTF-8") == 0)
+ result = g_strdup (xim_text->string.multi_byte);
+ else
+ result = g_convert (xim_text->string.multi_byte,
+ -1,
+ "UTF-8",
+ context->mb_charset,
+ NULL, NULL, &error);
if (result)
{
if (new_text)
g_free (new_text);
- gtk_signal_emit_by_name (GTK_OBJECT (context), "preedit_changed");
+ if (!context->finalizing)
+ g_signal_emit_by_name (context, "preedit_changed");
}
if (call_data->direction == XIMAbsolutePosition)
{
context->preedit_cursor = call_data->position;
- gtk_signal_emit_by_name (GTK_OBJECT (context), "preedit_changed");
+ if (!context->finalizing)
+ g_signal_emit_by_name (context, "preedit_changed");
}
else
{
XPointer client_data,
XPointer call_data)
{
- g_print ("Status start\n");
+ return;
}
static void
XPointer client_data,
XPointer call_data)
{
- g_print ("Status done!\n");
+ return;
}
static void
{
GtkIMContextXIM *context = GTK_IM_CONTEXT_XIM (client_data);
- g_print ("Status draw\n");
if (call_data->type == XIMTextType)
{
gchar *text;
xim_text_to_utf8 (context, call_data->data.text, &text);
- if (text)
- g_print (" %s\n", text);
+ if (context->status_window)
+ status_window_set_text (context->status_window, text ? text : "");
}
else /* bitmap */
{
- g_print (" bitmap id = %#lx\n", call_data->data.bitmap);
+ g_print ("Status drawn with bitmap - id = %#lx\n", call_data->data.bitmap);
}
}
+static void
+string_conversion_callback (XIC xic, XPointer client_data, XPointer call_data)
+{
+ GtkIMContextXIM *context_xim;
+ XIMStringConversionCallbackStruct *conv_data;
+ gchar *surrounding;
+ gint cursor_index;
+
+ context_xim = (GtkIMContextXIM *)client_data;
+ conv_data = (XIMStringConversionCallbackStruct *)call_data;
+
+ if (gtk_im_context_get_surrounding ((GtkIMContext *)context_xim,
+ &surrounding, &cursor_index))
+ {
+ gchar *text = NULL;
+ gsize text_len = 0;
+ gint subst_offset = 0, subst_nchars = 0;
+ gint i;
+ gchar *p = surrounding + cursor_index, *q;
+ gshort position = (gshort)conv_data->position;
+
+ if (position > 0)
+ {
+ for (i = position; i > 0 && *p; --i)
+ p = g_utf8_next_char (p);
+ if (i > 0)
+ return;
+ }
+ /* According to X11R6.4 Xlib - C Library Reference Manual
+ * section 13.5.7.3 String Conversion Callback,
+ * XIMStringConversionPosition is starting position _relative_
+ * to current client's cursor position. So it should be able
+ * to be negative, or referring to a position before the cursor
+ * would be impossible. But current X protocol defines this as
+ * unsigned short. So, compiler may warn about the value range
+ * here. We hope the X protocol is fixed soon.
+ */
+ else if (position < 0)
+ {
+ for (i = position; i < 0 && p > surrounding; ++i)
+ p = g_utf8_prev_char (p);
+ if (i < 0)
+ return;
+ }
+
+ switch (conv_data->direction)
+ {
+ case XIMForwardChar:
+ for (i = conv_data->factor, q = p; i > 0 && *q; --i)
+ q = g_utf8_next_char (q);
+ if (i > 0)
+ break;
+ text = g_locale_from_utf8 (p, q - p, NULL, &text_len, NULL);
+ subst_offset = position;
+ subst_nchars = conv_data->factor;
+ break;
+
+ case XIMBackwardChar:
+ for (i = conv_data->factor, q = p; i > 0 && q > surrounding; --i)
+ q = g_utf8_prev_char (q);
+ if (i > 0)
+ break;
+ text = g_locale_from_utf8 (q, p - q, NULL, &text_len, NULL);
+ subst_offset = position - conv_data->factor;
+ subst_nchars = conv_data->factor;
+ break;
+
+ case XIMForwardWord:
+ case XIMBackwardWord:
+ case XIMCaretUp:
+ case XIMCaretDown:
+ case XIMNextLine:
+ case XIMPreviousLine:
+ case XIMLineStart:
+ case XIMLineEnd:
+ case XIMAbsolutePosition:
+ case XIMDontChange:
+ default:
+ break;
+ }
+ /* block out any failure happenning to "text", including conversion */
+ if (text)
+ {
+ conv_data->text = (XIMStringConversionText *)
+ malloc (sizeof (XIMStringConversionText));
+ if (conv_data->text)
+ {
+ conv_data->text->length = text_len;
+ conv_data->text->feedback = NULL;
+ conv_data->text->encoding_is_wchar = False;
+ conv_data->text->string.mbs = (char *)malloc (text_len);
+ if (conv_data->text->string.mbs)
+ memcpy (conv_data->text->string.mbs, text, text_len);
+ else
+ {
+ free (conv_data->text);
+ conv_data->text = NULL;
+ }
+ }
+
+ g_free (text);
+ }
+ if (conv_data->operation == XIMStringConversionSubstitution
+ && subst_nchars > 0)
+ {
+ gtk_im_context_delete_surrounding ((GtkIMContext *)context_xim,
+ subst_offset, subst_nchars);
+ }
+
+ g_free (surrounding);
+ }
+}
+
+
+static XVaNestedList
+set_preedit_callback (GtkIMContextXIM *context_xim)
+{
+ context_xim->preedit_start_callback.client_data = (XPointer)context_xim;
+ context_xim->preedit_start_callback.callback = (XIMProc)preedit_start_callback;
+ context_xim->preedit_done_callback.client_data = (XPointer)context_xim;
+ context_xim->preedit_done_callback.callback = (XIMProc)preedit_done_callback;
+ context_xim->preedit_draw_callback.client_data = (XPointer)context_xim;
+ context_xim->preedit_draw_callback.callback = (XIMProc)preedit_draw_callback;
+ context_xim->preedit_caret_callback.client_data = (XPointer)context_xim;
+ context_xim->preedit_caret_callback.callback = (XIMProc)preedit_caret_callback;
+ return XVaCreateNestedList (0,
+ XNPreeditStartCallback, &context_xim->preedit_start_callback,
+ XNPreeditDoneCallback, &context_xim->preedit_done_callback,
+ XNPreeditDrawCallback, &context_xim->preedit_draw_callback,
+ XNPreeditCaretCallback, &context_xim->preedit_caret_callback,
+ NULL);
+}
+
+static XVaNestedList
+set_status_callback (GtkIMContextXIM *context_xim)
+{
+ context_xim->status_start_callback.client_data = (XPointer)context_xim;
+ context_xim->status_start_callback.callback = (XIMProc)status_start_callback;
+ context_xim->status_done_callback.client_data = (XPointer)context_xim;
+ context_xim->status_done_callback.callback = (XIMProc)status_done_callback;
+ context_xim->status_draw_callback.client_data = (XPointer)context_xim;
+ context_xim->status_draw_callback.callback = (XIMProc)status_draw_callback;
+
+ return XVaCreateNestedList (0,
+ XNStatusStartCallback, &context_xim->status_start_callback,
+ XNStatusDoneCallback, &context_xim->status_done_callback,
+ XNStatusDrawCallback, &context_xim->status_draw_callback,
+ NULL);
+}
+
+
+static void
+set_string_conversion_callback (GtkIMContextXIM *context_xim, XIC xic)
+{
+ if (!context_xim->im_info->supports_string_conversion)
+ return;
+
+ context_xim->string_conversion_callback.client_data = (XPointer)context_xim;
+ context_xim->string_conversion_callback.callback = (XIMProc)string_conversion_callback;
+
+ XSetICValues (xic,
+ XNStringConversionCallback,
+ (XPointer)&context_xim->string_conversion_callback,
+ NULL);
+}
+
static XIC
gtk_im_context_xim_get_ic (GtkIMContextXIM *context_xim)
{
- const char *name1 = NULL;
- XVaNestedList list1 = NULL;
- const char *name2 = NULL;
- XVaNestedList list2 = NULL;
+ if (context_xim->im_info == NULL || context_xim->im_info->im == NULL)
+ return NULL;
- if (!context_xim->ic && context_xim->client_window)
+ if (!context_xim->ic)
{
- if ((context_xim->im_info->style & PREEDIT_MASK) == XIMPreeditCallbacks)
+ const char *name1 = NULL;
+ XVaNestedList list1 = NULL;
+ const char *name2 = NULL;
+ XVaNestedList list2 = NULL;
+ XIMStyle im_style = 0;
+ XIC xic = NULL;
+
+ if (context_xim->use_preedit &&
+ (context_xim->im_info->style & PREEDIT_MASK) == XIMPreeditCallbacks)
{
- context_xim->preedit_start_callback.client_data = (XPointer)context_xim;
- context_xim->preedit_start_callback.callback = (XIMProc)preedit_start_callback;
- context_xim->preedit_done_callback.client_data = (XPointer)context_xim;
- context_xim->preedit_done_callback.callback = (XIMProc)preedit_done_callback;
- context_xim->preedit_draw_callback.client_data = (XPointer)context_xim;
- context_xim->preedit_draw_callback.callback = (XIMProc)preedit_draw_callback;
- context_xim->preedit_caret_callback.client_data = (XPointer)context_xim;
- context_xim->preedit_caret_callback.callback = (XIMProc)preedit_caret_callback;
-
+ im_style |= XIMPreeditCallbacks;
name1 = XNPreeditAttributes;
- list1 = XVaCreateNestedList (0,
- XNPreeditStartCallback, &context_xim->preedit_start_callback,
- XNPreeditDoneCallback, &context_xim->preedit_done_callback,
- XNPreeditDrawCallback, &context_xim->preedit_draw_callback,
- XNPreeditCaretCallback, &context_xim->preedit_caret_callback,
- NULL);
+ list1 = set_preedit_callback (context_xim);
}
+ else if ((context_xim->im_info->style & PREEDIT_MASK) == XIMPreeditNone)
+ im_style |= XIMPreeditNone;
+ else
+ im_style |= XIMPreeditNothing;
if ((context_xim->im_info->style & STATUS_MASK) == XIMStatusCallbacks)
{
- XVaNestedList status_attrs;
-
- context_xim->status_start_callback.client_data = (XPointer)context_xim;
- context_xim->status_start_callback.callback = (XIMProc)status_start_callback;
- context_xim->status_done_callback.client_data = (XPointer)context_xim;
- context_xim->status_done_callback.callback = (XIMProc)status_done_callback;
- context_xim->status_draw_callback.client_data = (XPointer)context_xim;
- context_xim->status_draw_callback.callback = (XIMProc)status_draw_callback;
-
- status_attrs = XVaCreateNestedList (0,
- XNStatusStartCallback, &context_xim->status_start_callback,
- XNStatusDoneCallback, &context_xim->status_done_callback,
- XNStatusDrawCallback, &context_xim->status_draw_callback,
- NULL);
-
+ im_style |= XIMStatusCallbacks;
if (name1 == NULL)
{
name1 = XNStatusAttributes;
- list1 = status_attrs;
+ list1 = set_status_callback (context_xim);
}
else
{
name2 = XNStatusAttributes;
- list2 = status_attrs;
+ list2 = set_status_callback (context_xim);
}
}
-
- context_xim->ic = XCreateIC (context_xim->im_info->im,
- XNInputStyle, context_xim->im_info->style,
- XNClientWindow, GDK_DRAWABLE_XID (context_xim->client_window),
- name1, list1,
- name2, list2,
- NULL);
-
+ else if ((context_xim->im_info->style & STATUS_MASK) == XIMStatusNone)
+ im_style |= XIMStatusNone;
+ else
+ im_style |= XIMStatusNothing;
+
+ xic = XCreateIC (context_xim->im_info->im,
+ XNInputStyle, im_style,
+ XNClientWindow, GDK_DRAWABLE_XID (context_xim->client_window),
+ name1, list1,
+ name2, list2,
+ NULL);
if (list1)
XFree (list1);
if (list2)
XFree (list2);
- }
+ if (xic)
+ {
+ /* Don't filter key released events with XFilterEvents unless
+ * input methods ask for. This is a workaround for Solaris input
+ * method bug in C and European locales. It doubles each key
+ * stroke if both key pressed and released events are filtered.
+ * (bugzilla #81759)
+ */
+ gulong mask = 0xaaaaaaaa;
+ XGetICValues (xic,
+ XNFilterEvents, &mask,
+ NULL);
+ context_xim->filter_key_release = (mask & KeyReleaseMask) != 0;
+ set_string_conversion_callback (context_xim, xic);
+ }
+
+ context_xim->ic = xic;
+
+ update_status_window (context_xim);
+
+ if (xic && context_xim->has_focus)
+ XSetICFocus (xic);
+ }
return context_xim->ic;
}
+
+/*****************************************************************
+ * Status Window handling
+ *
+ * A status window is a small window attached to the toplevel
+ * that is used to display information to the user about the
+ * current input operation.
+ *
+ * We claim the toplevel's status window for an input context if:
+ *
+ * A) The input context has a toplevel
+ * B) The input context has the focus
+ * C) The input context has an XIC associated with it
+ *
+ * Tracking A) and C) is pretty reliable since we
+ * compute A) and create the XIC for C) ourselves.
+ * For B) we basically have to depend on our callers
+ * calling ::focus-in and ::focus-out at the right time.
+ *
+ * The toplevel is computed by walking up the GdkWindow
+ * hierarchy from context->client_window until we find a
+ * window that is owned by some widget, and then calling
+ * gtk_widget_get_toplevel() on that widget. This should
+ * handle both cases where we might have GdkWindows without widgets,
+ * and cases where GtkWidgets have strange window hierarchies
+ * (like a torn off GtkHandleBox.)
+ *
+ * The status window is visible if and only if there is text
+ * for it; whenever a new GtkIMContextXIM claims the status
+ * window, we blank out any existing text. We actually only
+ * create a GtkWindow for the status window the first time
+ * it is shown; this is an important optimization when we are
+ * using XIM with something like a simple compose-key input
+ * method that never needs a status window.
+ *****************************************************************/
+
+/* Called when we no longer need a status window
+*/
+static void
+disclaim_status_window (GtkIMContextXIM *context_xim)
+{
+ if (context_xim->status_window)
+ {
+ g_assert (context_xim->status_window->context == context_xim);
+
+ status_window_set_text (context_xim->status_window, "");
+
+ context_xim->status_window->context = NULL;
+ context_xim->status_window = NULL;
+ }
+}
+
+/* Called when we need a status window
+ */
+static void
+claim_status_window (GtkIMContextXIM *context_xim)
+{
+ if (!context_xim->status_window && context_xim->client_widget)
+ {
+ GtkWidget *toplevel = gtk_widget_get_toplevel (context_xim->client_widget);
+ if (toplevel && GTK_WIDGET_TOPLEVEL (toplevel))
+ {
+ StatusWindow *status_window = status_window_get (toplevel);
+
+ if (status_window->context)
+ disclaim_status_window (status_window->context);
+
+ status_window->context = context_xim;
+ context_xim->status_window = status_window;
+ }
+ }
+}
+
+/* Basic call made whenever something changed that might cause
+ * us to need, or not to need a status window.
+ */
+static void
+update_status_window (GtkIMContextXIM *context_xim)
+{
+ if (context_xim->ic && context_xim->in_toplevel && context_xim->has_focus)
+ claim_status_window (context_xim);
+ else
+ disclaim_status_window (context_xim);
+}
+
+/* Updates the in_toplevel flag for @context_xim
+ */
+static void
+update_in_toplevel (GtkIMContextXIM *context_xim)
+{
+ if (context_xim->client_widget)
+ {
+ GtkWidget *toplevel = gtk_widget_get_toplevel (context_xim->client_widget);
+
+ context_xim->in_toplevel = (toplevel && GTK_WIDGET_TOPLEVEL (toplevel));
+ }
+ else
+ context_xim->in_toplevel = FALSE;
+
+ /* Some paranoia, in case we don't get a focus out */
+ if (!context_xim->in_toplevel)
+ context_xim->has_focus = FALSE;
+
+ update_status_window (context_xim);
+}
+
+/* Callback when @widget's toplevel changes. It will always
+ * change from NULL to a window, or a window to NULL;
+ * we use that intermediate NULL state to make sure
+ * that we disclaim the toplevel status window for the old
+ * window.
+ */
+static void
+on_client_widget_hierarchy_changed (GtkWidget *widget,
+ GtkWidget *old_toplevel,
+ GtkIMContextXIM *context_xim)
+{
+ update_in_toplevel (context_xim);
+}
+
+/* Finds the GtkWidget that owns the window, or if none, the
+ * widget owning the nearest parent that has a widget.
+ */
+static GtkWidget *
+widget_for_window (GdkWindow *window)
+{
+ while (window)
+ {
+ gpointer user_data;
+ gdk_window_get_user_data (window, &user_data);
+ if (user_data)
+ return user_data;
+
+ window = gdk_window_get_parent (window);
+ }
+
+ return NULL;
+}
+
+/* Called when context_xim->client_window changes; takes care of
+ * removing and/or setting up our watches for the toplevel
+ */
+static void
+update_client_widget (GtkIMContextXIM *context_xim)
+{
+ GtkWidget *new_client_widget = widget_for_window (context_xim->client_window);
+
+ if (new_client_widget != context_xim->client_widget)
+ {
+ if (context_xim->client_widget)
+ {
+ g_signal_handlers_disconnect_by_func (context_xim->client_widget,
+ G_CALLBACK (on_client_widget_hierarchy_changed),
+ context_xim);
+ }
+ context_xim->client_widget = new_client_widget;
+ if (context_xim->client_widget)
+ {
+ g_signal_connect (context_xim->client_widget, "hierarchy-changed",
+ G_CALLBACK (on_client_widget_hierarchy_changed),
+ context_xim);
+ }
+
+ update_in_toplevel (context_xim);
+ }
+}
+
+/* Called when the toplevel is destroyed; frees the status window
+ */
+static void
+on_status_toplevel_destroy (GtkWidget *toplevel,
+ StatusWindow *status_window)
+{
+ status_window_free (status_window);
+}
+
+/* Called when the screen for the toplevel changes; updates the
+ * screen for the status window to match.
+ */
+static void
+on_status_toplevel_notify_screen (GtkWindow *toplevel,
+ GParamSpec *pspec,
+ StatusWindow *status_window)
+{
+ if (status_window->window)
+ gtk_window_set_screen (GTK_WINDOW (status_window->window),
+ gtk_widget_get_screen (GTK_WIDGET (toplevel)));
+}
+
+/* Called when the toplevel window is moved; updates the position of
+ * the status window to follow it.
+ */
+static gboolean
+on_status_toplevel_configure (GtkWidget *toplevel,
+ GdkEventConfigure *event,
+ StatusWindow *status_window)
+{
+ GdkRectangle rect;
+ GtkRequisition requisition;
+ gint y;
+ gint height;
+
+ if (status_window->window)
+ {
+ height = gdk_screen_get_height (gtk_widget_get_screen (toplevel));
+
+ gdk_window_get_frame_extents (toplevel->window, &rect);
+ gtk_widget_size_request (status_window->window, &requisition);
+
+ if (rect.y + rect.height + requisition.height < height)
+ y = rect.y + rect.height;
+ else
+ y = height - requisition.height;
+
+ gtk_window_move (GTK_WINDOW (status_window->window), rect.x, y);
+ }
+
+ return FALSE;
+}
+
+/* Frees a status window and removes its link from the status_windows list
+ */
+static void
+status_window_free (StatusWindow *status_window)
+{
+ status_windows = g_slist_remove (status_windows, status_window);
+
+ if (status_window->context)
+ status_window->context->status_window = NULL;
+
+ g_signal_handlers_disconnect_by_func (status_window->toplevel,
+ G_CALLBACK (on_status_toplevel_destroy),
+ status_window);
+ g_signal_handlers_disconnect_by_func (status_window->toplevel,
+ G_CALLBACK (on_status_toplevel_notify_screen),
+ status_window);
+ g_signal_handlers_disconnect_by_func (status_window->toplevel,
+ G_CALLBACK (on_status_toplevel_configure),
+ status_window);
+
+ if (status_window->window)
+ gtk_widget_destroy (status_window->window);
+
+ g_object_set_data (G_OBJECT (status_window->toplevel), "gtk-im-xim-status-window", NULL);
+
+ g_free (status_window);
+}
+
+/* Finds the status window object for a toplevel, creating it if necessary.
+ */
+static StatusWindow *
+status_window_get (GtkWidget *toplevel)
+{
+ StatusWindow *status_window;
+
+ status_window = g_object_get_data (G_OBJECT (toplevel), "gtk-im-xim-status-window");
+ if (status_window)
+ return status_window;
+
+ status_window = g_new0 (StatusWindow, 1);
+ status_window->toplevel = toplevel;
+
+ status_windows = g_slist_prepend (status_windows, status_window);
+
+ g_signal_connect (toplevel, "destroy",
+ G_CALLBACK (on_status_toplevel_destroy),
+ status_window);
+ g_signal_connect (toplevel, "configure_event",
+ G_CALLBACK (on_status_toplevel_configure),
+ status_window);
+ g_signal_connect (toplevel, "notify::screen",
+ G_CALLBACK (on_status_toplevel_notify_screen),
+ status_window);
+
+ g_object_set_data (G_OBJECT (toplevel), "gtk-im-xim-status-window", status_window);
+
+ return status_window;
+}
+
+/* Draw the background (normally white) and border for the status window
+ */
+static gboolean
+on_status_window_expose_event (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ gdk_draw_rectangle (widget->window,
+ widget->style->base_gc [GTK_STATE_NORMAL],
+ TRUE,
+ 0, 0,
+ widget->allocation.width, widget->allocation.height);
+ gdk_draw_rectangle (widget->window,
+ widget->style->text_gc [GTK_STATE_NORMAL],
+ FALSE,
+ 0, 0,
+ widget->allocation.width - 1, widget->allocation.height - 1);
+
+ return FALSE;
+}
+
+/* We watch the ::style-set signal for our label widget
+ * and use that to change it's foreground color to match
+ * the 'text' color of the toplevel window. The text/base
+ * pair of colors might be reversed from the fg/bg pair
+ * that are normally used for labels.
+ */
+static void
+on_status_window_style_set (GtkWidget *toplevel,
+ GtkStyle *previous_style,
+ GtkWidget *label)
+{
+ gint i;
+
+ for (i = 0; i < 5; i++)
+ gtk_widget_modify_fg (label, i, &toplevel->style->text[i]);
+}
+
+/* Creates the widgets for the status window; called when we
+ * first need to show text for the status window.
+ */
+static void
+status_window_make_window (StatusWindow *status_window)
+{
+ GtkWidget *window;
+ GtkWidget *status_label;
+
+ status_window->window = gtk_window_new (GTK_WINDOW_POPUP);
+ window = status_window->window;
+
+ gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+ gtk_widget_set_app_paintable (window, TRUE);
+
+ status_label = gtk_label_new ("");
+ gtk_misc_set_padding (GTK_MISC (status_label), 1, 1);
+ gtk_widget_show (status_label);
+
+ g_signal_connect (window, "style_set",
+ G_CALLBACK (on_status_window_style_set), status_label);
+ gtk_container_add (GTK_CONTAINER (window), status_label);
+
+ g_signal_connect (window, "expose_event",
+ G_CALLBACK (on_status_window_expose_event), NULL);
+
+ gtk_window_set_screen (GTK_WINDOW (status_window->window),
+ gtk_widget_get_screen (status_window->toplevel));
+
+ on_status_toplevel_configure (status_window->toplevel, NULL, status_window);
+}
+
+/* Updates the text in the status window, hiding or
+ * showing the window as necessary.
+ */
+static void
+status_window_set_text (StatusWindow *status_window,
+ const gchar *text)
+{
+ if (text[0])
+ {
+ GtkWidget *label;
+
+ if (!status_window->window)
+ status_window_make_window (status_window);
+
+ label = GTK_BIN (status_window->window)->child;
+ gtk_label_set_text (GTK_LABEL (label), text);
+
+ gtk_widget_show (status_window->window);
+ }
+ else
+ {
+ if (status_window->window)
+ gtk_widget_hide (status_window->window);
+ }
+}
+
+/**
+ * gtk_im_context_xim_shutdown:
+ *
+ * Destroys all the status windows that are kept by the XIM contexts. This
+ * function should only be called by the XIM module exit routine.
+ **/
+void
+gtk_im_context_xim_shutdown (void)
+{
+ while (status_windows)
+ status_window_free (status_windows->data);
+}
projects / ~andy / gtk / blobdiff