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 BOOL X11DRV_ImmSetInternalString(DWORD dwIndex, 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     BOOL rc = FALSE;
  69
  70     TRACE("( %i, %i, %d, %p, %d):\n", dwOffset, selLength, dwIndex, lpComp, dwCompLen );
  71
  72     if (dwIndex == GCS_COMPSTR)
  73     {
  74         unsigned int i,j;
  75         LPBYTE ptr_new;
  76         LPBYTE ptr_old;
  77
  78         if ((dwCompLen == 0) && (selLength == 0))
  79         {
  80             /* DO Nothing */
  81         }
  82         /* deletion occurred */
  83         else if ((dwCompLen== 0) && (selLength != 0))
  84         {
  85             if (dwCompStringLength)
  86             {
  87                 for (i = 0; i < byte_selection; i++)
  88                 {
  89                     if (byte_offset+byte_selection+i <
  90                         dwCompStringLength)
  91                     {
  92                         CompositionString[byte_offset + i] =
  93                         CompositionString[byte_offset + byte_selection + i];
  94                     }
  95                     else
  96                         CompositionString[byte_offset + i] = 0;
  97                 }
  98                 /* clean up the end */
  99                 dwCompStringLength -= byte_selection;
 100
 101                 i = dwCompStringLength;
 102                 while (i < dwCompStringSize)
 103                 {
 104                     CompositionString[i++] = 0;
 105                 }
 106             }
 107         }
 108         else
 109         {
 110             int byte_expansion = byte_length - byte_selection;
 111
 112             if (byte_expansion + dwCompStringLength >= dwCompStringSize)
 113             {
 114                 if (CompositionString)
 115                     CompositionString =
 116                         HeapReAlloc(GetProcessHeap(), 0,
 117                                     CompositionString,
 118                                     dwCompStringSize +
 119                                     byte_expansion);
 120                 else
 121                      CompositionString =
 122                         HeapAlloc(GetProcessHeap(), 0, dwCompStringSize +
 123                                     byte_expansion);
 124
 125                 memset(&(CompositionString[dwCompStringSize]), 0,
 126                         byte_expansion);
 127
 128                 dwCompStringSize += byte_expansion;
 129             }
 130
 131             ptr_new =  ((LPBYTE)lpComp);
 132             ptr_old = CompositionString + byte_offset + byte_selection;
 133
 134             dwCompStringLength += byte_expansion;
 135
 136             for (j=0,i = byte_offset; i < dwCompStringSize; i++)
 137             {
 138                 if (j < byte_length)
 139                 {
 140                     CompositionString[i] = ptr_new[j++];
 141                 }
 142                 else
 143                 {
 144                     if (ptr_old < CompositionString + dwCompStringSize)
 145                     {
 146                         CompositionString[i] = *ptr_old;
 147                         ptr_old++;
 148                             }
 149                     else
 150                         CompositionString[i] = 0;
 151                 }
 152             }
 153         }
 154
 155         rc = IME_SetCompositionString(SCS_SETSTR, CompositionString,
 156                                       dwCompStringLength, NULL, 0);
 157     }
 158     else if ((dwIndex == GCS_RESULTSTR) && (lpComp) && (dwCompLen))
 159     {
 160         rc = IME_SetCompositionString(SCS_SETSTR, lpComp,
 161                                       byte_length, NULL, 0);
 162
 163         IME_NotifyIME( NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
 164     }
 165
 166     return rc;
 167 }
 168
 169 void X11DRV_XIMLookupChars( const char *str, DWORD count )
 170 {
 171     DWORD dwOutput;
 172     WCHAR *wcOutput;
 173     HWND focus;
 174
 175     dwOutput = MultiByteToWideChar(CP_UNIXCP, 0, str, count, NULL, 0);
 176     wcOutput = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * dwOutput);
 177     if (wcOutput == NULL)
 178         return;
 179     MultiByteToWideChar(CP_UNIXCP, 0, str, count, wcOutput, dwOutput);
 180
 181     if ((focus = GetFocus()))
 182         IME_UpdateAssociation(focus);
 183
 184     X11DRV_ImmSetInternalString(GCS_RESULTSTR,0,0,wcOutput,dwOutput);
 185     HeapFree(GetProcessHeap(), 0, wcOutput);
 186 }
 187
 188 static void X11DRV_ImmSetOpenStatus(BOOL fOpen)
 189 {
 190     if (fOpen == FALSE)
 191     {
 192         if (dwCompStringSize)
 193             HeapFree(GetProcessHeap(),0,CompositionString);
 194
 195         dwCompStringSize = 0;
 196         dwCompStringLength = 0;
 197         CompositionString = NULL;
 198     }
 199
 200     IME_SetOpenStatus(fOpen);
 201 }
 202
 203 static int XIMPreEditStartCallback(XIC ic, XPointer client_data, XPointer call_data)
 204 {
 205     TRACE("PreEditStartCallback %p\n",ic);
 206     X11DRV_ImmSetOpenStatus(TRUE);
 207     ximInComposeMode = TRUE;
 208     return -1;
 209 }
 210
 211 static void XIMPreEditDoneCallback(XIC ic, XPointer client_data, XPointer call_data)
 212 {
 213     TRACE("PreeditDoneCallback %p\n",ic);
 214     ximInComposeMode = FALSE;
 215     X11DRV_ImmSetOpenStatus(FALSE);
 216 }
 217
 218 static void XIMPreEditDrawCallback(XIM ic, XPointer client_data,
 219                                    XIMPreeditDrawCallbackStruct *P_DR)
 220 {
 221     TRACE("PreEditDrawCallback %p\n",ic);
 222
 223     if (P_DR)
 224     {
 225         int sel = P_DR->chg_first;
 226         int len = P_DR->chg_length;
 227         if (P_DR->text)
 228         {
 229             if (! P_DR->text->encoding_is_wchar)
 230             {
 231                 DWORD dwOutput;
 232                 WCHAR *wcOutput;
 233
 234                 TRACE("multibyte\n");
 235                 dwOutput = MultiByteToWideChar(CP_UNIXCP, 0,
 236                            P_DR->text->string.multi_byte, -1,
 237                            NULL, 0);
 238                 wcOutput = HeapAlloc(GetProcessHeap(), 0, sizeof (WCHAR) * dwOutput);
 239                 if (wcOutput)
 240                 {
 241                     dwOutput = MultiByteToWideChar(CP_UNIXCP, 0,
 242                                P_DR->text->string.multi_byte, -1,
 243                                wcOutput, dwOutput);
 244
 245                     /* ignore null */
 246                     dwOutput --;
 247                     X11DRV_ImmSetInternalString (GCS_COMPSTR, sel, len, wcOutput, dwOutput);
 248                     HeapFree(GetProcessHeap(), 0, wcOutput);
 249                 }
 250             }
 251             else
 252             {
 253                 FIXME("wchar PROBIBILY WRONG\n");
 254                 X11DRV_ImmSetInternalString (GCS_COMPSTR, sel, len,
 255                                              (LPWSTR)P_DR->text->string.wide_char,
 256                                              P_DR->text->length);
 257             }
 258         }
 259         else
 260             X11DRV_ImmSetInternalString (GCS_COMPSTR, sel, len, NULL, 0);
 261         IME_SetCursorPos(P_DR->caret);
 262     }
 263     TRACE("Finished\n");
 264 }
 265
 266 static void XIMPreEditCaretCallback(XIC ic, XPointer client_data,
 267                                     XIMPreeditCaretCallbackStruct *P_C)
 268 {
 269     TRACE("PreeditCaretCallback %p\n",ic);
 270
 271     if (P_C)
 272     {
 273         int pos = IME_GetCursorPos();
 274         TRACE("pos: %d\n", pos);
 275         switch(P_C->direction)
 276         {
 277             case XIMForwardChar:
 278             case XIMForwardWord:
 279                 pos++;
 280                 break;
 281             case XIMBackwardChar:
 282             case XIMBackwardWord:
 283                 pos--;
 284                 break;
 285             case XIMLineStart:
 286                 pos = 0;
 287                 break;
 288             case XIMAbsolutePosition:
 289                 pos = P_C->position;
 290                 break;
 291             case XIMDontChange:
 292                 P_C->position = pos;
 293                 return;
 294             case XIMCaretUp:
 295             case XIMCaretDown:
 296             case XIMPreviousLine:
 297             case XIMNextLine:
 298             case XIMLineEnd:
 299                 FIXME("Not implemented\n");
 300                 break;
 301         }
 302         IME_SetCursorPos(pos);
 303         P_C->position = pos;
 304     }
 305     TRACE("Finished\n");
 306 }
 307
 308 void X11DRV_ForceXIMReset(HWND hwnd)
 309 {
 310     XIC ic = X11DRV_get_ic(hwnd);
 311     if (ic)
 312     {
 313         char* leftover;
 314         TRACE("Forcing Reset %p\n",ic);
 315         wine_tsx11_lock();
 316         leftover = XmbResetIC(ic);
 317         XFree(leftover);
 318         wine_tsx11_unlock();
 319     }
 320 }
 321
 322 /***********************************************************************
 323  *           X11DRV_InitXIM
 324  *
 325  * Process-wide XIM initialization.
 326  */
 327 BOOL X11DRV_InitXIM( const char *input_style )
 328 {
 329     BOOL ret;
 330
 331     if (!strcasecmp(input_style, "offthespot"))
 332         ximStyleRequest = STYLE_OFFTHESPOT;
 333     else if (!strcasecmp(input_style, "overthespot"))
 334         ximStyleRequest = STYLE_OVERTHESPOT;
 335     else if (!strcasecmp(input_style, "root"))
 336         ximStyleRequest = STYLE_ROOT;
 337
 338     wine_tsx11_lock();
 339     if (!(ret = XSupportsLocale()))
 340     {
 341         WARN("X does not support locale.\n");
 342     }
 343     else if (XSetLocaleModifiers("") == NULL)
 344     {
 345         WARN("Could not set locale modifiers.\n");
 346         ret = FALSE;
 347     }
 348     wine_tsx11_unlock();
 349     return ret;
 350 }
 351
 352
 353 static void open_xim_callback( Display *display, XPointer ptr, XPointer data );
 354
 355 static void X11DRV_DestroyIM(XIM xim, XPointer p, XPointer data)
 356 {
 357     struct x11drv_thread_data *thread_data = x11drv_thread_data();
 358
 359     TRACE("xim = %p, p = %p\n", xim, p);
 360     thread_data->xim = NULL;
 361     ximStyle = 0;
 362     wine_tsx11_lock();
 363     XRegisterIMInstantiateCallback( thread_data->display, NULL, NULL, NULL, open_xim_callback, NULL );
 364     wine_tsx11_unlock();
 365 }
 366
 367 /***********************************************************************
 368  *           X11DRV Ime creation
 369  *
 370  * Should always be called with the x11 lock held
 371  */
 372 static BOOL open_xim( Display *display )
 373 {
 374     struct x11drv_thread_data *thread_data = x11drv_thread_data();
 375     XIMStyle ximStyleCallback, ximStyleNone;
 376     XIMStyles *ximStyles = NULL;
 377     INT i;
 378     XIM xim;
 379     XIMCallback destroy;
 380
 381     xim = XOpenIM(display, NULL, NULL, NULL);
 382     if (xim == NULL)
 383     {
 384         WARN("Could not open input method.\n");
 385         return FALSE;
 386     }
 387
 388     destroy.client_data = NULL;
 389     destroy.callback = X11DRV_DestroyIM;
 390     if (XSetIMValues(xim, XNDestroyCallback, &destroy, NULL))
 391     {
 392         WARN("Could not set destroy callback.\n");
 393     }
 394
 395     TRACE("xim = %p\n", xim);
 396     TRACE("X display of IM = %p\n", XDisplayOfIM(xim));
 397     TRACE("Using %s locale of Input Method\n", XLocaleOfIM(xim));
 398
 399     XGetIMValues(xim, XNQueryInputStyle, &ximStyles, NULL);
 400     if (ximStyles == 0)
 401     {
 402         WARN("Could not find supported input style.\n");
 403         XCloseIM(xim);
 404         return FALSE;
 405     }
 406     else
 407     {
 408         TRACE("ximStyles->count_styles = %d\n", ximStyles->count_styles);
 409
 410         ximStyleRoot = 0;
 411         ximStyleNone = 0;
 412         ximStyleCallback = 0;
 413
 414         for (i = 0; i < ximStyles->count_styles; ++i)
 415         {
 416             int style = ximStyles->supported_styles[i];
 417             TRACE("ximStyles[%d] = %s%s%s%s%s\n", i,
 418                         (style&XIMPreeditArea)?"XIMPreeditArea ":"",
 419                         (style&XIMPreeditCallbacks)?"XIMPreeditCallbacks ":"",
 420                         (style&XIMPreeditPosition)?"XIMPreeditPosition ":"",
 421                         (style&XIMPreeditNothing)?"XIMPreeditNothing ":"",
 422                         (style&XIMPreeditNone)?"XIMPreeditNone ":"");
 423             if (!ximStyle && (ximStyles->supported_styles[i] ==
 424                                 ximStyleRequest))
 425             {
 426                 ximStyle = ximStyleRequest;
 427                 TRACE("Setting Style: ximStyle = ximStyleRequest\n");
 428             }
 429             else if (!ximStyleRoot &&(ximStyles->supported_styles[i] ==
 430                      STYLE_ROOT))
 431             {
 432                 ximStyleRoot = STYLE_ROOT;
 433                 TRACE("Setting Style: ximStyleRoot = STYLE_ROOT\n");
 434             }
 435             else if (!ximStyleCallback &&(ximStyles->supported_styles[i] ==
 436                      STYLE_CALLBACK))
 437             {
 438                 ximStyleCallback = STYLE_CALLBACK;
 439                 TRACE("Setting Style: ximStyleCallback = STYLE_CALLBACK\n");
 440             }
 441             else if (!ximStyleNone && (ximStyles->supported_styles[i] ==
 442                      STYLE_NONE))
 443             {
 444                 TRACE("Setting Style: ximStyleNone = STYLE_NONE\n");
 445                 ximStyleNone = STYLE_NONE;
 446             }
 447         }
 448         XFree(ximStyles);
 449
 450         if (ximStyle == 0)
 451             ximStyle = ximStyleRoot;
 452
 453         if (ximStyle == 0)
 454             ximStyle = ximStyleNone;
 455
 456         if (ximStyleCallback == 0)
 457         {
 458             TRACE("No callback style avalable\n");
 459             ximStyleCallback = ximStyle;
 460         }
 461
 462     }
 463
 464     thread_data->xim = xim;
 465
 466     if ((ximStyle & (XIMPreeditNothing | XIMPreeditNone)) == 0 ||
 467         (ximStyle & (XIMStatusNothing | XIMStatusNone)) == 0)
 468     {
 469         char **list;
 470         int count;
 471         thread_data->font_set = XCreateFontSet(display, "fixed",
 472                           &list, &count, NULL);
 473         TRACE("ximFontSet = %p\n", thread_data->font_set);
 474         TRACE("list = %p, count = %d\n", list, count);
 475         if (list != NULL)
 476         {
 477             int i;
 478             for (i = 0; i < count; ++i)
 479                 TRACE("list[%d] = %s\n", i, list[i]);
 480             XFreeStringList(list);
 481         }
 482     }
 483     else
 484         thread_data->font_set = NULL;
 485
 486     wine_tsx11_unlock();
 487     IME_UpdateAssociation(NULL);
 488     wine_tsx11_lock();
 489     return TRUE;
 490 }
 491
 492 static void open_xim_callback( Display *display, XPointer ptr, XPointer data )
 493 {
 494     if (open_xim( display ))
 495         XUnregisterIMInstantiateCallback( display, NULL, NULL, NULL, open_xim_callback, NULL);
 496 }
 497
 498 void X11DRV_SetupXIM(void)
 499 {
 500     Display *display = thread_display();
 501
 502     wine_tsx11_lock();
 503     if (!open_xim( display ))
 504         XRegisterIMInstantiateCallback( display, NULL, NULL, NULL, open_xim_callback, NULL );
 505     wine_tsx11_unlock();
 506 }
 507
 508 static BOOL X11DRV_DestroyIC(XIC xic, XPointer p, XPointer data)
 509 {
 510     struct x11drv_win_data *win_data = (struct x11drv_win_data *)p;
 511     TRACE("xic = %p, win = %lx\n", xic, win_data->whole_window);
 512     win_data->xic = NULL;
 513     return TRUE;
 514 }
 515
 516
 517 XIC X11DRV_CreateIC(XIM xim, struct x11drv_win_data *data)
 518 {
 519     XPoint spot = {0};
 520     XVaNestedList preedit = NULL;
 521     XVaNestedList status = NULL;
 522     XIC xic;
 523     XICCallback destroy = {(XPointer)data, (XICProc)X11DRV_DestroyIC};
 524     XICCallback P_StartCB, P_DoneCB, P_DrawCB, P_CaretCB;
 525     LANGID langid = PRIMARYLANGID(LANGIDFROMLCID(GetThreadLocale()));
 526     Window win = data->whole_window;
 527     XFontSet fontSet = x11drv_thread_data()->font_set;
 528
 529     TRACE("xim = %p\n", xim);
 530
 531     wine_tsx11_lock();
 532
 533     /* use complex and slow XIC initialization method only for CJK */
 534     if (langid != LANG_CHINESE &&
 535         langid != LANG_JAPANESE &&
 536         langid != LANG_KOREAN)
 537     {
 538         xic = XCreateIC(xim,
 539                         XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
 540                         XNClientWindow, win,
 541                         XNFocusWindow, win,
 542                         XNDestroyCallback, &destroy,
 543                         NULL);
 544         wine_tsx11_unlock();
 545         data->xic = xic;
 546         return xic;
 547     }
 548
 549     /* create callbacks */
 550     P_StartCB.client_data = NULL;
 551     P_DoneCB.client_data = NULL;
 552     P_DrawCB.client_data = NULL;
 553     P_CaretCB.client_data = NULL;
 554     P_StartCB.callback = (XICProc)XIMPreEditStartCallback;
 555     P_DoneCB.callback = (XICProc)XIMPreEditDoneCallback;
 556     P_DrawCB.callback = (XICProc)XIMPreEditDrawCallback;
 557     P_CaretCB.callback = (XICProc)XIMPreEditCaretCallback;
 558
 559     if ((ximStyle & (XIMPreeditNothing | XIMPreeditNone)) == 0)
 560     {
 561         preedit = XVaCreateNestedList(0,
 562                         XNFontSet, fontSet,
 563                         XNSpotLocation, &spot,
 564                         XNPreeditStartCallback, &P_StartCB,
 565                         XNPreeditDoneCallback, &P_DoneCB,
 566                         XNPreeditDrawCallback, &P_DrawCB,
 567                         XNPreeditCaretCallback, &P_CaretCB,
 568                         NULL);
 569         TRACE("preedit = %p\n", preedit);
 570     }
 571     else
 572     {
 573         preedit = XVaCreateNestedList(0,
 574                         XNPreeditStartCallback, &P_StartCB,
 575                         XNPreeditDoneCallback, &P_DoneCB,
 576                         XNPreeditDrawCallback, &P_DrawCB,
 577                         XNPreeditCaretCallback, &P_CaretCB,
 578                         NULL);
 579
 580         TRACE("preedit = %p\n", preedit);
 581     }
 582
 583     if ((ximStyle & (XIMStatusNothing | XIMStatusNone)) == 0)
 584     {
 585         status = XVaCreateNestedList(0,
 586             XNFontSet, fontSet,
 587             NULL);
 588         TRACE("status = %p\n", status);
 589      }
 590
 591     if (preedit != NULL && status != NULL)
 592     {
 593         xic = XCreateIC(xim,
 594               XNInputStyle, ximStyle,
 595               XNPreeditAttributes, preedit,
 596               XNStatusAttributes, status,
 597               XNClientWindow, win,
 598               XNFocusWindow, win,
 599               XNDestroyCallback, &destroy,
 600               NULL);
 601      }
 602     else if (preedit != NULL)
 603     {
 604         xic = XCreateIC(xim,
 605               XNInputStyle, ximStyle,
 606               XNPreeditAttributes, preedit,
 607               XNClientWindow, win,
 608               XNFocusWindow, win,
 609               XNDestroyCallback, &destroy,
 610               NULL);
 611     }
 612     else if (status != NULL)
 613     {
 614         xic = XCreateIC(xim,
 615               XNInputStyle, ximStyle,
 616               XNStatusAttributes, status,
 617               XNClientWindow, win,
 618               XNFocusWindow, win,
 619               XNDestroyCallback, &destroy,
 620               NULL);
 621     }
 622     else
 623     {
 624         xic = XCreateIC(xim,
 625               XNInputStyle, ximStyle,
 626               XNClientWindow, win,
 627               XNFocusWindow, win,
 628               XNDestroyCallback, &destroy,
 629               NULL);
 630     }
 631
 632     TRACE("xic = %p\n", xic);
 633     data->xic = xic;
 634
 635     if (preedit != NULL)
 636         XFree(preedit);
 637     if (status != NULL)
 638         XFree(status);
 639
 640     wine_tsx11_unlock();
 641
 642     return xic;
 643 }