dlls/winex11.drv/xim.c

   1 /*
   2  * Functions for further XIM control
   3  *
   4  * Copyright 2003 CodeWeavers, Aric Stewart
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "wingdi.h"
  30 #include "winnls.h"
  31 #include "x11drv.h"
  32 #include "imm.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
  36
  37 #ifndef HAVE_XICCALLBACK_CALLBACK
  38 #define XICCallback XIMCallback
  39 #define XICProc XIMProc
  40 #endif
  41
  42 BOOL ximInComposeMode=FALSE;
  43
  44 /* moved here from imm32 for dll separation */
  45 static DWORD dwCompStringLength = 0;
  46 static LPBYTE CompositionString = NULL;
  47 static DWORD dwCompStringSize = 0;
  48
  49 #define STYLE_OFFTHESPOT (XIMPreeditArea | XIMStatusArea)
  50 #define STYLE_OVERTHESPOT (XIMPreeditPosition | XIMStatusNothing)
  51 #define STYLE_ROOT (XIMPreeditNothing | XIMStatusNothing)
  52 /* this uses all the callbacks to utilize full IME support */
  53 #define STYLE_CALLBACK (XIMPreeditCallbacks | XIMStatusNothing)
  54 /* inorder to enable deadkey support */
  55 #define STYLE_NONE (XIMPreeditNothing | XIMStatusNothing)
  56
  57 static XIMStyle ximStyle = 0;
  58 static XIMStyle ximStyleRoot = 0;
  59 static XIMStyle ximStyleRequest = STYLE_CALLBACK;
  60
  61 static void X11DRV_ImmSetInternalString(DWORD dwOffset,
  62                                         DWORD selLength, LPWSTR lpComp, DWORD dwCompLen)
  63 {
  64     /* Composition strings are edited in chunks */
  65     unsigned int byte_length = dwCompLen * sizeof(WCHAR);
  66     unsigned int byte_offset = dwOffset * sizeof(WCHAR);
  67     unsigned int byte_selection = selLength * sizeof(WCHAR);
  68     int byte_expansion = byte_length - byte_selection;
  69     LPBYTE ptr_new;
  70
  71     TRACE("( %i, %i, %p, %d):\n", dwOffset, selLength, lpComp, dwCompLen );
  72
  73     if (byte_expansion + dwCompStringLength >= dwCompStringSize)
  74     {
  75         if (CompositionString)
  76             ptr_new = HeapReAlloc(GetProcessHeap(), 0, CompositionString,
  77                                   dwCompStringSize + byte_expansion);
  78         else
  79             ptr_new = HeapAlloc(GetProcessHeap(), 0,
  80                                 dwCompStringSize + byte_expansion);
  81
  82         if (ptr_new == NULL)
  83         {
  84             ERR("Couldn't expand composition string buffer\n");
  85             return;
  86         }
  87
  88         CompositionString = ptr_new;
  89         dwCompStringSize += byte_expansion;
  90     }
  91
  92     ptr_new = CompositionString + byte_offset;
  93     memmove(ptr_new + byte_length, ptr_new + byte_selection,
  94             dwCompStringLength - byte_offset - byte_selection);
  95     memcpy(ptr_new, lpComp, byte_length);
  96     dwCompStringLength += byte_expansion;
  97
  98     IME_SetCompositionString(SCS_SETSTR, CompositionString,
  99                              dwCompStringLength, NULL, 0);
 100 }
 101
 102 void X11DRV_XIMLookupChars( const char *str, DWORD count )
 103 {
 104     DWORD dwOutput;
 105     WCHAR *wcOutput;
 106     HWND focus;
 107
 108     TRACE("%p %u\n", str, count);
 109
 110     dwOutput = MultiByteToWideChar(CP_UNIXCP, 0, str, count, NULL, 0);
 111     wcOutput = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * dwOutput);
 112     if (wcOutput == NULL)
 113         return;
 114     MultiByteToWideChar(CP_UNIXCP, 0, str, count, wcOutput, dwOutput);
 115
 116     if ((focus = GetFocus()))
 117         IME_UpdateAssociation(focus);
 118
 119     IME_SetCompositionString(SCS_SETSTR, wcOutput,
 120                              sizeof (WCHAR) * dwOutput, NULL, 0);
 121     IME_NotifyIME(NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
 122     HeapFree(GetProcessHeap(), 0, wcOutput);
 123 }
 124
 125 static int XIMPreEditStartCallback(XIC ic, XPointer client_data, XPointer call_data)
 126 {
 127     TRACE("PreEditStartCallback %p\n",ic);
 128     IME_SetOpenStatus(TRUE);
 129     ximInComposeMode = TRUE;
 130     return -1;
 131 }
 132
 133 static void XIMPreEditDoneCallback(XIC ic, XPointer client_data, XPointer call_data)
 134 {
 135     TRACE("PreeditDoneCallback %p\n",ic);
 136     ximInComposeMode = FALSE;
 137     if (dwCompStringSize)
 138         HeapFree(GetProcessHeap(), 0, CompositionString);
 139     dwCompStringSize = 0;
 140     dwCompStringLength = 0;
 141     CompositionString = NULL;
 142     IME_SetOpenStatus(FALSE);
 143 }
 144
 145 static void XIMPreEditDrawCallback(XIM ic, XPointer client_data,
 146                                    XIMPreeditDrawCallbackStruct *P_DR)
 147 {
 148     TRACE("PreEditDrawCallback %p\n",ic);
 149
 150     if (P_DR)
 151     {
 152         int sel = P_DR->chg_first;
 153         int len = P_DR->chg_length;
 154         if (P_DR->text)
 155         {
 156             if (! P_DR->text->encoding_is_wchar)
 157             {
 158                 DWORD dwOutput;
 159                 WCHAR *wcOutput;
 160
 161                 TRACE("multibyte\n");
 162                 dwOutput = MultiByteToWideChar(CP_UNIXCP, 0,
 163                            P_DR->text->string.multi_byte, -1,
 164                            NULL, 0);
 165                 wcOutput = HeapAlloc(GetProcessHeap(), 0, sizeof (WCHAR) * dwOutput);
 166                 if (wcOutput)
 167                 {
 168                     dwOutput = MultiByteToWideChar(CP_UNIXCP, 0,
 169                                P_DR->text->string.multi_byte, -1,
 170                                wcOutput, dwOutput);
 171
 172                     /* ignore null */
 173                     dwOutput --;
 174                     X11DRV_ImmSetInternalString (sel, len, wcOutput, dwOutput);
 175                     HeapFree(GetProcessHeap(), 0, wcOutput);
 176                 }
 177             }
 178             else
 179             {
 180                 FIXME("wchar PROBIBILY WRONG\n");
 181                 X11DRV_ImmSetInternalString (sel, len,
 182                                              (LPWSTR)P_DR->text->string.wide_char,
 183                                              P_DR->text->length);
 184             }
 185         }
 186         else
 187             X11DRV_ImmSetInternalString (sel, len, NULL, 0);
 188         IME_SetCursorPos(P_DR->caret);
 189     }
 190     TRACE("Finished\n");
 191 }
 192
 193 static void XIMPreEditCaretCallback(XIC ic, XPointer client_data,
 194                                     XIMPreeditCaretCallbackStruct *P_C)
 195 {
 196     TRACE("PreeditCaretCallback %p\n",ic);
 197
 198     if (P_C)
 199     {
 200         int pos = IME_GetCursorPos();
 201         TRACE("pos: %d\n", pos);
 202         switch(P_C->direction)
 203         {
 204             case XIMForwardChar:
 205             case XIMForwardWord:
 206                 pos++;
 207                 break;
 208             case XIMBackwardChar:
 209             case XIMBackwardWord:
 210                 pos--;
 211                 break;
 212             case XIMLineStart:
 213                 pos = 0;
 214                 break;
 215             case XIMAbsolutePosition:
 216                 pos = P_C->position;
 217                 break;
 218             case XIMDontChange:
 219                 P_C->position = pos;
 220                 return;
 221             case XIMCaretUp:
 222             case XIMCaretDown:
 223             case XIMPreviousLine:
 224             case XIMNextLine:
 225             case XIMLineEnd:
 226                 FIXME("Not implemented\n");
 227                 break;
 228         }
 229         IME_SetCursorPos(pos);
 230         P_C->position = pos;
 231     }
 232     TRACE("Finished\n");
 233 }
 234
 235 void X11DRV_ForceXIMReset(HWND hwnd)
 236 {
 237     XIC ic = X11DRV_get_ic(hwnd);
 238     if (ic)
 239     {
 240         char* leftover;
 241         TRACE("Forcing Reset %p\n",ic);
 242         wine_tsx11_lock();
 243         leftover = XmbResetIC(ic);
 244         XFree(leftover);
 245         wine_tsx11_unlock();
 246     }
 247 }
 248
 249 /***********************************************************************
 250  *           X11DRV_InitXIM
 251  *
 252  * Process-wide XIM initialization.
 253  */
 254 BOOL X11DRV_InitXIM( const char *input_style )
 255 {
 256     BOOL ret;
 257
 258     if (!strcasecmp(input_style, "offthespot"))
 259         ximStyleRequest = STYLE_OFFTHESPOT;
 260     else if (!strcasecmp(input_style, "overthespot"))
 261         ximStyleRequest = STYLE_OVERTHESPOT;
 262     else if (!strcasecmp(input_style, "root"))
 263         ximStyleRequest = STYLE_ROOT;
 264
 265     wine_tsx11_lock();
 266     if (!(ret = XSupportsLocale()))
 267     {
 268         WARN("X does not support locale.\n");
 269     }
 270     else if (XSetLocaleModifiers("") == NULL)
 271     {
 272         WARN("Could not set locale modifiers.\n");
 273         ret = FALSE;
 274     }
 275     wine_tsx11_unlock();
 276     return ret;
 277 }
 278
 279
 280 static void open_xim_callback( Display *display, XPointer ptr, XPointer data );
 281
 282 static void X11DRV_DestroyIM(XIM xim, XPointer p, XPointer data)
 283 {
 284     struct x11drv_thread_data *thread_data = x11drv_thread_data();
 285
 286     TRACE("xim = %p, p = %p\n", xim, p);
 287     thread_data->xim = NULL;
 288     ximStyle = 0;
 289     wine_tsx11_lock();
 290     XRegisterIMInstantiateCallback( thread_data->display, NULL, NULL, NULL, open_xim_callback, NULL );
 291     wine_tsx11_unlock();
 292 }
 293
 294 /***********************************************************************
 295  *           X11DRV Ime creation
 296  *
 297  * Should always be called with the x11 lock held
 298  */
 299 static BOOL open_xim( Display *display )
 300 {
 301     struct x11drv_thread_data *thread_data = x11drv_thread_data();
 302     XIMStyle ximStyleCallback, ximStyleNone;
 303     XIMStyles *ximStyles = NULL;
 304     INT i;
 305     XIM xim;
 306     XIMCallback destroy;
 307
 308     xim = XOpenIM(display, NULL, NULL, NULL);
 309     if (xim == NULL)
 310     {
 311         WARN("Could not open input method.\n");
 312         return FALSE;
 313     }
 314
 315     destroy.client_data = NULL;
 316     destroy.callback = X11DRV_DestroyIM;
 317     if (XSetIMValues(xim, XNDestroyCallback, &destroy, NULL))
 318     {
 319         WARN("Could not set destroy callback.\n");
 320     }
 321
 322     TRACE("xim = %p\n", xim);
 323     TRACE("X display of IM = %p\n", XDisplayOfIM(xim));
 324     TRACE("Using %s locale of Input Method\n", XLocaleOfIM(xim));
 325
 326     XGetIMValues(xim, XNQueryInputStyle, &ximStyles, NULL);
 327     if (ximStyles == 0)
 328     {
 329         WARN("Could not find supported input style.\n");
 330         XCloseIM(xim);
 331         return FALSE;
 332     }
 333     else
 334     {
 335         TRACE("ximStyles->count_styles = %d\n", ximStyles->count_styles);
 336
 337         ximStyleRoot = 0;
 338         ximStyleNone = 0;
 339         ximStyleCallback = 0;
 340
 341         for (i = 0; i < ximStyles->count_styles; ++i)
 342         {
 343             int style = ximStyles->supported_styles[i];
 344             TRACE("ximStyles[%d] = %s%s%s%s%s\n", i,
 345                         (style&XIMPreeditArea)?"XIMPreeditArea ":"",
 346                         (style&XIMPreeditCallbacks)?"XIMPreeditCallbacks ":"",
 347                         (style&XIMPreeditPosition)?"XIMPreeditPosition ":"",
 348                         (style&XIMPreeditNothing)?"XIMPreeditNothing ":"",
 349                         (style&XIMPreeditNone)?"XIMPreeditNone ":"");
 350             if (!ximStyle && (ximStyles->supported_styles[i] ==
 351                                 ximStyleRequest))
 352             {
 353                 ximStyle = ximStyleRequest;
 354                 TRACE("Setting Style: ximStyle = ximStyleRequest\n");
 355             }
 356             else if (!ximStyleRoot &&(ximStyles->supported_styles[i] ==
 357                      STYLE_ROOT))
 358             {
 359                 ximStyleRoot = STYLE_ROOT;
 360                 TRACE("Setting Style: ximStyleRoot = STYLE_ROOT\n");
 361             }
 362             else if (!ximStyleCallback &&(ximStyles->supported_styles[i] ==
 363                      STYLE_CALLBACK))
 364             {
 365                 ximStyleCallback = STYLE_CALLBACK;
 366                 TRACE("Setting Style: ximStyleCallback = STYLE_CALLBACK\n");
 367             }
 368             else if (!ximStyleNone && (ximStyles->supported_styles[i] ==
 369                      STYLE_NONE))
 370             {
 371                 TRACE("Setting Style: ximStyleNone = STYLE_NONE\n");
 372                 ximStyleNone = STYLE_NONE;
 373             }
 374         }
 375         XFree(ximStyles);
 376
 377         if (ximStyle == 0)
 378             ximStyle = ximStyleRoot;
 379
 380         if (ximStyle == 0)
 381             ximStyle = ximStyleNone;
 382
 383         if (ximStyleCallback == 0)
 384         {
 385             TRACE("No callback style avalable\n");
 386             ximStyleCallback = ximStyle;
 387         }
 388
 389     }
 390
 391     thread_data->xim = xim;
 392
 393     if ((ximStyle & (XIMPreeditNothing | XIMPreeditNone)) == 0 ||
 394         (ximStyle & (XIMStatusNothing | XIMStatusNone)) == 0)
 395     {
 396         char **list;
 397         int count;
 398         thread_data->font_set = XCreateFontSet(display, "fixed",
 399                           &list, &count, NULL);
 400         TRACE("ximFontSet = %p\n", thread_data->font_set);
 401         TRACE("list = %p, count = %d\n", list, count);
 402         if (list != NULL)
 403         {
 404             int i;
 405             for (i = 0; i < count; ++i)
 406                 TRACE("list[%d] = %s\n", i, list[i]);
 407             XFreeStringList(list);
 408         }
 409     }
 410     else
 411         thread_data->font_set = NULL;
 412
 413     wine_tsx11_unlock();
 414     IME_UpdateAssociation(NULL);
 415     wine_tsx11_lock();
 416     return TRUE;
 417 }
 418
 419 static void open_xim_callback( Display *display, XPointer ptr, XPointer data )
 420 {
 421     if (open_xim( display ))
 422         XUnregisterIMInstantiateCallback( display, NULL, NULL, NULL, open_xim_callback, NULL);
 423 }
 424
 425 void X11DRV_SetupXIM(void)
 426 {
 427     Display *display = thread_display();
 428
 429     wine_tsx11_lock();
 430     if (!open_xim( display ))
 431         XRegisterIMInstantiateCallback( display, NULL, NULL, NULL, open_xim_callback, NULL );
 432     wine_tsx11_unlock();
 433 }
 434
 435 static BOOL X11DRV_DestroyIC(XIC xic, XPointer p, XPointer data)
 436 {
 437     struct x11drv_win_data *win_data = (struct x11drv_win_data *)p;
 438     TRACE("xic = %p, win = %lx\n", xic, win_data->whole_window);
 439     win_data->xic = NULL;
 440     return TRUE;
 441 }
 442
 443
 444 XIC X11DRV_CreateIC(XIM xim, struct x11drv_win_data *data)
 445 {
 446     XPoint spot = {0};
 447     XVaNestedList preedit = NULL;
 448     XVaNestedList status = NULL;
 449     XIC xic;
 450     XICCallback destroy = {(XPointer)data, (XICProc)X11DRV_DestroyIC};
 451     XICCallback P_StartCB, P_DoneCB, P_DrawCB, P_CaretCB;
 452     LANGID langid = PRIMARYLANGID(LANGIDFROMLCID(GetThreadLocale()));
 453     Window win = data->whole_window;
 454     XFontSet fontSet = x11drv_thread_data()->font_set;
 455
 456     TRACE("xim = %p\n", xim);
 457
 458     wine_tsx11_lock();
 459
 460     /* use complex and slow XIC initialization method only for CJK */
 461     if (langid != LANG_CHINESE &&
 462         langid != LANG_JAPANESE &&
 463         langid != LANG_KOREAN)
 464     {
 465         xic = XCreateIC(xim,
 466                         XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
 467                         XNClientWindow, win,
 468                         XNFocusWindow, win,
 469                         XNDestroyCallback, &destroy,
 470                         NULL);
 471         wine_tsx11_unlock();
 472         data->xic = xic;
 473         return xic;
 474     }
 475
 476     /* create callbacks */
 477     P_StartCB.client_data = NULL;
 478     P_DoneCB.client_data = NULL;
 479     P_DrawCB.client_data = NULL;
 480     P_CaretCB.client_data = NULL;
 481     P_StartCB.callback = (XICProc)XIMPreEditStartCallback;
 482     P_DoneCB.callback = (XICProc)XIMPreEditDoneCallback;
 483     P_DrawCB.callback = (XICProc)XIMPreEditDrawCallback;
 484     P_CaretCB.callback = (XICProc)XIMPreEditCaretCallback;
 485
 486     if ((ximStyle & (XIMPreeditNothing | XIMPreeditNone)) == 0)
 487     {
 488         preedit = XVaCreateNestedList(0,
 489                         XNFontSet, fontSet,
 490                         XNSpotLocation, &spot,
 491                         XNPreeditStartCallback, &P_StartCB,
 492                         XNPreeditDoneCallback, &P_DoneCB,
 493                         XNPreeditDrawCallback, &P_DrawCB,
 494                         XNPreeditCaretCallback, &P_CaretCB,
 495                         NULL);
 496         TRACE("preedit = %p\n", preedit);
 497     }
 498     else
 499     {
 500         preedit = XVaCreateNestedList(0,
 501                         XNPreeditStartCallback, &P_StartCB,
 502                         XNPreeditDoneCallback, &P_DoneCB,
 503                         XNPreeditDrawCallback, &P_DrawCB,
 504                         XNPreeditCaretCallback, &P_CaretCB,
 505                         NULL);
 506
 507         TRACE("preedit = %p\n", preedit);
 508     }
 509
 510     if ((ximStyle & (XIMStatusNothing | XIMStatusNone)) == 0)
 511     {
 512         status = XVaCreateNestedList(0,
 513             XNFontSet, fontSet,
 514             NULL);
 515         TRACE("status = %p\n", status);
 516      }
 517
 518     if (preedit != NULL && status != NULL)
 519     {
 520         xic = XCreateIC(xim,
 521               XNInputStyle, ximStyle,
 522               XNPreeditAttributes, preedit,
 523               XNStatusAttributes, status,
 524               XNClientWindow, win,
 525               XNFocusWindow, win,
 526               XNDestroyCallback, &destroy,
 527               NULL);
 528      }
 529     else if (preedit != NULL)
 530     {
 531         xic = XCreateIC(xim,
 532               XNInputStyle, ximStyle,
 533               XNPreeditAttributes, preedit,
 534               XNClientWindow, win,
 535               XNFocusWindow, win,
 536               XNDestroyCallback, &destroy,
 537               NULL);
 538     }
 539     else if (status != NULL)
 540     {
 541         xic = XCreateIC(xim,
 542               XNInputStyle, ximStyle,
 543               XNStatusAttributes, status,
 544               XNClientWindow, win,
 545               XNFocusWindow, win,
 546               XNDestroyCallback, &destroy,
 547               NULL);
 548     }
 549     else
 550     {
 551         xic = XCreateIC(xim,
 552               XNInputStyle, ximStyle,
 553               XNClientWindow, win,
 554               XNFocusWindow, win,
 555               XNDestroyCallback, &destroy,
 556               NULL);
 557     }
 558
 559     TRACE("xic = %p\n", xic);
 560     data->xic = xic;
 561
 562     if (preedit != NULL)
 563         XFree(preedit);
 564     if (status != NULL)
 565         XFree(status);
 566
 567     wine_tsx11_unlock();
 568
 569     return xic;
 570 }