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