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