dlls/winex11.drv/ime.c

   1 /*
   2  * The IME for interfacing with XIM
   3  *
   4  * Copyright 2008 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 /*
  22  * Notes:
  23  *  The normal flow for IMM/IME Processing is as follows.
  24  * 1) The Keyboard Driver generates key messages which are first passed to
  25  *    the IMM and then to IME via ImeProcessKey. If the IME returns 0  then
  26  *    it does not want the key and the keyboard driver then generates the
  27  *    WM_KEYUP/WM_KEYDOWN messages.  However if the IME is going to process the
  28  *    key it returns non-zero.
  29  * 2) If the IME is going to process the key then the IMM calls ImeToAsciiEx to
  30  *    process the key.  the IME modifies the HIMC structure to reflect the
  31  *    current state and generates any messages it needs the IMM to process.
  32  * 3) IMM checks the messages and send them to the application in question. From
  33  *    here the IMM level deals with if the application is IME aware or not.
  34  *
  35  *  This flow does not work well for the X11 driver and XIM.
  36  *   (It works fine for Mac)
  37  *  As such we will have to reroute step 1.  Instead the x11drv driver will
  38  *  generate an XIM events and call directly into this IME implementation.
  39  *  As such we will have to use the alternative ImmGenerateMessage path to be
  40  *  generate the messages that we want the IMM layer to send to the application.
  41  */
  42
  43 #include "x11drv_dll.h"
  44 #include "wine/debug.h"
  45 #include "imm.h"
  46 #include "immdev.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(imm);
  49
  50 #define FROM_X11 ((HIMC)0xcafe1337)
  51
  52 static HIMC *hSelectedFrom = NULL;
  53 static INT  hSelectedCount = 0;
  54
  55 static void input_context_reset_comp_str( INPUTCONTEXT *ctx )
  56 {
  57     COMPOSITIONSTRING *compstr;
  58
  59     if (!(compstr = ImmLockIMCC( ctx->hCompStr )))
  60         WARN( "Failed to lock input context composition string\n" );
  61     else
  62     {
  63         memset( compstr, 0, sizeof(*compstr) );
  64         compstr->dwSize = sizeof(*compstr);
  65         ImmUnlockIMCC( ctx->hCompStr );
  66     }
  67 }
  68
  69 static HIMC RealIMC(HIMC hIMC)
  70 {
  71     if (hIMC == FROM_X11)
  72     {
  73         INT i;
  74         HWND wnd = GetFocus();
  75         HIMC winHimc = ImmGetContext(wnd);
  76         for (i = 0; i < hSelectedCount; i++)
  77             if (winHimc == hSelectedFrom[i])
  78                 return winHimc;
  79         return NULL;
  80     }
  81     else
  82         return hIMC;
  83 }
  84
  85 static LPINPUTCONTEXT LockRealIMC(HIMC hIMC)
  86 {
  87     HIMC real_imc = RealIMC(hIMC);
  88     if (real_imc)
  89         return ImmLockIMC(real_imc);
  90     else
  91         return NULL;
  92 }
  93
  94 static BOOL UnlockRealIMC(HIMC hIMC)
  95 {
  96     HIMC real_imc = RealIMC(hIMC);
  97     if (real_imc)
  98         return ImmUnlockIMC(real_imc);
  99     else
 100         return FALSE;
 101 }
 102
 103 static int updateField(DWORD origLen, DWORD origOffset, DWORD currentOffset,
 104                        LPBYTE target, LPBYTE source, DWORD* lenParam,
 105                        DWORD* offsetParam, BOOL wchars )
 106 {
 107      if (origLen > 0 && origOffset > 0)
 108      {
 109         int truelen = origLen;
 110         if (wchars)
 111             truelen *= sizeof(WCHAR);
 112
 113         memcpy(&target[currentOffset], &source[origOffset], truelen);
 114
 115         *lenParam = origLen;
 116         *offsetParam = currentOffset;
 117         currentOffset += truelen;
 118      }
 119      return currentOffset;
 120 }
 121
 122 static HIMCC updateCompStr(HIMCC old, LPCWSTR compstr, DWORD len)
 123 {
 124     /* We need to make sure the CompStr, CompClause and CompAttr fields are all
 125      * set and correct. */
 126     int needed_size;
 127     HIMCC   rc;
 128     LPBYTE newdata = NULL;
 129     LPBYTE olddata = NULL;
 130     LPCOMPOSITIONSTRING new_one;
 131     LPCOMPOSITIONSTRING lpcs = NULL;
 132     INT current_offset = 0;
 133
 134     TRACE("%s, %li\n",debugstr_wn(compstr,len),len);
 135
 136     if (old == NULL && compstr == NULL && len == 0)
 137         return NULL;
 138
 139     if (compstr == NULL && len != 0)
 140     {
 141         ERR("compstr is NULL however we have a len!  Please report\n");
 142         len = 0;
 143     }
 144
 145     if (old != NULL)
 146     {
 147         olddata = ImmLockIMCC(old);
 148         lpcs = (LPCOMPOSITIONSTRING)olddata;
 149     }
 150
 151     needed_size = sizeof(COMPOSITIONSTRING) + len * sizeof(WCHAR) +
 152                   len + sizeof(DWORD) * 2;
 153
 154     if (lpcs != NULL)
 155     {
 156         needed_size += lpcs->dwCompReadAttrLen;
 157         needed_size += lpcs->dwCompReadClauseLen;
 158         needed_size += lpcs->dwCompReadStrLen * sizeof(WCHAR);
 159         needed_size += lpcs->dwResultReadClauseLen;
 160         needed_size += lpcs->dwResultReadStrLen * sizeof(WCHAR);
 161         needed_size += lpcs->dwResultClauseLen;
 162         needed_size += lpcs->dwResultStrLen * sizeof(WCHAR);
 163         needed_size += lpcs->dwPrivateSize;
 164     }
 165     rc = ImmCreateIMCC(needed_size);
 166     newdata = ImmLockIMCC(rc);
 167     new_one = (LPCOMPOSITIONSTRING)newdata;
 168
 169     new_one->dwSize = needed_size;
 170     current_offset = sizeof(COMPOSITIONSTRING);
 171     if (lpcs != NULL)
 172     {
 173         current_offset = updateField(lpcs->dwCompReadAttrLen,
 174                                      lpcs->dwCompReadAttrOffset,
 175                                      current_offset, newdata, olddata,
 176                                      &new_one->dwCompReadAttrLen,
 177                                      &new_one->dwCompReadAttrOffset, FALSE);
 178
 179         current_offset = updateField(lpcs->dwCompReadClauseLen,
 180                                      lpcs->dwCompReadClauseOffset,
 181                                      current_offset, newdata, olddata,
 182                                      &new_one->dwCompReadClauseLen,
 183                                      &new_one->dwCompReadClauseOffset, FALSE);
 184
 185         current_offset = updateField(lpcs->dwCompReadStrLen,
 186                                      lpcs->dwCompReadStrOffset,
 187                                      current_offset, newdata, olddata,
 188                                      &new_one->dwCompReadStrLen,
 189                                      &new_one->dwCompReadStrOffset, TRUE);
 190
 191         /* new CompAttr, CompClause, CompStr, dwCursorPos */
 192         new_one->dwDeltaStart = 0;
 193
 194         current_offset = updateField(lpcs->dwResultReadClauseLen,
 195                                      lpcs->dwResultReadClauseOffset,
 196                                      current_offset, newdata, olddata,
 197                                      &new_one->dwResultReadClauseLen,
 198                                      &new_one->dwResultReadClauseOffset, FALSE);
 199
 200         current_offset = updateField(lpcs->dwResultReadStrLen,
 201                                      lpcs->dwResultReadStrOffset,
 202                                      current_offset, newdata, olddata,
 203                                      &new_one->dwResultReadStrLen,
 204                                      &new_one->dwResultReadStrOffset, TRUE);
 205
 206         current_offset = updateField(lpcs->dwResultClauseLen,
 207                                      lpcs->dwResultClauseOffset,
 208                                      current_offset, newdata, olddata,
 209                                      &new_one->dwResultClauseLen,
 210                                      &new_one->dwResultClauseOffset, FALSE);
 211
 212         current_offset = updateField(lpcs->dwResultStrLen,
 213                                      lpcs->dwResultStrOffset,
 214                                      current_offset, newdata, olddata,
 215                                      &new_one->dwResultStrLen,
 216                                      &new_one->dwResultStrOffset, TRUE);
 217
 218         current_offset = updateField(lpcs->dwPrivateSize,
 219                                      lpcs->dwPrivateOffset,
 220                                      current_offset, newdata, olddata,
 221                                      &new_one->dwPrivateSize,
 222                                      &new_one->dwPrivateOffset, FALSE);
 223     }
 224
 225     /* set new data */
 226     /* CompAttr */
 227     new_one->dwCompAttrLen = len;
 228     if (len > 0)
 229     {
 230         new_one->dwCompAttrOffset = current_offset;
 231         memset(&newdata[current_offset],ATTR_INPUT,len);
 232         current_offset += len;
 233     }
 234
 235     /* CompClause */
 236     if (len > 0)
 237     {
 238         new_one->dwCompClauseLen = sizeof(DWORD) * 2;
 239         new_one->dwCompClauseOffset = current_offset;
 240         *(DWORD*)(&newdata[current_offset]) = 0;
 241         current_offset += sizeof(DWORD);
 242         *(DWORD*)(&newdata[current_offset]) = len;
 243         current_offset += sizeof(DWORD);
 244     }
 245     else
 246         new_one->dwCompClauseLen = 0;
 247
 248     /* CompStr */
 249     new_one->dwCompStrLen = len;
 250     if (len > 0)
 251     {
 252         new_one->dwCompStrOffset = current_offset;
 253         memcpy(&newdata[current_offset],compstr,len*sizeof(WCHAR));
 254     }
 255
 256     /* CursorPos */
 257     new_one->dwCursorPos = len;
 258
 259     ImmUnlockIMCC(rc);
 260     if (lpcs)
 261         ImmUnlockIMCC(old);
 262
 263     return rc;
 264 }
 265
 266 static HIMCC updateResultStr(HIMCC old, LPWSTR resultstr, DWORD len)
 267 {
 268     /* we need to make sure the ResultStr and ResultClause fields are all
 269      * set and correct */
 270     int needed_size;
 271     HIMCC   rc;
 272     LPBYTE newdata = NULL;
 273     LPBYTE olddata = NULL;
 274     LPCOMPOSITIONSTRING new_one;
 275     LPCOMPOSITIONSTRING lpcs = NULL;
 276     INT current_offset = 0;
 277
 278     TRACE("%s, %li\n",debugstr_wn(resultstr,len),len);
 279
 280     if (old == NULL && resultstr == NULL && len == 0)
 281         return NULL;
 282
 283     if (resultstr == NULL && len != 0)
 284     {
 285         ERR("resultstr is NULL however we have a len!  Please report\n");
 286         len = 0;
 287     }
 288
 289     if (old != NULL)
 290     {
 291         olddata = ImmLockIMCC(old);
 292         lpcs = (LPCOMPOSITIONSTRING)olddata;
 293     }
 294
 295     needed_size = sizeof(COMPOSITIONSTRING) + len * sizeof(WCHAR) +
 296                   sizeof(DWORD) * 2;
 297
 298     if (lpcs != NULL)
 299     {
 300         needed_size += lpcs->dwCompReadAttrLen;
 301         needed_size += lpcs->dwCompReadClauseLen;
 302         needed_size += lpcs->dwCompReadStrLen * sizeof(WCHAR);
 303         needed_size += lpcs->dwCompAttrLen;
 304         needed_size += lpcs->dwCompClauseLen;
 305         needed_size += lpcs->dwCompStrLen * sizeof(WCHAR);
 306         needed_size += lpcs->dwResultReadClauseLen;
 307         needed_size += lpcs->dwResultReadStrLen * sizeof(WCHAR);
 308         needed_size += lpcs->dwPrivateSize;
 309     }
 310     rc = ImmCreateIMCC(needed_size);
 311     newdata = ImmLockIMCC(rc);
 312     new_one = (LPCOMPOSITIONSTRING)newdata;
 313
 314     new_one->dwSize = needed_size;
 315     current_offset = sizeof(COMPOSITIONSTRING);
 316     if (lpcs != NULL)
 317     {
 318         current_offset = updateField(lpcs->dwCompReadAttrLen,
 319                                      lpcs->dwCompReadAttrOffset,
 320                                      current_offset, newdata, olddata,
 321                                      &new_one->dwCompReadAttrLen,
 322                                      &new_one->dwCompReadAttrOffset, FALSE);
 323
 324         current_offset = updateField(lpcs->dwCompReadClauseLen,
 325                                      lpcs->dwCompReadClauseOffset,
 326                                      current_offset, newdata, olddata,
 327                                      &new_one->dwCompReadClauseLen,
 328                                      &new_one->dwCompReadClauseOffset, FALSE);
 329
 330         current_offset = updateField(lpcs->dwCompReadStrLen,
 331                                      lpcs->dwCompReadStrOffset,
 332                                      current_offset, newdata, olddata,
 333                                      &new_one->dwCompReadStrLen,
 334                                      &new_one->dwCompReadStrOffset, TRUE);
 335
 336         current_offset = updateField(lpcs->dwCompAttrLen,
 337                                      lpcs->dwCompAttrOffset,
 338                                      current_offset, newdata, olddata,
 339                                      &new_one->dwCompAttrLen,
 340                                      &new_one->dwCompAttrOffset, FALSE);
 341
 342         current_offset = updateField(lpcs->dwCompClauseLen,
 343                                      lpcs->dwCompClauseOffset,
 344                                      current_offset, newdata, olddata,
 345                                      &new_one->dwCompClauseLen,
 346                                      &new_one->dwCompClauseOffset, FALSE);
 347
 348         current_offset = updateField(lpcs->dwCompStrLen,
 349                                      lpcs->dwCompStrOffset,
 350                                      current_offset, newdata, olddata,
 351                                      &new_one->dwCompStrLen,
 352                                      &new_one->dwCompStrOffset, TRUE);
 353
 354         new_one->dwCursorPos = lpcs->dwCursorPos;
 355         new_one->dwDeltaStart = 0;
 356
 357         current_offset = updateField(lpcs->dwResultReadClauseLen,
 358                                      lpcs->dwResultReadClauseOffset,
 359                                      current_offset, newdata, olddata,
 360                                      &new_one->dwResultReadClauseLen,
 361                                      &new_one->dwResultReadClauseOffset, FALSE);
 362
 363         current_offset = updateField(lpcs->dwResultReadStrLen,
 364                                      lpcs->dwResultReadStrOffset,
 365                                      current_offset, newdata, olddata,
 366                                      &new_one->dwResultReadStrLen,
 367                                      &new_one->dwResultReadStrOffset, TRUE);
 368
 369         /* new ResultClause , ResultStr */
 370
 371         current_offset = updateField(lpcs->dwPrivateSize,
 372                                      lpcs->dwPrivateOffset,
 373                                      current_offset, newdata, olddata,
 374                                      &new_one->dwPrivateSize,
 375                                      &new_one->dwPrivateOffset, FALSE);
 376     }
 377
 378     /* set new data */
 379     /* ResultClause */
 380     if (len > 0)
 381     {
 382         new_one->dwResultClauseLen = sizeof(DWORD) * 2;
 383         new_one->dwResultClauseOffset = current_offset;
 384         *(DWORD*)(&newdata[current_offset]) = 0;
 385         current_offset += sizeof(DWORD);
 386         *(DWORD*)(&newdata[current_offset]) = len;
 387         current_offset += sizeof(DWORD);
 388     }
 389     else
 390         new_one->dwResultClauseLen = 0;
 391
 392     /* ResultStr */
 393     new_one->dwResultStrLen = len;
 394     if (len > 0)
 395     {
 396         new_one->dwResultStrOffset = current_offset;
 397         memcpy(&newdata[current_offset],resultstr,len*sizeof(WCHAR));
 398     }
 399     ImmUnlockIMCC(rc);
 400     if (lpcs)
 401         ImmUnlockIMCC(old);
 402
 403     return rc;
 404 }
 405
 406 static void GenerateIMEMessage(HIMC hIMC, UINT msg, WPARAM wParam,
 407                                LPARAM lParam)
 408 {
 409     LPINPUTCONTEXT lpIMC;
 410     LPTRANSMSG lpTransMsg;
 411
 412     lpIMC = LockRealIMC(hIMC);
 413     if (lpIMC == NULL)
 414         return;
 415
 416     lpIMC->hMsgBuf = ImmReSizeIMCC(lpIMC->hMsgBuf, (lpIMC->dwNumMsgBuf + 1) *
 417                                     sizeof(TRANSMSG));
 418     if (!lpIMC->hMsgBuf)
 419         return;
 420
 421     lpTransMsg = ImmLockIMCC(lpIMC->hMsgBuf);
 422     if (!lpTransMsg)
 423         return;
 424
 425     lpTransMsg += lpIMC->dwNumMsgBuf;
 426     lpTransMsg->message = msg;
 427     lpTransMsg->wParam = wParam;
 428     lpTransMsg->lParam = lParam;
 429
 430     ImmUnlockIMCC(lpIMC->hMsgBuf);
 431     lpIMC->dwNumMsgBuf++;
 432
 433     ImmGenerateMessage(RealIMC(hIMC));
 434     UnlockRealIMC(hIMC);
 435 }
 436
 437 static void ime_set_composition_status( HIMC himc, BOOL composition )
 438 {
 439     struct ime_private *priv;
 440     INPUTCONTEXT *ctx;
 441     UINT msg = 0;
 442
 443     if (!(ctx = ImmLockIMC( himc ))) return;
 444     if ((priv = ImmLockIMCC( ctx->hPrivate )))
 445     {
 446         if (!priv->bInComposition && composition) msg = WM_IME_STARTCOMPOSITION;
 447         else if (priv->bInComposition && !composition) msg = WM_IME_ENDCOMPOSITION;
 448         priv->bInComposition = composition;
 449         ImmUnlockIMCC( ctx->hPrivate );
 450     }
 451     ImmUnlockIMC( himc );
 452
 453     if (msg) GenerateIMEMessage( himc, msg, 0, 0 );
 454 }
 455
 456 static BOOL IME_RemoveFromSelected(HIMC hIMC)
 457 {
 458     int i;
 459     for (i = 0; i < hSelectedCount; i++)
 460         if (hSelectedFrom[i] == hIMC)
 461         {
 462             if (i < hSelectedCount - 1)
 463                 memmove(&hSelectedFrom[i], &hSelectedFrom[i+1], (hSelectedCount - i - 1)*sizeof(HIMC));
 464             hSelectedCount --;
 465             return TRUE;
 466         }
 467     return FALSE;
 468 }
 469
 470 static void IME_AddToSelected(HIMC hIMC)
 471 {
 472     hSelectedCount++;
 473     if (hSelectedFrom)
 474         hSelectedFrom = HeapReAlloc(GetProcessHeap(), 0, hSelectedFrom, hSelectedCount*sizeof(HIMC));
 475     else
 476         hSelectedFrom = HeapAlloc(GetProcessHeap(), 0, sizeof(HIMC));
 477     hSelectedFrom[hSelectedCount-1] = hIMC;
 478 }
 479
 480 BOOL WINAPI ImeProcessKey(HIMC hIMC, UINT vKey, LPARAM lKeyData, const LPBYTE lpbKeyState)
 481 {
 482     /* See the comment at the head of this file */
 483     TRACE("We do no processing via this route\n");
 484     return FALSE;
 485 }
 486
 487 BOOL WINAPI ImeSelect(HIMC hIMC, BOOL fSelect)
 488 {
 489     LPINPUTCONTEXT lpIMC;
 490     TRACE("%p %s\n",hIMC,(fSelect)?"TRUE":"FALSE");
 491
 492     if (hIMC == FROM_X11)
 493     {
 494         ERR("ImeSelect should never be called from X11\n");
 495         return FALSE;
 496     }
 497
 498     if (!hIMC)
 499         return TRUE;
 500
 501     /* not selected */
 502     if (!fSelect)
 503         return IME_RemoveFromSelected(hIMC);
 504
 505     IME_AddToSelected(hIMC);
 506
 507     /* Initialize our structures */
 508     lpIMC = LockRealIMC(hIMC);
 509     if (lpIMC != NULL)
 510     {
 511         LPIMEPRIVATE myPrivate;
 512         myPrivate = ImmLockIMCC(lpIMC->hPrivate);
 513         myPrivate->bInComposition = FALSE;
 514         myPrivate->bInternalState = FALSE;
 515         myPrivate->textfont = NULL;
 516         myPrivate->hwndDefault = NULL;
 517         ImmUnlockIMCC(lpIMC->hPrivate);
 518         UnlockRealIMC(hIMC);
 519     }
 520
 521     return TRUE;
 522 }
 523
 524 UINT WINAPI ImeToAsciiEx (UINT uVKey, UINT uScanCode, const LPBYTE lpbKeyState,
 525                           TRANSMSGLIST *lpdwTransKey, UINT fuState, HIMC hIMC)
 526 {
 527     /* See the comment at the head of this file */
 528     TRACE("We do no processing via this route\n");
 529     return 0;
 530 }
 531
 532 BOOL WINAPI NotifyIME(HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
 533 {
 534     struct xim_preedit_state_params preedit_params;
 535     BOOL bRet = FALSE;
 536     LPINPUTCONTEXT lpIMC;
 537
 538     TRACE("%p %li %li %li\n",hIMC,dwAction,dwIndex,dwValue);
 539
 540     lpIMC = LockRealIMC(hIMC);
 541     if (lpIMC == NULL)
 542         return FALSE;
 543
 544     switch (dwAction)
 545     {
 546         case NI_OPENCANDIDATE: FIXME("NI_OPENCANDIDATE\n"); break;
 547         case NI_CLOSECANDIDATE: FIXME("NI_CLOSECANDIDATE\n"); break;
 548         case NI_SELECTCANDIDATESTR: FIXME("NI_SELECTCANDIDATESTR\n"); break;
 549         case NI_CHANGECANDIDATELIST: FIXME("NI_CHANGECANDIDATELIST\n"); break;
 550         case NI_SETCANDIDATE_PAGESTART: FIXME("NI_SETCANDIDATE_PAGESTART\n"); break;
 551         case NI_SETCANDIDATE_PAGESIZE: FIXME("NI_SETCANDIDATE_PAGESIZE\n"); break;
 552         case NI_CONTEXTUPDATED:
 553             switch (dwValue)
 554             {
 555                 case IMC_SETCOMPOSITIONWINDOW: FIXME("IMC_SETCOMPOSITIONWINDOW\n"); break;
 556                 case IMC_SETCONVERSIONMODE: FIXME("IMC_SETCONVERSIONMODE\n"); break;
 557                 case IMC_SETSENTENCEMODE: FIXME("IMC_SETSENTENCEMODE\n"); break;
 558                 case IMC_SETCANDIDATEPOS: FIXME("IMC_SETCANDIDATEPOS\n"); break;
 559                 case IMC_SETCOMPOSITIONFONT:
 560                     {
 561                         LPIMEPRIVATE myPrivate;
 562                         TRACE("IMC_SETCOMPOSITIONFONT\n");
 563
 564                         myPrivate = ImmLockIMCC(lpIMC->hPrivate);
 565                         if (myPrivate->textfont)
 566                         {
 567                             DeleteObject(myPrivate->textfont);
 568                             myPrivate->textfont = NULL;
 569                         }
 570                         myPrivate->textfont = CreateFontIndirectW(&lpIMC->lfFont.W);
 571                         ImmUnlockIMCC(lpIMC->hPrivate);
 572                     }
 573                     break;
 574                 case IMC_SETOPENSTATUS:
 575                     bRet = TRUE;
 576                     preedit_params.hwnd = lpIMC->hWnd;
 577                     preedit_params.open = lpIMC->fOpen;
 578                     X11DRV_CALL( xim_preedit_state, &preedit_params );
 579                     if (!lpIMC->fOpen)
 580                     {
 581                         X11DRV_CALL( xim_reset, lpIMC->hWnd );
 582                         input_context_reset_comp_str( lpIMC );
 583                         ime_set_composition_status( hIMC, FALSE );
 584                     }
 585                     break;
 586                 default: FIXME("Unknown\n"); break;
 587             }
 588             break;
 589         case NI_COMPOSITIONSTR:
 590             switch (dwIndex)
 591             {
 592                 case CPS_COMPLETE:
 593                 {
 594                     COMPOSITIONSTRING *compstr;
 595
 596                     if (!(compstr = ImmLockIMCC( lpIMC->hCompStr )))
 597                         WARN( "Failed to lock input context composition string\n" );
 598                     else
 599                     {
 600                         WCHAR wchr = *(WCHAR *)((BYTE *)compstr + compstr->dwCompStrOffset);
 601                         COMPOSITIONSTRING tmp = *compstr;
 602                         UINT flags = 0;
 603
 604                         memset( compstr, 0, sizeof(*compstr) );
 605                         compstr->dwSize = tmp.dwSize;
 606                         compstr->dwResultStrLen = tmp.dwCompStrLen;
 607                         compstr->dwResultStrOffset = tmp.dwCompStrOffset;
 608                         compstr->dwResultClauseLen = tmp.dwCompClauseLen;
 609                         compstr->dwResultClauseOffset = tmp.dwCompClauseOffset;
 610                         ImmUnlockIMCC( lpIMC->hCompStr );
 611
 612                         if (tmp.dwCompStrLen) flags |= GCS_RESULTSTR;
 613                         if (tmp.dwCompClauseLen) flags |= GCS_RESULTCLAUSE;
 614                         if (flags) GenerateIMEMessage( hIMC, WM_IME_COMPOSITION, wchr, flags );
 615                     }
 616
 617                     ImmSetOpenStatus( hIMC, FALSE );
 618                     bRet = TRUE;
 619                 }
 620                 break;
 621                 case CPS_CONVERT: FIXME("CPS_CONVERT\n"); break;
 622                 case CPS_REVERT: FIXME("CPS_REVERT\n"); break;
 623                 case CPS_CANCEL:
 624                     input_context_reset_comp_str( lpIMC );
 625                     ime_set_composition_status( hIMC, FALSE );
 626                     bRet = TRUE;
 627                     break;
 628                 default: FIXME("Unknown\n"); break;
 629             }
 630             break;
 631         default: FIXME("Unknown Message\n"); break;
 632     }
 633
 634     UnlockRealIMC(hIMC);
 635     return bRet;
 636 }
 637
 638 BOOL WINAPI ImeSetCompositionString(HIMC hIMC, DWORD dwIndex, LPCVOID lpComp,
 639                                     DWORD dwCompLen, LPCVOID lpRead,
 640                                     DWORD dwReadLen)
 641 {
 642     LPINPUTCONTEXT lpIMC;
 643     DWORD flags = 0;
 644     WCHAR wParam  = 0;
 645
 646     TRACE("(%p, %ld, %p, %ld, %p, %ld):\n",
 647          hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
 648
 649
 650     if (hIMC != FROM_X11)
 651         FIXME("PROBLEM: This only sets the wine level string\n");
 652
 653     /*
 654     * Explanation:
 655     *  this sets the composition string in the imm32.dll level
 656     *  of the composition buffer. we cannot manipulate the xim level
 657     *  buffer, which means that once the xim level buffer changes again
 658     *  any call to this function from the application will be lost
 659     */
 660
 661     if (lpRead && dwReadLen)
 662         FIXME("Reading string unimplemented\n");
 663
 664     lpIMC = LockRealIMC(hIMC);
 665
 666     if (lpIMC == NULL)
 667         return FALSE;
 668
 669     if (dwIndex == SCS_SETSTR)
 670     {
 671         HIMCC newCompStr;
 672
 673         ime_set_composition_status( hIMC, TRUE );
 674
 675         /* clear existing result */
 676         newCompStr = updateResultStr(lpIMC->hCompStr, NULL, 0);
 677         ImmDestroyIMCC(lpIMC->hCompStr);
 678         lpIMC->hCompStr = newCompStr;
 679
 680         flags = GCS_COMPSTR;
 681
 682         if (dwCompLen && lpComp)
 683         {
 684             newCompStr = updateCompStr(lpIMC->hCompStr, (LPCWSTR)lpComp, dwCompLen / sizeof(WCHAR));
 685             ImmDestroyIMCC(lpIMC->hCompStr);
 686             lpIMC->hCompStr = newCompStr;
 687
 688              wParam = ((const WCHAR*)lpComp)[0];
 689              flags |= GCS_COMPCLAUSE | GCS_COMPATTR | GCS_DELTASTART;
 690         }
 691         else
 692         {
 693             newCompStr = updateCompStr(lpIMC->hCompStr, NULL, 0);
 694             ImmDestroyIMCC(lpIMC->hCompStr);
 695             lpIMC->hCompStr = newCompStr;
 696         }
 697     }
 698
 699     GenerateIMEMessage(hIMC, WM_IME_COMPOSITION, wParam, flags);
 700     ImmUnlockIMCC(lpIMC->hPrivate);
 701     UnlockRealIMC(hIMC);
 702
 703     return TRUE;
 704 }
 705
 706 /* Interfaces to XIM and other parts of winex11drv */
 707
 708 NTSTATUS x11drv_ime_set_open_status( UINT open )
 709 {
 710     HIMC imc;
 711
 712     imc = RealIMC(FROM_X11);
 713     ImmSetOpenStatus(imc, open);
 714     return 0;
 715 }
 716
 717 NTSTATUS x11drv_ime_set_composition_status( UINT open )
 718 {
 719     HIMC imc;
 720     LPINPUTCONTEXT lpIMC;
 721
 722     imc = RealIMC(FROM_X11);
 723     lpIMC = ImmLockIMC(imc);
 724     if (lpIMC == NULL)
 725         return 0;
 726
 727     if (!open)
 728     {
 729         struct ime_private *myPrivate = ImmLockIMCC(lpIMC->hPrivate);
 730         ShowWindow(myPrivate->hwndDefault, SW_HIDE);
 731         input_context_reset_comp_str( lpIMC );
 732         ImmUnlockIMCC(lpIMC->hPrivate);
 733     }
 734
 735     ImmUnlockIMC(imc);
 736
 737     ime_set_composition_status( imc, open );
 738
 739     return 0;
 740 }
 741
 742 NTSTATUS x11drv_ime_get_cursor_pos( UINT arg )
 743 {
 744     LPINPUTCONTEXT lpIMC;
 745     INT rc = 0;
 746     LPCOMPOSITIONSTRING compstr;
 747
 748     if (!hSelectedFrom)
 749         return rc;
 750
 751     lpIMC = LockRealIMC(FROM_X11);
 752     if (lpIMC)
 753     {
 754         compstr = ImmLockIMCC(lpIMC->hCompStr);
 755         rc = compstr->dwCursorPos;
 756         ImmUnlockIMCC(lpIMC->hCompStr);
 757     }
 758     UnlockRealIMC(FROM_X11);
 759     return rc;
 760 }
 761
 762 NTSTATUS x11drv_ime_set_cursor_pos( UINT pos )
 763 {
 764     LPINPUTCONTEXT lpIMC;
 765     LPCOMPOSITIONSTRING compstr;
 766
 767     if (!hSelectedFrom)
 768         return 0;
 769
 770     lpIMC = LockRealIMC(FROM_X11);
 771     if (!lpIMC)
 772         return 0;
 773
 774     compstr = ImmLockIMCC(lpIMC->hCompStr);
 775     if (!compstr)
 776     {
 777         UnlockRealIMC(FROM_X11);
 778         return 0;
 779     }
 780
 781     compstr->dwCursorPos = pos;
 782     ImmUnlockIMCC(lpIMC->hCompStr);
 783     UnlockRealIMC(FROM_X11);
 784     GenerateIMEMessage(FROM_X11, WM_IME_COMPOSITION, pos, GCS_CURSORPOS);
 785     return 0;
 786 }
 787
 788 NTSTATUS x11drv_ime_update_association( UINT arg )
 789 {
 790     HWND focus = UlongToHandle( arg );
 791
 792     ImmGetContext(focus);
 793
 794     if (focus && hSelectedFrom)
 795         ImmAssociateContext(focus,RealIMC(FROM_X11));
 796     return 0;
 797 }
 798
 799
 800 NTSTATUS WINAPI x11drv_ime_set_composition_string( void *param, ULONG size )
 801 {
 802     return ImeSetCompositionString(FROM_X11, SCS_SETSTR, param, size, NULL, 0);
 803 }
 804
 805 NTSTATUS WINAPI x11drv_ime_set_result( void *params, ULONG len )
 806 {
 807     WCHAR *lpResult = params;
 808     HIMC imc;
 809     LPINPUTCONTEXT lpIMC;
 810     HIMCC newCompStr;
 811     LPIMEPRIVATE myPrivate;
 812     BOOL inComp;
 813     HWND focus;
 814
 815     len /= sizeof(WCHAR);
 816     if ((focus = GetFocus()))
 817         x11drv_ime_update_association( HandleToUlong( focus ));
 818
 819     imc = RealIMC(FROM_X11);
 820     lpIMC = ImmLockIMC(imc);
 821     if (lpIMC == NULL)
 822         return 0;
 823
 824     newCompStr = updateCompStr(lpIMC->hCompStr, NULL, 0);
 825     ImmDestroyIMCC(lpIMC->hCompStr);
 826     lpIMC->hCompStr = newCompStr;
 827
 828     newCompStr = updateResultStr(lpIMC->hCompStr, lpResult, len);
 829     ImmDestroyIMCC(lpIMC->hCompStr);
 830     lpIMC->hCompStr = newCompStr;
 831
 832     myPrivate = ImmLockIMCC(lpIMC->hPrivate);
 833     inComp = myPrivate->bInComposition;
 834     ImmUnlockIMCC(lpIMC->hPrivate);
 835
 836     if (!inComp)
 837     {
 838         ImmSetOpenStatus(imc, TRUE);
 839         GenerateIMEMessage(imc, WM_IME_STARTCOMPOSITION, 0, 0);
 840     }
 841
 842     GenerateIMEMessage(imc, WM_IME_COMPOSITION, 0, GCS_COMPSTR);
 843     GenerateIMEMessage(imc, WM_IME_COMPOSITION, lpResult[0], GCS_RESULTSTR|GCS_RESULTCLAUSE);
 844     GenerateIMEMessage(imc, WM_IME_ENDCOMPOSITION, 0, 0);
 845
 846     if (!inComp)
 847         ImmSetOpenStatus(imc, FALSE);
 848
 849     ImmUnlockIMC(imc);
 850     return 0;
 851 }