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