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