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