?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
imm32: Implementation of the Imm{Get|Set}CandidateWindow.
[wine/wine64.git] / dlls / imm32 / imm.c
blob259bf3af8a16b5a2e13d49e97ca956d8f367ac75
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 #define is_himc_ime_unicode(p) (p->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE)
110 #define is_kbd_ime_unicode(p) (p->imeInfo.fdwProperty & IME_PROP_UNICODE)
111
112 static BOOL IMM_DestroyContext(HIMC hIMC);
113
114 static inline WCHAR *strdupAtoW( const char *str )
115 {
116 WCHAR *ret = NULL;
117 if (str)
118 {
119 DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
120 if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
121 MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
122 }
123 return ret;
124 }
125
126 static inline CHAR *strdupWtoA( const WCHAR *str )
127 {
128 CHAR *ret = NULL;
129 if (str)
130 {
131 DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
132 if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
133 WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
134 }
135 return ret;
136 }
137
138 static IMMThreadData* IMM_GetThreadData(void)
139 {
140 return (IMMThreadData*)TlsGetValue(tlsIndex);
141 }
142
143 static void IMM_InitThreadData(void)
144 {
145 IMMThreadData* data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
146 sizeof(IMMThreadData));
147 TlsSetValue(tlsIndex,data);
148
149 TRACE("Thread Data Created\n");
150 }
151
152 static void IMM_FreeThreadData(void)
153 {
154 IMMThreadData* data = TlsGetValue(tlsIndex);
155 IMM_DestroyContext(data->defaultContext);
156 DestroyWindow(data->hwndDefault);
157 HeapFree(GetProcessHeap(),0,data);
158 TRACE("Thread Data Destroyed\n");
159 }
160
161 static HMODULE LoadDefaultWineIME(void)
162 {
163 char buffer[MAX_PATH], libname[32], *name, *next;
164 HMODULE module = 0;
165 HKEY hkey;
166
167 TRACE("Attempting to fall back to wine default IME\n");
168
169 strcpy( buffer, "x11" ); /* default value */
170 /* @@ Wine registry key: HKCU\Software\Wine\Drivers */
171 if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Drivers", &hkey ))
172 {
173 DWORD type, count = sizeof(buffer);
174 RegQueryValueExA( hkey, "Ime", 0, &type, (LPBYTE) buffer, &count );
175 RegCloseKey( hkey );
176 }
177
178 name = buffer;
179 while (name)
180 {
181 next = strchr( name, ',' );
182 if (next) *next++ = 0;
183
184 snprintf( libname, sizeof(libname), "wine%s.drv", name );
185 if ((module = LoadLibraryA( libname )) != 0) break;
186 name = next;
187 }
188
189 return module;
190 }
191
192 /* ImmHkl loading and freeing */
193 #define LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}
194 static ImmHkl *IMM_GetImmHkl(HKL hkl)
195 {
196 ImmHkl *ptr;
197 WCHAR filename[MAX_PATH];
198
199 TRACE("Seeking ime for keyboard 0x%x\n",(unsigned)hkl);
200
201 LIST_FOR_EACH_ENTRY(ptr, &ImmHklList, ImmHkl, entry)
202 {
203 if (ptr->hkl == hkl)
204 return ptr;
205 }
206 /* not found... create it */
207
208 ptr = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ImmHkl));
209
210 ptr->hkl = hkl;
211 if (ImmGetIMEFileNameW(hkl, filename, MAX_PATH)) ptr->hIME = LoadLibraryW(filename);
212 if (!ptr->hIME)
213 ptr->hIME = LoadDefaultWineIME();
214 if (ptr->hIME)
215 {
216 LOAD_FUNCPTR(ImeInquire);
217 if (!ptr->pImeInquire || !ptr->pImeInquire(&ptr->imeInfo, ptr->imeClassName, NULL))
218 {
219 FreeLibrary(ptr->hIME);
220 ptr->hIME = NULL;
221 }
222 else
223 {
224 LOAD_FUNCPTR(ImeDestroy);
225 LOAD_FUNCPTR(ImeSelect);
226 if (!ptr->pImeSelect || !ptr->pImeDestroy)
227 {
228 FreeLibrary(ptr->hIME);
229 ptr->hIME = NULL;
230 }
231 else
232 {
233 LOAD_FUNCPTR(ImeConfigure);
234 LOAD_FUNCPTR(ImeEscape);
235 LOAD_FUNCPTR(ImeSetActiveContext);
236 LOAD_FUNCPTR(ImeToAsciiEx);
237 LOAD_FUNCPTR(NotifyIME);
238 LOAD_FUNCPTR(ImeRegisterWord);
239 LOAD_FUNCPTR(ImeUnregisterWord);
240 LOAD_FUNCPTR(ImeEnumRegisterWord);
241 LOAD_FUNCPTR(ImeSetCompositionString);
242 LOAD_FUNCPTR(ImeConversionList);
243 LOAD_FUNCPTR(ImeProcessKey);
244 LOAD_FUNCPTR(ImeGetRegisterWordStyle);
245 LOAD_FUNCPTR(ImeGetImeMenuItems);
246 /* make sure our classname is WCHAR */
247 if (!is_kbd_ime_unicode(ptr))
248 {
249 WCHAR bufW[17];
250 MultiByteToWideChar(CP_ACP, 0, (LPSTR)ptr->imeClassName,
251 -1, bufW, 17);
252 lstrcpyW(ptr->imeClassName, bufW);
253 }
254 }
255 }
256 }
257 list_add_head(&ImmHklList,&ptr->entry);
258
259 return ptr;
260 }
261 #undef LOAD_FUNCPTR
262
263 static void IMM_FreeAllImmHkl(void)
264 {
265 ImmHkl *ptr,*cursor2;
266
267 LIST_FOR_EACH_ENTRY_SAFE(ptr, cursor2, &ImmHklList, ImmHkl, entry)
268 {
269 list_remove(&ptr->entry);
270 if (ptr->hIME)
271 {
272 ptr->pImeDestroy(1);
273 FreeLibrary(ptr->hIME);
274 }
275 HeapFree(GetProcessHeap(),0,ptr);
276 }
277 }
278
279 static void IMM_RegisterMessages(void)
280 {
281 WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
282 WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
283 WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
284 WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
285 WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
286 WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
287 WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
288 }
289
290 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpReserved)
291 {
292 TRACE("%p, %x, %p\n",hInstDLL,fdwReason,lpReserved);
293 switch (fdwReason)
294 {
295 case DLL_PROCESS_ATTACH:
296 IMM_RegisterMessages();
297 tlsIndex = TlsAlloc();
298 IMM_InitThreadData();
299 break;
300 case DLL_THREAD_ATTACH:
301 IMM_InitThreadData();
302 break;
303 case DLL_THREAD_DETACH:
304 IMM_FreeThreadData();
305 break;
306 case DLL_PROCESS_DETACH:
307 IMM_FreeThreadData();
308 IMM_FreeAllImmHkl();
309 TlsFree(tlsIndex);
310 break;
311 }
312 return TRUE;
313 }
314
315 /* for posting messages as the IME */
316 static void ImmInternalPostIMEMessage(InputContextData *data, UINT msg, WPARAM wParam, LPARAM lParam)
317 {
318 HWND target = GetFocus();
319 if (!target)
320 PostMessageW(data->IMC.hWnd,msg,wParam,lParam);
321 else
322 PostMessageW(target, msg, wParam, lParam);
323 }
324
325 static LRESULT ImmInternalSendIMENotify(InputContextData *data, WPARAM notify, LPARAM lParam)
326 {
327 HWND target;
328
329 target = data->IMC.hWnd;
330 if (!target) target = GetFocus();
331
332 if (target)
333 return SendMessageW(target, WM_IME_NOTIFY, notify, lParam);
334
335 return 0;
336 }
337
338 static HIMCC ImmCreateBlankCompStr(void)
339 {
340 HIMCC rc;
341 LPCOMPOSITIONSTRING ptr;
342 rc = ImmCreateIMCC(sizeof(COMPOSITIONSTRING));
343 ptr = (LPCOMPOSITIONSTRING)ImmLockIMCC(rc);
344 memset(ptr,0,sizeof(COMPOSITIONSTRING));
345 ptr->dwSize = sizeof(COMPOSITIONSTRING);
346 ImmUnlockIMCC(rc);
347 return rc;
348 }
349
350 /***********************************************************************
351 * ImmAssociateContext (IMM32.@)
352 */
353 HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
354 {
355 HIMC old = NULL;
356 InputContextData *data = (InputContextData*)hIMC;
357
358 TRACE("(%p, %p):\n", hWnd, hIMC);
359
360 if (!IMM_GetThreadData()->defaultContext)
361 IMM_GetThreadData()->defaultContext = ImmCreateContext();
362
363 /*
364 * If already associated just return
365 */
366 if (hIMC && data->IMC.hWnd == hWnd)
367 return hIMC;
368
369 if (hWnd)
370 {
371 old = (HIMC)RemovePropW(hWnd,szwWineIMCProperty);
372
373 if (old == NULL)
374 old = IMM_GetThreadData()->defaultContext;
375 else if (old == (HIMC)-1)
376 old = NULL;
377
378 if (hIMC != IMM_GetThreadData()->defaultContext)
379 {
380 if (hIMC == NULL) /* Meaning disable imm for that window*/
381 SetPropW(hWnd,szwWineIMCProperty,(HANDLE)-1);
382 else
383 SetPropW(hWnd,szwWineIMCProperty,(HANDLE)hIMC);
384 }
385
386 if (old)
387 {
388 InputContextData *old_data = (InputContextData*)old;
389 if (old_data->IMC.hWnd == hWnd)
390 old_data->IMC.hWnd = NULL;
391 }
392 }
393
394 if (!hIMC)
395 return old;
396
397 if (IsWindow(data->IMC.hWnd))
398 {
399 /*
400 * Post a message that your context is switching
401 */
402 SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
403 }
404
405 data->IMC.hWnd = hWnd;
406
407 if (IsWindow(data->IMC.hWnd))
408 {
409 /*
410 * Post a message that your context is switching
411 */
412 SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
413 }
414
415 return old;
416 }
417
418 /***********************************************************************
419 * ImmAssociateContextEx (IMM32.@)
420 */
421 BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
422 {
423 FIXME("(%p, %p, %d): stub\n", hWnd, hIMC, dwFlags);
424 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
425 return FALSE;
426 }
427
428 /***********************************************************************
429 * ImmConfigureIMEA (IMM32.@)
430 */
431 BOOL WINAPI ImmConfigureIMEA(
432 HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
433 {
434 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
435
436 TRACE("(%p, %p, %d, %p):\n", hKL, hWnd, dwMode, lpData);
437
438 if (immHkl->hIME && immHkl->pImeConfigure)
439 {
440 if (dwMode != IME_CONFIG_REGISTERWORD || !is_kbd_ime_unicode(immHkl))
441 return immHkl->pImeConfigure(hKL,hWnd,dwMode,lpData);
442 else
443 {
444 REGISTERWORDW rww;
445 REGISTERWORDA *rwa = (REGISTERWORDA*)lpData;
446 BOOL rc;
447
448 rww.lpReading = strdupAtoW(rwa->lpReading);
449 rww.lpWord = strdupAtoW(rwa->lpWord);
450 rc = immHkl->pImeConfigure(hKL,hWnd,dwMode,&rww);
451 HeapFree(GetProcessHeap(),0,rww.lpReading);
452 HeapFree(GetProcessHeap(),0,rww.lpWord);
453 return rc;
454 }
455 }
456 else
457 return FALSE;
458 }
459
460 /***********************************************************************
461 * ImmConfigureIMEW (IMM32.@)
462 */
463 BOOL WINAPI ImmConfigureIMEW(
464 HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
465 {
466 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
467
468 TRACE("(%p, %p, %d, %p):\n", hKL, hWnd, dwMode, lpData);
469
470 if (immHkl->hIME && immHkl->pImeConfigure)
471 {
472 if (dwMode != IME_CONFIG_REGISTERWORD || is_kbd_ime_unicode(immHkl))
473 return immHkl->pImeConfigure(hKL,hWnd,dwMode,lpData);
474 else
475 {
476 REGISTERWORDW *rww = (REGISTERWORDW*)lpData;
477 REGISTERWORDA rwa;
478 BOOL rc;
479
480 rwa.lpReading = strdupWtoA(rww->lpReading);
481 rwa.lpWord = strdupWtoA(rww->lpWord);
482 rc = immHkl->pImeConfigure(hKL,hWnd,dwMode,&rwa);
483 HeapFree(GetProcessHeap(),0,rwa.lpReading);
484 HeapFree(GetProcessHeap(),0,rwa.lpWord);
485 return rc;
486 }
487 }
488 else
489 return FALSE;
490 }
491
492 /***********************************************************************
493 * ImmCreateContext (IMM32.@)
494 */
495 HIMC WINAPI ImmCreateContext(void)
496 {
497 InputContextData *new_context;
498 LPGUIDELINE gl;
499 LPCANDIDATEINFO ci;
500
501 new_context = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(InputContextData));
502
503 /* Load the IME */
504 new_context->immKbd = IMM_GetImmHkl(GetKeyboardLayout(0));
505
506 if (!new_context->immKbd->hIME)
507 {
508 TRACE("IME dll could not be loaded\n");
509 HeapFree(GetProcessHeap(),0,new_context);
510 return 0;
511 }
512
513 /* the HIMCCs are never NULL */
514 new_context->IMC.hCompStr = ImmCreateBlankCompStr();
515 new_context->IMC.hMsgBuf = ImmCreateIMCC(0);
516 new_context->IMC.hCandInfo = ImmCreateIMCC(sizeof(CANDIDATEINFO));
517 ci = ImmLockIMCC(new_context->IMC.hCandInfo);
518 memset(ci,0,sizeof(CANDIDATEINFO));
519 ci->dwSize = sizeof(CANDIDATEINFO);
520 ImmUnlockIMCC(new_context->IMC.hCandInfo);
521 new_context->IMC.hGuideLine = ImmCreateIMCC(sizeof(GUIDELINE));
522 gl = ImmLockIMCC(new_context->IMC.hGuideLine);
523 memset(gl,0,sizeof(GUIDELINE));
524 gl->dwSize = sizeof(GUIDELINE);
525 ImmUnlockIMCC(new_context->IMC.hGuideLine);
526
527 /* Initialize the IME Private */
528 new_context->IMC.hPrivate = ImmCreateIMCC(new_context->immKbd->imeInfo.dwPrivateDataSize);
529
530 if (!new_context->immKbd->pImeSelect(new_context, TRUE))
531 {
532 TRACE("Selection of IME failed\n");
533 IMM_DestroyContext(new_context);
534 return 0;
535 }
536
537 new_context->immKbd->uSelected++;
538 TRACE("Created context 0x%x\n",(UINT)new_context);
539
540 return (HIMC)new_context;
541 }
542
543 static BOOL IMM_DestroyContext(HIMC hIMC)
544 {
545 InputContextData *data = (InputContextData*)hIMC;
546
547 TRACE("Destroying %p\n",hIMC);
548
549 if (hIMC)
550 {
551 data->immKbd->uSelected --;
552 data->immKbd->pImeSelect(hIMC, FALSE);
553
554 if (IMM_GetThreadData()->hwndDefault == data->imeWnd)
555 IMM_GetThreadData()->hwndDefault = NULL;
556 DestroyWindow(data->imeWnd);
557
558 ImmDestroyIMCC(data->IMC.hCompStr);
559 ImmDestroyIMCC(data->IMC.hCandInfo);
560 ImmDestroyIMCC(data->IMC.hGuideLine);
561 ImmDestroyIMCC(data->IMC.hPrivate);
562 ImmDestroyIMCC(data->IMC.hMsgBuf);
563
564 HeapFree(GetProcessHeap(),0,data);
565 }
566 return TRUE;
567 }
568
569 /***********************************************************************
570 * ImmDestroyContext (IMM32.@)
571 */
572 BOOL WINAPI ImmDestroyContext(HIMC hIMC)
573 {
574 if (hIMC != IMM_GetThreadData()->defaultContext)
575 return IMM_DestroyContext(hIMC);
576 else
577 return FALSE;
578 }
579
580 /***********************************************************************
581 * ImmDisableIME (IMM32.@)
582 */
583 BOOL WINAPI ImmDisableIME(DWORD idThread)
584 {
585 FIXME("(%d): stub\n", idThread);
586 return TRUE;
587 }
588
589 /***********************************************************************
590 * ImmEnumRegisterWordA (IMM32.@)
591 */
592 UINT WINAPI ImmEnumRegisterWordA(
593 HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc,
594 LPCSTR lpszReading, DWORD dwStyle,
595 LPCSTR lpszRegister, LPVOID lpData)
596 {
597 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
598 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL, lpfnEnumProc,
599 debugstr_a(lpszReading), dwStyle, debugstr_a(lpszRegister), lpData);
600 if (immHkl->hIME && immHkl->pImeEnumRegisterWord)
601 {
602 if (!is_kbd_ime_unicode(immHkl))
603 return immHkl->pImeEnumRegisterWord((REGISTERWORDENUMPROCW)lpfnEnumProc,
604 (LPCWSTR)lpszReading, dwStyle, (LPCWSTR)lpszRegister, lpData);
605 else
606 {
607 FIXME("A procedure called with W ime back end\n");
608 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
609 return 0;
610 }
611 }
612 else
613 return 0;
614 }
615
616 /***********************************************************************
617 * ImmEnumRegisterWordW (IMM32.@)
618 */
619 UINT WINAPI ImmEnumRegisterWordW(
620 HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc,
621 LPCWSTR lpszReading, DWORD dwStyle,
622 LPCWSTR lpszRegister, LPVOID lpData)
623 {
624 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
625 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL, lpfnEnumProc,
626 debugstr_w(lpszReading), dwStyle, debugstr_w(lpszRegister), lpData);
627 if (immHkl->hIME && immHkl->pImeEnumRegisterWord)
628 {
629 if (is_kbd_ime_unicode(immHkl))
630 return immHkl->pImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
631 lpszRegister, lpData);
632 else
633 {
634 FIXME("W procedure called with A ime back end\n");
635 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
636 return 0;
637 }
638 }
639 else
640 return 0;
641 }
642
643 /***********************************************************************
644 * ImmEscapeA (IMM32.@)
645 */
646 LRESULT WINAPI ImmEscapeA(
647 HKL hKL, HIMC hIMC,
648 UINT uEscape, LPVOID lpData)
649 {
650 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
651 TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
652
653 if (immHkl->hIME && immHkl->pImeEscape)
654 {
655 if (!is_kbd_ime_unicode(immHkl))
656 return immHkl->pImeEscape(hIMC,uEscape,lpData);
657 else
658 {
659 FIXME("A procedure called with W ime back end\n");
660 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
661 return 0;
662 }
663 }
664 else
665 return 0;
666 }
667
668 /***********************************************************************
669 * ImmEscapeW (IMM32.@)
670 */
671 LRESULT WINAPI ImmEscapeW(
672 HKL hKL, HIMC hIMC,
673 UINT uEscape, LPVOID lpData)
674 {
675 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
676 TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
677
678 if (immHkl->hIME && immHkl->pImeEscape)
679 {
680 if (is_kbd_ime_unicode(immHkl))
681 return immHkl->pImeEscape(hIMC,uEscape,lpData);
682 else
683 {
684 FIXME("W procedure called with A ime back end\n");
685 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
686 return 0;
687 }
688 }
689 else
690 return 0;
691 }
692
693 /***********************************************************************
694 * ImmGetCandidateListA (IMM32.@)
695 */
696 DWORD WINAPI ImmGetCandidateListA(
697 HIMC hIMC, DWORD deIndex,
698 LPCANDIDATELIST lpCandList, DWORD dwBufLen)
699 {
700 FIXME("(%p, %d, %p, %d): stub\n",
701 hIMC, deIndex,
702 lpCandList, dwBufLen
703 );
704 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
705 return 0;
706 }
707
708 /***********************************************************************
709 * ImmGetCandidateListCountA (IMM32.@)
710 */
711 DWORD WINAPI ImmGetCandidateListCountA(
712 HIMC hIMC, LPDWORD lpdwListCount)
713 {
714 FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
715 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
716 return 0;
717 }
718
719 /***********************************************************************
720 * ImmGetCandidateListCountW (IMM32.@)
721 */
722 DWORD WINAPI ImmGetCandidateListCountW(
723 HIMC hIMC, LPDWORD lpdwListCount)
724 {
725 FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
726 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
727 return 0;
728 }
729
730 /***********************************************************************
731 * ImmGetCandidateListW (IMM32.@)
732 */
733 DWORD WINAPI ImmGetCandidateListW(
734 HIMC hIMC, DWORD deIndex,
735 LPCANDIDATELIST lpCandList, DWORD dwBufLen)
736 {
737 FIXME("(%p, %d, %p, %d): stub\n",
738 hIMC, deIndex,
739 lpCandList, dwBufLen
740 );
741 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
742 return 0;
743 }
744
745 /***********************************************************************
746 * ImmGetCandidateWindow (IMM32.@)
747 */
748 BOOL WINAPI ImmGetCandidateWindow(
749 HIMC hIMC, DWORD dwIndex, LPCANDIDATEFORM lpCandidate)
750 {
751 InputContextData *data = (InputContextData*)hIMC;
752
753 TRACE("%p, %d, %p\n", hIMC, dwIndex, lpCandidate);
754
755 if (!data || !lpCandidate)
756 return FALSE;
757
758 if ( dwIndex >= (sizeof(data->IMC.cfCandForm) / sizeof(CANDIDATEFORM)) )
759 return FALSE;
760
761 *lpCandidate = data->IMC.cfCandForm[dwIndex];
762
763 return TRUE;
764 }
765
766 /***********************************************************************
767 * ImmGetCompositionFontA (IMM32.@)
768 */
769 BOOL WINAPI ImmGetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
770 {
771 LOGFONTW lfW;
772 BOOL rc;
773
774 TRACE("(%p, %p):\n", hIMC, lplf);
775
776 rc = ImmGetCompositionFontW(hIMC,&lfW);
777 if (rc)
778 {
779 memcpy(lplf,&lfW,sizeof(LOGFONTA));
780 WideCharToMultiByte(CP_ACP, 0, lfW.lfFaceName, -1, lplf->lfFaceName,
781 LF_FACESIZE, NULL, NULL);
782 }
783 return rc;
784 }
785
786 /***********************************************************************
787 * ImmGetCompositionFontW (IMM32.@)
788 */
789 BOOL WINAPI ImmGetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
790 {
791 InputContextData *data = (InputContextData*)hIMC;
792
793 TRACE("(%p, %p):\n", hIMC, lplf);
794
795 if (!data)
796 return FALSE;
797
798 *lplf = data->IMC.lfFont.W;
799
800 return TRUE;
801 }
802
803 /***********************************************************************
804 * ImmGetCompositionStringA (IMM32.@)
805 */
806 LONG WINAPI ImmGetCompositionStringA(
807 HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
808 {
809 CHAR *buf;
810 LONG rc = 0;
811 InputContextData *data = (InputContextData*)hIMC;
812 LPCOMPOSITIONSTRING compstr;
813 LPBYTE compdata;
814
815 TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
816
817 if (!data)
818 return FALSE;
819
820 if (!data->IMC.hCompStr)
821 return FALSE;
822
823 compdata = ImmLockIMCC(data->IMC.hCompStr);
824 compstr = (LPCOMPOSITIONSTRING)compdata;
825
826 if (dwIndex == GCS_RESULTSTR && compstr->dwResultStrLen > 0 &&
827 compstr->dwResultStrOffset > 0)
828 {
829 LPWSTR ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
830
831 TRACE("GCS_RESULTSTR %p %i\n",ResultStr,
832 compstr->dwResultStrLen);
833
834 buf = HeapAlloc( GetProcessHeap(), 0, compstr->dwResultStrLen * 3 );
835 rc = WideCharToMultiByte(CP_ACP, 0, ResultStr,
836 compstr->dwResultStrLen , buf,
837 compstr->dwResultStrLen * 3, NULL, NULL);
838 if (dwBufLen >= rc)
839 memcpy(lpBuf,buf,rc);
840
841 HeapFree( GetProcessHeap(), 0, buf );
842 }
843 else if (dwIndex == GCS_COMPSTR && compstr->dwCompStrLen > 0 &&
844 compstr->dwCompStrOffset > 0)
845 {
846 LPWSTR CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
847
848 TRACE("GCS_COMPSTR %p %i\n", CompString, compstr->dwCompStrLen);
849
850 buf = HeapAlloc( GetProcessHeap(), 0, compstr->dwCompStrLen * 3 );
851 rc = WideCharToMultiByte(CP_ACP, 0, CompString,
852 compstr->dwCompStrLen, buf,
853 compstr->dwCompStrLen * 3, NULL, NULL);
854 if (dwBufLen >= rc)
855 memcpy(lpBuf,buf,rc);
856 HeapFree( GetProcessHeap(), 0, buf );
857 }
858 else if (dwIndex == GCS_COMPATTR && compstr->dwCompAttrLen > 0 &&
859 compstr->dwCompAttrOffset > 0)
860 {
861 LPWSTR Compattr = (LPWSTR)(compdata + compstr->dwCompAttrOffset);
862 TRACE("GCS_COMPATTR %p %i\n", Compattr , compstr->dwCompAttrLen);
863
864 rc = compstr->dwCompAttrLen;
865 if (dwBufLen >= rc)
866 memcpy(lpBuf,Compattr,rc);
867 }
868 else if (dwIndex == GCS_COMPCLAUSE && compstr->dwCompClauseLen > 0 &&
869 compstr->dwCompClauseOffset > 0)
870 {
871 LPWSTR Compclause = (LPWSTR)(compdata + compstr->dwCompClauseOffset);
872 TRACE("GCS_COMPCLAUSE %p %i\n", Compclause, compstr->dwCompClauseLen);
873
874 rc = compstr->dwCompClauseLen;
875 if (dwBufLen >= compstr->dwCompClauseLen)
876 memcpy(lpBuf,Compclause,rc);
877 }
878 else if (dwIndex == GCS_RESULTCLAUSE && compstr->dwResultClauseLen > 0 &&
879 compstr->dwResultClauseOffset > 0)
880 {
881 LPWSTR Resultclause = (LPWSTR)(compdata + compstr->dwResultClauseOffset);
882 TRACE("GCS_RESULTCLAUSE %p %i\n", Resultclause, compstr->dwResultClauseLen);
883
884 rc = compstr->dwResultClauseLen;
885 if (dwBufLen >= compstr->dwResultClauseLen)
886 memcpy(lpBuf,Resultclause,rc);
887 }
888 else if (dwIndex == GCS_CURSORPOS)
889 {
890 TRACE("GCS_CURSORPOS\n");
891 rc = compstr->dwCursorPos;
892 }
893 else if (dwIndex == GCS_DELTASTART)
894 {
895 TRACE("GCS_DELTASTART\n");
896 rc = compstr->dwDeltaStart;
897 }
898 else
899 {
900 FIXME("Unhandled index 0x%x\n",dwIndex);
901 }
902
903 ImmUnlockIMCC(data->IMC.hCompStr);
904
905 return rc;
906 }
907
908 /***********************************************************************
909 * ImmGetCompositionStringW (IMM32.@)
910 */
911 LONG WINAPI ImmGetCompositionStringW(
912 HIMC hIMC, DWORD dwIndex,
913 LPVOID lpBuf, DWORD dwBufLen)
914 {
915 LONG rc = 0;
916 InputContextData *data = (InputContextData*)hIMC;
917 LPCOMPOSITIONSTRING compstr;
918 LPBYTE compdata;
919
920 TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
921
922 if (!data)
923 return FALSE;
924
925 if (!data->IMC.hCompStr)
926 return FALSE;
927
928 compdata = ImmLockIMCC(data->IMC.hCompStr);
929 compstr = (LPCOMPOSITIONSTRING)compdata;
930
931 if (dwIndex == GCS_RESULTSTR && compstr->dwResultStrLen > 0 &&
932 compstr->dwResultStrOffset > 0)
933 {
934 LPWSTR ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
935 rc = compstr->dwResultStrLen * sizeof(WCHAR);
936
937 if (dwBufLen >= rc)
938 memcpy(lpBuf,ResultStr,rc);
939 }
940 else if (dwIndex == GCS_RESULTREADSTR && compstr->dwResultReadStrLen > 0 &&
941 compstr->dwResultReadStrOffset > 0)
942 {
943 LPWSTR ResultReadString = (LPWSTR)(compdata + compstr->dwResultReadStrOffset);
944
945 rc = compstr->dwResultReadStrLen * sizeof(WCHAR);
946 if (dwBufLen >= rc)
947 memcpy(lpBuf,ResultReadString,rc);
948 }
949 else if (dwIndex == GCS_COMPSTR && compstr->dwCompStrLen > 0 &&
950 compstr->dwCompStrOffset > 0)
951 {
952 LPWSTR CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
953 rc = compstr->dwCompStrLen * sizeof(WCHAR);
954 if (dwBufLen >= rc)
955 memcpy(lpBuf,CompString,rc);
956 }
957 else if (dwIndex == GCS_COMPATTR && compstr->dwCompAttrLen > 0 &&
958 compstr->dwCompAttrOffset > 0)
959 {
960
961 LPWSTR Compattr = (LPWSTR)(compdata + compstr->dwCompAttrOffset);
962
963 rc = compstr->dwCompAttrLen;
964 if (dwBufLen >= rc)
965 memcpy(lpBuf,Compattr,rc);
966 }
967 else if (dwIndex == GCS_COMPCLAUSE && compstr->dwCompClauseLen > 0 &&
968 compstr->dwCompClauseOffset > 0)
969 {
970 LPWSTR Compclause = (LPWSTR)(compdata + compstr->dwCompClauseOffset);
971
972 rc = compstr->dwCompClauseLen;
973 if (dwBufLen >= compstr->dwCompClauseLen)
974 memcpy(lpBuf,Compclause,rc);
975 }
976 else if (dwIndex == GCS_COMPREADSTR && compstr->dwCompReadStrLen > 0 &&
977 compstr->dwCompReadStrOffset > 0)
978 {
979 LPWSTR CompReadString = (LPWSTR)(compdata + compstr->dwCompReadStrOffset);
980
981 rc = compstr->dwCompReadStrLen * sizeof(WCHAR);
982
983 if (dwBufLen >= rc)
984 memcpy(lpBuf,CompReadString,rc);
985 }
986 else if (dwIndex == GCS_CURSORPOS)
987 {
988 TRACE("GCS_CURSORPOS\n");
989 rc = compstr->dwCursorPos;
990 }
991 else if (dwIndex == GCS_DELTASTART)
992 {
993 TRACE("GCS_DELTASTART\n");
994 rc = compstr->dwDeltaStart;
995 }
996 else
997 {
998 FIXME("Unhandled index 0x%x\n",dwIndex);
999 }
1000
1001 ImmUnlockIMCC(data->IMC.hCompStr);
1002
1003 return rc;
1004 }
1005
1006 /***********************************************************************
1007 * ImmGetCompositionWindow (IMM32.@)
1008 */
1009 BOOL WINAPI ImmGetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
1010 {
1011 InputContextData *data = (InputContextData*)hIMC;
1012
1013 TRACE("(%p, %p)\n", hIMC, lpCompForm);
1014
1015 if (!data)
1016 return FALSE;
1017
1018 *lpCompForm = data->IMC.cfCompForm;
1019 return 1;
1020 }
1021
1022 /***********************************************************************
1023 * ImmGetContext (IMM32.@)
1024 *
1025 */
1026 HIMC WINAPI ImmGetContext(HWND hWnd)
1027 {
1028 HIMC rc = NULL;
1029
1030 TRACE("%p\n", hWnd);
1031 if (!IMM_GetThreadData()->defaultContext)
1032 IMM_GetThreadData()->defaultContext = ImmCreateContext();
1033
1034 rc = (HIMC)GetPropW(hWnd,szwWineIMCProperty);
1035 if (rc == (HIMC)-1)
1036 rc = NULL;
1037 else if (rc == NULL)
1038 rc = IMM_GetThreadData()->defaultContext;
1039
1040 if (rc)
1041 {
1042 InputContextData *data = (InputContextData*)rc;
1043 data->IMC.hWnd = hWnd;
1044 }
1045 TRACE("returning %p\n", rc);
1046
1047 return rc;
1048 }
1049
1050 /***********************************************************************
1051 * ImmGetConversionListA (IMM32.@)
1052 */
1053 DWORD WINAPI ImmGetConversionListA(
1054 HKL hKL, HIMC hIMC,
1055 LPCSTR pSrc, LPCANDIDATELIST lpDst,
1056 DWORD dwBufLen, UINT uFlag)
1057 {
1058 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1059 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL, hIMC, debugstr_a(pSrc), lpDst,
1060 dwBufLen, uFlag);
1061 if (immHkl->hIME && immHkl->pImeConversionList)
1062 {
1063 if (!is_kbd_ime_unicode(immHkl))
1064 return immHkl->pImeConversionList(hIMC,(LPCWSTR)pSrc,lpDst,dwBufLen,uFlag);
1065 else
1066 {
1067 FIXME("A procedure called with W ime back end\n");
1068 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1069 return 0;
1070 }
1071 }
1072 else
1073 return 0;
1074 }
1075
1076 /***********************************************************************
1077 * ImmGetConversionListW (IMM32.@)
1078 */
1079 DWORD WINAPI ImmGetConversionListW(
1080 HKL hKL, HIMC hIMC,
1081 LPCWSTR pSrc, LPCANDIDATELIST lpDst,
1082 DWORD dwBufLen, UINT uFlag)
1083 {
1084 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1085 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL, hIMC, debugstr_w(pSrc), lpDst,
1086 dwBufLen, uFlag);
1087 if (immHkl->hIME && immHkl->pImeConversionList)
1088 {
1089 if (is_kbd_ime_unicode(immHkl))
1090 return immHkl->pImeConversionList(hIMC,pSrc,lpDst,dwBufLen,uFlag);
1091 else
1092 {
1093 FIXME("W procedure called with A ime back end\n");
1094 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1095 return 0;
1096 }
1097 }
1098 else
1099 return 0;
1100 }
1101
1102 /***********************************************************************
1103 * ImmGetConversionStatus (IMM32.@)
1104 */
1105 BOOL WINAPI ImmGetConversionStatus(
1106 HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)
1107 {
1108 InputContextData *data = (InputContextData*)hIMC;
1109
1110 TRACE("%p %p %p\n", hIMC, lpfdwConversion, lpfdwSentence);
1111
1112 if (!data)
1113 return FALSE;
1114
1115 if (lpfdwConversion)
1116 *lpfdwConversion = data->IMC.fdwConversion;
1117 if (lpfdwSentence)
1118 *lpfdwSentence = data->IMC.fdwSentence;
1119
1120 return TRUE;
1121 }
1122
1123 /***********************************************************************
1124 * ImmGetDefaultIMEWnd (IMM32.@)
1125 */
1126 HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
1127 {
1128 TRACE("Default is %x\n",(unsigned)IMM_GetThreadData()->hwndDefault);
1129 return IMM_GetThreadData()->hwndDefault;
1130 }
1131
1132 /***********************************************************************
1133 * ImmGetDescriptionA (IMM32.@)
1134 */
1135 UINT WINAPI ImmGetDescriptionA(
1136 HKL hKL, LPSTR lpszDescription, UINT uBufLen)
1137 {
1138 WCHAR *buf;
1139 DWORD len;
1140
1141 TRACE("%p %p %d\n", hKL, lpszDescription, uBufLen);
1142
1143 /* find out how many characters in the unicode buffer */
1144 len = ImmGetDescriptionW( hKL, NULL, 0 );
1145
1146 /* allocate a buffer of that size */
1147 buf = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof (WCHAR) );
1148 if( !buf )
1149 return 0;
1150
1151 /* fetch the unicode buffer */
1152 len = ImmGetDescriptionW( hKL, buf, len + 1 );
1153
1154 /* convert it back to ASCII */
1155 len = WideCharToMultiByte( CP_ACP, 0, buf, len + 1,
1156 lpszDescription, uBufLen, NULL, NULL );
1157
1158 HeapFree( GetProcessHeap(), 0, buf );
1159
1160 return len;
1161 }
1162
1163 /***********************************************************************
1164 * ImmGetDescriptionW (IMM32.@)
1165 */
1166 UINT WINAPI ImmGetDescriptionW(HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
1167 {
1168 static const WCHAR name[] = { 'W','i','n','e',' ','X','I','M',0 };
1169
1170 FIXME("(%p, %p, %d): semi stub\n", hKL, lpszDescription, uBufLen);
1171
1172 if (!uBufLen) return lstrlenW( name );
1173 lstrcpynW( lpszDescription, name, uBufLen );
1174 return lstrlenW( lpszDescription );
1175 }
1176
1177 /***********************************************************************
1178 * ImmGetGuideLineA (IMM32.@)
1179 */
1180 DWORD WINAPI ImmGetGuideLineA(
1181 HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)
1182 {
1183 FIXME("(%p, %d, %s, %d): stub\n",
1184 hIMC, dwIndex, debugstr_a(lpBuf), dwBufLen
1185 );
1186 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1187 return 0;
1188 }
1189
1190 /***********************************************************************
1191 * ImmGetGuideLineW (IMM32.@)
1192 */
1193 DWORD WINAPI ImmGetGuideLineW(HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)
1194 {
1195 FIXME("(%p, %d, %s, %d): stub\n",
1196 hIMC, dwIndex, debugstr_w(lpBuf), dwBufLen
1197 );
1198 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1199 return 0;
1200 }
1201
1202 /***********************************************************************
1203 * ImmGetIMEFileNameA (IMM32.@)
1204 */
1205 UINT WINAPI ImmGetIMEFileNameA( HKL hKL, LPSTR lpszFileName, UINT uBufLen)
1206 {
1207 LPWSTR bufW = NULL;
1208 UINT wBufLen = uBufLen;
1209 UINT rc;
1210
1211 if (uBufLen && lpszFileName)
1212 bufW = HeapAlloc(GetProcessHeap(),0,uBufLen * sizeof(WCHAR));
1213 else /* We need this to get the number of byte required */
1214 {
1215 bufW = HeapAlloc(GetProcessHeap(),0,MAX_PATH * sizeof(WCHAR));
1216 wBufLen = MAX_PATH;
1217 }
1218
1219 rc = ImmGetIMEFileNameW(hKL,bufW,wBufLen);
1220
1221 if (rc > 0)
1222 {
1223 if (uBufLen && lpszFileName)
1224 rc = WideCharToMultiByte(CP_ACP, 0, bufW, -1, lpszFileName,
1225 uBufLen, NULL, NULL);
1226 else /* get the length */
1227 rc = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL,
1228 NULL);
1229 }
1230
1231 HeapFree(GetProcessHeap(),0,bufW);
1232 return rc;
1233 }
1234
1235 /***********************************************************************
1236 * ImmGetIMEFileNameW (IMM32.@)
1237 */
1238 UINT WINAPI ImmGetIMEFileNameW(HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
1239 {
1240 static const WCHAR szImeFileW[] = {'I','m','e',' ','F','i','l','e',0};
1241 static const WCHAR fmt[] = {'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','x',0};
1242
1243 HKEY hkey;
1244 DWORD length;
1245 DWORD rc;
1246 WCHAR regKey[sizeof(fmt)/sizeof(WCHAR)+8];
1247
1248 wsprintfW( regKey, fmt, (unsigned)hKL );
1249 rc = RegOpenKeyW( HKEY_LOCAL_MACHINE, regKey, &hkey);
1250 if (rc != ERROR_SUCCESS)
1251 {
1252 SetLastError(rc);
1253 return 0;
1254 }
1255
1256 length = 0;
1257 rc = RegGetValueW(hkey, NULL, szImeFileW, RRF_RT_REG_SZ, NULL, NULL, &length);
1258
1259 if (rc != ERROR_SUCCESS)
1260 {
1261 RegCloseKey(hkey);
1262 SetLastError(rc);
1263 return 0;
1264 }
1265 if (length > uBufLen * sizeof(WCHAR) || !lpszFileName)
1266 {
1267 RegCloseKey(hkey);
1268 if (lpszFileName)
1269 {
1270 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1271 return 0;
1272 }
1273 else
1274 return length / sizeof(WCHAR);
1275 }
1276
1277 RegGetValueW(hkey, NULL, szImeFileW, RRF_RT_REG_SZ, NULL, lpszFileName, &length);
1278
1279 RegCloseKey(hkey);
1280
1281 return length / sizeof(WCHAR);
1282 }
1283
1284 /***********************************************************************
1285 * ImmGetOpenStatus (IMM32.@)
1286 */
1287 BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
1288 {
1289 InputContextData *data = (InputContextData*)hIMC;
1290
1291 if (!data)
1292 return FALSE;
1293 FIXME("(%p): semi-stub\n", hIMC);
1294
1295 return data->IMC.fOpen;
1296 }
1297
1298 /***********************************************************************
1299 * ImmGetProperty (IMM32.@)
1300 */
1301 DWORD WINAPI ImmGetProperty(HKL hKL, DWORD fdwIndex)
1302 {
1303 DWORD rc = 0;
1304 ImmHkl *kbd;
1305
1306 TRACE("(%p, %d)\n", hKL, fdwIndex);
1307 kbd = IMM_GetImmHkl(hKL);
1308
1309 if (kbd && kbd->hIME)
1310 {
1311 switch (fdwIndex)
1312 {
1313 case IGP_PROPERTY: rc = kbd->imeInfo.fdwProperty; break;
1314 case IGP_CONVERSION: rc = kbd->imeInfo.fdwConversionCaps; break;
1315 case IGP_SENTENCE: rc = kbd->imeInfo.fdwSentenceCaps; break;
1316 case IGP_SETCOMPSTR: rc = kbd->imeInfo.fdwSCSCaps; break;
1317 case IGP_SELECT: rc = kbd->imeInfo.fdwSelectCaps; break;
1318 case IGP_GETIMEVERSION: rc = IMEVER_0400; break;
1319 case IGP_UI: rc = 0; break;
1320 default: rc = 0;
1321 }
1322 }
1323 return rc;
1324 }
1325
1326 /***********************************************************************
1327 * ImmGetRegisterWordStyleA (IMM32.@)
1328 */
1329 UINT WINAPI ImmGetRegisterWordStyleA(
1330 HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
1331 {
1332 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1333 TRACE("(%p, %d, %p):\n", hKL, nItem, lpStyleBuf);
1334 if (immHkl->hIME && immHkl->pImeGetRegisterWordStyle)
1335 {
1336 if (!is_kbd_ime_unicode(immHkl))
1337 return immHkl->pImeGetRegisterWordStyle(nItem,(LPSTYLEBUFW)lpStyleBuf);
1338 else
1339 {
1340 STYLEBUFW sbw;
1341 UINT rc;
1342
1343 rc = immHkl->pImeGetRegisterWordStyle(nItem,&sbw);
1344 WideCharToMultiByte(CP_ACP, 0, sbw.szDescription, -1,
1345 lpStyleBuf->szDescription, 32, NULL, NULL);
1346 lpStyleBuf->dwStyle = sbw.dwStyle;
1347 return rc;
1348 }
1349 }
1350 else
1351 return 0;
1352 }
1353
1354 /***********************************************************************
1355 * ImmGetRegisterWordStyleW (IMM32.@)
1356 */
1357 UINT WINAPI ImmGetRegisterWordStyleW(
1358 HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
1359 {
1360 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1361 TRACE("(%p, %d, %p):\n", hKL, nItem, lpStyleBuf);
1362 if (immHkl->hIME && immHkl->pImeGetRegisterWordStyle)
1363 {
1364 if (is_kbd_ime_unicode(immHkl))
1365 return immHkl->pImeGetRegisterWordStyle(nItem,lpStyleBuf);
1366 else
1367 {
1368 STYLEBUFA sba;
1369 UINT rc;
1370
1371 rc = immHkl->pImeGetRegisterWordStyle(nItem,(LPSTYLEBUFW)&sba);
1372 MultiByteToWideChar(CP_ACP, 0, sba.szDescription, -1,
1373 lpStyleBuf->szDescription, 32);
1374 lpStyleBuf->dwStyle = sba.dwStyle;
1375 return rc;
1376 }
1377 }
1378 else
1379 return 0;
1380 }
1381
1382 /***********************************************************************
1383 * ImmGetStatusWindowPos (IMM32.@)
1384 */
1385 BOOL WINAPI ImmGetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1386 {
1387 FIXME("(%p, %p): stub\n", hIMC, lpptPos);
1388 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1389 return FALSE;
1390 }
1391
1392 /***********************************************************************
1393 * ImmGetVirtualKey (IMM32.@)
1394 */
1395 UINT WINAPI ImmGetVirtualKey(HWND hWnd)
1396 {
1397 OSVERSIONINFOA version;
1398 InputContextData *data = (InputContextData *)ImmGetContext( hWnd );
1399 TRACE("%p\n", hWnd);
1400
1401 if ( data )
1402 return data->lastVK;
1403
1404 GetVersionExA( &version );
1405 switch(version.dwPlatformId)
1406 {
1407 case VER_PLATFORM_WIN32_WINDOWS:
1408 return VK_PROCESSKEY;
1409 case VER_PLATFORM_WIN32_NT:
1410 return 0;
1411 default:
1412 FIXME("%d not supported\n",version.dwPlatformId);
1413 return VK_PROCESSKEY;
1414 }
1415 }
1416
1417 /***********************************************************************
1418 * ImmInstallIMEA (IMM32.@)
1419 */
1420 HKL WINAPI ImmInstallIMEA(
1421 LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
1422 {
1423 FIXME("(%s, %s): stub\n",
1424 debugstr_a(lpszIMEFileName), debugstr_a(lpszLayoutText)
1425 );
1426 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1427 return NULL;
1428 }
1429
1430 /***********************************************************************
1431 * ImmInstallIMEW (IMM32.@)
1432 */
1433 HKL WINAPI ImmInstallIMEW(
1434 LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
1435 {
1436 FIXME("(%s, %s): stub\n",
1437 debugstr_w(lpszIMEFileName), debugstr_w(lpszLayoutText)
1438 );
1439 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1440 return NULL;
1441 }
1442
1443 /***********************************************************************
1444 * ImmIsIME (IMM32.@)
1445 */
1446 BOOL WINAPI ImmIsIME(HKL hKL)
1447 {
1448 ImmHkl *ptr;
1449 TRACE("(%p):\n", hKL);
1450 ptr = IMM_GetImmHkl(hKL);
1451 return (ptr && ptr->hIME);
1452 }
1453
1454 /***********************************************************************
1455 * ImmIsUIMessageA (IMM32.@)
1456 */
1457 BOOL WINAPI ImmIsUIMessageA(
1458 HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1459 {
1460 BOOL rc = FALSE;
1461
1462 TRACE("(%p, %x, %ld, %ld)\n", hWndIME, msg, wParam, lParam);
1463 if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1464 (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1465 (msg == WM_MSIME_SERVICE) ||
1466 (msg == WM_MSIME_RECONVERTOPTIONS) ||
1467 (msg == WM_MSIME_MOUSE) ||
1468 (msg == WM_MSIME_RECONVERTREQUEST) ||
1469 (msg == WM_MSIME_RECONVERT) ||
1470 (msg == WM_MSIME_QUERYPOSITION) ||
1471 (msg == WM_MSIME_DOCUMENTFEED))
1472
1473 {
1474 if (!IMM_GetThreadData()->hwndDefault)
1475 ImmGetDefaultIMEWnd(NULL);
1476
1477 if (hWndIME == NULL)
1478 PostMessageA(IMM_GetThreadData()->hwndDefault, msg, wParam, lParam);
1479
1480 rc = TRUE;
1481 }
1482 return rc;
1483 }
1484
1485 /***********************************************************************
1486 * ImmIsUIMessageW (IMM32.@)
1487 */
1488 BOOL WINAPI ImmIsUIMessageW(
1489 HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1490 {
1491 BOOL rc = FALSE;
1492 TRACE("(%p, %d, %ld, %ld):\n", hWndIME, msg, wParam, lParam);
1493 if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1494 (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1495 (msg == WM_MSIME_SERVICE) ||
1496 (msg == WM_MSIME_RECONVERTOPTIONS) ||
1497 (msg == WM_MSIME_MOUSE) ||
1498 (msg == WM_MSIME_RECONVERTREQUEST) ||
1499 (msg == WM_MSIME_RECONVERT) ||
1500 (msg == WM_MSIME_QUERYPOSITION) ||
1501 (msg == WM_MSIME_DOCUMENTFEED))
1502 rc = TRUE;
1503 return rc;
1504 }
1505
1506 /***********************************************************************
1507 * ImmNotifyIME (IMM32.@)
1508 */
1509 BOOL WINAPI ImmNotifyIME(
1510 HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
1511 {
1512 InputContextData *data = (InputContextData*)hIMC;
1513
1514 TRACE("(%p, %d, %d, %d)\n",
1515 hIMC, dwAction, dwIndex, dwValue);
1516
1517 if (!data || ! data->immKbd->pNotifyIME)
1518 return FALSE;
1519
1520 return data->immKbd->pNotifyIME(hIMC,dwAction,dwIndex,dwValue);
1521 }
1522
1523 /***********************************************************************
1524 * ImmRegisterWordA (IMM32.@)
1525 */
1526 BOOL WINAPI ImmRegisterWordA(
1527 HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
1528 {
1529 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1530 TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_a(lpszReading), dwStyle,
1531 debugstr_a(lpszRegister));
1532 if (immHkl->hIME && immHkl->pImeRegisterWord)
1533 {
1534 if (!is_kbd_ime_unicode(immHkl))
1535 return immHkl->pImeRegisterWord((LPCWSTR)lpszReading,dwStyle,
1536 (LPCWSTR)lpszRegister);
1537 else
1538 {
1539 LPWSTR lpszwReading = strdupAtoW(lpszReading);
1540 LPWSTR lpszwRegister = strdupAtoW(lpszRegister);
1541 BOOL rc;
1542
1543 rc = immHkl->pImeRegisterWord(lpszwReading,dwStyle,lpszwRegister);
1544 HeapFree(GetProcessHeap(),0,lpszwReading);
1545 HeapFree(GetProcessHeap(),0,lpszwRegister);
1546 return rc;
1547 }
1548 }
1549 else
1550 return FALSE;
1551 }
1552
1553 /***********************************************************************
1554 * ImmRegisterWordW (IMM32.@)
1555 */
1556 BOOL WINAPI ImmRegisterWordW(
1557 HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
1558 {
1559 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1560 TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_w(lpszReading), dwStyle,
1561 debugstr_w(lpszRegister));
1562 if (immHkl->hIME && immHkl->pImeRegisterWord)
1563 {
1564 if (is_kbd_ime_unicode(immHkl))
1565 return immHkl->pImeRegisterWord(lpszReading,dwStyle,lpszRegister);
1566 else
1567 {
1568 LPSTR lpszaReading = strdupWtoA(lpszReading);
1569 LPSTR lpszaRegister = strdupWtoA(lpszRegister);
1570 BOOL rc;
1571
1572 rc = immHkl->pImeRegisterWord((LPCWSTR)lpszaReading,dwStyle,
1573 (LPCWSTR)lpszaRegister);
1574 HeapFree(GetProcessHeap(),0,lpszaReading);
1575 HeapFree(GetProcessHeap(),0,lpszaRegister);
1576 return rc;
1577 }
1578 }
1579 else
1580 return FALSE;
1581 }
1582
1583 /***********************************************************************
1584 * ImmReleaseContext (IMM32.@)
1585 */
1586 BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
1587 {
1588 static int shown = 0;
1589
1590 if (!shown) {
1591 FIXME("(%p, %p): stub\n", hWnd, hIMC);
1592 shown = 1;
1593 }
1594 return TRUE;
1595 }
1596
1597 /***********************************************************************
1598 * ImmRequestMessageA(IMM32.@)
1599 */
1600 LRESULT WINAPI ImmRequestMessageA(HIMC hIMC, WPARAM wParam, LPARAM lParam)
1601 {
1602 FIXME("(%p %ld %ld): stub\n", hIMC, wParam, wParam);
1603 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1604 return 0;
1605 }
1606
1607 /***********************************************************************
1608 * ImmRequestMessageW(IMM32.@)
1609 */
1610 LRESULT WINAPI ImmRequestMessageW(HIMC hIMC, WPARAM wParam, LPARAM lParam)
1611 {
1612 FIXME("(%p %ld %ld): stub\n", hIMC, wParam, wParam);
1613 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1614 return 0;
1615 }
1616
1617 /***********************************************************************
1618 * ImmSetCandidateWindow (IMM32.@)
1619 */
1620 BOOL WINAPI ImmSetCandidateWindow(
1621 HIMC hIMC, LPCANDIDATEFORM lpCandidate)
1622 {
1623 InputContextData *data = (InputContextData*)hIMC;
1624
1625 TRACE("(%p, %p)\n", hIMC, lpCandidate);
1626
1627 if (!data || !lpCandidate)
1628 return FALSE;
1629
1630 TRACE("\t%x, %x, (%i,%i), (%i,%i - %i,%i)\n",
1631 lpCandidate->dwIndex, lpCandidate->dwStyle,
1632 lpCandidate->ptCurrentPos.x, lpCandidate->ptCurrentPos.y,
1633 lpCandidate->rcArea.top, lpCandidate->rcArea.left,
1634 lpCandidate->rcArea.bottom, lpCandidate->rcArea.right);
1635
1636 if ( lpCandidate->dwIndex >= (sizeof(data->IMC.cfCandForm) / sizeof(CANDIDATEFORM)) )
1637 return FALSE;
1638
1639 data->IMC.cfCandForm[lpCandidate->dwIndex] = *lpCandidate;
1640 ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, 0, IMC_SETCANDIDATEPOS);
1641 ImmInternalSendIMENotify(data, IMN_SETCANDIDATEPOS, 1 << lpCandidate->dwIndex);
1642
1643 return TRUE;
1644 }
1645
1646 /***********************************************************************
1647 * ImmSetCompositionFontA (IMM32.@)
1648 */
1649 BOOL WINAPI ImmSetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
1650 {
1651 InputContextData *data = (InputContextData*)hIMC;
1652 TRACE("(%p, %p)\n", hIMC, lplf);
1653
1654 if (!data)
1655 return FALSE;
1656
1657 memcpy(&data->IMC.lfFont.W,lplf,sizeof(LOGFONTA));
1658 MultiByteToWideChar(CP_ACP, 0, lplf->lfFaceName, -1, data->IMC.lfFont.W.lfFaceName,
1659 LF_FACESIZE);
1660 ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONFONT, 0);
1661
1662 return TRUE;
1663 }
1664
1665 /***********************************************************************
1666 * ImmSetCompositionFontW (IMM32.@)
1667 */
1668 BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
1669 {
1670 InputContextData *data = (InputContextData*)hIMC;
1671 TRACE("(%p, %p)\n", hIMC, lplf);
1672
1673 if (!data)
1674 return FALSE;
1675
1676 data->IMC.lfFont.W = *lplf;
1677 ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONFONT, 0);
1678
1679 return TRUE;
1680 }
1681
1682 /***********************************************************************
1683 * ImmSetCompositionStringA (IMM32.@)
1684 */
1685 BOOL WINAPI ImmSetCompositionStringA(
1686 HIMC hIMC, DWORD dwIndex,
1687 LPCVOID lpComp, DWORD dwCompLen,
1688 LPCVOID lpRead, DWORD dwReadLen)
1689 {
1690 DWORD comp_len;
1691 DWORD read_len;
1692 WCHAR *CompBuffer = NULL;
1693 WCHAR *ReadBuffer = NULL;
1694 BOOL rc;
1695 InputContextData *data = (InputContextData*)hIMC;
1696
1697 TRACE("(%p, %d, %p, %d, %p, %d):\n",
1698 hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1699
1700 if (!data)
1701 return FALSE;
1702
1703 if (!is_himc_ime_unicode(data))
1704 return data->immKbd->pImeSetCompositionString(hIMC, dwIndex, lpComp,
1705 dwCompLen, lpRead, dwReadLen);
1706
1707 comp_len = MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, NULL, 0);
1708 if (comp_len)
1709 {
1710 CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len * sizeof(WCHAR));
1711 MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len);
1712 }
1713
1714 read_len = MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, NULL, 0);
1715 if (read_len)
1716 {
1717 ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len * sizeof(WCHAR));
1718 MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len);
1719 }
1720
1721 rc = ImmSetCompositionStringW(hIMC, dwIndex, CompBuffer, comp_len,
1722 ReadBuffer, read_len);
1723
1724 HeapFree(GetProcessHeap(), 0, CompBuffer);
1725 HeapFree(GetProcessHeap(), 0, ReadBuffer);
1726
1727 return rc;
1728 }
1729
1730 /***********************************************************************
1731 * ImmSetCompositionStringW (IMM32.@)
1732 */
1733 BOOL WINAPI ImmSetCompositionStringW(
1734 HIMC hIMC, DWORD dwIndex,
1735 LPCVOID lpComp, DWORD dwCompLen,
1736 LPCVOID lpRead, DWORD dwReadLen)
1737 {
1738 DWORD comp_len;
1739 DWORD read_len;
1740 CHAR *CompBuffer = NULL;
1741 CHAR *ReadBuffer = NULL;
1742 BOOL rc;
1743 InputContextData *data = (InputContextData*)hIMC;
1744
1745 TRACE("(%p, %d, %p, %d, %p, %d):\n",
1746 hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1747
1748 if (!data)
1749 return FALSE;
1750
1751 if (is_himc_ime_unicode(data))
1752 return data->immKbd->pImeSetCompositionString(hIMC, dwIndex, lpComp,
1753 dwCompLen, lpRead, dwReadLen);
1754
1755 comp_len = WideCharToMultiByte(CP_ACP, 0, lpComp, dwCompLen, NULL, 0, NULL,
1756 NULL);
1757 if (comp_len)
1758 {
1759 CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len);
1760 WideCharToMultiByte(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len,
1761 NULL, NULL);
1762 }
1763
1764 read_len = WideCharToMultiByte(CP_ACP, 0, lpRead, dwReadLen, NULL, 0, NULL,
1765 NULL);
1766 if (read_len)
1767 {
1768 ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len);
1769 WideCharToMultiByte(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len,
1770 NULL, NULL);
1771 }
1772
1773 rc = ImmSetCompositionStringA(hIMC, dwIndex, CompBuffer, comp_len,
1774 ReadBuffer, read_len);
1775
1776 HeapFree(GetProcessHeap(), 0, CompBuffer);
1777 HeapFree(GetProcessHeap(), 0, ReadBuffer);
1778
1779 return rc;
1780 }
1781
1782 /***********************************************************************
1783 * ImmSetCompositionWindow (IMM32.@)
1784 */
1785 BOOL WINAPI ImmSetCompositionWindow(
1786 HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
1787 {
1788 BOOL reshow = FALSE;
1789 InputContextData *data = (InputContextData*)hIMC;
1790
1791 TRACE("(%p, %p)\n", hIMC, lpCompForm);
1792 TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm->dwStyle,
1793 lpCompForm->ptCurrentPos.x, lpCompForm->ptCurrentPos.y, lpCompForm->rcArea.top,
1794 lpCompForm->rcArea.left, lpCompForm->rcArea.bottom, lpCompForm->rcArea.right);
1795
1796 if (!data)
1797 return FALSE;
1798
1799 data->IMC.cfCompForm = *lpCompForm;
1800
1801 if (IsWindowVisible(IMM_GetThreadData()->hwndDefault))
1802 {
1803 reshow = TRUE;
1804 ShowWindow(IMM_GetThreadData()->hwndDefault,SW_HIDE);
1805 }
1806
1807 /* FIXME: this is a partial stub */
1808
1809 if (reshow)
1810 ShowWindow(IMM_GetThreadData()->hwndDefault,SW_SHOWNOACTIVATE);
1811
1812 ImmInternalSendIMENotify(data, IMN_SETCOMPOSITIONWINDOW, 0);
1813 return TRUE;
1814 }
1815
1816 /***********************************************************************
1817 * ImmSetConversionStatus (IMM32.@)
1818 */
1819 BOOL WINAPI ImmSetConversionStatus(
1820 HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
1821 {
1822 DWORD oldConversion, oldSentence;
1823 InputContextData *data = (InputContextData*)hIMC;
1824
1825 TRACE("%p %d %d\n", hIMC, fdwConversion, fdwSentence);
1826
1827 if (!data)
1828 return FALSE;
1829
1830 if ( fdwConversion != data->IMC.fdwConversion )
1831 {
1832 oldConversion = data->IMC.fdwConversion;
1833 data->IMC.fdwConversion = fdwConversion;
1834 ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, oldConversion, IMC_SETCONVERSIONMODE);
1835 ImmInternalSendIMENotify(data, IMN_SETCONVERSIONMODE, 0);
1836 }
1837 if ( fdwSentence != data->IMC.fdwSentence )
1838 {
1839 oldSentence = data->IMC.fdwSentence;
1840 data->IMC.fdwSentence = fdwSentence;
1841 ImmNotifyIME(hIMC, NI_CONTEXTUPDATED, oldSentence, IMC_SETSENTENCEMODE);
1842 ImmInternalSendIMENotify(data, IMN_SETSENTENCEMODE, 0);
1843 }
1844
1845 return TRUE;
1846 }
1847
1848 /***********************************************************************
1849 * ImmSetOpenStatus (IMM32.@)
1850 */
1851 BOOL WINAPI ImmSetOpenStatus(HIMC hIMC, BOOL fOpen)
1852 {
1853 InputContextData *data = (InputContextData*)hIMC;
1854
1855 TRACE("%p %d\n", hIMC, fOpen);
1856
1857 if (!data)
1858 return FALSE;
1859
1860 if (data->imeWnd == NULL)
1861 {
1862 /* create the ime window */
1863 data->imeWnd = CreateWindowExW( WS_EX_TOOLWINDOW,
1864 data->immKbd->imeClassName, NULL, WS_POPUP, 0, 0, 1, 1, 0,
1865 0, data->immKbd->hIME, 0);
1866 SetWindowLongW(data->imeWnd, IMMGWL_IMC, (LONG)data);
1867 IMM_GetThreadData()->hwndDefault = data->imeWnd;
1868 }
1869
1870 if (!fOpen != !data->IMC.fOpen)
1871 {
1872 data->IMC.fOpen = fOpen;
1873 ImmNotifyIME( hIMC, NI_CONTEXTUPDATED, 0, IMC_SETOPENSTATUS);
1874 ImmInternalSendIMENotify(data, IMN_SETOPENSTATUS, 0);
1875 }
1876
1877 return TRUE;
1878 }
1879
1880 /***********************************************************************
1881 * ImmSetStatusWindowPos (IMM32.@)
1882 */
1883 BOOL WINAPI ImmSetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1884 {
1885 FIXME("(%p, %p): stub\n", hIMC, lpptPos);
1886 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1887 return FALSE;
1888 }
1889
1890 /***********************************************************************
1891 * ImmCreateSoftKeyboard(IMM32.@)
1892 */
1893 HWND WINAPI ImmCreateSoftKeyboard(UINT uType, UINT hOwner, int x, int y)
1894 {
1895 FIXME("(%d, %d, %d, %d): stub\n", uType, hOwner, x, y);
1896 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1897 return 0;
1898 }
1899
1900 /***********************************************************************
1901 * ImmDestroySoftKeyboard(IMM32.@)
1902 */
1903 BOOL WINAPI ImmDestroySoftKeyboard(HWND hSoftWnd)
1904 {
1905 FIXME("(%p): stub\n", hSoftWnd);
1906 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1907 return FALSE;
1908 }
1909
1910 /***********************************************************************
1911 * ImmShowSoftKeyboard(IMM32.@)
1912 */
1913 BOOL WINAPI ImmShowSoftKeyboard(HWND hSoftWnd, int nCmdShow)
1914 {
1915 FIXME("(%p, %d): stub\n", hSoftWnd, nCmdShow);
1916 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1917 return FALSE;
1918 }
1919
1920 /***********************************************************************
1921 * ImmSimulateHotKey (IMM32.@)
1922 */
1923 BOOL WINAPI ImmSimulateHotKey(HWND hWnd, DWORD dwHotKeyID)
1924 {
1925 FIXME("(%p, %d): stub\n", hWnd, dwHotKeyID);
1926 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1927 return FALSE;
1928 }
1929
1930 /***********************************************************************
1931 * ImmUnregisterWordA (IMM32.@)
1932 */
1933 BOOL WINAPI ImmUnregisterWordA(
1934 HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
1935 {
1936 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1937 TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_a(lpszReading), dwStyle,
1938 debugstr_a(lpszUnregister));
1939 if (immHkl->hIME && immHkl->pImeUnregisterWord)
1940 {
1941 if (!is_kbd_ime_unicode(immHkl))
1942 return immHkl->pImeUnregisterWord((LPCWSTR)lpszReading,dwStyle,
1943 (LPCWSTR)lpszUnregister);
1944 else
1945 {
1946 LPWSTR lpszwReading = strdupAtoW(lpszReading);
1947 LPWSTR lpszwUnregister = strdupAtoW(lpszUnregister);
1948 BOOL rc;
1949
1950 rc = immHkl->pImeUnregisterWord(lpszwReading,dwStyle,lpszwUnregister);
1951 HeapFree(GetProcessHeap(),0,lpszwReading);
1952 HeapFree(GetProcessHeap(),0,lpszwUnregister);
1953 return rc;
1954 }
1955 }
1956 else
1957 return FALSE;
1958 }
1959
1960 /***********************************************************************
1961 * ImmUnregisterWordW (IMM32.@)
1962 */
1963 BOOL WINAPI ImmUnregisterWordW(
1964 HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
1965 {
1966 ImmHkl *immHkl = IMM_GetImmHkl(hKL);
1967 TRACE("(%p, %s, %d, %s):\n", hKL, debugstr_w(lpszReading), dwStyle,
1968 debugstr_w(lpszUnregister));
1969 if (immHkl->hIME && immHkl->pImeUnregisterWord)
1970 {
1971 if (is_kbd_ime_unicode(immHkl))
1972 return immHkl->pImeUnregisterWord(lpszReading,dwStyle,lpszUnregister);
1973 else
1974 {
1975 LPSTR lpszaReading = strdupWtoA(lpszReading);
1976 LPSTR lpszaUnregister = strdupWtoA(lpszUnregister);
1977 BOOL rc;
1978
1979 rc = immHkl->pImeUnregisterWord((LPCWSTR)lpszaReading,dwStyle,
1980 (LPCWSTR)lpszaUnregister);
1981 HeapFree(GetProcessHeap(),0,lpszaReading);
1982 HeapFree(GetProcessHeap(),0,lpszaUnregister);
1983 return rc;
1984 }
1985 }
1986 else
1987 return FALSE;
1988 }
1989
1990 /***********************************************************************
1991 * ImmGetImeMenuItemsA (IMM32.@)
1992 */
1993 DWORD WINAPI ImmGetImeMenuItemsA( HIMC hIMC, DWORD dwFlags, DWORD dwType,
1994 LPIMEMENUITEMINFOA lpImeParentMenu, LPIMEMENUITEMINFOA lpImeMenu,
1995 DWORD dwSize)
1996 {
1997 InputContextData *data = (InputContextData*)hIMC;
1998 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC, dwFlags, dwType,
1999 lpImeParentMenu, lpImeMenu, dwSize);
2000 if (data->immKbd->hIME && data->immKbd->pImeGetImeMenuItems)
2001 {
2002 if (!is_himc_ime_unicode(data) || (!lpImeParentMenu && !lpImeMenu))
2003 return data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2004 (IMEMENUITEMINFOW*)lpImeParentMenu,
2005 (IMEMENUITEMINFOW*)lpImeMenu, dwSize);
2006 else
2007 {
2008 IMEMENUITEMINFOW lpImeParentMenuW;
2009 IMEMENUITEMINFOW *lpImeMenuW, *parent = NULL;
2010 DWORD rc;
2011
2012 if (lpImeParentMenu)
2013 parent = &lpImeParentMenuW;
2014 if (lpImeMenu)
2015 {
2016 int count = dwSize / sizeof(LPIMEMENUITEMINFOA);
2017 dwSize = count * sizeof(IMEMENUITEMINFOW);
2018 lpImeMenuW = HeapAlloc(GetProcessHeap(), 0, dwSize);
2019 }
2020 else
2021 lpImeMenuW = NULL;
2022
2023 rc = data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2024 parent, lpImeMenuW, dwSize);
2025
2026 if (lpImeParentMenu)
2027 {
2028 memcpy(lpImeParentMenu,&lpImeParentMenuW,sizeof(IMEMENUITEMINFOA));
2029 lpImeParentMenu->hbmpItem = lpImeParentMenuW.hbmpItem;
2030 WideCharToMultiByte(CP_ACP, 0, lpImeParentMenuW.szString,
2031 -1, lpImeParentMenu->szString, IMEMENUITEM_STRING_SIZE,
2032 NULL, NULL);
2033 }
2034 if (lpImeMenu && rc)
2035 {
2036 int i;
2037 for (i = 0; i < rc; i++)
2038 {
2039 memcpy(&lpImeMenu[i],&lpImeMenuW[1],sizeof(IMEMENUITEMINFOA));
2040 lpImeMenu[i].hbmpItem = lpImeMenuW[i].hbmpItem;
2041 WideCharToMultiByte(CP_ACP, 0, lpImeMenuW[i].szString,
2042 -1, lpImeMenu[i].szString, IMEMENUITEM_STRING_SIZE,
2043 NULL, NULL);
2044 }
2045 }
2046 HeapFree(GetProcessHeap(),0,lpImeMenuW);
2047 return rc;
2048 }
2049 }
2050 else
2051 return 0;
2052 }
2053
2054 /***********************************************************************
2055 * ImmGetImeMenuItemsW (IMM32.@)
2056 */
2057 DWORD WINAPI ImmGetImeMenuItemsW( HIMC hIMC, DWORD dwFlags, DWORD dwType,
2058 LPIMEMENUITEMINFOW lpImeParentMenu, LPIMEMENUITEMINFOW lpImeMenu,
2059 DWORD dwSize)
2060 {
2061 InputContextData *data = (InputContextData*)hIMC;
2062 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC, dwFlags, dwType,
2063 lpImeParentMenu, lpImeMenu, dwSize);
2064 if (data->immKbd->hIME && data->immKbd->pImeGetImeMenuItems)
2065 {
2066 if (is_himc_ime_unicode(data) || (!lpImeParentMenu && !lpImeMenu))
2067 return data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2068 lpImeParentMenu, lpImeMenu, dwSize);
2069 else
2070 {
2071 IMEMENUITEMINFOA lpImeParentMenuA;
2072 IMEMENUITEMINFOA *lpImeMenuA, *parent = NULL;
2073 DWORD rc;
2074
2075 if (lpImeParentMenu)
2076 parent = &lpImeParentMenuA;
2077 if (lpImeMenu)
2078 {
2079 int count = dwSize / sizeof(LPIMEMENUITEMINFOW);
2080 dwSize = count * sizeof(IMEMENUITEMINFOA);
2081 lpImeMenuA = HeapAlloc(GetProcessHeap(), 0, dwSize);
2082 }
2083 else
2084 lpImeMenuA = NULL;
2085
2086 rc = data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
2087 (IMEMENUITEMINFOW*)parent,
2088 (IMEMENUITEMINFOW*)lpImeMenuA, dwSize);
2089
2090 if (lpImeParentMenu)
2091 {
2092 memcpy(lpImeParentMenu,&lpImeParentMenuA,sizeof(IMEMENUITEMINFOA));
2093 lpImeParentMenu->hbmpItem = lpImeParentMenuA.hbmpItem;
2094 MultiByteToWideChar(CP_ACP, 0, lpImeParentMenuA.szString,
2095 -1, lpImeParentMenu->szString, IMEMENUITEM_STRING_SIZE);
2096 }
2097 if (lpImeMenu && rc)
2098 {
2099 int i;
2100 for (i = 0; i < rc; i++)
2101 {
2102 memcpy(&lpImeMenu[i],&lpImeMenuA[1],sizeof(IMEMENUITEMINFOA));
2103 lpImeMenu[i].hbmpItem = lpImeMenuA[i].hbmpItem;
2104 MultiByteToWideChar(CP_ACP, 0, lpImeMenuA[i].szString,
2105 -1, lpImeMenu[i].szString, IMEMENUITEM_STRING_SIZE);
2106 }
2107 }
2108 HeapFree(GetProcessHeap(),0,lpImeMenuA);
2109 return rc;
2110 }
2111 }
2112 else
2113 return 0;
2114 }
2115
2116 /***********************************************************************
2117 * ImmLockIMC(IMM32.@)
2118 */
2119 LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
2120 {
2121 InputContextData *data = (InputContextData*)hIMC;
2122
2123 if (!data)
2124 return NULL;
2125 data->dwLock++;
2126 return &data->IMC;
2127 }
2128
2129 /***********************************************************************
2130 * ImmUnlockIMC(IMM32.@)
2131 */
2132 BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
2133 {
2134 InputContextData *data = (InputContextData*)hIMC;
2135 data->dwLock--;
2136 return (data->dwLock!=0);
2137 }
2138
2139 /***********************************************************************
2140 * ImmGetIMCLockCount(IMM32.@)
2141 */
2142 DWORD WINAPI ImmGetIMCLockCount(HIMC hIMC)
2143 {
2144 InputContextData *data = (InputContextData*)hIMC;
2145 return data->dwLock;
2146 }
2147
2148 /***********************************************************************
2149 * ImmCreateIMCC(IMM32.@)
2150 */
2151 HIMCC WINAPI ImmCreateIMCC(DWORD size)
2152 {
2153 IMCCInternal *internal;
2154 int real_size = size + sizeof(IMCCInternal);
2155
2156 internal = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, real_size);
2157 if (internal == NULL)
2158 return NULL;
2159
2160 internal->dwSize = size;
2161 return (HIMCC)internal;
2162 }
2163
2164 /***********************************************************************
2165 * ImmDestroyIMCC(IMM32.@)
2166 */
2167 HIMCC WINAPI ImmDestroyIMCC(HIMCC block)
2168 {
2169 HeapFree(GetProcessHeap(),0,block);
2170 return NULL;
2171 }
2172
2173 /***********************************************************************
2174 * ImmLockIMCC(IMM32.@)
2175 */
2176 LPVOID WINAPI ImmLockIMCC(HIMCC imcc)
2177 {
2178 IMCCInternal *internal;
2179 internal = (IMCCInternal*) imcc;
2180
2181 internal->dwLock ++;
2182 return internal + 1;
2183 }
2184
2185 /***********************************************************************
2186 * ImmUnlockIMCC(IMM32.@)
2187 */
2188 BOOL WINAPI ImmUnlockIMCC(HIMCC imcc)
2189 {
2190 IMCCInternal *internal;
2191 internal = (IMCCInternal*) imcc;
2192
2193 internal->dwLock --;
2194 return (internal->dwLock!=0);
2195 }
2196
2197 /***********************************************************************
2198 * ImmGetIMCCLockCount(IMM32.@)
2199 */
2200 DWORD WINAPI ImmGetIMCCLockCount(HIMCC imcc)
2201 {
2202 IMCCInternal *internal;
2203 internal = (IMCCInternal*) imcc;
2204
2205 return internal->dwLock;
2206 }
2207
2208 /***********************************************************************
2209 * ImmReSizeIMCC(IMM32.@)
2210 */
2211 HIMCC WINAPI ImmReSizeIMCC(HIMCC imcc, DWORD size)
2212 {
2213 IMCCInternal *internal,*newone;
2214 int real_size = size + sizeof(IMCCInternal);
2215
2216 internal = (IMCCInternal*) imcc;
2217
2218 newone = HeapReAlloc(GetProcessHeap(), 0, internal, real_size);
2219 newone->dwSize = size;
2220
2221 return newone;
2222 }
2223
2224 /***********************************************************************
2225 * ImmGetIMCCSize(IMM32.@)
2226 */
2227 DWORD WINAPI ImmGetIMCCSize(HIMCC imcc)
2228 {
2229 IMCCInternal *internal;
2230 internal = (IMCCInternal*) imcc;
2231
2232 return internal->dwSize;
2233 }
2234
2235 /***********************************************************************
2236 * ImmGenerateMessage(IMM32.@)
2237 */
2238 BOOL WINAPI ImmGenerateMessage(HIMC hIMC)
2239 {
2240 InputContextData *data = (InputContextData*)hIMC;
2241
2242 TRACE("%i messages queued\n",data->IMC.dwNumMsgBuf);
2243 if (data->IMC.dwNumMsgBuf > 0)
2244 {
2245 LPTRANSMSG lpTransMsg;
2246 INT i;
2247
2248 lpTransMsg = (LPTRANSMSG)ImmLockIMCC(data->IMC.hMsgBuf);
2249 for (i = 0; i < data->IMC.dwNumMsgBuf; i++)
2250 ImmInternalPostIMEMessage(data, lpTransMsg[i].message, lpTransMsg[i].wParam, lpTransMsg[i].lParam);
2251
2252 ImmUnlockIMCC(data->IMC.hMsgBuf);
2253
2254 data->IMC.dwNumMsgBuf = 0;
2255 }
2256
2257 return TRUE;
2258 }
2259
2260 /***********************************************************************
2261 * ImmTranslateMessage(IMM32.@)
2262 * ( Undocumented, call internally and from user32.dll )
2263 */
2264 BOOL WINAPI ImmTranslateMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lKeyData)
2265 {
2266 InputContextData *data;
2267 HIMC imc = ImmGetContext(hwnd);
2268 BYTE state[256];
2269 UINT scancode;
2270 LPVOID list = 0;
2271 UINT msg_count;
2272 UINT uVirtKey;
2273 static const int list_count = 10;
2274
2275 TRACE("%p %x %x %x\n",hwnd, msg, (UINT)wParam, (UINT)lKeyData);
2276
2277 if (imc)
2278 data = (InputContextData*)imc;
2279 else
2280 return FALSE;
2281
2282 if (!data->immKbd->hIME || !data->immKbd->pImeToAsciiEx)
2283 return FALSE;
2284
2285 GetKeyboardState(state);
2286 scancode = lKeyData >> 0x10 & 0xff;
2287
2288 list = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, list_count * sizeof(TRANSMSG) + sizeof(DWORD));
2289 ((DWORD*)list)[0] = list_count;
2290
2291 if (data->immKbd->imeInfo.fdwProperty & IME_PROP_KBD_CHAR_FIRST)
2292 {
2293 WCHAR chr;
2294
2295 if (!is_himc_ime_unicode(data))
2296 ToAscii(data->lastVK, scancode, state, &chr, 0);
2297 else
2298 ToUnicodeEx(data->lastVK, scancode, state, &chr, 1, 0, GetKeyboardLayout(0));
2299 uVirtKey = MAKELONG(data->lastVK,chr);
2300 }
2301 else
2302 uVirtKey = data->lastVK;
2303
2304 msg_count = data->immKbd->pImeToAsciiEx(uVirtKey, scancode, state, list, 0, imc);
2305 TRACE("%i messages generated\n",msg_count);
2306 if (msg_count && msg_count <= list_count)
2307 {
2308 int i;
2309 LPTRANSMSG msgs = (LPTRANSMSG)((LPBYTE)list + sizeof(DWORD));
2310
2311 for (i = 0; i < msg_count; i++)
2312 ImmInternalPostIMEMessage(data, msgs[i].message, msgs[i].wParam, msgs[i].lParam);
2313 }
2314 else if (msg_count > list_count)
2315 ImmGenerateMessage(imc);
2316
2317 HeapFree(GetProcessHeap(),0,list);
2318
2319 data->lastVK = VK_PROCESSKEY;
2320
2321 return (msg_count > 0);
2322 }
2323
2324 /***********************************************************************
2325 * ImmProcessKey(IMM32.@)
2326 * ( Undocumented, called from user32.dll )
2327 */
2328 BOOL WINAPI ImmProcessKey(HWND hwnd, HKL hKL, UINT vKey, LPARAM lKeyData, DWORD unknown)
2329 {
2330 InputContextData *data;
2331 HIMC imc = ImmGetContext(hwnd);
2332 BYTE state[256];
2333
2334 TRACE("%p %p %x %x %x\n",hwnd, hKL, vKey, (UINT)lKeyData, unknown);
2335
2336 if (imc)
2337 data = (InputContextData*)imc;
2338 else
2339 return FALSE;
2340
2341 if (!data->immKbd->hIME || !data->immKbd->pImeProcessKey)
2342 return FALSE;
2343
2344 GetKeyboardState(state);
2345 if (data->immKbd->pImeProcessKey(imc, vKey, lKeyData, state))
2346 {
2347 data->lastVK = vKey;
2348 return TRUE;
2349 }
2350
2351 data->lastVK = VK_PROCESSKEY;
2352 return FALSE;
2353 }