4 * Copyright 1998 Patrik Stridvall
5 * Copyright 2002, 2003, 2007 CodeWeavers, Aric Stewart
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.
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.
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
30 #include "wine/debug.h"
35 #include "wine/list.h"
36 #include "wine/unicode.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(imm
);
40 #define IMM_INIT_MAGIC 0x19650412
41 BOOL WINAPI
User32InitializeImmEntryTable(DWORD
);
43 typedef struct _tagImmHkl
{
48 WCHAR imeClassName
[17]; /* 16 character max */
52 /* Function Pointers */
53 BOOL (WINAPI
*pImeInquire
)(IMEINFO
*, WCHAR
*, const WCHAR
*);
54 BOOL (WINAPI
*pImeConfigure
)(HKL
, HWND
, DWORD
, void *);
55 BOOL (WINAPI
*pImeDestroy
)(UINT
);
56 LRESULT (WINAPI
*pImeEscape
)(HIMC
, UINT
, void *);
57 BOOL (WINAPI
*pImeSelect
)(HIMC
, BOOL
);
58 BOOL (WINAPI
*pImeSetActiveContext
)(HIMC
, BOOL
);
59 UINT (WINAPI
*pImeToAsciiEx
)(UINT
, UINT
, const BYTE
*, DWORD
*, UINT
, HIMC
);
60 BOOL (WINAPI
*pNotifyIME
)(HIMC
, DWORD
, DWORD
, DWORD
);
61 BOOL (WINAPI
*pImeRegisterWord
)(const WCHAR
*, DWORD
, const WCHAR
*);
62 BOOL (WINAPI
*pImeUnregisterWord
)(const WCHAR
*, DWORD
, const WCHAR
*);
63 UINT (WINAPI
*pImeEnumRegisterWord
)(REGISTERWORDENUMPROCW
, const WCHAR
*, DWORD
, const WCHAR
*, void *);
64 BOOL (WINAPI
*pImeSetCompositionString
)(HIMC
, DWORD
, const void *, DWORD
, const void *, DWORD
);
65 DWORD (WINAPI
*pImeConversionList
)(HIMC
, const WCHAR
*, CANDIDATELIST
*, DWORD
, UINT
);
66 BOOL (WINAPI
*pImeProcessKey
)(HIMC
, UINT
, LPARAM
, const BYTE
*);
67 UINT (WINAPI
*pImeGetRegisterWordStyle
)(UINT
, STYLEBUFW
*);
68 DWORD (WINAPI
*pImeGetImeMenuItems
)(HIMC
, DWORD
, DWORD
, IMEMENUITEMINFOW
*, IMEMENUITEMINFOW
*, DWORD
);
71 typedef struct tagInputContextData
83 #define WINE_IMC_VALID_MAGIC 0x56434D49
85 typedef struct _tagTRANSMSG
{
89 } TRANSMSG
, *LPTRANSMSG
;
91 typedef struct _tagIMMThreadData
{
100 static struct list ImmHklList
= LIST_INIT(ImmHklList
);
101 static struct list ImmThreadDataList
= LIST_INIT(ImmThreadDataList
);
103 static const WCHAR szwWineIMCProperty
[] = {'W','i','n','e','I','m','m','H','I','M','C','P','r','o','p','e','r','t','y',0};
105 static const WCHAR szImeFileW
[] = {'I','m','e',' ','F','i','l','e',0};
106 static const WCHAR szLayoutTextW
[] = {'L','a','y','o','u','t',' ','T','e','x','t',0};
107 static const WCHAR szImeRegFmt
[] = {'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','s','\\','%','0','8','l','x',0};
109 static const WCHAR szwIME
[] = {'I','M','E',0};
110 static const WCHAR szwDefaultIME
[] = {'D','e','f','a','u','l','t',' ','I','M','E',0};
112 static CRITICAL_SECTION threaddata_cs
;
113 static CRITICAL_SECTION_DEBUG critsect_debug
=
115 0, 0, &threaddata_cs
,
116 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
117 0, 0, { (DWORD_PTR
)(__FILE__
": threaddata_cs") }
119 static CRITICAL_SECTION threaddata_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
120 static BOOL disable_ime
;
122 #define is_himc_ime_unicode(p) (p->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE)
123 #define is_kbd_ime_unicode(p) (p->imeInfo.fdwProperty & IME_PROP_UNICODE)
125 static BOOL
IMM_DestroyContext(HIMC hIMC
);
126 static InputContextData
* get_imc_data(HIMC hIMC
);
128 static inline WCHAR
*strdupAtoW( const char *str
)
133 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
134 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
135 MultiByteToWideChar( CP_ACP
, 0, str
, -1, ret
, len
);
140 static inline CHAR
*strdupWtoA( const WCHAR
*str
)
145 DWORD len
= WideCharToMultiByte( CP_ACP
, 0, str
, -1, NULL
, 0, NULL
, NULL
);
146 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
)))
147 WideCharToMultiByte( CP_ACP
, 0, str
, -1, ret
, len
, NULL
, NULL
);
152 static DWORD
convert_candidatelist_WtoA(
153 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
157 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
158 if ( lpDst
&& dwBufLen
> 0 )
161 lpDst
->dwOffset
[0] = ret
;
164 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
166 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
168 if ( lpDst
&& dwBufLen
> 0 )
170 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
172 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1,
173 (LPSTR
)dest
, dwBufLen
, NULL
, NULL
);
175 if ( i
+ 1 < lpSrc
->dwCount
)
176 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(char);
177 dwBufLen
-= len
* sizeof(char);
180 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1, NULL
, 0, NULL
, NULL
);
182 ret
+= len
* sizeof(char);
191 static DWORD
convert_candidatelist_AtoW(
192 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
196 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
197 if ( lpDst
&& dwBufLen
> 0 )
200 lpDst
->dwOffset
[0] = ret
;
203 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
205 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
207 if ( lpDst
&& dwBufLen
> 0 )
209 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
211 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1,
212 (LPWSTR
)dest
, dwBufLen
);
214 if ( i
+ 1 < lpSrc
->dwCount
)
215 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(WCHAR
);
216 dwBufLen
-= len
* sizeof(WCHAR
);
219 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1, NULL
, 0);
221 ret
+= len
* sizeof(WCHAR
);
230 static IMMThreadData
*IMM_GetThreadData(HWND hwnd
, DWORD thread
)
237 if (!(thread
= GetWindowThreadProcessId(hwnd
, &process
))) return NULL
;
238 if (process
!= GetCurrentProcessId()) return NULL
;
242 HANDLE h
= OpenThread(THREAD_QUERY_INFORMATION
, FALSE
, thread
);
244 process
= GetProcessIdOfThread(h
);
246 if (process
!= GetCurrentProcessId()) return NULL
;
249 thread
= GetCurrentThreadId();
251 EnterCriticalSection(&threaddata_cs
);
252 LIST_FOR_EACH_ENTRY(data
, &ImmThreadDataList
, IMMThreadData
, entry
)
253 if (data
->threadID
== thread
) return data
;
255 data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*data
));
256 data
->threadID
= thread
;
257 list_add_head(&ImmThreadDataList
,&data
->entry
);
258 TRACE("Thread Data Created (%x)\n",thread
);
262 static BOOL
IMM_IsDefaultContext(HIMC imc
)
264 InputContextData
*data
= get_imc_data(imc
);
269 return data
->threadDefault
;
272 static void IMM_FreeThreadData(void)
276 EnterCriticalSection(&threaddata_cs
);
277 LIST_FOR_EACH_ENTRY(data
, &ImmThreadDataList
, IMMThreadData
, entry
)
279 if (data
->threadID
== GetCurrentThreadId())
281 list_remove(&data
->entry
);
282 LeaveCriticalSection(&threaddata_cs
);
283 IMM_DestroyContext(data
->defaultContext
);
284 HeapFree(GetProcessHeap(),0,data
);
285 TRACE("Thread Data Destroyed\n");
289 LeaveCriticalSection(&threaddata_cs
);
292 static HMODULE
load_graphics_driver(void)
294 static const WCHAR display_device_guid_propW
[] = {
295 '_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
296 'd','e','v','i','c','e','_','g','u','i','d',0 };
297 static const WCHAR key_pathW
[] = {
298 'S','y','s','t','e','m','\\',
299 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
300 'C','o','n','t','r','o','l','\\',
301 'V','i','d','e','o','\\','{',0};
302 static const WCHAR displayW
[] = {'}','\\','0','0','0','0',0};
303 static const WCHAR driverW
[] = {'G','r','a','p','h','i','c','s','D','r','i','v','e','r',0};
308 WCHAR path
[MAX_PATH
];
309 WCHAR key
[ARRAY_SIZE( key_pathW
) + ARRAY_SIZE( displayW
) + 40];
310 UINT guid_atom
= HandleToULong( GetPropW( GetDesktopWindow(), display_device_guid_propW
));
312 if (!guid_atom
) return 0;
313 memcpy( key
, key_pathW
, sizeof(key_pathW
) );
314 if (!GlobalGetAtomNameW( guid_atom
, key
+ strlenW(key
), 40 )) return 0;
315 strcatW( key
, displayW
);
316 if (RegOpenKeyW( HKEY_LOCAL_MACHINE
, key
, &hkey
)) return 0;
318 if (!RegQueryValueExW( hkey
, driverW
, NULL
, NULL
, (BYTE
*)path
, &size
)) ret
= LoadLibraryW( path
);
320 TRACE( "%s %p\n", debugstr_w(path
), ret
);
324 /* ImmHkl loading and freeing */
325 #define LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}
326 static ImmHkl
*IMM_GetImmHkl(HKL hkl
)
329 WCHAR filename
[MAX_PATH
];
331 TRACE("Seeking ime for keyboard %p\n",hkl
);
333 LIST_FOR_EACH_ENTRY(ptr
, &ImmHklList
, ImmHkl
, entry
)
338 /* not found... create it */
340 ptr
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ImmHkl
));
343 if (ImmGetIMEFileNameW(hkl
, filename
, MAX_PATH
)) ptr
->hIME
= LoadLibraryW(filename
);
344 if (!ptr
->hIME
) ptr
->hIME
= load_graphics_driver();
347 LOAD_FUNCPTR(ImeInquire
);
348 if (!ptr
->pImeInquire
|| !ptr
->pImeInquire(&ptr
->imeInfo
, ptr
->imeClassName
, NULL
))
350 FreeLibrary(ptr
->hIME
);
355 LOAD_FUNCPTR(ImeDestroy
);
356 LOAD_FUNCPTR(ImeSelect
);
357 if (!ptr
->pImeSelect
|| !ptr
->pImeDestroy
)
359 FreeLibrary(ptr
->hIME
);
364 LOAD_FUNCPTR(ImeConfigure
);
365 LOAD_FUNCPTR(ImeEscape
);
366 LOAD_FUNCPTR(ImeSetActiveContext
);
367 LOAD_FUNCPTR(ImeToAsciiEx
);
368 LOAD_FUNCPTR(NotifyIME
);
369 LOAD_FUNCPTR(ImeRegisterWord
);
370 LOAD_FUNCPTR(ImeUnregisterWord
);
371 LOAD_FUNCPTR(ImeEnumRegisterWord
);
372 LOAD_FUNCPTR(ImeSetCompositionString
);
373 LOAD_FUNCPTR(ImeConversionList
);
374 LOAD_FUNCPTR(ImeProcessKey
);
375 LOAD_FUNCPTR(ImeGetRegisterWordStyle
);
376 LOAD_FUNCPTR(ImeGetImeMenuItems
);
377 /* make sure our classname is WCHAR */
378 if (!is_kbd_ime_unicode(ptr
))
381 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ptr
->imeClassName
,
383 lstrcpyW(ptr
->imeClassName
, bufW
);
388 list_add_head(&ImmHklList
,&ptr
->entry
);
394 HWND WINAPI
__wine_get_ui_window(HKL hkl
)
396 ImmHkl
*immHkl
= IMM_GetImmHkl(hkl
);
397 return immHkl
->UIWnd
;
400 static void IMM_FreeAllImmHkl(void)
402 ImmHkl
*ptr
,*cursor2
;
404 LIST_FOR_EACH_ENTRY_SAFE(ptr
, cursor2
, &ImmHklList
, ImmHkl
, entry
)
406 list_remove(&ptr
->entry
);
410 FreeLibrary(ptr
->hIME
);
413 DestroyWindow(ptr
->UIWnd
);
414 HeapFree(GetProcessHeap(),0,ptr
);
418 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID lpReserved
)
420 TRACE("%p, %x, %p\n",hInstDLL
,fdwReason
,lpReserved
);
423 case DLL_PROCESS_ATTACH
:
424 if (!User32InitializeImmEntryTable(IMM_INIT_MAGIC
))
429 case DLL_THREAD_ATTACH
:
431 case DLL_THREAD_DETACH
:
432 IMM_FreeThreadData();
434 case DLL_PROCESS_DETACH
:
435 if (lpReserved
) break;
436 IMM_FreeThreadData();
443 /* for posting messages as the IME */
444 static void ImmInternalPostIMEMessage(InputContextData
*data
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
446 HWND target
= GetFocus();
448 PostMessageW(data
->IMC
.hWnd
,msg
,wParam
,lParam
);
450 PostMessageW(target
, msg
, wParam
, lParam
);
453 /* for sending messages as the IME */
454 static void ImmInternalSendIMEMessage(InputContextData
*data
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
456 HWND target
= GetFocus();
458 SendMessageW(data
->IMC
.hWnd
,msg
,wParam
,lParam
);
460 SendMessageW(target
, msg
, wParam
, lParam
);
463 static LRESULT
ImmInternalSendIMENotify(InputContextData
*data
, WPARAM notify
, LPARAM lParam
)
467 target
= data
->IMC
.hWnd
;
468 if (!target
) target
= GetFocus();
471 return SendMessageW(target
, WM_IME_NOTIFY
, notify
, lParam
);
476 static HIMCC
ImmCreateBlankCompStr(void)
479 LPCOMPOSITIONSTRING ptr
;
480 rc
= ImmCreateIMCC(sizeof(COMPOSITIONSTRING
));
481 ptr
= ImmLockIMCC(rc
);
482 memset(ptr
,0,sizeof(COMPOSITIONSTRING
));
483 ptr
->dwSize
= sizeof(COMPOSITIONSTRING
);
488 static InputContextData
* get_imc_data(HIMC hIMC
)
490 InputContextData
*data
= hIMC
;
495 if(IsBadReadPtr(data
, sizeof(InputContextData
)) || data
->magic
!= WINE_IMC_VALID_MAGIC
)
497 SetLastError(ERROR_INVALID_HANDLE
);
503 static HIMC
get_default_context( HWND hwnd
)
506 IMMThreadData
* thread_data
= IMM_GetThreadData( hwnd
, 0 );
508 if (!thread_data
) return 0;
510 if (thread_data
->defaultContext
)
512 ret
= thread_data
->defaultContext
;
513 LeaveCriticalSection(&threaddata_cs
);
517 /* can't create a default context in another thread */
518 if (thread_data
->threadID
!= GetCurrentThreadId())
520 LeaveCriticalSection(&threaddata_cs
);
524 LeaveCriticalSection(&threaddata_cs
);
526 ret
= ImmCreateContext();
528 ((InputContextData
*)ret
)->threadDefault
= TRUE
;
530 /* thread_data is in the current thread so we can assume it's still valid */
531 EnterCriticalSection(&threaddata_cs
);
533 if (thread_data
->defaultContext
) /* someone beat us */
535 IMM_DestroyContext( ret
);
536 ret
= thread_data
->defaultContext
;
538 else thread_data
->defaultContext
= ret
;
540 LeaveCriticalSection(&threaddata_cs
);
544 static BOOL
IMM_IsCrossThreadAccess(HWND hWnd
, HIMC hIMC
)
546 InputContextData
*data
;
550 DWORD thread
= GetWindowThreadProcessId(hWnd
, NULL
);
551 if (thread
!= GetCurrentThreadId()) return TRUE
;
553 data
= get_imc_data(hIMC
);
554 if (data
&& data
->threadID
!= GetCurrentThreadId())
560 /***********************************************************************
561 * ImmAssociateContext (IMM32.@)
563 HIMC WINAPI
ImmAssociateContext(HWND hWnd
, HIMC hIMC
)
566 InputContextData
*data
= get_imc_data(hIMC
);
568 TRACE("(%p, %p):\n", hWnd
, hIMC
);
574 * If already associated just return
576 if (hIMC
&& data
->IMC
.hWnd
== hWnd
)
579 if (hIMC
&& IMM_IsCrossThreadAccess(hWnd
, hIMC
))
584 HIMC defaultContext
= get_default_context( hWnd
);
585 old
= RemovePropW(hWnd
,szwWineIMCProperty
);
588 old
= defaultContext
;
589 else if (old
== (HIMC
)-1)
592 if (hIMC
!= defaultContext
)
594 if (hIMC
== NULL
) /* Meaning disable imm for that window*/
595 SetPropW(hWnd
,szwWineIMCProperty
,(HANDLE
)-1);
597 SetPropW(hWnd
,szwWineIMCProperty
,hIMC
);
602 InputContextData
*old_data
= old
;
603 if (old_data
->IMC
.hWnd
== hWnd
)
604 old_data
->IMC
.hWnd
= NULL
;
611 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, FALSE
, ISC_SHOWUIALL
);
612 data
->IMC
.hWnd
= hWnd
;
613 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, TRUE
, ISC_SHOWUIALL
);
620 * Helper function for ImmAssociateContextEx
622 static BOOL CALLBACK
_ImmAssociateContextExEnumProc(HWND hwnd
, LPARAM lParam
)
624 HIMC hImc
= (HIMC
)lParam
;
625 ImmAssociateContext(hwnd
,hImc
);
629 /***********************************************************************
630 * ImmAssociateContextEx (IMM32.@)
632 BOOL WINAPI
ImmAssociateContextEx(HWND hWnd
, HIMC hIMC
, DWORD dwFlags
)
634 TRACE("(%p, %p, 0x%x):\n", hWnd
, hIMC
, dwFlags
);
642 ImmAssociateContext(hWnd
,hIMC
);
646 HIMC defaultContext
= get_default_context( hWnd
);
647 if (!defaultContext
) return FALSE
;
648 ImmAssociateContext(hWnd
,defaultContext
);
651 case IACE_IGNORENOCONTEXT
:
652 if (GetPropW(hWnd
,szwWineIMCProperty
))
653 ImmAssociateContext(hWnd
,hIMC
);
656 EnumChildWindows(hWnd
,_ImmAssociateContextExEnumProc
,(LPARAM
)hIMC
);
659 FIXME("Unknown dwFlags 0x%x\n",dwFlags
);
664 /***********************************************************************
665 * ImmConfigureIMEA (IMM32.@)
667 BOOL WINAPI
ImmConfigureIMEA(
668 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
670 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
672 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
674 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
677 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
679 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| !is_kbd_ime_unicode(immHkl
))
680 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
684 REGISTERWORDA
*rwa
= lpData
;
687 rww
.lpReading
= strdupAtoW(rwa
->lpReading
);
688 rww
.lpWord
= strdupAtoW(rwa
->lpWord
);
689 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rww
);
690 HeapFree(GetProcessHeap(),0,rww
.lpReading
);
691 HeapFree(GetProcessHeap(),0,rww
.lpWord
);
699 /***********************************************************************
700 * ImmConfigureIMEW (IMM32.@)
702 BOOL WINAPI
ImmConfigureIMEW(
703 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
705 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
707 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
709 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
712 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
714 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| is_kbd_ime_unicode(immHkl
))
715 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
718 REGISTERWORDW
*rww
= lpData
;
722 rwa
.lpReading
= strdupWtoA(rww
->lpReading
);
723 rwa
.lpWord
= strdupWtoA(rww
->lpWord
);
724 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rwa
);
725 HeapFree(GetProcessHeap(),0,rwa
.lpReading
);
726 HeapFree(GetProcessHeap(),0,rwa
.lpWord
);
734 /***********************************************************************
735 * ImmCreateContext (IMM32.@)
737 HIMC WINAPI
ImmCreateContext(void)
739 InputContextData
*new_context
;
744 new_context
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(InputContextData
));
747 new_context
->immKbd
= IMM_GetImmHkl(GetKeyboardLayout(0));
749 if (!new_context
->immKbd
->hIME
)
751 TRACE("IME dll could not be loaded\n");
752 HeapFree(GetProcessHeap(),0,new_context
);
756 /* the HIMCCs are never NULL */
757 new_context
->IMC
.hCompStr
= ImmCreateBlankCompStr();
758 new_context
->IMC
.hMsgBuf
= ImmCreateIMCC(0);
759 new_context
->IMC
.hCandInfo
= ImmCreateIMCC(sizeof(CANDIDATEINFO
));
760 ci
= ImmLockIMCC(new_context
->IMC
.hCandInfo
);
761 memset(ci
,0,sizeof(CANDIDATEINFO
));
762 ci
->dwSize
= sizeof(CANDIDATEINFO
);
763 ImmUnlockIMCC(new_context
->IMC
.hCandInfo
);
764 new_context
->IMC
.hGuideLine
= ImmCreateIMCC(sizeof(GUIDELINE
));
765 gl
= ImmLockIMCC(new_context
->IMC
.hGuideLine
);
766 memset(gl
,0,sizeof(GUIDELINE
));
767 gl
->dwSize
= sizeof(GUIDELINE
);
768 ImmUnlockIMCC(new_context
->IMC
.hGuideLine
);
770 for (i
= 0; i
< ARRAY_SIZE(new_context
->IMC
.cfCandForm
); i
++)
771 new_context
->IMC
.cfCandForm
[i
].dwIndex
= ~0u;
773 /* Initialize the IME Private */
774 new_context
->IMC
.hPrivate
= ImmCreateIMCC(new_context
->immKbd
->imeInfo
.dwPrivateDataSize
);
776 new_context
->IMC
.fdwConversion
= new_context
->immKbd
->imeInfo
.fdwConversionCaps
;
777 new_context
->IMC
.fdwSentence
= new_context
->immKbd
->imeInfo
.fdwSentenceCaps
;
779 if (!new_context
->immKbd
->pImeSelect(new_context
, TRUE
))
781 TRACE("Selection of IME failed\n");
782 IMM_DestroyContext(new_context
);
785 new_context
->threadID
= GetCurrentThreadId();
786 SendMessageW(GetFocus(), WM_IME_SELECT
, TRUE
, (LPARAM
)new_context
->immKbd
);
788 new_context
->immKbd
->uSelected
++;
789 TRACE("Created context %p\n",new_context
);
791 new_context
->magic
= WINE_IMC_VALID_MAGIC
;
795 static BOOL
IMM_DestroyContext(HIMC hIMC
)
797 InputContextData
*data
= get_imc_data(hIMC
);
799 TRACE("Destroying %p\n",hIMC
);
804 data
->immKbd
->uSelected
--;
805 data
->immKbd
->pImeSelect(hIMC
, FALSE
);
806 SendMessageW(data
->IMC
.hWnd
, WM_IME_SELECT
, FALSE
, (LPARAM
)data
->immKbd
);
808 ImmDestroyIMCC(data
->IMC
.hCompStr
);
809 ImmDestroyIMCC(data
->IMC
.hCandInfo
);
810 ImmDestroyIMCC(data
->IMC
.hGuideLine
);
811 ImmDestroyIMCC(data
->IMC
.hPrivate
);
812 ImmDestroyIMCC(data
->IMC
.hMsgBuf
);
815 HeapFree(GetProcessHeap(),0,data
);
820 /***********************************************************************
821 * ImmDestroyContext (IMM32.@)
823 BOOL WINAPI
ImmDestroyContext(HIMC hIMC
)
825 if (!IMM_IsDefaultContext(hIMC
) && !IMM_IsCrossThreadAccess(NULL
, hIMC
))
826 return IMM_DestroyContext(hIMC
);
831 /***********************************************************************
832 * ImmDisableIME (IMM32.@)
834 BOOL WINAPI
ImmDisableIME(DWORD idThread
)
836 if (idThread
== (DWORD
)-1)
839 IMMThreadData
*thread_data
= IMM_GetThreadData(NULL
, idThread
);
840 if (!thread_data
) return FALSE
;
841 thread_data
->disableIME
= TRUE
;
842 LeaveCriticalSection(&threaddata_cs
);
847 /***********************************************************************
848 * ImmEnumRegisterWordA (IMM32.@)
850 UINT WINAPI
ImmEnumRegisterWordA(
851 HKL hKL
, REGISTERWORDENUMPROCA lpfnEnumProc
,
852 LPCSTR lpszReading
, DWORD dwStyle
,
853 LPCSTR lpszRegister
, LPVOID lpData
)
855 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
856 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
857 debugstr_a(lpszReading
), dwStyle
, debugstr_a(lpszRegister
), lpData
);
858 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
860 if (!is_kbd_ime_unicode(immHkl
))
861 return immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
862 (LPCWSTR
)lpszReading
, dwStyle
, (LPCWSTR
)lpszRegister
, lpData
);
865 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
866 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
869 rc
= immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
870 lpszwReading
, dwStyle
, lpszwRegister
,
873 HeapFree(GetProcessHeap(),0,lpszwReading
);
874 HeapFree(GetProcessHeap(),0,lpszwRegister
);
882 /***********************************************************************
883 * ImmEnumRegisterWordW (IMM32.@)
885 UINT WINAPI
ImmEnumRegisterWordW(
886 HKL hKL
, REGISTERWORDENUMPROCW lpfnEnumProc
,
887 LPCWSTR lpszReading
, DWORD dwStyle
,
888 LPCWSTR lpszRegister
, LPVOID lpData
)
890 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
891 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
892 debugstr_w(lpszReading
), dwStyle
, debugstr_w(lpszRegister
), lpData
);
893 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
895 if (is_kbd_ime_unicode(immHkl
))
896 return immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, lpszReading
, dwStyle
,
897 lpszRegister
, lpData
);
900 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
901 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
904 rc
= immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, (LPCWSTR
)lpszaReading
,
905 dwStyle
, (LPCWSTR
)lpszaRegister
, lpData
);
907 HeapFree(GetProcessHeap(),0,lpszaReading
);
908 HeapFree(GetProcessHeap(),0,lpszaRegister
);
916 static inline BOOL
EscapeRequiresWA(UINT uEscape
)
918 if (uEscape
== IME_ESC_GET_EUDC_DICTIONARY
||
919 uEscape
== IME_ESC_SET_EUDC_DICTIONARY
||
920 uEscape
== IME_ESC_IME_NAME
||
921 uEscape
== IME_ESC_GETHELPFILENAME
)
926 /***********************************************************************
927 * ImmEscapeA (IMM32.@)
929 LRESULT WINAPI
ImmEscapeA(
931 UINT uEscape
, LPVOID lpData
)
933 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
934 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
936 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
938 if (!EscapeRequiresWA(uEscape
) || !is_kbd_ime_unicode(immHkl
))
939 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
942 WCHAR buffer
[81]; /* largest required buffer should be 80 */
944 if (uEscape
== IME_ESC_SET_EUDC_DICTIONARY
)
946 MultiByteToWideChar(CP_ACP
,0,lpData
,-1,buffer
,81);
947 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
951 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
952 WideCharToMultiByte(CP_ACP
,0,buffer
,-1,lpData
,80, NULL
, NULL
);
961 /***********************************************************************
962 * ImmEscapeW (IMM32.@)
964 LRESULT WINAPI
ImmEscapeW(
966 UINT uEscape
, LPVOID lpData
)
968 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
969 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
971 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
973 if (!EscapeRequiresWA(uEscape
) || is_kbd_ime_unicode(immHkl
))
974 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
977 CHAR buffer
[81]; /* largest required buffer should be 80 */
979 if (uEscape
== IME_ESC_SET_EUDC_DICTIONARY
)
981 WideCharToMultiByte(CP_ACP
,0,lpData
,-1,buffer
,81, NULL
, NULL
);
982 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
986 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
987 MultiByteToWideChar(CP_ACP
,0,buffer
,-1,lpData
,80);
996 /***********************************************************************
997 * ImmGetCandidateListA (IMM32.@)
999 DWORD WINAPI
ImmGetCandidateListA(
1000 HIMC hIMC
, DWORD dwIndex
,
1001 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
1003 InputContextData
*data
= get_imc_data(hIMC
);
1004 LPCANDIDATEINFO candinfo
;
1005 LPCANDIDATELIST candlist
;
1008 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
1010 if (!data
|| !data
->IMC
.hCandInfo
)
1013 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1014 if (dwIndex
>= candinfo
->dwCount
|| dwIndex
>= ARRAY_SIZE(candinfo
->dwOffset
))
1017 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
1018 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
1021 if ( !is_himc_ime_unicode(data
) )
1023 ret
= candlist
->dwSize
;
1024 if ( lpCandList
&& dwBufLen
>= ret
)
1025 memcpy(lpCandList
, candlist
, ret
);
1028 ret
= convert_candidatelist_WtoA( candlist
, lpCandList
, dwBufLen
);
1031 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1035 /***********************************************************************
1036 * ImmGetCandidateListCountA (IMM32.@)
1038 DWORD WINAPI
ImmGetCandidateListCountA(
1039 HIMC hIMC
, LPDWORD lpdwListCount
)
1041 InputContextData
*data
= get_imc_data(hIMC
);
1042 LPCANDIDATEINFO candinfo
;
1045 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
1047 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
1050 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1052 *lpdwListCount
= count
= candinfo
->dwCount
;
1054 if ( !is_himc_ime_unicode(data
) )
1055 ret
= candinfo
->dwSize
;
1058 ret
= sizeof(CANDIDATEINFO
);
1060 ret
+= ImmGetCandidateListA(hIMC
, count
, NULL
, 0);
1063 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1067 /***********************************************************************
1068 * ImmGetCandidateListCountW (IMM32.@)
1070 DWORD WINAPI
ImmGetCandidateListCountW(
1071 HIMC hIMC
, LPDWORD lpdwListCount
)
1073 InputContextData
*data
= get_imc_data(hIMC
);
1074 LPCANDIDATEINFO candinfo
;
1077 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
1079 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
1082 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1084 *lpdwListCount
= count
= candinfo
->dwCount
;
1086 if ( is_himc_ime_unicode(data
) )
1087 ret
= candinfo
->dwSize
;
1090 ret
= sizeof(CANDIDATEINFO
);
1092 ret
+= ImmGetCandidateListW(hIMC
, count
, NULL
, 0);
1095 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1099 /***********************************************************************
1100 * ImmGetCandidateListW (IMM32.@)
1102 DWORD WINAPI
ImmGetCandidateListW(
1103 HIMC hIMC
, DWORD dwIndex
,
1104 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
1106 InputContextData
*data
= get_imc_data(hIMC
);
1107 LPCANDIDATEINFO candinfo
;
1108 LPCANDIDATELIST candlist
;
1111 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
1113 if (!data
|| !data
->IMC
.hCandInfo
)
1116 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1117 if (dwIndex
>= candinfo
->dwCount
|| dwIndex
>= ARRAY_SIZE(candinfo
->dwOffset
))
1120 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
1121 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
1124 if ( is_himc_ime_unicode(data
) )
1126 ret
= candlist
->dwSize
;
1127 if ( lpCandList
&& dwBufLen
>= ret
)
1128 memcpy(lpCandList
, candlist
, ret
);
1131 ret
= convert_candidatelist_AtoW( candlist
, lpCandList
, dwBufLen
);
1134 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1138 /***********************************************************************
1139 * ImmGetCandidateWindow (IMM32.@)
1141 BOOL WINAPI
ImmGetCandidateWindow(
1142 HIMC hIMC
, DWORD dwIndex
, LPCANDIDATEFORM lpCandidate
)
1144 InputContextData
*data
= get_imc_data(hIMC
);
1146 TRACE("%p, %d, %p\n", hIMC
, dwIndex
, lpCandidate
);
1148 if (!data
|| !lpCandidate
)
1151 if (dwIndex
>= ARRAY_SIZE(data
->IMC
.cfCandForm
))
1154 if (data
->IMC
.cfCandForm
[dwIndex
].dwIndex
!= dwIndex
)
1157 *lpCandidate
= data
->IMC
.cfCandForm
[dwIndex
];
1162 /***********************************************************************
1163 * ImmGetCompositionFontA (IMM32.@)
1165 BOOL WINAPI
ImmGetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
1170 TRACE("(%p, %p):\n", hIMC
, lplf
);
1172 rc
= ImmGetCompositionFontW(hIMC
,&lfW
);
1176 memcpy(lplf
,&lfW
,sizeof(LOGFONTA
));
1177 WideCharToMultiByte(CP_ACP
, 0, lfW
.lfFaceName
, -1, lplf
->lfFaceName
,
1178 LF_FACESIZE
, NULL
, NULL
);
1182 /***********************************************************************
1183 * ImmGetCompositionFontW (IMM32.@)
1185 BOOL WINAPI
ImmGetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
1187 InputContextData
*data
= get_imc_data(hIMC
);
1189 TRACE("(%p, %p):\n", hIMC
, lplf
);
1194 *lplf
= data
->IMC
.lfFont
.W
;
1200 /* Helpers for the GetCompositionString functions */
1202 static INT
CopyCompStringIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE target
, INT tlen
,
1207 if (is_himc_ime_unicode(data
) && !unicode
)
1208 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)source
, slen
, (LPSTR
)target
, tlen
, NULL
, NULL
);
1209 else if (!is_himc_ime_unicode(data
) && unicode
)
1210 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)source
, slen
, (LPWSTR
)target
, tlen
) * sizeof(WCHAR
);
1213 int dlen
= (unicode
)?sizeof(WCHAR
):sizeof(CHAR
);
1214 memcpy( target
, source
, min(slen
,tlen
)*dlen
);
1221 static INT
CopyCompAttrIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
, INT sslen
,
1222 LPBYTE target
, INT tlen
, BOOL unicode
)
1226 if (is_himc_ime_unicode(data
) && !unicode
)
1228 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, sslen
, NULL
, 0, NULL
, NULL
);
1231 const BYTE
*src
= source
;
1232 LPBYTE dst
= target
;
1233 int i
, j
= 0, k
= 0;
1237 for (i
= 0; i
< sslen
; ++i
)
1241 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)ssource
+ i
, 1,
1242 NULL
, 0, NULL
, NULL
);
1243 for (; len
> 0; --len
)
1256 else if (!is_himc_ime_unicode(data
) && unicode
)
1258 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, sslen
, NULL
, 0);
1261 const BYTE
*src
= source
;
1262 LPBYTE dst
= target
;
1267 for (i
= 0; i
< sslen
; ++i
)
1269 if (IsDBCSLeadByte(((LPSTR
)ssource
)[i
]))
1282 memcpy( target
, source
, min(slen
,tlen
));
1289 static INT
CopyCompClauseIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
,
1290 LPBYTE target
, INT tlen
, BOOL unicode
)
1294 if (is_himc_ime_unicode(data
) && !unicode
)
1302 tlen
/= sizeof (DWORD
);
1303 for (i
= 0; i
< tlen
; ++i
)
1305 ((DWORD
*)target
)[i
] = WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
,
1306 ((DWORD
*)source
)[i
],
1310 rc
= sizeof (DWORD
) * i
;
1315 else if (!is_himc_ime_unicode(data
) && unicode
)
1323 tlen
/= sizeof (DWORD
);
1324 for (i
= 0; i
< tlen
; ++i
)
1326 ((DWORD
*)target
)[i
] = MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
,
1327 ((DWORD
*)source
)[i
],
1330 rc
= sizeof (DWORD
) * i
;
1337 memcpy( target
, source
, min(slen
,tlen
));
1344 static INT
CopyCompOffsetIMEtoClient(InputContextData
*data
, DWORD offset
, LPBYTE ssource
, BOOL unicode
)
1348 if (is_himc_ime_unicode(data
) && !unicode
)
1350 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, offset
, NULL
, 0, NULL
, NULL
);
1352 else if (!is_himc_ime_unicode(data
) && unicode
)
1354 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, offset
, NULL
, 0);
1362 static LONG
ImmGetCompositionStringT( HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
,
1363 DWORD dwBufLen
, BOOL unicode
)
1366 InputContextData
*data
= get_imc_data(hIMC
);
1367 LPCOMPOSITIONSTRING compstr
;
1370 TRACE("(%p, 0x%x, %p, %d)\n", hIMC
, dwIndex
, lpBuf
, dwBufLen
);
1375 if (!data
->IMC
.hCompStr
)
1378 compdata
= ImmLockIMCC(data
->IMC
.hCompStr
);
1379 compstr
= (LPCOMPOSITIONSTRING
)compdata
;
1384 TRACE("GCS_RESULTSTR\n");
1385 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultStrOffset
, compstr
->dwResultStrLen
, lpBuf
, dwBufLen
, unicode
);
1388 TRACE("GCS_COMPSTR\n");
1389 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
, lpBuf
, dwBufLen
, unicode
);
1392 TRACE("GCS_COMPATTR\n");
1393 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompAttrOffset
, compstr
->dwCompAttrLen
,
1394 compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
,
1395 lpBuf
, dwBufLen
, unicode
);
1397 case GCS_COMPCLAUSE
:
1398 TRACE("GCS_COMPCLAUSE\n");
1399 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompClauseOffset
,compstr
->dwCompClauseLen
,
1400 compdata
+ compstr
->dwCompStrOffset
,
1401 lpBuf
, dwBufLen
, unicode
);
1403 case GCS_RESULTCLAUSE
:
1404 TRACE("GCS_RESULTCLAUSE\n");
1405 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultClauseOffset
,compstr
->dwResultClauseLen
,
1406 compdata
+ compstr
->dwResultStrOffset
,
1407 lpBuf
, dwBufLen
, unicode
);
1409 case GCS_RESULTREADSTR
:
1410 TRACE("GCS_RESULTREADSTR\n");
1411 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultReadStrOffset
, compstr
->dwResultReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1413 case GCS_RESULTREADCLAUSE
:
1414 TRACE("GCS_RESULTREADCLAUSE\n");
1415 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultReadClauseOffset
,compstr
->dwResultReadClauseLen
,
1416 compdata
+ compstr
->dwResultStrOffset
,
1417 lpBuf
, dwBufLen
, unicode
);
1419 case GCS_COMPREADSTR
:
1420 TRACE("GCS_COMPREADSTR\n");
1421 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1423 case GCS_COMPREADATTR
:
1424 TRACE("GCS_COMPREADATTR\n");
1425 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompReadAttrOffset
, compstr
->dwCompReadAttrLen
,
1426 compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
,
1427 lpBuf
, dwBufLen
, unicode
);
1429 case GCS_COMPREADCLAUSE
:
1430 TRACE("GCS_COMPREADCLAUSE\n");
1431 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompReadClauseOffset
,compstr
->dwCompReadClauseLen
,
1432 compdata
+ compstr
->dwCompStrOffset
,
1433 lpBuf
, dwBufLen
, unicode
);
1436 TRACE("GCS_CURSORPOS\n");
1437 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwCursorPos
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1439 case GCS_DELTASTART
:
1440 TRACE("GCS_DELTASTART\n");
1441 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwDeltaStart
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1444 FIXME("Unhandled index 0x%x\n",dwIndex
);
1448 ImmUnlockIMCC(data
->IMC
.hCompStr
);
1453 /***********************************************************************
1454 * ImmGetCompositionStringA (IMM32.@)
1456 LONG WINAPI
ImmGetCompositionStringA(
1457 HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
, DWORD dwBufLen
)
1459 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, FALSE
);
1463 /***********************************************************************
1464 * ImmGetCompositionStringW (IMM32.@)
1466 LONG WINAPI
ImmGetCompositionStringW(
1467 HIMC hIMC
, DWORD dwIndex
,
1468 LPVOID lpBuf
, DWORD dwBufLen
)
1470 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, TRUE
);
1473 /***********************************************************************
1474 * ImmGetCompositionWindow (IMM32.@)
1476 BOOL WINAPI
ImmGetCompositionWindow(HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
1478 InputContextData
*data
= get_imc_data(hIMC
);
1480 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
1485 *lpCompForm
= data
->IMC
.cfCompForm
;
1489 /***********************************************************************
1490 * ImmGetContext (IMM32.@)
1493 HIMC WINAPI
ImmGetContext(HWND hWnd
)
1497 TRACE("%p\n", hWnd
);
1499 if (!IsWindow(hWnd
))
1501 SetLastError(ERROR_INVALID_WINDOW_HANDLE
);
1505 rc
= GetPropW(hWnd
,szwWineIMCProperty
);
1508 else if (rc
== NULL
)
1509 rc
= get_default_context( hWnd
);
1513 InputContextData
*data
= rc
;
1514 data
->IMC
.hWnd
= hWnd
;
1517 TRACE("returning %p\n", rc
);
1522 /***********************************************************************
1523 * ImmGetConversionListA (IMM32.@)
1525 DWORD WINAPI
ImmGetConversionListA(
1527 LPCSTR pSrc
, LPCANDIDATELIST lpDst
,
1528 DWORD dwBufLen
, UINT uFlag
)
1530 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1531 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_a(pSrc
), lpDst
,
1533 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1535 if (!is_kbd_ime_unicode(immHkl
))
1536 return immHkl
->pImeConversionList(hIMC
,(LPCWSTR
)pSrc
,lpDst
,dwBufLen
,uFlag
);
1539 LPCANDIDATELIST lpwDst
;
1541 LPWSTR pwSrc
= strdupAtoW(pSrc
);
1543 len
= immHkl
->pImeConversionList(hIMC
, pwSrc
, NULL
, 0, uFlag
);
1544 lpwDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1547 immHkl
->pImeConversionList(hIMC
, pwSrc
, lpwDst
, len
, uFlag
);
1548 ret
= convert_candidatelist_WtoA( lpwDst
, lpDst
, dwBufLen
);
1549 HeapFree(GetProcessHeap(), 0, lpwDst
);
1551 HeapFree(GetProcessHeap(), 0, pwSrc
);
1560 /***********************************************************************
1561 * ImmGetConversionListW (IMM32.@)
1563 DWORD WINAPI
ImmGetConversionListW(
1565 LPCWSTR pSrc
, LPCANDIDATELIST lpDst
,
1566 DWORD dwBufLen
, UINT uFlag
)
1568 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1569 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_w(pSrc
), lpDst
,
1571 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1573 if (is_kbd_ime_unicode(immHkl
))
1574 return immHkl
->pImeConversionList(hIMC
,pSrc
,lpDst
,dwBufLen
,uFlag
);
1577 LPCANDIDATELIST lpaDst
;
1579 LPSTR paSrc
= strdupWtoA(pSrc
);
1581 len
= immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, NULL
, 0, uFlag
);
1582 lpaDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1585 immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, lpaDst
, len
, uFlag
);
1586 ret
= convert_candidatelist_AtoW( lpaDst
, lpDst
, dwBufLen
);
1587 HeapFree(GetProcessHeap(), 0, lpaDst
);
1589 HeapFree(GetProcessHeap(), 0, paSrc
);
1598 /***********************************************************************
1599 * ImmGetConversionStatus (IMM32.@)
1601 BOOL WINAPI
ImmGetConversionStatus(
1602 HIMC hIMC
, LPDWORD lpfdwConversion
, LPDWORD lpfdwSentence
)
1604 InputContextData
*data
= get_imc_data(hIMC
);
1606 TRACE("%p %p %p\n", hIMC
, lpfdwConversion
, lpfdwSentence
);
1611 if (lpfdwConversion
)
1612 *lpfdwConversion
= data
->IMC
.fdwConversion
;
1614 *lpfdwSentence
= data
->IMC
.fdwSentence
;
1619 static BOOL
needs_ime_window(HWND hwnd
)
1623 if (GetClassNameW(hwnd
, classW
, ARRAY_SIZE(classW
)) && !strcmpW(classW
, szwIME
))
1625 if (GetClassLongPtrW(hwnd
, GCL_STYLE
) & CS_IME
) return FALSE
;
1630 /***********************************************************************
1631 * __wine_register_window (IMM32.@)
1633 BOOL WINAPI
__wine_register_window(HWND hwnd
)
1636 IMMThreadData
*thread_data
;
1637 TRACE("(%p)\n", hwnd
);
1639 if (!needs_ime_window(hwnd
))
1642 thread_data
= IMM_GetThreadData(hwnd
, 0);
1646 if (thread_data
->disableIME
|| disable_ime
)
1648 TRACE("IME for this thread is disabled\n");
1649 LeaveCriticalSection(&threaddata_cs
);
1652 thread_data
->windowRefs
++;
1653 TRACE("windowRefs=%u, hwndDefault=%p\n",
1654 thread_data
->windowRefs
, thread_data
->hwndDefault
);
1656 /* Create default IME window */
1657 if (thread_data
->windowRefs
== 1)
1659 /* Do not create the window inside of a critical section */
1660 LeaveCriticalSection(&threaddata_cs
);
1661 new = CreateWindowExW( 0, szwIME
, szwDefaultIME
,
1662 WS_POPUP
| WS_DISABLED
| WS_CLIPSIBLINGS
,
1663 0, 0, 1, 1, 0, 0, 0, 0);
1664 /* thread_data is in the current thread so we can assume it's still valid */
1665 EnterCriticalSection(&threaddata_cs
);
1666 /* See if anyone beat us */
1667 if (thread_data
->hwndDefault
== NULL
)
1669 thread_data
->hwndDefault
= new;
1671 TRACE("Default is %p\n", thread_data
->hwndDefault
);
1675 LeaveCriticalSection(&threaddata_cs
);
1677 /* Clean up an unused new window outside of the critical section */
1683 /***********************************************************************
1684 * __wine_unregister_window (IMM32.@)
1686 void WINAPI
__wine_unregister_window(HWND hwnd
)
1688 HWND to_destroy
= 0;
1689 IMMThreadData
*thread_data
;
1690 TRACE("(%p)\n", hwnd
);
1692 thread_data
= IMM_GetThreadData(hwnd
, 0);
1693 if (!thread_data
) return;
1695 thread_data
->windowRefs
--;
1696 TRACE("windowRefs=%u, hwndDefault=%p\n",
1697 thread_data
->windowRefs
, thread_data
->hwndDefault
);
1699 /* Destroy default IME window */
1700 if (thread_data
->windowRefs
== 0 && thread_data
->hwndDefault
)
1702 to_destroy
= thread_data
->hwndDefault
;
1703 thread_data
->hwndDefault
= NULL
;
1705 LeaveCriticalSection(&threaddata_cs
);
1707 if (to_destroy
) DestroyWindow( to_destroy
);
1710 /***********************************************************************
1711 * ImmGetDefaultIMEWnd (IMM32.@)
1713 HWND WINAPI
ImmGetDefaultIMEWnd(HWND hWnd
)
1716 IMMThreadData
* thread_data
= IMM_GetThreadData(hWnd
, 0);
1719 ret
= thread_data
->hwndDefault
;
1720 LeaveCriticalSection(&threaddata_cs
);
1721 TRACE("Default is %p\n",ret
);
1725 /***********************************************************************
1726 * ImmGetDescriptionA (IMM32.@)
1728 UINT WINAPI
ImmGetDescriptionA(
1729 HKL hKL
, LPSTR lpszDescription
, UINT uBufLen
)
1734 TRACE("%p %p %d\n", hKL
, lpszDescription
, uBufLen
);
1736 /* find out how many characters in the unicode buffer */
1737 len
= ImmGetDescriptionW( hKL
, NULL
, 0 );
1741 /* allocate a buffer of that size */
1742 buf
= HeapAlloc( GetProcessHeap(), 0, (len
+ 1) * sizeof (WCHAR
) );
1746 /* fetch the unicode buffer */
1747 len
= ImmGetDescriptionW( hKL
, buf
, len
+ 1 );
1749 /* convert it back to ASCII */
1750 len
= WideCharToMultiByte( CP_ACP
, 0, buf
, len
+ 1,
1751 lpszDescription
, uBufLen
, NULL
, NULL
);
1753 HeapFree( GetProcessHeap(), 0, buf
);
1761 /***********************************************************************
1762 * ImmGetDescriptionW (IMM32.@)
1764 UINT WINAPI
ImmGetDescriptionW(HKL hKL
, LPWSTR lpszDescription
, UINT uBufLen
)
1766 static const WCHAR name
[] = { 'W','i','n','e',' ','X','I','M',0 };
1768 FIXME("(%p, %p, %d): semi stub\n", hKL
, lpszDescription
, uBufLen
);
1771 if (!uBufLen
) return lstrlenW( name
);
1772 lstrcpynW( lpszDescription
, name
, uBufLen
);
1773 return lstrlenW( lpszDescription
);
1776 /***********************************************************************
1777 * ImmGetGuideLineA (IMM32.@)
1779 DWORD WINAPI
ImmGetGuideLineA(
1780 HIMC hIMC
, DWORD dwIndex
, LPSTR lpBuf
, DWORD dwBufLen
)
1782 FIXME("(%p, %d, %s, %d): stub\n",
1783 hIMC
, dwIndex
, debugstr_a(lpBuf
), dwBufLen
1785 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1789 /***********************************************************************
1790 * ImmGetGuideLineW (IMM32.@)
1792 DWORD WINAPI
ImmGetGuideLineW(HIMC hIMC
, DWORD dwIndex
, LPWSTR lpBuf
, DWORD dwBufLen
)
1794 FIXME("(%p, %d, %s, %d): stub\n",
1795 hIMC
, dwIndex
, debugstr_w(lpBuf
), dwBufLen
1797 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1801 /***********************************************************************
1802 * ImmGetIMEFileNameA (IMM32.@)
1804 UINT WINAPI
ImmGetIMEFileNameA( HKL hKL
, LPSTR lpszFileName
, UINT uBufLen
)
1807 UINT wBufLen
= uBufLen
;
1810 if (uBufLen
&& lpszFileName
)
1811 bufW
= HeapAlloc(GetProcessHeap(),0,uBufLen
* sizeof(WCHAR
));
1812 else /* We need this to get the number of byte required */
1814 bufW
= HeapAlloc(GetProcessHeap(),0,MAX_PATH
* sizeof(WCHAR
));
1818 rc
= ImmGetIMEFileNameW(hKL
,bufW
,wBufLen
);
1822 if (uBufLen
&& lpszFileName
)
1823 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, lpszFileName
,
1824 uBufLen
, NULL
, NULL
);
1825 else /* get the length */
1826 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, NULL
, 0, NULL
,
1830 HeapFree(GetProcessHeap(),0,bufW
);
1834 /***********************************************************************
1835 * ImmGetIMEFileNameW (IMM32.@)
1837 UINT WINAPI
ImmGetIMEFileNameW(HKL hKL
, LPWSTR lpszFileName
, UINT uBufLen
)
1842 WCHAR regKey
[ARRAY_SIZE(szImeRegFmt
)+8];
1844 wsprintfW( regKey
, szImeRegFmt
, (ULONG_PTR
)hKL
);
1845 rc
= RegOpenKeyW( HKEY_LOCAL_MACHINE
, regKey
, &hkey
);
1846 if (rc
!= ERROR_SUCCESS
)
1853 rc
= RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, NULL
, &length
);
1855 if (rc
!= ERROR_SUCCESS
)
1861 if (length
> uBufLen
* sizeof(WCHAR
) || !lpszFileName
)
1866 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
1870 return length
/ sizeof(WCHAR
);
1873 RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, lpszFileName
, &length
);
1877 return length
/ sizeof(WCHAR
);
1880 /***********************************************************************
1881 * ImmGetOpenStatus (IMM32.@)
1883 BOOL WINAPI
ImmGetOpenStatus(HIMC hIMC
)
1885 InputContextData
*data
= get_imc_data(hIMC
);
1891 TRACE("(%p): semi-stub\n", hIMC
);
1894 FIXME("(%p): semi-stub\n", hIMC
);
1896 return data
->IMC
.fOpen
;
1899 /***********************************************************************
1900 * ImmGetProperty (IMM32.@)
1902 DWORD WINAPI
ImmGetProperty(HKL hKL
, DWORD fdwIndex
)
1907 TRACE("(%p, %d)\n", hKL
, fdwIndex
);
1908 kbd
= IMM_GetImmHkl(hKL
);
1910 if (kbd
&& kbd
->hIME
)
1914 case IGP_PROPERTY
: rc
= kbd
->imeInfo
.fdwProperty
; break;
1915 case IGP_CONVERSION
: rc
= kbd
->imeInfo
.fdwConversionCaps
; break;
1916 case IGP_SENTENCE
: rc
= kbd
->imeInfo
.fdwSentenceCaps
; break;
1917 case IGP_SETCOMPSTR
: rc
= kbd
->imeInfo
.fdwSCSCaps
; break;
1918 case IGP_SELECT
: rc
= kbd
->imeInfo
.fdwSelectCaps
; break;
1919 case IGP_GETIMEVERSION
: rc
= IMEVER_0400
; break;
1920 case IGP_UI
: rc
= 0; break;
1927 /***********************************************************************
1928 * ImmGetRegisterWordStyleA (IMM32.@)
1930 UINT WINAPI
ImmGetRegisterWordStyleA(
1931 HKL hKL
, UINT nItem
, LPSTYLEBUFA lpStyleBuf
)
1933 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1934 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1935 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1937 if (!is_kbd_ime_unicode(immHkl
))
1938 return immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)lpStyleBuf
);
1944 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,&sbw
);
1945 WideCharToMultiByte(CP_ACP
, 0, sbw
.szDescription
, -1,
1946 lpStyleBuf
->szDescription
, 32, NULL
, NULL
);
1947 lpStyleBuf
->dwStyle
= sbw
.dwStyle
;
1955 /***********************************************************************
1956 * ImmGetRegisterWordStyleW (IMM32.@)
1958 UINT WINAPI
ImmGetRegisterWordStyleW(
1959 HKL hKL
, UINT nItem
, LPSTYLEBUFW lpStyleBuf
)
1961 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1962 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1963 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1965 if (is_kbd_ime_unicode(immHkl
))
1966 return immHkl
->pImeGetRegisterWordStyle(nItem
,lpStyleBuf
);
1972 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)&sba
);
1973 MultiByteToWideChar(CP_ACP
, 0, sba
.szDescription
, -1,
1974 lpStyleBuf
->szDescription
, 32);
1975 lpStyleBuf
->dwStyle
= sba
.dwStyle
;
1983 /***********************************************************************
1984 * ImmGetStatusWindowPos (IMM32.@)
1986 BOOL WINAPI
ImmGetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
1988 InputContextData
*data
= get_imc_data(hIMC
);
1990 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
1992 if (!data
|| !lpptPos
)
1995 *lpptPos
= data
->IMC
.ptStatusWndPos
;
2000 /***********************************************************************
2001 * ImmGetVirtualKey (IMM32.@)
2003 UINT WINAPI
ImmGetVirtualKey(HWND hWnd
)
2005 OSVERSIONINFOA version
;
2006 InputContextData
*data
= ImmGetContext( hWnd
);
2007 TRACE("%p\n", hWnd
);
2010 return data
->lastVK
;
2012 version
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFOA
);
2013 GetVersionExA( &version
);
2014 switch(version
.dwPlatformId
)
2016 case VER_PLATFORM_WIN32_WINDOWS
:
2017 return VK_PROCESSKEY
;
2018 case VER_PLATFORM_WIN32_NT
:
2021 FIXME("%d not supported\n",version
.dwPlatformId
);
2022 return VK_PROCESSKEY
;
2026 /***********************************************************************
2027 * ImmInstallIMEA (IMM32.@)
2029 HKL WINAPI
ImmInstallIMEA(
2030 LPCSTR lpszIMEFileName
, LPCSTR lpszLayoutText
)
2032 LPWSTR lpszwIMEFileName
;
2033 LPWSTR lpszwLayoutText
;
2036 TRACE ("(%s, %s)\n", debugstr_a(lpszIMEFileName
),
2037 debugstr_a(lpszLayoutText
));
2039 lpszwIMEFileName
= strdupAtoW(lpszIMEFileName
);
2040 lpszwLayoutText
= strdupAtoW(lpszLayoutText
);
2042 hkl
= ImmInstallIMEW(lpszwIMEFileName
, lpszwLayoutText
);
2044 HeapFree(GetProcessHeap(),0,lpszwIMEFileName
);
2045 HeapFree(GetProcessHeap(),0,lpszwLayoutText
);
2049 /***********************************************************************
2050 * ImmInstallIMEW (IMM32.@)
2052 HKL WINAPI
ImmInstallIMEW(
2053 LPCWSTR lpszIMEFileName
, LPCWSTR lpszLayoutText
)
2055 INT lcid
= GetUserDefaultLCID();
2060 WCHAR regKey
[ARRAY_SIZE(szImeRegFmt
)+8];
2062 TRACE ("(%s, %s):\n", debugstr_w(lpszIMEFileName
),
2063 debugstr_w(lpszLayoutText
));
2065 /* Start with 2. e001 will be blank and so default to the wine internal IME */
2068 while (count
< 0xfff)
2070 DWORD disposition
= 0;
2072 hkl
= (HKL
)MAKELPARAM( lcid
, 0xe000 | count
);
2073 wsprintfW( regKey
, szImeRegFmt
, (ULONG_PTR
)hkl
);
2075 rc
= RegCreateKeyExW(HKEY_LOCAL_MACHINE
, regKey
, 0, NULL
, 0, KEY_WRITE
, NULL
, &hkey
, &disposition
);
2076 if (rc
== ERROR_SUCCESS
&& disposition
== REG_CREATED_NEW_KEY
)
2078 else if (rc
== ERROR_SUCCESS
)
2086 WARN("Unable to find slot to install IME\n");
2090 if (rc
== ERROR_SUCCESS
)
2092 rc
= RegSetValueExW(hkey
, szImeFileW
, 0, REG_SZ
, (const BYTE
*)lpszIMEFileName
,
2093 (lstrlenW(lpszIMEFileName
) + 1) * sizeof(WCHAR
));
2094 if (rc
== ERROR_SUCCESS
)
2095 rc
= RegSetValueExW(hkey
, szLayoutTextW
, 0, REG_SZ
, (const BYTE
*)lpszLayoutText
,
2096 (lstrlenW(lpszLayoutText
) + 1) * sizeof(WCHAR
));
2102 WARN("Unable to set IME registry values\n");
2107 /***********************************************************************
2108 * ImmIsIME (IMM32.@)
2110 BOOL WINAPI
ImmIsIME(HKL hKL
)
2113 TRACE("(%p):\n", hKL
);
2114 ptr
= IMM_GetImmHkl(hKL
);
2115 return (ptr
&& ptr
->hIME
);
2118 /***********************************************************************
2119 * ImmIsUIMessageA (IMM32.@)
2121 BOOL WINAPI
ImmIsUIMessageA(
2122 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
2124 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
2125 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
2126 (msg
== WM_IME_SETCONTEXT
) ||
2127 (msg
== WM_IME_NOTIFY
) ||
2128 (msg
== WM_IME_COMPOSITIONFULL
) ||
2129 (msg
== WM_IME_SELECT
) ||
2130 (msg
== 0x287 /* FIXME: WM_IME_SYSTEM */))
2133 SendMessageA(hWndIME
, msg
, wParam
, lParam
);
2140 /***********************************************************************
2141 * ImmIsUIMessageW (IMM32.@)
2143 BOOL WINAPI
ImmIsUIMessageW(
2144 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
2146 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
2147 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
2148 (msg
== WM_IME_SETCONTEXT
) ||
2149 (msg
== WM_IME_NOTIFY
) ||
2150 (msg
== WM_IME_COMPOSITIONFULL
) ||
2151 (msg
== WM_IME_SELECT
) ||
2152 (msg
== 0x287 /* FIXME: WM_IME_SYSTEM */))
2155 SendMessageW(hWndIME
, msg
, wParam
, lParam
);
2162 /***********************************************************************
2163 * ImmNotifyIME (IMM32.@)
2165 BOOL WINAPI
ImmNotifyIME(
2166 HIMC hIMC
, DWORD dwAction
, DWORD dwIndex
, DWORD dwValue
)
2168 InputContextData
*data
= get_imc_data(hIMC
);
2170 TRACE("(%p, %d, %d, %d)\n",
2171 hIMC
, dwAction
, dwIndex
, dwValue
);
2175 SetLastError(ERROR_SUCCESS
);
2179 if (!data
|| ! data
->immKbd
->pNotifyIME
)
2184 return data
->immKbd
->pNotifyIME(hIMC
,dwAction
,dwIndex
,dwValue
);
2187 /***********************************************************************
2188 * ImmRegisterWordA (IMM32.@)
2190 BOOL WINAPI
ImmRegisterWordA(
2191 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszRegister
)
2193 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2194 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
2195 debugstr_a(lpszRegister
));
2196 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
2198 if (!is_kbd_ime_unicode(immHkl
))
2199 return immHkl
->pImeRegisterWord((LPCWSTR
)lpszReading
,dwStyle
,
2200 (LPCWSTR
)lpszRegister
);
2203 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
2204 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
2207 rc
= immHkl
->pImeRegisterWord(lpszwReading
,dwStyle
,lpszwRegister
);
2208 HeapFree(GetProcessHeap(),0,lpszwReading
);
2209 HeapFree(GetProcessHeap(),0,lpszwRegister
);
2217 /***********************************************************************
2218 * ImmRegisterWordW (IMM32.@)
2220 BOOL WINAPI
ImmRegisterWordW(
2221 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszRegister
)
2223 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2224 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
2225 debugstr_w(lpszRegister
));
2226 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
2228 if (is_kbd_ime_unicode(immHkl
))
2229 return immHkl
->pImeRegisterWord(lpszReading
,dwStyle
,lpszRegister
);
2232 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2233 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
2236 rc
= immHkl
->pImeRegisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2237 (LPCWSTR
)lpszaRegister
);
2238 HeapFree(GetProcessHeap(),0,lpszaReading
);
2239 HeapFree(GetProcessHeap(),0,lpszaRegister
);
2247 /***********************************************************************
2248 * ImmReleaseContext (IMM32.@)
2250 BOOL WINAPI
ImmReleaseContext(HWND hWnd
, HIMC hIMC
)
2252 static BOOL shown
= FALSE
;
2255 FIXME("(%p, %p): stub\n", hWnd
, hIMC
);
2261 /***********************************************************************
2262 * ImmRequestMessageA(IMM32.@)
2264 LRESULT WINAPI
ImmRequestMessageA(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
2266 InputContextData
*data
= get_imc_data(hIMC
);
2268 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
2270 if (data
) return SendMessageA(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
2272 SetLastError(ERROR_INVALID_HANDLE
);
2276 /***********************************************************************
2277 * ImmRequestMessageW(IMM32.@)
2279 LRESULT WINAPI
ImmRequestMessageW(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
2281 InputContextData
*data
= get_imc_data(hIMC
);
2283 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
2285 if (data
) return SendMessageW(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
2287 SetLastError(ERROR_INVALID_HANDLE
);
2291 /***********************************************************************
2292 * ImmSetCandidateWindow (IMM32.@)
2294 BOOL WINAPI
ImmSetCandidateWindow(
2295 HIMC hIMC
, LPCANDIDATEFORM lpCandidate
)
2297 InputContextData
*data
= get_imc_data(hIMC
);
2299 TRACE("(%p, %p)\n", hIMC
, lpCandidate
);
2301 if (!data
|| !lpCandidate
)
2304 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2307 TRACE("\t%x, %x, %s, %s\n",
2308 lpCandidate
->dwIndex
, lpCandidate
->dwStyle
,
2309 wine_dbgstr_point(&lpCandidate
->ptCurrentPos
),
2310 wine_dbgstr_rect(&lpCandidate
->rcArea
));
2312 if (lpCandidate
->dwIndex
>= ARRAY_SIZE(data
->IMC
.cfCandForm
))
2315 data
->IMC
.cfCandForm
[lpCandidate
->dwIndex
] = *lpCandidate
;
2316 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCANDIDATEPOS
);
2317 ImmInternalSendIMENotify(data
, IMN_SETCANDIDATEPOS
, 1 << lpCandidate
->dwIndex
);
2322 /***********************************************************************
2323 * ImmSetCompositionFontA (IMM32.@)
2325 BOOL WINAPI
ImmSetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
2327 InputContextData
*data
= get_imc_data(hIMC
);
2328 TRACE("(%p, %p)\n", hIMC
, lplf
);
2332 SetLastError(ERROR_INVALID_HANDLE
);
2336 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2339 memcpy(&data
->IMC
.lfFont
.W
,lplf
,sizeof(LOGFONTA
));
2340 MultiByteToWideChar(CP_ACP
, 0, lplf
->lfFaceName
, -1, data
->IMC
.lfFont
.W
.lfFaceName
,
2342 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2343 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2348 /***********************************************************************
2349 * ImmSetCompositionFontW (IMM32.@)
2351 BOOL WINAPI
ImmSetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
2353 InputContextData
*data
= get_imc_data(hIMC
);
2354 TRACE("(%p, %p)\n", hIMC
, lplf
);
2358 SetLastError(ERROR_INVALID_HANDLE
);
2362 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2365 data
->IMC
.lfFont
.W
= *lplf
;
2366 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2367 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2372 /***********************************************************************
2373 * ImmSetCompositionStringA (IMM32.@)
2375 BOOL WINAPI
ImmSetCompositionStringA(
2376 HIMC hIMC
, DWORD dwIndex
,
2377 LPCVOID lpComp
, DWORD dwCompLen
,
2378 LPCVOID lpRead
, DWORD dwReadLen
)
2382 WCHAR
*CompBuffer
= NULL
;
2383 WCHAR
*ReadBuffer
= NULL
;
2385 InputContextData
*data
= get_imc_data(hIMC
);
2387 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2388 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2393 if (!(dwIndex
== SCS_SETSTR
||
2394 dwIndex
== SCS_CHANGEATTR
||
2395 dwIndex
== SCS_CHANGECLAUSE
||
2396 dwIndex
== SCS_SETRECONVERTSTRING
||
2397 dwIndex
== SCS_QUERYRECONVERTSTRING
))
2400 if (!is_himc_ime_unicode(data
))
2401 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2402 dwCompLen
, lpRead
, dwReadLen
);
2404 comp_len
= MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0);
2407 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
* sizeof(WCHAR
));
2408 MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
);
2411 read_len
= MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0);
2414 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
* sizeof(WCHAR
));
2415 MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
);
2418 rc
= ImmSetCompositionStringW(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2419 ReadBuffer
, read_len
);
2421 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2422 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2427 /***********************************************************************
2428 * ImmSetCompositionStringW (IMM32.@)
2430 BOOL WINAPI
ImmSetCompositionStringW(
2431 HIMC hIMC
, DWORD dwIndex
,
2432 LPCVOID lpComp
, DWORD dwCompLen
,
2433 LPCVOID lpRead
, DWORD dwReadLen
)
2437 CHAR
*CompBuffer
= NULL
;
2438 CHAR
*ReadBuffer
= NULL
;
2440 InputContextData
*data
= get_imc_data(hIMC
);
2442 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2443 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2448 if (!(dwIndex
== SCS_SETSTR
||
2449 dwIndex
== SCS_CHANGEATTR
||
2450 dwIndex
== SCS_CHANGECLAUSE
||
2451 dwIndex
== SCS_SETRECONVERTSTRING
||
2452 dwIndex
== SCS_QUERYRECONVERTSTRING
))
2455 if (is_himc_ime_unicode(data
))
2456 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2457 dwCompLen
, lpRead
, dwReadLen
);
2459 comp_len
= WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0, NULL
,
2463 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
);
2464 WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
,
2468 read_len
= WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0, NULL
,
2472 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
);
2473 WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
,
2477 rc
= ImmSetCompositionStringA(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2478 ReadBuffer
, read_len
);
2480 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2481 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2486 /***********************************************************************
2487 * ImmSetCompositionWindow (IMM32.@)
2489 BOOL WINAPI
ImmSetCompositionWindow(
2490 HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
2492 BOOL reshow
= FALSE
;
2493 InputContextData
*data
= get_imc_data(hIMC
);
2495 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
2497 TRACE("\t%x, %s, %s\n", lpCompForm
->dwStyle
,
2498 wine_dbgstr_point(&lpCompForm
->ptCurrentPos
),
2499 wine_dbgstr_rect(&lpCompForm
->rcArea
));
2503 SetLastError(ERROR_INVALID_HANDLE
);
2507 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2510 data
->IMC
.cfCompForm
= *lpCompForm
;
2512 if (IsWindowVisible(data
->immKbd
->UIWnd
))
2515 ShowWindow(data
->immKbd
->UIWnd
,SW_HIDE
);
2518 /* FIXME: this is a partial stub */
2521 ShowWindow(data
->immKbd
->UIWnd
,SW_SHOWNOACTIVATE
);
2523 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONWINDOW
, 0);
2527 /***********************************************************************
2528 * ImmSetConversionStatus (IMM32.@)
2530 BOOL WINAPI
ImmSetConversionStatus(
2531 HIMC hIMC
, DWORD fdwConversion
, DWORD fdwSentence
)
2533 DWORD oldConversion
, oldSentence
;
2534 InputContextData
*data
= get_imc_data(hIMC
);
2536 TRACE("%p %d %d\n", hIMC
, fdwConversion
, fdwSentence
);
2540 SetLastError(ERROR_INVALID_HANDLE
);
2544 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2547 if ( fdwConversion
!= data
->IMC
.fdwConversion
)
2549 oldConversion
= data
->IMC
.fdwConversion
;
2550 data
->IMC
.fdwConversion
= fdwConversion
;
2551 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldConversion
, IMC_SETCONVERSIONMODE
);
2552 ImmInternalSendIMENotify(data
, IMN_SETCONVERSIONMODE
, 0);
2554 if ( fdwSentence
!= data
->IMC
.fdwSentence
)
2556 oldSentence
= data
->IMC
.fdwSentence
;
2557 data
->IMC
.fdwSentence
= fdwSentence
;
2558 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldSentence
, IMC_SETSENTENCEMODE
);
2559 ImmInternalSendIMENotify(data
, IMN_SETSENTENCEMODE
, 0);
2565 /***********************************************************************
2566 * ImmSetOpenStatus (IMM32.@)
2568 BOOL WINAPI
ImmSetOpenStatus(HIMC hIMC
, BOOL fOpen
)
2570 InputContextData
*data
= get_imc_data(hIMC
);
2572 TRACE("%p %d\n", hIMC
, fOpen
);
2576 SetLastError(ERROR_INVALID_HANDLE
);
2580 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2583 if (data
->immKbd
->UIWnd
== NULL
)
2585 /* create the ime window */
2586 data
->immKbd
->UIWnd
= CreateWindowExW( WS_EX_TOOLWINDOW
,
2587 data
->immKbd
->imeClassName
, NULL
, WS_POPUP
, 0, 0, 1, 1, 0,
2588 0, data
->immKbd
->hIME
, 0);
2589 SetWindowLongPtrW(data
->immKbd
->UIWnd
, IMMGWL_IMC
, (LONG_PTR
)data
);
2592 SetWindowLongPtrW(data
->immKbd
->UIWnd
, IMMGWL_IMC
, (LONG_PTR
)data
);
2594 if (!fOpen
!= !data
->IMC
.fOpen
)
2596 data
->IMC
.fOpen
= fOpen
;
2597 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETOPENSTATUS
);
2598 ImmInternalSendIMENotify(data
, IMN_SETOPENSTATUS
, 0);
2604 /***********************************************************************
2605 * ImmSetStatusWindowPos (IMM32.@)
2607 BOOL WINAPI
ImmSetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
2609 InputContextData
*data
= get_imc_data(hIMC
);
2611 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
2613 if (!data
|| !lpptPos
)
2615 SetLastError(ERROR_INVALID_HANDLE
);
2619 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2622 TRACE("\t%s\n", wine_dbgstr_point(lpptPos
));
2624 data
->IMC
.ptStatusWndPos
= *lpptPos
;
2625 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETSTATUSWINDOWPOS
);
2626 ImmInternalSendIMENotify(data
, IMN_SETSTATUSWINDOWPOS
, 0);
2631 /***********************************************************************
2632 * ImmCreateSoftKeyboard(IMM32.@)
2634 HWND WINAPI
ImmCreateSoftKeyboard(UINT uType
, UINT hOwner
, int x
, int y
)
2636 FIXME("(%d, %d, %d, %d): stub\n", uType
, hOwner
, x
, y
);
2637 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2641 /***********************************************************************
2642 * ImmDestroySoftKeyboard(IMM32.@)
2644 BOOL WINAPI
ImmDestroySoftKeyboard(HWND hSoftWnd
)
2646 FIXME("(%p): stub\n", hSoftWnd
);
2647 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2651 /***********************************************************************
2652 * ImmShowSoftKeyboard(IMM32.@)
2654 BOOL WINAPI
ImmShowSoftKeyboard(HWND hSoftWnd
, int nCmdShow
)
2656 FIXME("(%p, %d): stub\n", hSoftWnd
, nCmdShow
);
2657 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2661 /***********************************************************************
2662 * ImmSimulateHotKey (IMM32.@)
2664 BOOL WINAPI
ImmSimulateHotKey(HWND hWnd
, DWORD dwHotKeyID
)
2666 FIXME("(%p, %d): stub\n", hWnd
, dwHotKeyID
);
2667 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2671 /***********************************************************************
2672 * ImmUnregisterWordA (IMM32.@)
2674 BOOL WINAPI
ImmUnregisterWordA(
2675 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszUnregister
)
2677 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2678 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
2679 debugstr_a(lpszUnregister
));
2680 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2682 if (!is_kbd_ime_unicode(immHkl
))
2683 return immHkl
->pImeUnregisterWord((LPCWSTR
)lpszReading
,dwStyle
,
2684 (LPCWSTR
)lpszUnregister
);
2687 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
2688 LPWSTR lpszwUnregister
= strdupAtoW(lpszUnregister
);
2691 rc
= immHkl
->pImeUnregisterWord(lpszwReading
,dwStyle
,lpszwUnregister
);
2692 HeapFree(GetProcessHeap(),0,lpszwReading
);
2693 HeapFree(GetProcessHeap(),0,lpszwUnregister
);
2701 /***********************************************************************
2702 * ImmUnregisterWordW (IMM32.@)
2704 BOOL WINAPI
ImmUnregisterWordW(
2705 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszUnregister
)
2707 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2708 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
2709 debugstr_w(lpszUnregister
));
2710 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2712 if (is_kbd_ime_unicode(immHkl
))
2713 return immHkl
->pImeUnregisterWord(lpszReading
,dwStyle
,lpszUnregister
);
2716 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2717 LPSTR lpszaUnregister
= strdupWtoA(lpszUnregister
);
2720 rc
= immHkl
->pImeUnregisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2721 (LPCWSTR
)lpszaUnregister
);
2722 HeapFree(GetProcessHeap(),0,lpszaReading
);
2723 HeapFree(GetProcessHeap(),0,lpszaUnregister
);
2731 /***********************************************************************
2732 * ImmGetImeMenuItemsA (IMM32.@)
2734 DWORD WINAPI
ImmGetImeMenuItemsA( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2735 LPIMEMENUITEMINFOA lpImeParentMenu
, LPIMEMENUITEMINFOA lpImeMenu
,
2738 InputContextData
*data
= get_imc_data(hIMC
);
2739 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2740 lpImeParentMenu
, lpImeMenu
, dwSize
);
2744 SetLastError(ERROR_INVALID_HANDLE
);
2748 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2750 if (!is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2751 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2752 (IMEMENUITEMINFOW
*)lpImeParentMenu
,
2753 (IMEMENUITEMINFOW
*)lpImeMenu
, dwSize
);
2756 IMEMENUITEMINFOW lpImeParentMenuW
;
2757 IMEMENUITEMINFOW
*lpImeMenuW
, *parent
= NULL
;
2760 if (lpImeParentMenu
)
2761 parent
= &lpImeParentMenuW
;
2764 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOA
);
2765 dwSize
= count
* sizeof(IMEMENUITEMINFOW
);
2766 lpImeMenuW
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2771 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2772 parent
, lpImeMenuW
, dwSize
);
2774 if (lpImeParentMenu
)
2776 memcpy(lpImeParentMenu
,&lpImeParentMenuW
,sizeof(IMEMENUITEMINFOA
));
2777 lpImeParentMenu
->hbmpItem
= lpImeParentMenuW
.hbmpItem
;
2778 WideCharToMultiByte(CP_ACP
, 0, lpImeParentMenuW
.szString
,
2779 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
,
2782 if (lpImeMenu
&& rc
)
2785 for (i
= 0; i
< rc
; i
++)
2787 memcpy(&lpImeMenu
[i
],&lpImeMenuW
[1],sizeof(IMEMENUITEMINFOA
));
2788 lpImeMenu
[i
].hbmpItem
= lpImeMenuW
[i
].hbmpItem
;
2789 WideCharToMultiByte(CP_ACP
, 0, lpImeMenuW
[i
].szString
,
2790 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
,
2794 HeapFree(GetProcessHeap(),0,lpImeMenuW
);
2802 /***********************************************************************
2803 * ImmGetImeMenuItemsW (IMM32.@)
2805 DWORD WINAPI
ImmGetImeMenuItemsW( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2806 LPIMEMENUITEMINFOW lpImeParentMenu
, LPIMEMENUITEMINFOW lpImeMenu
,
2809 InputContextData
*data
= get_imc_data(hIMC
);
2810 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2811 lpImeParentMenu
, lpImeMenu
, dwSize
);
2815 SetLastError(ERROR_INVALID_HANDLE
);
2819 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2821 if (is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2822 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2823 lpImeParentMenu
, lpImeMenu
, dwSize
);
2826 IMEMENUITEMINFOA lpImeParentMenuA
;
2827 IMEMENUITEMINFOA
*lpImeMenuA
, *parent
= NULL
;
2830 if (lpImeParentMenu
)
2831 parent
= &lpImeParentMenuA
;
2834 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOW
);
2835 dwSize
= count
* sizeof(IMEMENUITEMINFOA
);
2836 lpImeMenuA
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2841 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2842 (IMEMENUITEMINFOW
*)parent
,
2843 (IMEMENUITEMINFOW
*)lpImeMenuA
, dwSize
);
2845 if (lpImeParentMenu
)
2847 memcpy(lpImeParentMenu
,&lpImeParentMenuA
,sizeof(IMEMENUITEMINFOA
));
2848 lpImeParentMenu
->hbmpItem
= lpImeParentMenuA
.hbmpItem
;
2849 MultiByteToWideChar(CP_ACP
, 0, lpImeParentMenuA
.szString
,
2850 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
);
2852 if (lpImeMenu
&& rc
)
2855 for (i
= 0; i
< rc
; i
++)
2857 memcpy(&lpImeMenu
[i
],&lpImeMenuA
[1],sizeof(IMEMENUITEMINFOA
));
2858 lpImeMenu
[i
].hbmpItem
= lpImeMenuA
[i
].hbmpItem
;
2859 MultiByteToWideChar(CP_ACP
, 0, lpImeMenuA
[i
].szString
,
2860 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
);
2863 HeapFree(GetProcessHeap(),0,lpImeMenuA
);
2871 /***********************************************************************
2872 * ImmLockIMC(IMM32.@)
2874 LPINPUTCONTEXT WINAPI
ImmLockIMC(HIMC hIMC
)
2876 InputContextData
*data
= get_imc_data(hIMC
);
2884 /***********************************************************************
2885 * ImmUnlockIMC(IMM32.@)
2887 BOOL WINAPI
ImmUnlockIMC(HIMC hIMC
)
2889 InputContextData
*data
= get_imc_data(hIMC
);
2898 /***********************************************************************
2899 * ImmGetIMCLockCount(IMM32.@)
2901 DWORD WINAPI
ImmGetIMCLockCount(HIMC hIMC
)
2903 InputContextData
*data
= get_imc_data(hIMC
);
2906 return data
->dwLock
;
2909 /***********************************************************************
2910 * ImmCreateIMCC(IMM32.@)
2912 HIMCC WINAPI
ImmCreateIMCC(DWORD size
)
2914 return GlobalAlloc(GMEM_ZEROINIT
| GMEM_MOVEABLE
, size
);
2917 /***********************************************************************
2918 * ImmDestroyIMCC(IMM32.@)
2920 HIMCC WINAPI
ImmDestroyIMCC(HIMCC block
)
2922 return GlobalFree(block
);
2925 /***********************************************************************
2926 * ImmLockIMCC(IMM32.@)
2928 LPVOID WINAPI
ImmLockIMCC(HIMCC imcc
)
2930 return GlobalLock(imcc
);
2933 /***********************************************************************
2934 * ImmUnlockIMCC(IMM32.@)
2936 BOOL WINAPI
ImmUnlockIMCC(HIMCC imcc
)
2938 return GlobalUnlock(imcc
);
2941 /***********************************************************************
2942 * ImmGetIMCCLockCount(IMM32.@)
2944 DWORD WINAPI
ImmGetIMCCLockCount(HIMCC imcc
)
2946 return GlobalFlags(imcc
) & GMEM_LOCKCOUNT
;
2949 /***********************************************************************
2950 * ImmReSizeIMCC(IMM32.@)
2952 HIMCC WINAPI
ImmReSizeIMCC(HIMCC imcc
, DWORD size
)
2954 return GlobalReAlloc(imcc
, size
, GMEM_ZEROINIT
| GMEM_MOVEABLE
);
2957 /***********************************************************************
2958 * ImmGetIMCCSize(IMM32.@)
2960 DWORD WINAPI
ImmGetIMCCSize(HIMCC imcc
)
2962 return GlobalSize(imcc
);
2965 /***********************************************************************
2966 * ImmGenerateMessage(IMM32.@)
2968 BOOL WINAPI
ImmGenerateMessage(HIMC hIMC
)
2970 InputContextData
*data
= get_imc_data(hIMC
);
2974 SetLastError(ERROR_INVALID_HANDLE
);
2978 TRACE("%i messages queued\n",data
->IMC
.dwNumMsgBuf
);
2979 if (data
->IMC
.dwNumMsgBuf
> 0)
2981 LPTRANSMSG lpTransMsg
;
2983 DWORD i
, dwNumMsgBuf
;
2985 /* We are going to detach our hMsgBuff so that if processing messages
2986 generates new messages they go into a new buffer */
2987 hMsgBuf
= data
->IMC
.hMsgBuf
;
2988 dwNumMsgBuf
= data
->IMC
.dwNumMsgBuf
;
2990 data
->IMC
.hMsgBuf
= ImmCreateIMCC(0);
2991 data
->IMC
.dwNumMsgBuf
= 0;
2993 lpTransMsg
= ImmLockIMCC(hMsgBuf
);
2994 for (i
= 0; i
< dwNumMsgBuf
; i
++)
2995 ImmInternalSendIMEMessage(data
, lpTransMsg
[i
].message
, lpTransMsg
[i
].wParam
, lpTransMsg
[i
].lParam
);
2997 ImmUnlockIMCC(hMsgBuf
);
2998 ImmDestroyIMCC(hMsgBuf
);
3004 /***********************************************************************
3005 * ImmTranslateMessage(IMM32.@)
3006 * ( Undocumented, call internally and from user32.dll )
3008 BOOL WINAPI
ImmTranslateMessage(HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lKeyData
)
3010 InputContextData
*data
;
3011 HIMC imc
= ImmGetContext(hwnd
);
3017 static const DWORD list_count
= 10;
3019 TRACE("%p %x %x %x\n",hwnd
, msg
, (UINT
)wParam
, (UINT
)lKeyData
);
3026 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeToAsciiEx
)
3029 GetKeyboardState(state
);
3030 scancode
= lKeyData
>> 0x10 & 0xff;
3032 list
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, list_count
* sizeof(TRANSMSG
) + sizeof(DWORD
));
3033 ((DWORD
*)list
)[0] = list_count
;
3035 if (data
->immKbd
->imeInfo
.fdwProperty
& IME_PROP_KBD_CHAR_FIRST
)
3039 if (!is_himc_ime_unicode(data
))
3040 ToAscii(data
->lastVK
, scancode
, state
, &chr
, 0);
3042 ToUnicodeEx(data
->lastVK
, scancode
, state
, &chr
, 1, 0, GetKeyboardLayout(0));
3043 uVirtKey
= MAKELONG(data
->lastVK
,chr
);
3046 uVirtKey
= data
->lastVK
;
3048 msg_count
= data
->immKbd
->pImeToAsciiEx(uVirtKey
, scancode
, state
, list
, 0, imc
);
3049 TRACE("%i messages generated\n",msg_count
);
3050 if (msg_count
&& msg_count
<= list_count
)
3053 LPTRANSMSG msgs
= (LPTRANSMSG
)((LPBYTE
)list
+ sizeof(DWORD
));
3055 for (i
= 0; i
< msg_count
; i
++)
3056 ImmInternalPostIMEMessage(data
, msgs
[i
].message
, msgs
[i
].wParam
, msgs
[i
].lParam
);
3058 else if (msg_count
> list_count
)
3059 ImmGenerateMessage(imc
);
3061 HeapFree(GetProcessHeap(),0,list
);
3063 data
->lastVK
= VK_PROCESSKEY
;
3065 return (msg_count
> 0);
3068 /***********************************************************************
3069 * ImmProcessKey(IMM32.@)
3070 * ( Undocumented, called from user32.dll )
3072 BOOL WINAPI
ImmProcessKey(HWND hwnd
, HKL hKL
, UINT vKey
, LPARAM lKeyData
, DWORD unknown
)
3074 InputContextData
*data
;
3075 HIMC imc
= ImmGetContext(hwnd
);
3078 TRACE("%p %p %x %x %x\n",hwnd
, hKL
, vKey
, (UINT
)lKeyData
, unknown
);
3085 /* Make sure we are inputting to the correct keyboard */
3086 if (data
->immKbd
->hkl
!= hKL
)
3088 ImmHkl
*new_hkl
= IMM_GetImmHkl(hKL
);
3091 data
->immKbd
->pImeSelect(imc
, FALSE
);
3092 data
->immKbd
->uSelected
--;
3093 data
->immKbd
= new_hkl
;
3094 data
->immKbd
->pImeSelect(imc
, TRUE
);
3095 data
->immKbd
->uSelected
++;
3101 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeProcessKey
)
3104 GetKeyboardState(state
);
3105 if (data
->immKbd
->pImeProcessKey(imc
, vKey
, lKeyData
, state
))
3107 data
->lastVK
= vKey
;
3111 data
->lastVK
= VK_PROCESSKEY
;
3115 /***********************************************************************
3116 * ImmDisableTextFrameService(IMM32.@)
3118 BOOL WINAPI
ImmDisableTextFrameService(DWORD idThread
)
3124 /***********************************************************************
3125 * ImmEnumInputContext(IMM32.@)
3128 BOOL WINAPI
ImmEnumInputContext(DWORD idThread
, IMCENUMPROC lpfn
, LPARAM lParam
)
3134 /***********************************************************************
3135 * ImmGetHotKey(IMM32.@)
3138 BOOL WINAPI
ImmGetHotKey(DWORD hotkey
, UINT
*modifiers
, UINT
*key
, HKL hkl
)
3140 FIXME("%x, %p, %p, %p: stub\n", hotkey
, modifiers
, key
, hkl
);
3144 /***********************************************************************
3145 * ImmDisableLegacyIME(IMM32.@)
3147 BOOL WINAPI
ImmDisableLegacyIME(void)