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