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
22 #define WIN32_NO_STATUS
31 //#include "winerror.h"
32 #include <wine/debug.h>
37 #include <wine/list.h>
38 #include <wine/unicode.h>
40 WINE_DEFAULT_DEBUG_CHANNEL(imm
);
42 #define IMM_INIT_MAGIC 0x19650412
43 BOOL WINAPI
User32InitializeImmEntryTable(DWORD
);
45 #define MAKE_FUNCPTR(f) typeof(f) * p##f
46 typedef struct _tagImmHkl
{
51 WCHAR imeClassName
[17]; /* 16 character max */
55 /* Function Pointers */
56 MAKE_FUNCPTR(ImeInquire
);
57 MAKE_FUNCPTR(ImeConfigure
);
58 MAKE_FUNCPTR(ImeDestroy
);
59 MAKE_FUNCPTR(ImeEscape
);
60 MAKE_FUNCPTR(ImeSelect
);
61 MAKE_FUNCPTR(ImeSetActiveContext
);
62 MAKE_FUNCPTR(ImeToAsciiEx
);
63 MAKE_FUNCPTR(NotifyIME
);
64 MAKE_FUNCPTR(ImeRegisterWord
);
65 MAKE_FUNCPTR(ImeUnregisterWord
);
66 MAKE_FUNCPTR(ImeEnumRegisterWord
);
67 MAKE_FUNCPTR(ImeSetCompositionString
);
68 MAKE_FUNCPTR(ImeConversionList
);
69 MAKE_FUNCPTR(ImeProcessKey
);
70 MAKE_FUNCPTR(ImeGetRegisterWordStyle
);
71 MAKE_FUNCPTR(ImeGetImeMenuItems
);
75 typedef struct tagInputContextData
87 #define WINE_IMC_VALID_MAGIC 0x56434D49
89 typedef struct _tagTRANSMSG
{
93 } TRANSMSG
, *LPTRANSMSG
;
95 typedef struct _tagIMMThreadData
{
104 static struct list ImmHklList
= LIST_INIT(ImmHklList
);
105 static struct list ImmThreadDataList
= LIST_INIT(ImmThreadDataList
);
107 static const WCHAR szwWineIMCProperty
[] = {'W','i','n','e','I','m','m','H','I','M','C','P','r','o','p','e','r','t','y',0};
109 static const WCHAR szImeFileW
[] = {'I','m','e',' ','F','i','l','e',0};
110 static const WCHAR szLayoutTextW
[] = {'L','a','y','o','u','t',' ','T','e','x','t',0};
111 static const WCHAR szImeRegFmt
[] = {'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','s','\\','%','0','8','l','x',0};
113 static const WCHAR szwIME
[] = {'I','M','E',0};
114 static const WCHAR szwDefaultIME
[] = {'D','e','f','a','u','l','t',' ','I','M','E',0};
116 static CRITICAL_SECTION threaddata_cs
;
117 static CRITICAL_SECTION_DEBUG critsect_debug
=
119 0, 0, &threaddata_cs
,
120 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
121 0, 0, { (DWORD_PTR
)(__FILE__
": threaddata_cs") }
123 static CRITICAL_SECTION threaddata_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
124 static BOOL disable_ime
;
126 #define is_himc_ime_unicode(p) (p->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE)
127 #define is_kbd_ime_unicode(p) (p->imeInfo.fdwProperty & IME_PROP_UNICODE)
129 static BOOL
IMM_DestroyContext(HIMC hIMC
);
130 static InputContextData
* get_imc_data(HIMC hIMC
);
132 static inline WCHAR
*strdupAtoW( const char *str
)
137 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
138 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
139 MultiByteToWideChar( CP_ACP
, 0, str
, -1, ret
, len
);
144 static inline CHAR
*strdupWtoA( const WCHAR
*str
)
149 DWORD len
= WideCharToMultiByte( CP_ACP
, 0, str
, -1, NULL
, 0, NULL
, NULL
);
150 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
)))
151 WideCharToMultiByte( CP_ACP
, 0, str
, -1, ret
, len
, NULL
, NULL
);
156 static DWORD
convert_candidatelist_WtoA(
157 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
161 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
162 if ( lpDst
&& dwBufLen
> 0 )
165 lpDst
->dwOffset
[0] = ret
;
168 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
170 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
172 if ( lpDst
&& dwBufLen
> 0 )
174 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
176 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1,
177 (LPSTR
)dest
, dwBufLen
, NULL
, NULL
);
179 if ( i
+ 1 < lpSrc
->dwCount
)
180 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(char);
181 dwBufLen
-= len
* sizeof(char);
184 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1, NULL
, 0, NULL
, NULL
);
186 ret
+= len
* sizeof(char);
195 static DWORD
convert_candidatelist_AtoW(
196 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
200 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
201 if ( lpDst
&& dwBufLen
> 0 )
204 lpDst
->dwOffset
[0] = ret
;
207 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
209 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
211 if ( lpDst
&& dwBufLen
> 0 )
213 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
215 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1,
216 (LPWSTR
)dest
, dwBufLen
);
218 if ( i
+ 1 < lpSrc
->dwCount
)
219 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(WCHAR
);
220 dwBufLen
-= len
* sizeof(WCHAR
);
223 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1, NULL
, 0);
225 ret
+= len
* sizeof(WCHAR
);
234 static IMMThreadData
*IMM_GetThreadData(HWND hwnd
, DWORD thread
)
241 if (!(thread
= GetWindowThreadProcessId(hwnd
, &process
))) return NULL
;
242 if (process
!= GetCurrentProcessId()) return NULL
;
246 HANDLE h
= OpenThread(THREAD_QUERY_INFORMATION
, FALSE
, thread
);
248 process
= GetProcessIdOfThread(h
);
250 if (process
!= GetCurrentProcessId()) return NULL
;
253 thread
= GetCurrentThreadId();
255 EnterCriticalSection(&threaddata_cs
);
256 LIST_FOR_EACH_ENTRY(data
, &ImmThreadDataList
, IMMThreadData
, entry
)
257 if (data
->threadID
== thread
) return data
;
259 data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*data
));
260 data
->threadID
= thread
;
261 list_add_head(&ImmThreadDataList
,&data
->entry
);
262 TRACE("Thread Data Created (%x)\n",thread
);
266 static BOOL
IMM_IsDefaultContext(HIMC imc
)
268 InputContextData
*data
= get_imc_data(imc
);
273 return data
->threadDefault
;
276 static void IMM_FreeThreadData(void)
280 EnterCriticalSection(&threaddata_cs
);
281 LIST_FOR_EACH_ENTRY(data
, &ImmThreadDataList
, IMMThreadData
, entry
)
283 if (data
->threadID
== GetCurrentThreadId())
285 list_remove(&data
->entry
);
286 LeaveCriticalSection(&threaddata_cs
);
287 IMM_DestroyContext(data
->defaultContext
);
288 HeapFree(GetProcessHeap(),0,data
);
289 TRACE("Thread Data Destroyed\n");
293 LeaveCriticalSection(&threaddata_cs
);
296 static HMODULE
load_graphics_driver(void)
298 static const WCHAR display_device_guid_propW
[] = {
299 '_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
300 'd','e','v','i','c','e','_','g','u','i','d',0 };
301 static const WCHAR key_pathW
[] = {
302 'S','y','s','t','e','m','\\',
303 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
304 'C','o','n','t','r','o','l','\\',
305 'V','i','d','e','o','\\','{',0};
306 static const WCHAR displayW
[] = {'}','\\','0','0','0','0',0};
307 static const WCHAR driverW
[] = {'G','r','a','p','h','i','c','s','D','r','i','v','e','r',0};
312 WCHAR path
[MAX_PATH
];
313 WCHAR key
[(sizeof(key_pathW
) + sizeof(displayW
)) / sizeof(WCHAR
) + 40];
314 UINT guid_atom
= HandleToULong( GetPropW( GetDesktopWindow(), display_device_guid_propW
));
316 if (!guid_atom
) return 0;
317 memcpy( key
, key_pathW
, sizeof(key_pathW
) );
318 if (!GlobalGetAtomNameW( guid_atom
, key
+ strlenW(key
), 40 )) return 0;
319 strcatW( key
, displayW
);
320 if (RegOpenKeyW( HKEY_LOCAL_MACHINE
, key
, &hkey
)) return 0;
322 if (!RegQueryValueExW( hkey
, driverW
, NULL
, NULL
, (BYTE
*)path
, &size
)) ret
= LoadLibraryW( path
);
324 TRACE( "%s %p\n", debugstr_w(path
), ret
);
328 /* ImmHkl loading and freeing */
329 #define LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}
330 static ImmHkl
*IMM_GetImmHkl(HKL hkl
)
333 WCHAR filename
[MAX_PATH
];
335 TRACE("Seeking ime for keyboard %p\n",hkl
);
337 LIST_FOR_EACH_ENTRY(ptr
, &ImmHklList
, ImmHkl
, entry
)
342 /* not found... create it */
344 ptr
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ImmHkl
));
347 if (ImmGetIMEFileNameW(hkl
, filename
, MAX_PATH
)) ptr
->hIME
= LoadLibraryW(filename
);
348 if (!ptr
->hIME
) ptr
->hIME
= load_graphics_driver();
351 LOAD_FUNCPTR(ImeInquire
);
352 if (!ptr
->pImeInquire
|| !ptr
->pImeInquire(&ptr
->imeInfo
, ptr
->imeClassName
, NULL
))
354 FreeLibrary(ptr
->hIME
);
359 LOAD_FUNCPTR(ImeDestroy
);
360 LOAD_FUNCPTR(ImeSelect
);
361 if (!ptr
->pImeSelect
|| !ptr
->pImeDestroy
)
363 FreeLibrary(ptr
->hIME
);
368 LOAD_FUNCPTR(ImeConfigure
);
369 LOAD_FUNCPTR(ImeEscape
);
370 LOAD_FUNCPTR(ImeSetActiveContext
);
371 LOAD_FUNCPTR(ImeToAsciiEx
);
372 LOAD_FUNCPTR(NotifyIME
);
373 LOAD_FUNCPTR(ImeRegisterWord
);
374 LOAD_FUNCPTR(ImeUnregisterWord
);
375 LOAD_FUNCPTR(ImeEnumRegisterWord
);
376 LOAD_FUNCPTR(ImeSetCompositionString
);
377 LOAD_FUNCPTR(ImeConversionList
);
378 LOAD_FUNCPTR(ImeProcessKey
);
379 LOAD_FUNCPTR(ImeGetRegisterWordStyle
);
380 LOAD_FUNCPTR(ImeGetImeMenuItems
);
381 /* make sure our classname is WCHAR */
382 if (!is_kbd_ime_unicode(ptr
))
385 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ptr
->imeClassName
,
387 lstrcpyW(ptr
->imeClassName
, bufW
);
392 list_add_head(&ImmHklList
,&ptr
->entry
);
398 HWND WINAPI
__wine_get_ui_window(HKL hkl
)
400 ImmHkl
*immHkl
= IMM_GetImmHkl(hkl
);
401 return immHkl
->UIWnd
;
404 static void IMM_FreeAllImmHkl(void)
406 ImmHkl
*ptr
,*cursor2
;
408 LIST_FOR_EACH_ENTRY_SAFE(ptr
, cursor2
, &ImmHklList
, ImmHkl
, entry
)
410 list_remove(&ptr
->entry
);
414 FreeLibrary(ptr
->hIME
);
417 DestroyWindow(ptr
->UIWnd
);
418 HeapFree(GetProcessHeap(),0,ptr
);
422 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID lpReserved
)
424 TRACE("%p, %x, %p\n",hInstDLL
,fdwReason
,lpReserved
);
427 case DLL_PROCESS_ATTACH
:
428 if (!User32InitializeImmEntryTable(IMM_INIT_MAGIC
))
433 case DLL_THREAD_ATTACH
:
435 case DLL_THREAD_DETACH
:
436 IMM_FreeThreadData();
438 case DLL_PROCESS_DETACH
:
439 if (lpReserved
) break;
440 IMM_FreeThreadData();
447 /* for posting messages as the IME */
448 static void ImmInternalPostIMEMessage(InputContextData
*data
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
450 HWND target
= GetFocus();
452 PostMessageW(data
->IMC
.hWnd
,msg
,wParam
,lParam
);
454 PostMessageW(target
, msg
, wParam
, lParam
);
457 /* for sending messages as the IME */
458 static void ImmInternalSendIMEMessage(InputContextData
*data
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
460 HWND target
= GetFocus();
462 SendMessageW(data
->IMC
.hWnd
,msg
,wParam
,lParam
);
464 SendMessageW(target
, msg
, wParam
, lParam
);
467 static LRESULT
ImmInternalSendIMENotify(InputContextData
*data
, WPARAM notify
, LPARAM lParam
)
471 target
= data
->IMC
.hWnd
;
472 if (!target
) target
= GetFocus();
475 return SendMessageW(target
, WM_IME_NOTIFY
, notify
, lParam
);
480 static HIMCC
ImmCreateBlankCompStr(void)
483 LPCOMPOSITIONSTRING ptr
;
484 rc
= ImmCreateIMCC(sizeof(COMPOSITIONSTRING
));
485 ptr
= ImmLockIMCC(rc
);
486 memset(ptr
,0,sizeof(COMPOSITIONSTRING
));
487 ptr
->dwSize
= sizeof(COMPOSITIONSTRING
);
492 static InputContextData
* get_imc_data(HIMC hIMC
)
494 InputContextData
*data
= hIMC
;
499 if(IsBadReadPtr(data
, sizeof(InputContextData
)) || data
->magic
!= WINE_IMC_VALID_MAGIC
)
501 SetLastError(ERROR_INVALID_HANDLE
);
507 static HIMC
get_default_context( HWND hwnd
)
510 IMMThreadData
* thread_data
= IMM_GetThreadData( hwnd
, 0 );
512 if (!thread_data
) return 0;
514 if (thread_data
->defaultContext
)
516 ret
= thread_data
->defaultContext
;
517 LeaveCriticalSection(&threaddata_cs
);
521 /* can't create a default context in another thread */
522 if (thread_data
->threadID
!= GetCurrentThreadId())
524 LeaveCriticalSection(&threaddata_cs
);
528 LeaveCriticalSection(&threaddata_cs
);
530 ret
= ImmCreateContext();
532 ((InputContextData
*)ret
)->threadDefault
= TRUE
;
534 /* thread_data is in the current thread so we can assume it's still valid */
535 EnterCriticalSection(&threaddata_cs
);
537 if (thread_data
->defaultContext
) /* someone beat us */
539 IMM_DestroyContext( ret
);
540 ret
= thread_data
->defaultContext
;
542 else thread_data
->defaultContext
= ret
;
544 LeaveCriticalSection(&threaddata_cs
);
548 static BOOL
IMM_IsCrossThreadAccess(HWND hWnd
, HIMC hIMC
)
550 InputContextData
*data
;
554 DWORD thread
= GetWindowThreadProcessId(hWnd
, NULL
);
555 if (thread
!= GetCurrentThreadId()) return TRUE
;
557 data
= get_imc_data(hIMC
);
558 if (data
&& data
->threadID
!= GetCurrentThreadId())
564 /***********************************************************************
565 * ImmAssociateContext (IMM32.@)
567 HIMC WINAPI
ImmAssociateContext(HWND hWnd
, HIMC hIMC
)
570 InputContextData
*data
= get_imc_data(hIMC
);
572 TRACE("(%p, %p):\n", hWnd
, hIMC
);
578 * If already associated just return
580 if (hIMC
&& data
->IMC
.hWnd
== hWnd
)
583 if (hIMC
&& IMM_IsCrossThreadAccess(hWnd
, hIMC
))
588 HIMC defaultContext
= get_default_context( hWnd
);
589 old
= RemovePropW(hWnd
,szwWineIMCProperty
);
592 old
= defaultContext
;
593 else if (old
== (HIMC
)-1)
596 if (hIMC
!= defaultContext
)
598 if (hIMC
== NULL
) /* Meaning disable imm for that window*/
599 SetPropW(hWnd
,szwWineIMCProperty
,(HANDLE
)-1);
601 SetPropW(hWnd
,szwWineIMCProperty
,hIMC
);
606 InputContextData
*old_data
= old
;
607 if (old_data
->IMC
.hWnd
== hWnd
)
608 old_data
->IMC
.hWnd
= NULL
;
615 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, FALSE
, ISC_SHOWUIALL
);
616 data
->IMC
.hWnd
= hWnd
;
617 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, TRUE
, ISC_SHOWUIALL
);
624 * Helper function for ImmAssociateContextEx
626 static BOOL CALLBACK
_ImmAssociateContextExEnumProc(HWND hwnd
, LPARAM lParam
)
628 HIMC hImc
= (HIMC
)lParam
;
629 ImmAssociateContext(hwnd
,hImc
);
633 /***********************************************************************
634 * ImmAssociateContextEx (IMM32.@)
636 BOOL WINAPI
ImmAssociateContextEx(HWND hWnd
, HIMC hIMC
, DWORD dwFlags
)
638 TRACE("(%p, %p, 0x%x):\n", hWnd
, hIMC
, dwFlags
);
646 ImmAssociateContext(hWnd
,hIMC
);
650 HIMC defaultContext
= get_default_context( hWnd
);
651 if (!defaultContext
) return FALSE
;
652 ImmAssociateContext(hWnd
,defaultContext
);
655 case IACE_IGNORENOCONTEXT
:
656 if (GetPropW(hWnd
,szwWineIMCProperty
))
657 ImmAssociateContext(hWnd
,hIMC
);
660 EnumChildWindows(hWnd
,_ImmAssociateContextExEnumProc
,(LPARAM
)hIMC
);
663 FIXME("Unknown dwFlags 0x%x\n",dwFlags
);
668 /***********************************************************************
669 * ImmConfigureIMEA (IMM32.@)
671 BOOL WINAPI
ImmConfigureIMEA(
672 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
674 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
676 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
678 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
681 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
683 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| !is_kbd_ime_unicode(immHkl
))
684 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
688 REGISTERWORDA
*rwa
= lpData
;
691 rww
.lpReading
= strdupAtoW(rwa
->lpReading
);
692 rww
.lpWord
= strdupAtoW(rwa
->lpWord
);
693 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rww
);
694 HeapFree(GetProcessHeap(),0,rww
.lpReading
);
695 HeapFree(GetProcessHeap(),0,rww
.lpWord
);
703 /***********************************************************************
704 * ImmConfigureIMEW (IMM32.@)
706 BOOL WINAPI
ImmConfigureIMEW(
707 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
709 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
711 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
713 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
716 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
718 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| is_kbd_ime_unicode(immHkl
))
719 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
722 REGISTERWORDW
*rww
= lpData
;
726 rwa
.lpReading
= strdupWtoA(rww
->lpReading
);
727 rwa
.lpWord
= strdupWtoA(rww
->lpWord
);
728 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rwa
);
729 HeapFree(GetProcessHeap(),0,rwa
.lpReading
);
730 HeapFree(GetProcessHeap(),0,rwa
.lpWord
);
738 /***********************************************************************
739 * ImmCreateContext (IMM32.@)
741 HIMC WINAPI
ImmCreateContext(void)
743 InputContextData
*new_context
;
748 new_context
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(InputContextData
));
751 new_context
->immKbd
= IMM_GetImmHkl(GetKeyboardLayout(0));
753 if (!new_context
->immKbd
->hIME
)
755 TRACE("IME dll could not be loaded\n");
756 HeapFree(GetProcessHeap(),0,new_context
);
760 /* the HIMCCs are never NULL */
761 new_context
->IMC
.hCompStr
= ImmCreateBlankCompStr();
762 new_context
->IMC
.hMsgBuf
= ImmCreateIMCC(0);
763 new_context
->IMC
.hCandInfo
= ImmCreateIMCC(sizeof(CANDIDATEINFO
));
764 ci
= ImmLockIMCC(new_context
->IMC
.hCandInfo
);
765 memset(ci
,0,sizeof(CANDIDATEINFO
));
766 ci
->dwSize
= sizeof(CANDIDATEINFO
);
767 ImmUnlockIMCC(new_context
->IMC
.hCandInfo
);
768 new_context
->IMC
.hGuideLine
= ImmCreateIMCC(sizeof(GUIDELINE
));
769 gl
= ImmLockIMCC(new_context
->IMC
.hGuideLine
);
770 memset(gl
,0,sizeof(GUIDELINE
));
771 gl
->dwSize
= sizeof(GUIDELINE
);
772 ImmUnlockIMCC(new_context
->IMC
.hGuideLine
);
774 for (i
= 0; i
< sizeof(new_context
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
); i
++)
775 new_context
->IMC
.cfCandForm
[i
].dwIndex
= ~0u;
777 /* Initialize the IME Private */
778 new_context
->IMC
.hPrivate
= ImmCreateIMCC(new_context
->immKbd
->imeInfo
.dwPrivateDataSize
);
780 new_context
->IMC
.fdwConversion
= new_context
->immKbd
->imeInfo
.fdwConversionCaps
;
781 new_context
->IMC
.fdwSentence
= new_context
->immKbd
->imeInfo
.fdwSentenceCaps
;
783 if (!new_context
->immKbd
->pImeSelect(new_context
, TRUE
))
785 TRACE("Selection of IME failed\n");
786 IMM_DestroyContext(new_context
);
789 new_context
->threadID
= GetCurrentThreadId();
790 SendMessageW(GetFocus(), WM_IME_SELECT
, TRUE
, (LPARAM
)new_context
->immKbd
);
792 new_context
->immKbd
->uSelected
++;
793 TRACE("Created context %p\n",new_context
);
795 new_context
->magic
= WINE_IMC_VALID_MAGIC
;
799 static BOOL
IMM_DestroyContext(HIMC hIMC
)
801 InputContextData
*data
= get_imc_data(hIMC
);
803 TRACE("Destroying %p\n",hIMC
);
808 data
->immKbd
->uSelected
--;
809 data
->immKbd
->pImeSelect(hIMC
, FALSE
);
810 SendMessageW(data
->IMC
.hWnd
, WM_IME_SELECT
, FALSE
, (LPARAM
)data
->immKbd
);
812 ImmDestroyIMCC(data
->IMC
.hCompStr
);
813 ImmDestroyIMCC(data
->IMC
.hCandInfo
);
814 ImmDestroyIMCC(data
->IMC
.hGuideLine
);
815 ImmDestroyIMCC(data
->IMC
.hPrivate
);
816 ImmDestroyIMCC(data
->IMC
.hMsgBuf
);
819 HeapFree(GetProcessHeap(),0,data
);
824 /***********************************************************************
825 * ImmDestroyContext (IMM32.@)
827 BOOL WINAPI
ImmDestroyContext(HIMC hIMC
)
829 if (!IMM_IsDefaultContext(hIMC
) && !IMM_IsCrossThreadAccess(NULL
, hIMC
))
830 return IMM_DestroyContext(hIMC
);
835 /***********************************************************************
836 * ImmDisableIME (IMM32.@)
838 BOOL WINAPI
ImmDisableIME(DWORD idThread
)
840 if (idThread
== (DWORD
)-1)
843 IMMThreadData
*thread_data
= IMM_GetThreadData(NULL
, idThread
);
844 if (!thread_data
) return FALSE
;
845 thread_data
->disableIME
= TRUE
;
846 LeaveCriticalSection(&threaddata_cs
);
851 /***********************************************************************
852 * ImmEnumRegisterWordA (IMM32.@)
854 UINT WINAPI
ImmEnumRegisterWordA(
855 HKL hKL
, REGISTERWORDENUMPROCA lpfnEnumProc
,
856 LPCSTR lpszReading
, DWORD dwStyle
,
857 LPCSTR lpszRegister
, LPVOID lpData
)
859 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
860 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
861 debugstr_a(lpszReading
), dwStyle
, debugstr_a(lpszRegister
), lpData
);
862 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
864 if (!is_kbd_ime_unicode(immHkl
))
865 return immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
866 (LPCWSTR
)lpszReading
, dwStyle
, (LPCWSTR
)lpszRegister
, lpData
);
869 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
870 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
873 rc
= immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
874 lpszwReading
, dwStyle
, lpszwRegister
,
877 HeapFree(GetProcessHeap(),0,lpszwReading
);
878 HeapFree(GetProcessHeap(),0,lpszwRegister
);
886 /***********************************************************************
887 * ImmEnumRegisterWordW (IMM32.@)
889 UINT WINAPI
ImmEnumRegisterWordW(
890 HKL hKL
, REGISTERWORDENUMPROCW lpfnEnumProc
,
891 LPCWSTR lpszReading
, DWORD dwStyle
,
892 LPCWSTR lpszRegister
, LPVOID lpData
)
894 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
895 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
896 debugstr_w(lpszReading
), dwStyle
, debugstr_w(lpszRegister
), lpData
);
897 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
899 if (is_kbd_ime_unicode(immHkl
))
900 return immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, lpszReading
, dwStyle
,
901 lpszRegister
, lpData
);
904 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
905 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
908 rc
= immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, (LPCWSTR
)lpszaReading
,
909 dwStyle
, (LPCWSTR
)lpszaRegister
, lpData
);
911 HeapFree(GetProcessHeap(),0,lpszaReading
);
912 HeapFree(GetProcessHeap(),0,lpszaRegister
);
920 static inline BOOL
EscapeRequiresWA(UINT uEscape
)
922 if (uEscape
== IME_ESC_GET_EUDC_DICTIONARY
||
923 uEscape
== IME_ESC_SET_EUDC_DICTIONARY
||
924 uEscape
== IME_ESC_IME_NAME
||
925 uEscape
== IME_ESC_GETHELPFILENAME
)
930 /***********************************************************************
931 * ImmEscapeA (IMM32.@)
933 LRESULT WINAPI
ImmEscapeA(
935 UINT uEscape
, LPVOID lpData
)
937 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
938 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
940 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
942 if (!EscapeRequiresWA(uEscape
) || !is_kbd_ime_unicode(immHkl
))
943 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
946 WCHAR buffer
[81]; /* largest required buffer should be 80 */
948 if (uEscape
== IME_ESC_SET_EUDC_DICTIONARY
)
950 MultiByteToWideChar(CP_ACP
,0,lpData
,-1,buffer
,81);
951 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
955 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
956 WideCharToMultiByte(CP_ACP
,0,buffer
,-1,lpData
,80, NULL
, NULL
);
965 /***********************************************************************
966 * ImmEscapeW (IMM32.@)
968 LRESULT WINAPI
ImmEscapeW(
970 UINT uEscape
, LPVOID lpData
)
972 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
973 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
975 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
977 if (!EscapeRequiresWA(uEscape
) || is_kbd_ime_unicode(immHkl
))
978 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
981 CHAR buffer
[81]; /* largest required buffer should be 80 */
983 if (uEscape
== IME_ESC_SET_EUDC_DICTIONARY
)
985 WideCharToMultiByte(CP_ACP
,0,lpData
,-1,buffer
,81, NULL
, NULL
);
986 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
990 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
991 MultiByteToWideChar(CP_ACP
,0,buffer
,-1,lpData
,80);
1000 /***********************************************************************
1001 * ImmGetCandidateListA (IMM32.@)
1003 DWORD WINAPI
ImmGetCandidateListA(
1004 HIMC hIMC
, DWORD dwIndex
,
1005 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
1007 InputContextData
*data
= get_imc_data(hIMC
);
1008 LPCANDIDATEINFO candinfo
;
1009 LPCANDIDATELIST candlist
;
1012 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
1014 if (!data
|| !data
->IMC
.hCandInfo
)
1017 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1018 if ( dwIndex
>= candinfo
->dwCount
||
1019 dwIndex
>= (sizeof(candinfo
->dwOffset
) / sizeof(DWORD
)) )
1022 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
1023 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
1026 if ( !is_himc_ime_unicode(data
) )
1028 ret
= candlist
->dwSize
;
1029 if ( lpCandList
&& dwBufLen
>= ret
)
1030 memcpy(lpCandList
, candlist
, ret
);
1033 ret
= convert_candidatelist_WtoA( candlist
, lpCandList
, dwBufLen
);
1036 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1040 /***********************************************************************
1041 * ImmGetCandidateListCountA (IMM32.@)
1043 DWORD WINAPI
ImmGetCandidateListCountA(
1044 HIMC hIMC
, LPDWORD lpdwListCount
)
1046 InputContextData
*data
= get_imc_data(hIMC
);
1047 LPCANDIDATEINFO candinfo
;
1050 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
1052 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
1055 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1057 *lpdwListCount
= count
= candinfo
->dwCount
;
1059 if ( !is_himc_ime_unicode(data
) )
1060 ret
= candinfo
->dwSize
;
1063 ret
= sizeof(CANDIDATEINFO
);
1065 ret
+= ImmGetCandidateListA(hIMC
, count
, NULL
, 0);
1068 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1072 /***********************************************************************
1073 * ImmGetCandidateListCountW (IMM32.@)
1075 DWORD WINAPI
ImmGetCandidateListCountW(
1076 HIMC hIMC
, LPDWORD lpdwListCount
)
1078 InputContextData
*data
= get_imc_data(hIMC
);
1079 LPCANDIDATEINFO candinfo
;
1082 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
1084 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
1087 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1089 *lpdwListCount
= count
= candinfo
->dwCount
;
1091 if ( is_himc_ime_unicode(data
) )
1092 ret
= candinfo
->dwSize
;
1095 ret
= sizeof(CANDIDATEINFO
);
1097 ret
+= ImmGetCandidateListW(hIMC
, count
, NULL
, 0);
1100 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1104 /***********************************************************************
1105 * ImmGetCandidateListW (IMM32.@)
1107 DWORD WINAPI
ImmGetCandidateListW(
1108 HIMC hIMC
, DWORD dwIndex
,
1109 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
1111 InputContextData
*data
= get_imc_data(hIMC
);
1112 LPCANDIDATEINFO candinfo
;
1113 LPCANDIDATELIST candlist
;
1116 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
1118 if (!data
|| !data
->IMC
.hCandInfo
)
1121 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1122 if ( dwIndex
>= candinfo
->dwCount
||
1123 dwIndex
>= (sizeof(candinfo
->dwOffset
) / sizeof(DWORD
)) )
1126 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
1127 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
1130 if ( is_himc_ime_unicode(data
) )
1132 ret
= candlist
->dwSize
;
1133 if ( lpCandList
&& dwBufLen
>= ret
)
1134 memcpy(lpCandList
, candlist
, ret
);
1137 ret
= convert_candidatelist_AtoW( candlist
, lpCandList
, dwBufLen
);
1140 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1144 /***********************************************************************
1145 * ImmGetCandidateWindow (IMM32.@)
1147 BOOL WINAPI
ImmGetCandidateWindow(
1148 HIMC hIMC
, DWORD dwIndex
, LPCANDIDATEFORM lpCandidate
)
1150 InputContextData
*data
= get_imc_data(hIMC
);
1152 TRACE("%p, %d, %p\n", hIMC
, dwIndex
, lpCandidate
);
1154 if (!data
|| !lpCandidate
)
1157 if ( dwIndex
>= (sizeof(data
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
)) )
1160 if (data
->IMC
.cfCandForm
[dwIndex
].dwIndex
!= dwIndex
)
1163 *lpCandidate
= data
->IMC
.cfCandForm
[dwIndex
];
1168 /***********************************************************************
1169 * ImmGetCompositionFontA (IMM32.@)
1171 BOOL WINAPI
ImmGetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
1176 TRACE("(%p, %p):\n", hIMC
, lplf
);
1178 rc
= ImmGetCompositionFontW(hIMC
,&lfW
);
1182 memcpy(lplf
,&lfW
,sizeof(LOGFONTA
));
1183 WideCharToMultiByte(CP_ACP
, 0, lfW
.lfFaceName
, -1, lplf
->lfFaceName
,
1184 LF_FACESIZE
, NULL
, NULL
);
1188 /***********************************************************************
1189 * ImmGetCompositionFontW (IMM32.@)
1191 BOOL WINAPI
ImmGetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
1193 InputContextData
*data
= get_imc_data(hIMC
);
1195 TRACE("(%p, %p):\n", hIMC
, lplf
);
1200 *lplf
= data
->IMC
.lfFont
.W
;
1206 /* Helpers for the GetCompositionString functions */
1208 static INT
CopyCompStringIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE target
, INT tlen
,
1213 if (is_himc_ime_unicode(data
) && !unicode
)
1214 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)source
, slen
, (LPSTR
)target
, tlen
, NULL
, NULL
);
1215 else if (!is_himc_ime_unicode(data
) && unicode
)
1216 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)source
, slen
, (LPWSTR
)target
, tlen
) * sizeof(WCHAR
);
1219 int dlen
= (unicode
)?sizeof(WCHAR
):sizeof(CHAR
);
1220 memcpy( target
, source
, min(slen
,tlen
)*dlen
);
1227 static INT
CopyCompAttrIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
, INT sslen
,
1228 LPBYTE target
, INT tlen
, BOOL unicode
)
1232 if (is_himc_ime_unicode(data
) && !unicode
)
1234 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, sslen
, NULL
, 0, NULL
, NULL
);
1237 const BYTE
*src
= source
;
1238 LPBYTE dst
= target
;
1239 int i
, j
= 0, k
= 0;
1243 for (i
= 0; i
< sslen
; ++i
)
1247 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)ssource
+ i
, 1,
1248 NULL
, 0, NULL
, NULL
);
1249 for (; len
> 0; --len
)
1262 else if (!is_himc_ime_unicode(data
) && unicode
)
1264 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, sslen
, NULL
, 0);
1267 const BYTE
*src
= source
;
1268 LPBYTE dst
= target
;
1273 for (i
= 0; i
< sslen
; ++i
)
1275 if (IsDBCSLeadByte(((LPSTR
)ssource
)[i
]))
1288 memcpy( target
, source
, min(slen
,tlen
));
1295 static INT
CopyCompClauseIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
,
1296 LPBYTE target
, INT tlen
, BOOL unicode
)
1300 if (is_himc_ime_unicode(data
) && !unicode
)
1308 tlen
/= sizeof (DWORD
);
1309 for (i
= 0; i
< tlen
; ++i
)
1311 ((DWORD
*)target
)[i
] = WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
,
1312 ((DWORD
*)source
)[i
],
1316 rc
= sizeof (DWORD
) * i
;
1321 else if (!is_himc_ime_unicode(data
) && unicode
)
1329 tlen
/= sizeof (DWORD
);
1330 for (i
= 0; i
< tlen
; ++i
)
1332 ((DWORD
*)target
)[i
] = MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
,
1333 ((DWORD
*)source
)[i
],
1336 rc
= sizeof (DWORD
) * i
;
1343 memcpy( target
, source
, min(slen
,tlen
));
1350 static INT
CopyCompOffsetIMEtoClient(InputContextData
*data
, DWORD offset
, LPBYTE ssource
, BOOL unicode
)
1354 if (is_himc_ime_unicode(data
) && !unicode
)
1356 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, offset
, NULL
, 0, NULL
, NULL
);
1358 else if (!is_himc_ime_unicode(data
) && unicode
)
1360 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, offset
, NULL
, 0);
1368 static LONG
ImmGetCompositionStringT( HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
,
1369 DWORD dwBufLen
, BOOL unicode
)
1372 InputContextData
*data
= get_imc_data(hIMC
);
1373 LPCOMPOSITIONSTRING compstr
;
1376 TRACE("(%p, 0x%x, %p, %d)\n", hIMC
, dwIndex
, lpBuf
, dwBufLen
);
1381 if (!data
->IMC
.hCompStr
)
1384 compdata
= ImmLockIMCC(data
->IMC
.hCompStr
);
1385 compstr
= (LPCOMPOSITIONSTRING
)compdata
;
1390 TRACE("GCS_RESULTSTR\n");
1391 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultStrOffset
, compstr
->dwResultStrLen
, lpBuf
, dwBufLen
, unicode
);
1394 TRACE("GCS_COMPSTR\n");
1395 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
, lpBuf
, dwBufLen
, unicode
);
1398 TRACE("GCS_COMPATTR\n");
1399 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompAttrOffset
, compstr
->dwCompAttrLen
,
1400 compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
,
1401 lpBuf
, dwBufLen
, unicode
);
1403 case GCS_COMPCLAUSE
:
1404 TRACE("GCS_COMPCLAUSE\n");
1405 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompClauseOffset
,compstr
->dwCompClauseLen
,
1406 compdata
+ compstr
->dwCompStrOffset
,
1407 lpBuf
, dwBufLen
, unicode
);
1409 case GCS_RESULTCLAUSE
:
1410 TRACE("GCS_RESULTCLAUSE\n");
1411 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultClauseOffset
,compstr
->dwResultClauseLen
,
1412 compdata
+ compstr
->dwResultStrOffset
,
1413 lpBuf
, dwBufLen
, unicode
);
1415 case GCS_RESULTREADSTR
:
1416 TRACE("GCS_RESULTREADSTR\n");
1417 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultReadStrOffset
, compstr
->dwResultReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1419 case GCS_RESULTREADCLAUSE
:
1420 TRACE("GCS_RESULTREADCLAUSE\n");
1421 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultReadClauseOffset
,compstr
->dwResultReadClauseLen
,
1422 compdata
+ compstr
->dwResultStrOffset
,
1423 lpBuf
, dwBufLen
, unicode
);
1425 case GCS_COMPREADSTR
:
1426 TRACE("GCS_COMPREADSTR\n");
1427 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1429 case GCS_COMPREADATTR
:
1430 TRACE("GCS_COMPREADATTR\n");
1431 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompReadAttrOffset
, compstr
->dwCompReadAttrLen
,
1432 compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
,
1433 lpBuf
, dwBufLen
, unicode
);
1435 case GCS_COMPREADCLAUSE
:
1436 TRACE("GCS_COMPREADCLAUSE\n");
1437 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompReadClauseOffset
,compstr
->dwCompReadClauseLen
,
1438 compdata
+ compstr
->dwCompStrOffset
,
1439 lpBuf
, dwBufLen
, unicode
);
1442 TRACE("GCS_CURSORPOS\n");
1443 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwCursorPos
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1445 case GCS_DELTASTART
:
1446 TRACE("GCS_DELTASTART\n");
1447 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwDeltaStart
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1450 FIXME("Unhandled index 0x%x\n",dwIndex
);
1454 ImmUnlockIMCC(data
->IMC
.hCompStr
);
1459 /***********************************************************************
1460 * ImmGetCompositionStringA (IMM32.@)
1462 LONG WINAPI
ImmGetCompositionStringA(
1463 HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
, DWORD dwBufLen
)
1465 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, FALSE
);
1469 /***********************************************************************
1470 * ImmGetCompositionStringW (IMM32.@)
1472 LONG WINAPI
ImmGetCompositionStringW(
1473 HIMC hIMC
, DWORD dwIndex
,
1474 LPVOID lpBuf
, DWORD dwBufLen
)
1476 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, TRUE
);
1479 /***********************************************************************
1480 * ImmGetCompositionWindow (IMM32.@)
1482 BOOL WINAPI
ImmGetCompositionWindow(HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
1484 InputContextData
*data
= get_imc_data(hIMC
);
1486 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
1491 *lpCompForm
= data
->IMC
.cfCompForm
;
1495 /***********************************************************************
1496 * ImmGetContext (IMM32.@)
1499 HIMC WINAPI
ImmGetContext(HWND hWnd
)
1503 TRACE("%p\n", hWnd
);
1505 if (!IsWindow(hWnd
))
1507 SetLastError(ERROR_INVALID_WINDOW_HANDLE
);
1511 rc
= GetPropW(hWnd
,szwWineIMCProperty
);
1514 else if (rc
== NULL
)
1515 rc
= get_default_context( hWnd
);
1519 InputContextData
*data
= rc
;
1520 data
->IMC
.hWnd
= hWnd
;
1523 TRACE("returning %p\n", rc
);
1528 /***********************************************************************
1529 * ImmGetConversionListA (IMM32.@)
1531 DWORD WINAPI
ImmGetConversionListA(
1533 LPCSTR pSrc
, LPCANDIDATELIST lpDst
,
1534 DWORD dwBufLen
, UINT uFlag
)
1536 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1537 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_a(pSrc
), lpDst
,
1539 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1541 if (!is_kbd_ime_unicode(immHkl
))
1542 return immHkl
->pImeConversionList(hIMC
,(LPCWSTR
)pSrc
,lpDst
,dwBufLen
,uFlag
);
1545 LPCANDIDATELIST lpwDst
;
1547 LPWSTR pwSrc
= strdupAtoW(pSrc
);
1549 len
= immHkl
->pImeConversionList(hIMC
, pwSrc
, NULL
, 0, uFlag
);
1550 lpwDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1553 immHkl
->pImeConversionList(hIMC
, pwSrc
, lpwDst
, len
, uFlag
);
1554 ret
= convert_candidatelist_WtoA( lpwDst
, lpDst
, dwBufLen
);
1555 HeapFree(GetProcessHeap(), 0, lpwDst
);
1557 HeapFree(GetProcessHeap(), 0, pwSrc
);
1566 /***********************************************************************
1567 * ImmGetConversionListW (IMM32.@)
1569 DWORD WINAPI
ImmGetConversionListW(
1571 LPCWSTR pSrc
, LPCANDIDATELIST lpDst
,
1572 DWORD dwBufLen
, UINT uFlag
)
1574 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1575 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_w(pSrc
), lpDst
,
1577 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1579 if (is_kbd_ime_unicode(immHkl
))
1580 return immHkl
->pImeConversionList(hIMC
,pSrc
,lpDst
,dwBufLen
,uFlag
);
1583 LPCANDIDATELIST lpaDst
;
1585 LPSTR paSrc
= strdupWtoA(pSrc
);
1587 len
= immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, NULL
, 0, uFlag
);
1588 lpaDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1591 immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, lpaDst
, len
, uFlag
);
1592 ret
= convert_candidatelist_AtoW( lpaDst
, lpDst
, dwBufLen
);
1593 HeapFree(GetProcessHeap(), 0, lpaDst
);
1595 HeapFree(GetProcessHeap(), 0, paSrc
);
1604 /***********************************************************************
1605 * ImmGetConversionStatus (IMM32.@)
1607 BOOL WINAPI
ImmGetConversionStatus(
1608 HIMC hIMC
, LPDWORD lpfdwConversion
, LPDWORD lpfdwSentence
)
1610 InputContextData
*data
= get_imc_data(hIMC
);
1612 TRACE("%p %p %p\n", hIMC
, lpfdwConversion
, lpfdwSentence
);
1617 if (lpfdwConversion
)
1618 *lpfdwConversion
= data
->IMC
.fdwConversion
;
1620 *lpfdwSentence
= data
->IMC
.fdwSentence
;
1625 static BOOL
needs_ime_window(HWND hwnd
)
1629 if (GetClassNameW(hwnd
, classW
, sizeof(classW
)/sizeof(classW
[0])) &&
1630 !strcmpW(classW
, szwIME
))
1632 if (GetClassLongPtrW(hwnd
, GCL_STYLE
) & CS_IME
) return FALSE
;
1637 /***********************************************************************
1638 * __wine_register_window (IMM32.@)
1640 BOOL WINAPI
__wine_register_window(HWND hwnd
)
1643 IMMThreadData
*thread_data
;
1644 TRACE("(%p)\n", hwnd
);
1646 if (!needs_ime_window(hwnd
))
1649 thread_data
= IMM_GetThreadData(hwnd
, 0);
1653 if (thread_data
->disableIME
|| disable_ime
)
1655 TRACE("IME for this thread is disabled\n");
1656 LeaveCriticalSection(&threaddata_cs
);
1659 thread_data
->windowRefs
++;
1660 TRACE("windowRefs=%u, hwndDefault=%p\n",
1661 thread_data
->windowRefs
, thread_data
->hwndDefault
);
1663 /* Create default IME window */
1664 if (thread_data
->windowRefs
== 1)
1666 /* Do not create the window inside of a critical section */
1667 LeaveCriticalSection(&threaddata_cs
);
1668 new = CreateWindowExW( 0, szwIME
, szwDefaultIME
,
1669 WS_POPUP
| WS_DISABLED
| WS_CLIPSIBLINGS
,
1670 0, 0, 1, 1, 0, 0, 0, 0);
1671 /* thread_data is in the current thread so we can assume it's still valid */
1672 EnterCriticalSection(&threaddata_cs
);
1673 /* See if anyone beat us */
1674 if (thread_data
->hwndDefault
== NULL
)
1676 thread_data
->hwndDefault
= new;
1678 TRACE("Default is %p\n", thread_data
->hwndDefault
);
1682 LeaveCriticalSection(&threaddata_cs
);
1684 /* Clean up an unused new window outside of the critical section */
1690 /***********************************************************************
1691 * __wine_unregister_window (IMM32.@)
1693 void WINAPI
__wine_unregister_window(HWND hwnd
)
1695 HWND to_destroy
= 0;
1696 IMMThreadData
*thread_data
;
1697 TRACE("(%p)\n", hwnd
);
1699 thread_data
= IMM_GetThreadData(hwnd
, 0);
1700 if (!thread_data
) return;
1702 thread_data
->windowRefs
--;
1703 TRACE("windowRefs=%u, hwndDefault=%p\n",
1704 thread_data
->windowRefs
, thread_data
->hwndDefault
);
1706 /* Destroy default IME window */
1707 if (thread_data
->windowRefs
== 0 && thread_data
->hwndDefault
)
1709 to_destroy
= thread_data
->hwndDefault
;
1710 thread_data
->hwndDefault
= NULL
;
1712 LeaveCriticalSection(&threaddata_cs
);
1714 if (to_destroy
) DestroyWindow( to_destroy
);
1717 /***********************************************************************
1718 * ImmGetDefaultIMEWnd (IMM32.@)
1720 HWND WINAPI
ImmGetDefaultIMEWnd(HWND hWnd
)
1723 IMMThreadData
* thread_data
= IMM_GetThreadData(hWnd
, 0);
1726 ret
= thread_data
->hwndDefault
;
1727 LeaveCriticalSection(&threaddata_cs
);
1728 TRACE("Default is %p\n",ret
);
1732 /***********************************************************************
1733 * ImmGetDescriptionA (IMM32.@)
1735 UINT WINAPI
ImmGetDescriptionA(
1736 HKL hKL
, LPSTR lpszDescription
, UINT uBufLen
)
1741 TRACE("%p %p %d\n", hKL
, lpszDescription
, uBufLen
);
1743 /* find out how many characters in the unicode buffer */
1744 len
= ImmGetDescriptionW( hKL
, NULL
, 0 );
1748 /* allocate a buffer of that size */
1749 buf
= HeapAlloc( GetProcessHeap(), 0, (len
+ 1) * sizeof (WCHAR
) );
1753 /* fetch the unicode buffer */
1754 len
= ImmGetDescriptionW( hKL
, buf
, len
+ 1 );
1756 /* convert it back to ASCII */
1757 len
= WideCharToMultiByte( CP_ACP
, 0, buf
, len
+ 1,
1758 lpszDescription
, uBufLen
, NULL
, NULL
);
1760 HeapFree( GetProcessHeap(), 0, buf
);
1768 /***********************************************************************
1769 * ImmGetDescriptionW (IMM32.@)
1771 UINT WINAPI
ImmGetDescriptionW(HKL hKL
, LPWSTR lpszDescription
, UINT uBufLen
)
1773 static const WCHAR name
[] = { 'W','i','n','e',' ','X','I','M',0 };
1775 FIXME("(%p, %p, %d): semi stub\n", hKL
, lpszDescription
, uBufLen
);
1778 if (!uBufLen
) return lstrlenW( name
);
1779 lstrcpynW( lpszDescription
, name
, uBufLen
);
1780 return lstrlenW( lpszDescription
);
1783 /***********************************************************************
1784 * ImmGetGuideLineA (IMM32.@)
1786 DWORD WINAPI
ImmGetGuideLineA(
1787 HIMC hIMC
, DWORD dwIndex
, LPSTR lpBuf
, DWORD dwBufLen
)
1789 FIXME("(%p, %d, %s, %d): stub\n",
1790 hIMC
, dwIndex
, debugstr_a(lpBuf
), dwBufLen
1792 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1796 /***********************************************************************
1797 * ImmGetGuideLineW (IMM32.@)
1799 DWORD WINAPI
ImmGetGuideLineW(HIMC hIMC
, DWORD dwIndex
, LPWSTR lpBuf
, DWORD dwBufLen
)
1801 FIXME("(%p, %d, %s, %d): stub\n",
1802 hIMC
, dwIndex
, debugstr_w(lpBuf
), dwBufLen
1804 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1808 /***********************************************************************
1809 * ImmGetIMEFileNameA (IMM32.@)
1811 UINT WINAPI
ImmGetIMEFileNameA( HKL hKL
, LPSTR lpszFileName
, UINT uBufLen
)
1814 UINT wBufLen
= uBufLen
;
1817 if (uBufLen
&& lpszFileName
)
1818 bufW
= HeapAlloc(GetProcessHeap(),0,uBufLen
* sizeof(WCHAR
));
1819 else /* We need this to get the number of byte required */
1821 bufW
= HeapAlloc(GetProcessHeap(),0,MAX_PATH
* sizeof(WCHAR
));
1825 rc
= ImmGetIMEFileNameW(hKL
,bufW
,wBufLen
);
1829 if (uBufLen
&& lpszFileName
)
1830 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, lpszFileName
,
1831 uBufLen
, NULL
, NULL
);
1832 else /* get the length */
1833 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, NULL
, 0, NULL
,
1837 HeapFree(GetProcessHeap(),0,bufW
);
1841 /***********************************************************************
1842 * ImmGetIMEFileNameW (IMM32.@)
1844 UINT WINAPI
ImmGetIMEFileNameW(HKL hKL
, LPWSTR lpszFileName
, UINT uBufLen
)
1849 WCHAR regKey
[sizeof(szImeRegFmt
)/sizeof(WCHAR
)+8];
1851 wsprintfW( regKey
, szImeRegFmt
, (ULONG_PTR
)hKL
);
1852 rc
= RegOpenKeyW( HKEY_LOCAL_MACHINE
, regKey
, &hkey
);
1853 if (rc
!= ERROR_SUCCESS
)
1860 rc
= RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, NULL
, &length
);
1862 if (rc
!= ERROR_SUCCESS
)
1868 if (length
> uBufLen
* sizeof(WCHAR
) || !lpszFileName
)
1873 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
1877 return length
/ sizeof(WCHAR
);
1880 RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, lpszFileName
, &length
);
1884 return length
/ sizeof(WCHAR
);
1887 /***********************************************************************
1888 * ImmGetOpenStatus (IMM32.@)
1890 BOOL WINAPI
ImmGetOpenStatus(HIMC hIMC
)
1892 InputContextData
*data
= get_imc_data(hIMC
);
1898 TRACE("(%p): semi-stub\n", hIMC
);
1901 FIXME("(%p): semi-stub\n", hIMC
);
1903 return data
->IMC
.fOpen
;
1906 /***********************************************************************
1907 * ImmGetProperty (IMM32.@)
1909 DWORD WINAPI
ImmGetProperty(HKL hKL
, DWORD fdwIndex
)
1914 TRACE("(%p, %d)\n", hKL
, fdwIndex
);
1915 kbd
= IMM_GetImmHkl(hKL
);
1917 if (kbd
&& kbd
->hIME
)
1921 case IGP_PROPERTY
: rc
= kbd
->imeInfo
.fdwProperty
; break;
1922 case IGP_CONVERSION
: rc
= kbd
->imeInfo
.fdwConversionCaps
; break;
1923 case IGP_SENTENCE
: rc
= kbd
->imeInfo
.fdwSentenceCaps
; break;
1924 case IGP_SETCOMPSTR
: rc
= kbd
->imeInfo
.fdwSCSCaps
; break;
1925 case IGP_SELECT
: rc
= kbd
->imeInfo
.fdwSelectCaps
; break;
1926 case IGP_GETIMEVERSION
: rc
= IMEVER_0400
; break;
1927 case IGP_UI
: rc
= 0; break;
1934 /***********************************************************************
1935 * ImmGetRegisterWordStyleA (IMM32.@)
1937 UINT WINAPI
ImmGetRegisterWordStyleA(
1938 HKL hKL
, UINT nItem
, LPSTYLEBUFA lpStyleBuf
)
1940 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1941 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1942 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1944 if (!is_kbd_ime_unicode(immHkl
))
1945 return immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)lpStyleBuf
);
1951 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,&sbw
);
1952 WideCharToMultiByte(CP_ACP
, 0, sbw
.szDescription
, -1,
1953 lpStyleBuf
->szDescription
, 32, NULL
, NULL
);
1954 lpStyleBuf
->dwStyle
= sbw
.dwStyle
;
1962 /***********************************************************************
1963 * ImmGetRegisterWordStyleW (IMM32.@)
1965 UINT WINAPI
ImmGetRegisterWordStyleW(
1966 HKL hKL
, UINT nItem
, LPSTYLEBUFW lpStyleBuf
)
1968 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1969 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1970 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1972 if (is_kbd_ime_unicode(immHkl
))
1973 return immHkl
->pImeGetRegisterWordStyle(nItem
,lpStyleBuf
);
1979 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)&sba
);
1980 MultiByteToWideChar(CP_ACP
, 0, sba
.szDescription
, -1,
1981 lpStyleBuf
->szDescription
, 32);
1982 lpStyleBuf
->dwStyle
= sba
.dwStyle
;
1990 /***********************************************************************
1991 * ImmGetStatusWindowPos (IMM32.@)
1993 BOOL WINAPI
ImmGetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
1995 InputContextData
*data
= get_imc_data(hIMC
);
1997 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
1999 if (!data
|| !lpptPos
)
2002 *lpptPos
= data
->IMC
.ptStatusWndPos
;
2007 /***********************************************************************
2008 * ImmGetVirtualKey (IMM32.@)
2010 UINT WINAPI
ImmGetVirtualKey(HWND hWnd
)
2012 OSVERSIONINFOA version
;
2013 InputContextData
*data
= ImmGetContext( hWnd
);
2014 TRACE("%p\n", hWnd
);
2017 return data
->lastVK
;
2019 version
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFOA
);
2020 GetVersionExA( &version
);
2021 switch(version
.dwPlatformId
)
2023 case VER_PLATFORM_WIN32_WINDOWS
:
2024 return VK_PROCESSKEY
;
2025 case VER_PLATFORM_WIN32_NT
:
2028 FIXME("%d not supported\n",version
.dwPlatformId
);
2029 return VK_PROCESSKEY
;
2033 /***********************************************************************
2034 * ImmInstallIMEA (IMM32.@)
2036 HKL WINAPI
ImmInstallIMEA(
2037 LPCSTR lpszIMEFileName
, LPCSTR lpszLayoutText
)
2039 LPWSTR lpszwIMEFileName
;
2040 LPWSTR lpszwLayoutText
;
2043 TRACE ("(%s, %s)\n", debugstr_a(lpszIMEFileName
),
2044 debugstr_a(lpszLayoutText
));
2046 lpszwIMEFileName
= strdupAtoW(lpszIMEFileName
);
2047 lpszwLayoutText
= strdupAtoW(lpszLayoutText
);
2049 hkl
= ImmInstallIMEW(lpszwIMEFileName
, lpszwLayoutText
);
2051 HeapFree(GetProcessHeap(),0,lpszwIMEFileName
);
2052 HeapFree(GetProcessHeap(),0,lpszwLayoutText
);
2056 /***********************************************************************
2057 * ImmInstallIMEW (IMM32.@)
2059 HKL WINAPI
ImmInstallIMEW(
2060 LPCWSTR lpszIMEFileName
, LPCWSTR lpszLayoutText
)
2062 INT lcid
= GetUserDefaultLCID();
2067 WCHAR regKey
[sizeof(szImeRegFmt
)/sizeof(WCHAR
)+8];
2069 TRACE ("(%s, %s):\n", debugstr_w(lpszIMEFileName
),
2070 debugstr_w(lpszLayoutText
));
2072 /* Start with 2. e001 will be blank and so default to the wine internal IME */
2075 while (count
< 0xfff)
2077 DWORD disposition
= 0;
2079 hkl
= (HKL
)MAKELPARAM( lcid
, 0xe000 | count
);
2080 wsprintfW( regKey
, szImeRegFmt
, (ULONG_PTR
)hkl
);
2082 rc
= RegCreateKeyExW(HKEY_LOCAL_MACHINE
, regKey
, 0, NULL
, 0, KEY_WRITE
, NULL
, &hkey
, &disposition
);
2083 if (rc
== ERROR_SUCCESS
&& disposition
== REG_CREATED_NEW_KEY
)
2085 else if (rc
== ERROR_SUCCESS
)
2093 WARN("Unable to find slot to install IME\n");
2097 if (rc
== ERROR_SUCCESS
)
2099 rc
= RegSetValueExW(hkey
, szImeFileW
, 0, REG_SZ
, (const BYTE
*)lpszIMEFileName
,
2100 (lstrlenW(lpszIMEFileName
) + 1) * sizeof(WCHAR
));
2101 if (rc
== ERROR_SUCCESS
)
2102 rc
= RegSetValueExW(hkey
, szLayoutTextW
, 0, REG_SZ
, (const BYTE
*)lpszLayoutText
,
2103 (lstrlenW(lpszLayoutText
) + 1) * sizeof(WCHAR
));
2109 WARN("Unable to set IME registry values\n");
2114 /***********************************************************************
2115 * ImmIsIME (IMM32.@)
2117 BOOL WINAPI
ImmIsIME(HKL hKL
)
2120 TRACE("(%p):\n", hKL
);
2121 ptr
= IMM_GetImmHkl(hKL
);
2122 return (ptr
&& ptr
->hIME
);
2125 /***********************************************************************
2126 * ImmIsUIMessageA (IMM32.@)
2128 BOOL WINAPI
ImmIsUIMessageA(
2129 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
2131 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
2132 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
2133 (msg
== WM_IME_SETCONTEXT
) ||
2134 (msg
== WM_IME_NOTIFY
) ||
2135 (msg
== WM_IME_COMPOSITIONFULL
) ||
2136 (msg
== WM_IME_SELECT
) ||
2137 (msg
== 0x287 /* FIXME: WM_IME_SYSTEM */))
2140 SendMessageA(hWndIME
, msg
, wParam
, lParam
);
2147 /***********************************************************************
2148 * ImmIsUIMessageW (IMM32.@)
2150 BOOL WINAPI
ImmIsUIMessageW(
2151 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
2153 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
2154 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
2155 (msg
== WM_IME_SETCONTEXT
) ||
2156 (msg
== WM_IME_NOTIFY
) ||
2157 (msg
== WM_IME_COMPOSITIONFULL
) ||
2158 (msg
== WM_IME_SELECT
) ||
2159 (msg
== 0x287 /* FIXME: WM_IME_SYSTEM */))
2162 SendMessageW(hWndIME
, msg
, wParam
, lParam
);
2169 /***********************************************************************
2170 * ImmNotifyIME (IMM32.@)
2172 BOOL WINAPI
ImmNotifyIME(
2173 HIMC hIMC
, DWORD dwAction
, DWORD dwIndex
, DWORD dwValue
)
2175 InputContextData
*data
= get_imc_data(hIMC
);
2177 TRACE("(%p, %d, %d, %d)\n",
2178 hIMC
, dwAction
, dwIndex
, dwValue
);
2182 SetLastError(ERROR_SUCCESS
);
2186 if (!data
|| ! data
->immKbd
->pNotifyIME
)
2191 return data
->immKbd
->pNotifyIME(hIMC
,dwAction
,dwIndex
,dwValue
);
2194 /***********************************************************************
2195 * ImmRegisterWordA (IMM32.@)
2197 BOOL WINAPI
ImmRegisterWordA(
2198 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszRegister
)
2200 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2201 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
2202 debugstr_a(lpszRegister
));
2203 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
2205 if (!is_kbd_ime_unicode(immHkl
))
2206 return immHkl
->pImeRegisterWord((LPCWSTR
)lpszReading
,dwStyle
,
2207 (LPCWSTR
)lpszRegister
);
2210 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
2211 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
2214 rc
= immHkl
->pImeRegisterWord(lpszwReading
,dwStyle
,lpszwRegister
);
2215 HeapFree(GetProcessHeap(),0,lpszwReading
);
2216 HeapFree(GetProcessHeap(),0,lpszwRegister
);
2224 /***********************************************************************
2225 * ImmRegisterWordW (IMM32.@)
2227 BOOL WINAPI
ImmRegisterWordW(
2228 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszRegister
)
2230 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2231 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
2232 debugstr_w(lpszRegister
));
2233 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
2235 if (is_kbd_ime_unicode(immHkl
))
2236 return immHkl
->pImeRegisterWord(lpszReading
,dwStyle
,lpszRegister
);
2239 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2240 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
2243 rc
= immHkl
->pImeRegisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2244 (LPCWSTR
)lpszaRegister
);
2245 HeapFree(GetProcessHeap(),0,lpszaReading
);
2246 HeapFree(GetProcessHeap(),0,lpszaRegister
);
2254 /***********************************************************************
2255 * ImmReleaseContext (IMM32.@)
2257 BOOL WINAPI
ImmReleaseContext(HWND hWnd
, HIMC hIMC
)
2259 static BOOL shown
= FALSE
;
2262 FIXME("(%p, %p): stub\n", hWnd
, hIMC
);
2268 /***********************************************************************
2269 * ImmRequestMessageA(IMM32.@)
2271 LRESULT WINAPI
ImmRequestMessageA(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
2273 InputContextData
*data
= get_imc_data(hIMC
);
2275 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
2277 if (data
) return SendMessageA(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
2279 SetLastError(ERROR_INVALID_HANDLE
);
2283 /***********************************************************************
2284 * ImmRequestMessageW(IMM32.@)
2286 LRESULT WINAPI
ImmRequestMessageW(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
2288 InputContextData
*data
= get_imc_data(hIMC
);
2290 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
2292 if (data
) return SendMessageW(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
2294 SetLastError(ERROR_INVALID_HANDLE
);
2298 /***********************************************************************
2299 * ImmSetCandidateWindow (IMM32.@)
2301 BOOL WINAPI
ImmSetCandidateWindow(
2302 HIMC hIMC
, LPCANDIDATEFORM lpCandidate
)
2304 InputContextData
*data
= get_imc_data(hIMC
);
2306 TRACE("(%p, %p)\n", hIMC
, lpCandidate
);
2308 if (!data
|| !lpCandidate
)
2311 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2314 TRACE("\t%x, %x, %s, %s\n",
2315 lpCandidate
->dwIndex
, lpCandidate
->dwStyle
,
2316 wine_dbgstr_point(&lpCandidate
->ptCurrentPos
),
2317 wine_dbgstr_rect(&lpCandidate
->rcArea
));
2319 if ( lpCandidate
->dwIndex
>= (sizeof(data
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
)) )
2322 data
->IMC
.cfCandForm
[lpCandidate
->dwIndex
] = *lpCandidate
;
2323 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCANDIDATEPOS
);
2324 ImmInternalSendIMENotify(data
, IMN_SETCANDIDATEPOS
, 1 << lpCandidate
->dwIndex
);
2329 /***********************************************************************
2330 * ImmSetCompositionFontA (IMM32.@)
2332 BOOL WINAPI
ImmSetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
2334 InputContextData
*data
= get_imc_data(hIMC
);
2335 TRACE("(%p, %p)\n", hIMC
, lplf
);
2339 SetLastError(ERROR_INVALID_HANDLE
);
2343 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2346 memcpy(&data
->IMC
.lfFont
.W
,lplf
,sizeof(LOGFONTA
));
2347 MultiByteToWideChar(CP_ACP
, 0, lplf
->lfFaceName
, -1, data
->IMC
.lfFont
.W
.lfFaceName
,
2349 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2350 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2355 /***********************************************************************
2356 * ImmSetCompositionFontW (IMM32.@)
2358 BOOL WINAPI
ImmSetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
2360 InputContextData
*data
= get_imc_data(hIMC
);
2361 TRACE("(%p, %p)\n", hIMC
, lplf
);
2365 SetLastError(ERROR_INVALID_HANDLE
);
2369 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2372 data
->IMC
.lfFont
.W
= *lplf
;
2373 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2374 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2379 /***********************************************************************
2380 * ImmSetCompositionStringA (IMM32.@)
2382 BOOL WINAPI
ImmSetCompositionStringA(
2383 HIMC hIMC
, DWORD dwIndex
,
2384 LPCVOID lpComp
, DWORD dwCompLen
,
2385 LPCVOID lpRead
, DWORD dwReadLen
)
2389 WCHAR
*CompBuffer
= NULL
;
2390 WCHAR
*ReadBuffer
= NULL
;
2392 InputContextData
*data
= get_imc_data(hIMC
);
2394 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2395 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2400 if (!(dwIndex
== SCS_SETSTR
||
2401 dwIndex
== SCS_CHANGEATTR
||
2402 dwIndex
== SCS_CHANGECLAUSE
||
2403 dwIndex
== SCS_SETRECONVERTSTRING
||
2404 dwIndex
== SCS_QUERYRECONVERTSTRING
))
2407 if (!is_himc_ime_unicode(data
))
2408 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2409 dwCompLen
, lpRead
, dwReadLen
);
2411 comp_len
= MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0);
2414 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
* sizeof(WCHAR
));
2415 MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
);
2418 read_len
= MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0);
2421 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
* sizeof(WCHAR
));
2422 MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
);
2425 rc
= ImmSetCompositionStringW(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2426 ReadBuffer
, read_len
);
2428 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2429 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2434 /***********************************************************************
2435 * ImmSetCompositionStringW (IMM32.@)
2437 BOOL WINAPI
ImmSetCompositionStringW(
2438 HIMC hIMC
, DWORD dwIndex
,
2439 LPCVOID lpComp
, DWORD dwCompLen
,
2440 LPCVOID lpRead
, DWORD dwReadLen
)
2444 CHAR
*CompBuffer
= NULL
;
2445 CHAR
*ReadBuffer
= NULL
;
2447 InputContextData
*data
= get_imc_data(hIMC
);
2449 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2450 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2455 if (!(dwIndex
== SCS_SETSTR
||
2456 dwIndex
== SCS_CHANGEATTR
||
2457 dwIndex
== SCS_CHANGECLAUSE
||
2458 dwIndex
== SCS_SETRECONVERTSTRING
||
2459 dwIndex
== SCS_QUERYRECONVERTSTRING
))
2462 if (is_himc_ime_unicode(data
))
2463 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2464 dwCompLen
, lpRead
, dwReadLen
);
2466 comp_len
= WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0, NULL
,
2470 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
);
2471 WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
,
2475 read_len
= WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0, NULL
,
2479 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
);
2480 WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
,
2484 rc
= ImmSetCompositionStringA(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2485 ReadBuffer
, read_len
);
2487 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2488 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2493 /***********************************************************************
2494 * ImmSetCompositionWindow (IMM32.@)
2496 BOOL WINAPI
ImmSetCompositionWindow(
2497 HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
2499 BOOL reshow
= FALSE
;
2500 InputContextData
*data
= get_imc_data(hIMC
);
2502 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
2504 TRACE("\t%x, %s, %s\n", lpCompForm
->dwStyle
,
2505 wine_dbgstr_point(&lpCompForm
->ptCurrentPos
),
2506 wine_dbgstr_rect(&lpCompForm
->rcArea
));
2510 SetLastError(ERROR_INVALID_HANDLE
);
2514 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2517 data
->IMC
.cfCompForm
= *lpCompForm
;
2519 if (IsWindowVisible(data
->immKbd
->UIWnd
))
2522 ShowWindow(data
->immKbd
->UIWnd
,SW_HIDE
);
2525 /* FIXME: this is a partial stub */
2528 ShowWindow(data
->immKbd
->UIWnd
,SW_SHOWNOACTIVATE
);
2530 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONWINDOW
, 0);
2534 /***********************************************************************
2535 * ImmSetConversionStatus (IMM32.@)
2537 BOOL WINAPI
ImmSetConversionStatus(
2538 HIMC hIMC
, DWORD fdwConversion
, DWORD fdwSentence
)
2540 DWORD oldConversion
, oldSentence
;
2541 InputContextData
*data
= get_imc_data(hIMC
);
2543 TRACE("%p %d %d\n", hIMC
, fdwConversion
, fdwSentence
);
2547 SetLastError(ERROR_INVALID_HANDLE
);
2551 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2554 if ( fdwConversion
!= data
->IMC
.fdwConversion
)
2556 oldConversion
= data
->IMC
.fdwConversion
;
2557 data
->IMC
.fdwConversion
= fdwConversion
;
2558 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldConversion
, IMC_SETCONVERSIONMODE
);
2559 ImmInternalSendIMENotify(data
, IMN_SETCONVERSIONMODE
, 0);
2561 if ( fdwSentence
!= data
->IMC
.fdwSentence
)
2563 oldSentence
= data
->IMC
.fdwSentence
;
2564 data
->IMC
.fdwSentence
= fdwSentence
;
2565 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldSentence
, IMC_SETSENTENCEMODE
);
2566 ImmInternalSendIMENotify(data
, IMN_SETSENTENCEMODE
, 0);
2572 /***********************************************************************
2573 * ImmSetOpenStatus (IMM32.@)
2575 BOOL WINAPI
ImmSetOpenStatus(HIMC hIMC
, BOOL fOpen
)
2577 InputContextData
*data
= get_imc_data(hIMC
);
2579 TRACE("%p %d\n", hIMC
, fOpen
);
2583 SetLastError(ERROR_INVALID_HANDLE
);
2587 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2590 if (data
->immKbd
->UIWnd
== NULL
)
2592 /* create the ime window */
2593 data
->immKbd
->UIWnd
= CreateWindowExW( WS_EX_TOOLWINDOW
,
2594 data
->immKbd
->imeClassName
, NULL
, WS_POPUP
, 0, 0, 1, 1, 0,
2595 0, data
->immKbd
->hIME
, 0);
2596 SetWindowLongPtrW(data
->immKbd
->UIWnd
, IMMGWL_IMC
, (LONG_PTR
)data
);
2599 SetWindowLongPtrW(data
->immKbd
->UIWnd
, IMMGWL_IMC
, (LONG_PTR
)data
);
2601 if (!fOpen
!= !data
->IMC
.fOpen
)
2603 data
->IMC
.fOpen
= fOpen
;
2604 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETOPENSTATUS
);
2605 ImmInternalSendIMENotify(data
, IMN_SETOPENSTATUS
, 0);
2611 /***********************************************************************
2612 * ImmSetStatusWindowPos (IMM32.@)
2614 BOOL WINAPI
ImmSetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
2616 InputContextData
*data
= get_imc_data(hIMC
);
2618 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
2620 if (!data
|| !lpptPos
)
2622 SetLastError(ERROR_INVALID_HANDLE
);
2626 if (IMM_IsCrossThreadAccess(NULL
, hIMC
))
2629 TRACE("\t%s\n", wine_dbgstr_point(lpptPos
));
2631 data
->IMC
.ptStatusWndPos
= *lpptPos
;
2632 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETSTATUSWINDOWPOS
);
2633 ImmInternalSendIMENotify(data
, IMN_SETSTATUSWINDOWPOS
, 0);
2638 /***********************************************************************
2639 * ImmCreateSoftKeyboard(IMM32.@)
2641 HWND WINAPI
ImmCreateSoftKeyboard(UINT uType
, UINT hOwner
, int x
, int y
)
2643 FIXME("(%d, %d, %d, %d): stub\n", uType
, hOwner
, x
, y
);
2644 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2648 /***********************************************************************
2649 * ImmDestroySoftKeyboard(IMM32.@)
2651 BOOL WINAPI
ImmDestroySoftKeyboard(HWND hSoftWnd
)
2653 FIXME("(%p): stub\n", hSoftWnd
);
2654 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2658 /***********************************************************************
2659 * ImmShowSoftKeyboard(IMM32.@)
2661 BOOL WINAPI
ImmShowSoftKeyboard(HWND hSoftWnd
, int nCmdShow
)
2663 FIXME("(%p, %d): stub\n", hSoftWnd
, nCmdShow
);
2664 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2668 /***********************************************************************
2669 * ImmSimulateHotKey (IMM32.@)
2671 BOOL WINAPI
ImmSimulateHotKey(HWND hWnd
, DWORD dwHotKeyID
)
2673 FIXME("(%p, %d): stub\n", hWnd
, dwHotKeyID
);
2674 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2678 /***********************************************************************
2679 * ImmUnregisterWordA (IMM32.@)
2681 BOOL WINAPI
ImmUnregisterWordA(
2682 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszUnregister
)
2684 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2685 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
2686 debugstr_a(lpszUnregister
));
2687 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2689 if (!is_kbd_ime_unicode(immHkl
))
2690 return immHkl
->pImeUnregisterWord((LPCWSTR
)lpszReading
,dwStyle
,
2691 (LPCWSTR
)lpszUnregister
);
2694 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
2695 LPWSTR lpszwUnregister
= strdupAtoW(lpszUnregister
);
2698 rc
= immHkl
->pImeUnregisterWord(lpszwReading
,dwStyle
,lpszwUnregister
);
2699 HeapFree(GetProcessHeap(),0,lpszwReading
);
2700 HeapFree(GetProcessHeap(),0,lpszwUnregister
);
2708 /***********************************************************************
2709 * ImmUnregisterWordW (IMM32.@)
2711 BOOL WINAPI
ImmUnregisterWordW(
2712 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszUnregister
)
2714 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2715 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
2716 debugstr_w(lpszUnregister
));
2717 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2719 if (is_kbd_ime_unicode(immHkl
))
2720 return immHkl
->pImeUnregisterWord(lpszReading
,dwStyle
,lpszUnregister
);
2723 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2724 LPSTR lpszaUnregister
= strdupWtoA(lpszUnregister
);
2727 rc
= immHkl
->pImeUnregisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2728 (LPCWSTR
)lpszaUnregister
);
2729 HeapFree(GetProcessHeap(),0,lpszaReading
);
2730 HeapFree(GetProcessHeap(),0,lpszaUnregister
);
2738 /***********************************************************************
2739 * ImmGetImeMenuItemsA (IMM32.@)
2741 DWORD WINAPI
ImmGetImeMenuItemsA( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2742 LPIMEMENUITEMINFOA lpImeParentMenu
, LPIMEMENUITEMINFOA lpImeMenu
,
2745 InputContextData
*data
= get_imc_data(hIMC
);
2746 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2747 lpImeParentMenu
, lpImeMenu
, dwSize
);
2751 SetLastError(ERROR_INVALID_HANDLE
);
2755 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2757 if (!is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2758 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2759 (IMEMENUITEMINFOW
*)lpImeParentMenu
,
2760 (IMEMENUITEMINFOW
*)lpImeMenu
, dwSize
);
2763 IMEMENUITEMINFOW lpImeParentMenuW
;
2764 IMEMENUITEMINFOW
*lpImeMenuW
, *parent
= NULL
;
2767 if (lpImeParentMenu
)
2768 parent
= &lpImeParentMenuW
;
2771 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOA
);
2772 dwSize
= count
* sizeof(IMEMENUITEMINFOW
);
2773 lpImeMenuW
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2778 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2779 parent
, lpImeMenuW
, dwSize
);
2781 if (lpImeParentMenu
)
2783 memcpy(lpImeParentMenu
,&lpImeParentMenuW
,sizeof(IMEMENUITEMINFOA
));
2784 lpImeParentMenu
->hbmpItem
= lpImeParentMenuW
.hbmpItem
;
2785 WideCharToMultiByte(CP_ACP
, 0, lpImeParentMenuW
.szString
,
2786 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
,
2789 if (lpImeMenu
&& rc
)
2792 for (i
= 0; i
< rc
; i
++)
2794 memcpy(&lpImeMenu
[i
],&lpImeMenuW
[1],sizeof(IMEMENUITEMINFOA
));
2795 lpImeMenu
[i
].hbmpItem
= lpImeMenuW
[i
].hbmpItem
;
2796 WideCharToMultiByte(CP_ACP
, 0, lpImeMenuW
[i
].szString
,
2797 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
,
2801 HeapFree(GetProcessHeap(),0,lpImeMenuW
);
2809 /***********************************************************************
2810 * ImmGetImeMenuItemsW (IMM32.@)
2812 DWORD WINAPI
ImmGetImeMenuItemsW( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2813 LPIMEMENUITEMINFOW lpImeParentMenu
, LPIMEMENUITEMINFOW lpImeMenu
,
2816 InputContextData
*data
= get_imc_data(hIMC
);
2817 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2818 lpImeParentMenu
, lpImeMenu
, dwSize
);
2822 SetLastError(ERROR_INVALID_HANDLE
);
2826 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2828 if (is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2829 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2830 lpImeParentMenu
, lpImeMenu
, dwSize
);
2833 IMEMENUITEMINFOA lpImeParentMenuA
;
2834 IMEMENUITEMINFOA
*lpImeMenuA
, *parent
= NULL
;
2837 if (lpImeParentMenu
)
2838 parent
= &lpImeParentMenuA
;
2841 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOW
);
2842 dwSize
= count
* sizeof(IMEMENUITEMINFOA
);
2843 lpImeMenuA
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2848 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2849 (IMEMENUITEMINFOW
*)parent
,
2850 (IMEMENUITEMINFOW
*)lpImeMenuA
, dwSize
);
2852 if (lpImeParentMenu
)
2854 memcpy(lpImeParentMenu
,&lpImeParentMenuA
,sizeof(IMEMENUITEMINFOA
));
2855 lpImeParentMenu
->hbmpItem
= lpImeParentMenuA
.hbmpItem
;
2856 MultiByteToWideChar(CP_ACP
, 0, lpImeParentMenuA
.szString
,
2857 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
);
2859 if (lpImeMenu
&& rc
)
2862 for (i
= 0; i
< rc
; i
++)
2864 memcpy(&lpImeMenu
[i
],&lpImeMenuA
[1],sizeof(IMEMENUITEMINFOA
));
2865 lpImeMenu
[i
].hbmpItem
= lpImeMenuA
[i
].hbmpItem
;
2866 MultiByteToWideChar(CP_ACP
, 0, lpImeMenuA
[i
].szString
,
2867 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
);
2870 HeapFree(GetProcessHeap(),0,lpImeMenuA
);
2878 /***********************************************************************
2879 * ImmLockIMC(IMM32.@)
2881 LPINPUTCONTEXT WINAPI
ImmLockIMC(HIMC hIMC
)
2883 InputContextData
*data
= get_imc_data(hIMC
);
2891 /***********************************************************************
2892 * ImmUnlockIMC(IMM32.@)
2894 BOOL WINAPI
ImmUnlockIMC(HIMC hIMC
)
2896 InputContextData
*data
= get_imc_data(hIMC
);
2905 /***********************************************************************
2906 * ImmGetIMCLockCount(IMM32.@)
2908 DWORD WINAPI
ImmGetIMCLockCount(HIMC hIMC
)
2910 InputContextData
*data
= get_imc_data(hIMC
);
2913 return data
->dwLock
;
2916 /***********************************************************************
2917 * ImmCreateIMCC(IMM32.@)
2919 HIMCC WINAPI
ImmCreateIMCC(DWORD size
)
2921 return GlobalAlloc(GMEM_ZEROINIT
| GMEM_MOVEABLE
, size
);
2924 /***********************************************************************
2925 * ImmDestroyIMCC(IMM32.@)
2927 HIMCC WINAPI
ImmDestroyIMCC(HIMCC block
)
2929 return GlobalFree(block
);
2932 /***********************************************************************
2933 * ImmLockIMCC(IMM32.@)
2935 LPVOID WINAPI
ImmLockIMCC(HIMCC imcc
)
2937 return GlobalLock(imcc
);
2940 /***********************************************************************
2941 * ImmUnlockIMCC(IMM32.@)
2943 BOOL WINAPI
ImmUnlockIMCC(HIMCC imcc
)
2945 return GlobalUnlock(imcc
);
2948 /***********************************************************************
2949 * ImmGetIMCCLockCount(IMM32.@)
2951 DWORD WINAPI
ImmGetIMCCLockCount(HIMCC imcc
)
2953 return GlobalFlags(imcc
) & GMEM_LOCKCOUNT
;
2956 /***********************************************************************
2957 * ImmReSizeIMCC(IMM32.@)
2959 HIMCC WINAPI
ImmReSizeIMCC(HIMCC imcc
, DWORD size
)
2961 return GlobalReAlloc(imcc
, size
, GMEM_ZEROINIT
| GMEM_MOVEABLE
);
2964 /***********************************************************************
2965 * ImmGetIMCCSize(IMM32.@)
2967 DWORD WINAPI
ImmGetIMCCSize(HIMCC imcc
)
2969 return GlobalSize(imcc
);
2972 /***********************************************************************
2973 * ImmGenerateMessage(IMM32.@)
2975 BOOL WINAPI
ImmGenerateMessage(HIMC hIMC
)
2977 InputContextData
*data
= get_imc_data(hIMC
);
2981 SetLastError(ERROR_INVALID_HANDLE
);
2985 TRACE("%i messages queued\n",data
->IMC
.dwNumMsgBuf
);
2986 if (data
->IMC
.dwNumMsgBuf
> 0)
2988 LPTRANSMSG lpTransMsg
;
2990 DWORD i
, dwNumMsgBuf
;
2992 /* We are going to detach our hMsgBuff so that if processing messages
2993 generates new messages they go into a new buffer */
2994 hMsgBuf
= data
->IMC
.hMsgBuf
;
2995 dwNumMsgBuf
= data
->IMC
.dwNumMsgBuf
;
2997 data
->IMC
.hMsgBuf
= ImmCreateIMCC(0);
2998 data
->IMC
.dwNumMsgBuf
= 0;
3000 lpTransMsg
= ImmLockIMCC(hMsgBuf
);
3001 for (i
= 0; i
< dwNumMsgBuf
; i
++)
3002 ImmInternalSendIMEMessage(data
, lpTransMsg
[i
].message
, lpTransMsg
[i
].wParam
, lpTransMsg
[i
].lParam
);
3004 ImmUnlockIMCC(hMsgBuf
);
3005 ImmDestroyIMCC(hMsgBuf
);
3011 /***********************************************************************
3012 * ImmTranslateMessage(IMM32.@)
3013 * ( Undocumented, call internally and from user32.dll )
3015 BOOL WINAPI
ImmTranslateMessage(HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lKeyData
)
3017 InputContextData
*data
;
3018 HIMC imc
= ImmGetContext(hwnd
);
3024 static const DWORD list_count
= 10;
3026 TRACE("%p %x %x %x\n",hwnd
, msg
, (UINT
)wParam
, (UINT
)lKeyData
);
3033 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeToAsciiEx
)
3036 GetKeyboardState(state
);
3037 scancode
= lKeyData
>> 0x10 & 0xff;
3039 list
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, list_count
* sizeof(TRANSMSG
) + sizeof(DWORD
));
3040 ((DWORD
*)list
)[0] = list_count
;
3042 if (data
->immKbd
->imeInfo
.fdwProperty
& IME_PROP_KBD_CHAR_FIRST
)
3046 if (!is_himc_ime_unicode(data
))
3047 ToAscii(data
->lastVK
, scancode
, state
, &chr
, 0);
3049 ToUnicodeEx(data
->lastVK
, scancode
, state
, &chr
, 1, 0, GetKeyboardLayout(0));
3050 uVirtKey
= MAKELONG(data
->lastVK
,chr
);
3053 uVirtKey
= data
->lastVK
;
3055 msg_count
= data
->immKbd
->pImeToAsciiEx(uVirtKey
, scancode
, state
, list
, 0, imc
);
3056 TRACE("%i messages generated\n",msg_count
);
3057 if (msg_count
&& msg_count
<= list_count
)
3060 LPTRANSMSG msgs
= (LPTRANSMSG
)((LPBYTE
)list
+ sizeof(DWORD
));
3062 for (i
= 0; i
< msg_count
; i
++)
3063 ImmInternalPostIMEMessage(data
, msgs
[i
].message
, msgs
[i
].wParam
, msgs
[i
].lParam
);
3065 else if (msg_count
> list_count
)
3066 ImmGenerateMessage(imc
);
3068 HeapFree(GetProcessHeap(),0,list
);
3070 data
->lastVK
= VK_PROCESSKEY
;
3072 return (msg_count
> 0);
3075 /***********************************************************************
3076 * ImmProcessKey(IMM32.@)
3077 * ( Undocumented, called from user32.dll )
3079 BOOL WINAPI
ImmProcessKey(HWND hwnd
, HKL hKL
, UINT vKey
, LPARAM lKeyData
, DWORD unknown
)
3081 InputContextData
*data
;
3082 HIMC imc
= ImmGetContext(hwnd
);
3085 TRACE("%p %p %x %x %x\n",hwnd
, hKL
, vKey
, (UINT
)lKeyData
, unknown
);
3092 /* Make sure we are inputting to the correct keyboard */
3093 if (data
->immKbd
->hkl
!= hKL
)
3095 ImmHkl
*new_hkl
= IMM_GetImmHkl(hKL
);
3098 data
->immKbd
->pImeSelect(imc
, FALSE
);
3099 data
->immKbd
->uSelected
--;
3100 data
->immKbd
= new_hkl
;
3101 data
->immKbd
->pImeSelect(imc
, TRUE
);
3102 data
->immKbd
->uSelected
++;
3108 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeProcessKey
)
3111 GetKeyboardState(state
);
3112 if (data
->immKbd
->pImeProcessKey(imc
, vKey
, lKeyData
, state
))
3114 data
->lastVK
= vKey
;
3118 data
->lastVK
= VK_PROCESSKEY
;
3122 /***********************************************************************
3123 * ImmDisableTextFrameService(IMM32.@)
3125 BOOL WINAPI
ImmDisableTextFrameService(DWORD idThread
)
3131 /***********************************************************************
3132 * ImmEnumInputContext(IMM32.@)
3135 BOOL WINAPI
ImmEnumInputContext(DWORD idThread
, IMCENUMPROC lpfn
, LPARAM lParam
)
3141 /***********************************************************************
3142 * ImmGetHotKey(IMM32.@)
3145 BOOL WINAPI
ImmGetHotKey(DWORD hotkey
, UINT
*modifiers
, UINT
*key
, HKL hkl
)
3147 FIXME("%x, %p, %p, %p: stub\n", hotkey
, modifiers
, key
, hkl
);