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