/* GTK - The GIMP Toolkit

 * Copyright (C) 2000 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 "config.h"

#include "locale.h"

#include <string.h>

#include <stdlib.h>

#include "gtkimcontextxim.h"

#include "gtk/gtkintl.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;

  gulong display_closed_cb;

  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_init               (GtkIMContextXIM       *im_context_xim);

static void     gtk_im_context_xim_finalize           (GObject               *obj);

static void     gtk_im_context_xim_set_client_window  (GtkIMContext          *context,

						       GdkWindow             *client_window);

static gboolean gtk_im_context_xim_filter_keypress    (GtkIMContext          *context,

						       GdkEventKey           *key);

static void     gtk_im_context_xim_reset              (GtkIMContext          *context);

static void     gtk_im_context_xim_focus_in           (GtkIMContext          *context);

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 void           xim_info_display_closed (GdkDisplay *display,

			                       gboolean    is_error,

			                       GtkXIMInfo *info);

static GObjectClass *parent_class;

GType gtk_type_im_context_xim = 0;

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)

{

  const GTypeInfo im_context_xim_info =

  {

    sizeof (GtkIMContextXIMClass),

    (GBaseInitFunc) NULL,

    (GBaseFinalizeFunc) NULL,

    (GClassInitFunc) gtk_im_context_xim_class_init,

    NULL,           /* class_finalize */    

    NULL,           /* class_data */

    sizeof (GtkIMContextXIM),

    0,

    (GInstanceInitFunc) gtk_im_context_xim_init,

  };

  gtk_type_im_context_xim = 

    g_type_module_register_type (type_module,

				 GTK_TYPE_IM_CONTEXT,

				 "GtkIMContextXIM",

				 &im_context_xim_info, 0);

}

#define PREEDIT_MASK (XIMPreeditCallbacks | XIMPreeditPosition | \

		      XIMPreeditArea | XIMPreeditNothing | XIMPreeditNone)

#define STATUS_MASK (XIMStatusCallbacks | XIMStatusArea | \

		      XIMStatusNothing | XIMStatusNone)

#define ALLOWED_MASK (XIMPreeditCallbacks | XIMPreeditNothing | XIMPreeditNone | \

		      XIMStatusCallbacks | XIMStatusNothing | XIMStatusNone)

static XIMStyle 

choose_better_style (XIMStyle style1, XIMStyle style2) 

{

  XIMStyle s1, s2, u; 

  if (style1 == 0) return style2;

  if (style2 == 0) return style1;

  if ((style1 & (PREEDIT_MASK | STATUS_MASK))

    	== (style2 & (PREEDIT_MASK | STATUS_MASK)))

    return style1;

  s1 = style1 & PREEDIT_MASK;

  s2 = style2 & PREEDIT_MASK;

  u = s1 | s2;

  if (s1 != s2) {

    if (u & XIMPreeditCallbacks)

      return (s1 == XIMPreeditCallbacks) ? style1 : style2;

    else if (u & XIMPreeditPosition)

      return (s1 == XIMPreeditPosition) ? style1 :style2;

    else if (u & XIMPreeditArea)

      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;

    u = s1 | s2;

    if (u & XIMStatusCallbacks)

      return (s1 == XIMStatusCallbacks) ? style1 : style2;

    else if (u & XIMStatusArea)

      return (s1 == XIMStatusArea) ? style1 : style2;

    else if (u & XIMStatusNothing)

      return (s1 == XIMStatusNothing) ? style1 : style2;

    else if (u & XIMStatusNone)

      return (s1 == XIMStatusNone) ? style1 : style2;

  }

  return 0; /* Get rid of stupid warning */

}

static void

reinitialize_all_ics (GtkXIMInfo *info)

{

  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;

  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])

	  {

	    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;

  GdkDisplay *display;

  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);

  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);

    }

  status_style_change (info);

  preedit_style_change (info);

  display = gdk_screen_get_display (info->screen);

  info->display_closed_cb = g_signal_connect (display, "closed",

	                                      G_CALLBACK (xim_info_display_closed), info);

}

static void

xim_info_display_closed (GdkDisplay *display,

			 gboolean    is_error,

			 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);

  if (info->status_set)

    g_signal_handler_disconnect (info->settings, info->status_set);

  if (info->preedit_set)

    g_signal_handler_disconnect (info->settings, info->preedit_set);

  if (info->display_closed_cb)

    g_signal_handler_disconnect (display, info->display_closed_cb);

  if (info->xim_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;

  im = XOpenIM (display, NULL, NULL, NULL);

  if (!im)

    return;

  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 ("Unable to set locale modifiers with XSetLocaleModifiers()");

      info->im = XOpenIM (GDK_DISPLAY_XDISPLAY (display), NULL, NULL, NULL);

      if (!info->im)

	{

	  XRegisterIMInstantiateCallback (GDK_DISPLAY_XDISPLAY(display),

					  NULL, NULL, NULL,

					  xim_instantiate_callback,

					  (XPointer)info);

	  info->reconnecting = TRUE;

	  return;

	}

      setup_im (info);

    }

}

static void

xim_destroy_callback (XIM      xim,

		      XPointer client_data,

		      XPointer call_data)

{

  GtkXIMInfo *info = (GtkXIMInfo*)client_data;

  info->im = NULL;

  g_signal_handler_disconnect (info->settings, info->status_set);

  info->status_set = 0;

  g_signal_handler_disconnect (info->settings, info->preedit_set);

  info->preedit_set = 0;

  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_window_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->display_closed_cb = 0;

      info->ics = NULL;

      info->reconnecting = FALSE;

      info->im = NULL;

    }

  xim_info_try_im (info);

  return info;

}

static void

gtk_im_context_xim_class_init (GtkIMContextXIMClass *class)

{

  GtkIMContextClass *im_context_class = GTK_IM_CONTEXT_CLASS (class);

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  parent_class = g_type_class_peek_parent (class);

  im_context_class->set_client_window = gtk_im_context_xim_set_client_window;

  im_context_class->filter_keypress = gtk_im_context_xim_filter_keypress;

  im_context_class->reset = gtk_im_context_xim_reset;

  im_context_class->get_preedit_string = gtk_im_context_xim_get_preedit_string;

  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

gtk_im_context_xim_finalize (GObject *obj)

{

  GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (obj);

  context_xim->finalizing = TRUE;

  if (context_xim->im_info && !context_xim->im_info->ics->next) 

    {

      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 if (context_xim->im_info->im)

	{

	  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

reinitialize_ic (GtkIMContextXIM *context_xim)

{

  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)

{

  GtkIMContextXIM *result;

  const gchar *charset;

  result = g_object_new (GTK_TYPE_IM_CONTEXT_XIM, NULL);

  result->locale = g_strdup (setlocale (LC_CTYPE, NULL));

  g_get_charset (&charset);

  result->mb_charset = g_strdup (charset);

  return GTK_IM_CONTEXT (result);

}

static char *

mb_to_utf8 (GtkIMContextXIM *context_xim,

	    const char      *str)

{

  GError *error = NULL;

  gchar *result;

  if (strcmp (context_xim->mb_charset, "UTF-8") == 0)

    result = g_strdup (str);

  else

    {

      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;

}

static gboolean

gtk_im_context_xim_filter_keypress (GtkIMContext *context,

				    GdkEventKey  *event)

{

  GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);

  XIC ic = gtk_im_context_xim_get_ic (context_xim);

  gchar static_buffer[256];

  gchar *buffer = static_buffer;

  gint buffer_size = sizeof(static_buffer) - 1;

  gint num_bytes = 0;

  KeySym keysym;

  Status status;

  gboolean result = FALSE;

  GdkWindow *root_window = gdk_screen_get_root_window (gdk_window_get_screen (event->window));

  XKeyPressedEvent xevent;

  if (event->type == GDK_KEY_RELEASE && !context_xim->filter_key_release)

    return FALSE;

  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_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->hardware_keycode;

  xevent.same_screen = True;

  if (XFilterEvent ((XEvent *)&xevent, GDK_DRAWABLE_XID (context_xim->client_window)))

    return TRUE;

  if (event->state &

      (gtk_accelerator_get_default_mod_mask () & ~(GDK_SHIFT_MASK | GDK_CONTROL_MASK))) 

    return FALSE;

 again:

  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;

    }

  /* I don't know how we should properly handle XLookupKeysym or XLookupBoth

   * here ... do input methods actually change the keysym? we can't really

   * feed it back to accelerator processing at this point...

   */

  if (status == XLookupChars || status == XLookupBoth)

    {

      char *result_utf8;

      buffer[num_bytes] = '\0';

      result_utf8 = mb_to_utf8 (context_xim, buffer);

      if (result_utf8)

	{

	  if ((guchar)result_utf8[0] >= 0x20 &&

	      result_utf8[0] != 0x7f) /* Some IM have a nasty habit of converting

				       * control characters into strings

				       */

	    {

	      g_signal_emit_by_name (context, "commit", result_utf8);

	      result = TRUE;

	    }

	  g_free (result_utf8);

	}

    }

  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);

  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);

    }

  return;

}

static void

gtk_im_context_xim_focus_out (GtkIMContext *context)

{

  GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);

  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);

    }

  return;

}

static void

gtk_im_context_xim_set_cursor_location (GtkIMContext *context,

					GdkRectangle *area)

{

  GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);

  XIC ic = gtk_im_context_xim_get_ic (context_xim);

  XVaNestedList preedit_attr;

  XPoint          spot;

  if (!ic)

    return;

  spot.x = area->x;

  spot.y = area->y + area->height;

  preedit_attr = XVaCreateNestedList (0,

				      XNSpotLocation, &spot,

				      NULL);

  XSetICValues (ic,

		XNPreeditAttributes, preedit_attr,

		NULL);

  XFree(preedit_attr);

  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)

{

  GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);

  XIC ic = gtk_im_context_xim_get_ic (context_xim);

  gchar *result;

  /* restore conversion state after resetting ic later */

  XIMPreeditState preedit_state = XIMPreeditUnKnown;

  XVaNestedList preedit_attr;

  gboolean have_preedit_state = FALSE;

  if (!ic)

    return;

  if (context_xim->preedit_length == 0)

    return;

  preedit_attr = XVaCreateNestedList(0,

                                     XNPreeditState, &preedit_state,