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
  37 WINE_DEFAULT_DEBUG_CHANNEL(imm);
  38
  39 typedef struct tagIMCCInternal
  40 {
  41     DWORD dwLock;
  42     DWORD dwSize;
  43 } IMCCInternal;
  44
  45 #define MAKE_FUNCPTR(f) typeof(f) * p##f
  46 typedef struct _tagImmHkl{
  47     struct list entry;
  48     HKL         hkl;
  49     HMODULE     hIME;
  50     IMEINFO     imeInfo;
  51     WCHAR       imeClassName[17]; /* 16 character max */
  52     ULONG       uSelected;
  53
  54     /* Function Pointers */
  55     MAKE_FUNCPTR(ImeInquire);
  56     MAKE_FUNCPTR(ImeConfigure);
  57     MAKE_FUNCPTR(ImeDestroy);
  58     MAKE_FUNCPTR(ImeEscape);
  59     MAKE_FUNCPTR(ImeSelect);
  60     MAKE_FUNCPTR(ImeSetActiveContext);
  61     MAKE_FUNCPTR(ImeToAsciiEx);
  62     MAKE_FUNCPTR(NotifyIME);
  63     MAKE_FUNCPTR(ImeRegisterWord);
  64     MAKE_FUNCPTR(ImeUnregisterWord);
  65     MAKE_FUNCPTR(ImeEnumRegisterWord);
  66     MAKE_FUNCPTR(ImeSetCompositionString);
  67     MAKE_FUNCPTR(ImeConversionList);
  68     MAKE_FUNCPTR(ImeProcessKey);
  69     MAKE_FUNCPTR(ImeGetRegisterWordStyle);
  70     MAKE_FUNCPTR(ImeGetImeMenuItems);
  71 } ImmHkl;
  72 #undef MAKE_FUNCPTR
  73
  74 typedef struct tagInputContextData
  75 {
  76         DWORD           dwLock;
  77         INPUTCONTEXT    IMC;
  78
  79         ImmHkl          *immKbd;
  80         HWND            imeWnd;
  81         UINT            lastVK;
  82 } InputContextData;
  83
  84 typedef struct _tagTRANSMSG {
  85     UINT message;
  86     WPARAM wParam;
  87     LPARAM lParam;
  88 } TRANSMSG, *LPTRANSMSG;
  89
  90 typedef struct _tagIMMThreadData {
  91     HIMC defaultContext;
  92     HWND hwndDefault;
  93 } IMMThreadData;
  94
  95 static DWORD tlsIndex = 0;
  96 static struct list ImmHklList = LIST_INIT(ImmHklList);
  97
  98 /* MSIME messages */
  99 static UINT WM_MSIME_SERVICE;
 100 static UINT WM_MSIME_RECONVERTOPTIONS;
 101 static UINT WM_MSIME_MOUSE;
 102 static UINT WM_MSIME_RECONVERTREQUEST;
 103 static UINT WM_MSIME_RECONVERT;
 104 static UINT WM_MSIME_QUERYPOSITION;
 105 static UINT WM_MSIME_DOCUMENTFEED;
 106
 107 static const WCHAR szwWineIMCProperty[] = {'W','i','n','e','I','m','m','H','I','M','C','P','r','o','p','e','r','t','y',0};
 108
 109 #define is_himc_ime_unicode(p)  (p->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE)
 110 #define is_kbd_ime_unicode(p)  (p->imeInfo.fdwProperty & IME_PROP_UNICODE)
 111
 112 static BOOL IMM_DestroyContext(HIMC hIMC);
 113
 114 static inline WCHAR *strdupAtoW( const char *str )
 115 {
 116     WCHAR *ret = NULL;
 117     if (str)
 118     {
 119         DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 120         if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 121             MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
 122     }
 123     return ret;
 124 }
 125
 126 static inline CHAR *strdupWtoA( const WCHAR *str )
 127 {
 128     CHAR *ret = NULL;
 129     if (str)
 130     {
 131         DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
 132         if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
 133             WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
 134     }
 135     return ret;
 136 }
 137
 138 static IMMThreadData* IMM_GetThreadData(void)
 139 {
 140     return (IMMThreadData*)TlsGetValue(tlsIndex);
 141 }
 142
 143 static void IMM_InitThreadData(void)
 144 {
 145     IMMThreadData* data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 146                                     sizeof(IMMThreadData));
 147     TlsSetValue(tlsIndex,data);
 148
 149     TRACE("Thread Data Created\n");
 150 }
 151
 152 static void IMM_FreeThreadData(void)
 153 {
 154     IMMThreadData* data = TlsGetValue(tlsIndex);
 155     IMM_DestroyContext(data->defaultContext);
 156     DestroyWindow(data->hwndDefault);
 157     HeapFree(GetProcessHeap(),0,data);
 158     TRACE("Thread Data Destroyed\n");
 159 }
 160
 161 static HMODULE LoadDefaultWineIME(void)
 162 {
 163     char buffer[MAX_PATH], libname[32], *name, *next;
 164     HMODULE module = 0;
 165     HKEY hkey;
 166
 167     TRACE("Attempting to fall back to wine default IME\n");
 168
 169     strcpy( buffer, "x11" );  /* default value */
 170     /* @@ Wine registry key: HKCU\Software\Wine\Drivers */
 171     if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Drivers", &hkey ))
 172     {
 173         DWORD type, count = sizeof(buffer);
 174         RegQueryValueExA( hkey, "Ime", 0, &type, (LPBYTE) buffer, &count );
 175         RegCloseKey( hkey );
 176     }
 177
 178     name = buffer;
 179     while (name)
 180     {
 181         next = strchr( name, ',' );
 182         if (next) *next++ = 0;
 183
 184         snprintf( libname, sizeof(libname), "wine%s.drv", name );
 185         if ((module = LoadLibraryA( libname )) != 0) break;
 186         name = next;
 187     }
 188
 189     return module;
 190 }
 191
 192 /* ImmHkl loading and freeing */
 193 #define LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}
 194 static ImmHkl *IMM_GetImmHkl(HKL hkl)
 195 {
 196     ImmHkl *ptr;
 197     WCHAR filename[MAX_PATH];
 198
 199     TRACE("Seeking ime for keyboard 0x%x\n",(unsigned)hkl);
 200
 201     LIST_FOR_EACH_ENTRY(ptr, &ImmHklList, ImmHkl, entry)
 202     {
 203         if (ptr->hkl == hkl)
 204             return ptr;
 205     }
 206     /* not found... create it */
 207
 208     ptr = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ImmHkl));
 209
 210     ptr->hkl = hkl;
 211     if (ImmGetIMEFileNameW(hkl, filename, MAX_PATH)) ptr->hIME = LoadLibraryW(filename);
 212     if (!ptr->hIME)
 213         ptr->hIME = LoadDefaultWineIME();
 214     if (ptr->hIME)
 215     {
 216         LOAD_FUNCPTR(ImeInquire);
 217         if (!ptr->pImeInquire || !ptr->pImeInquire(&ptr->imeInfo, ptr->imeClassName, NULL))
 218         {
 219             FreeLibrary(ptr->hIME);
 220             ptr->hIME = NULL;
 221         }
 222         else
 223         {
 224             LOAD_FUNCPTR(ImeDestroy);
 225             LOAD_FUNCPTR(ImeSelect);
 226             if (!ptr->pImeSelect || !ptr->pImeDestroy)
 227             {
 228                 FreeLibrary(ptr->hIME);
 229                 ptr->hIME = NULL;
 230             }
 231             else
 232             {
 233                 LOAD_FUNCPTR(ImeConfigure);
 234                 LOAD_FUNCPTR(ImeEscape);
 235                 LOAD_FUNCPTR(ImeSetActiveContext);
 236                 LOAD_FUNCPTR(ImeToAsciiEx);
 237                 LOAD_FUNCPTR(NotifyIME);
 238                 LOAD_FUNCPTR(ImeRegisterWord);
 239                 LOAD_FUNCPTR(ImeUnregisterWord);
 240                 LOAD_FUNCPTR(ImeEnumRegisterWord);
 241                 LOAD_FUNCPTR(ImeSetCompositionString);
 242                 LOAD_FUNCPTR(ImeConversionList);
 243                 LOAD_FUNCPTR(ImeProcessKey);
 244                 LOAD_FUNCPTR(ImeGetRegisterWordStyle);
 245                 LOAD_FUNCPTR(ImeGetImeMenuItems);
 246                 /* make sure our classname is WCHAR */
 247                 if (!is_kbd_ime_unicode(ptr))
 248                 {
 249                     WCHAR bufW[17];
 250                     MultiByteToWideChar(CP_ACP, 0, (LPSTR)ptr->imeClassName,
 251                                         -1, bufW, 17);
 252                     lstrcpyW(ptr->imeClassName, bufW);
 253                 }
 254             }
 255         }
 256     }
 257     list_add_head(&ImmHklList,&ptr->entry);
 258
 259     return ptr;
 260 }
 261 #undef LOAD_FUNCPTR
 262
 263 static void IMM_FreeAllImmHkl(void)
 264 {
 265     ImmHkl *ptr,*cursor2;
 266
 267     LIST_FOR_EACH_ENTRY_SAFE(ptr, cursor2, &ImmHklList, ImmHkl, entry)
 268     {
 269         list_remove(&ptr->entry);
 270         if (ptr->hIME)
 271         {
 272             ptr->pImeDestroy(1);
 273             FreeLibrary(ptr->hIME);
 274         }
 275         HeapFree(GetProcessHeap(),0,ptr);
 276     }
 277 }
 278
 279 static void IMM_RegisterMessages(void)
 280 {
 281     WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
 282     WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
 283     WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
 284     WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
 285     WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
 286     WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
 287     WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
 288 }
 289
 290 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpReserved)
 291 {
 292     TRACE("%p, %x, %p\n",hInstDLL,fdwReason,lpReserved);
 293     switch (fdwReason)
 294     {
 295         case DLL_PROCESS_ATTACH:
 296             IMM_RegisterMessages();
 297             tlsIndex = TlsAlloc();
 298             IMM_InitThreadData();
 299             break;
 300         case DLL_THREAD_ATTACH:
 301             IMM_InitThreadData();
 302             break;
 303         case DLL_THREAD_DETACH:
 304             IMM_FreeThreadData();
 305             break;
 306         case DLL_PROCESS_DETACH:
 307             IMM_FreeThreadData();
 308             IMM_FreeAllImmHkl();
 309             TlsFree(tlsIndex);
 310             break;
 311     }
 312     return TRUE;
 313 }
 314
 315 /* for posting messages as the IME */
 316 static void ImmInternalPostIMEMessage(InputContextData *data, UINT msg, WPARAM wParam, LPARAM lParam)
 317 {
 318     HWND target = GetFocus();
 319     if (!target)
 320        PostMessageW(data->IMC.hWnd,msg,wParam,lParam);
 321     else
 322        PostMessageW(target, msg, wParam, lParam);
 323 }
 324
 325 static LRESULT ImmInternalSendIMENotify(InputContextData *data, WPARAM notify, LPARAM lParam)
 326 {
 327     HWND target;
 328
 329     target = data->IMC.hWnd;
 330     if (!target) target = GetFocus();
 331
 332     if (target)
 333        return SendMessageW(target, WM_IME_NOTIFY, notify, lParam);
 334
 335     return 0;
 336 }
 337
 338 static HIMCC ImmCreateBlankCompStr(void)
 339 {
 340     HIMCC rc;
 341     LPCOMPOSITIONSTRING ptr;
 342     rc = ImmCreateIMCC(sizeof(COMPOSITIONSTRING));
 343     ptr = (LPCOMPOSITIONSTRING)ImmLockIMCC(rc);
 344     memset(ptr,0,sizeof(COMPOSITIONSTRING));
 345     ptr->dwSize = sizeof(COMPOSITIONSTRING);
 346     ImmUnlockIMCC(rc);
 347     return rc;
 348 }
 349
 350 /***********************************************************************
 351  *              ImmAssociateContext (IMM32.@)
 352  */
 353 HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
 354 {
 355     HIMC old = NULL;
 356     InputContextData *data = (InputContextData*)hIMC;
 357
 358     TRACE("(%p, %p):\n", hWnd, hIMC);
 359
 360     if (!IMM_GetThreadData()->defaultContext)
 361         IMM_GetThreadData()->defaultContext = ImmCreateContext();
 362
 363     /*
 364      * If already associated just return
 365      */
 366     if (hIMC && data->IMC.hWnd == hWnd)
 367         return hIMC;
 368
 369     if (hWnd)
 370     {
 371         old = (HIMC)RemovePropW(hWnd,szwWineIMCProperty);
 372
 373         if (old == NULL)
 374             old = IMM_GetThreadData()->defaultContext;
 375         else if (old == (HIMC)-1)
 376             old = NULL;
 377
 378         if (hIMC != IMM_GetThreadData()->defaultContext)
 379         {
 380             if (hIMC == NULL) /* Meaning disable imm for that window*/
 381                 SetPropW(hWnd,szwWineIMCProperty,(HANDLE)-1);
 382             else
 383                 SetPropW(hWnd,szwWineIMCProperty,(HANDLE)hIMC);
 384         }
 385
 386         if (old)
 387         {
 388             InputContextData *old_data = (InputContextData*)old;
 389             if (old_data->IMC.hWnd == hWnd)
 390                 old_data->IMC.hWnd = NULL;
 391         }
 392     }
 393
 394     if (!hIMC)
 395         return old;
 396
 397     if (IsWindow(data->IMC.hWnd))
 398     {
 399         /*
 400          * Post a message that your context is switching
 401          */
 402         SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
 403     }
 404
 405     data->IMC.hWnd = hWnd;
 406
 407     if (IsWindow(data->IMC.hWnd))
 408     {
 409         /*
 410          * Post a message that your context is switching
 411          */
 412         SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
 413     }
 414
 415     return old;
 416 }
 417
 418 /***********************************************************************
 419  *              ImmAssociateContextEx (IMM32.@)
 420  */
 421 BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
 422 {
 423     FIXME("(%p, %p, %d): stub\n", hWnd, hIMC, dwFlags);
 424     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 425     return FALSE;
 426 }
 427
 428 /***********************************************************************
 429  *              ImmConfigureIMEA (IMM32.@)
 430  */
 431 BOOL WINAPI ImmConfigureIMEA(
 432   HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
 433 {
 434     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 435
 436     TRACE("(%p, %p, %d, %p):\n", hKL, hWnd, dwMode, lpData);
 437
 438     if (immHkl->hIME && immHkl->pImeConfigure)
 439     {
 440         if (dwMode != IME_CONFIG_REGISTERWORD || !is_kbd_ime_unicode(immHkl))
 441             return immHkl->pImeConfigure(hKL,hWnd,dwMode,lpData);
 442         else
 443         {
 444             REGISTERWORDW rww;
 445             REGISTERWORDA *rwa = (REGISTERWORDA*)lpData;
 446             BOOL rc;
 447
 448             rww.lpReading = strdupAtoW(rwa->lpReading);
 449             rww.lpWord = strdupAtoW(rwa->lpWord);
 450             rc = immHkl->pImeConfigure(hKL,hWnd,dwMode,&rww);
 451             HeapFree(GetProcessHeap(),0,rww.lpReading);
 452             HeapFree(GetProcessHeap(),0,rww.lpWord);
 453             return rc;
 454         }
 455     }
 456     else
 457         return FALSE;
 458 }
 459
 460 /***********************************************************************
 461  *              ImmConfigureIMEW (IMM32.@)
 462  */
 463 BOOL WINAPI ImmConfigureIMEW(
 464   HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
 465 {
 466     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 467
 468     TRACE("(%p, %p, %d, %p):\n", hKL, hWnd, dwMode, lpData);
 469
 470     if (immHkl->hIME && immHkl->pImeConfigure)
 471     {
 472         if (dwMode != IME_CONFIG_REGISTERWORD || is_kbd_ime_unicode(immHkl))
 473             return immHkl->pImeConfigure(hKL,hWnd,dwMode,lpData);
 474         else
 475         {
 476             REGISTERWORDW *rww = (REGISTERWORDW*)lpData;
 477             REGISTERWORDA rwa;
 478             BOOL rc;
 479
 480             rwa.lpReading = strdupWtoA(rww->lpReading);
 481             rwa.lpWord = strdupWtoA(rww->lpWord);
 482             rc = immHkl->pImeConfigure(hKL,hWnd,dwMode,&rwa);
 483             HeapFree(GetProcessHeap(),0,rwa.lpReading);
 484             HeapFree(GetProcessHeap(),0,rwa.lpWord);
 485             return rc;
 486         }
 487     }
 488     else
 489         return FALSE;
 490 }
 491
 492 /***********************************************************************
 493  *              ImmCreateContext (IMM32.@)
 494  */
 495 HIMC WINAPI ImmCreateContext(void)
 496 {
 497     InputContextData *new_context;
 498     LPGUIDELINE gl;
 499     LPCANDIDATEINFO ci;
 500
 501     new_context = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(InputContextData));
 502
 503     /* Load the IME */
 504     new_context->immKbd = IMM_GetImmHkl(GetKeyboardLayout(0));
 505
 506     if (!new_context->immKbd->hIME)
 507     {
 508         TRACE("IME dll could not be loaded\n");
 509         HeapFree(GetProcessHeap(),0,new_context);
 510         return 0;
 511     }
 512
 513     /* the HIMCCs are never NULL */
 514     new_context->IMC.hCompStr = ImmCreateBlankCompStr();
 515     new_context->IMC.hMsgBuf = ImmCreateIMCC(0);
 516     new_context->IMC.hCandInfo = ImmCreateIMCC(sizeof(CANDIDATEINFO));
 517     ci = ImmLockIMCC(new_context->IMC.hCandInfo);
 518     memset(ci,0,sizeof(CANDIDATEINFO));
 519     ci->dwSize = sizeof(CANDIDATEINFO);
 520     ImmUnlockIMCC(new_context->IMC.hCandInfo);
 521     new_context->IMC.hGuideLine = ImmCreateIMCC(sizeof(GUIDELINE));
 522     gl = ImmLockIMCC(new_context->IMC.hGuideLine);
 523     memset(gl,0,sizeof(GUIDELINE));
 524     gl->dwSize = sizeof(GUIDELINE);
 525     ImmUnlockIMCC(new_context->IMC.hGuideLine);
 526
 527     /* Initialize the IME Private */
 528     new_context->IMC.hPrivate = ImmCreateIMCC(new_context->immKbd->imeInfo.dwPrivateDataSize);
 529
 530     if (!new_context->immKbd->pImeSelect(new_context, TRUE))
 531     {
 532         TRACE("Selection of IME failed\n");
 533         IMM_DestroyContext(new_context);
 534         return 0;
 535     }
 536
 537     new_context->immKbd->uSelected++;
 538     TRACE("Created context 0x%x\n",(UINT)new_context);
 539
 540     return (HIMC)new_context;
 541 }
 542
 543 static BOOL IMM_DestroyContext(HIMC hIMC)
 544 {
 545     InputContextData *data = (InputContextData*)hIMC;
 546
 547     TRACE("Destroying %p\n",hIMC);
 548
 549     if (hIMC)
 550     {
 551         data->immKbd->uSelected --;
 552         data->immKbd->pImeSelect(hIMC, FALSE);
 553
 554         if (IMM_GetThreadData()->hwndDefault == data->imeWnd)
 555             IMM_GetThreadData()->hwndDefault = NULL;
 556         DestroyWindow(data->imeWnd);
 557
 558         ImmDestroyIMCC(data->IMC.hCompStr);
 559         ImmDestroyIMCC(data->IMC.hCandInfo);
 560         ImmDestroyIMCC(data->IMC.hGuideLine);
 561         ImmDestroyIMCC(data->IMC.hPrivate);
 562         ImmDestroyIMCC(data->IMC.hMsgBuf);
 563
 564         HeapFree(GetProcessHeap(),0,data);
 565     }
 566     return TRUE;
 567 }
 568
 569 /***********************************************************************
 570  *              ImmDestroyContext (IMM32.@)
 571  */
 572 BOOL WINAPI ImmDestroyContext(HIMC hIMC)
 573 {
 574     if (hIMC != IMM_GetThreadData()->defaultContext)
 575         return IMM_DestroyContext(hIMC);
 576     else
 577         return FALSE;
 578 }
 579
 580 /***********************************************************************
 581  *              ImmDisableIME (IMM32.@)
 582  */
 583 BOOL WINAPI ImmDisableIME(DWORD idThread)
 584 {
 585     FIXME("(%d): stub\n", idThread);
 586     return TRUE;
 587 }
 588
 589 /***********************************************************************
 590  *              ImmEnumRegisterWordA (IMM32.@)
 591  */
 592 UINT WINAPI ImmEnumRegisterWordA(
 593   HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc,
 594   LPCSTR lpszReading, DWORD dwStyle,
 595   LPCSTR lpszRegister, LPVOID lpData)
 596 {
 597     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 598     TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL, lpfnEnumProc,
 599         debugstr_a(lpszReading), dwStyle, debugstr_a(lpszRegister), lpData);
 600     if (immHkl->hIME && immHkl->pImeEnumRegisterWord)
 601     {
 602         if (!is_kbd_ime_unicode(immHkl))
 603             return immHkl->pImeEnumRegisterWord((REGISTERWORDENUMPROCW)lpfnEnumProc,
 604                 (LPCWSTR)lpszReading, dwStyle, (LPCWSTR)lpszRegister, lpData);
 605         else
 606         {
 607             FIXME("A procedure called with W ime back end\n");
 608             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 609             return 0;
 610         }
 611     }
 612     else
 613         return 0;
 614 }
 615
 616 /***********************************************************************
 617  *              ImmEnumRegisterWordW (IMM32.@)
 618  */
 619 UINT WINAPI ImmEnumRegisterWordW(
 620   HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc,
 621   LPCWSTR lpszReading, DWORD dwStyle,
 622   LPCWSTR lpszRegister, LPVOID lpData)
 623 {
 624     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 625     TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL, lpfnEnumProc,
 626         debugstr_w(lpszReading), dwStyle, debugstr_w(lpszRegister), lpData);
 627     if (immHkl->hIME && immHkl->pImeEnumRegisterWord)
 628     {
 629         if (is_kbd_ime_unicode(immHkl))
 630             return immHkl->pImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
 631                                             lpszRegister, lpData);
 632         else
 633         {
 634             FIXME("W procedure called with A ime back end\n");
 635             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 636             return 0;
 637         }
 638     }
 639     else
 640         return 0;
 641 }
 642
 643 /***********************************************************************
 644  *              ImmEscapeA (IMM32.@)
 645  */
 646 LRESULT WINAPI ImmEscapeA(
 647   HKL hKL, HIMC hIMC,
 648   UINT uEscape, LPVOID lpData)
 649 {
 650     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 651     TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
 652
 653     if (immHkl->hIME && immHkl->pImeEscape)
 654     {
 655         if (!is_kbd_ime_unicode(immHkl))
 656             return immHkl->pImeEscape(hIMC,uEscape,lpData);
 657         else
 658         {
 659             FIXME("A procedure called with W ime back end\n");
 660             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 661             return 0;
 662         }
 663     }
 664     else
 665         return 0;
 666 }
 667
 668 /***********************************************************************
 669  *              ImmEscapeW (IMM32.@)
 670  */
 671 LRESULT WINAPI ImmEscapeW(
 672   HKL hKL, HIMC hIMC,
 673   UINT uEscape, LPVOID lpData)
 674 {
 675     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 676     TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
 677
 678     if (immHkl->hIME && immHkl->pImeEscape)
 679     {
 680         if (is_kbd_ime_unicode(immHkl))
 681             return immHkl->pImeEscape(hIMC,uEscape,lpData);
 682         else
 683         {
 684             FIXME("W procedure called with A ime back end\n");
 685             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 686             return 0;
 687         }
 688     }
 689     else
 690         return 0;
 691 }
 692
 693 /***********************************************************************
 694  *              ImmGetCandidateListA (IMM32.@)
 695  */
 696 DWORD WINAPI ImmGetCandidateListA(
 697   HIMC hIMC, DWORD deIndex,
 698   LPCANDIDATELIST lpCandList, DWORD dwBufLen)
 699 {
 700   FIXME("(%p, %d, %p, %d): stub\n",
 701     hIMC, deIndex,
 702     lpCandList, dwBufLen
 703   );
 704   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 705   return 0;
 706 }
 707
 708 /***********************************************************************
 709  *              ImmGetCandidateListCountA (IMM32.@)
 710  */
 711 DWORD WINAPI ImmGetCandidateListCountA(
 712   HIMC hIMC, LPDWORD lpdwListCount)
 713 {
 714   FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
 715   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 716   return 0;
 717 }
 718
 719 /***********************************************************************
 720  *              ImmGetCandidateListCountW (IMM32.@)
 721  */
 722 DWORD WINAPI ImmGetCandidateListCountW(
 723   HIMC hIMC, LPDWORD lpdwListCount)
 724 {
 725   FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
 726   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 727   return 0;
 728 }
 729
 730 /***********************************************************************
 731  *              ImmGetCandidateListW (IMM32.@)
 732  */
 733 DWORD WINAPI ImmGetCandidateListW(
 734   HIMC hIMC, DWORD deIndex,
 735   LPCANDIDATELIST lpCandList, DWORD dwBufLen)
 736 {
 737   FIXME("(%p, %d, %p, %d): stub\n",
 738     hIMC, deIndex,
 739     lpCandList, dwBufLen
 740   );
 741   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 742   return 0;
 743 }
 744
 745 /***********************************************************************
 746  *              ImmGetCandidateWindow (IMM32.@)
 747  */
 748 BOOL WINAPI ImmGetCandidateWindow(
 749   HIMC hIMC, DWORD dwBufLen, LPCANDIDATEFORM lpCandidate)
 750 {
 751   FIXME("(%p, %d, %p): stub\n", hIMC, dwBufLen, lpCandidate);
 752   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 753   return FALSE;
 754 }
 755
 756 /***********************************************************************
 757  *              ImmGetCompositionFontA (IMM32.@)
 758  */
 759 BOOL WINAPI ImmGetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
 760 {
 761     LOGFONTW lfW;
 762     BOOL rc;
 763
 764     TRACE("(%p, %p):\n", hIMC, lplf);
 765
 766     rc = ImmGetCompositionFontW(hIMC,&lfW);
 767     if (rc)
 768     {
 769         memcpy(lplf,&lfW,sizeof(LOGFONTA));
 770         WideCharToMultiByte(CP_ACP, 0, lfW.lfFaceName, -1, lplf->lfFaceName,
 771                         LF_FACESIZE, NULL, NULL);
 772     }
 773     return rc;
 774 }
 775
 776 /***********************************************************************
 777  *              ImmGetCompositionFontW (IMM32.@)
 778  */
 779 BOOL WINAPI ImmGetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
 780 {
 781     InputContextData *data = (InputContextData*)hIMC;
 782
 783     TRACE("(%p, %p):\n", hIMC, lplf);
 784
 785     if (!data)
 786         return FALSE;
 787
 788     *lplf = data->IMC.lfFont.W;
 789
 790     return TRUE;
 791 }
 792
 793 /***********************************************************************
 794  *              ImmGetCompositionStringA (IMM32.@)
 795  */
 796 LONG WINAPI ImmGetCompositionStringA(
 797   HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
 798 {
 799     CHAR *buf;
 800     LONG rc = 0;
 801     InputContextData *data = (InputContextData*)hIMC;
 802     LPCOMPOSITIONSTRING compstr;
 803     LPBYTE compdata;
 804
 805     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 806
 807     if (!data)
 808        return FALSE;
 809
 810     if (!data->IMC.hCompStr)
 811        return FALSE;
 812
 813     compdata = ImmLockIMCC(data->IMC.hCompStr);
 814     compstr = (LPCOMPOSITIONSTRING)compdata;
 815
 816     if (dwIndex == GCS_RESULTSTR && compstr->dwResultStrLen > 0 &&
 817         compstr->dwResultStrOffset > 0)
 818     {
 819         LPWSTR ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
 820
 821         TRACE("GSC_RESULTSTR %p %i\n",ResultStr,
 822                                     compstr->dwResultStrLen);
 823
 824         buf = HeapAlloc( GetProcessHeap(), 0, compstr->dwResultStrLen * 3 );
 825         rc = WideCharToMultiByte(CP_ACP, 0, ResultStr,
 826                                  compstr->dwResultStrLen , buf,
 827                                  compstr->dwResultStrLen * 3, NULL, NULL);
 828         if (dwBufLen >= rc)
 829             memcpy(lpBuf,buf,rc);
 830
 831         HeapFree( GetProcessHeap(), 0, buf );
 832     }
 833     else if (dwIndex == GCS_COMPSTR && compstr->dwCompStrLen > 0 &&
 834               compstr->dwCompStrOffset > 0)
 835     {
 836         LPWSTR CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
 837
 838         TRACE("GSC_COMPSTR %p %i\n", CompString, compstr->dwCompStrLen);
 839
 840         buf = HeapAlloc( GetProcessHeap(), 0, compstr->dwCompStrLen * 3 );
 841         rc = WideCharToMultiByte(CP_ACP, 0, CompString,
 842                                  compstr->dwCompStrLen, buf,
 843                                  compstr->dwCompStrLen * 3, NULL, NULL);
 844         if (dwBufLen >= rc)
 845             memcpy(lpBuf,buf,rc);
 846         HeapFree( GetProcessHeap(), 0, buf );
 847     }
 848     else if (dwIndex == GCS_COMPATTR && compstr->dwCompAttrLen > 0 &&
 849              compstr->dwCompAttrOffset > 0)
 850     {
 851         LPWSTR Compattr = (LPWSTR)(compdata + compstr->dwCompAttrOffset);
 852         TRACE("GSC_COMPATTR %p %i\n", Compattr , compstr->dwCompAttrLen);
 853
 854         rc = compstr->dwCompAttrLen;
 855         if (dwBufLen >= rc)
 856             memcpy(lpBuf,Compattr,rc);
 857     }
 858     else if (dwIndex == GCS_COMPCLAUSE && compstr->dwCompClauseLen > 0 &&
 859              compstr->dwCompClauseOffset > 0)
 860     {
 861         LPWSTR Compclause = (LPWSTR)(compdata + compstr->dwCompClauseOffset);
 862         TRACE("GSC_COMPCLAUSE %p %i\n", Compclause, compstr->dwCompClauseLen);
 863
 864         rc = compstr->dwCompClauseLen;
 865         if (dwBufLen >= compstr->dwCompClauseLen)
 866             memcpy(lpBuf,Compclause,rc);
 867     }
 868     else if (dwIndex == GCS_RESULTCLAUSE && compstr->dwResultClauseLen > 0 &&
 869              compstr->dwResultClauseOffset > 0)
 870     {
 871         LPWSTR Resultclause = (LPWSTR)(compdata + compstr->dwResultClauseOffset);
 872         TRACE("GSC_RESULTCLAUSE %p %i\n", Resultclause, compstr->dwResultClauseLen);
 873
 874         rc = compstr->dwResultClauseLen;
 875         if (dwBufLen >= compstr->dwResultClauseLen)
 876             memcpy(lpBuf,Resultclause,rc);
 877     }
 878     else if (dwIndex == GCS_CURSORPOS)
 879     {
 880         TRACE("GSC_CURSORPOS\n");
 881         rc = compstr->dwCursorPos;
 882     }
 883     else if (dwIndex == GCS_DELTASTART)
 884     {
 885         TRACE("GCS_DELTASTART\n");
 886         rc = compstr->dwDeltaStart;
 887     }
 888     else
 889     {
 890         FIXME("Unhandled index 0x%x\n",dwIndex);
 891     }
 892
 893     ImmUnlockIMCC(data->IMC.hCompStr);
 894
 895     return rc;
 896 }
 897
 898 /***********************************************************************
 899  *              ImmGetCompositionStringW (IMM32.@)
 900  */
 901 LONG WINAPI ImmGetCompositionStringW(
 902   HIMC hIMC, DWORD dwIndex,
 903   LPVOID lpBuf, DWORD dwBufLen)
 904 {
 905     LONG rc = 0;
 906     InputContextData *data = (InputContextData*)hIMC;
 907     LPCOMPOSITIONSTRING compstr;
 908     LPBYTE compdata;
 909
 910     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 911
 912     if (!data)
 913        return FALSE;
 914
 915     if (!data->IMC.hCompStr)
 916        return FALSE;
 917
 918     compdata = ImmLockIMCC(data->IMC.hCompStr);
 919     compstr = (LPCOMPOSITIONSTRING)compdata;
 920
 921     if (dwIndex == GCS_RESULTSTR && compstr->dwResultStrLen > 0 &&
 922         compstr->dwResultStrOffset > 0)
 923     {
 924         LPWSTR ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
 925         rc =  compstr->dwResultStrLen * sizeof(WCHAR);
 926
 927         if (dwBufLen >= rc)
 928             memcpy(lpBuf,ResultStr,rc);
 929     }
 930     else if (dwIndex == GCS_RESULTREADSTR && compstr->dwResultReadStrLen > 0 &&
 931              compstr->dwResultReadStrOffset > 0)
 932     {
 933         LPWSTR ResultReadString = (LPWSTR)(compdata + compstr->dwResultReadStrOffset);
 934
 935         rc = compstr->dwResultReadStrLen * sizeof(WCHAR);
 936         if (dwBufLen >= rc)
 937             memcpy(lpBuf,ResultReadString,rc);
 938     }
 939     else if (dwIndex == GCS_COMPSTR && compstr->dwCompStrLen > 0 &&
 940               compstr->dwCompStrOffset > 0)
 941     {
 942         LPWSTR CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
 943         rc = compstr->dwCompStrLen * sizeof(WCHAR);
 944         if (dwBufLen >= rc)
 945             memcpy(lpBuf,CompString,rc);
 946     }
 947     else if (dwIndex == GCS_COMPATTR && compstr->dwCompAttrLen > 0 &&
 948              compstr->dwCompAttrOffset > 0)
 949     {
 950
 951         LPWSTR Compattr = (LPWSTR)(compdata + compstr->dwCompAttrOffset);
 952
 953         rc = compstr->dwCompAttrLen;
 954         if (dwBufLen >= rc)
 955             memcpy(lpBuf,Compattr,rc);
 956     }
 957     else if (dwIndex == GCS_COMPCLAUSE && compstr->dwCompClauseLen > 0 &&
 958              compstr->dwCompClauseOffset > 0)
 959     {
 960         LPWSTR Compclause = (LPWSTR)(compdata + compstr->dwCompClauseOffset);
 961
 962         rc = compstr->dwCompClauseLen;
 963         if (dwBufLen >= compstr->dwCompClauseLen)
 964             memcpy(lpBuf,Compclause,rc);
 965     }
 966     else if (dwIndex == GCS_COMPREADSTR && compstr->dwCompReadStrLen > 0 &&
 967               compstr->dwCompReadStrOffset > 0)
 968     {
 969         LPWSTR CompReadString = (LPWSTR)(compdata + compstr->dwCompReadStrOffset);
 970
 971         rc = compstr->dwCompReadStrLen * sizeof(WCHAR);
 972
 973         if (dwBufLen >= rc)
 974             memcpy(lpBuf,CompReadString,rc);
 975     }
 976     else if (dwIndex == GCS_CURSORPOS)
 977     {
 978         TRACE("GSC_CURSORPOS\n");
 979         rc = compstr->dwCursorPos;
 980     }
 981     else if (dwIndex == GCS_DELTASTART)
 982     {
 983         TRACE("GCS_DELTASTART\n");
 984         rc = compstr->dwDeltaStart;
 985     }
 986     else
 987     {
 988         FIXME("Unhandled index 0x%x\n",dwIndex);
 989     }
 990
 991     ImmUnlockIMCC(data->IMC.hCompStr);
 992
 993     return rc;
 994 }
 995
 996 /***********************************************************************
 997  *              ImmGetCompositionWindow (IMM32.@)
 998  */
 999 BOOL WINAPI ImmGetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
1000 {
1001     InputContextData *data = (InputContextData*)hIMC;
1002
1003     TRACE("(%p, %p)\n", hIMC, lpCompForm);
1004
1005     if (!data)
1006         return FALSE;
1007
1008     *lpCompForm = data->IMC.cfCompForm;
1009     return 1;
1010 }
1011
1012 /***********************************************************************
1013  *              ImmGetContext (IMM32.@)
1014  *
1015  */
1016 HIMC WINAPI ImmGetContext(HWND hWnd)
1017 {
1018     HIMC rc = NULL;
1019
1020     TRACE("%p\n", hWnd);
1021     if (!IMM_GetThreadData()->defaultContext)
1022         IMM_GetThreadData()->defaultContext = ImmCreateContext();
1023
1024     rc = (HIMC)GetPropW(hWnd,szwWineIMCProperty);
1025     if (rc == (HIMC)-1)
1026         rc = NULL;
1027     else if (rc == NULL)
1028         rc = IMM_GetThreadData()->defaultContext;
1029
1030     if (rc)
1031     {
1032         InputContextData *data = (InputContextData*)rc;
1033         data->IMC.hWnd = hWnd;
1034     }
1035     TRACE("returning %p\n", rc);
1036
1037     return rc;
1038 }
1039
1040 /***********************************************************************
1041  *              ImmGetConversionListA (IMM32.@)
1042  */
1043 DWORD WINAPI ImmGetConversionListA(
1044   HKL hKL, HIMC hIMC,
1045   LPCSTR pSrc, LPCANDIDATELIST lpDst,
1046   DWORD dwBufLen, UINT uFlag)
1047 {
1048     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1049     TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL, hIMC, debugstr_a(pSrc), lpDst,
1050                 dwBufLen, uFlag);
1051     if (immHkl->hIME && immHkl->pImeConversionList)
1052     {
1053         if (!is_kbd_ime_unicode(immHkl))
1054             return immHkl->pImeConversionList(hIMC,(LPCWSTR)pSrc,lpDst,dwBufLen,uFlag);
1055         else
1056         {
1057             FIXME("A procedure called with W ime back end\n");
1058             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1059             return 0;
1060         }
1061     }
1062     else
1063         return 0;
1064 }
1065
1066 /***********************************************************************
1067  *              ImmGetConversionListW (IMM32.@)
1068  */
1069 DWORD WINAPI ImmGetConversionListW(
1070   HKL hKL, HIMC hIMC,
1071   LPCWSTR pSrc, LPCANDIDATELIST lpDst,
1072   DWORD dwBufLen, UINT uFlag)
1073 {
1074     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1075     TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL, hIMC, debugstr_w(pSrc), lpDst,
1076                 dwBufLen, uFlag);
1077     if (immHkl->hIME && immHkl->pImeConversionList)
1078     {
1079         if (is_kbd_ime_unicode(immHkl))
1080             return immHkl->pImeConversionList(hIMC,pSrc,lpDst,dwBufLen,uFlag);
1081         else
1082         {
1083             FIXME("W procedure called with A ime back end\n");
1084             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1085             return 0;
1086         }
1087     }
1088     else
1089         return 0;
1090 }
1091
1092 /***********************************************************************
1093  *              ImmGetConversionStatus (IMM32.@)
1094  */
1095 BOOL WINAPI ImmGetConversionStatus(
1096   HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)
1097 {
1098     InputContextData *data = (InputContextData*)hIMC;
1099
1100     TRACE("%p %p %p\n", hIMC, lpfdwConversion, lpfdwSentence);
1101
1102     if (!data)
1103         return FALSE;
1104
1105     if (lpfdwConversion)
1106         *lpfdwConversion = data->IMC.fdwConversion;
1107     if (lpfdwSentence)
1108         *lpfdwSentence = data->IMC.fdwSentence;
1109
1110     return TRUE;
1111 }
1112
1113 /***********************************************************************
1114  *              ImmGetDefaultIMEWnd (IMM32.@)
1115  */
1116 HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
1117 {
1118     TRACE("Default is %x\n",(unsigned)IMM_GetThreadData()->hwndDefault);
1119     return IMM_GetThreadData()->hwndDefault;
1120 }
1121
1122 /***********************************************************************
1123  *              ImmGetDescriptionA (IMM32.@)
1124  */
1125 UINT WINAPI ImmGetDescriptionA(
1126   HKL hKL, LPSTR lpszDescription, UINT uBufLen)
1127 {
1128   WCHAR *buf;
1129   DWORD len;
1130
1131   TRACE("%p %p %d\n", hKL, lpszDescription, uBufLen);
1132
1133   /* find out how many characters in the unicode buffer */
1134   len = ImmGetDescriptionW( hKL, NULL, 0 );
1135
1136   /* allocate a buffer of that size */
1137   buf = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof (WCHAR) );
1138   if( !buf )
1139   return 0;
1140
1141   /* fetch the unicode buffer */
1142   len = ImmGetDescriptionW( hKL, buf, len + 1 );
1143
1144   /* convert it back to ASCII */
1145   len = WideCharToMultiByte( CP_ACP, 0, buf, len + 1,
1146                              lpszDescription, uBufLen, NULL, NULL );
1147
1148   HeapFree( GetProcessHeap(), 0, buf );
1149
1150   return len;
1151 }
1152
1153 /***********************************************************************
1154  *              ImmGetDescriptionW (IMM32.@)
1155  */
1156 UINT WINAPI ImmGetDescriptionW(HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
1157 {
1158   static const WCHAR name[] = { 'W','i','n','e',' ','X','I','M',0 };
1159
1160   FIXME("(%p, %p, %d): semi stub\n", hKL, lpszDescription, uBufLen);
1161
1162   if (!uBufLen) return lstrlenW( name );
1163   lstrcpynW( lpszDescription, name, uBufLen );
1164   return lstrlenW( lpszDescription );
1165 }
1166
1167 /***********************************************************************
1168  *              ImmGetGuideLineA (IMM32.@)
1169  */
1170 DWORD WINAPI ImmGetGuideLineA(
1171   HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)
1172 {
1173   FIXME("(%p, %d, %s, %d): stub\n",
1174     hIMC, dwIndex, debugstr_a(lpBuf), dwBufLen
1175   );
1176   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1177   return 0;
1178 }
1179
1180 /***********************************************************************
1181  *              ImmGetGuideLineW (IMM32.@)
1182  */
1183 DWORD WINAPI ImmGetGuideLineW(HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)
1184 {
1185   FIXME("(%p, %d, %s, %d): stub\n",
1186     hIMC, dwIndex, debugstr_w(lpBuf), dwBufLen
1187   );
1188   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1189   return 0;
1190 }
1191
1192 /***********************************************************************
1193  *              ImmGetIMEFileNameA (IMM32.@)
1194  */
1195 UINT WINAPI ImmGetIMEFileNameA( HKL hKL, LPSTR lpszFileName, UINT uBufLen)
1196 {
1197     LPWSTR bufW = NULL;
1198     UINT wBufLen = uBufLen;
1199     UINT rc;
1200
1201     if (uBufLen && lpszFileName)
1202         bufW = HeapAlloc(GetProcessHeap(),0,uBufLen * sizeof(WCHAR));
1203     else /* We need this to get the number of byte required */
1204     {
1205         bufW = HeapAlloc(GetProcessHeap(),0,MAX_PATH * sizeof(WCHAR));
1206         wBufLen = MAX_PATH;
1207     }
1208
1209     rc = ImmGetIMEFileNameW(hKL,bufW,wBufLen);
1210
1211     if (rc > 0)
1212     {
1213         if (uBufLen && lpszFileName)
1214             rc = WideCharToMultiByte(CP_ACP, 0, bufW, -1, lpszFileName,
1215                                  uBufLen, NULL, NULL);
1216         else /* get the length */
1217             rc = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL,
1218                                      NULL);
1219     }
1220
1221     HeapFree(GetProcessHeap(),0,bufW);
1222     return rc;
1223 }
1224
1225 /***********************************************************************
1226  *              ImmGetIMEFileNameW (IMM32.@)
1227  */
1228 UINT WINAPI ImmGetIMEFileNameW(HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
1229 {
1230     static const WCHAR szImeFileW[] = {'I','m','e',' ','F','i','l','e',0};
1231     static const WCHAR fmt[] = {'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','x',0};
1232
1233     HKEY hkey;
1234     DWORD length;
1235     DWORD rc;
1236     WCHAR regKey[sizeof(fmt)/sizeof(WCHAR)+8];
1237
1238     wsprintfW( regKey, fmt, (unsigned)hKL );
1239     rc = RegOpenKeyW( HKEY_LOCAL_MACHINE, regKey, &hkey);
1240     if (rc != ERROR_SUCCESS)
1241     {
1242         SetLastError(rc);
1243         return 0;
1244     }
1245
1246     length = 0;
1247     rc = RegGetValueW(hkey, NULL, szImeFileW, RRF_RT_REG_SZ, NULL, NULL, &length);
1248
1249     if (rc != ERROR_SUCCESS)
1250     {
1251         RegCloseKey(hkey);
1252         SetLastError(rc);
1253         return 0;
1254     }
1255     if (length > uBufLen * sizeof(WCHAR) || !lpszFileName)
1256     {
1257         RegCloseKey(hkey);
1258         if (lpszFileName)
1259         {
1260             SetLastError(ERROR_INSUFFICIENT_BUFFER);
1261             return 0;
1262         }
1263         else
1264             return length / sizeof(WCHAR);
1265     }
1266
1267     RegGetValueW(hkey, NULL, szImeFileW, RRF_RT_REG_SZ, NULL, lpszFileName, &length);
1268
1269     RegCloseKey(hkey);
1270
1271     return length / sizeof(WCHAR);
1272 }
1273
1274 /***********************************************************************
1275  *              ImmGetOpenStatus (IMM32.@)
1276  */
1277 BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
1278 {
1279   InputContextData *data = (InputContextData*)hIMC;
1280
1281     if (!data)
1282         return FALSE;
1283   FIXME("(%p): semi-stub\n", hIMC);
1284
1285   return data->IMC.fOpen;
1286 }
1287
1288 /***********************************************************************
1289  *              ImmGetProperty (IMM32.@)
1290  */
1291 DWORD WINAPI ImmGetProperty(HKL hKL, DWORD fdwIndex)
1292 {
1293     DWORD rc = 0;
1294     ImmHkl *kbd;
1295
1296     TRACE("(%p, %d)\n", hKL, fdwIndex);
1297     kbd = IMM_GetImmHkl(hKL);
1298
1299     if (kbd && kbd->hIME)
1300     {
1301         switch (fdwIndex)
1302         {
1303             case IGP_PROPERTY: rc = kbd->imeInfo.fdwProperty; break;
1304             case IGP_CONVERSION: rc = kbd->imeInfo.fdwConversionCaps; break;
1305             case IGP_SENTENCE: rc = kbd->imeInfo.fdwSentenceCaps; break;
1306             case IGP_SETCOMPSTR: rc = kbd->imeInfo.fdwSCSCaps; break;
1307             case IGP_SELECT: rc = kbd->imeInfo.fdwSelectCaps; break;
1308             case IGP_GETIMEVERSION: rc = IMEVER_0400; break;
1309             case IGP_UI: rc = 0; break;
1310             default: rc = 0;
1311         }
1312     }
1313     return rc;
1314 }
1315
1316 /***********************************************************************
1317  *              ImmGetRegisterWordStyleA (IMM32.@)
1318  */
1319 UINT WINAPI ImmGetRegisterWordStyleA(
1320   HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
1321 {
1322     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1323     TRACE("(%p, %d, %p):\n", hKL, nItem, lpStyleBuf);
1324     if (immHkl->hIME && immHkl->pImeGetRegisterWordStyle)
1325     {
1326         if (!is_kbd_ime_unicode(immHkl))
1327             return immHkl->pImeGetRegisterWordStyle(nItem,(LPSTYLEBUFW)lpStyleBuf);
1328         else
1329         {
1330             STYLEBUFW sbw;
1331             UINT rc;
1332
1333             rc = immHkl->pImeGetRegisterWordStyle(nItem,&sbw);
1334             WideCharToMultiByte(CP_ACP, 0, sbw.szDescription, -1,
1335                 lpStyleBuf->szDescription, 32, NULL, NULL);
1336             lpStyleBuf->dwStyle = sbw.dwStyle;
1337             return rc;
1338         }
1339     }
1340     else
1341         return 0;
1342 }
1343
1344 /***********************************************************************
1345  *              ImmGetRegisterWordStyleW (IMM32.@)
1346  */
1347 UINT WINAPI ImmGetRegisterWordStyleW(
1348   HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
1349 {
1350     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1351     TRACE("(%p, %d, %p):\n", hKL, nItem, lpStyleBuf);
1352     if (immHkl->hIME && immHkl->pImeGetRegisterWordStyle)
1353     {
1354         if (is_kbd_ime_unicode(immHkl))
1355             return immHkl->pImeGetRegisterWordStyle(nItem,lpStyleBuf);
1356         else
1357         {
1358             STYLEBUFA sba;
1359             UINT rc;
1360
1361             rc = immHkl->pImeGetRegisterWordStyle(nItem,(LPSTYLEBUFW)&sba);
1362             MultiByteToWideChar(CP_ACP, 0, sba.szDescription, -1,
1363                 lpStyleBuf->szDescription, 32);
1364             lpStyleBuf->dwStyle = sba.dwStyle;
1365             return rc;
1366         }
1367     }
1368     else
1369         return 0;
1370 }
1371
1372 /***********************************************************************
1373  *              ImmGetStatusWindowPos (IMM32.@)
1374  */
1375 BOOL WINAPI ImmGetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1376 {
1377   FIXME("(%p, %p): stub\n", hIMC, lpptPos);
1378   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1379   return FALSE;
1380 }
1381
1382 /***********************************************************************
1383  *              ImmGetVirtualKey (IMM32.@)
1384  */
1385 UINT WINAPI ImmGetVirtualKey(HWND hWnd)
1386 {
1387   OSVERSIONINFOA version;
1388   FIXME("(%p): stub\n", hWnd);
1389   GetVersionExA( &version );
1390   switch(version.dwPlatformId)
1391   {
1392   case VER_PLATFORM_WIN32_WINDOWS:
1393       return VK_PROCESSKEY;
1394   case VER_PLATFORM_WIN32_NT:
1395       return 0;
1396   default:
1397       FIXME("%d not supported\n",version.dwPlatformId);
1398       return VK_PROCESSKEY;
1399   }
1400 }
1401
1402 /***********************************************************************
1403  *              ImmInstallIMEA (IMM32.@)
1404  */
1405 HKL WINAPI ImmInstallIMEA(
1406   LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
1407 {
1408   FIXME("(%s, %s): stub\n",
1409     debugstr_a(lpszIMEFileName), debugstr_a(lpszLayoutText)
1410   );
1411   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1412   return NULL;
1413 }
1414
1415 /***********************************************************************
1416  *              ImmInstallIMEW (IMM32.@)
1417  */
1418 HKL WINAPI ImmInstallIMEW(
1419   LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
1420 {
1421   FIXME("(%s, %s): stub\n",
1422     debugstr_w(lpszIMEFileName), debugstr_w(lpszLayoutText)
1423   );
1424   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1425   return NULL;
1426 }
1427
1428 /***********************************************************************
1429  *              ImmIsIME (IMM32.@)
1430  */
1431 BOOL WINAPI ImmIsIME(HKL hKL)
1432 {
1433     ImmHkl *ptr;
1434     TRACE("(%p):\n", hKL);
1435     ptr = IMM_GetImmHkl(hKL);
1436     return (ptr && ptr->hIME);
1437 }
1438
1439 /***********************************************************************
1440  *              ImmIsUIMessageA (IMM32.@)
1441  */
1442 BOOL WINAPI ImmIsUIMessageA(
1443   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1444 {
1445     BOOL rc = FALSE;
1446
1447     TRACE("(%p, %x, %ld, %ld)\n", hWndIME, msg, wParam, lParam);
1448     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1449         (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1450         (msg == WM_MSIME_SERVICE) ||
1451         (msg == WM_MSIME_RECONVERTOPTIONS) ||
1452         (msg == WM_MSIME_MOUSE) ||
1453         (msg == WM_MSIME_RECONVERTREQUEST) ||
1454         (msg == WM_MSIME_RECONVERT) ||
1455         (msg == WM_MSIME_QUERYPOSITION) ||
1456         (msg == WM_MSIME_DOCUMENTFEED))
1457
1458     {
1459         if (!IMM_GetThreadData()->hwndDefault)
1460             ImmGetDefaultIMEWnd(NULL);
1461
1462         if (hWndIME == NULL)
1463             PostMessageA(IMM_GetThreadData()->hwndDefault, msg, wParam, lParam);
1464
1465         rc = TRUE;
1466     }
1467     return rc;
1468 }
1469
1470 /***********************************************************************
1471  *              ImmIsUIMessageW (IMM32.@)
1472  */
1473 BOOL WINAPI ImmIsUIMessageW(
1474   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1475 {
1476     BOOL rc = FALSE;
1477     TRACE("(%p, %d, %ld, %ld):\n", hWndIME, msg, wParam, lParam);
1478     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1479         (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1480         (msg == WM_MSIME_SERVICE) ||
1481         (msg == WM_MSIME_RECONVERTOPTIONS) ||
1482         (msg == WM_MSIME_MOUSE) ||
1483         (msg == WM_MSIME_RECONVERTREQUEST) ||
1484         (msg == WM_MSIME_RECONVERT) ||
1485         (msg == WM_MSIME_QUERYPOSITION) ||
1486         (msg == WM_MSIME_DOCUMENTFEED))
1487         rc = TRUE;
1488     return rc;
1489 }
1490
1491 /***********************************************************************
1492  *              ImmNotifyIME (IMM32.@)
1493  */
1494 BOOL WINAPI ImmNotifyIME(
1495   HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
1496 {
1497     InputContextData *data = (InputContextData*)hIMC;
1498
1499     TRACE("(%p, %d, %d, %d)\n",
1500         hIMC, dwAction, dwIndex, dwValue);
1501
1502     if (!data || ! data->immKbd->pNotifyIME)
1503         return FALSE;
1504
1505     return data->immKbd->pNotifyIME(hIMC,dwAction,dwIndex,dwValue);
1506 }
1507
1508 /***********************************************************************
1509  *              ImmRegisterWordA (IMM32.@)
1510  */
1511 BOOL WINAPI ImmRegisterWordA(
1512   HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
1513 {
1514     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1515     TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_a(lpszReading), dwStyle,
1516                     debugstr_a(lpszRegister));
1517     if (immHkl->hIME && immHkl->pImeRegisterWord)
1518     {
1519         if (!is_kbd_ime_unicode(immHkl))
1520             return immHkl->pImeRegisterWord((LPCWSTR)lpszReading,dwStyle,
1521                                             (LPCWSTR)lpszRegister);
1522         else
1523         {
1524             LPWSTR lpszwReading = strdupAtoW(lpszReading);
1525             LPWSTR lpszwRegister = strdupAtoW(lpszRegister);
1526             BOOL rc;
1527
1528             rc = immHkl->pImeRegisterWord(lpszwReading,dwStyle,lpszwRegister);
1529             HeapFree(GetProcessHeap(),0,lpszwReading);
1530             HeapFree(GetProcessHeap(),0,lpszwRegister);
1531             return rc;
1532         }
1533     }
1534     else
1535         return FALSE;
1536 }
1537
1538 /***********************************************************************
1539  *              ImmRegisterWordW (IMM32.@)
1540  */
1541 BOOL WINAPI ImmRegisterWordW(
1542   HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
1543 {
1544     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1545     TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_w(lpszReading), dwStyle,
1546                     debugstr_w(lpszRegister));
1547     if (immHkl->hIME && immHkl->pImeRegisterWord)
1548     {
1549         if (is_kbd_ime_unicode(immHkl))
1550             return immHkl->pImeRegisterWord(lpszReading,dwStyle,lpszRegister);
1551         else
1552         {
1553             LPSTR lpszaReading = strdupWtoA(lpszReading);
1554             LPSTR lpszaRegister = strdupWtoA(lpszRegister);
1555             BOOL rc;
1556
1557             rc = immHkl->pImeRegisterWord((LPCWSTR)lpszaReading,dwStyle,
1558                                           (LPCWSTR)lpszaRegister);
1559             HeapFree(GetProcessHeap(),0,lpszaReading);
1560             HeapFree(GetProcessHeap(),0,lpszaRegister);
1561             return rc;
1562         }
1563     }
1564     else
1565         return FALSE;
1566 }
1567
1568 /***********************************************************************
1569  *              ImmReleaseContext (IMM32.@)
1570  */
1571 BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
1572 {
1573   static int shown = 0;
1574
1575   if (!shown) {
1576      FIXME("(%p, %p): stub\n", hWnd, hIMC);
1577      shown = 1;
1578   }
1579   return TRUE;
1580 }
1581
1582 /***********************************************************************
1583 *              ImmRequestMessageA(IMM32.@)
1584 */
1585 LRESULT WINAPI ImmRequestMessageA(HIMC hIMC, WPARAM wParam, LPARAM lParam)
1586 {
1587     FIXME("(%p %ld %ld): stub\n", hIMC, wParam, wParam);
1588     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1589     return 0;
1590 }
1591
1592 /***********************************************************************
1593 *              ImmRequestMessageW(IMM32.@)
1594 */
1595 LRESULT WINAPI ImmRequestMessageW(HIMC hIMC, WPARAM wParam, LPARAM lParam)
1596 {
1597     FIXME("(%p %ld %ld): stub\n", hIMC, wParam, wParam);
1598     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1599     return 0;
1600 }
1601
1602 /***********************************************************************
1603  *              ImmSetCandidateWindow (IMM32.@)
1604  */
1605 BOOL WINAPI ImmSetCandidateWindow(
1606   HIMC hIMC, LPCANDIDATEFORM lpCandidate)
1607 {
1608   FIXME("(%p, %p): stub\n", hIMC, lpCandidate);
1609   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1610   return FALSE;
1611 }
1612
1613 /***********************************************************************
1614  *              ImmSetCompositionFontA (IMM32.@)
1615  */
1616 BOOL WINAPI ImmSetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
1617 {
1618     InputContextData *data = (InputContextData*)hIMC;
1619     TRACE("(%p, %p)\n", hIMC, lplf);
1620
1621     if (!data)
1622         return FALSE;
1623
1624     memcpy(&data->IMC.lfFont.W,lplf,sizeof(LOGFONTA));
1625     MultiByteToWideChar(CP_ACP, 0, lplf->lfFaceName, -1, data->IMC.lfFont.W.lfFaceName,
1626                         LF_FACESIZE);
1627     ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONFONT, 0);
1628
1629     return TRUE;
1630 }
1631
1632 /***********************************************************************
1633  *              ImmSetCompositionFontW (IMM32.@)
1634  */
1635 BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
1636 {
1637     InputContextData *data = (InputContextData*)hIMC;
1638     TRACE("(%p, %p)\n", hIMC, lplf);
1639
1640     if (!data)
1641         return FALSE;
1642
1643     data->IMC.lfFont.W = *lplf;
1644     ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONFONT, 0);
1645
1646     return TRUE;
1647 }
1648
1649 /***********************************************************************
1650  *              ImmSetCompositionStringA (IMM32.@)
1651  */
1652 BOOL WINAPI ImmSetCompositionStringA(
1653   HIMC hIMC, DWORD dwIndex,
1654   LPCVOID lpComp, DWORD dwCompLen,
1655   LPCVOID lpRead, DWORD dwReadLen)
1656 {
1657     DWORD comp_len;
1658     DWORD read_len;
1659     WCHAR *CompBuffer = NULL;
1660     WCHAR *ReadBuffer = NULL;
1661     BOOL rc;
1662     InputContextData *data = (InputContextData*)hIMC;
1663
1664     TRACE("(%p, %d, %p, %d, %p, %d):\n",
1665             hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1666
1667     if (!data)
1668         return FALSE;
1669
1670     if (!is_himc_ime_unicode(data))
1671         return data->immKbd->pImeSetCompositionString(hIMC, dwIndex, lpComp,
1672                         dwCompLen, lpRead, dwReadLen);
1673
1674     comp_len = MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, NULL, 0);
1675     if (comp_len)
1676     {
1677         CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len * sizeof(WCHAR));
1678         MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len);
1679     }
1680
1681     read_len = MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, NULL, 0);
1682     if (read_len)
1683     {
1684         ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len * sizeof(WCHAR));
1685         MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len);
1686     }
1687
1688     rc =  ImmSetCompositionStringW(hIMC, dwIndex, CompBuffer, comp_len,
1689                                    ReadBuffer, read_len);
1690
1691     HeapFree(GetProcessHeap(), 0, CompBuffer);
1692     HeapFree(GetProcessHeap(), 0, ReadBuffer);
1693
1694     return rc;
1695 }
1696
1697 /***********************************************************************
1698  *              ImmSetCompositionStringW (IMM32.@)
1699  */
1700 BOOL WINAPI ImmSetCompositionStringW(
1701         HIMC hIMC, DWORD dwIndex,
1702         LPCVOID lpComp, DWORD dwCompLen,
1703         LPCVOID lpRead, DWORD dwReadLen)
1704 {
1705     DWORD comp_len;
1706     DWORD read_len;
1707     CHAR *CompBuffer = NULL;
1708     CHAR *ReadBuffer = NULL;
1709     BOOL rc;
1710     InputContextData *data = (InputContextData*)hIMC;
1711
1712     TRACE("(%p, %d, %p, %d, %p, %d):\n",
1713             hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1714
1715     if (!data)
1716         return FALSE;
1717
1718     if (is_himc_ime_unicode(data))
1719         return data->immKbd->pImeSetCompositionString(hIMC, dwIndex, lpComp,
1720                         dwCompLen, lpRead, dwReadLen);
1721
1722     comp_len = WideCharToMultiByte(CP_ACP, 0, lpComp, dwCompLen, NULL, 0, NULL,
1723                                    NULL);
1724     if (comp_len)
1725     {
1726         CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len);
1727         WideCharToMultiByte(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len,
1728                             NULL, NULL);
1729     }
1730
1731     read_len = WideCharToMultiByte(CP_ACP, 0, lpRead, dwReadLen, NULL, 0, NULL,
1732                                    NULL);
1733     if (read_len)
1734     {
1735         ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len);
1736         WideCharToMultiByte(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len,
1737                             NULL, NULL);
1738     }
1739
1740     rc =  ImmSetCompositionStringA(hIMC, dwIndex, CompBuffer, comp_len,
1741                                    ReadBuffer, read_len);
1742
1743     HeapFree(GetProcessHeap(), 0, CompBuffer);
1744     HeapFree(GetProcessHeap(), 0, ReadBuffer);
1745
1746     return rc;
1747 }
1748
1749 /***********************************************************************
1750  *              ImmSetCompositionWindow (IMM32.@)
1751  */
1752 BOOL WINAPI ImmSetCompositionWindow(
1753   HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
1754 {
1755     BOOL reshow = FALSE;
1756     InputContextData *data = (InputContextData*)hIMC;
1757
1758     TRACE("(%p, %p)\n", hIMC, lpCompForm);
1759     TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm->dwStyle,
1760           lpCompForm->ptCurrentPos.x, lpCompForm->ptCurrentPos.y, lpCompForm->rcArea.top,
1761           lpCompForm->rcArea.left, lpCompForm->rcArea.bottom, lpCompForm->rcArea.right);
1762
1763     if (!data)
1764         return FALSE;
1765
1766     data->IMC.cfCompForm = *lpCompForm;
1767
1768     if (IsWindowVisible(IMM_GetThreadData()->hwndDefault))
1769     {
1770         reshow = TRUE;
1771         ShowWindow(IMM_GetThreadData()->hwndDefault,SW_HIDE);
1772     }
1773
1774     /* FIXME: this is a partial stub */
1775
1776     if (reshow)
1777         ShowWindow(IMM_GetThreadData()->hwndDefault,SW_SHOWNOACTIVATE);
1778
1779     ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONWINDOW, 0);
1780     return TRUE;
1781 }
1782
1783 /***********************************************************************
1784  *              ImmSetConversionStatus (IMM32.@)
1785  */
1786 BOOL WINAPI ImmSetConversionStatus(
1787   HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
1788 {
1789     DWORD oldConversion, oldSentence;
1790     InputContextData *data = (InputContextData*)hIMC;
1791
1792     TRACE("%p %d %d\n", hIMC, fdwConversion, fdwSentence);
1793
1794     if (!data)
1795         return FALSE;
1796
1797     if ( fdwConversion != data->IMC.fdwConversion )
1798     {
1799         oldConversion = data->IMC.fdwConversion;
1800         data->IMC.fdwConversion = fdwConversion;
1801         ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, oldConversion, IMC_SETCONVERSIONMODE);
1802         ImmInternalSendIMENotify(data, IMN_SETCONVERSIONMODE, 0);
1803     }
1804     if ( fdwSentence != data->IMC.fdwSentence )
1805     {
1806         oldSentence = data->IMC.fdwSentence;
1807         data->IMC.fdwSentence = fdwSentence;
1808         ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, oldSentence, IMC_SETSENTENCEMODE);
1809         ImmInternalSendIMENotify(data, IMN_SETSENTENCEMODE, 0);
1810     }
1811
1812     return TRUE;
1813 }
1814
1815 /***********************************************************************
1816  *              ImmSetOpenStatus (IMM32.@)
1817  */
1818 BOOL WINAPI ImmSetOpenStatus(HIMC hIMC, BOOL fOpen)
1819 {
1820     InputContextData *data = (InputContextData*)hIMC;
1821
1822     TRACE("%p %d\n", hIMC, fOpen);
1823
1824     if (!data)
1825         return FALSE;
1826
1827     if (data->imeWnd == NULL)
1828     {
1829         /* create the ime window */
1830         data->imeWnd = CreateWindowExW( WS_EX_TOOLWINDOW,
1831                     data->immKbd->imeClassName, NULL, WS_POPUP, 0, 0, 1, 1, 0,
1832                     0, data->immKbd->hIME, 0);
1833         SetWindowLongW(data->imeWnd, IMMGWL_IMC, (LONG)data);
1834         IMM_GetThreadData()->hwndDefault = data->imeWnd;
1835     }
1836
1837     if (!fOpen != !data->IMC.fOpen)
1838     {
1839         data->IMC.fOpen = fOpen;
1840         ImmNotifyIME( hIMC, NI_CONTEXTUPDATED, 0, IMC_SETOPENSTATUS);
1841         ImmInternalSendIMENotify(data, IMN_SETSENTENCEMODE, 0);
1842     }
1843
1844     return TRUE;
1845 }
1846
1847 /***********************************************************************
1848  *              ImmSetStatusWindowPos (IMM32.@)
1849  */
1850 BOOL WINAPI ImmSetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1851 {
1852   FIXME("(%p, %p): stub\n", hIMC, lpptPos);
1853   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1854   return FALSE;
1855 }
1856
1857 /***********************************************************************
1858  *              ImmCreateSoftKeyboard(IMM32.@)
1859  */
1860 HWND WINAPI ImmCreateSoftKeyboard(UINT uType, UINT hOwner, int x, int y)
1861 {
1862     FIXME("(%d, %d, %d, %d): stub\n", uType, hOwner, x, y);
1863     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1864     return 0;
1865 }
1866
1867 /***********************************************************************
1868  *              ImmDestroySoftKeyboard(IMM32.@)
1869  */
1870 BOOL WINAPI ImmDestroySoftKeyboard(HWND hSoftWnd)
1871 {
1872     FIXME("(%p): stub\n", hSoftWnd);
1873     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1874     return FALSE;
1875 }
1876
1877 /***********************************************************************
1878  *              ImmShowSoftKeyboard(IMM32.@)
1879  */
1880 BOOL WINAPI ImmShowSoftKeyboard(HWND hSoftWnd, int nCmdShow)
1881 {
1882     FIXME("(%p, %d): stub\n", hSoftWnd, nCmdShow);
1883     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1884     return FALSE;
1885 }
1886
1887 /***********************************************************************
1888  *              ImmSimulateHotKey (IMM32.@)
1889  */
1890 BOOL WINAPI ImmSimulateHotKey(HWND hWnd, DWORD dwHotKeyID)
1891 {
1892   FIXME("(%p, %d): stub\n", hWnd, dwHotKeyID);
1893   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1894   return FALSE;
1895 }
1896
1897 /***********************************************************************
1898  *              ImmUnregisterWordA (IMM32.@)
1899  */
1900 BOOL WINAPI ImmUnregisterWordA(
1901   HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
1902 {
1903     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1904     TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_a(lpszReading), dwStyle,
1905             debugstr_a(lpszUnregister));
1906     if (immHkl->hIME && immHkl->pImeUnregisterWord)
1907     {
1908         if (!is_kbd_ime_unicode(immHkl))
1909             return immHkl->pImeUnregisterWord((LPCWSTR)lpszReading,dwStyle,
1910                                               (LPCWSTR)lpszUnregister);
1911         else
1912         {
1913             LPWSTR lpszwReading = strdupAtoW(lpszReading);
1914             LPWSTR lpszwUnregister = strdupAtoW(lpszUnregister);
1915             BOOL rc;
1916
1917             rc = immHkl->pImeUnregisterWord(lpszwReading,dwStyle,lpszwUnregister);
1918             HeapFree(GetProcessHeap(),0,lpszwReading);
1919             HeapFree(GetProcessHeap(),0,lpszwUnregister);
1920             return rc;
1921         }
1922     }
1923     else
1924         return FALSE;
1925 }
1926
1927 /***********************************************************************
1928  *              ImmUnregisterWordW (IMM32.@)
1929  */
1930 BOOL WINAPI ImmUnregisterWordW(
1931   HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
1932 {
1933     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1934     TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_w(lpszReading), dwStyle,
1935             debugstr_w(lpszUnregister));
1936     if (immHkl->hIME && immHkl->pImeUnregisterWord)
1937     {
1938         if (is_kbd_ime_unicode(immHkl))
1939             return immHkl->pImeUnregisterWord(lpszReading,dwStyle,lpszUnregister);
1940         else
1941         {
1942             LPSTR lpszaReading = strdupWtoA(lpszReading);
1943             LPSTR lpszaUnregister = strdupWtoA(lpszUnregister);
1944             BOOL rc;
1945
1946             rc = immHkl->pImeUnregisterWord((LPCWSTR)lpszaReading,dwStyle,
1947                                             (LPCWSTR)lpszaUnregister);
1948             HeapFree(GetProcessHeap(),0,lpszaReading);
1949             HeapFree(GetProcessHeap(),0,lpszaUnregister);
1950             return rc;
1951         }
1952     }
1953     else
1954         return FALSE;
1955 }
1956
1957 /***********************************************************************
1958  *              ImmGetImeMenuItemsA (IMM32.@)
1959  */
1960 DWORD WINAPI ImmGetImeMenuItemsA( HIMC hIMC, DWORD dwFlags, DWORD dwType,
1961    LPIMEMENUITEMINFOA lpImeParentMenu, LPIMEMENUITEMINFOA lpImeMenu,
1962     DWORD dwSize)
1963 {
1964     InputContextData *data = (InputContextData*)hIMC;
1965     TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC, dwFlags, dwType,
1966         lpImeParentMenu, lpImeMenu, dwSize);
1967     if (data->immKbd->hIME && data->immKbd->pImeGetImeMenuItems)
1968     {
1969         if (!is_himc_ime_unicode(data) || (!lpImeParentMenu && !lpImeMenu))
1970             return data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
1971                                 (IMEMENUITEMINFOW*)lpImeParentMenu,
1972                                 (IMEMENUITEMINFOW*)lpImeMenu, dwSize);
1973         else
1974         {
1975             IMEMENUITEMINFOW lpImeParentMenuW;
1976             IMEMENUITEMINFOW *lpImeMenuW, *parent = NULL;
1977             DWORD rc;
1978
1979             if (lpImeParentMenu)
1980                 parent = &lpImeParentMenuW;
1981             if (lpImeMenu)
1982             {
1983                 int count = dwSize / sizeof(LPIMEMENUITEMINFOA);
1984                 dwSize = count * sizeof(IMEMENUITEMINFOW);
1985                 lpImeMenuW = HeapAlloc(GetProcessHeap(), 0, dwSize);
1986             }
1987             else
1988                 lpImeMenuW = NULL;
1989
1990             rc = data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
1991                                 parent, lpImeMenuW, dwSize);
1992
1993             if (lpImeParentMenu)
1994             {
1995                 memcpy(lpImeParentMenu,&lpImeParentMenuW,sizeof(IMEMENUITEMINFOA));
1996                 lpImeParentMenu->hbmpItem = lpImeParentMenuW.hbmpItem;
1997                 WideCharToMultiByte(CP_ACP, 0, lpImeParentMenuW.szString,
1998                     -1, lpImeParentMenu->szString, IMEMENUITEM_STRING_SIZE,
1999                     NULL, NULL);
2000             }
2001             if (lpImeMenu && rc)
2002             {
2003                 int i;
2004                 for (i = 0; i < rc; i++)
2005                 {
2006                     memcpy(&lpImeMenu[i],&lpImeMenuW[1],sizeof(IMEMENUITEMINFOA));
2007                     lpImeMenu[i].hbmpItem = lpImeMenuW[i].hbmpItem;
2008                     WideCharToMultiByte(CP_ACP, 0, lpImeMenuW[i].szString,
2009                         -1, lpImeMenu[i].szString, IMEMENUITEM_STRING_SIZE,
2010                         NULL, NULL);
2011                 }
2012             }
2013             HeapFree(GetProcessHeap(),0,lpImeMenuW);
2014             return rc;
2015         }
2016     }
2017     else
2018         return 0;
2019 }
2020
2021 /***********************************************************************
2022 *               ImmGetImeMenuItemsW (IMM32.@)
2023 */
2024 DWORD WINAPI ImmGetImeMenuItemsW( HIMC hIMC, DWORD dwFlags, DWORD dwType,
2025    LPIMEMENUITEMINFOW lpImeParentMenu, LPIMEMENUITEMINFOW lpImeMenu,
2026    DWORD dwSize)
2027 {
2028     InputContextData *data = (InputContextData*)hIMC;
2029     TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC, dwFlags, dwType,
2030         lpImeParentMenu, lpImeMenu, dwSize);
2031     if (data->immKbd->hIME && data->immKbd->pImeGetImeMenuItems)
2032     {
2033         if (is_himc_ime_unicode(data) || (!lpImeParentMenu && !lpImeMenu))
2034             return data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2035                                 lpImeParentMenu, lpImeMenu, dwSize);
2036         else
2037         {
2038             IMEMENUITEMINFOA lpImeParentMenuA;
2039             IMEMENUITEMINFOA *lpImeMenuA, *parent = NULL;
2040             DWORD rc;
2041
2042             if (lpImeParentMenu)
2043                 parent = &lpImeParentMenuA;
2044             if (lpImeMenu)
2045             {
2046                 int count = dwSize / sizeof(LPIMEMENUITEMINFOW);
2047                 dwSize = count * sizeof(IMEMENUITEMINFOA);
2048                 lpImeMenuA = HeapAlloc(GetProcessHeap(), 0, dwSize);
2049             }
2050             else
2051                 lpImeMenuA = NULL;
2052
2053             rc = data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2054                                 (IMEMENUITEMINFOW*)parent,
2055                                 (IMEMENUITEMINFOW*)lpImeMenuA, dwSize);
2056
2057             if (lpImeParentMenu)
2058             {
2059                 memcpy(lpImeParentMenu,&lpImeParentMenuA,sizeof(IMEMENUITEMINFOA));
2060                 lpImeParentMenu->hbmpItem = lpImeParentMenuA.hbmpItem;
2061                 MultiByteToWideChar(CP_ACP, 0, lpImeParentMenuA.szString,
2062                     -1, lpImeParentMenu->szString, IMEMENUITEM_STRING_SIZE);
2063             }
2064             if (lpImeMenu && rc)
2065             {
2066                 int i;
2067                 for (i = 0; i < rc; i++)
2068                 {
2069                     memcpy(&lpImeMenu[i],&lpImeMenuA[1],sizeof(IMEMENUITEMINFOA));
2070                     lpImeMenu[i].hbmpItem = lpImeMenuA[i].hbmpItem;
2071                     MultiByteToWideChar(CP_ACP, 0, lpImeMenuA[i].szString,
2072                         -1, lpImeMenu[i].szString, IMEMENUITEM_STRING_SIZE);
2073                 }
2074             }
2075             HeapFree(GetProcessHeap(),0,lpImeMenuA);
2076             return rc;
2077         }
2078     }
2079     else
2080         return 0;
2081 }
2082
2083 /***********************************************************************
2084 *               ImmLockIMC(IMM32.@)
2085 */
2086 LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
2087 {
2088     InputContextData *data = (InputContextData*)hIMC;
2089
2090     if (!data)
2091         return NULL;
2092     data->dwLock++;
2093     return &data->IMC;
2094 }
2095
2096 /***********************************************************************
2097 *               ImmUnlockIMC(IMM32.@)
2098 */
2099 BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
2100 {
2101     InputContextData *data = (InputContextData*)hIMC;
2102     data->dwLock--;
2103     return (data->dwLock!=0);
2104 }
2105
2106 /***********************************************************************
2107 *               ImmGetIMCLockCount(IMM32.@)
2108 */
2109 DWORD WINAPI ImmGetIMCLockCount(HIMC hIMC)
2110 {
2111     InputContextData *data = (InputContextData*)hIMC;
2112     return data->dwLock;
2113 }
2114
2115 /***********************************************************************
2116 *               ImmCreateIMCC(IMM32.@)
2117 */
2118 HIMCC  WINAPI ImmCreateIMCC(DWORD size)
2119 {
2120     IMCCInternal *internal;
2121     int real_size = size + sizeof(IMCCInternal);
2122
2123     internal = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, real_size);
2124     if (internal == NULL)
2125         return NULL;
2126
2127     internal->dwSize = size;
2128     return  (HIMCC)internal;
2129 }
2130
2131 /***********************************************************************
2132 *       ImmDestroyIMCC(IMM32.@)
2133 */
2134 HIMCC WINAPI ImmDestroyIMCC(HIMCC block)
2135 {
2136     HeapFree(GetProcessHeap(),0,block);
2137     return NULL;
2138 }
2139
2140 /***********************************************************************
2141 *               ImmLockIMCC(IMM32.@)
2142 */
2143 LPVOID WINAPI ImmLockIMCC(HIMCC imcc)
2144 {
2145     IMCCInternal *internal;
2146     internal = (IMCCInternal*) imcc;
2147
2148     internal->dwLock ++;
2149     return internal + 1;
2150 }
2151
2152 /***********************************************************************
2153 *               ImmUnlockIMCC(IMM32.@)
2154 */
2155 BOOL WINAPI ImmUnlockIMCC(HIMCC imcc)
2156 {
2157     IMCCInternal *internal;
2158     internal = (IMCCInternal*) imcc;
2159
2160     internal->dwLock --;
2161     return (internal->dwLock!=0);
2162 }
2163
2164 /***********************************************************************
2165 *               ImmGetIMCCLockCount(IMM32.@)
2166 */
2167 DWORD WINAPI ImmGetIMCCLockCount(HIMCC imcc)
2168 {
2169     IMCCInternal *internal;
2170     internal = (IMCCInternal*) imcc;
2171
2172     return internal->dwLock;
2173 }
2174
2175 /***********************************************************************
2176 *               ImmReSizeIMCC(IMM32.@)
2177 */
2178 HIMCC  WINAPI ImmReSizeIMCC(HIMCC imcc, DWORD size)
2179 {
2180     IMCCInternal *internal,*newone;
2181     int real_size = size + sizeof(IMCCInternal);
2182
2183     internal = (IMCCInternal*) imcc;
2184
2185     newone = HeapReAlloc(GetProcessHeap(), 0, internal, real_size);
2186     newone->dwSize = size;
2187
2188     return newone;
2189 }
2190
2191 /***********************************************************************
2192 *               ImmGetIMCCSize(IMM32.@)
2193 */
2194 DWORD WINAPI ImmGetIMCCSize(HIMCC imcc)
2195 {
2196     IMCCInternal *internal;
2197     internal = (IMCCInternal*) imcc;
2198
2199     return internal->dwSize;
2200 }
2201
2202 /***********************************************************************
2203 *               ImmGenerateMessage(IMM32.@)
2204 */
2205 BOOL WINAPI ImmGenerateMessage(HIMC hIMC)
2206 {
2207     InputContextData *data = (InputContextData*)hIMC;
2208
2209     TRACE("%i messages queued\n",data->IMC.dwNumMsgBuf);
2210     if (data->IMC.dwNumMsgBuf > 0)
2211     {
2212         LPTRANSMSG lpTransMsg;
2213         INT i;
2214
2215         lpTransMsg = (LPTRANSMSG)ImmLockIMCC(data->IMC.hMsgBuf);
2216         for (i = 0; i < data->IMC.dwNumMsgBuf; i++)
2217             ImmInternalPostIMEMessage(data, lpTransMsg[i].message, lpTransMsg[i].wParam, lpTransMsg[i].lParam);
2218
2219         ImmUnlockIMCC(data->IMC.hMsgBuf);
2220
2221         data->IMC.dwNumMsgBuf = 0;
2222     }
2223
2224     return TRUE;
2225 }
2226
2227 /***********************************************************************
2228 *       ImmTranslateMessage(IMM32.@)
2229 *       ( Undocumented, call internally and from user32.dll )
2230 */
2231 BOOL WINAPI ImmTranslateMessage(HWND hwnd, UINT msg, WCHAR chr, LPARAM lKeyData)
2232 {
2233     InputContextData *data;
2234     HIMC imc = ImmGetContext(hwnd);
2235     BYTE state[256];
2236     UINT scancode;
2237     LPVOID list = 0;
2238     UINT msg_count;
2239     UINT uVirtKey;
2240     static const int list_count = 10;
2241
2242     TRACE("%p %x '%c' %x\n",hwnd, msg, chr, (UINT)lKeyData);
2243
2244     if (imc)
2245         data = (InputContextData*)imc;
2246     else
2247         return FALSE;
2248
2249     if (!data->immKbd->hIME || !data->immKbd->pImeToAsciiEx)
2250         return FALSE;
2251
2252     GetKeyboardState(state);
2253     scancode = lKeyData >> 0x10 & 0xff;
2254
2255     list = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, list_count * sizeof(TRANSMSG) + sizeof(DWORD));
2256     ((DWORD*)list)[0] = list_count;
2257
2258     if (data->immKbd->imeInfo.fdwProperty & IME_PROP_KBD_CHAR_FIRST)
2259     {
2260         if (!is_himc_ime_unicode(data))
2261             ToAscii(data->lastVK, scancode, state, &chr, 0);
2262         uVirtKey = MAKELONG(data->lastVK,chr);
2263     }
2264     else
2265         uVirtKey = data->lastVK;
2266
2267     msg_count = data->immKbd->pImeToAsciiEx(uVirtKey, scancode, state, list, 0, imc);
2268     TRACE("%i messages generated\n",msg_count);
2269     if (msg_count && msg_count <= list_count)
2270     {
2271         int i;
2272         LPTRANSMSG msgs = (LPTRANSMSG)((LPBYTE)list + sizeof(DWORD));
2273
2274         for (i = 0; i < msg_count; i++)
2275             ImmInternalPostIMEMessage(data, msgs[i].message, msgs[i].wParam, msgs[i].lParam);
2276     }
2277     else if (msg_count > list_count)
2278         ImmGenerateMessage(imc);
2279
2280     HeapFree(GetProcessHeap(),0,list);
2281
2282     return (msg_count > 0);
2283 }
2284
2285 /***********************************************************************
2286 *               ImmProcessKey(IMM32.@)
2287 *       ( Undocumented, called from user32.dll )
2288 */
2289 BOOL WINAPI ImmProcessKey(HWND hwnd, HKL hKL, UINT vKey, LPARAM lKeyData, DWORD unknown)
2290 {
2291     InputContextData *data;
2292     HIMC imc = ImmGetContext(hwnd);
2293     BYTE state[256];
2294
2295     TRACE("%p %p %x %x %x\n",hwnd, hKL, vKey, (UINT)lKeyData, unknown);
2296
2297     if (imc)
2298         data = (InputContextData*)imc;
2299     else
2300         return FALSE;
2301
2302     if (!data->immKbd->hIME || !data->immKbd->pImeProcessKey)
2303         return FALSE;
2304
2305     GetKeyboardState(state);
2306     data->lastVK = vKey;
2307
2308     if (data->immKbd->pImeProcessKey(imc, vKey, lKeyData, state))
2309     {
2310         WCHAR key;
2311         UINT scancode;
2312
2313         scancode = lKeyData >> 0x10 & 0xff;
2314         ToUnicodeEx(vKey, scancode, state, &key, 1, 0, hKL);
2315         return ImmTranslateMessage(hwnd, WM_KEYDOWN, key, lKeyData );
2316     }
2317
2318     return FALSE;
2319 }