git.oblomov.eu Git - wine/blob - dlls/imm32/imm.c

   1 /*
   2  * IMM32 library
   3  *
   4  * Copyright 1998 Patrik Stridvall
   5  * Copyright 2002, 2003 CodeWeavers, Aric Stewart
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "winerror.h"
  29 #include "wine/debug.h"
  30 #include "imm.h"
  31 #include "winnls.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(imm);
  34
  35 #define FROM_IME 0xcafe1337
  36
  37 static void (*pX11DRV_ForceXIMReset)(HWND);
  38
  39 typedef struct tagInputContextData
  40 {
  41         LPBYTE          CompositionString;
  42         LPBYTE          CompositionReadingString;
  43         LPBYTE          ResultString;
  44         LPBYTE          ResultReadingString;
  45         DWORD           dwCompStringSize;   /* buffer size */
  46         DWORD           dwCompStringLength; /* string length (in bytes) */
  47         DWORD           dwCompReadStringSize;
  48         DWORD           dwResultStringSize;
  49         DWORD           dwResultReadStringSize;
  50         HWND            hwnd;
  51         BOOL            bOpen;
  52         BOOL            bInternalState;
  53         BOOL            bRead;
  54         LOGFONTW        font;
  55         HFONT           textfont;
  56         COMPOSITIONFORM CompForm;
  57 } InputContextData;
  58
  59 static InputContextData *root_context = NULL;
  60 static HWND hwndDefault = NULL;
  61 static HANDLE hImeInst;
  62 static const WCHAR WC_IMECLASSNAME[] = {'I','M','E',0};
  63
  64 /* MSIME messages */
  65 static UINT WM_MSIME_SERVICE;
  66 static UINT WM_MSIME_RECONVERTOPTIONS;
  67 static UINT WM_MSIME_MOUSE;
  68 static UINT WM_MSIME_RECONVERTREQUEST;
  69 static UINT WM_MSIME_RECONVERT;
  70 static UINT WM_MSIME_QUERYPOSITION;
  71 static UINT WM_MSIME_DOCUMENTFEED;
  72
  73 /*
  74  * prototypes
  75  */
  76 static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
  77                                           LPARAM lParam);
  78 static void UpdateDataInDefaultIMEWindow(HWND hwnd);
  79 static void ImmInternalPostIMEMessage(UINT, WPARAM, LPARAM);
  80 static void ImmInternalSetOpenStatus(BOOL fOpen);
  81
  82 static VOID IMM_PostResult(InputContextData *data)
  83 {
  84     unsigned int i;
  85     TRACE("Posting result as IME_CHAR\n");
  86
  87     for (i = 0; i < data->dwResultStringSize / sizeof (WCHAR); i++)
  88         ImmInternalPostIMEMessage (WM_IME_CHAR, ((WCHAR*)data->ResultString)[i],
  89                      1);
  90
  91     /* clear the buffer */
  92     if (data->dwResultStringSize)
  93         HeapFree(GetProcessHeap(),0,data->ResultString);
  94     data->dwResultStringSize = 0;
  95     data->ResultString = NULL;
  96 }
  97
  98 static void IMM_Register(void)
  99 {
 100     WNDCLASSW wndClass;
 101     ZeroMemory(&wndClass, sizeof(WNDCLASSW));
 102     wndClass.style = CS_GLOBALCLASS | CS_IME | CS_HREDRAW | CS_VREDRAW;
 103     wndClass.lpfnWndProc = (WNDPROC) IME_WindowProc;
 104     wndClass.cbClsExtra = 0;
 105     wndClass.cbWndExtra = 0;
 106     wndClass.hInstance = hImeInst;
 107     wndClass.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
 108     wndClass.hIcon = NULL;
 109     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW +1);
 110     wndClass.lpszMenuName   = 0;
 111     wndClass.lpszClassName = WC_IMECLASSNAME;
 112     RegisterClassW(&wndClass);
 113 }
 114
 115 static void IMM_Unregister(void)
 116 {
 117     UnregisterClassW(WC_IMECLASSNAME, NULL);
 118 }
 119
 120 static void IMM_RegisterMessages(void)
 121 {
 122     WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
 123     WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
 124     WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
 125     WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
 126     WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
 127     WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
 128     WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
 129 }
 130
 131
 132 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpReserved)
 133 {
 134     HMODULE x11drv;
 135
 136     TRACE("%p, %x, %p\n",hInstDLL,fdwReason,lpReserved);
 137     switch (fdwReason)
 138     {
 139         case DLL_PROCESS_ATTACH:
 140             DisableThreadLibraryCalls(hInstDLL);
 141             hImeInst = hInstDLL;
 142             IMM_RegisterMessages();
 143             x11drv = GetModuleHandleA("winex11.drv");
 144             if (x11drv) pX11DRV_ForceXIMReset = (void *)GetProcAddress( x11drv, "ForceXIMReset");
 145             break;
 146         case DLL_PROCESS_DETACH:
 147             if (hwndDefault)
 148             {
 149                 DestroyWindow(hwndDefault);
 150                 hwndDefault = 0;
 151             }
 152             IMM_Unregister();
 153             break;
 154     }
 155     return TRUE;
 156 }
 157
 158 /* for posting messages as the IME */
 159 static void ImmInternalPostIMEMessage(UINT msg, WPARAM wParam, LPARAM lParam)
 160 {
 161     HWND target = GetFocus();
 162     if (!target)
 163        PostMessageW(root_context->hwnd,msg,wParam,lParam);
 164     else
 165        PostMessageW(target, msg, wParam, lParam);
 166 }
 167
 168
 169 static void ImmInternalSetOpenStatus(BOOL fOpen)
 170 {
 171     TRACE("Setting internal state to %s\n",(fOpen)?"OPEN":"CLOSED");
 172
 173    root_context->bOpen = fOpen;
 174    root_context->bInternalState = fOpen;
 175
 176    if (fOpen == FALSE)
 177    {
 178         ShowWindow(hwndDefault,SW_HIDE);
 179
 180         if (root_context->dwCompStringSize)
 181             HeapFree(GetProcessHeap(),0,root_context->CompositionString);
 182         if (root_context->dwCompReadStringSize)
 183             HeapFree(GetProcessHeap(),0,root_context->CompositionReadingString);
 184         if (root_context->dwResultStringSize)
 185             HeapFree(GetProcessHeap(),0,root_context->ResultString);
 186         if (root_context->dwResultReadStringSize)
 187             HeapFree(GetProcessHeap(),0,root_context->ResultReadingString);
 188         root_context->dwCompStringSize = 0;
 189         root_context->dwCompStringLength = 0;
 190         root_context->CompositionString = NULL;
 191         root_context->dwCompReadStringSize = 0;
 192         root_context->CompositionReadingString = NULL;
 193         root_context->dwResultStringSize = 0;
 194         root_context->ResultString = NULL;
 195         root_context->dwResultReadStringSize = 0;
 196         root_context->ResultReadingString = NULL;
 197     }
 198     else
 199         ShowWindow(hwndDefault, SW_SHOWNOACTIVATE);
 200
 201    SendMessageW(root_context->hwnd, WM_IME_NOTIFY, IMN_SETOPENSTATUS, 0);
 202 }
 203
 204
 205 /***********************************************************************
 206  *              ImmAssociateContext (IMM32.@)
 207  */
 208 HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
 209 {
 210     InputContextData *data = (InputContextData*)hIMC;
 211
 212     WARN("(%p, %p): semi-stub\n", hWnd, hIMC);
 213
 214     if (!hIMC)
 215         return NULL;
 216
 217     /*
 218      * WINE SPECIFIC! MAY CONFLICT
 219      * associate the root context we have an XIM created
 220      */
 221     if (hWnd == 0x000)
 222     {
 223         root_context = (InputContextData*)hIMC;
 224     }
 225
 226     /*
 227      * If already associated just return
 228      */
 229     if (data->hwnd == hWnd)
 230         return hIMC;
 231
 232     if (IsWindow(data->hwnd))
 233     {
 234         /*
 235          * Post a message that your context is switching
 236          */
 237         SendMessageW(data->hwnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
 238     }
 239
 240     data->hwnd = hWnd;
 241
 242     if (IsWindow(data->hwnd))
 243     {
 244         /*
 245          * Post a message that your context is switching
 246          */
 247         SendMessageW(data->hwnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
 248     }
 249
 250     /*
 251      * TODO: We need to keep track of the old context associated
 252      * with a window and return it for now we will return NULL;
 253      */
 254     return NULL;
 255 }
 256
 257 /***********************************************************************
 258  *              ImmAssociateContextEx (IMM32.@)
 259  */
 260 BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
 261 {
 262     FIXME("(%p, %p, %d): stub\n", hWnd, hIMC, dwFlags);
 263     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 264     return FALSE;
 265 }
 266
 267 /***********************************************************************
 268  *              ImmConfigureIMEA (IMM32.@)
 269  */
 270 BOOL WINAPI ImmConfigureIMEA(
 271   HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
 272 {
 273   FIXME("(%p, %p, %d, %p): stub\n",
 274     hKL, hWnd, dwMode, lpData
 275   );
 276   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 277   return FALSE;
 278 }
 279
 280 /***********************************************************************
 281  *              ImmConfigureIMEW (IMM32.@)
 282  */
 283 BOOL WINAPI ImmConfigureIMEW(
 284   HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
 285 {
 286   FIXME("(%p, %p, %d, %p): stub\n",
 287     hKL, hWnd, dwMode, lpData
 288   );
 289   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 290   return FALSE;
 291 }
 292
 293 /***********************************************************************
 294  *              ImmCreateContext (IMM32.@)
 295  */
 296 HIMC WINAPI ImmCreateContext(void)
 297 {
 298     InputContextData *new_context;
 299
 300     new_context = HeapAlloc(GetProcessHeap(),0,sizeof(InputContextData));
 301     ZeroMemory(new_context,sizeof(InputContextData));
 302
 303     return (HIMC)new_context;
 304 }
 305
 306 /***********************************************************************
 307  *              ImmDestroyContext (IMM32.@)
 308  */
 309 BOOL WINAPI ImmDestroyContext(HIMC hIMC)
 310 {
 311     InputContextData *data = (InputContextData*)hIMC;
 312
 313     TRACE("Destroying %p\n",hIMC);
 314
 315     if (hIMC)
 316     {
 317         if (data->dwCompStringSize)
 318             HeapFree(GetProcessHeap(),0,data->CompositionString);
 319         if (data->dwCompReadStringSize)
 320             HeapFree(GetProcessHeap(),0,data->CompositionReadingString);
 321         if (data->dwResultStringSize)
 322             HeapFree(GetProcessHeap(),0,data->ResultString);
 323         if (data->dwResultReadStringSize)
 324             HeapFree(GetProcessHeap(),0,data->ResultReadingString);
 325
 326         if (data->textfont)
 327         {
 328             DeleteObject(data->textfont);
 329             data->textfont = NULL;
 330         }
 331
 332         HeapFree(GetProcessHeap(),0,data);
 333     }
 334     return TRUE;
 335 }
 336
 337 /***********************************************************************
 338  *              ImmDisableIME (IMM32.@)
 339  */
 340 BOOL WINAPI ImmDisableIME(DWORD idThread)
 341 {
 342     FIXME("(%d): stub\n", idThread);
 343     return TRUE;
 344 }
 345
 346 /***********************************************************************
 347  *              ImmEnumRegisterWordA (IMM32.@)
 348  */
 349 UINT WINAPI ImmEnumRegisterWordA(
 350   HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc,
 351   LPCSTR lpszReading, DWORD dwStyle,
 352   LPCSTR lpszRegister, LPVOID lpData)
 353 {
 354   FIXME("(%p, %p, %s, %d, %s, %p): stub\n",
 355     hKL, lpfnEnumProc,
 356     debugstr_a(lpszReading), dwStyle,
 357     debugstr_a(lpszRegister), lpData
 358   );
 359   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 360   return 0;
 361 }
 362
 363 /***********************************************************************
 364  *              ImmEnumRegisterWordW (IMM32.@)
 365  */
 366 UINT WINAPI ImmEnumRegisterWordW(
 367   HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc,
 368   LPCWSTR lpszReading, DWORD dwStyle,
 369   LPCWSTR lpszRegister, LPVOID lpData)
 370 {
 371   FIXME("(%p, %p, %s, %d, %s, %p): stub\n",
 372     hKL, lpfnEnumProc,
 373     debugstr_w(lpszReading), dwStyle,
 374     debugstr_w(lpszRegister), lpData
 375   );
 376   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 377   return 0;
 378 }
 379
 380 /***********************************************************************
 381  *              ImmEscapeA (IMM32.@)
 382  */
 383 LRESULT WINAPI ImmEscapeA(
 384   HKL hKL, HIMC hIMC,
 385   UINT uEscape, LPVOID lpData)
 386 {
 387   FIXME("(%p, %p, %d, %p): stub\n",
 388     hKL, hIMC, uEscape, lpData
 389   );
 390   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 391   return 0;
 392 }
 393
 394 /***********************************************************************
 395  *              ImmEscapeW (IMM32.@)
 396  */
 397 LRESULT WINAPI ImmEscapeW(
 398   HKL hKL, HIMC hIMC,
 399   UINT uEscape, LPVOID lpData)
 400 {
 401   FIXME("(%p, %p, %d, %p): stub\n",
 402     hKL, hIMC, uEscape, lpData
 403   );
 404   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 405   return 0;
 406 }
 407
 408 /***********************************************************************
 409  *              ImmGetCandidateListA (IMM32.@)
 410  */
 411 DWORD WINAPI ImmGetCandidateListA(
 412   HIMC hIMC, DWORD deIndex,
 413   LPCANDIDATELIST lpCandList, DWORD dwBufLen)
 414 {
 415   FIXME("(%p, %d, %p, %d): stub\n",
 416     hIMC, deIndex,
 417     lpCandList, dwBufLen
 418   );
 419   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 420   return 0;
 421 }
 422
 423 /***********************************************************************
 424  *              ImmGetCandidateListCountA (IMM32.@)
 425  */
 426 DWORD WINAPI ImmGetCandidateListCountA(
 427   HIMC hIMC, LPDWORD lpdwListCount)
 428 {
 429   FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
 430   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 431   return 0;
 432 }
 433
 434 /***********************************************************************
 435  *              ImmGetCandidateListCountW (IMM32.@)
 436  */
 437 DWORD WINAPI ImmGetCandidateListCountW(
 438   HIMC hIMC, LPDWORD lpdwListCount)
 439 {
 440   FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
 441   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 442   return 0;
 443 }
 444
 445 /***********************************************************************
 446  *              ImmGetCandidateListW (IMM32.@)
 447  */
 448 DWORD WINAPI ImmGetCandidateListW(
 449   HIMC hIMC, DWORD deIndex,
 450   LPCANDIDATELIST lpCandList, DWORD dwBufLen)
 451 {
 452   FIXME("(%p, %d, %p, %d): stub\n",
 453     hIMC, deIndex,
 454     lpCandList, dwBufLen
 455   );
 456   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 457   return 0;
 458 }
 459
 460 /***********************************************************************
 461  *              ImmGetCandidateWindow (IMM32.@)
 462  */
 463 BOOL WINAPI ImmGetCandidateWindow(
 464   HIMC hIMC, DWORD dwBufLen, LPCANDIDATEFORM lpCandidate)
 465 {
 466   FIXME("(%p, %d, %p): stub\n", hIMC, dwBufLen, lpCandidate);
 467   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 468   return FALSE;
 469 }
 470
 471 /***********************************************************************
 472  *              ImmGetCompositionFontA (IMM32.@)
 473  */
 474 BOOL WINAPI ImmGetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
 475 {
 476   FIXME("(%p, %p): stub\n", hIMC, lplf);
 477   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 478   return FALSE;
 479 }
 480
 481 /***********************************************************************
 482  *              ImmGetCompositionFontW (IMM32.@)
 483  */
 484 BOOL WINAPI ImmGetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
 485 {
 486   FIXME("(%p, %p): stub\n", hIMC, lplf);
 487   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 488   return FALSE;
 489 }
 490
 491 /***********************************************************************
 492  *              ImmGetCompositionStringA (IMM32.@)
 493  */
 494 LONG WINAPI ImmGetCompositionStringA(
 495   HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
 496 {
 497     CHAR *buf;
 498     LONG rc = 0;
 499     InputContextData *data = (InputContextData*)hIMC;
 500
 501     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 502
 503     if (!data)
 504        return FALSE;
 505
 506     if (dwIndex == GCS_RESULTSTR)
 507     {
 508         TRACE("GSC_RESULTSTR %p %i\n",data->ResultString,
 509                                     data->dwResultStringSize);
 510
 511         buf = HeapAlloc( GetProcessHeap(), 0, data->dwResultStringSize * 3 );
 512         rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->ResultString,
 513                                  data->dwResultStringSize / sizeof(WCHAR), buf,
 514                                  data->dwResultStringSize * 3, NULL, NULL);
 515         if (dwBufLen >= rc)
 516             memcpy(lpBuf,buf,rc);
 517
 518         data->bRead = TRUE;
 519         HeapFree( GetProcessHeap(), 0, buf );
 520     }
 521     else if (dwIndex == GCS_COMPSTR)
 522     {
 523          TRACE("GSC_COMPSTR %p %i\n", data->CompositionString, data->dwCompStringLength);
 524
 525         buf = HeapAlloc( GetProcessHeap(), 0, data->dwCompStringLength * 3 );
 526         rc = WideCharToMultiByte(CP_ACP, 0,(LPWSTR)data->CompositionString,
 527                                  data->dwCompStringLength/ sizeof(WCHAR), buf,
 528                                  data->dwCompStringLength* 3, NULL, NULL);
 529         if (dwBufLen >= rc)
 530             memcpy(lpBuf,buf,rc);
 531         HeapFree( GetProcessHeap(), 0, buf );
 532     }
 533     else if (dwIndex == GCS_COMPATTR)
 534     {
 535         TRACE("GSC_COMPATTR %p %i\n", data->CompositionString, data->dwCompStringLength);
 536
 537         rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->CompositionString,
 538                                  data->dwCompStringLength/ sizeof(WCHAR), NULL,
 539                                  0, NULL, NULL);
 540
 541         if (dwBufLen >= rc)
 542         {
 543             int i=0;
 544             for (i = 0;  i < rc; i++)
 545                 ((LPBYTE)lpBuf)[i] = ATTR_INPUT;
 546     }
 547     }
 548     else if (dwIndex == GCS_COMPCLAUSE)
 549     {
 550         TRACE("GSC_COMPCLAUSE %p %i\n", data->CompositionString, data->dwCompStringLength);
 551
 552         rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->CompositionString,
 553                                  data->dwCompStringLength/ sizeof(WCHAR), NULL,
 554                                  0, NULL, NULL);
 555
 556         if (dwBufLen >= sizeof(DWORD)*2)
 557         {
 558             ((LPDWORD)lpBuf)[0] = 0;
 559             ((LPDWORD)lpBuf)[1] = rc;
 560         }
 561         rc = sizeof(DWORD)*2;
 562     }
 563     else
 564     {
 565         FIXME("Unhandled index 0x%x\n",dwIndex);
 566     }
 567
 568     return rc;
 569 }
 570
 571 /***********************************************************************
 572  *              ImmGetCompositionStringW (IMM32.@)
 573  */
 574 LONG WINAPI ImmGetCompositionStringW(
 575   HIMC hIMC, DWORD dwIndex,
 576   LPVOID lpBuf, DWORD dwBufLen)
 577 {
 578     LONG rc = 0;
 579     InputContextData *data = (InputContextData*)hIMC;
 580
 581     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 582
 583     if (!data)
 584        return FALSE;
 585
 586     if (dwIndex == GCS_RESULTSTR)
 587     {
 588         data->bRead = TRUE;
 589
 590         if (dwBufLen >= data->dwResultStringSize)
 591             memcpy(lpBuf,data->ResultString,data->dwResultStringSize);
 592
 593         rc =  data->dwResultStringSize;
 594     }
 595     else if (dwIndex == GCS_RESULTREADSTR)
 596     {
 597         if (dwBufLen >= data->dwResultReadStringSize)
 598             memcpy(lpBuf,data->ResultReadingString,
 599                     data->dwResultReadStringSize);
 600
 601         rc = data->dwResultReadStringSize;
 602     }
 603     else if (dwIndex == GCS_COMPSTR)
 604     {
 605         if (dwBufLen >= data->dwCompStringLength)
 606             memcpy(lpBuf,data->CompositionString,data->dwCompStringLength);
 607
 608         rc = data->dwCompStringLength;
 609     }
 610     else if (dwIndex == GCS_COMPATTR)
 611     {
 612         unsigned int len = data->dwCompStringLength;
 613
 614         if (dwBufLen >= len)
 615         {
 616             unsigned int i=0;
 617             for (i = 0;  i < len; i++)
 618                 ((LPBYTE)lpBuf)[i] = ATTR_INPUT;
 619         }
 620
 621         rc = len;
 622     }
 623     else if (dwIndex == GCS_COMPCLAUSE)
 624     {
 625         if (dwBufLen >= sizeof(DWORD)*2)
 626         {
 627             ((LPDWORD)lpBuf)[0] = 0;
 628             ((LPDWORD)lpBuf)[1] = data->dwCompStringLength/sizeof(WCHAR);
 629         }
 630         rc = sizeof(DWORD)*2;
 631     }
 632     else if (dwIndex == GCS_COMPREADSTR)
 633     {
 634         if (dwBufLen >= data->dwCompReadStringSize)
 635             memcpy(lpBuf,data->CompositionReadingString,
 636                     data->dwCompReadStringSize);
 637
 638         rc = data->dwCompReadStringSize;
 639     }
 640     else
 641     {
 642         FIXME("Unhandled index 0x%x\n",dwIndex);
 643     }
 644
 645     return rc;
 646 }
 647
 648 /***********************************************************************
 649  *              ImmGetCompositionWindow (IMM32.@)
 650  */
 651 BOOL WINAPI ImmGetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
 652 {
 653     InputContextData *data = (InputContextData*)hIMC;
 654
 655     TRACE("(%p, %p)\n", hIMC, lpCompForm);
 656
 657     if (!data)
 658         return FALSE;
 659
 660     memcpy(lpCompForm,&(data->CompForm),sizeof(COMPOSITIONFORM));
 661     return 1;
 662 }
 663
 664 /***********************************************************************
 665  *              ImmGetContext (IMM32.@)
 666  *
 667  */
 668 HIMC WINAPI ImmGetContext(HWND hWnd)
 669 {
 670     TRACE("%p\n", hWnd);
 671
 672     if (!root_context)
 673         return NULL;
 674
 675     root_context->hwnd = hWnd;
 676     return (HIMC)root_context;
 677 }
 678
 679 /***********************************************************************
 680  *              ImmGetConversionListA (IMM32.@)
 681  */
 682 DWORD WINAPI ImmGetConversionListA(
 683   HKL hKL, HIMC hIMC,
 684   LPCSTR pSrc, LPCANDIDATELIST lpDst,
 685   DWORD dwBufLen, UINT uFlag)
 686 {
 687   FIXME("(%p, %p, %s, %p, %d, %d): stub\n",
 688     hKL, hIMC, debugstr_a(pSrc), lpDst, dwBufLen, uFlag
 689   );
 690   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 691   return 0;
 692 }
 693
 694 /***********************************************************************
 695  *              ImmGetConversionListW (IMM32.@)
 696  */
 697 DWORD WINAPI ImmGetConversionListW(
 698   HKL hKL, HIMC hIMC,
 699   LPCWSTR pSrc, LPCANDIDATELIST lpDst,
 700   DWORD dwBufLen, UINT uFlag)
 701 {
 702   FIXME("(%p, %p, %s, %p, %d, %d): stub\n",
 703     hKL, hIMC, debugstr_w(pSrc), lpDst, dwBufLen, uFlag
 704   );
 705   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 706   return 0;
 707 }
 708
 709 /***********************************************************************
 710  *              ImmGetConversionStatus (IMM32.@)
 711  */
 712 BOOL WINAPI ImmGetConversionStatus(
 713   HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)
 714 {
 715     TRACE("(%p, %p, %p): best guess\n", hIMC, lpfdwConversion, lpfdwSentence);
 716     if (lpfdwConversion)
 717         *lpfdwConversion = IME_CMODE_NATIVE;
 718     if (lpfdwSentence)
 719         *lpfdwSentence = IME_SMODE_NONE;
 720     return TRUE;
 721 }
 722
 723 /***********************************************************************
 724  *              ImmGetDefaultIMEWnd (IMM32.@)
 725  */
 726 HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
 727 {
 728   FIXME("(%p - %p %p ): semi-stub\n", hWnd,hwndDefault, root_context);
 729
 730   if (hwndDefault == NULL)
 731   {
 732         static const WCHAR the_name[] = {'I','M','E','\0'};
 733
 734         IMM_Register();
 735         hwndDefault = CreateWindowExW( WS_EX_CLIENTEDGE, WC_IMECLASSNAME,
 736                 the_name, WS_POPUPWINDOW|WS_CAPTION, 0, 0, 120, 55, 0, 0,
 737                 hImeInst, 0);
 738
 739         TRACE("Default created (%p)\n",hwndDefault);
 740   }
 741
 742   return (HWND)hwndDefault;
 743 }
 744
 745 /***********************************************************************
 746  *              ImmGetDescriptionA (IMM32.@)
 747  */
 748 UINT WINAPI ImmGetDescriptionA(
 749   HKL hKL, LPSTR lpszDescription, UINT uBufLen)
 750 {
 751   WCHAR *buf;
 752   DWORD len;
 753
 754   TRACE("%p %p %d\n", hKL, lpszDescription, uBufLen);
 755
 756   /* find out how many characters in the unicode buffer */
 757   len = ImmGetDescriptionW( hKL, NULL, 0 );
 758
 759   /* allocate a buffer of that size */
 760   buf = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof (WCHAR) );
 761   if( !buf )
 762   return 0;
 763
 764   /* fetch the unicode buffer */
 765   len = ImmGetDescriptionW( hKL, buf, len + 1 );
 766
 767   /* convert it back to ASCII */
 768   len = WideCharToMultiByte( CP_ACP, 0, buf, len + 1,
 769                              lpszDescription, uBufLen, NULL, NULL );
 770
 771   HeapFree( GetProcessHeap(), 0, buf );
 772
 773   return len;
 774 }
 775
 776 /***********************************************************************
 777  *              ImmGetDescriptionW (IMM32.@)
 778  */
 779 UINT WINAPI ImmGetDescriptionW(HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
 780 {
 781   static const WCHAR name[] = { 'W','i','n','e',' ','X','I','M',0 };
 782
 783   FIXME("(%p, %p, %d): semi stub\n", hKL, lpszDescription, uBufLen);
 784
 785   if (!uBufLen) return lstrlenW( name );
 786   lstrcpynW( lpszDescription, name, uBufLen );
 787   return lstrlenW( lpszDescription );
 788 }
 789
 790 /***********************************************************************
 791  *              ImmGetGuideLineA (IMM32.@)
 792  */
 793 DWORD WINAPI ImmGetGuideLineA(
 794   HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)
 795 {
 796   FIXME("(%p, %d, %s, %d): stub\n",
 797     hIMC, dwIndex, debugstr_a(lpBuf), dwBufLen
 798   );
 799   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 800   return 0;
 801 }
 802
 803 /***********************************************************************
 804  *              ImmGetGuideLineW (IMM32.@)
 805  */
 806 DWORD WINAPI ImmGetGuideLineW(HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)
 807 {
 808   FIXME("(%p, %d, %s, %d): stub\n",
 809     hIMC, dwIndex, debugstr_w(lpBuf), dwBufLen
 810   );
 811   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 812   return 0;
 813 }
 814
 815 /***********************************************************************
 816  *              ImmGetIMEFileNameA (IMM32.@)
 817  */
 818 UINT WINAPI ImmGetIMEFileNameA(
 819   HKL hKL, LPSTR lpszFileName, UINT uBufLen)
 820 {
 821   FIXME("(%p, %p, %d): stub\n", hKL, lpszFileName, uBufLen);
 822   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 823   return 0;
 824 }
 825
 826 /***********************************************************************
 827  *              ImmGetIMEFileNameW (IMM32.@)
 828  */
 829 UINT WINAPI ImmGetIMEFileNameW(
 830   HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
 831 {
 832   FIXME("(%p, %p, %d): stub\n", hKL, lpszFileName, uBufLen);
 833   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 834   return 0;
 835 }
 836
 837 /***********************************************************************
 838  *              ImmGetOpenStatus (IMM32.@)
 839  */
 840 BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
 841 {
 842   InputContextData *data = (InputContextData*)hIMC;
 843
 844     if (!data)
 845         return FALSE;
 846   FIXME("(%p): semi-stub\n", hIMC);
 847
 848   return data->bOpen;
 849 }
 850
 851 /***********************************************************************
 852  *              ImmGetProperty (IMM32.@)
 853  */
 854 DWORD WINAPI ImmGetProperty(HKL hKL, DWORD fdwIndex)
 855 {
 856     DWORD rc = 0;
 857     TRACE("(%p, %d)\n", hKL, fdwIndex);
 858
 859     switch (fdwIndex)
 860     {
 861         case IGP_PROPERTY:
 862             TRACE("(%s)\n", "IGP_PROPERTY");
 863             rc = IME_PROP_UNICODE | IME_PROP_AT_CARET;
 864             break;
 865         case IGP_CONVERSION:
 866             FIXME("(%s)\n", "IGP_CONVERSION");
 867             rc = IME_CMODE_NATIVE;
 868             break;
 869         case IGP_SENTENCE:
 870             FIXME("%s)\n", "IGP_SENTENCE");
 871             rc = IME_SMODE_AUTOMATIC;
 872             break;
 873         case IGP_SETCOMPSTR:
 874             TRACE("(%s)\n", "IGP_SETCOMPSTR");
 875             rc = 0;
 876             break;
 877         case IGP_SELECT:
 878             TRACE("(%s)\n", "IGP_SELECT");
 879             rc = SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE;
 880             break;
 881         case IGP_GETIMEVERSION:
 882             TRACE("(%s)\n", "IGP_GETIMEVERSION");
 883             rc = IMEVER_0400;
 884             break;
 885         case IGP_UI:
 886             TRACE("(%s)\n", "IGP_UI");
 887             rc = 0;
 888             break;
 889         default:
 890             rc = 0;
 891     }
 892     return rc;
 893 }
 894
 895 /***********************************************************************
 896  *              ImmGetRegisterWordStyleA (IMM32.@)
 897  */
 898 UINT WINAPI ImmGetRegisterWordStyleA(
 899   HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
 900 {
 901   FIXME("(%p, %d, %p): stub\n", hKL, nItem, lpStyleBuf);
 902   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 903   return 0;
 904 }
 905
 906 /***********************************************************************
 907  *              ImmGetRegisterWordStyleW (IMM32.@)
 908  */
 909 UINT WINAPI ImmGetRegisterWordStyleW(
 910   HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
 911 {
 912   FIXME("(%p, %d, %p): stub\n", hKL, nItem, lpStyleBuf);
 913   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 914   return 0;
 915 }
 916
 917 /***********************************************************************
 918  *              ImmGetStatusWindowPos (IMM32.@)
 919  */
 920 BOOL WINAPI ImmGetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
 921 {
 922   FIXME("(%p, %p): stub\n", hIMC, lpptPos);
 923   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 924   return FALSE;
 925 }
 926
 927 /***********************************************************************
 928  *              ImmGetVirtualKey (IMM32.@)
 929  */
 930 UINT WINAPI ImmGetVirtualKey(HWND hWnd)
 931 {
 932   OSVERSIONINFOA version;
 933   FIXME("(%p): stub\n", hWnd);
 934   GetVersionExA( &version );
 935   switch(version.dwPlatformId)
 936   {
 937   case VER_PLATFORM_WIN32_WINDOWS:
 938       return VK_PROCESSKEY;
 939   case VER_PLATFORM_WIN32_NT:
 940       return 0;
 941   default:
 942       FIXME("%d not supported\n",version.dwPlatformId);
 943       return VK_PROCESSKEY;
 944   }
 945 }
 946
 947 /***********************************************************************
 948  *              ImmInstallIMEA (IMM32.@)
 949  */
 950 HKL WINAPI ImmInstallIMEA(
 951   LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
 952 {
 953   FIXME("(%s, %s): stub\n",
 954     debugstr_a(lpszIMEFileName), debugstr_a(lpszLayoutText)
 955   );
 956   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 957   return NULL;
 958 }
 959
 960 /***********************************************************************
 961  *              ImmInstallIMEW (IMM32.@)
 962  */
 963 HKL WINAPI ImmInstallIMEW(
 964   LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
 965 {
 966   FIXME("(%s, %s): stub\n",
 967     debugstr_w(lpszIMEFileName), debugstr_w(lpszLayoutText)
 968   );
 969   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 970   return NULL;
 971 }
 972
 973 /***********************************************************************
 974  *              ImmIsIME (IMM32.@)
 975  */
 976 BOOL WINAPI ImmIsIME(HKL hKL)
 977 {
 978   TRACE("(%p): semi-stub\n", hKL);
 979   /*
 980    * FIXME: Dead key locales will return TRUE here when they should not
 981    * There is probably a more proper way to check this.
 982    */
 983   return (root_context != NULL);
 984 }
 985
 986 /***********************************************************************
 987  *              ImmIsUIMessageA (IMM32.@)
 988  */
 989 BOOL WINAPI ImmIsUIMessageA(
 990   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
 991 {
 992     BOOL rc = FALSE;
 993
 994     TRACE("(%p, %x, %d, %ld)\n", hWndIME, msg, wParam, lParam);
 995     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
 996         (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
 997         (msg == WM_MSIME_SERVICE) ||
 998         (msg == WM_MSIME_RECONVERTOPTIONS) ||
 999         (msg == WM_MSIME_MOUSE) ||
1000         (msg == WM_MSIME_RECONVERTREQUEST) ||
1001         (msg == WM_MSIME_RECONVERT) ||
1002         (msg == WM_MSIME_QUERYPOSITION) ||
1003         (msg == WM_MSIME_DOCUMENTFEED))
1004
1005     {
1006         if (!hwndDefault)
1007             ImmGetDefaultIMEWnd(NULL);
1008
1009         if (hWndIME == NULL)
1010             PostMessageA(hwndDefault, msg, wParam, lParam);
1011
1012         rc = TRUE;
1013     }
1014     return rc;
1015 }
1016
1017 /***********************************************************************
1018  *              ImmIsUIMessageW (IMM32.@)
1019  */
1020 BOOL WINAPI ImmIsUIMessageW(
1021   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1022 {
1023     BOOL rc = FALSE;
1024     TRACE("(%p, %d, %d, %ld): stub\n", hWndIME, msg, wParam, lParam);
1025     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1026         (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1027         (msg == WM_MSIME_SERVICE) ||
1028         (msg == WM_MSIME_RECONVERTOPTIONS) ||
1029         (msg == WM_MSIME_MOUSE) ||
1030         (msg == WM_MSIME_RECONVERTREQUEST) ||
1031         (msg == WM_MSIME_RECONVERT) ||
1032         (msg == WM_MSIME_QUERYPOSITION) ||
1033         (msg == WM_MSIME_DOCUMENTFEED))
1034         rc = TRUE;
1035     return rc;
1036 }
1037
1038 /***********************************************************************
1039  *              ImmNotifyIME (IMM32.@)
1040  */
1041 BOOL WINAPI ImmNotifyIME(
1042   HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
1043 {
1044     BOOL rc = FALSE;
1045
1046     TRACE("(%p, %d, %d, %d)\n",
1047         hIMC, dwAction, dwIndex, dwValue);
1048
1049     if (!root_context)
1050         return rc;
1051
1052     switch(dwAction)
1053     {
1054         case NI_CHANGECANDIDATELIST:
1055             FIXME("%s\n","NI_CHANGECANDIDATELIST");
1056             break;
1057         case NI_CLOSECANDIDATE:
1058             FIXME("%s\n","NI_CLOSECANDIDATE");
1059             break;
1060         case NI_COMPOSITIONSTR:
1061             switch (dwIndex)
1062             {
1063                 case CPS_CANCEL:
1064                     TRACE("%s - %s\n","NI_COMPOSITIONSTR","CPS_CANCEL");
1065                     if (pX11DRV_ForceXIMReset)
1066                         pX11DRV_ForceXIMReset(root_context->hwnd);
1067                     if (root_context->dwCompStringSize)
1068                     {
1069                         HeapFree(GetProcessHeap(),0,
1070                                  root_context->CompositionString);
1071                         root_context->dwCompStringSize = 0;
1072                         root_context->dwCompStringLength = 0;
1073                         root_context->CompositionString = NULL;
1074                         ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
1075                                                   GCS_COMPSTR);
1076                     }
1077                     rc = TRUE;
1078                     break;
1079                 case CPS_COMPLETE:
1080                     TRACE("%s - %s\n","NI_COMPOSITIONSTR","CPS_COMPLETE");
1081                     if (hIMC != (HIMC)FROM_IME && pX11DRV_ForceXIMReset)
1082                         pX11DRV_ForceXIMReset(root_context->hwnd);
1083
1084                     if (root_context->dwResultStringSize)
1085                     {
1086                         HeapFree(GetProcessHeap(),0,root_context->ResultString);
1087                         root_context->dwResultStringSize = 0;
1088                         root_context->ResultString = NULL;
1089                     }
1090                     if (root_context->dwCompStringLength)
1091                     {
1092                         root_context->ResultString = HeapAlloc(
1093                         GetProcessHeap(), 0, root_context->dwCompStringLength);
1094                         root_context->dwResultStringSize =
1095                                         root_context->dwCompStringLength;
1096
1097                         memcpy(root_context->ResultString,
1098                                root_context->CompositionString,
1099                                root_context->dwCompStringLength);
1100
1101                         HeapFree(GetProcessHeap(),0,
1102                                  root_context->CompositionString);
1103
1104                         root_context->dwCompStringSize = 0;
1105                         root_context->dwCompStringLength = 0;
1106                         root_context->CompositionString = NULL;
1107                         root_context->bRead = FALSE;
1108
1109                         ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
1110                                                   GCS_COMPSTR);
1111
1112                         ImmInternalPostIMEMessage(WM_IME_COMPOSITION,
1113                                             root_context->ResultString[0],
1114                                             GCS_RESULTSTR|GCS_RESULTCLAUSE);
1115                     }
1116                     break;
1117                 case CPS_CONVERT:
1118                     FIXME("%s - %s\n","NI_COMPOSITIONSTR","CPS_CONVERT");
1119                     break;
1120                 case CPS_REVERT:
1121                     FIXME("%s - %s\n","NI_COMPOSITIONSTR","CPS_REVERT");
1122                     break;
1123                 default:
1124                     ERR("%s - %s (%i)\n","NI_COMPOSITIONSTR","UNKNOWN",dwIndex);
1125                     break;
1126             }
1127             break;
1128         case NI_IMEMENUSELECTED:
1129             FIXME("%s\n", "NI_IMEMENUSELECTED");
1130             break;
1131         case NI_OPENCANDIDATE:
1132             FIXME("%s\n", "NI_OPENCANDIDATE");
1133             break;
1134         case NI_SELECTCANDIDATESTR:
1135             FIXME("%s\n", "NI_SELECTCANDIDATESTR");
1136             break;
1137         case NI_SETCANDIDATE_PAGESIZE:
1138             FIXME("%s\n", "NI_SETCANDIDATE_PAGESIZE");
1139             break;
1140         case NI_SETCANDIDATE_PAGESTART:
1141             FIXME("%s\n", "NI_SETCANDIDATE_PAGESTART");
1142             break;
1143         default:
1144             ERR("Unknown\n");
1145     }
1146
1147     return rc;
1148 }
1149
1150 /***********************************************************************
1151  *              ImmRegisterWordA (IMM32.@)
1152  */
1153 BOOL WINAPI ImmRegisterWordA(
1154   HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
1155 {
1156   FIXME("(%p, %s, %d, %s): stub\n",
1157     hKL, debugstr_a(lpszReading), dwStyle, debugstr_a(lpszRegister)
1158   );
1159   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1160   return FALSE;
1161 }
1162
1163 /***********************************************************************
1164  *              ImmRegisterWordW (IMM32.@)
1165  */
1166 BOOL WINAPI ImmRegisterWordW(
1167   HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
1168 {
1169   FIXME("(%p, %s, %d, %s): stub\n",
1170     hKL, debugstr_w(lpszReading), dwStyle, debugstr_w(lpszRegister)
1171   );
1172   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1173   return FALSE;
1174 }
1175
1176 /***********************************************************************
1177  *              ImmReleaseContext (IMM32.@)
1178  */
1179 BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
1180 {
1181   FIXME("(%p, %p): stub\n", hWnd, hIMC);
1182
1183     return TRUE;
1184 }
1185
1186 /***********************************************************************
1187  *              ImmSetCandidateWindow (IMM32.@)
1188  */
1189 BOOL WINAPI ImmSetCandidateWindow(
1190   HIMC hIMC, LPCANDIDATEFORM lpCandidate)
1191 {
1192   FIXME("(%p, %p): stub\n", hIMC, lpCandidate);
1193   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1194   return FALSE;
1195 }
1196
1197 /***********************************************************************
1198  *              ImmSetCompositionFontA (IMM32.@)
1199  */
1200 BOOL WINAPI ImmSetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
1201 {
1202     InputContextData *data = (InputContextData*)hIMC;
1203     TRACE("(%p, %p)\n", hIMC, lplf);
1204
1205     if (!data)
1206         return FALSE;
1207
1208     memcpy(&data->font,lplf,sizeof(LOGFONTA));
1209     MultiByteToWideChar(CP_ACP, 0, lplf->lfFaceName, -1, data->font.lfFaceName,
1210                         LF_FACESIZE);
1211
1212     SendMessageW(root_context->hwnd, WM_IME_NOTIFY, IMN_SETCOMPOSITIONFONT, 0);
1213
1214     if (data->textfont)
1215     {
1216         DeleteObject(data->textfont);
1217         data->textfont = NULL;
1218     }
1219
1220     data->textfont = CreateFontIndirectW(&data->font);
1221     return TRUE;
1222 }
1223
1224 /***********************************************************************
1225  *              ImmSetCompositionFontW (IMM32.@)
1226  */
1227 BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
1228 {
1229     InputContextData *data = (InputContextData*)hIMC;
1230     TRACE("(%p, %p)\n", hIMC, lplf);
1231
1232     if (!data)
1233         return FALSE;
1234
1235     memcpy(&data->font,lplf,sizeof(LOGFONTW));
1236     SendMessageW(root_context->hwnd, WM_IME_NOTIFY, IMN_SETCOMPOSITIONFONT, 0);
1237
1238     if (data->textfont)
1239     {
1240         DeleteObject(data->textfont);
1241         data->textfont = NULL;
1242     }
1243     data->textfont = CreateFontIndirectW(&data->font);
1244     return TRUE;
1245 }
1246
1247 /***********************************************************************
1248  *              ImmSetCompositionStringA (IMM32.@)
1249  */
1250 BOOL WINAPI ImmSetCompositionStringA(
1251   HIMC hIMC, DWORD dwIndex,
1252   LPCVOID lpComp, DWORD dwCompLen,
1253   LPCVOID lpRead, DWORD dwReadLen)
1254 {
1255     DWORD comp_len;
1256     DWORD read_len;
1257     WCHAR *CompBuffer = NULL;
1258     WCHAR *ReadBuffer = NULL;
1259     BOOL rc;
1260
1261     TRACE("(%p, %d, %p, %d, %p, %d): stub\n",
1262             hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1263
1264     comp_len = MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, NULL, 0);
1265     if (comp_len)
1266     {
1267         CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len * sizeof(WCHAR));
1268         MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len);
1269     }
1270
1271     read_len = MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, NULL, 0);
1272     if (read_len)
1273     {
1274         ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len * sizeof(WCHAR));
1275         MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len);
1276     }
1277
1278     rc =  ImmSetCompositionStringW(hIMC, dwIndex, CompBuffer, comp_len,
1279                                    ReadBuffer, read_len);
1280
1281     HeapFree(GetProcessHeap(), 0, CompBuffer);
1282     HeapFree(GetProcessHeap(), 0, ReadBuffer);
1283
1284     return rc;
1285 }
1286
1287 /***********************************************************************
1288  *              ImmSetCompositionStringW (IMM32.@)
1289  */
1290 BOOL WINAPI ImmSetCompositionStringW(
1291         HIMC hIMC, DWORD dwIndex,
1292         LPCVOID lpComp, DWORD dwCompLen,
1293         LPCVOID lpRead, DWORD dwReadLen)
1294 {
1295      DWORD flags = 0;
1296      WCHAR wParam  = 0;
1297
1298      TRACE("(%p, %d, %p, %d, %p, %d): stub\n",
1299              hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1300
1301
1302      if (hIMC != (HIMC)FROM_IME)
1303          FIXME("PROBLEM: This only sets the wine level string\n");
1304
1305      /*
1306       * Explanation:
1307       *  this sets the composition string in the imm32.dll level
1308       *  of the composition buffer. we cannot manipulate the xim level
1309       *  buffer, which means that once the xim level buffer changes again
1310       *  any call to this function from the application will be lost
1311       */
1312
1313      if (lpRead && dwReadLen)
1314          FIXME("Reading string unimplemented\n");
1315
1316      /*
1317       * app operating this api to also receive the message from xim
1318       */
1319
1320     if (dwIndex == SCS_SETSTR)
1321     {
1322          flags = GCS_COMPSTR;
1323
1324          if (root_context->dwCompStringLength)
1325              HeapFree(GetProcessHeap(),0,root_context->CompositionString);
1326
1327          root_context->dwCompStringLength = dwCompLen;
1328          root_context->dwCompStringSize = dwCompLen;
1329
1330          if (dwCompLen && lpComp)
1331          {
1332              root_context->CompositionString = HeapAlloc(GetProcessHeap(), 0,
1333                                                      dwCompLen);
1334              memcpy(root_context->CompositionString,lpComp,dwCompLen);
1335
1336              wParam = ((const WCHAR*)lpComp)[0];
1337              flags |= GCS_COMPCLAUSE | GCS_COMPATTR;
1338          }
1339          else
1340              root_context->CompositionString = NULL;
1341
1342     }
1343
1344      UpdateDataInDefaultIMEWindow(hwndDefault);
1345
1346      ImmInternalPostIMEMessage(WM_IME_COMPOSITION, wParam, flags);
1347
1348      return TRUE;
1349 }
1350
1351 /***********************************************************************
1352  *              ImmSetCompositionWindow (IMM32.@)
1353  */
1354 BOOL WINAPI ImmSetCompositionWindow(
1355   HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
1356 {
1357     BOOL reshow = FALSE;
1358     InputContextData *data = (InputContextData*)hIMC;
1359
1360     TRACE("(%p, %p)\n", hIMC, lpCompForm);
1361     TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm->dwStyle,
1362           lpCompForm->ptCurrentPos.x, lpCompForm->ptCurrentPos.y, lpCompForm->rcArea.top,
1363           lpCompForm->rcArea.left, lpCompForm->rcArea.bottom, lpCompForm->rcArea.right);
1364
1365     if (!data)
1366         return FALSE;
1367
1368     memcpy(&data->CompForm,lpCompForm,sizeof(COMPOSITIONFORM));
1369
1370     if (IsWindowVisible(hwndDefault))
1371     {
1372         reshow = TRUE;
1373         ShowWindow(hwndDefault,SW_HIDE);
1374     }
1375
1376     /* FIXME: this is a partial stub */
1377
1378     if (reshow)
1379         ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
1380
1381     SendMessageW(root_context->hwnd, WM_IME_NOTIFY,IMN_SETCOMPOSITIONWINDOW, 0);
1382     return TRUE;
1383 }
1384
1385 /***********************************************************************
1386  *              ImmSetConversionStatus (IMM32.@)
1387  */
1388 BOOL WINAPI ImmSetConversionStatus(
1389   HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
1390 {
1391   FIXME("(%p, %d, %d): stub\n",
1392     hIMC, fdwConversion, fdwSentence
1393   );
1394   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1395   return FALSE;
1396 }
1397
1398 /***********************************************************************
1399  *              ImmSetOpenStatus (IMM32.@)
1400  */
1401 BOOL WINAPI ImmSetOpenStatus(HIMC hIMC, BOOL fOpen)
1402 {
1403     InputContextData *data = (InputContextData*)hIMC;
1404
1405     TRACE("%p %d\n", hIMC, fOpen);
1406
1407     if (hIMC == (HIMC)FROM_IME)
1408     {
1409         if (fOpen)
1410             ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION, 0, 0);
1411
1412         ImmInternalSetOpenStatus(fOpen);
1413
1414         if (!fOpen)
1415             ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION, 0, 0);
1416
1417         return TRUE;
1418     }
1419
1420     if (!data)
1421         return FALSE;
1422
1423     if (fOpen != data->bInternalState)
1424     {
1425         if (fOpen == FALSE && pX11DRV_ForceXIMReset)
1426             pX11DRV_ForceXIMReset(data->hwnd);
1427
1428         if (fOpen == FALSE)
1429             ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION,0,0);
1430         else
1431             ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION,0,0);
1432
1433         ImmInternalSetOpenStatus(fOpen);
1434         ImmInternalSetOpenStatus(!fOpen);
1435
1436         if (data->bOpen == FALSE)
1437             ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION,0,0);
1438         else
1439             ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION,0,0);
1440
1441         return FALSE;
1442     }
1443     return TRUE;
1444 }
1445
1446 /***********************************************************************
1447  *              ImmSetStatusWindowPos (IMM32.@)
1448  */
1449 BOOL WINAPI ImmSetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1450 {
1451   FIXME("(%p, %p): stub\n", hIMC, lpptPos);
1452   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1453   return FALSE;
1454 }
1455
1456 /***********************************************************************
1457  *              ImmSimulateHotKey (IMM32.@)
1458  */
1459 BOOL WINAPI ImmSimulateHotKey(HWND hWnd, DWORD dwHotKeyID)
1460 {
1461   FIXME("(%p, %d): stub\n", hWnd, dwHotKeyID);
1462   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1463   return FALSE;
1464 }
1465
1466 /***********************************************************************
1467  *              ImmUnregisterWordA (IMM32.@)
1468  */
1469 BOOL WINAPI ImmUnregisterWordA(
1470   HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
1471 {
1472   FIXME("(%p, %s, %d, %s): stub\n",
1473     hKL, debugstr_a(lpszReading), dwStyle, debugstr_a(lpszUnregister)
1474   );
1475   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1476   return FALSE;
1477 }
1478
1479 /***********************************************************************
1480  *              ImmUnregisterWordW (IMM32.@)
1481  */
1482 BOOL WINAPI ImmUnregisterWordW(
1483   HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
1484 {
1485   FIXME("(%p, %s, %d, %s): stub\n",
1486     hKL, debugstr_w(lpszReading), dwStyle, debugstr_w(lpszUnregister)
1487   );
1488   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1489   return FALSE;
1490 }
1491
1492
1493 /*****
1494  * Internal functions to help with IME window management
1495  */
1496 static void PaintDefaultIMEWnd(HWND hwnd)
1497 {
1498     PAINTSTRUCT ps;
1499     RECT rect;
1500     HDC hdc = BeginPaint(hwnd,&ps);
1501     GetClientRect(hwnd,&rect);
1502
1503     if (root_context->dwCompStringLength && root_context->CompositionString)
1504     {
1505         SIZE size;
1506         POINT pt;
1507         HFONT oldfont = NULL;
1508
1509         if (root_context->textfont)
1510             oldfont = SelectObject(hdc,root_context->textfont);
1511
1512         TextOutW(hdc, 0,0,(LPWSTR)root_context->CompositionString,
1513                  root_context->dwCompStringLength / sizeof(WCHAR));
1514
1515         GetTextExtentPoint32W(hdc, (LPWSTR)root_context->CompositionString,
1516                               root_context->dwCompStringLength / sizeof(WCHAR),
1517                               &size);
1518         pt.x = size.cx;
1519         pt.y = size.cy;
1520         LPtoDP(hdc,&pt,1);
1521         rect.left = pt.x;
1522
1523         if (oldfont)
1524             SelectObject(hdc,oldfont);
1525     }
1526     FillRect(hdc,&rect, (HBRUSH) (COLOR_WINDOW+1));
1527     EndPaint(hwnd,&ps);
1528 }
1529
1530 static void UpdateDataInDefaultIMEWindow(HWND hwnd)
1531 {
1532     RedrawWindow(hwnd,NULL,NULL,RDW_ERASENOW|RDW_INVALIDATE);
1533 }
1534
1535 /*
1536  * The window proc for the default IME window
1537  */
1538 static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT msg, WPARAM wParam,
1539                                           LPARAM lParam)
1540 {
1541     LRESULT rc = 0;
1542
1543     TRACE("Incoming Message 0x%x  (0x%08x, 0x%08x)\n", msg, (UINT)wParam,
1544            (UINT)lParam);
1545
1546     switch(msg)
1547     {
1548         case WM_PAINT:
1549             PaintDefaultIMEWnd(hwnd);
1550             return FALSE;
1551
1552         case WM_NCCREATE:
1553             return TRUE;
1554
1555         case WM_CREATE:
1556             SetWindowTextA(hwnd,"Wine Ime Active");
1557             return TRUE;
1558
1559         case WM_SETFOCUS:
1560             if (wParam)
1561                 SetFocus((HWND)wParam);
1562             else
1563                 FIXME("Received focus, should never have focus\n");
1564             break;
1565         case WM_IME_COMPOSITION:
1566             TRACE("IME message %s, 0x%x, 0x%x (%i)\n",
1567                     "WM_IME_COMPOSITION", (UINT)wParam, (UINT)lParam,
1568                      root_context->bRead);
1569             if ((lParam & GCS_RESULTSTR) && (!root_context->bRead))
1570                     IMM_PostResult(root_context);
1571             else
1572                  UpdateDataInDefaultIMEWindow(hwnd);
1573             break;
1574         case WM_IME_STARTCOMPOSITION:
1575             TRACE("IME message %s, 0x%x, 0x%x\n",
1576                     "WM_IME_STARTCOMPOSITION", (UINT)wParam, (UINT)lParam);
1577             root_context->hwnd = GetFocus();
1578             ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
1579             break;
1580         case WM_IME_ENDCOMPOSITION:
1581             TRACE("IME message %s, 0x%x, 0x%x\n",
1582                     "WM_IME_ENDCOMPOSITION", (UINT)wParam, (UINT)lParam);
1583             ShowWindow(hwndDefault,SW_HIDE);
1584             break;
1585         case WM_IME_SELECT:
1586             TRACE("IME message %s, 0x%x, 0x%x\n","WM_IME_SELECT",
1587                 (UINT)wParam, (UINT)lParam);
1588             break;
1589         case WM_IME_CONTROL:
1590             TRACE("IME message %s, 0x%x, 0x%x\n","WM_IME_CONTROL",
1591                 (UINT)wParam, (UINT)lParam);
1592             rc = 1;
1593             break;
1594         case WM_IME_NOTIFY:
1595             TRACE("!! IME NOTIFY\n");
1596             break;
1597        default:
1598             TRACE("Non-standard message 0x%x\n",msg);
1599     }
1600     /* check the MSIME messages */
1601     if (msg == WM_MSIME_SERVICE)
1602     {
1603             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_SERVICE",
1604                 (UINT)wParam, (UINT)lParam);
1605             rc = FALSE;
1606     }
1607     else if (msg == WM_MSIME_RECONVERTOPTIONS)
1608     {
1609             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERTOPTIONS",
1610                 (UINT)wParam, (UINT)lParam);
1611     }
1612     else if (msg == WM_MSIME_MOUSE)
1613     {
1614             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_MOUSE",
1615                 (UINT)wParam, (UINT)lParam);
1616     }
1617     else if (msg == WM_MSIME_RECONVERTREQUEST)
1618     {
1619             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERTREQUEST",
1620                 (UINT)wParam, (UINT)lParam);
1621     }
1622     else if (msg == WM_MSIME_RECONVERT)
1623     {
1624             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERT",
1625                 (UINT)wParam, (UINT)lParam);
1626     }
1627     else if (msg == WM_MSIME_QUERYPOSITION)
1628     {
1629             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_QUERYPOSITION",
1630                 (UINT)wParam, (UINT)lParam);
1631     }
1632     else if (msg == WM_MSIME_DOCUMENTFEED)
1633     {
1634             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_DOCUMENTFEED",
1635                 (UINT)wParam, (UINT)lParam);
1636     }
1637     /* DefWndProc if not an IME message */
1638     else if (!rc && !((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1639                       (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP)))
1640         rc = DefWindowProcW(hwnd,msg,wParam,lParam);
1641
1642     return rc;
1643 }