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