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