Pileus Git - ~andy/gtk/blob - modules/input/gtkimcontextxim.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2000 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <config.h>
  21 #include "locale.h"
  22 #include <string.h>
  23 #include <stdlib.h>
  24
  25 #include "gtk/gtkintl.h"
  26 #include "gtk/gtklabel.h"
  27 #include "gtk/gtksignal.h"
  28 #include "gtk/gtkwindow.h"
  29 #include "gtkimcontextxim.h"
  30
  31 typedef struct _StatusWindow StatusWindow;
  32 typedef struct _GtkXIMInfo GtkXIMInfo;
  33
  34 struct _GtkIMContextXIM
  35 {
  36   GtkIMContext object;
  37
  38   GtkXIMInfo *im_info;
  39
  40   gchar *locale;
  41   gchar *mb_charset;
  42
  43   GdkWindow *client_window;
  44   GtkWidget *client_widget;
  45
  46   /* The status window for this input context; we claim the
  47    * status window when we are focused and have created an XIC
  48    */
  49   StatusWindow *status_window;
  50
  51   gint preedit_size;
  52   gint preedit_length;
  53   gunichar *preedit_chars;
  54   XIMFeedback *feedbacks;
  55
  56   gint preedit_cursor;
  57
  58   XIMCallback preedit_start_callback;
  59   XIMCallback preedit_done_callback;
  60   XIMCallback preedit_draw_callback;
  61   XIMCallback preedit_caret_callback;
  62
  63   XIMCallback status_start_callback;
  64   XIMCallback status_done_callback;
  65   XIMCallback status_draw_callback;
  66
  67   XIMCallback string_conversion_callback;
  68
  69   XIC ic;
  70
  71   guint filter_key_release : 1;
  72   guint use_preedit : 1;
  73   guint finalizing : 1;
  74   guint in_toplevel : 1;
  75   guint has_focus : 1;
  76 };
  77
  78 struct _GtkXIMInfo
  79 {
  80   GdkScreen *screen;
  81   XIM im;
  82   char *locale;
  83   XIMStyle preedit_style_setting;
  84   XIMStyle status_style_setting;
  85   XIMStyle style;
  86   GtkSettings *settings;
  87   gulong status_set;
  88   gulong preedit_set;
  89   XIMStyles *xim_styles;
  90   GSList *ics;
  91
  92   guint reconnecting :1;
  93   guint supports_string_conversion;
  94 };
  95
  96 /* A context status window; these are kept in the status_windows list. */
  97 struct _StatusWindow
  98 {
  99   GtkWidget *window;
 100
 101   /* Toplevel window to which the status window corresponds */
 102   GtkWidget *toplevel;
 103
 104   /* Currently focused GtkIMContextXIM for the toplevel, if any */
 105   GtkIMContextXIM *context;
 106 };
 107
 108 static void     gtk_im_context_xim_class_init         (GtkIMContextXIMClass  *class);
 109 static void     gtk_im_context_xim_init               (GtkIMContextXIM       *im_context_xim);
 110 static void     gtk_im_context_xim_finalize           (GObject               *obj);
 111 static void     gtk_im_context_xim_set_client_window  (GtkIMContext          *context,
 112                                                        GdkWindow             *client_window);
 113 static gboolean gtk_im_context_xim_filter_keypress    (GtkIMContext          *context,
 114                                                        GdkEventKey           *key);
 115 static void     gtk_im_context_xim_reset              (GtkIMContext          *context);
 116 static void     gtk_im_context_xim_focus_in           (GtkIMContext          *context);
 117 static void     gtk_im_context_xim_focus_out          (GtkIMContext          *context);
 118 static void     gtk_im_context_xim_set_cursor_location (GtkIMContext          *context,
 119                                                        GdkRectangle             *area);
 120 static void     gtk_im_context_xim_set_use_preedit    (GtkIMContext          *context,
 121                                                        gboolean               use_preedit);
 122 static void     gtk_im_context_xim_get_preedit_string (GtkIMContext          *context,
 123                                                        gchar                **str,
 124                                                        PangoAttrList        **attrs,
 125                                                        gint                  *cursor_pos);
 126
 127 static void reinitialize_ic      (GtkIMContextXIM *context_xim);
 128 static void set_ic_client_window (GtkIMContextXIM *context_xim,
 129                                   GdkWindow       *client_window);
 130
 131 static void setup_styles (GtkXIMInfo *info);
 132
 133 static void update_client_widget   (GtkIMContextXIM *context_xim);
 134 static void update_status_window   (GtkIMContextXIM *context_xim);
 135
 136 static StatusWindow *status_window_get      (GtkWidget    *toplevel);
 137 static void          status_window_free     (StatusWindow *status_window);
 138 static void          status_window_set_text (StatusWindow *status_window,
 139                                              const gchar  *text);
 140
 141 static void xim_destroy_callback   (XIM      xim,
 142                                     XPointer client_data,
 143                                     XPointer call_data);
 144
 145 static XIC       gtk_im_context_xim_get_ic            (GtkIMContextXIM *context_xim);
 146 static GObjectClass *parent_class;
 147
 148 GType gtk_type_im_context_xim = 0;
 149
 150 static GSList *open_ims = NULL;
 151
 152 /* List of status windows for different toplevels */
 153 static GSList *status_windows = NULL;
 154
 155 void
 156 gtk_im_context_xim_register_type (GTypeModule *type_module)
 157 {
 158   static const GTypeInfo im_context_xim_info =
 159   {
 160     sizeof (GtkIMContextXIMClass),
 161     (GBaseInitFunc) NULL,
 162     (GBaseFinalizeFunc) NULL,
 163     (GClassInitFunc) gtk_im_context_xim_class_init,
 164     NULL,           /* class_finalize */
 165     NULL,           /* class_data */
 166     sizeof (GtkIMContextXIM),
 167     0,
 168     (GInstanceInitFunc) gtk_im_context_xim_init,
 169   };
 170
 171   gtk_type_im_context_xim =
 172     g_type_module_register_type (type_module,
 173                                  GTK_TYPE_IM_CONTEXT,
 174                                  "GtkIMContextXIM",
 175                                  &im_context_xim_info, 0);
 176 }
 177
 178 #define PREEDIT_MASK (XIMPreeditCallbacks | XIMPreeditPosition | \
 179                       XIMPreeditArea | XIMPreeditNothing | XIMPreeditNone)
 180 #define STATUS_MASK (XIMStatusCallbacks | XIMStatusArea | \
 181                       XIMStatusNothing | XIMStatusNone)
 182 #define ALLOWED_MASK (XIMPreeditCallbacks | XIMPreeditNothing | XIMPreeditNone | \
 183                       XIMStatusCallbacks | XIMStatusNothing | XIMStatusNone)
 184
 185 static XIMStyle
 186 choose_better_style (XIMStyle style1, XIMStyle style2)
 187 {
 188   XIMStyle s1, s2, u;
 189
 190   if (style1 == 0) return style2;
 191   if (style2 == 0) return style1;
 192   if ((style1 & (PREEDIT_MASK | STATUS_MASK))
 193         == (style2 & (PREEDIT_MASK | STATUS_MASK)))
 194     return style1;
 195
 196   s1 = style1 & PREEDIT_MASK;
 197   s2 = style2 & PREEDIT_MASK;
 198   u = s1 | s2;
 199   if (s1 != s2) {
 200     if (u & XIMPreeditCallbacks)
 201       return (s1 == XIMPreeditCallbacks) ? style1 : style2;
 202     else if (u & XIMPreeditPosition)
 203       return (s1 == XIMPreeditPosition) ? style1 :style2;
 204     else if (u & XIMPreeditArea)
 205       return (s1 == XIMPreeditArea) ? style1 : style2;
 206     else if (u & XIMPreeditNothing)
 207       return (s1 == XIMPreeditNothing) ? style1 : style2;
 208     else if (u & XIMPreeditNone)
 209       return (s1 == XIMPreeditNone) ? style1 : style2;
 210   } else {
 211     s1 = style1 & STATUS_MASK;
 212     s2 = style2 & STATUS_MASK;
 213     u = s1 | s2;
 214     if (u & XIMStatusCallbacks)
 215       return (s1 == XIMStatusCallbacks) ? style1 : style2;
 216     else if (u & XIMStatusArea)
 217       return (s1 == XIMStatusArea) ? style1 : style2;
 218     else if (u & XIMStatusNothing)
 219       return (s1 == XIMStatusNothing) ? style1 : style2;
 220     else if (u & XIMStatusNone)
 221       return (s1 == XIMStatusNone) ? style1 : style2;
 222   }
 223   return 0; /* Get rid of stupid warning */
 224 }
 225
 226 static void
 227 reinitialize_all_ics (GtkXIMInfo *info)
 228 {
 229   GSList *tmp_list;
 230
 231   for (tmp_list = info->ics; tmp_list; tmp_list = tmp_list->next)
 232     reinitialize_ic (tmp_list->data);
 233 }
 234
 235 static void
 236 status_style_change (GtkXIMInfo *info)
 237 {
 238   GtkIMStatusStyle status_style;
 239
 240   g_object_get (info->settings,
 241                 "gtk-im-status-style", &status_style,
 242                 NULL);
 243   if (status_style == GTK_IM_STATUS_CALLBACK)
 244     info->status_style_setting = XIMStatusCallbacks;
 245   else if (status_style == GTK_IM_STATUS_NOTHING)
 246     info->status_style_setting = XIMStatusNothing;
 247   else if (status_style == GTK_IM_STATUS_NONE)
 248     info->status_style_setting = XIMStatusNone;
 249   else
 250     return;
 251
 252   setup_styles (info);
 253
 254   reinitialize_all_ics (info);
 255 }
 256
 257 static void
 258 preedit_style_change (GtkXIMInfo *info)
 259 {
 260   GtkIMPreeditStyle preedit_style;
 261   g_object_get (info->settings,
 262                 "gtk-im-preedit-style", &preedit_style,
 263                 NULL);
 264   if (preedit_style == GTK_IM_PREEDIT_CALLBACK)
 265     info->preedit_style_setting = XIMPreeditCallbacks;
 266   else if (preedit_style == GTK_IM_PREEDIT_NOTHING)
 267     info->preedit_style_setting = XIMPreeditNothing;
 268   else if (preedit_style == GTK_IM_PREEDIT_NONE)
 269     info->preedit_style_setting = XIMPreeditNone;
 270   else
 271     return;
 272
 273   setup_styles (info);
 274
 275   reinitialize_all_ics (info);
 276 }
 277
 278 static void
 279 setup_styles (GtkXIMInfo *info)
 280 {
 281   int i;
 282   unsigned long settings_preference;
 283   XIMStyles *xim_styles = info->xim_styles;
 284
 285   settings_preference = info->status_style_setting|info->preedit_style_setting;
 286   info->style = 0;
 287   if (xim_styles)
 288     {
 289       for (i = 0; i < xim_styles->count_styles; i++)
 290         if ((xim_styles->supported_styles[i] & ALLOWED_MASK) == xim_styles->supported_styles[i])
 291           {
 292             if (settings_preference == xim_styles->supported_styles[i])
 293               {
 294                 info->style = settings_preference;
 295                 break;
 296               }
 297             info->style = choose_better_style (info->style,
 298                                                xim_styles->supported_styles[i]);
 299           }
 300     }
 301   if (info->style == 0)
 302     info->style = XIMPreeditNothing | XIMStatusNothing;
 303 }
 304
 305 static void
 306 setup_im (GtkXIMInfo *info)
 307 {
 308   XIMValuesList *ic_values = NULL;
 309   XIMCallback im_destroy_callback;
 310
 311   if (info->im == NULL)
 312     return;
 313
 314   im_destroy_callback.client_data = (XPointer)info;
 315   im_destroy_callback.callback = (XIMProc)xim_destroy_callback;
 316   XSetIMValues (info->im,
 317                 XNDestroyCallback, &im_destroy_callback,
 318                 NULL);
 319
 320   XGetIMValues (info->im,
 321                 XNQueryInputStyle, &info->xim_styles,
 322                 XNQueryICValuesList, &ic_values,
 323                 NULL);
 324
 325   info->settings = gtk_settings_get_for_screen (info->screen);
 326
 327   if (!g_object_class_find_property (G_OBJECT_GET_CLASS (info->settings),
 328                                      "gtk-im-preedit-style"))
 329     gtk_settings_install_property (g_param_spec_enum ("gtk-im-preedit-style",
 330                                                       P_("IM Preedit style"),
 331                                                       P_("How to draw the input method preedit string"),
 332                                                       GTK_TYPE_IM_PREEDIT_STYLE,
 333                                                       GTK_IM_PREEDIT_CALLBACK,
 334                                                       G_PARAM_READWRITE));
 335
 336   if (!g_object_class_find_property (G_OBJECT_GET_CLASS (info->settings),
 337                                      "gtk-im-status-style"))
 338     gtk_settings_install_property (g_param_spec_enum ("gtk-im-status-style",
 339                                                       P_("IM Status style"),
 340                                                       P_("How to draw the input method statusbar"),
 341                                                       GTK_TYPE_IM_STATUS_STYLE,
 342                                                       GTK_IM_STATUS_CALLBACK,
 343                                                       G_PARAM_READWRITE));
 344
 345   info->status_set = g_signal_connect_swapped (info->settings,
 346                                                "notify::gtk-im-status-style",
 347                                                G_CALLBACK (status_style_change),
 348                                                info);
 349   info->preedit_set = g_signal_connect_swapped (info->settings,
 350                                                 "notify::gtk-im-preedit-style",
 351                                                 G_CALLBACK (preedit_style_change),
 352                                                 info);
 353
 354   info->supports_string_conversion = FALSE;
 355   if (ic_values)
 356     {
 357       int i;
 358
 359       for (i = 0; i < ic_values->count_values; i++)
 360         if (strcmp (ic_values->supported_values[i],
 361                     XNStringConversionCallback) == 0)
 362           {
 363             info->supports_string_conversion = TRUE;
 364             break;
 365           }
 366
 367 #if 0
 368       for (i = 0; i < ic_values->count_values; i++)
 369         g_print ("%s\n", ic_values->supported_values[i]);
 370       for (i = 0; i < xim_styles->count_styles; i++)
 371         g_print ("%#x\n", xim_styles->supported_styles[i]);
 372 #endif
 373
 374       XFree (ic_values);
 375     }
 376
 377   status_style_change (info);
 378   preedit_style_change (info);
 379 }
 380
 381 static void
 382 xim_info_display_closed (GdkDisplay *display,
 383                          gboolean    is_error,
 384                          GtkXIMInfo *info)
 385 {
 386   GSList *ics, *tmp_list;
 387
 388   open_ims = g_slist_remove (open_ims, info);
 389
 390   ics = info->ics;
 391   info->ics = NULL;
 392
 393   for (tmp_list = ics; tmp_list; tmp_list = tmp_list->next)
 394     set_ic_client_window (tmp_list->data, NULL);
 395
 396   g_slist_free (ics);
 397
 398   g_signal_handler_disconnect (info->settings, info->status_set);
 399   g_signal_handler_disconnect (info->settings, info->preedit_set);
 400
 401   XFree (info->xim_styles->supported_styles);
 402   XFree (info->xim_styles);
 403   g_free (info->locale);
 404
 405   if (info->im)
 406     XCloseIM (info->im);
 407
 408   g_free (info);
 409 }
 410
 411 static void
 412 xim_instantiate_callback (Display *display, XPointer client_data,
 413                           XPointer call_data)
 414 {
 415   GtkXIMInfo *info = (GtkXIMInfo*)client_data;
 416   XIM im = NULL;
 417
 418   im = XOpenIM (display, NULL, NULL, NULL);
 419
 420   if (!im)
 421     return;
 422
 423   info->im = im;
 424   setup_im (info);
 425
 426   XUnregisterIMInstantiateCallback (display, NULL, NULL, NULL,
 427                                     xim_instantiate_callback,
 428                                     (XPointer)info);
 429   info->reconnecting = FALSE;
 430 }
 431
 432 /* initialize info->im */
 433 static void
 434 xim_info_try_im (GtkXIMInfo *info)
 435 {
 436   GdkScreen *screen = info->screen;
 437   GdkDisplay *display = gdk_screen_get_display (screen);
 438
 439   g_assert (info->im == NULL);
 440   if (info->reconnecting)
 441     return;
 442
 443   if (XSupportsLocale ())
 444     {
 445       if (!XSetLocaleModifiers (""))
 446         g_warning ("Unable to set locale modifiers with XSetLocaleModifiers()");
 447       info->im = XOpenIM (GDK_DISPLAY_XDISPLAY (display), NULL, NULL, NULL);
 448       if (!info->im)
 449         {
 450           XRegisterIMInstantiateCallback (GDK_DISPLAY_XDISPLAY(display),
 451                                           NULL, NULL, NULL,
 452                                           xim_instantiate_callback,
 453                                           (XPointer)info);
 454           info->reconnecting = TRUE;
 455           return;
 456         }
 457       setup_im (info);
 458
 459       g_signal_connect (display, "closed",
 460                         G_CALLBACK (xim_info_display_closed), info);
 461     }
 462 }
 463
 464 static void
 465 xim_destroy_callback (XIM      xim,
 466                       XPointer client_data,
 467                       XPointer call_data)
 468 {
 469   GtkXIMInfo *info = (GtkXIMInfo*)client_data;
 470
 471   info->im = NULL;
 472
 473   g_signal_handler_disconnect (info->settings, info->status_set);
 474   g_signal_handler_disconnect (info->settings, info->preedit_set);
 475
 476   reinitialize_all_ics (info);
 477   xim_info_try_im (info);
 478   return;
 479 }
 480
 481 static GtkXIMInfo *
 482 get_im (GdkWindow *client_window,
 483         const char *locale)
 484 {
 485   GSList *tmp_list;
 486   GtkXIMInfo *info;
 487   GdkScreen *screen = gdk_drawable_get_screen (client_window);
 488
 489   info = NULL;
 490   tmp_list = open_ims;
 491   while (tmp_list)
 492     {
 493       GtkXIMInfo *tmp_info = tmp_list->data;
 494       if (tmp_info->screen == screen &&
 495           strcmp (tmp_info->locale, locale) == 0)
 496         {
 497           if (tmp_info->im)
 498             {
 499               return tmp_info;
 500             }
 501           else
 502             {
 503               tmp_info = tmp_info;
 504               break;
 505             }
 506         }
 507       tmp_list = tmp_list->next;
 508     }
 509
 510   if (info == NULL)
 511     {
 512       info = g_new (GtkXIMInfo, 1);
 513       open_ims = g_slist_prepend (open_ims, info);
 514
 515       info->screen = screen;
 516       info->locale = g_strdup (locale);
 517       info->xim_styles = NULL;
 518       info->preedit_style_setting = 0;
 519       info->status_style_setting = 0;
 520       info->settings = NULL;
 521       info->preedit_set = 0;
 522       info->status_set = 0;
 523       info->ics = NULL;
 524       info->reconnecting = FALSE;
 525       info->im = NULL;
 526     }
 527
 528   xim_info_try_im (info);
 529   return info;
 530 }
 531
 532 static void
 533 gtk_im_context_xim_class_init (GtkIMContextXIMClass *class)
 534 {
 535   GtkIMContextClass *im_context_class = GTK_IM_CONTEXT_CLASS (class);
 536   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 537
 538   parent_class = g_type_class_peek_parent (class);
 539
 540   im_context_class->set_client_window = gtk_im_context_xim_set_client_window;
 541   im_context_class->filter_keypress = gtk_im_context_xim_filter_keypress;
 542   im_context_class->reset = gtk_im_context_xim_reset;
 543   im_context_class->get_preedit_string = gtk_im_context_xim_get_preedit_string;
 544   im_context_class->focus_in = gtk_im_context_xim_focus_in;
 545   im_context_class->focus_out = gtk_im_context_xim_focus_out;
 546   im_context_class->set_cursor_location = gtk_im_context_xim_set_cursor_location;
 547   im_context_class->set_use_preedit = gtk_im_context_xim_set_use_preedit;
 548   gobject_class->finalize = gtk_im_context_xim_finalize;
 549 }
 550
 551 static void
 552 gtk_im_context_xim_init (GtkIMContextXIM *im_context_xim)
 553 {
 554   im_context_xim->use_preedit = TRUE;
 555   im_context_xim->filter_key_release = FALSE;
 556   im_context_xim->finalizing = FALSE;
 557   im_context_xim->has_focus = FALSE;
 558   im_context_xim->in_toplevel = FALSE;
 559 }
 560
 561 static void
 562 gtk_im_context_xim_finalize (GObject *obj)
 563 {
 564   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (obj);
 565
 566   context_xim->finalizing = TRUE;
 567
 568   if (context_xim->im_info && !context_xim->im_info->ics->next)
 569     {
 570       if (context_xim->im_info->reconnecting)
 571         {
 572           GdkDisplay *display;
 573
 574           display = gdk_screen_get_display (context_xim->im_info->screen);
 575           XUnregisterIMInstantiateCallback (GDK_DISPLAY_XDISPLAY (display),
 576                                             NULL, NULL, NULL,
 577                                             xim_instantiate_callback,
 578                                             (XPointer)context_xim->im_info);
 579         }
 580       else
 581         {
 582           XIMCallback im_destroy_callback;
 583
 584           im_destroy_callback.client_data = NULL;
 585           im_destroy_callback.callback = NULL;
 586           XSetIMValues (context_xim->im_info->im,
 587                         XNDestroyCallback, &im_destroy_callback,
 588                         NULL);
 589         }
 590     }
 591
 592   set_ic_client_window (context_xim, NULL);
 593
 594   g_free (context_xim->locale);
 595   g_free (context_xim->mb_charset);
 596
 597   G_OBJECT_CLASS (parent_class)->finalize (obj);
 598 }
 599
 600 static void
 601 reinitialize_ic (GtkIMContextXIM *context_xim)
 602 {
 603   if (context_xim->ic)
 604     {
 605       XDestroyIC (context_xim->ic);
 606       context_xim->ic = NULL;
 607       update_status_window (context_xim);
 608
 609       if (context_xim->preedit_length)
 610         {
 611           context_xim->preedit_length = 0;
 612           if (!context_xim->finalizing)
 613             g_signal_emit_by_name (context_xim, "preedit_changed");
 614         }
 615     }
 616   /*
 617      reset filter_key_release flag, otherwise keystrokes will be doubled
 618      until reconnecting to XIM.
 619   */
 620   context_xim->filter_key_release = FALSE;
 621 }
 622
 623 static void
 624 set_ic_client_window (GtkIMContextXIM *context_xim,
 625                       GdkWindow       *client_window)
 626 {
 627   reinitialize_ic (context_xim);
 628   if (context_xim->client_window)
 629     {
 630       context_xim->im_info->ics = g_slist_remove (context_xim->im_info->ics, context_xim);
 631       context_xim->im_info = NULL;
 632     }
 633
 634   context_xim->client_window = client_window;
 635
 636   if (context_xim->client_window)
 637     {
 638       context_xim->im_info = get_im (context_xim->client_window, context_xim->locale);
 639       context_xim->im_info->ics = g_slist_prepend (context_xim->im_info->ics, context_xim);
 640     }
 641
 642   update_client_widget (context_xim);
 643 }
 644
 645 static void
 646 gtk_im_context_xim_set_client_window (GtkIMContext          *context,
 647                                       GdkWindow             *client_window)
 648 {
 649   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
 650
 651   set_ic_client_window (context_xim, client_window);
 652 }
 653
 654 GtkIMContext *
 655 gtk_im_context_xim_new (void)
 656 {
 657   GtkIMContextXIM *result;
 658   const gchar *charset;
 659
 660   result = g_object_new (GTK_TYPE_IM_CONTEXT_XIM, NULL);
 661
 662   result->locale = g_strdup (setlocale (LC_CTYPE, NULL));
 663
 664   g_get_charset (&charset);
 665   result->mb_charset = g_strdup (charset);
 666
 667   return GTK_IM_CONTEXT (result);
 668 }
 669
 670 static char *
 671 mb_to_utf8 (GtkIMContextXIM *context_xim,
 672             const char      *str)
 673 {
 674   GError *error = NULL;
 675   gchar *result;
 676
 677   if (strcmp (context_xim->mb_charset, "UTF-8") == 0)
 678     result = g_strdup (str);
 679   else
 680     {
 681       result = g_convert (str, -1,
 682                           "UTF-8", context_xim->mb_charset,
 683                           NULL, NULL, &error);
 684       if (!result)
 685         {
 686           g_warning ("Error converting text from IM to UTF-8: %s\n", error->message);
 687           g_error_free (error);
 688         }
 689     }
 690
 691   return result;
 692 }
 693
 694 static gboolean
 695 gtk_im_context_xim_filter_keypress (GtkIMContext *context,
 696                                     GdkEventKey  *event)
 697 {
 698   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
 699   XIC ic = gtk_im_context_xim_get_ic (context_xim);
 700   gchar static_buffer[256];
 701   gchar *buffer = static_buffer;
 702   gint buffer_size = sizeof(static_buffer) - 1;
 703   gint num_bytes = 0;
 704   KeySym keysym;
 705   Status status;
 706   gboolean result = FALSE;
 707   GdkWindow *root_window = gdk_screen_get_root_window (gdk_drawable_get_screen (event->window));
 708
 709   XKeyPressedEvent xevent;
 710
 711   if (event->type == GDK_KEY_RELEASE && !context_xim->filter_key_release)
 712     return FALSE;
 713
 714   xevent.type = (event->type == GDK_KEY_PRESS) ? KeyPress : KeyRelease;
 715   xevent.serial = 0;            /* hope it doesn't matter */
 716   xevent.send_event = event->send_event;
 717   xevent.display = GDK_DRAWABLE_XDISPLAY (event->window);
 718   xevent.window = GDK_DRAWABLE_XID (event->window);
 719   xevent.root = GDK_DRAWABLE_XID (root_window);
 720   xevent.subwindow = xevent.window;
 721   xevent.time = event->time;
 722   xevent.x = xevent.x_root = 0;
 723   xevent.y = xevent.y_root = 0;
 724   xevent.state = event->state;
 725   xevent.keycode = event->hardware_keycode;
 726   xevent.same_screen = True;
 727
 728   if (XFilterEvent ((XEvent *)&xevent, GDK_DRAWABLE_XID (context_xim->client_window)))
 729     return TRUE;
 730
 731  again:
 732   if (ic)
 733     num_bytes = XmbLookupString (ic, &xevent, buffer, buffer_size, &keysym, &status);
 734   else
 735     {
 736       num_bytes = XLookupString (&xevent, buffer, buffer_size, &keysym, NULL);
 737       status = XLookupBoth;
 738     }
 739
 740   if (status == XBufferOverflow)
 741     {
 742       buffer_size = num_bytes;
 743       if (buffer != static_buffer)
 744         g_free (buffer);
 745       buffer = g_malloc (num_bytes + 1);
 746       goto again;
 747     }
 748
 749   /* I don't know how we should properly handle XLookupKeysym or XLookupBoth
 750    * here ... do input methods actually change the keysym? we can't really
 751    * feed it back to accelerator processing at this point...
 752    */
 753   if (status == XLookupChars || status == XLookupBoth)
 754     {
 755       char *result_utf8;
 756
 757       buffer[num_bytes] = '\0';
 758
 759       result_utf8 = mb_to_utf8 (context_xim, buffer);
 760       if (result_utf8)
 761         {
 762           if ((guchar)result_utf8[0] >= 0x20 &&
 763               result_utf8[0] != 0x7f) /* Some IM have a nasty habit of converting
 764                                        * control characters into strings
 765                                        */
 766             {
 767               g_signal_emit_by_name (context, "commit", result_utf8);
 768               result = TRUE;
 769             }
 770
 771           g_free (result_utf8);
 772         }
 773     }
 774
 775   if (buffer != static_buffer)
 776     g_free (buffer);
 777
 778   return result;
 779 }
 780
 781 static void
 782 gtk_im_context_xim_focus_in (GtkIMContext *context)
 783 {
 784   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
 785
 786   if (!context_xim->has_focus)
 787     {
 788       XIC ic = gtk_im_context_xim_get_ic (context_xim);
 789
 790       context_xim->has_focus = TRUE;
 791       update_status_window (context_xim);
 792
 793       if (ic)
 794         XSetICFocus (ic);
 795     }
 796
 797   return;
 798 }
 799
 800 static void
 801 gtk_im_context_xim_focus_out (GtkIMContext *context)
 802 {
 803   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
 804
 805   if (context_xim->has_focus)
 806     {
 807       XIC ic = gtk_im_context_xim_get_ic (context_xim);
 808
 809       context_xim->has_focus = FALSE;
 810       update_status_window (context_xim);
 811
 812       if (ic)
 813         XUnsetICFocus (ic);
 814     }
 815
 816   return;
 817 }
 818
 819 static void
 820 gtk_im_context_xim_set_cursor_location (GtkIMContext *context,
 821                                         GdkRectangle *area)
 822 {
 823   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
 824   XIC ic = gtk_im_context_xim_get_ic (context_xim);
 825
 826   XVaNestedList preedit_attr;
 827   XPoint          spot;
 828
 829   if (!ic)
 830     return;
 831
 832   spot.x = area->x;
 833   spot.y = area->y;
 834
 835   preedit_attr = XVaCreateNestedList (0,
 836                                       XNSpotLocation, &spot,
 837                                       NULL);
 838   XSetICValues (ic,
 839                 XNPreeditAttributes, preedit_attr,
 840                 NULL);
 841   XFree(preedit_attr);
 842
 843   return;
 844 }
 845
 846 static void
 847 gtk_im_context_xim_set_use_preedit (GtkIMContext *context,
 848                                     gboolean      use_preedit)
 849 {
 850   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
 851
 852   use_preedit = use_preedit != FALSE;
 853
 854   if (context_xim->use_preedit != use_preedit)
 855     {
 856       context_xim->use_preedit = use_preedit;
 857       reinitialize_ic (context_xim);
 858     }
 859
 860   return;
 861 }
 862
 863 static void
 864 gtk_im_context_xim_reset (GtkIMContext *context)
 865 {
 866   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
 867   XIC ic = gtk_im_context_xim_get_ic (context_xim);
 868   gchar *result;
 869
 870   /* restore conversion state after resetting ic later */
 871   XIMPreeditState preedit_state = XIMPreeditUnKnown;
 872   XVaNestedList preedit_attr;
 873   gboolean have_preedit_state = FALSE;
 874
 875   if (!ic)
 876     return;
 877
 878
 879   if (context_xim->preedit_length == 0)
 880     return;
 881
 882   preedit_attr = XVaCreateNestedList(0,
 883                                      XNPreeditState, &preedit_state,
 884                                      NULL);
 885   if (!XGetICValues(ic,
 886                     XNPreeditAttributes, preedit_attr,
 887                     NULL))
 888     have_preedit_state = TRUE;
 889
 890   XFree(preedit_attr);
 891
 892   result = XmbResetIC (ic);
 893
 894   preedit_attr = XVaCreateNestedList(0,
 895                                      XNPreeditState, preedit_state,
 896                                      NULL);
 897   if (have_preedit_state)
 898     XSetICValues(ic,
 899                  XNPreeditAttributes, preedit_attr,
 900                  NULL);
 901
 902   XFree(preedit_attr);
 903
 904   if (result)
 905     {
 906       char *result_utf8 = mb_to_utf8 (context_xim, result);
 907       if (result_utf8)
 908         {
 909           g_signal_emit_by_name (context, "commit", result_utf8);
 910           g_free (result_utf8);
 911         }
 912     }
 913
 914   if (context_xim->preedit_length)
 915     {
 916       context_xim->preedit_length = 0;
 917       g_signal_emit_by_name (context, "preedit_changed");
 918     }
 919
 920   XFree (result);
 921 }
 922
 923 /* Mask of feedback bits that we render
 924  */
 925 #define FEEDBACK_MASK (XIMReverse | XIMUnderline)
 926
 927 static void
 928 add_feedback_attr (PangoAttrList *attrs,
 929                    const gchar   *str,
 930                    XIMFeedback    feedback,
 931                    gint           start_pos,
 932                    gint           end_pos)
 933 {
 934   PangoAttribute *attr;
 935
 936   gint start_index = g_utf8_offset_to_pointer (str, start_pos) - str;
 937   gint end_index = g_utf8_offset_to_pointer (str, end_pos) - str;
 938
 939   if (feedback & XIMUnderline)
 940     {
 941       attr = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
 942       attr->start_index = start_index;
 943       attr->end_index = end_index;
 944
 945       pango_attr_list_change (attrs, attr);
 946     }
 947
 948   if (feedback & XIMReverse)
 949     {
 950       attr = pango_attr_foreground_new (0xffff, 0xffff, 0xffff);
 951       attr->start_index = start_index;
 952       attr->end_index = end_index;
 953
 954       pango_attr_list_change (attrs, attr);
 955
 956       attr = pango_attr_background_new (0, 0, 0);
 957       attr->start_index = start_index;
 958       attr->end_index = end_index;
 959
 960       pango_attr_list_change (attrs, attr);
 961     }
 962
 963   if (feedback & ~FEEDBACK_MASK)
 964     g_warning ("Unrendered feedback style: %#lx", feedback & ~FEEDBACK_MASK);
 965 }
 966
 967 static void
 968 gtk_im_context_xim_get_preedit_string (GtkIMContext   *context,
 969                                        gchar         **str,
 970                                        PangoAttrList **attrs,
 971                                        gint           *cursor_pos)
 972 {
 973   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
 974   gchar *utf8 = g_ucs4_to_utf8 (context_xim->preedit_chars, context_xim->preedit_length, NULL, NULL, NULL);
 975
 976   if (attrs)
 977     {
 978       int i;
 979       XIMFeedback last_feedback = 0;
 980       gint start = -1;
 981
 982       *attrs = pango_attr_list_new ();
 983
 984       for (i = 0; i < context_xim->preedit_length; i++)
 985         {
 986           XIMFeedback new_feedback = context_xim->feedbacks[i] & FEEDBACK_MASK;
 987           if (new_feedback != last_feedback)
 988             {
 989               if (start >= 0)
 990                 add_feedback_attr (*attrs, utf8, last_feedback, start, i);
 991
 992               last_feedback = new_feedback;
 993               start = i;
 994             }
 995         }
 996
 997       if (start >= 0)
 998         add_feedback_attr (*attrs, utf8, last_feedback, start, i);
 999     }
1000
1001   if (str)
1002     *str = utf8;
1003   else
1004     g_free (utf8);
1005
1006   if (cursor_pos)
1007     *cursor_pos = context_xim->preedit_cursor;
1008 }
1009
1010 static int
1011 preedit_start_callback (XIC      xic,
1012                         XPointer client_data,
1013                         XPointer call_data)
1014 {
1015   GtkIMContext *context = GTK_IM_CONTEXT (client_data);
1016   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
1017
1018   if (!context_xim->finalizing)
1019     g_signal_emit_by_name (context, "preedit_start");
1020
1021   return -1;                    /* No length limit */
1022 }
1023
1024 static void
1025 preedit_done_callback (XIC      xic,
1026                      XPointer client_data,
1027                      XPointer call_data)
1028 {
1029   GtkIMContext *context = GTK_IM_CONTEXT (client_data);
1030   GtkIMContextXIM *context_xim = GTK_IM_CONTEXT_XIM (context);
1031
1032   if (context_xim->preedit_length)
1033     {
1034       context_xim->preedit_length = 0;
1035       if (!context_xim->finalizing)
1036         g_signal_emit_by_name (context_xim, "preedit_changed");
1037     }
1038
1039   if (!context_xim->finalizing)
1040     g_signal_emit_by_name (context, "preedit_end");
1041 }
1042
1043 static gint
1044 xim_text_to_utf8 (GtkIMContextXIM *context, XIMText *xim_text, gchar **text)
1045 {
1046   gint text_length = 0;
1047   GError *error = NULL;
1048   gchar *result = NULL;
1049
1050   if (xim_text && xim_text->string.multi_byte)
1051     {
1052       if (xim_text->encoding_is_wchar)
1053         {
1054           g_warning ("Wide character return from Xlib not currently supported");
1055           *text = NULL;
1056           return 0;
1057         }
1058
1059       if (strcmp (context->mb_charset, "UTF-8") == 0)
1060         result = g_strdup (xim_text->string.multi_byte);
1061       else
1062         result = g_convert (xim_text->string.multi_byte,
1063                             -1,
1064                             "UTF-8",
1065                             context->mb_charset,
1066                             NULL, NULL, &error);
1067
1068       if (result)
1069         {
1070           text_length = g_utf8_strlen (result, -1);
1071
1072           if (text_length != xim_text->length)
1073             {
1074               g_warning ("Size mismatch when converting text from input method: supplied length = %d\n, result length = %d", xim_text->length, text_length);
1075             }
1076         }
1077       else
1078         {
1079           g_warning ("Error converting text from IM to UCS-4: %s", error->message);
1080           g_error_free (error);
1081
1082           *text = NULL;
1083           return 0;
1084         }
1085
1086       *text = result;
1087       return text_length;
1088     }
1089   else
1090     {
1091       *text = NULL;
1092       return 0;
1093     }
1094 }
1095
1096 static void
1097 preedit_draw_callback (XIC                           xic,
1098                        XPointer                      client_data,
1099                        XIMPreeditDrawCallbackStruct *call_data)
1100 {
1101   GtkIMContextXIM *context = GTK_IM_CONTEXT_XIM (client_data);
1102
1103   XIMText *new_xim_text = call_data->text;
1104   gint new_text_length;
1105   gunichar *new_text = NULL;
1106   gint i;
1107   gint diff;
1108   gint new_length;
1109   gchar *tmp;
1110
1111   gint chg_first = CLAMP (call_data->chg_first, 0, context->preedit_length);
1112   gint chg_length = CLAMP (call_data->chg_length, 0, context->preedit_length - chg_first);
1113
1114   context->preedit_cursor = call_data->caret;
1115
1116   if (chg_first != call_data->chg_first || chg_length != call_data->chg_length)
1117     g_warning ("Invalid change to preedit string, first=%d length=%d (orig length == %d)",
1118                call_data->chg_first, call_data->chg_length, context->preedit_length);
1119
1120   new_text_length = xim_text_to_utf8 (context, new_xim_text, &tmp);
1121   if (tmp)
1122     {
1123       new_text = g_utf8_to_ucs4_fast (tmp, -1, NULL);
1124       g_free (tmp);
1125     }
1126
1127   diff = new_text_length - chg_length;
1128   new_length = context->preedit_length + diff;
1129
1130   if (new_length > context->preedit_size)
1131     {
1132       context->preedit_size = new_length;
1133       context->preedit_chars = g_renew (gunichar, context->preedit_chars, new_length);
1134       context->feedbacks = g_renew (XIMFeedback, context->feedbacks, new_length);
1135     }
1136
1137   if (diff < 0)
1138     {
1139       for (i = chg_first + chg_length ; i < context->preedit_length; i++)
1140         {
1141           context->preedit_chars[i + diff] = context->preedit_chars[i];
1142           context->feedbacks[i + diff] = context->feedbacks[i];
1143         }
1144     }
1145   else
1146     {
1147       for (i = context->preedit_length - 1; i >= chg_first + chg_length ; i--)
1148         {
1149           context->preedit_chars[i + diff] = context->preedit_chars[i];
1150           context->feedbacks[i + diff] = context->feedbacks[i];
1151         }
1152     }
1153
1154   for (i = 0; i < new_text_length; i++)
1155     {
1156       context->preedit_chars[chg_first + i] = new_text[i];
1157       context->feedbacks[chg_first + i] = new_xim_text->feedback[i];
1158     }
1159
1160   context->preedit_length += diff;
1161
1162   if (new_text)
1163     g_free (new_text);
1164
1165   if (!context->finalizing)
1166     g_signal_emit_by_name (context, "preedit_changed");
1167 }
1168
1169
1170 static void
1171 preedit_caret_callback (XIC                            xic,
1172                         XPointer                       client_data,
1173                         XIMPreeditCaretCallbackStruct *call_data)
1174 {
1175   GtkIMContextXIM *context = GTK_IM_CONTEXT_XIM (client_data);
1176
1177   if (call_data->direction == XIMAbsolutePosition)
1178     {
1179       context->preedit_cursor = call_data->position;
1180       if (!context->finalizing)
1181         g_signal_emit_by_name (context, "preedit_changed");
1182     }
1183   else
1184     {
1185       g_warning ("Caret movement command: %d %d %d not supported",
1186                  call_data->position, call_data->direction, call_data->style);
1187     }
1188 }
1189
1190 static void
1191 status_start_callback (XIC      xic,
1192                        XPointer client_data,
1193                        XPointer call_data)
1194 {
1195   return;
1196 }
1197
1198 static void
1199 status_done_callback (XIC      xic,
1200                       XPointer client_data,
1201                       XPointer call_data)
1202 {
1203   return;
1204 }
1205
1206 static void
1207 status_draw_callback (XIC      xic,
1208                       XPointer client_data,
1209                       XIMStatusDrawCallbackStruct *call_data)
1210 {
1211   GtkIMContextXIM *context = GTK_IM_CONTEXT_XIM (client_data);
1212
1213   if (call_data->type == XIMTextType)
1214     {
1215       gchar *text;
1216       xim_text_to_utf8 (context, call_data->data.text, &text);
1217
1218       if (context->status_window)
1219         status_window_set_text (context->status_window, text ? text : "");
1220     }
1221   else                          /* bitmap */
1222     {
1223       g_print ("Status drawn with bitmap - id = %#lx\n", call_data->data.bitmap);
1224     }
1225 }
1226
1227 static void
1228 string_conversion_callback (XIC xic, XPointer client_data, XPointer call_data)
1229 {
1230   GtkIMContextXIM *context_xim;
1231   XIMStringConversionCallbackStruct *conv_data;
1232   gchar *surrounding;
1233   gint  cursor_index;
1234
1235   context_xim = (GtkIMContextXIM *)client_data;
1236   conv_data = (XIMStringConversionCallbackStruct *)call_data;
1237
1238   if (gtk_im_context_get_surrounding ((GtkIMContext *)context_xim,
1239                                       &surrounding, &cursor_index))
1240     {
1241       gchar *text = NULL;
1242       gsize text_len = 0;
1243       gint  subst_offset = 0, subst_nchars = 0;
1244       gint  i;
1245       gchar *p = surrounding + cursor_index, *q;
1246       gshort position = (gshort)conv_data->position;
1247
1248       if (position > 0)
1249         {
1250           for (i = position; i > 0 && *p; --i)
1251             p = g_utf8_next_char (p);
1252           if (i > 0)
1253             return;
1254         }
1255       /* According to X11R6.4 Xlib - C Library Reference Manual
1256        * section 13.5.7.3 String Conversion Callback,
1257        * XIMStringConversionPosition is starting position _relative_
1258        * to current client's cursor position. So it should be able
1259        * to be negative, or referring to a position before the cursor
1260        * would be impossible. But current X protocol defines this as
1261        * unsigned short. So, compiler may warn about the value range
1262        * here. We hope the X protocol is fixed soon.
1263        */
1264       else if (position < 0)
1265         {
1266           for (i = position; i < 0 && p > surrounding; ++i)
1267             p = g_utf8_prev_char (p);
1268           if (i < 0)
1269             return;
1270         }
1271
1272       switch (conv_data->direction)
1273         {
1274         case XIMForwardChar:
1275           for (i = conv_data->factor, q = p; i > 0 && *q; --i)
1276             q = g_utf8_next_char (q);
1277           if (i > 0)
1278             break;
1279           text = g_locale_from_utf8 (p, q - p, NULL, &text_len, NULL);
1280           subst_offset = position;
1281           subst_nchars = conv_data->factor;
1282           break;
1283
1284         case XIMBackwardChar:
1285           for (i = conv_data->factor, q = p; i > 0 && q > surrounding; --i)
1286             q = g_utf8_prev_char (q);
1287           if (i > 0)
1288             break;
1289           text = g_locale_from_utf8 (q, p - q, NULL, &text_len, NULL);
1290           subst_offset = position - conv_data->factor;
1291           subst_nchars = conv_data->factor;
1292           break;
1293
1294         case XIMForwardWord:
1295         case XIMBackwardWord:
1296         case XIMCaretUp:
1297         case XIMCaretDown:
1298         case XIMNextLine:
1299         case XIMPreviousLine:
1300         case XIMLineStart:
1301         case XIMLineEnd:
1302         case XIMAbsolutePosition:
1303         case XIMDontChange:
1304         default:
1305           break;
1306         }
1307       /* block out any failure happenning to "text", including conversion */
1308       if (text)
1309         {
1310           conv_data->text = (XIMStringConversionText *)
1311                               malloc (sizeof (XIMStringConversionText));
1312           if (conv_data->text)
1313             {
1314               conv_data->text->length = text_len;
1315               conv_data->text->feedback = NULL;
1316               conv_data->text->encoding_is_wchar = False;
1317               conv_data->text->string.mbs = (char *)malloc (text_len);
1318               if (conv_data->text->string.mbs)
1319                 memcpy (conv_data->text->string.mbs, text, text_len);
1320               else
1321                 {
1322                   free (conv_data->text);
1323                   conv_data->text = NULL;
1324                 }
1325             }
1326
1327           g_free (text);
1328         }
1329       if (conv_data->operation == XIMStringConversionSubstitution
1330           && subst_nchars > 0)
1331         {
1332           gtk_im_context_delete_surrounding ((GtkIMContext *)context_xim,
1333                                             subst_offset, subst_nchars);
1334         }
1335
1336       g_free (surrounding);
1337     }
1338 }
1339
1340
1341 static XVaNestedList
1342 set_preedit_callback (GtkIMContextXIM *context_xim)
1343 {
1344   context_xim->preedit_start_callback.client_data = (XPointer)context_xim;
1345   context_xim->preedit_start_callback.callback = (XIMProc)preedit_start_callback;
1346   context_xim->preedit_done_callback.client_data = (XPointer)context_xim;
1347   context_xim->preedit_done_callback.callback = (XIMProc)preedit_done_callback;
1348   context_xim->preedit_draw_callback.client_data = (XPointer)context_xim;
1349   context_xim->preedit_draw_callback.callback = (XIMProc)preedit_draw_callback;
1350   context_xim->preedit_caret_callback.client_data = (XPointer)context_xim;
1351   context_xim->preedit_caret_callback.callback = (XIMProc)preedit_caret_callback;
1352   return XVaCreateNestedList (0,
1353                               XNPreeditStartCallback, &context_xim->preedit_start_callback,
1354                               XNPreeditDoneCallback, &context_xim->preedit_done_callback,
1355                               XNPreeditDrawCallback, &context_xim->preedit_draw_callback,
1356                               XNPreeditCaretCallback, &context_xim->preedit_caret_callback,
1357                               NULL);
1358 }
1359
1360 static XVaNestedList
1361 set_status_callback (GtkIMContextXIM *context_xim)
1362 {
1363   context_xim->status_start_callback.client_data = (XPointer)context_xim;
1364   context_xim->status_start_callback.callback = (XIMProc)status_start_callback;
1365   context_xim->status_done_callback.client_data = (XPointer)context_xim;
1366   context_xim->status_done_callback.callback = (XIMProc)status_done_callback;
1367   context_xim->status_draw_callback.client_data = (XPointer)context_xim;
1368   context_xim->status_draw_callback.callback = (XIMProc)status_draw_callback;
1369
1370   return XVaCreateNestedList (0,
1371                               XNStatusStartCallback, &context_xim->status_start_callback,
1372                               XNStatusDoneCallback, &context_xim->status_done_callback,
1373                               XNStatusDrawCallback, &context_xim->status_draw_callback,
1374                               NULL);
1375 }
1376
1377
1378 static void
1379 set_string_conversion_callback (GtkIMContextXIM *context_xim, XIC xic)
1380 {
1381   if (!context_xim->im_info->supports_string_conversion)
1382     return;
1383
1384   context_xim->string_conversion_callback.client_data = (XPointer)context_xim;
1385   context_xim->string_conversion_callback.callback = (XIMProc)string_conversion_callback;
1386
1387   XSetICValues (xic,
1388                 XNStringConversionCallback,
1389                 (XPointer)&context_xim->string_conversion_callback,
1390                 NULL);
1391 }
1392
1393 static XIC
1394 gtk_im_context_xim_get_ic (GtkIMContextXIM *context_xim)
1395 {
1396   if (context_xim->im_info == NULL || context_xim->im_info->im == NULL)
1397     return NULL;
1398
1399   if (!context_xim->ic)
1400     {
1401       const char *name1 = NULL;
1402       XVaNestedList list1 = NULL;
1403       const char *name2 = NULL;
1404       XVaNestedList list2 = NULL;
1405       XIMStyle im_style = 0;
1406       XIC xic = NULL;
1407
1408       if (context_xim->use_preedit &&
1409           (context_xim->im_info->style & PREEDIT_MASK) == XIMPreeditCallbacks)
1410         {
1411           im_style |= XIMPreeditCallbacks;
1412           name1 = XNPreeditAttributes;
1413           list1 = set_preedit_callback (context_xim);
1414         }
1415       else if ((context_xim->im_info->style & PREEDIT_MASK) == XIMPreeditNone)
1416         im_style |= XIMPreeditNone;
1417       else
1418         im_style |= XIMPreeditNothing;
1419
1420       if ((context_xim->im_info->style & STATUS_MASK) == XIMStatusCallbacks)
1421         {
1422           im_style |= XIMStatusCallbacks;
1423           if (name1 == NULL)
1424             {
1425               name1 = XNStatusAttributes;
1426               list1 = set_status_callback (context_xim);
1427             }
1428           else
1429             {
1430               name2 = XNStatusAttributes;
1431               list2 = set_status_callback (context_xim);
1432             }
1433         }
1434       else if ((context_xim->im_info->style & STATUS_MASK) == XIMStatusNone)
1435         im_style |= XIMStatusNone;
1436       else
1437         im_style |= XIMStatusNothing;
1438
1439       xic = XCreateIC (context_xim->im_info->im,
1440                        XNInputStyle, im_style,
1441                        XNClientWindow, GDK_DRAWABLE_XID (context_xim->client_window),
1442                        name1, list1,
1443                        name2, list2,
1444                        NULL);
1445       if (list1)
1446         XFree (list1);
1447       if (list2)
1448         XFree (list2);
1449
1450       if (xic)
1451         {
1452           /* Don't filter key released events with XFilterEvents unless
1453            * input methods ask for. This is a workaround for Solaris input
1454            * method bug in C and European locales. It doubles each key
1455            * stroke if both key pressed and released events are filtered.
1456            * (bugzilla #81759)
1457            */
1458           gulong mask = 0xaaaaaaaa;
1459           XGetICValues (xic,
1460                         XNFilterEvents, &mask,
1461                         NULL);
1462           context_xim->filter_key_release = (mask & KeyReleaseMask) != 0;
1463           set_string_conversion_callback (context_xim, xic);
1464         }
1465
1466       context_xim->ic = xic;
1467
1468       update_status_window (context_xim);
1469
1470       if (xic && context_xim->has_focus)
1471         XSetICFocus (xic);
1472     }
1473   return context_xim->ic;
1474 }
1475
1476 /*****************************************************************
1477  * Status Window handling
1478  *
1479  * A status window is a small window attached to the toplevel
1480  * that is used to display information to the user about the
1481  * current input operation.
1482  *
1483  * We claim the toplevel's status window for an input context if:
1484  *
1485  * A) The input context has a toplevel
1486  * B) The input context has the focus
1487  * C) The input context has an XIC associated with it
1488  *
1489  * Tracking A) and C) is pretty reliable since we
1490  * compute A) and create the XIC for C) ourselves.
1491  * For B) we basically have to depend on our callers
1492  * calling ::focus-in and ::focus-out at the right time.
1493  *
1494  * The toplevel is computed by walking up the GdkWindow
1495  * hierarchy from context->client_window until we find a
1496  * window that is owned by some widget, and then calling
1497  * gtk_widget_get_toplevel() on that widget. This should
1498  * handle both cases where we might have GdkWindows without widgets,
1499  * and cases where GtkWidgets have strange window hierarchies
1500  * (like a torn off GtkHandleBox.)
1501  *
1502  * The status window is visible if and only if there is text
1503  * for it; whenever a new GtkIMContextXIM claims the status
1504  * window, we blank out any existing text. We actually only
1505  * create a GtkWindow for the status window the first time
1506  * it is shown; this is an important optimization when we are
1507  * using XIM with something like a simple compose-key input
1508  * method that never needs a status window.
1509  *****************************************************************/
1510
1511 /* Called when we no longer need a status window
1512 */
1513 static void
1514 disclaim_status_window (GtkIMContextXIM *context_xim)
1515 {
1516   if (context_xim->status_window)
1517     {
1518       g_assert (context_xim->status_window->context == context_xim);
1519
1520       status_window_set_text (context_xim->status_window, "");
1521
1522       context_xim->status_window->context = NULL;
1523       context_xim->status_window = NULL;
1524     }
1525 }
1526
1527 /* Called when we need a status window
1528  */
1529 static void
1530 claim_status_window (GtkIMContextXIM *context_xim)
1531 {
1532   if (!context_xim->status_window && context_xim->client_widget)
1533     {
1534       GtkWidget *toplevel = gtk_widget_get_toplevel (context_xim->client_widget);
1535       if (toplevel && GTK_WIDGET_TOPLEVEL (toplevel))
1536         {
1537           StatusWindow *status_window = status_window_get (toplevel);
1538
1539           if (status_window->context)
1540             disclaim_status_window (status_window->context);
1541
1542           status_window->context = context_xim;
1543           context_xim->status_window = status_window;
1544         }
1545     }
1546 }
1547
1548 /* Basic call made whenever something changed that might cause
1549  * us to need, or not to need a status window.
1550  */
1551 static void
1552 update_status_window (GtkIMContextXIM *context_xim)
1553 {
1554   if (context_xim->ic && context_xim->in_toplevel && context_xim->has_focus)
1555     claim_status_window (context_xim);
1556   else
1557     disclaim_status_window (context_xim);
1558 }
1559
1560 /* Updates the in_toplevel flag for @context_xim
1561  */
1562 static void
1563 update_in_toplevel (GtkIMContextXIM *context_xim)
1564 {
1565   if (context_xim->client_widget)
1566     {
1567       GtkWidget *toplevel = gtk_widget_get_toplevel (context_xim->client_widget);
1568
1569       context_xim->in_toplevel = (toplevel && GTK_WIDGET_TOPLEVEL (toplevel));
1570     }
1571   else
1572     context_xim->in_toplevel = FALSE;
1573
1574   /* Some paranoia, in case we don't get a focus out */
1575   if (!context_xim->in_toplevel)
1576     context_xim->has_focus = FALSE;
1577
1578   update_status_window (context_xim);
1579 }
1580
1581 /* Callback when @widget's toplevel changes. It will always
1582  * change from NULL to a window, or a window to NULL;
1583  * we use that intermediate NULL state to make sure
1584  * that we disclaim the toplevel status window for the old
1585  * window.
1586  */
1587 static void
1588 on_client_widget_hierarchy_changed (GtkWidget       *widget,
1589                                     GtkWidget       *old_toplevel,
1590                                     GtkIMContextXIM *context_xim)
1591 {
1592   update_in_toplevel (context_xim);
1593 }
1594
1595 /* Finds the GtkWidget that owns the window, or if none, the
1596  * widget owning the nearest parent that has a widget.
1597  */
1598 static GtkWidget *
1599 widget_for_window (GdkWindow *window)
1600 {
1601   while (window)
1602     {
1603       gpointer user_data;
1604       gdk_window_get_user_data (window, &user_data);
1605       if (user_data)
1606         return user_data;
1607
1608       window = gdk_window_get_parent (window);
1609     }
1610
1611   return NULL;
1612 }
1613
1614 /* Called when context_xim->client_window changes; takes care of
1615  * removing and/or setting up our watches for the toplevel
1616  */
1617 static void
1618 update_client_widget (GtkIMContextXIM *context_xim)
1619 {
1620   GtkWidget *new_client_widget = widget_for_window (context_xim->client_window);
1621
1622   if (new_client_widget != context_xim->client_widget)
1623     {
1624       if (context_xim->client_widget)
1625         {
1626           g_signal_handlers_disconnect_by_func (context_xim->client_widget,
1627                                                 G_CALLBACK (on_client_widget_hierarchy_changed),
1628                                                 context_xim);
1629         }
1630       context_xim->client_widget = new_client_widget;
1631       if (context_xim->client_widget)
1632         {
1633           g_signal_connect (context_xim->client_widget, "hierarchy-changed",
1634                             G_CALLBACK (on_client_widget_hierarchy_changed),
1635                             context_xim);
1636         }
1637
1638       update_in_toplevel (context_xim);
1639     }
1640 }
1641
1642 /* Called when the toplevel is destroyed; frees the status window
1643  */
1644 static void
1645 on_status_toplevel_destroy (GtkWidget    *toplevel,
1646                             StatusWindow *status_window)
1647 {
1648   status_window_free (status_window);
1649 }
1650
1651 /* Called when the screen for the toplevel changes; updates the
1652  * screen for the status window to match.
1653  */
1654 static void
1655 on_status_toplevel_notify_screen (GtkWindow    *toplevel,
1656                                   GParamSpec   *pspec,
1657                                   StatusWindow *status_window)
1658 {
1659   if (status_window->window)
1660     gtk_window_set_screen (GTK_WINDOW (status_window->window),
1661                            gtk_widget_get_screen (GTK_WIDGET (toplevel)));
1662 }
1663
1664 /* Called when the toplevel window is moved; updates the position of
1665  * the status window to follow it.
1666  */
1667 static gboolean
1668 on_status_toplevel_configure (GtkWidget         *toplevel,
1669                               GdkEventConfigure *event,
1670                               StatusWindow      *status_window)
1671 {
1672   GdkRectangle rect;
1673   GtkRequisition requisition;
1674   gint y;
1675   gint height;
1676
1677   if (status_window->window)
1678     {
1679       height = gdk_screen_get_height (gtk_widget_get_screen (toplevel));
1680
1681       gdk_window_get_frame_extents (toplevel->window, &rect);
1682       gtk_widget_size_request (status_window->window, &requisition);
1683
1684       if (rect.y + rect.height + requisition.height < height)
1685         y = rect.y + rect.height;
1686       else
1687         y = height - requisition.height;
1688
1689       gtk_window_move (GTK_WINDOW (status_window->window), rect.x, y);
1690     }
1691
1692   return FALSE;
1693 }
1694
1695 /* Frees a status window and removes its link from the status_windows list
1696  */
1697 static void
1698 status_window_free (StatusWindow *status_window)
1699 {
1700   status_windows = g_slist_remove (status_windows, status_window);
1701
1702   if (status_window->context)
1703     status_window->context->status_window = NULL;
1704
1705   g_signal_handlers_disconnect_by_func (status_window->toplevel,
1706                                         G_CALLBACK (on_status_toplevel_destroy),
1707                                         status_window);
1708   g_signal_handlers_disconnect_by_func (status_window->toplevel,
1709                                         G_CALLBACK (on_status_toplevel_notify_screen),
1710                                         status_window);
1711   g_signal_handlers_disconnect_by_func (status_window->toplevel,
1712                                         G_CALLBACK (on_status_toplevel_configure),
1713                                         status_window);
1714
1715   if (status_window->window)
1716     gtk_widget_destroy (status_window->window);
1717
1718   g_object_set_data (G_OBJECT (status_window->toplevel), "gtk-im-xim-status-window", NULL);
1719
1720   g_free (status_window);
1721 }
1722
1723 /* Finds the status window object for a toplevel, creating it if necessary.
1724  */
1725 static StatusWindow *
1726 status_window_get (GtkWidget *toplevel)
1727 {
1728   StatusWindow *status_window;
1729
1730   status_window = g_object_get_data (G_OBJECT (toplevel), "gtk-im-xim-status-window");
1731   if (status_window)
1732     return status_window;
1733
1734   status_window = g_new0 (StatusWindow, 1);
1735   status_window->toplevel = toplevel;
1736
1737   status_windows = g_slist_prepend (status_windows, status_window);
1738
1739   g_signal_connect (toplevel, "destroy",
1740                     G_CALLBACK (on_status_toplevel_destroy),
1741                     status_window);
1742   g_signal_connect (toplevel, "configure_event",
1743                     G_CALLBACK (on_status_toplevel_configure),
1744                     status_window);
1745   g_signal_connect (toplevel, "notify::screen",
1746                     G_CALLBACK (on_status_toplevel_notify_screen),
1747                     status_window);
1748
1749   g_object_set_data (G_OBJECT (toplevel), "gtk-im-xim-status-window", status_window);
1750
1751   return status_window;
1752 }
1753
1754 /* Draw the background (normally white) and border for the status window
1755  */
1756 static gboolean
1757 on_status_window_expose_event (GtkWidget      *widget,
1758                                GdkEventExpose *event)
1759 {
1760   gdk_draw_rectangle (widget->window,
1761                       widget->style->base_gc [GTK_STATE_NORMAL],
1762                       TRUE,
1763                       0, 0,
1764                       widget->allocation.width, widget->allocation.height);
1765   gdk_draw_rectangle (widget->window,
1766                       widget->style->text_gc [GTK_STATE_NORMAL],
1767                       FALSE,
1768                       0, 0,
1769                       widget->allocation.width - 1, widget->allocation.height - 1);
1770
1771   return FALSE;
1772 }
1773
1774 /* We watch the ::style-set signal for our label widget
1775  * and use that to change it's foreground color to match
1776  * the 'text' color of the toplevel window. The text/base
1777  * pair of colors might be reversed from the fg/bg pair
1778  * that are normally used for labels.
1779  */
1780 static void
1781 on_status_window_style_set (GtkWidget *toplevel,
1782                             GtkStyle  *previous_style,
1783                             GtkWidget *label)
1784 {
1785   gint i;
1786
1787   for (i = 0; i < 5; i++)
1788     gtk_widget_modify_fg (label, i, &toplevel->style->text[i]);
1789 }
1790
1791 /* Creates the widgets for the status window; called when we
1792  * first need to show text for the status window.
1793  */
1794 static void
1795 status_window_make_window (StatusWindow *status_window)
1796 {
1797   GtkWidget *window;
1798   GtkWidget *status_label;
1799
1800   status_window->window = gtk_window_new (GTK_WINDOW_POPUP);
1801   window = status_window->window;
1802
1803   gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
1804   gtk_widget_set_app_paintable (window, TRUE);
1805
1806   status_label = gtk_label_new ("");
1807   gtk_misc_set_padding (GTK_MISC (status_label), 1, 1);
1808   gtk_widget_show (status_label);
1809
1810   g_signal_connect (window, "style_set",
1811                     G_CALLBACK (on_status_window_style_set), status_label);
1812   gtk_container_add (GTK_CONTAINER (window), status_label);
1813
1814   g_signal_connect (window, "expose_event",
1815                     G_CALLBACK (on_status_window_expose_event), NULL);
1816
1817   gtk_window_set_screen (GTK_WINDOW (status_window->window),
1818                          gtk_widget_get_screen (status_window->toplevel));
1819
1820   on_status_toplevel_configure (status_window->toplevel, NULL, status_window);
1821 }
1822
1823 /* Updates the text in the status window, hiding or
1824  * showing the window as necessary.
1825  */
1826 static void
1827 status_window_set_text (StatusWindow *status_window,
1828                         const gchar  *text)
1829 {
1830   if (text[0])
1831     {
1832       GtkWidget *label;
1833
1834       if (!status_window->window)
1835         status_window_make_window (status_window);
1836
1837       label = GTK_BIN (status_window->window)->child;
1838       gtk_label_set_text (GTK_LABEL (label), text);
1839
1840       gtk_widget_show (status_window->window);
1841     }
1842   else
1843     {
1844       if (status_window->window)
1845         gtk_widget_hide (status_window->window);
1846     }
1847 }
1848
1849 /**
1850  * gtk_im_context_xim_shutdown:
1851  *
1852  * Destroys all the status windows that are kept by the XIM contexts.  This
1853  * function should only be called by the XIM module exit routine.
1854  **/
1855 void
1856 gtk_im_context_xim_shutdown (void)
1857 {
1858   while (status_windows)
1859     status_window_free (status_windows->data);
1860 }