dlls/imm32/imm.c

   1 /*
   2  * IMM32 library
   3  *
   4  * Copyright 1998 Patrik Stridvall
   5  * Copyright 2002, 2003, 2007 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 #include <stdio.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winuser.h"
  29 #include "winerror.h"
  30 #include "wine/debug.h"
  31 #include "imm.h"
  32 #include "ddk/imm.h"
  33 #include "winnls.h"
  34 #include "winreg.h"
  35 #include "wine/list.h"
  36 #include "wine/unicode.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(imm);
  39
  40 #define IMM_INIT_MAGIC 0x19650412
  41 BOOL WINAPI User32InitializeImmEntryTable(DWORD);
  42
  43 #define MAKE_FUNCPTR(f) typeof(f) * p##f
  44 typedef struct _tagImmHkl{
  45     struct list entry;
  46     HKL         hkl;
  47     HMODULE     hIME;
  48     IMEINFO     imeInfo;
  49     WCHAR       imeClassName[17]; /* 16 character max */
  50     ULONG       uSelected;
  51     HWND        UIWnd;
  52
  53     /* Function Pointers */
  54     MAKE_FUNCPTR(ImeInquire);
  55     MAKE_FUNCPTR(ImeConfigure);
  56     MAKE_FUNCPTR(ImeDestroy);
  57     MAKE_FUNCPTR(ImeEscape);
  58     MAKE_FUNCPTR(ImeSelect);
  59     MAKE_FUNCPTR(ImeSetActiveContext);
  60     MAKE_FUNCPTR(ImeToAsciiEx);
  61     MAKE_FUNCPTR(NotifyIME);
  62     MAKE_FUNCPTR(ImeRegisterWord);
  63     MAKE_FUNCPTR(ImeUnregisterWord);
  64     MAKE_FUNCPTR(ImeEnumRegisterWord);
  65     MAKE_FUNCPTR(ImeSetCompositionString);
  66     MAKE_FUNCPTR(ImeConversionList);
  67     MAKE_FUNCPTR(ImeProcessKey);
  68     MAKE_FUNCPTR(ImeGetRegisterWordStyle);
  69     MAKE_FUNCPTR(ImeGetImeMenuItems);
  70 } ImmHkl;
  71 #undef MAKE_FUNCPTR
  72
  73 typedef struct tagInputContextData
  74 {
  75         DWORD           dwLock;
  76         INPUTCONTEXT    IMC;
  77         DWORD           threadID;
  78
  79         ImmHkl          *immKbd;
  80         UINT            lastVK;
  81         BOOL            threadDefault;
  82         DWORD           magic;
  83 } InputContextData;
  84
  85 #define WINE_IMC_VALID_MAGIC 0x56434D49
  86
  87 typedef struct _tagTRANSMSG {
  88     UINT message;
  89     WPARAM wParam;
  90     LPARAM lParam;
  91 } TRANSMSG, *LPTRANSMSG;
  92
  93 typedef struct _tagIMMThreadData {
  94     struct list entry;
  95     DWORD threadID;
  96     HIMC defaultContext;
  97     HWND hwndDefault;
  98 } IMMThreadData;
  99
 100 static struct list ImmHklList = LIST_INIT(ImmHklList);
 101 static struct list ImmThreadDataList = LIST_INIT(ImmThreadDataList);
 102
 103 static const WCHAR szwWineIMCProperty[] = {'W','i','n','e','I','m','m','H','I','M','C','P','r','o','p','e','r','t','y',0};
 104
 105 static const WCHAR szImeFileW[] = {'I','m','e',' ','F','i','l','e',0};
 106 static const WCHAR szLayoutTextW[] = {'L','a','y','o','u','t',' ','T','e','x','t',0};
 107 static const WCHAR szImeRegFmt[] = {'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','s','\\','%','0','8','l','x',0};
 108
 109 static const WCHAR szwIME[] = {'I','M','E',0};
 110
 111 static CRITICAL_SECTION threaddata_cs;
 112 static CRITICAL_SECTION_DEBUG critsect_debug =
 113 {
 114     0, 0, &threaddata_cs,
 115     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 116       0, 0, { (DWORD_PTR)(__FILE__ ": threaddata_cs") }
 117 };
 118 static CRITICAL_SECTION threaddata_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 119
 120 #define is_himc_ime_unicode(p)  (p->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE)
 121 #define is_kbd_ime_unicode(p)  (p->imeInfo.fdwProperty & IME_PROP_UNICODE)
 122
 123 static BOOL IMM_DestroyContext(HIMC hIMC);
 124 static InputContextData* get_imc_data(HIMC hIMC);
 125
 126 static inline WCHAR *strdupAtoW( const char *str )
 127 {
 128     WCHAR *ret = NULL;
 129     if (str)
 130     {
 131         DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 132         if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 133             MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
 134     }
 135     return ret;
 136 }
 137
 138 static inline CHAR *strdupWtoA( const WCHAR *str )
 139 {
 140     CHAR *ret = NULL;
 141     if (str)
 142     {
 143         DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
 144         if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
 145             WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
 146     }
 147     return ret;
 148 }
 149
 150 static DWORD convert_candidatelist_WtoA(
 151         LPCANDIDATELIST lpSrc, LPCANDIDATELIST lpDst, DWORD dwBufLen)
 152 {
 153     DWORD ret, i, len;
 154
 155     ret = FIELD_OFFSET( CANDIDATELIST, dwOffset[lpSrc->dwCount] );
 156     if ( lpDst && dwBufLen > 0 )
 157     {
 158         *lpDst = *lpSrc;
 159         lpDst->dwOffset[0] = ret;
 160     }
 161
 162     for ( i = 0; i < lpSrc->dwCount; i++)
 163     {
 164         LPBYTE src = (LPBYTE)lpSrc + lpSrc->dwOffset[i];
 165
 166         if ( lpDst && dwBufLen > 0 )
 167         {
 168             LPBYTE dest = (LPBYTE)lpDst + lpDst->dwOffset[i];
 169
 170             len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)src, -1,
 171                                       (LPSTR)dest, dwBufLen, NULL, NULL);
 172
 173             if ( i + 1 < lpSrc->dwCount )
 174                 lpDst->dwOffset[i+1] = lpDst->dwOffset[i] + len * sizeof(char);
 175             dwBufLen -= len * sizeof(char);
 176         }
 177         else
 178             len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)src, -1, NULL, 0, NULL, NULL);
 179
 180         ret += len * sizeof(char);
 181     }
 182
 183     if ( lpDst )
 184         lpDst->dwSize = ret;
 185
 186     return ret;
 187 }
 188
 189 static DWORD convert_candidatelist_AtoW(
 190         LPCANDIDATELIST lpSrc, LPCANDIDATELIST lpDst, DWORD dwBufLen)
 191 {
 192     DWORD ret, i, len;
 193
 194     ret = FIELD_OFFSET( CANDIDATELIST, dwOffset[lpSrc->dwCount] );
 195     if ( lpDst && dwBufLen > 0 )
 196     {
 197         *lpDst = *lpSrc;
 198         lpDst->dwOffset[0] = ret;
 199     }
 200
 201     for ( i = 0; i < lpSrc->dwCount; i++)
 202     {
 203         LPBYTE src = (LPBYTE)lpSrc + lpSrc->dwOffset[i];
 204
 205         if ( lpDst && dwBufLen > 0 )
 206         {
 207             LPBYTE dest = (LPBYTE)lpDst + lpDst->dwOffset[i];
 208
 209             len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)src, -1,
 210                                       (LPWSTR)dest, dwBufLen);
 211
 212             if ( i + 1 < lpSrc->dwCount )
 213                 lpDst->dwOffset[i+1] = lpDst->dwOffset[i] + len * sizeof(WCHAR);
 214             dwBufLen -= len * sizeof(WCHAR);
 215         }
 216         else
 217             len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)src, -1, NULL, 0);
 218
 219         ret += len * sizeof(WCHAR);
 220     }
 221
 222     if ( lpDst )
 223         lpDst->dwSize = ret;
 224
 225     return ret;
 226 }
 227
 228 static IMMThreadData *IMM_GetThreadData(HWND hwnd)
 229 {
 230     IMMThreadData *data;
 231     DWORD process, thread;
 232
 233     if (hwnd)
 234     {
 235         if (!(thread = GetWindowThreadProcessId(hwnd, &process))) return NULL;
 236         if (process != GetCurrentProcessId()) return NULL;
 237     }
 238     else thread = GetCurrentThreadId();
 239
 240     EnterCriticalSection(&threaddata_cs);
 241     LIST_FOR_EACH_ENTRY(data, &ImmThreadDataList, IMMThreadData, entry)
 242         if (data->threadID == thread) return data;
 243
 244     data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data));
 245     data->threadID = thread;
 246     list_add_head(&ImmThreadDataList,&data->entry);
 247     TRACE("Thread Data Created (%x)\n",thread);
 248     return data;
 249 }
 250
 251 static BOOL IMM_IsDefaultContext(HIMC imc)
 252 {
 253     InputContextData *data = get_imc_data(imc);
 254
 255     if (!data)
 256         return FALSE;
 257
 258     return data->threadDefault;
 259 }
 260
 261 static void IMM_FreeThreadData(void)
 262 {
 263     IMMThreadData *data;
 264
 265     EnterCriticalSection(&threaddata_cs);
 266     LIST_FOR_EACH_ENTRY(data, &ImmThreadDataList, IMMThreadData, entry)
 267     {
 268         if (data->threadID == GetCurrentThreadId())
 269         {
 270             list_remove(&data->entry);
 271             LeaveCriticalSection(&threaddata_cs);
 272             IMM_DestroyContext(data->defaultContext);
 273             HeapFree(GetProcessHeap(),0,data);
 274             TRACE("Thread Data Destroyed\n");
 275             return;
 276         }
 277     }
 278     LeaveCriticalSection(&threaddata_cs);
 279 }
 280
 281 static HMODULE load_graphics_driver(void)
 282 {
 283     static const WCHAR display_device_guid_propW[] = {
 284         '_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
 285         'd','e','v','i','c','e','_','g','u','i','d',0 };
 286     static const WCHAR key_pathW[] = {
 287         'S','y','s','t','e','m','\\',
 288         'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 289         'C','o','n','t','r','o','l','\\',
 290         'V','i','d','e','o','\\','{',0};
 291     static const WCHAR displayW[] = {'}','\\','0','0','0','0',0};
 292     static const WCHAR driverW[] = {'G','r','a','p','h','i','c','s','D','r','i','v','e','r',0};
 293
 294     HMODULE ret = 0;
 295     HKEY hkey;
 296     DWORD size;
 297     WCHAR path[MAX_PATH];
 298     WCHAR key[(sizeof(key_pathW) + sizeof(displayW)) / sizeof(WCHAR) + 40];
 299     UINT guid_atom = HandleToULong( GetPropW( GetDesktopWindow(), display_device_guid_propW ));
 300
 301     if (!guid_atom) return 0;
 302     memcpy( key, key_pathW, sizeof(key_pathW) );
 303     if (!GlobalGetAtomNameW( guid_atom, key + strlenW(key), 40 )) return 0;
 304     strcatW( key, displayW );
 305     if (RegOpenKeyW( HKEY_LOCAL_MACHINE, key, &hkey )) return 0;
 306     size = sizeof(path);
 307     if (!RegQueryValueExW( hkey, driverW, NULL, NULL, (BYTE *)path, &size )) ret = LoadLibraryW( path );
 308     RegCloseKey( hkey );
 309     TRACE( "%s %p\n", debugstr_w(path), ret );
 310     return ret;
 311 }
 312
 313 /* ImmHkl loading and freeing */
 314 #define LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}
 315 static ImmHkl *IMM_GetImmHkl(HKL hkl)
 316 {
 317     ImmHkl *ptr;
 318     WCHAR filename[MAX_PATH];
 319
 320     TRACE("Seeking ime for keyboard %p\n",hkl);
 321
 322     LIST_FOR_EACH_ENTRY(ptr, &ImmHklList, ImmHkl, entry)
 323     {
 324         if (ptr->hkl == hkl)
 325             return ptr;
 326     }
 327     /* not found... create it */
 328
 329     ptr = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ImmHkl));
 330
 331     ptr->hkl = hkl;
 332     if (ImmGetIMEFileNameW(hkl, filename, MAX_PATH)) ptr->hIME = LoadLibraryW(filename);
 333     if (!ptr->hIME) ptr->hIME = load_graphics_driver();
 334     if (ptr->hIME)
 335     {
 336         LOAD_FUNCPTR(ImeInquire);
 337         if (!ptr->pImeInquire || !ptr->pImeInquire(&ptr->imeInfo, ptr->imeClassName, NULL))
 338         {
 339             FreeLibrary(ptr->hIME);
 340             ptr->hIME = NULL;
 341         }
 342         else
 343         {
 344             LOAD_FUNCPTR(ImeDestroy);
 345             LOAD_FUNCPTR(ImeSelect);
 346             if (!ptr->pImeSelect || !ptr->pImeDestroy)
 347             {
 348                 FreeLibrary(ptr->hIME);
 349                 ptr->hIME = NULL;
 350             }
 351             else
 352             {
 353                 LOAD_FUNCPTR(ImeConfigure);
 354                 LOAD_FUNCPTR(ImeEscape);
 355                 LOAD_FUNCPTR(ImeSetActiveContext);
 356                 LOAD_FUNCPTR(ImeToAsciiEx);
 357                 LOAD_FUNCPTR(NotifyIME);
 358                 LOAD_FUNCPTR(ImeRegisterWord);
 359                 LOAD_FUNCPTR(ImeUnregisterWord);
 360                 LOAD_FUNCPTR(ImeEnumRegisterWord);
 361                 LOAD_FUNCPTR(ImeSetCompositionString);
 362                 LOAD_FUNCPTR(ImeConversionList);
 363                 LOAD_FUNCPTR(ImeProcessKey);
 364                 LOAD_FUNCPTR(ImeGetRegisterWordStyle);
 365                 LOAD_FUNCPTR(ImeGetImeMenuItems);
 366                 /* make sure our classname is WCHAR */
 367                 if (!is_kbd_ime_unicode(ptr))
 368                 {
 369                     WCHAR bufW[17];
 370                     MultiByteToWideChar(CP_ACP, 0, (LPSTR)ptr->imeClassName,
 371                                         -1, bufW, 17);
 372                     lstrcpyW(ptr->imeClassName, bufW);
 373                 }
 374             }
 375         }
 376     }
 377     list_add_head(&ImmHklList,&ptr->entry);
 378
 379     return ptr;
 380 }
 381 #undef LOAD_FUNCPTR
 382
 383 HWND WINAPI __wine_get_ui_window(HKL hkl)
 384 {
 385     ImmHkl *immHkl = IMM_GetImmHkl(hkl);
 386     return immHkl->UIWnd;
 387 }
 388
 389 static void IMM_FreeAllImmHkl(void)
 390 {
 391     ImmHkl *ptr,*cursor2;
 392
 393     LIST_FOR_EACH_ENTRY_SAFE(ptr, cursor2, &ImmHklList, ImmHkl, entry)
 394     {
 395         list_remove(&ptr->entry);
 396         if (ptr->hIME)
 397         {
 398             ptr->pImeDestroy(1);
 399             FreeLibrary(ptr->hIME);
 400         }
 401         if (ptr->UIWnd)
 402             DestroyWindow(ptr->UIWnd);
 403         HeapFree(GetProcessHeap(),0,ptr);
 404     }
 405 }
 406
 407 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpReserved)
 408 {
 409     TRACE("%p, %x, %p\n",hInstDLL,fdwReason,lpReserved);
 410     switch (fdwReason)
 411     {
 412         case DLL_PROCESS_ATTACH:
 413             if (!User32InitializeImmEntryTable(IMM_INIT_MAGIC))
 414             {
 415                 return FALSE;
 416             }
 417             break;
 418         case DLL_THREAD_ATTACH:
 419             break;
 420         case DLL_THREAD_DETACH:
 421             IMM_FreeThreadData();
 422             break;
 423         case DLL_PROCESS_DETACH:
 424             if (lpReserved) break;
 425             IMM_FreeThreadData();
 426             IMM_FreeAllImmHkl();
 427             break;
 428     }
 429     return TRUE;
 430 }
 431
 432 /* for posting messages as the IME */
 433 static void ImmInternalPostIMEMessage(InputContextData *data, UINT msg, WPARAM wParam, LPARAM lParam)
 434 {
 435     HWND target = GetFocus();
 436     if (!target)
 437        PostMessageW(data->IMC.hWnd,msg,wParam,lParam);
 438     else
 439        PostMessageW(target, msg, wParam, lParam);
 440 }
 441
 442 static LRESULT ImmInternalSendIMENotify(InputContextData *data, WPARAM notify, LPARAM lParam)
 443 {
 444     HWND target;
 445
 446     target = data->IMC.hWnd;
 447     if (!target) target = GetFocus();
 448
 449     if (target)
 450        return SendMessageW(target, WM_IME_NOTIFY, notify, lParam);
 451
 452     return 0;
 453 }
 454
 455 static HIMCC ImmCreateBlankCompStr(void)
 456 {
 457     HIMCC rc;
 458     LPCOMPOSITIONSTRING ptr;
 459     rc = ImmCreateIMCC(sizeof(COMPOSITIONSTRING));
 460     ptr = ImmLockIMCC(rc);
 461     memset(ptr,0,sizeof(COMPOSITIONSTRING));
 462     ptr->dwSize = sizeof(COMPOSITIONSTRING);
 463     ImmUnlockIMCC(rc);
 464     return rc;
 465 }
 466
 467 static InputContextData* get_imc_data(HIMC hIMC)
 468 {
 469     InputContextData *data = hIMC;
 470
 471     if (hIMC == NULL)
 472         return NULL;
 473
 474     if(IsBadReadPtr(data, sizeof(InputContextData)) || data->magic != WINE_IMC_VALID_MAGIC)
 475     {
 476         SetLastError(ERROR_INVALID_HANDLE);
 477         return NULL;
 478     }
 479     return data;
 480 }
 481
 482 static HIMC get_default_context( HWND hwnd )
 483 {
 484     HIMC ret;
 485     IMMThreadData* thread_data = IMM_GetThreadData( hwnd );
 486
 487     if (!thread_data) return 0;
 488
 489     if (thread_data->defaultContext)
 490     {
 491         ret = thread_data->defaultContext;
 492         LeaveCriticalSection(&threaddata_cs);
 493         return ret;
 494     }
 495
 496     /* can't create a default context in another thread */
 497     if (thread_data->threadID != GetCurrentThreadId())
 498     {
 499         LeaveCriticalSection(&threaddata_cs);
 500         return 0;
 501     }
 502
 503     LeaveCriticalSection(&threaddata_cs);
 504
 505     ret = ImmCreateContext();
 506     if (!ret) return 0;
 507     ((InputContextData*)ret)->threadDefault = TRUE;
 508
 509     /* thread_data is in the current thread so we can assume it's still valid */
 510     EnterCriticalSection(&threaddata_cs);
 511
 512     if (thread_data->defaultContext) /* someone beat us */
 513     {
 514         IMM_DestroyContext( ret );
 515         ret = thread_data->defaultContext;
 516     }
 517     else thread_data->defaultContext = ret;
 518
 519     LeaveCriticalSection(&threaddata_cs);
 520     return ret;
 521 }
 522
 523 static BOOL IMM_IsCrossThreadAccess(HWND hWnd,  HIMC hIMC)
 524 {
 525     InputContextData *data;
 526
 527     if (hWnd)
 528     {
 529         DWORD thread = GetWindowThreadProcessId(hWnd, NULL);
 530         if (thread != GetCurrentThreadId()) return TRUE;
 531     }
 532     data = get_imc_data(hIMC);
 533     if (data && data->threadID != GetCurrentThreadId())
 534         return TRUE;
 535
 536     return FALSE;
 537 }
 538
 539 /***********************************************************************
 540  *              ImmAssociateContext (IMM32.@)
 541  */
 542 HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
 543 {
 544     HIMC old = NULL;
 545     InputContextData *data = get_imc_data(hIMC);
 546
 547     TRACE("(%p, %p):\n", hWnd, hIMC);
 548
 549     if(hIMC && !data)
 550         return NULL;
 551
 552     /*
 553      * If already associated just return
 554      */
 555     if (hIMC && data->IMC.hWnd == hWnd)
 556         return hIMC;
 557
 558     if (hIMC && IMM_IsCrossThreadAccess(hWnd, hIMC))
 559         return NULL;
 560
 561     if (hWnd)
 562     {
 563         HIMC defaultContext = get_default_context( hWnd );
 564         old = RemovePropW(hWnd,szwWineIMCProperty);
 565
 566         if (old == NULL)
 567             old = defaultContext;
 568         else if (old == (HIMC)-1)
 569             old = NULL;
 570
 571         if (hIMC != defaultContext)
 572         {
 573             if (hIMC == NULL) /* Meaning disable imm for that window*/
 574                 SetPropW(hWnd,szwWineIMCProperty,(HANDLE)-1);
 575             else
 576                 SetPropW(hWnd,szwWineIMCProperty,hIMC);
 577         }
 578
 579         if (old)
 580         {
 581             InputContextData *old_data = old;
 582             if (old_data->IMC.hWnd == hWnd)
 583                 old_data->IMC.hWnd = NULL;
 584         }
 585     }
 586
 587     if (!hIMC)
 588         return old;
 589
 590     SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
 591     data->IMC.hWnd = hWnd;
 592     SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
 593
 594     return old;
 595 }
 596
 597
 598 /*
 599  * Helper function for ImmAssociateContextEx
 600  */
 601 static BOOL CALLBACK _ImmAssociateContextExEnumProc(HWND hwnd, LPARAM lParam)
 602 {
 603     HIMC hImc = (HIMC)lParam;
 604     ImmAssociateContext(hwnd,hImc);
 605     return TRUE;
 606 }
 607
 608 /***********************************************************************
 609  *              ImmAssociateContextEx (IMM32.@)
 610  */
 611 BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
 612 {
 613     TRACE("(%p, %p, 0x%x):\n", hWnd, hIMC, dwFlags);
 614
 615     if (!hWnd)
 616         return FALSE;
 617
 618     switch (dwFlags)
 619     {
 620     case 0:
 621         ImmAssociateContext(hWnd,hIMC);
 622         return TRUE;
 623     case IACE_DEFAULT:
 624     {
 625         HIMC defaultContext = get_default_context( hWnd );
 626         if (!defaultContext) return FALSE;
 627         ImmAssociateContext(hWnd,defaultContext);
 628         return TRUE;
 629     }
 630     case IACE_IGNORENOCONTEXT:
 631         if (GetPropW(hWnd,szwWineIMCProperty))
 632             ImmAssociateContext(hWnd,hIMC);
 633         return TRUE;
 634     case IACE_CHILDREN:
 635         EnumChildWindows(hWnd,_ImmAssociateContextExEnumProc,(LPARAM)hIMC);
 636         return TRUE;
 637     default:
 638         FIXME("Unknown dwFlags 0x%x\n",dwFlags);
 639         return FALSE;
 640     }
 641 }
 642
 643 /***********************************************************************
 644  *              ImmConfigureIMEA (IMM32.@)
 645  */
 646 BOOL WINAPI ImmConfigureIMEA(
 647   HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
 648 {
 649     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 650
 651     TRACE("(%p, %p, %d, %p):\n", hKL, hWnd, dwMode, lpData);
 652
 653     if (dwMode == IME_CONFIG_REGISTERWORD && !lpData)
 654         return FALSE;
 655
 656     if (immHkl->hIME && immHkl->pImeConfigure)
 657     {
 658         if (dwMode != IME_CONFIG_REGISTERWORD || !is_kbd_ime_unicode(immHkl))
 659             return immHkl->pImeConfigure(hKL,hWnd,dwMode,lpData);
 660         else
 661         {
 662             REGISTERWORDW rww;
 663             REGISTERWORDA *rwa = lpData;
 664             BOOL rc;
 665
 666             rww.lpReading = strdupAtoW(rwa->lpReading);
 667             rww.lpWord = strdupAtoW(rwa->lpWord);
 668             rc = immHkl->pImeConfigure(hKL,hWnd,dwMode,&rww);
 669             HeapFree(GetProcessHeap(),0,rww.lpReading);
 670             HeapFree(GetProcessHeap(),0,rww.lpWord);
 671             return rc;
 672         }
 673     }
 674     else
 675         return FALSE;
 676 }
 677
 678 /***********************************************************************
 679  *              ImmConfigureIMEW (IMM32.@)
 680  */
 681 BOOL WINAPI ImmConfigureIMEW(
 682   HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
 683 {
 684     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 685
 686     TRACE("(%p, %p, %d, %p):\n", hKL, hWnd, dwMode, lpData);
 687
 688     if (dwMode == IME_CONFIG_REGISTERWORD && !lpData)
 689         return FALSE;
 690
 691     if (immHkl->hIME && immHkl->pImeConfigure)
 692     {
 693         if (dwMode != IME_CONFIG_REGISTERWORD || is_kbd_ime_unicode(immHkl))
 694             return immHkl->pImeConfigure(hKL,hWnd,dwMode,lpData);
 695         else
 696         {
 697             REGISTERWORDW *rww = lpData;
 698             REGISTERWORDA rwa;
 699             BOOL rc;
 700
 701             rwa.lpReading = strdupWtoA(rww->lpReading);
 702             rwa.lpWord = strdupWtoA(rww->lpWord);
 703             rc = immHkl->pImeConfigure(hKL,hWnd,dwMode,&rwa);
 704             HeapFree(GetProcessHeap(),0,rwa.lpReading);
 705             HeapFree(GetProcessHeap(),0,rwa.lpWord);
 706             return rc;
 707         }
 708     }
 709     else
 710         return FALSE;
 711 }
 712
 713 /***********************************************************************
 714  *              ImmCreateContext (IMM32.@)
 715  */
 716 HIMC WINAPI ImmCreateContext(void)
 717 {
 718     InputContextData *new_context;
 719     LPGUIDELINE gl;
 720     LPCANDIDATEINFO ci;
 721     int i;
 722
 723     new_context = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(InputContextData));
 724
 725     /* Load the IME */
 726     new_context->immKbd = IMM_GetImmHkl(GetKeyboardLayout(0));
 727
 728     if (!new_context->immKbd->hIME)
 729     {
 730         TRACE("IME dll could not be loaded\n");
 731         HeapFree(GetProcessHeap(),0,new_context);
 732         return 0;
 733     }
 734
 735     /* the HIMCCs are never NULL */
 736     new_context->IMC.hCompStr = ImmCreateBlankCompStr();
 737     new_context->IMC.hMsgBuf = ImmCreateIMCC(0);
 738     new_context->IMC.hCandInfo = ImmCreateIMCC(sizeof(CANDIDATEINFO));
 739     ci = ImmLockIMCC(new_context->IMC.hCandInfo);
 740     memset(ci,0,sizeof(CANDIDATEINFO));
 741     ci->dwSize = sizeof(CANDIDATEINFO);
 742     ImmUnlockIMCC(new_context->IMC.hCandInfo);
 743     new_context->IMC.hGuideLine = ImmCreateIMCC(sizeof(GUIDELINE));
 744     gl = ImmLockIMCC(new_context->IMC.hGuideLine);
 745     memset(gl,0,sizeof(GUIDELINE));
 746     gl->dwSize = sizeof(GUIDELINE);
 747     ImmUnlockIMCC(new_context->IMC.hGuideLine);
 748
 749     for (i = 0; i < sizeof(new_context->IMC.cfCandForm) / sizeof(CANDIDATEFORM); i++)
 750         new_context->IMC.cfCandForm[i].dwIndex = ~0u;
 751
 752     /* Initialize the IME Private */
 753     new_context->IMC.hPrivate = ImmCreateIMCC(new_context->immKbd->imeInfo.dwPrivateDataSize);
 754
 755     new_context->IMC.fdwConversion = new_context->immKbd->imeInfo.fdwConversionCaps;
 756     new_context->IMC.fdwSentence = new_context->immKbd->imeInfo.fdwSentenceCaps;
 757
 758     if (!new_context->immKbd->pImeSelect(new_context, TRUE))
 759     {
 760         TRACE("Selection of IME failed\n");
 761         IMM_DestroyContext(new_context);
 762         return 0;
 763     }
 764     new_context->threadID = GetCurrentThreadId();
 765     SendMessageW(GetFocus(), WM_IME_SELECT, TRUE, (LPARAM)new_context->immKbd);
 766
 767     new_context->immKbd->uSelected++;
 768     TRACE("Created context %p\n",new_context);
 769
 770     new_context->magic = WINE_IMC_VALID_MAGIC;
 771     return new_context;
 772 }
 773
 774 static BOOL IMM_DestroyContext(HIMC hIMC)
 775 {
 776     InputContextData *data = get_imc_data(hIMC);
 777
 778     TRACE("Destroying %p\n",hIMC);
 779
 780     if (!data)
 781         return FALSE;
 782
 783     data->immKbd->uSelected --;
 784     data->immKbd->pImeSelect(hIMC, FALSE);
 785     SendMessageW(data->IMC.hWnd, WM_IME_SELECT, FALSE, (LPARAM)data->immKbd);
 786
 787     ImmDestroyIMCC(data->IMC.hCompStr);
 788     ImmDestroyIMCC(data->IMC.hCandInfo);
 789     ImmDestroyIMCC(data->IMC.hGuideLine);
 790     ImmDestroyIMCC(data->IMC.hPrivate);
 791     ImmDestroyIMCC(data->IMC.hMsgBuf);
 792
 793     data->magic = 0;
 794     HeapFree(GetProcessHeap(),0,data);
 795
 796     return TRUE;
 797 }
 798
 799 /***********************************************************************
 800  *              ImmDestroyContext (IMM32.@)
 801  */
 802 BOOL WINAPI ImmDestroyContext(HIMC hIMC)
 803 {
 804     if (!IMM_IsDefaultContext(hIMC) && !IMM_IsCrossThreadAccess(NULL, hIMC))
 805         return IMM_DestroyContext(hIMC);
 806     else
 807         return FALSE;
 808 }
 809
 810 /***********************************************************************
 811  *              ImmDisableIME (IMM32.@)
 812  */
 813 BOOL WINAPI ImmDisableIME(DWORD idThread)
 814 {
 815     FIXME("(%d): stub\n", idThread);
 816     return TRUE;
 817 }
 818
 819 /***********************************************************************
 820  *              ImmEnumRegisterWordA (IMM32.@)
 821  */
 822 UINT WINAPI ImmEnumRegisterWordA(
 823   HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc,
 824   LPCSTR lpszReading, DWORD dwStyle,
 825   LPCSTR lpszRegister, LPVOID lpData)
 826 {
 827     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 828     TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL, lpfnEnumProc,
 829         debugstr_a(lpszReading), dwStyle, debugstr_a(lpszRegister), lpData);
 830     if (immHkl->hIME && immHkl->pImeEnumRegisterWord)
 831     {
 832         if (!is_kbd_ime_unicode(immHkl))
 833             return immHkl->pImeEnumRegisterWord((REGISTERWORDENUMPROCW)lpfnEnumProc,
 834                 (LPCWSTR)lpszReading, dwStyle, (LPCWSTR)lpszRegister, lpData);
 835         else
 836         {
 837             LPWSTR lpszwReading = strdupAtoW(lpszReading);
 838             LPWSTR lpszwRegister = strdupAtoW(lpszRegister);
 839             BOOL rc;
 840
 841             rc = immHkl->pImeEnumRegisterWord((REGISTERWORDENUMPROCW)lpfnEnumProc,
 842                                               lpszwReading, dwStyle, lpszwRegister,
 843                                               lpData);
 844
 845             HeapFree(GetProcessHeap(),0,lpszwReading);
 846             HeapFree(GetProcessHeap(),0,lpszwRegister);
 847             return rc;
 848         }
 849     }
 850     else
 851         return 0;
 852 }
 853
 854 /***********************************************************************
 855  *              ImmEnumRegisterWordW (IMM32.@)
 856  */
 857 UINT WINAPI ImmEnumRegisterWordW(
 858   HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc,
 859   LPCWSTR lpszReading, DWORD dwStyle,
 860   LPCWSTR lpszRegister, LPVOID lpData)
 861 {
 862     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 863     TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL, lpfnEnumProc,
 864         debugstr_w(lpszReading), dwStyle, debugstr_w(lpszRegister), lpData);
 865     if (immHkl->hIME && immHkl->pImeEnumRegisterWord)
 866     {
 867         if (is_kbd_ime_unicode(immHkl))
 868             return immHkl->pImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
 869                                             lpszRegister, lpData);
 870         else
 871         {
 872             LPSTR lpszaReading = strdupWtoA(lpszReading);
 873             LPSTR lpszaRegister = strdupWtoA(lpszRegister);
 874             BOOL rc;
 875
 876             rc = immHkl->pImeEnumRegisterWord(lpfnEnumProc, (LPCWSTR)lpszaReading,
 877                                               dwStyle, (LPCWSTR)lpszaRegister, lpData);
 878
 879             HeapFree(GetProcessHeap(),0,lpszaReading);
 880             HeapFree(GetProcessHeap(),0,lpszaRegister);
 881             return rc;
 882         }
 883     }
 884     else
 885         return 0;
 886 }
 887
 888 static inline BOOL EscapeRequiresWA(UINT uEscape)
 889 {
 890         if (uEscape == IME_ESC_GET_EUDC_DICTIONARY ||
 891             uEscape == IME_ESC_SET_EUDC_DICTIONARY ||
 892             uEscape == IME_ESC_IME_NAME ||
 893             uEscape == IME_ESC_GETHELPFILENAME)
 894         return TRUE;
 895     return FALSE;
 896 }
 897
 898 /***********************************************************************
 899  *              ImmEscapeA (IMM32.@)
 900  */
 901 LRESULT WINAPI ImmEscapeA(
 902   HKL hKL, HIMC hIMC,
 903   UINT uEscape, LPVOID lpData)
 904 {
 905     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 906     TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
 907
 908     if (immHkl->hIME && immHkl->pImeEscape)
 909     {
 910         if (!EscapeRequiresWA(uEscape) || !is_kbd_ime_unicode(immHkl))
 911             return immHkl->pImeEscape(hIMC,uEscape,lpData);
 912         else
 913         {
 914             WCHAR buffer[81]; /* largest required buffer should be 80 */
 915             LRESULT rc;
 916             if (uEscape == IME_ESC_SET_EUDC_DICTIONARY)
 917             {
 918                 MultiByteToWideChar(CP_ACP,0,lpData,-1,buffer,81);
 919                 rc = immHkl->pImeEscape(hIMC,uEscape,buffer);
 920             }
 921             else
 922             {
 923                 rc = immHkl->pImeEscape(hIMC,uEscape,buffer);
 924                 WideCharToMultiByte(CP_ACP,0,buffer,-1,lpData,80, NULL, NULL);
 925             }
 926             return rc;
 927         }
 928     }
 929     else
 930         return 0;
 931 }
 932
 933 /***********************************************************************
 934  *              ImmEscapeW (IMM32.@)
 935  */
 936 LRESULT WINAPI ImmEscapeW(
 937   HKL hKL, HIMC hIMC,
 938   UINT uEscape, LPVOID lpData)
 939 {
 940     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 941     TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
 942
 943     if (immHkl->hIME && immHkl->pImeEscape)
 944     {
 945         if (!EscapeRequiresWA(uEscape) || is_kbd_ime_unicode(immHkl))
 946             return immHkl->pImeEscape(hIMC,uEscape,lpData);
 947         else
 948         {
 949             CHAR buffer[81]; /* largest required buffer should be 80 */
 950             LRESULT rc;
 951             if (uEscape == IME_ESC_SET_EUDC_DICTIONARY)
 952             {
 953                 WideCharToMultiByte(CP_ACP,0,lpData,-1,buffer,81, NULL, NULL);
 954                 rc = immHkl->pImeEscape(hIMC,uEscape,buffer);
 955             }
 956             else
 957             {
 958                 rc = immHkl->pImeEscape(hIMC,uEscape,buffer);
 959                 MultiByteToWideChar(CP_ACP,0,buffer,-1,lpData,80);
 960             }
 961             return rc;
 962         }
 963     }
 964     else
 965         return 0;
 966 }
 967
 968 /***********************************************************************
 969  *              ImmGetCandidateListA (IMM32.@)
 970  */
 971 DWORD WINAPI ImmGetCandidateListA(
 972   HIMC hIMC, DWORD dwIndex,
 973   LPCANDIDATELIST lpCandList, DWORD dwBufLen)
 974 {
 975     InputContextData *data = get_imc_data(hIMC);
 976     LPCANDIDATEINFO candinfo;
 977     LPCANDIDATELIST candlist;
 978     DWORD ret = 0;
 979
 980     TRACE("%p, %d, %p, %d\n", hIMC, dwIndex, lpCandList, dwBufLen);
 981
 982     if (!data || !data->IMC.hCandInfo)
 983        return 0;
 984
 985     candinfo = ImmLockIMCC(data->IMC.hCandInfo);
 986     if ( dwIndex >= candinfo->dwCount ||
 987          dwIndex >= (sizeof(candinfo->dwOffset) / sizeof(DWORD)) )
 988         goto done;
 989
 990     candlist = (LPCANDIDATELIST)((LPBYTE)candinfo + candinfo->dwOffset[dwIndex]);
 991     if ( !candlist->dwSize || !candlist->dwCount )
 992         goto done;
 993
 994     if ( !is_himc_ime_unicode(data) )
 995     {
 996         ret = candlist->dwSize;
 997         if ( lpCandList && dwBufLen >= ret )
 998             memcpy(lpCandList, candlist, ret);
 999     }
1000     else
1001         ret = convert_candidatelist_WtoA( candlist, lpCandList, dwBufLen);
1002
1003 done:
1004     ImmUnlockIMCC(data->IMC.hCandInfo);
1005     return ret;
1006 }
1007
1008 /***********************************************************************
1009  *              ImmGetCandidateListCountA (IMM32.@)
1010  */
1011 DWORD WINAPI ImmGetCandidateListCountA(
1012   HIMC hIMC, LPDWORD lpdwListCount)
1013 {
1014     InputContextData *data = get_imc_data(hIMC);
1015     LPCANDIDATEINFO candinfo;
1016     DWORD ret, count;
1017
1018     TRACE("%p, %p\n", hIMC, lpdwListCount);
1019
1020     if (!data || !lpdwListCount || !data->IMC.hCandInfo)
1021        return 0;
1022
1023     candinfo = ImmLockIMCC(data->IMC.hCandInfo);
1024
1025     *lpdwListCount = count = candinfo->dwCount;
1026
1027     if ( !is_himc_ime_unicode(data) )
1028         ret = candinfo->dwSize;
1029     else
1030     {
1031         ret = sizeof(CANDIDATEINFO);
1032         while ( count-- )
1033             ret += ImmGetCandidateListA(hIMC, count, NULL, 0);
1034     }
1035
1036     ImmUnlockIMCC(data->IMC.hCandInfo);
1037     return ret;
1038 }
1039
1040 /***********************************************************************
1041  *              ImmGetCandidateListCountW (IMM32.@)
1042  */
1043 DWORD WINAPI ImmGetCandidateListCountW(
1044   HIMC hIMC, LPDWORD lpdwListCount)
1045 {
1046     InputContextData *data = get_imc_data(hIMC);
1047     LPCANDIDATEINFO candinfo;
1048     DWORD ret, count;
1049
1050     TRACE("%p, %p\n", hIMC, lpdwListCount);
1051
1052     if (!data || !lpdwListCount || !data->IMC.hCandInfo)
1053        return 0;
1054
1055     candinfo = ImmLockIMCC(data->IMC.hCandInfo);
1056
1057     *lpdwListCount = count = candinfo->dwCount;
1058
1059     if ( is_himc_ime_unicode(data) )
1060         ret = candinfo->dwSize;
1061     else
1062     {
1063         ret = sizeof(CANDIDATEINFO);
1064         while ( count-- )
1065             ret += ImmGetCandidateListW(hIMC, count, NULL, 0);
1066     }
1067
1068     ImmUnlockIMCC(data->IMC.hCandInfo);
1069     return ret;
1070 }
1071
1072 /***********************************************************************
1073  *              ImmGetCandidateListW (IMM32.@)
1074  */
1075 DWORD WINAPI ImmGetCandidateListW(
1076   HIMC hIMC, DWORD dwIndex,
1077   LPCANDIDATELIST lpCandList, DWORD dwBufLen)
1078 {
1079     InputContextData *data = get_imc_data(hIMC);
1080     LPCANDIDATEINFO candinfo;
1081     LPCANDIDATELIST candlist;
1082     DWORD ret = 0;
1083
1084     TRACE("%p, %d, %p, %d\n", hIMC, dwIndex, lpCandList, dwBufLen);
1085
1086     if (!data || !data->IMC.hCandInfo)
1087        return 0;
1088
1089     candinfo = ImmLockIMCC(data->IMC.hCandInfo);
1090     if ( dwIndex >= candinfo->dwCount ||
1091          dwIndex >= (sizeof(candinfo->dwOffset) / sizeof(DWORD)) )
1092         goto done;
1093
1094     candlist = (LPCANDIDATELIST)((LPBYTE)candinfo + candinfo->dwOffset[dwIndex]);
1095     if ( !candlist->dwSize || !candlist->dwCount )
1096         goto done;
1097
1098     if ( is_himc_ime_unicode(data) )
1099     {
1100         ret = candlist->dwSize;
1101         if ( lpCandList && dwBufLen >= ret )
1102             memcpy(lpCandList, candlist, ret);
1103     }
1104     else
1105         ret = convert_candidatelist_AtoW( candlist, lpCandList, dwBufLen);
1106
1107 done:
1108     ImmUnlockIMCC(data->IMC.hCandInfo);
1109     return ret;
1110 }
1111
1112 /***********************************************************************
1113  *              ImmGetCandidateWindow (IMM32.@)
1114  */
1115 BOOL WINAPI ImmGetCandidateWindow(
1116   HIMC hIMC, DWORD dwIndex, LPCANDIDATEFORM lpCandidate)
1117 {
1118     InputContextData *data = get_imc_data(hIMC);
1119
1120     TRACE("%p, %d, %p\n", hIMC, dwIndex, lpCandidate);
1121
1122     if (!data || !lpCandidate)
1123         return FALSE;
1124
1125     if ( dwIndex >= (sizeof(data->IMC.cfCandForm) / sizeof(CANDIDATEFORM)) )
1126         return FALSE;
1127
1128     if (data->IMC.cfCandForm[dwIndex].dwIndex != dwIndex)
1129         return FALSE;
1130
1131     *lpCandidate = data->IMC.cfCandForm[dwIndex];
1132
1133     return TRUE;
1134 }
1135
1136 /***********************************************************************
1137  *              ImmGetCompositionFontA (IMM32.@)
1138  */
1139 BOOL WINAPI ImmGetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
1140 {
1141     LOGFONTW lfW;
1142     BOOL rc;
1143
1144     TRACE("(%p, %p):\n", hIMC, lplf);
1145
1146     rc = ImmGetCompositionFontW(hIMC,&lfW);
1147     if (!rc || !lplf)
1148         return FALSE;
1149
1150     memcpy(lplf,&lfW,sizeof(LOGFONTA));
1151     WideCharToMultiByte(CP_ACP, 0, lfW.lfFaceName, -1, lplf->lfFaceName,
1152                         LF_FACESIZE, NULL, NULL);
1153     return TRUE;
1154 }
1155
1156 /***********************************************************************
1157  *              ImmGetCompositionFontW (IMM32.@)
1158  */
1159 BOOL WINAPI ImmGetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
1160 {
1161     InputContextData *data = get_imc_data(hIMC);
1162
1163     TRACE("(%p, %p):\n", hIMC, lplf);
1164
1165     if (!data || !lplf)
1166         return FALSE;
1167
1168     *lplf = data->IMC.lfFont.W;
1169
1170     return TRUE;
1171 }
1172
1173
1174 /* Helpers for the GetCompositionString functions */
1175
1176 static INT CopyCompStringIMEtoClient(InputContextData *data, LPBYTE source, INT slen, LPBYTE target, INT tlen,
1177                                      BOOL unicode )
1178 {
1179     INT rc;
1180
1181     if (is_himc_ime_unicode(data) && !unicode)
1182         rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)source, slen, (LPSTR)target, tlen, NULL, NULL);
1183     else if (!is_himc_ime_unicode(data) && unicode)
1184         rc = MultiByteToWideChar(CP_ACP, 0, (LPSTR)source, slen, (LPWSTR)target, tlen) * sizeof(WCHAR);
1185     else
1186     {
1187         int dlen = (unicode)?sizeof(WCHAR):sizeof(CHAR);
1188         memcpy( target, source, min(slen,tlen)*dlen);
1189         rc = slen*dlen;
1190     }
1191
1192     return rc;
1193 }
1194
1195 static INT CopyCompAttrIMEtoClient(InputContextData *data, LPBYTE source, INT slen, LPBYTE ssource, INT sslen,
1196                                    LPBYTE target, INT tlen, BOOL unicode )
1197 {
1198     INT rc;
1199
1200     if (is_himc_ime_unicode(data) && !unicode)
1201     {
1202         rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource, sslen, NULL, 0, NULL, NULL);
1203         if (tlen)
1204         {
1205             const BYTE *src = source;
1206             LPBYTE dst = target;
1207             int i, j = 0, k = 0;
1208
1209             if (rc < tlen)
1210                 tlen = rc;
1211             for (i = 0; i < sslen; ++i)
1212             {
1213                 int len;
1214
1215                 len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)ssource + i, 1,
1216                                           NULL, 0, NULL, NULL);
1217                 for (; len > 0; --len)
1218                 {
1219                     dst[j++] = src[k];
1220
1221                     if (j >= tlen)
1222                         goto end;
1223                 }
1224                 ++k;
1225             }
1226         end:
1227             rc = j;
1228         }
1229     }
1230     else if (!is_himc_ime_unicode(data) && unicode)
1231     {
1232         rc = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource, sslen, NULL, 0);
1233         if (tlen)
1234         {
1235             const BYTE *src = source;
1236             LPBYTE dst = target;
1237             int i, j = 0;
1238
1239             if (rc < tlen)
1240                 tlen = rc;
1241             for (i = 0; i < sslen; ++i)
1242             {
1243                 if (IsDBCSLeadByte(((LPSTR)ssource)[i]))
1244                     continue;
1245
1246                 dst[j++] = src[i];
1247
1248                 if (j >= tlen)
1249                     break;
1250             }
1251             rc = j;
1252         }
1253     }
1254     else
1255     {
1256         memcpy( target, source, min(slen,tlen));
1257         rc = slen;
1258     }
1259
1260     return rc;
1261 }
1262
1263 static INT CopyCompClauseIMEtoClient(InputContextData *data, LPBYTE source, INT slen, LPBYTE ssource,
1264                                      LPBYTE target, INT tlen, BOOL unicode )
1265 {
1266     INT rc;
1267
1268     if (is_himc_ime_unicode(data) && !unicode)
1269     {
1270         if (tlen)
1271         {
1272             int i;
1273
1274             if (slen < tlen)
1275                 tlen = slen;
1276             tlen /= sizeof (DWORD);
1277             for (i = 0; i < tlen; ++i)
1278             {
1279                 ((DWORD *)target)[i] = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource,
1280                                                           ((DWORD *)source)[i],
1281                                                           NULL, 0,
1282                                                           NULL, NULL);
1283             }
1284             rc = sizeof (DWORD) * i;
1285         }
1286         else
1287             rc = slen;
1288     }
1289     else if (!is_himc_ime_unicode(data) && unicode)
1290     {
1291         if (tlen)
1292         {
1293             int i;
1294
1295             if (slen < tlen)
1296                 tlen = slen;
1297             tlen /= sizeof (DWORD);
1298             for (i = 0; i < tlen; ++i)
1299             {
1300                 ((DWORD *)target)[i] = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource,
1301                                                           ((DWORD *)source)[i],
1302                                                           NULL, 0);
1303             }
1304             rc = sizeof (DWORD) * i;
1305         }
1306         else
1307             rc = slen;
1308     }
1309     else
1310     {
1311         memcpy( target, source, min(slen,tlen));
1312         rc = slen;
1313     }
1314
1315     return rc;
1316 }
1317
1318 static INT CopyCompOffsetIMEtoClient(InputContextData *data, DWORD offset, LPBYTE ssource, BOOL unicode)
1319 {
1320     int rc;
1321
1322     if (is_himc_ime_unicode(data) && !unicode)
1323     {
1324         rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource, offset, NULL, 0, NULL, NULL);
1325     }
1326     else if (!is_himc_ime_unicode(data) && unicode)
1327     {
1328         rc = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource, offset, NULL, 0);
1329     }
1330     else
1331         rc = offset;
1332
1333     return rc;
1334 }
1335
1336 static LONG ImmGetCompositionStringT( HIMC hIMC, DWORD dwIndex, LPVOID lpBuf,
1337                                       DWORD dwBufLen, BOOL unicode)
1338 {
1339     LONG rc = 0;
1340     InputContextData *data = get_imc_data(hIMC);
1341     LPCOMPOSITIONSTRING compstr;
1342     LPBYTE compdata;
1343
1344     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
1345
1346     if (!data)
1347        return FALSE;
1348
1349     if (!data->IMC.hCompStr)
1350        return FALSE;
1351
1352     compdata = ImmLockIMCC(data->IMC.hCompStr);
1353     compstr = (LPCOMPOSITIONSTRING)compdata;
1354
1355     switch (dwIndex)
1356     {
1357     case GCS_RESULTSTR:
1358         TRACE("GCS_RESULTSTR\n");
1359         rc = CopyCompStringIMEtoClient(data, compdata + compstr->dwResultStrOffset, compstr->dwResultStrLen, lpBuf, dwBufLen, unicode);
1360         break;
1361     case GCS_COMPSTR:
1362         TRACE("GCS_COMPSTR\n");
1363         rc = CopyCompStringIMEtoClient(data, compdata + compstr->dwCompStrOffset, compstr->dwCompStrLen, lpBuf, dwBufLen, unicode);
1364         break;
1365     case GCS_COMPATTR:
1366         TRACE("GCS_COMPATTR\n");
1367         rc = CopyCompAttrIMEtoClient(data, compdata + compstr->dwCompAttrOffset, compstr->dwCompAttrLen,
1368                                      compdata + compstr->dwCompStrOffset, compstr->dwCompStrLen,
1369                                      lpBuf, dwBufLen, unicode);
1370         break;
1371     case GCS_COMPCLAUSE:
1372         TRACE("GCS_COMPCLAUSE\n");
1373         rc = CopyCompClauseIMEtoClient(data, compdata + compstr->dwCompClauseOffset,compstr->dwCompClauseLen,
1374                                        compdata + compstr->dwCompStrOffset,
1375                                        lpBuf, dwBufLen, unicode);
1376         break;
1377     case GCS_RESULTCLAUSE:
1378         TRACE("GCS_RESULTCLAUSE\n");
1379         rc = CopyCompClauseIMEtoClient(data, compdata + compstr->dwResultClauseOffset,compstr->dwResultClauseLen,
1380                                        compdata + compstr->dwResultStrOffset,
1381                                        lpBuf, dwBufLen, unicode);
1382         break;
1383     case GCS_RESULTREADSTR:
1384         TRACE("GCS_RESULTREADSTR\n");
1385         rc = CopyCompStringIMEtoClient(data, compdata + compstr->dwResultReadStrOffset, compstr->dwResultReadStrLen, lpBuf, dwBufLen, unicode);
1386         break;
1387     case GCS_RESULTREADCLAUSE:
1388         TRACE("GCS_RESULTREADCLAUSE\n");
1389         rc = CopyCompClauseIMEtoClient(data, compdata + compstr->dwResultReadClauseOffset,compstr->dwResultReadClauseLen,
1390                                        compdata + compstr->dwResultStrOffset,
1391                                        lpBuf, dwBufLen, unicode);
1392         break;
1393     case GCS_COMPREADSTR:
1394         TRACE("GCS_COMPREADSTR\n");
1395         rc = CopyCompStringIMEtoClient(data, compdata + compstr->dwCompReadStrOffset, compstr->dwCompReadStrLen, lpBuf, dwBufLen, unicode);
1396         break;
1397     case GCS_COMPREADATTR:
1398         TRACE("GCS_COMPREADATTR\n");
1399         rc = CopyCompAttrIMEtoClient(data, compdata + compstr->dwCompReadAttrOffset, compstr->dwCompReadAttrLen,
1400                                      compdata + compstr->dwCompReadStrOffset, compstr->dwCompReadStrLen,
1401                                      lpBuf, dwBufLen, unicode);
1402         break;
1403     case GCS_COMPREADCLAUSE:
1404         TRACE("GCS_COMPREADCLAUSE\n");
1405         rc = CopyCompClauseIMEtoClient(data, compdata + compstr->dwCompReadClauseOffset,compstr->dwCompReadClauseLen,
1406                                        compdata + compstr->dwCompStrOffset,
1407                                        lpBuf, dwBufLen, unicode);
1408         break;
1409     case GCS_CURSORPOS:
1410         TRACE("GCS_CURSORPOS\n");
1411         rc = CopyCompOffsetIMEtoClient(data, compstr->dwCursorPos, compdata + compstr->dwCompStrOffset, unicode);
1412         break;
1413     case GCS_DELTASTART:
1414         TRACE("GCS_DELTASTART\n");
1415         rc = CopyCompOffsetIMEtoClient(data, compstr->dwDeltaStart, compdata + compstr->dwCompStrOffset, unicode);
1416         break;
1417     default:
1418         FIXME("Unhandled index 0x%x\n",dwIndex);
1419         break;
1420     }
1421
1422     ImmUnlockIMCC(data->IMC.hCompStr);
1423
1424     return rc;
1425 }
1426
1427 /***********************************************************************
1428  *              ImmGetCompositionStringA (IMM32.@)
1429  */
1430 LONG WINAPI ImmGetCompositionStringA(
1431   HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
1432 {
1433     return ImmGetCompositionStringT(hIMC, dwIndex, lpBuf, dwBufLen, FALSE);
1434 }
1435
1436
1437 /***********************************************************************
1438  *              ImmGetCompositionStringW (IMM32.@)
1439  */
1440 LONG WINAPI ImmGetCompositionStringW(
1441   HIMC hIMC, DWORD dwIndex,
1442   LPVOID lpBuf, DWORD dwBufLen)
1443 {
1444     return ImmGetCompositionStringT(hIMC, dwIndex, lpBuf, dwBufLen, TRUE);
1445 }
1446
1447 /***********************************************************************
1448  *              ImmGetCompositionWindow (IMM32.@)
1449  */
1450 BOOL WINAPI ImmGetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
1451 {
1452     InputContextData *data = get_imc_data(hIMC);
1453
1454     TRACE("(%p, %p)\n", hIMC, lpCompForm);
1455
1456     if (!data)
1457         return FALSE;
1458
1459     *lpCompForm = data->IMC.cfCompForm;
1460     return TRUE;
1461 }
1462
1463 /***********************************************************************
1464  *              ImmGetContext (IMM32.@)
1465  *
1466  */
1467 HIMC WINAPI ImmGetContext(HWND hWnd)
1468 {
1469     HIMC rc;
1470
1471     TRACE("%p\n", hWnd);
1472
1473     if (!IsWindow(hWnd))
1474     {
1475         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1476         return NULL;
1477     }
1478
1479     rc = GetPropW(hWnd,szwWineIMCProperty);
1480     if (rc == (HIMC)-1)
1481         rc = NULL;
1482     else if (rc == NULL)
1483         rc = get_default_context( hWnd );
1484
1485     if (rc)
1486     {
1487         InputContextData *data = rc;
1488         data->IMC.hWnd = hWnd;
1489     }
1490
1491     TRACE("returning %p\n", rc);
1492
1493     return rc;
1494 }
1495
1496 /***********************************************************************
1497  *              ImmGetConversionListA (IMM32.@)
1498  */
1499 DWORD WINAPI ImmGetConversionListA(
1500   HKL hKL, HIMC hIMC,
1501   LPCSTR pSrc, LPCANDIDATELIST lpDst,
1502   DWORD dwBufLen, UINT uFlag)
1503 {
1504     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1505     TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL, hIMC, debugstr_a(pSrc), lpDst,
1506                 dwBufLen, uFlag);
1507     if (immHkl->hIME && immHkl->pImeConversionList)
1508     {
1509         if (!is_kbd_ime_unicode(immHkl))
1510             return immHkl->pImeConversionList(hIMC,(LPCWSTR)pSrc,lpDst,dwBufLen,uFlag);
1511         else
1512         {
1513             LPCANDIDATELIST lpwDst;
1514             DWORD ret = 0, len;
1515             LPWSTR pwSrc = strdupAtoW(pSrc);
1516
1517             len = immHkl->pImeConversionList(hIMC, pwSrc, NULL, 0, uFlag);
1518             lpwDst = HeapAlloc(GetProcessHeap(), 0, len);
1519             if ( lpwDst )
1520             {
1521                 immHkl->pImeConversionList(hIMC, pwSrc, lpwDst, len, uFlag);
1522                 ret = convert_candidatelist_WtoA( lpwDst, lpDst, dwBufLen);
1523                 HeapFree(GetProcessHeap(), 0, lpwDst);
1524             }
1525             HeapFree(GetProcessHeap(), 0, pwSrc);
1526
1527             return ret;
1528         }
1529     }
1530     else
1531         return 0;
1532 }
1533
1534 /***********************************************************************
1535  *              ImmGetConversionListW (IMM32.@)
1536  */
1537 DWORD WINAPI ImmGetConversionListW(
1538   HKL hKL, HIMC hIMC,
1539   LPCWSTR pSrc, LPCANDIDATELIST lpDst,
1540   DWORD dwBufLen, UINT uFlag)
1541 {
1542     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1543     TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL, hIMC, debugstr_w(pSrc), lpDst,
1544                 dwBufLen, uFlag);
1545     if (immHkl->hIME && immHkl->pImeConversionList)
1546     {
1547         if (is_kbd_ime_unicode(immHkl))
1548             return immHkl->pImeConversionList(hIMC,pSrc,lpDst,dwBufLen,uFlag);
1549         else
1550         {
1551             LPCANDIDATELIST lpaDst;
1552             DWORD ret = 0, len;
1553             LPSTR paSrc = strdupWtoA(pSrc);
1554
1555             len = immHkl->pImeConversionList(hIMC, (LPCWSTR)paSrc, NULL, 0, uFlag);
1556             lpaDst = HeapAlloc(GetProcessHeap(), 0, len);
1557             if ( lpaDst )
1558             {
1559                 immHkl->pImeConversionList(hIMC, (LPCWSTR)paSrc, lpaDst, len, uFlag);
1560                 ret = convert_candidatelist_AtoW( lpaDst, lpDst, dwBufLen);
1561                 HeapFree(GetProcessHeap(), 0, lpaDst);
1562             }
1563             HeapFree(GetProcessHeap(), 0, paSrc);
1564
1565             return ret;
1566         }
1567     }
1568     else
1569         return 0;
1570 }
1571
1572 /***********************************************************************
1573  *              ImmGetConversionStatus (IMM32.@)
1574  */
1575 BOOL WINAPI ImmGetConversionStatus(
1576   HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)
1577 {
1578     InputContextData *data = get_imc_data(hIMC);
1579
1580     TRACE("%p %p %p\n", hIMC, lpfdwConversion, lpfdwSentence);
1581
1582     if (!data)
1583         return FALSE;
1584
1585     if (lpfdwConversion)
1586         *lpfdwConversion = data->IMC.fdwConversion;
1587     if (lpfdwSentence)
1588         *lpfdwSentence = data->IMC.fdwSentence;
1589
1590     return TRUE;
1591 }
1592
1593 /***********************************************************************
1594  *              ImmGetDefaultIMEWnd (IMM32.@)
1595  */
1596 HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
1597 {
1598     HWND ret, new = NULL;
1599     IMMThreadData* thread_data = IMM_GetThreadData(hWnd);
1600     if (!thread_data)
1601         return NULL;
1602     if (thread_data->hwndDefault == NULL && thread_data->threadID == GetCurrentThreadId())
1603     {
1604         /* Do not create the window inside of a critical section */
1605         LeaveCriticalSection(&threaddata_cs);
1606         new = CreateWindowExW( WS_EX_TOOLWINDOW,
1607                     szwIME, NULL, WS_POPUP, 0, 0, 1, 1, 0, 0, 0, 0);
1608         /* thread_data is in the current thread so we can assume it's still valid */
1609         EnterCriticalSection(&threaddata_cs);
1610         /* See if anyone beat us */
1611         if (thread_data->hwndDefault == NULL)
1612         {
1613             thread_data->hwndDefault = new;
1614             new = NULL;
1615         }
1616     }
1617     ret = thread_data->hwndDefault;
1618     LeaveCriticalSection(&threaddata_cs);
1619     TRACE("Default is %p\n",ret);
1620     /* Clean up an unused new window outside of the critical section */
1621     if (new != NULL)
1622     {
1623         DestroyWindow(new);
1624     }
1625     TRACE("Default is %p\n",ret);
1626     return ret;
1627 }
1628
1629 /***********************************************************************
1630  *              ImmGetDescriptionA (IMM32.@)
1631  */
1632 UINT WINAPI ImmGetDescriptionA(
1633   HKL hKL, LPSTR lpszDescription, UINT uBufLen)
1634 {
1635   WCHAR *buf;
1636   DWORD len;
1637
1638   TRACE("%p %p %d\n", hKL, lpszDescription, uBufLen);
1639
1640   /* find out how many characters in the unicode buffer */
1641   len = ImmGetDescriptionW( hKL, NULL, 0 );
1642   if (!len)
1643     return 0;
1644
1645   /* allocate a buffer of that size */
1646   buf = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof (WCHAR) );
1647   if( !buf )
1648   return 0;
1649
1650   /* fetch the unicode buffer */
1651   len = ImmGetDescriptionW( hKL, buf, len + 1 );
1652
1653   /* convert it back to ASCII */
1654   len = WideCharToMultiByte( CP_ACP, 0, buf, len + 1,
1655                              lpszDescription, uBufLen, NULL, NULL );
1656
1657   HeapFree( GetProcessHeap(), 0, buf );
1658
1659   if (len == 0)
1660     return 0;
1661
1662   return len - 1;
1663 }
1664
1665 /***********************************************************************
1666  *              ImmGetDescriptionW (IMM32.@)
1667  */
1668 UINT WINAPI ImmGetDescriptionW(HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
1669 {
1670   static const WCHAR name[] = { 'W','i','n','e',' ','X','I','M',0 };
1671
1672   FIXME("(%p, %p, %d): semi stub\n", hKL, lpszDescription, uBufLen);
1673
1674   if (!hKL) return 0;
1675   if (!uBufLen) return lstrlenW( name );
1676   lstrcpynW( lpszDescription, name, uBufLen );
1677   return lstrlenW( lpszDescription );
1678 }
1679
1680 /***********************************************************************
1681  *              ImmGetGuideLineA (IMM32.@)
1682  */
1683 DWORD WINAPI ImmGetGuideLineA(
1684   HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)
1685 {
1686   FIXME("(%p, %d, %s, %d): stub\n",
1687     hIMC, dwIndex, debugstr_a(lpBuf), dwBufLen
1688   );
1689   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1690   return 0;
1691 }
1692
1693 /***********************************************************************
1694  *              ImmGetGuideLineW (IMM32.@)
1695  */
1696 DWORD WINAPI ImmGetGuideLineW(HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)
1697 {
1698   FIXME("(%p, %d, %s, %d): stub\n",
1699     hIMC, dwIndex, debugstr_w(lpBuf), dwBufLen
1700   );
1701   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1702   return 0;
1703 }
1704
1705 /***********************************************************************
1706  *              ImmGetIMEFileNameA (IMM32.@)
1707  */
1708 UINT WINAPI ImmGetIMEFileNameA( HKL hKL, LPSTR lpszFileName, UINT uBufLen)
1709 {
1710     LPWSTR bufW = NULL;
1711     UINT wBufLen = uBufLen;
1712     UINT rc;
1713
1714     if (uBufLen && lpszFileName)
1715         bufW = HeapAlloc(GetProcessHeap(),0,uBufLen * sizeof(WCHAR));
1716     else /* We need this to get the number of byte required */
1717     {
1718         bufW = HeapAlloc(GetProcessHeap(),0,MAX_PATH * sizeof(WCHAR));
1719         wBufLen = MAX_PATH;
1720     }
1721
1722     rc = ImmGetIMEFileNameW(hKL,bufW,wBufLen);
1723
1724     if (rc > 0)
1725     {
1726         if (uBufLen && lpszFileName)
1727             rc = WideCharToMultiByte(CP_ACP, 0, bufW, -1, lpszFileName,
1728                                  uBufLen, NULL, NULL);
1729         else /* get the length */
1730             rc = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL,
1731                                      NULL);
1732     }
1733
1734     HeapFree(GetProcessHeap(),0,bufW);
1735     return rc;
1736 }
1737
1738 /***********************************************************************
1739  *              ImmGetIMEFileNameW (IMM32.@)
1740  */
1741 UINT WINAPI ImmGetIMEFileNameW(HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
1742 {
1743     HKEY hkey;
1744     DWORD length;
1745     DWORD rc;
1746     WCHAR regKey[sizeof(szImeRegFmt)/sizeof(WCHAR)+8];
1747
1748     wsprintfW( regKey, szImeRegFmt, (ULONG_PTR)hKL );
1749     rc = RegOpenKeyW( HKEY_LOCAL_MACHINE, regKey, &hkey);
1750     if (rc != ERROR_SUCCESS)
1751     {
1752         SetLastError(rc);
1753         return 0;
1754     }
1755
1756     length = 0;
1757     rc = RegGetValueW(hkey, NULL, szImeFileW, RRF_RT_REG_SZ, NULL, NULL, &length);
1758
1759     if (rc != ERROR_SUCCESS)
1760     {
1761         RegCloseKey(hkey);
1762         SetLastError(rc);
1763         return 0;
1764     }
1765     if (length > uBufLen * sizeof(WCHAR) || !lpszFileName)
1766     {
1767         RegCloseKey(hkey);
1768         if (lpszFileName)
1769         {
1770             SetLastError(ERROR_INSUFFICIENT_BUFFER);
1771             return 0;
1772         }
1773         else
1774             return length / sizeof(WCHAR);
1775     }
1776
1777     RegGetValueW(hkey, NULL, szImeFileW, RRF_RT_REG_SZ, NULL, lpszFileName, &length);
1778
1779     RegCloseKey(hkey);
1780
1781     return length / sizeof(WCHAR);
1782 }
1783
1784 /***********************************************************************
1785  *              ImmGetOpenStatus (IMM32.@)
1786  */
1787 BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
1788 {
1789   InputContextData *data = get_imc_data(hIMC);
1790   static int i;
1791
1792     if (!data)
1793         return FALSE;
1794
1795     TRACE("(%p): semi-stub\n", hIMC);
1796
1797     if (!i++)
1798       FIXME("(%p): semi-stub\n", hIMC);
1799
1800   return data->IMC.fOpen;
1801 }
1802
1803 /***********************************************************************
1804  *              ImmGetProperty (IMM32.@)
1805  */
1806 DWORD WINAPI ImmGetProperty(HKL hKL, DWORD fdwIndex)
1807 {
1808     DWORD rc = 0;
1809     ImmHkl *kbd;
1810
1811     TRACE("(%p, %d)\n", hKL, fdwIndex);
1812     kbd = IMM_GetImmHkl(hKL);
1813
1814     if (kbd && kbd->hIME)
1815     {
1816         switch (fdwIndex)
1817         {
1818             case IGP_PROPERTY: rc = kbd->imeInfo.fdwProperty; break;
1819             case IGP_CONVERSION: rc = kbd->imeInfo.fdwConversionCaps; break;
1820             case IGP_SENTENCE: rc = kbd->imeInfo.fdwSentenceCaps; break;
1821             case IGP_SETCOMPSTR: rc = kbd->imeInfo.fdwSCSCaps; break;
1822             case IGP_SELECT: rc = kbd->imeInfo.fdwSelectCaps; break;
1823             case IGP_GETIMEVERSION: rc = IMEVER_0400; break;
1824             case IGP_UI: rc = 0; break;
1825             default: rc = 0;
1826         }
1827     }
1828     return rc;
1829 }
1830
1831 /***********************************************************************
1832  *              ImmGetRegisterWordStyleA (IMM32.@)
1833  */
1834 UINT WINAPI ImmGetRegisterWordStyleA(
1835   HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
1836 {
1837     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1838     TRACE("(%p, %d, %p):\n", hKL, nItem, lpStyleBuf);
1839     if (immHkl->hIME && immHkl->pImeGetRegisterWordStyle)
1840     {
1841         if (!is_kbd_ime_unicode(immHkl))
1842             return immHkl->pImeGetRegisterWordStyle(nItem,(LPSTYLEBUFW)lpStyleBuf);
1843         else
1844         {
1845             STYLEBUFW sbw;
1846             UINT rc;
1847
1848             rc = immHkl->pImeGetRegisterWordStyle(nItem,&sbw);
1849             WideCharToMultiByte(CP_ACP, 0, sbw.szDescription, -1,
1850                 lpStyleBuf->szDescription, 32, NULL, NULL);
1851             lpStyleBuf->dwStyle = sbw.dwStyle;
1852             return rc;
1853         }
1854     }
1855     else
1856         return 0;
1857 }
1858
1859 /***********************************************************************
1860  *              ImmGetRegisterWordStyleW (IMM32.@)
1861  */
1862 UINT WINAPI ImmGetRegisterWordStyleW(
1863   HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
1864 {
1865     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1866     TRACE("(%p, %d, %p):\n", hKL, nItem, lpStyleBuf);
1867     if (immHkl->hIME && immHkl->pImeGetRegisterWordStyle)
1868     {
1869         if (is_kbd_ime_unicode(immHkl))
1870             return immHkl->pImeGetRegisterWordStyle(nItem,lpStyleBuf);
1871         else
1872         {
1873             STYLEBUFA sba;
1874             UINT rc;
1875
1876             rc = immHkl->pImeGetRegisterWordStyle(nItem,(LPSTYLEBUFW)&sba);
1877             MultiByteToWideChar(CP_ACP, 0, sba.szDescription, -1,
1878                 lpStyleBuf->szDescription, 32);
1879             lpStyleBuf->dwStyle = sba.dwStyle;
1880             return rc;
1881         }
1882     }
1883     else
1884         return 0;
1885 }
1886
1887 /***********************************************************************
1888  *              ImmGetStatusWindowPos (IMM32.@)
1889  */
1890 BOOL WINAPI ImmGetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1891 {
1892     InputContextData *data = get_imc_data(hIMC);
1893
1894     TRACE("(%p, %p)\n", hIMC, lpptPos);
1895
1896     if (!data || !lpptPos)
1897         return FALSE;
1898
1899     *lpptPos = data->IMC.ptStatusWndPos;
1900
1901     return TRUE;
1902 }
1903
1904 /***********************************************************************
1905  *              ImmGetVirtualKey (IMM32.@)
1906  */
1907 UINT WINAPI ImmGetVirtualKey(HWND hWnd)
1908 {
1909   OSVERSIONINFOA version;
1910   InputContextData *data = ImmGetContext( hWnd );
1911   TRACE("%p\n", hWnd);
1912
1913   if ( data )
1914       return data->lastVK;
1915
1916   version.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
1917   GetVersionExA( &version );
1918   switch(version.dwPlatformId)
1919   {
1920   case VER_PLATFORM_WIN32_WINDOWS:
1921       return VK_PROCESSKEY;
1922   case VER_PLATFORM_WIN32_NT:
1923       return 0;
1924   default:
1925       FIXME("%d not supported\n",version.dwPlatformId);
1926       return VK_PROCESSKEY;
1927   }
1928 }
1929
1930 /***********************************************************************
1931  *              ImmInstallIMEA (IMM32.@)
1932  */
1933 HKL WINAPI ImmInstallIMEA(
1934   LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
1935 {
1936     LPWSTR lpszwIMEFileName;
1937     LPWSTR lpszwLayoutText;
1938     HKL hkl;
1939
1940     TRACE ("(%s, %s)\n", debugstr_a(lpszIMEFileName),
1941                          debugstr_a(lpszLayoutText));
1942
1943     lpszwIMEFileName = strdupAtoW(lpszIMEFileName);
1944     lpszwLayoutText = strdupAtoW(lpszLayoutText);
1945
1946     hkl = ImmInstallIMEW(lpszwIMEFileName, lpszwLayoutText);
1947
1948     HeapFree(GetProcessHeap(),0,lpszwIMEFileName);
1949     HeapFree(GetProcessHeap(),0,lpszwLayoutText);
1950     return hkl;
1951 }
1952
1953 /***********************************************************************
1954  *              ImmInstallIMEW (IMM32.@)
1955  */
1956 HKL WINAPI ImmInstallIMEW(
1957   LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
1958 {
1959     INT lcid = GetUserDefaultLCID();
1960     INT count;
1961     HKL hkl;
1962     DWORD rc;
1963     HKEY hkey;
1964     WCHAR regKey[sizeof(szImeRegFmt)/sizeof(WCHAR)+8];
1965
1966     TRACE ("(%s, %s):\n", debugstr_w(lpszIMEFileName),
1967                           debugstr_w(lpszLayoutText));
1968
1969     /* Start with 2.  e001 will be blank and so default to the wine internal IME */
1970     count = 2;
1971
1972     while (count < 0xfff)
1973     {
1974         DWORD disposition = 0;
1975
1976         hkl = (HKL)MAKELPARAM( lcid, 0xe000 | count );
1977         wsprintfW( regKey, szImeRegFmt, (ULONG_PTR)hkl);
1978
1979         rc = RegCreateKeyExW(HKEY_LOCAL_MACHINE, regKey, 0, NULL, 0, KEY_WRITE, NULL, &hkey, &disposition);
1980         if (rc == ERROR_SUCCESS && disposition == REG_CREATED_NEW_KEY)
1981             break;
1982         else if (rc == ERROR_SUCCESS)
1983             RegCloseKey(hkey);
1984
1985         count++;
1986     }
1987
1988     if (count == 0xfff)
1989     {
1990         WARN("Unable to find slot to install IME\n");
1991         return 0;
1992     }
1993
1994     if (rc == ERROR_SUCCESS)
1995     {
1996         rc = RegSetValueExW(hkey, szImeFileW, 0, REG_SZ, (const BYTE*)lpszIMEFileName,
1997                             (lstrlenW(lpszIMEFileName) + 1) * sizeof(WCHAR));
1998         if (rc == ERROR_SUCCESS)
1999             rc = RegSetValueExW(hkey, szLayoutTextW, 0, REG_SZ, (const BYTE*)lpszLayoutText,
2000                                 (lstrlenW(lpszLayoutText) + 1) * sizeof(WCHAR));
2001         RegCloseKey(hkey);
2002         return hkl;
2003     }
2004     else
2005     {
2006         WARN("Unable to set IME registry values\n");
2007         return 0;
2008     }
2009 }
2010
2011 /***********************************************************************
2012  *              ImmIsIME (IMM32.@)
2013  */
2014 BOOL WINAPI ImmIsIME(HKL hKL)
2015 {
2016     ImmHkl *ptr;
2017     TRACE("(%p):\n", hKL);
2018     ptr = IMM_GetImmHkl(hKL);
2019     return (ptr && ptr->hIME);
2020 }
2021
2022 /***********************************************************************
2023  *              ImmIsUIMessageA (IMM32.@)
2024  */
2025 BOOL WINAPI ImmIsUIMessageA(
2026   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
2027 {
2028     TRACE("(%p, %x, %ld, %ld)\n", hWndIME, msg, wParam, lParam);
2029     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
2030             (msg == WM_IME_SETCONTEXT) ||
2031             (msg == WM_IME_NOTIFY) ||
2032             (msg == WM_IME_COMPOSITIONFULL) ||
2033             (msg == WM_IME_SELECT) ||
2034             (msg == 0x287 /* FIXME: WM_IME_SYSTEM */))
2035     {
2036         if (hWndIME)
2037             SendMessageA(hWndIME, msg, wParam, lParam);
2038
2039         return TRUE;
2040     }
2041     return FALSE;
2042 }
2043
2044 /***********************************************************************
2045  *              ImmIsUIMessageW (IMM32.@)
2046  */
2047 BOOL WINAPI ImmIsUIMessageW(
2048   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
2049 {
2050     TRACE("(%p, %x, %ld, %ld)\n", hWndIME, msg, wParam, lParam);
2051     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
2052             (msg == WM_IME_SETCONTEXT) ||
2053             (msg == WM_IME_NOTIFY) ||
2054             (msg == WM_IME_COMPOSITIONFULL) ||
2055             (msg == WM_IME_SELECT) ||
2056             (msg == 0x287 /* FIXME: WM_IME_SYSTEM */))
2057     {
2058         if (hWndIME)
2059             SendMessageW(hWndIME, msg, wParam, lParam);
2060
2061         return TRUE;
2062     }
2063     return FALSE;
2064 }
2065
2066 /***********************************************************************
2067  *              ImmNotifyIME (IMM32.@)
2068  */
2069 BOOL WINAPI ImmNotifyIME(
2070   HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
2071 {
2072     InputContextData *data = get_imc_data(hIMC);
2073
2074     TRACE("(%p, %d, %d, %d)\n",
2075         hIMC, dwAction, dwIndex, dwValue);
2076
2077     if (hIMC == NULL)
2078     {
2079         SetLastError(ERROR_SUCCESS);
2080         return FALSE;
2081     }
2082
2083     if (!data || ! data->immKbd->pNotifyIME)
2084     {
2085         return FALSE;
2086     }
2087
2088     return data->immKbd->pNotifyIME(hIMC,dwAction,dwIndex,dwValue);
2089 }
2090
2091 /***********************************************************************
2092  *              ImmRegisterWordA (IMM32.@)
2093  */
2094 BOOL WINAPI ImmRegisterWordA(
2095   HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
2096 {
2097     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
2098     TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_a(lpszReading), dwStyle,
2099                     debugstr_a(lpszRegister));
2100     if (immHkl->hIME && immHkl->pImeRegisterWord)
2101     {
2102         if (!is_kbd_ime_unicode(immHkl))
2103             return immHkl->pImeRegisterWord((LPCWSTR)lpszReading,dwStyle,
2104                                             (LPCWSTR)lpszRegister);
2105         else
2106         {
2107             LPWSTR lpszwReading = strdupAtoW(lpszReading);
2108             LPWSTR lpszwRegister = strdupAtoW(lpszRegister);
2109             BOOL rc;
2110
2111             rc = immHkl->pImeRegisterWord(lpszwReading,dwStyle,lpszwRegister);
2112             HeapFree(GetProcessHeap(),0,lpszwReading);
2113             HeapFree(GetProcessHeap(),0,lpszwRegister);
2114             return rc;
2115         }
2116     }
2117     else
2118         return FALSE;
2119 }
2120
2121 /***********************************************************************
2122  *              ImmRegisterWordW (IMM32.@)
2123  */
2124 BOOL WINAPI ImmRegisterWordW(
2125   HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
2126 {
2127     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
2128     TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_w(lpszReading), dwStyle,
2129                     debugstr_w(lpszRegister));
2130     if (immHkl->hIME && immHkl->pImeRegisterWord)
2131     {
2132         if (is_kbd_ime_unicode(immHkl))
2133             return immHkl->pImeRegisterWord(lpszReading,dwStyle,lpszRegister);
2134         else
2135         {
2136             LPSTR lpszaReading = strdupWtoA(lpszReading);
2137             LPSTR lpszaRegister = strdupWtoA(lpszRegister);
2138             BOOL rc;
2139
2140             rc = immHkl->pImeRegisterWord((LPCWSTR)lpszaReading,dwStyle,
2141                                           (LPCWSTR)lpszaRegister);
2142             HeapFree(GetProcessHeap(),0,lpszaReading);
2143             HeapFree(GetProcessHeap(),0,lpszaRegister);
2144             return rc;
2145         }
2146     }
2147     else
2148         return FALSE;
2149 }
2150
2151 /***********************************************************************
2152  *              ImmReleaseContext (IMM32.@)
2153  */
2154 BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
2155 {
2156   static BOOL shown = FALSE;
2157
2158   if (!shown) {
2159      FIXME("(%p, %p): stub\n", hWnd, hIMC);
2160      shown = TRUE;
2161   }
2162   return TRUE;
2163 }
2164
2165 /***********************************************************************
2166 *              ImmRequestMessageA(IMM32.@)
2167 */
2168 LRESULT WINAPI ImmRequestMessageA(HIMC hIMC, WPARAM wParam, LPARAM lParam)
2169 {
2170     InputContextData *data = get_imc_data(hIMC);
2171
2172     TRACE("%p %ld %ld\n", hIMC, wParam, wParam);
2173
2174     if (data) return SendMessageA(data->IMC.hWnd, WM_IME_REQUEST, wParam, lParam);
2175
2176     SetLastError(ERROR_INVALID_HANDLE);
2177     return 0;
2178 }
2179
2180 /***********************************************************************
2181 *              ImmRequestMessageW(IMM32.@)
2182 */
2183 LRESULT WINAPI ImmRequestMessageW(HIMC hIMC, WPARAM wParam, LPARAM lParam)
2184 {
2185     InputContextData *data = get_imc_data(hIMC);
2186
2187     TRACE("%p %ld %ld\n", hIMC, wParam, wParam);
2188
2189     if (data) return SendMessageW(data->IMC.hWnd, WM_IME_REQUEST, wParam, lParam);
2190
2191     SetLastError(ERROR_INVALID_HANDLE);
2192     return 0;
2193 }
2194
2195 /***********************************************************************
2196  *              ImmSetCandidateWindow (IMM32.@)
2197  */
2198 BOOL WINAPI ImmSetCandidateWindow(
2199   HIMC hIMC, LPCANDIDATEFORM lpCandidate)
2200 {
2201     InputContextData *data = get_imc_data(hIMC);
2202
2203     TRACE("(%p, %p)\n", hIMC, lpCandidate);
2204
2205     if (!data || !lpCandidate)
2206         return FALSE;
2207
2208     if (IMM_IsCrossThreadAccess(NULL, hIMC))
2209         return FALSE;
2210
2211     TRACE("\t%x, %x, (%i,%i), (%i,%i - %i,%i)\n",
2212             lpCandidate->dwIndex, lpCandidate->dwStyle,
2213             lpCandidate->ptCurrentPos.x, lpCandidate->ptCurrentPos.y,
2214             lpCandidate->rcArea.top, lpCandidate->rcArea.left,
2215             lpCandidate->rcArea.bottom, lpCandidate->rcArea.right);
2216
2217     if ( lpCandidate->dwIndex >= (sizeof(data->IMC.cfCandForm) / sizeof(CANDIDATEFORM)) )
2218         return FALSE;
2219
2220     data->IMC.cfCandForm[lpCandidate->dwIndex] = *lpCandidate;
2221     ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, 0, IMC_SETCANDIDATEPOS);
2222     ImmInternalSendIMENotify(data, IMN_SETCANDIDATEPOS, 1 << lpCandidate->dwIndex);
2223
2224     return TRUE;
2225 }
2226
2227 /***********************************************************************
2228  *              ImmSetCompositionFontA (IMM32.@)
2229  */
2230 BOOL WINAPI ImmSetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
2231 {
2232     InputContextData *data = get_imc_data(hIMC);
2233     TRACE("(%p, %p)\n", hIMC, lplf);
2234
2235     if (!data || !lplf)
2236     {
2237         SetLastError(ERROR_INVALID_HANDLE);
2238         return FALSE;
2239     }
2240
2241     if (IMM_IsCrossThreadAccess(NULL, hIMC))
2242         return FALSE;
2243
2244     memcpy(&data->IMC.lfFont.W,lplf,sizeof(LOGFONTA));
2245     MultiByteToWideChar(CP_ACP, 0, lplf->lfFaceName, -1, data->IMC.lfFont.W.lfFaceName,
2246                         LF_FACESIZE);
2247     ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, 0, IMC_SETCOMPOSITIONFONT);
2248     ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONFONT, 0);
2249
2250     return TRUE;
2251 }
2252
2253 /***********************************************************************
2254  *              ImmSetCompositionFontW (IMM32.@)
2255  */
2256 BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
2257 {
2258     InputContextData *data = get_imc_data(hIMC);
2259     TRACE("(%p, %p)\n", hIMC, lplf);
2260
2261     if (!data || !lplf)
2262     {
2263         SetLastError(ERROR_INVALID_HANDLE);
2264         return FALSE;
2265     }
2266
2267     if (IMM_IsCrossThreadAccess(NULL, hIMC))
2268         return FALSE;
2269
2270     data->IMC.lfFont.W = *lplf;
2271     ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, 0, IMC_SETCOMPOSITIONFONT);
2272     ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONFONT, 0);
2273
2274     return TRUE;
2275 }
2276
2277 /***********************************************************************
2278  *              ImmSetCompositionStringA (IMM32.@)
2279  */
2280 BOOL WINAPI ImmSetCompositionStringA(
2281   HIMC hIMC, DWORD dwIndex,
2282   LPCVOID lpComp, DWORD dwCompLen,
2283   LPCVOID lpRead, DWORD dwReadLen)
2284 {
2285     DWORD comp_len;
2286     DWORD read_len;
2287     WCHAR *CompBuffer = NULL;
2288     WCHAR *ReadBuffer = NULL;
2289     BOOL rc;
2290     InputContextData *data = get_imc_data(hIMC);
2291
2292     TRACE("(%p, %d, %p, %d, %p, %d):\n",
2293             hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
2294
2295     if (!data)
2296         return FALSE;
2297
2298     if (!(dwIndex == SCS_SETSTR ||
2299           dwIndex == SCS_CHANGEATTR ||
2300           dwIndex == SCS_CHANGECLAUSE ||
2301           dwIndex == SCS_SETRECONVERTSTRING ||
2302           dwIndex == SCS_QUERYRECONVERTSTRING))
2303         return FALSE;
2304
2305     if (!is_himc_ime_unicode(data))
2306         return data->immKbd->pImeSetCompositionString(hIMC, dwIndex, lpComp,
2307                         dwCompLen, lpRead, dwReadLen);
2308
2309     comp_len = MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, NULL, 0);
2310     if (comp_len)
2311     {
2312         CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len * sizeof(WCHAR));
2313         MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len);
2314     }
2315
2316     read_len = MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, NULL, 0);
2317     if (read_len)
2318     {
2319         ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len * sizeof(WCHAR));
2320         MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len);
2321     }
2322
2323     rc =  ImmSetCompositionStringW(hIMC, dwIndex, CompBuffer, comp_len,
2324                                    ReadBuffer, read_len);
2325
2326     HeapFree(GetProcessHeap(), 0, CompBuffer);
2327     HeapFree(GetProcessHeap(), 0, ReadBuffer);
2328
2329     return rc;
2330 }
2331
2332 /***********************************************************************
2333  *              ImmSetCompositionStringW (IMM32.@)
2334  */
2335 BOOL WINAPI ImmSetCompositionStringW(
2336         HIMC hIMC, DWORD dwIndex,
2337         LPCVOID lpComp, DWORD dwCompLen,
2338         LPCVOID lpRead, DWORD dwReadLen)
2339 {
2340     DWORD comp_len;
2341     DWORD read_len;
2342     CHAR *CompBuffer = NULL;
2343     CHAR *ReadBuffer = NULL;
2344     BOOL rc;
2345     InputContextData *data = get_imc_data(hIMC);
2346
2347     TRACE("(%p, %d, %p, %d, %p, %d):\n",
2348             hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
2349
2350     if (!data)
2351         return FALSE;
2352
2353     if (!(dwIndex == SCS_SETSTR ||
2354           dwIndex == SCS_CHANGEATTR ||
2355           dwIndex == SCS_CHANGECLAUSE ||
2356           dwIndex == SCS_SETRECONVERTSTRING ||
2357           dwIndex == SCS_QUERYRECONVERTSTRING))
2358         return FALSE;
2359
2360     if (is_himc_ime_unicode(data))
2361         return data->immKbd->pImeSetCompositionString(hIMC, dwIndex, lpComp,
2362                         dwCompLen, lpRead, dwReadLen);
2363
2364     comp_len = WideCharToMultiByte(CP_ACP, 0, lpComp, dwCompLen, NULL, 0, NULL,
2365                                    NULL);
2366     if (comp_len)
2367     {
2368         CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len);
2369         WideCharToMultiByte(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len,
2370                             NULL, NULL);
2371     }
2372
2373     read_len = WideCharToMultiByte(CP_ACP, 0, lpRead, dwReadLen, NULL, 0, NULL,
2374                                    NULL);
2375     if (read_len)
2376     {
2377         ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len);
2378         WideCharToMultiByte(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len,
2379                             NULL, NULL);
2380     }
2381
2382     rc =  ImmSetCompositionStringA(hIMC, dwIndex, CompBuffer, comp_len,
2383                                    ReadBuffer, read_len);
2384
2385     HeapFree(GetProcessHeap(), 0, CompBuffer);
2386     HeapFree(GetProcessHeap(), 0, ReadBuffer);
2387
2388     return rc;
2389 }
2390
2391 /***********************************************************************
2392  *              ImmSetCompositionWindow (IMM32.@)
2393  */
2394 BOOL WINAPI ImmSetCompositionWindow(
2395   HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
2396 {
2397     BOOL reshow = FALSE;
2398     InputContextData *data = get_imc_data(hIMC);
2399
2400     TRACE("(%p, %p)\n", hIMC, lpCompForm);
2401     TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm->dwStyle,
2402           lpCompForm->ptCurrentPos.x, lpCompForm->ptCurrentPos.y, lpCompForm->rcArea.top,
2403           lpCompForm->rcArea.left, lpCompForm->rcArea.bottom, lpCompForm->rcArea.right);
2404
2405     if (!data)
2406     {
2407         SetLastError(ERROR_INVALID_HANDLE);
2408         return FALSE;
2409     }
2410
2411     if (IMM_IsCrossThreadAccess(NULL, hIMC))
2412         return FALSE;
2413
2414     data->IMC.cfCompForm = *lpCompForm;
2415
2416     if (IsWindowVisible(data->immKbd->UIWnd))
2417     {
2418         reshow = TRUE;
2419         ShowWindow(data->immKbd->UIWnd,SW_HIDE);
2420     }
2421
2422     /* FIXME: this is a partial stub */
2423
2424     if (reshow)
2425         ShowWindow(data->immKbd->UIWnd,SW_SHOWNOACTIVATE);
2426
2427     ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONWINDOW, 0);
2428     return TRUE;
2429 }
2430
2431 /***********************************************************************
2432  *              ImmSetConversionStatus (IMM32.@)
2433  */
2434 BOOL WINAPI ImmSetConversionStatus(
2435   HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
2436 {
2437     DWORD oldConversion, oldSentence;
2438     InputContextData *data = get_imc_data(hIMC);
2439
2440     TRACE("%p %d %d\n", hIMC, fdwConversion, fdwSentence);
2441
2442     if (!data)
2443     {
2444         SetLastError(ERROR_INVALID_HANDLE);
2445         return FALSE;
2446     }
2447
2448     if (IMM_IsCrossThreadAccess(NULL, hIMC))
2449         return FALSE;
2450
2451     if ( fdwConversion != data->IMC.fdwConversion )
2452     {
2453         oldConversion = data->IMC.fdwConversion;
2454         data->IMC.fdwConversion = fdwConversion;
2455         ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, oldConversion, IMC_SETCONVERSIONMODE);
2456         ImmInternalSendIMENotify(data, IMN_SETCONVERSIONMODE, 0);
2457     }
2458     if ( fdwSentence != data->IMC.fdwSentence )
2459     {
2460         oldSentence = data->IMC.fdwSentence;
2461         data->IMC.fdwSentence = fdwSentence;
2462         ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, oldSentence, IMC_SETSENTENCEMODE);
2463         ImmInternalSendIMENotify(data, IMN_SETSENTENCEMODE, 0);
2464     }
2465
2466     return TRUE;
2467 }
2468
2469 /***********************************************************************
2470  *              ImmSetOpenStatus (IMM32.@)
2471  */
2472 BOOL WINAPI ImmSetOpenStatus(HIMC hIMC, BOOL fOpen)
2473 {
2474     InputContextData *data = get_imc_data(hIMC);
2475
2476     TRACE("%p %d\n", hIMC, fOpen);
2477
2478     if (!data)
2479     {
2480         SetLastError(ERROR_INVALID_HANDLE);
2481         return FALSE;
2482     }
2483
2484     if (IMM_IsCrossThreadAccess(NULL, hIMC))
2485         return FALSE;
2486
2487     if (data->immKbd->UIWnd == NULL)
2488     {
2489         /* create the ime window */
2490         data->immKbd->UIWnd = CreateWindowExW( WS_EX_TOOLWINDOW,
2491                     data->immKbd->imeClassName, NULL, WS_POPUP, 0, 0, 1, 1, 0,
2492                     0, data->immKbd->hIME, 0);
2493         SetWindowLongPtrW(data->immKbd->UIWnd, IMMGWL_IMC, (LONG_PTR)data);
2494     }
2495     else if (fOpen)
2496         SetWindowLongPtrW(data->immKbd->UIWnd, IMMGWL_IMC, (LONG_PTR)data);
2497
2498     if (!fOpen != !data->IMC.fOpen)
2499     {
2500         data->IMC.fOpen = fOpen;
2501         ImmNotifyIME( hIMC, NI_CONTEXTUPDATED, 0, IMC_SETOPENSTATUS);
2502         ImmInternalSendIMENotify(data, IMN_SETOPENSTATUS, 0);
2503     }
2504
2505     return TRUE;
2506 }
2507
2508 /***********************************************************************
2509  *              ImmSetStatusWindowPos (IMM32.@)
2510  */
2511 BOOL WINAPI ImmSetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
2512 {
2513     InputContextData *data = get_imc_data(hIMC);
2514
2515     TRACE("(%p, %p)\n", hIMC, lpptPos);
2516
2517     if (!data || !lpptPos)
2518     {
2519         SetLastError(ERROR_INVALID_HANDLE);
2520         return FALSE;
2521     }
2522
2523     if (IMM_IsCrossThreadAccess(NULL, hIMC))
2524         return FALSE;
2525
2526     TRACE("\t(%i,%i)\n", lpptPos->x, lpptPos->y);
2527
2528     data->IMC.ptStatusWndPos = *lpptPos;
2529     ImmNotifyIME( hIMC, NI_CONTEXTUPDATED, 0, IMC_SETSTATUSWINDOWPOS);
2530     ImmInternalSendIMENotify(data, IMN_SETSTATUSWINDOWPOS, 0);
2531
2532     return TRUE;
2533 }
2534
2535 /***********************************************************************
2536  *              ImmCreateSoftKeyboard(IMM32.@)
2537  */
2538 HWND WINAPI ImmCreateSoftKeyboard(UINT uType, UINT hOwner, int x, int y)
2539 {
2540     FIXME("(%d, %d, %d, %d): stub\n", uType, hOwner, x, y);
2541     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2542     return 0;
2543 }
2544
2545 /***********************************************************************
2546  *              ImmDestroySoftKeyboard(IMM32.@)
2547  */
2548 BOOL WINAPI ImmDestroySoftKeyboard(HWND hSoftWnd)
2549 {
2550     FIXME("(%p): stub\n", hSoftWnd);
2551     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2552     return FALSE;
2553 }
2554
2555 /***********************************************************************
2556  *              ImmShowSoftKeyboard(IMM32.@)
2557  */
2558 BOOL WINAPI ImmShowSoftKeyboard(HWND hSoftWnd, int nCmdShow)
2559 {
2560     FIXME("(%p, %d): stub\n", hSoftWnd, nCmdShow);
2561     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2562     return FALSE;
2563 }
2564
2565 /***********************************************************************
2566  *              ImmSimulateHotKey (IMM32.@)
2567  */
2568 BOOL WINAPI ImmSimulateHotKey(HWND hWnd, DWORD dwHotKeyID)
2569 {
2570   FIXME("(%p, %d): stub\n", hWnd, dwHotKeyID);
2571   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2572   return FALSE;
2573 }
2574
2575 /***********************************************************************
2576  *              ImmUnregisterWordA (IMM32.@)
2577  */
2578 BOOL WINAPI ImmUnregisterWordA(
2579   HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
2580 {
2581     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
2582     TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_a(lpszReading), dwStyle,
2583             debugstr_a(lpszUnregister));
2584     if (immHkl->hIME && immHkl->pImeUnregisterWord)
2585     {
2586         if (!is_kbd_ime_unicode(immHkl))
2587             return immHkl->pImeUnregisterWord((LPCWSTR)lpszReading,dwStyle,
2588                                               (LPCWSTR)lpszUnregister);
2589         else
2590         {
2591             LPWSTR lpszwReading = strdupAtoW(lpszReading);
2592             LPWSTR lpszwUnregister = strdupAtoW(lpszUnregister);
2593             BOOL rc;
2594
2595             rc = immHkl->pImeUnregisterWord(lpszwReading,dwStyle,lpszwUnregister);
2596             HeapFree(GetProcessHeap(),0,lpszwReading);
2597             HeapFree(GetProcessHeap(),0,lpszwUnregister);
2598             return rc;
2599         }
2600     }
2601     else
2602         return FALSE;
2603 }
2604
2605 /***********************************************************************
2606  *              ImmUnregisterWordW (IMM32.@)
2607  */
2608 BOOL WINAPI ImmUnregisterWordW(
2609   HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
2610 {
2611     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
2612     TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_w(lpszReading), dwStyle,
2613             debugstr_w(lpszUnregister));
2614     if (immHkl->hIME && immHkl->pImeUnregisterWord)
2615     {
2616         if (is_kbd_ime_unicode(immHkl))
2617             return immHkl->pImeUnregisterWord(lpszReading,dwStyle,lpszUnregister);
2618         else
2619         {
2620             LPSTR lpszaReading = strdupWtoA(lpszReading);
2621             LPSTR lpszaUnregister = strdupWtoA(lpszUnregister);
2622             BOOL rc;
2623
2624             rc = immHkl->pImeUnregisterWord((LPCWSTR)lpszaReading,dwStyle,
2625                                             (LPCWSTR)lpszaUnregister);
2626             HeapFree(GetProcessHeap(),0,lpszaReading);
2627             HeapFree(GetProcessHeap(),0,lpszaUnregister);
2628             return rc;
2629         }
2630     }
2631     else
2632         return FALSE;
2633 }
2634
2635 /***********************************************************************
2636  *              ImmGetImeMenuItemsA (IMM32.@)
2637  */
2638 DWORD WINAPI ImmGetImeMenuItemsA( HIMC hIMC, DWORD dwFlags, DWORD dwType,
2639    LPIMEMENUITEMINFOA lpImeParentMenu, LPIMEMENUITEMINFOA lpImeMenu,
2640     DWORD dwSize)
2641 {
2642     InputContextData *data = get_imc_data(hIMC);
2643     TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC, dwFlags, dwType,
2644         lpImeParentMenu, lpImeMenu, dwSize);
2645
2646     if (!data)
2647     {
2648         SetLastError(ERROR_INVALID_HANDLE);
2649         return 0;
2650     }
2651
2652     if (data->immKbd->hIME && data->immKbd->pImeGetImeMenuItems)
2653     {
2654         if (!is_himc_ime_unicode(data) || (!lpImeParentMenu && !lpImeMenu))
2655             return data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2656                                 (IMEMENUITEMINFOW*)lpImeParentMenu,
2657                                 (IMEMENUITEMINFOW*)lpImeMenu, dwSize);
2658         else
2659         {
2660             IMEMENUITEMINFOW lpImeParentMenuW;
2661             IMEMENUITEMINFOW *lpImeMenuW, *parent = NULL;
2662             DWORD rc;
2663
2664             if (lpImeParentMenu)
2665                 parent = &lpImeParentMenuW;
2666             if (lpImeMenu)
2667             {
2668                 int count = dwSize / sizeof(LPIMEMENUITEMINFOA);
2669                 dwSize = count * sizeof(IMEMENUITEMINFOW);
2670                 lpImeMenuW = HeapAlloc(GetProcessHeap(), 0, dwSize);
2671             }
2672             else
2673                 lpImeMenuW = NULL;
2674
2675             rc = data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2676                                 parent, lpImeMenuW, dwSize);
2677
2678             if (lpImeParentMenu)
2679             {
2680                 memcpy(lpImeParentMenu,&lpImeParentMenuW,sizeof(IMEMENUITEMINFOA));
2681                 lpImeParentMenu->hbmpItem = lpImeParentMenuW.hbmpItem;
2682                 WideCharToMultiByte(CP_ACP, 0, lpImeParentMenuW.szString,
2683                     -1, lpImeParentMenu->szString, IMEMENUITEM_STRING_SIZE,
2684                     NULL, NULL);
2685             }
2686             if (lpImeMenu && rc)
2687             {
2688                 unsigned int i;
2689                 for (i = 0; i < rc; i++)
2690                 {
2691                     memcpy(&lpImeMenu[i],&lpImeMenuW[1],sizeof(IMEMENUITEMINFOA));
2692                     lpImeMenu[i].hbmpItem = lpImeMenuW[i].hbmpItem;
2693                     WideCharToMultiByte(CP_ACP, 0, lpImeMenuW[i].szString,
2694                         -1, lpImeMenu[i].szString, IMEMENUITEM_STRING_SIZE,
2695                         NULL, NULL);
2696                 }
2697             }
2698             HeapFree(GetProcessHeap(),0,lpImeMenuW);
2699             return rc;
2700         }
2701     }
2702     else
2703         return 0;
2704 }
2705
2706 /***********************************************************************
2707 *               ImmGetImeMenuItemsW (IMM32.@)
2708 */
2709 DWORD WINAPI ImmGetImeMenuItemsW( HIMC hIMC, DWORD dwFlags, DWORD dwType,
2710    LPIMEMENUITEMINFOW lpImeParentMenu, LPIMEMENUITEMINFOW lpImeMenu,
2711    DWORD dwSize)
2712 {
2713     InputContextData *data = get_imc_data(hIMC);
2714     TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC, dwFlags, dwType,
2715         lpImeParentMenu, lpImeMenu, dwSize);
2716
2717     if (!data)
2718     {
2719         SetLastError(ERROR_INVALID_HANDLE);
2720         return 0;
2721     }
2722
2723     if (data->immKbd->hIME && data->immKbd->pImeGetImeMenuItems)
2724     {
2725         if (is_himc_ime_unicode(data) || (!lpImeParentMenu && !lpImeMenu))
2726             return data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2727                                 lpImeParentMenu, lpImeMenu, dwSize);
2728         else
2729         {
2730             IMEMENUITEMINFOA lpImeParentMenuA;
2731             IMEMENUITEMINFOA *lpImeMenuA, *parent = NULL;
2732             DWORD rc;
2733
2734             if (lpImeParentMenu)
2735                 parent = &lpImeParentMenuA;
2736             if (lpImeMenu)
2737             {
2738                 int count = dwSize / sizeof(LPIMEMENUITEMINFOW);
2739                 dwSize = count * sizeof(IMEMENUITEMINFOA);
2740                 lpImeMenuA = HeapAlloc(GetProcessHeap(), 0, dwSize);
2741             }
2742             else
2743                 lpImeMenuA = NULL;
2744
2745             rc = data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2746                                 (IMEMENUITEMINFOW*)parent,
2747                                 (IMEMENUITEMINFOW*)lpImeMenuA, dwSize);
2748
2749             if (lpImeParentMenu)
2750             {
2751                 memcpy(lpImeParentMenu,&lpImeParentMenuA,sizeof(IMEMENUITEMINFOA));
2752                 lpImeParentMenu->hbmpItem = lpImeParentMenuA.hbmpItem;
2753                 MultiByteToWideChar(CP_ACP, 0, lpImeParentMenuA.szString,
2754                     -1, lpImeParentMenu->szString, IMEMENUITEM_STRING_SIZE);
2755             }
2756             if (lpImeMenu && rc)
2757             {
2758                 unsigned int i;
2759                 for (i = 0; i < rc; i++)
2760                 {
2761                     memcpy(&lpImeMenu[i],&lpImeMenuA[1],sizeof(IMEMENUITEMINFOA));
2762                     lpImeMenu[i].hbmpItem = lpImeMenuA[i].hbmpItem;
2763                     MultiByteToWideChar(CP_ACP, 0, lpImeMenuA[i].szString,
2764                         -1, lpImeMenu[i].szString, IMEMENUITEM_STRING_SIZE);
2765                 }
2766             }
2767             HeapFree(GetProcessHeap(),0,lpImeMenuA);
2768             return rc;
2769         }
2770     }
2771     else
2772         return 0;
2773 }
2774
2775 /***********************************************************************
2776 *               ImmLockIMC(IMM32.@)
2777 */
2778 LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
2779 {
2780     InputContextData *data = get_imc_data(hIMC);
2781
2782     if (!data)
2783         return NULL;
2784     data->dwLock++;
2785     return &data->IMC;
2786 }
2787
2788 /***********************************************************************
2789 *               ImmUnlockIMC(IMM32.@)
2790 */
2791 BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
2792 {
2793     InputContextData *data = get_imc_data(hIMC);
2794
2795     if (!data)
2796         return FALSE;
2797     if (data->dwLock)
2798         data->dwLock--;
2799     return TRUE;
2800 }
2801
2802 /***********************************************************************
2803 *               ImmGetIMCLockCount(IMM32.@)
2804 */
2805 DWORD WINAPI ImmGetIMCLockCount(HIMC hIMC)
2806 {
2807     InputContextData *data = get_imc_data(hIMC);
2808     if (!data)
2809         return 0;
2810     return data->dwLock;
2811 }
2812
2813 /***********************************************************************
2814 *               ImmCreateIMCC(IMM32.@)
2815 */
2816 HIMCC  WINAPI ImmCreateIMCC(DWORD size)
2817 {
2818     return GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE, size);
2819 }
2820
2821 /***********************************************************************
2822 *       ImmDestroyIMCC(IMM32.@)
2823 */
2824 HIMCC WINAPI ImmDestroyIMCC(HIMCC block)
2825 {
2826     return GlobalFree(block);
2827 }
2828
2829 /***********************************************************************
2830 *               ImmLockIMCC(IMM32.@)
2831 */
2832 LPVOID WINAPI ImmLockIMCC(HIMCC imcc)
2833 {
2834     return GlobalLock(imcc);
2835 }
2836
2837 /***********************************************************************
2838 *               ImmUnlockIMCC(IMM32.@)
2839 */
2840 BOOL WINAPI ImmUnlockIMCC(HIMCC imcc)
2841 {
2842     return GlobalUnlock(imcc);
2843 }
2844
2845 /***********************************************************************
2846 *               ImmGetIMCCLockCount(IMM32.@)
2847 */
2848 DWORD WINAPI ImmGetIMCCLockCount(HIMCC imcc)
2849 {
2850     return GlobalFlags(imcc) & GMEM_LOCKCOUNT;
2851 }
2852
2853 /***********************************************************************
2854 *               ImmReSizeIMCC(IMM32.@)
2855 */
2856 HIMCC  WINAPI ImmReSizeIMCC(HIMCC imcc, DWORD size)
2857 {
2858     return GlobalReAlloc(imcc, size, GMEM_ZEROINIT | GMEM_MOVEABLE);
2859 }
2860
2861 /***********************************************************************
2862 *               ImmGetIMCCSize(IMM32.@)
2863 */
2864 DWORD WINAPI ImmGetIMCCSize(HIMCC imcc)
2865 {
2866     return GlobalSize(imcc);
2867 }
2868
2869 /***********************************************************************
2870 *               ImmGenerateMessage(IMM32.@)
2871 */
2872 BOOL WINAPI ImmGenerateMessage(HIMC hIMC)
2873 {
2874     InputContextData *data = get_imc_data(hIMC);
2875
2876     if (!data)
2877     {
2878         SetLastError(ERROR_INVALID_HANDLE);
2879         return FALSE;
2880     }
2881
2882     TRACE("%i messages queued\n",data->IMC.dwNumMsgBuf);
2883     if (data->IMC.dwNumMsgBuf > 0)
2884     {
2885         LPTRANSMSG lpTransMsg;
2886         DWORD i;
2887
2888         lpTransMsg = ImmLockIMCC(data->IMC.hMsgBuf);
2889         for (i = 0; i < data->IMC.dwNumMsgBuf; i++)
2890             ImmInternalPostIMEMessage(data, lpTransMsg[i].message, lpTransMsg[i].wParam, lpTransMsg[i].lParam);
2891
2892         ImmUnlockIMCC(data->IMC.hMsgBuf);
2893
2894         data->IMC.dwNumMsgBuf = 0;
2895     }
2896
2897     return TRUE;
2898 }
2899
2900 /***********************************************************************
2901 *       ImmTranslateMessage(IMM32.@)
2902 *       ( Undocumented, call internally and from user32.dll )
2903 */
2904 BOOL WINAPI ImmTranslateMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lKeyData)
2905 {
2906     InputContextData *data;
2907     HIMC imc = ImmGetContext(hwnd);
2908     BYTE state[256];
2909     UINT scancode;
2910     LPVOID list = 0;
2911     UINT msg_count;
2912     UINT uVirtKey;
2913     static const DWORD list_count = 10;
2914
2915     TRACE("%p %x %x %x\n",hwnd, msg, (UINT)wParam, (UINT)lKeyData);
2916
2917     if (imc)
2918         data = imc;
2919     else
2920         return FALSE;
2921
2922     if (!data->immKbd->hIME || !data->immKbd->pImeToAsciiEx)
2923         return FALSE;
2924
2925     GetKeyboardState(state);
2926     scancode = lKeyData >> 0x10 & 0xff;
2927
2928     list = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, list_count * sizeof(TRANSMSG) + sizeof(DWORD));
2929     ((DWORD*)list)[0] = list_count;
2930
2931     if (data->immKbd->imeInfo.fdwProperty & IME_PROP_KBD_CHAR_FIRST)
2932     {
2933         WCHAR chr;
2934
2935         if (!is_himc_ime_unicode(data))
2936             ToAscii(data->lastVK, scancode, state, &chr, 0);
2937         else
2938             ToUnicodeEx(data->lastVK, scancode, state, &chr, 1, 0, GetKeyboardLayout(0));
2939         uVirtKey = MAKELONG(data->lastVK,chr);
2940     }
2941     else
2942         uVirtKey = data->lastVK;
2943
2944     msg_count = data->immKbd->pImeToAsciiEx(uVirtKey, scancode, state, list, 0, imc);
2945     TRACE("%i messages generated\n",msg_count);
2946     if (msg_count && msg_count <= list_count)
2947     {
2948         UINT i;
2949         LPTRANSMSG msgs = (LPTRANSMSG)((LPBYTE)list + sizeof(DWORD));
2950
2951         for (i = 0; i < msg_count; i++)
2952             ImmInternalPostIMEMessage(data, msgs[i].message, msgs[i].wParam, msgs[i].lParam);
2953     }
2954     else if (msg_count > list_count)
2955         ImmGenerateMessage(imc);
2956
2957     HeapFree(GetProcessHeap(),0,list);
2958
2959     data->lastVK = VK_PROCESSKEY;
2960
2961     return (msg_count > 0);
2962 }
2963
2964 /***********************************************************************
2965 *               ImmProcessKey(IMM32.@)
2966 *       ( Undocumented, called from user32.dll )
2967 */
2968 BOOL WINAPI ImmProcessKey(HWND hwnd, HKL hKL, UINT vKey, LPARAM lKeyData, DWORD unknown)
2969 {
2970     InputContextData *data;
2971     HIMC imc = ImmGetContext(hwnd);
2972     BYTE state[256];
2973
2974     TRACE("%p %p %x %x %x\n",hwnd, hKL, vKey, (UINT)lKeyData, unknown);
2975
2976     if (imc)
2977         data = imc;
2978     else
2979         return FALSE;
2980
2981     /* Make sure we are inputting to the correct keyboard */
2982     if (data->immKbd->hkl != hKL)
2983     {
2984         ImmHkl *new_hkl = IMM_GetImmHkl(hKL);
2985         if (new_hkl)
2986         {
2987             data->immKbd->pImeSelect(imc, FALSE);
2988             data->immKbd->uSelected--;
2989             data->immKbd = new_hkl;
2990             data->immKbd->pImeSelect(imc, TRUE);
2991             data->immKbd->uSelected++;
2992         }
2993         else
2994             return FALSE;
2995     }
2996
2997     if (!data->immKbd->hIME || !data->immKbd->pImeProcessKey)
2998         return FALSE;
2999
3000     GetKeyboardState(state);
3001     if (data->immKbd->pImeProcessKey(imc, vKey, lKeyData, state))
3002     {
3003         data->lastVK = vKey;
3004         return TRUE;
3005     }
3006
3007     data->lastVK = VK_PROCESSKEY;
3008     return FALSE;
3009 }
3010
3011 /***********************************************************************
3012 *               ImmDisableTextFrameService(IMM32.@)
3013 */
3014 BOOL WINAPI ImmDisableTextFrameService(DWORD idThread)
3015 {
3016     FIXME("Stub\n");
3017     return FALSE;
3018 }
3019
3020 /***********************************************************************
3021  *              ImmEnumInputContext(IMM32.@)
3022  */
3023
3024 BOOL WINAPI ImmEnumInputContext(DWORD idThread, IMCENUMPROC lpfn, LPARAM lParam)
3025 {
3026     FIXME("Stub\n");
3027     return FALSE;
3028 }
3029
3030 /***********************************************************************
3031  *              ImmGetHotKey(IMM32.@)
3032  */
3033
3034 BOOL WINAPI ImmGetHotKey(DWORD hotkey, UINT *modifiers, UINT *key, HKL hkl)
3035 {
3036     FIXME("%x, %p, %p, %p: stub\n", hotkey, modifiers, key, hkl);
3037     return FALSE;
3038 }