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