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 MAKE_FUNCPTR(f) typeof(f) * p##f
41 typedef struct _tagImmHkl
{
46 WCHAR imeClassName
[17]; /* 16 character max */
50 /* Function Pointers */
51 MAKE_FUNCPTR(ImeInquire
);
52 MAKE_FUNCPTR(ImeConfigure
);
53 MAKE_FUNCPTR(ImeDestroy
);
54 MAKE_FUNCPTR(ImeEscape
);
55 MAKE_FUNCPTR(ImeSelect
);
56 MAKE_FUNCPTR(ImeSetActiveContext
);
57 MAKE_FUNCPTR(ImeToAsciiEx
);
58 MAKE_FUNCPTR(NotifyIME
);
59 MAKE_FUNCPTR(ImeRegisterWord
);
60 MAKE_FUNCPTR(ImeUnregisterWord
);
61 MAKE_FUNCPTR(ImeEnumRegisterWord
);
62 MAKE_FUNCPTR(ImeSetCompositionString
);
63 MAKE_FUNCPTR(ImeConversionList
);
64 MAKE_FUNCPTR(ImeProcessKey
);
65 MAKE_FUNCPTR(ImeGetRegisterWordStyle
);
66 MAKE_FUNCPTR(ImeGetImeMenuItems
);
70 typedef struct tagInputContextData
80 #define WINE_IMC_VALID_MAGIC 0x56434D49
82 typedef struct _tagTRANSMSG
{
86 } TRANSMSG
, *LPTRANSMSG
;
88 typedef struct _tagIMMThreadData
{
93 static DWORD tlsIndex
= 0;
94 static struct list ImmHklList
= LIST_INIT(ImmHklList
);
97 static UINT WM_MSIME_SERVICE
;
98 static UINT WM_MSIME_RECONVERTOPTIONS
;
99 static UINT WM_MSIME_MOUSE
;
100 static UINT WM_MSIME_RECONVERTREQUEST
;
101 static UINT WM_MSIME_RECONVERT
;
102 static UINT WM_MSIME_QUERYPOSITION
;
103 static UINT WM_MSIME_DOCUMENTFEED
;
105 static const WCHAR szwWineIMCProperty
[] = {'W','i','n','e','I','m','m','H','I','M','C','P','r','o','p','e','r','t','y',0};
107 static const WCHAR szImeFileW
[] = {'I','m','e',' ','F','i','l','e',0};
108 static const WCHAR szLayoutTextW
[] = {'L','a','y','o','u','t',' ','T','e','x','t',0};
109 static const WCHAR szImeRegFmt
[] = {'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','s','\\','%','0','8','l','x',0};
111 static const WCHAR szwIME
[] = {'I','M','E',0};
113 static LRESULT WINAPI
DefIME_WindowProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
,
116 #define is_himc_ime_unicode(p) (p->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE)
117 #define is_kbd_ime_unicode(p) (p->imeInfo.fdwProperty & IME_PROP_UNICODE)
119 static BOOL
IMM_DestroyContext(HIMC hIMC
);
121 static inline WCHAR
*strdupAtoW( const char *str
)
126 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
127 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
128 MultiByteToWideChar( CP_ACP
, 0, str
, -1, ret
, len
);
133 static inline CHAR
*strdupWtoA( const WCHAR
*str
)
138 DWORD len
= WideCharToMultiByte( CP_ACP
, 0, str
, -1, NULL
, 0, NULL
, NULL
);
139 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
)))
140 WideCharToMultiByte( CP_ACP
, 0, str
, -1, ret
, len
, NULL
, NULL
);
145 static DWORD
convert_candidatelist_WtoA(
146 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
150 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
151 if ( lpDst
&& dwBufLen
> 0 )
154 lpDst
->dwOffset
[0] = ret
;
157 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
159 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
161 if ( lpDst
&& dwBufLen
> 0 )
163 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
165 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1,
166 (LPSTR
)dest
, dwBufLen
, NULL
, NULL
);
168 if ( i
+ 1 < lpSrc
->dwCount
)
169 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(char);
170 dwBufLen
-= len
* sizeof(char);
173 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1, NULL
, 0, NULL
, NULL
);
175 ret
+= len
* sizeof(char);
184 static DWORD
convert_candidatelist_AtoW(
185 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
189 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
190 if ( lpDst
&& dwBufLen
> 0 )
193 lpDst
->dwOffset
[0] = ret
;
196 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
198 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
200 if ( lpDst
&& dwBufLen
> 0 )
202 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
204 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1,
205 (LPWSTR
)dest
, dwBufLen
);
207 if ( i
+ 1 < lpSrc
->dwCount
)
208 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(WCHAR
);
209 dwBufLen
-= len
* sizeof(WCHAR
);
212 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1, NULL
, 0);
214 ret
+= len
* sizeof(WCHAR
);
223 static IMMThreadData
* IMM_GetThreadData(void)
225 IMMThreadData
* data
= TlsGetValue(tlsIndex
);
228 data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
229 sizeof(IMMThreadData
));
230 TlsSetValue(tlsIndex
,data
);
231 TRACE("Thread Data Created\n");
236 static void IMM_FreeThreadData(void)
238 IMMThreadData
* data
= TlsGetValue(tlsIndex
);
241 IMM_DestroyContext(data
->defaultContext
);
242 DestroyWindow(data
->hwndDefault
);
243 HeapFree(GetProcessHeap(),0,data
);
244 TRACE("Thread Data Destroyed\n");
248 static HMODULE
load_graphics_driver(void)
250 static const WCHAR display_device_guid_propW
[] = {
251 '_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
252 'd','e','v','i','c','e','_','g','u','i','d',0 };
253 static const WCHAR key_pathW
[] = {
254 'S','y','s','t','e','m','\\',
255 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
256 'C','o','n','t','r','o','l','\\',
257 'V','i','d','e','o','\\','{',0};
258 static const WCHAR displayW
[] = {'}','\\','0','0','0','0',0};
259 static const WCHAR driverW
[] = {'G','r','a','p','h','i','c','s','D','r','i','v','e','r',0};
264 WCHAR path
[MAX_PATH
];
265 WCHAR key
[(sizeof(key_pathW
) + sizeof(displayW
)) / sizeof(WCHAR
) + 40];
266 UINT guid_atom
= HandleToULong( GetPropW( GetDesktopWindow(), display_device_guid_propW
));
268 if (!guid_atom
) return 0;
269 memcpy( key
, key_pathW
, sizeof(key_pathW
) );
270 if (!GlobalGetAtomNameW( guid_atom
, key
+ strlenW(key
), 40 )) return 0;
271 strcatW( key
, displayW
);
272 if (RegOpenKeyW( HKEY_LOCAL_MACHINE
, key
, &hkey
)) return 0;
274 if (!RegQueryValueExW( hkey
, driverW
, NULL
, NULL
, (BYTE
*)path
, &size
)) ret
= LoadLibraryW( path
);
276 TRACE( "%s %p\n", debugstr_w(path
), ret
);
280 /* ImmHkl loading and freeing */
281 #define LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}
282 static ImmHkl
*IMM_GetImmHkl(HKL hkl
)
285 WCHAR filename
[MAX_PATH
];
287 TRACE("Seeking ime for keyboard %p\n",hkl
);
289 LIST_FOR_EACH_ENTRY(ptr
, &ImmHklList
, ImmHkl
, entry
)
294 /* not found... create it */
296 ptr
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ImmHkl
));
299 if (ImmGetIMEFileNameW(hkl
, filename
, MAX_PATH
)) ptr
->hIME
= LoadLibraryW(filename
);
300 if (!ptr
->hIME
) ptr
->hIME
= load_graphics_driver();
303 LOAD_FUNCPTR(ImeInquire
);
304 if (!ptr
->pImeInquire
|| !ptr
->pImeInquire(&ptr
->imeInfo
, ptr
->imeClassName
, NULL
))
306 FreeLibrary(ptr
->hIME
);
311 LOAD_FUNCPTR(ImeDestroy
);
312 LOAD_FUNCPTR(ImeSelect
);
313 if (!ptr
->pImeSelect
|| !ptr
->pImeDestroy
)
315 FreeLibrary(ptr
->hIME
);
320 LOAD_FUNCPTR(ImeConfigure
);
321 LOAD_FUNCPTR(ImeEscape
);
322 LOAD_FUNCPTR(ImeSetActiveContext
);
323 LOAD_FUNCPTR(ImeToAsciiEx
);
324 LOAD_FUNCPTR(NotifyIME
);
325 LOAD_FUNCPTR(ImeRegisterWord
);
326 LOAD_FUNCPTR(ImeUnregisterWord
);
327 LOAD_FUNCPTR(ImeEnumRegisterWord
);
328 LOAD_FUNCPTR(ImeSetCompositionString
);
329 LOAD_FUNCPTR(ImeConversionList
);
330 LOAD_FUNCPTR(ImeProcessKey
);
331 LOAD_FUNCPTR(ImeGetRegisterWordStyle
);
332 LOAD_FUNCPTR(ImeGetImeMenuItems
);
333 /* make sure our classname is WCHAR */
334 if (!is_kbd_ime_unicode(ptr
))
337 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ptr
->imeClassName
,
339 lstrcpyW(ptr
->imeClassName
, bufW
);
344 list_add_head(&ImmHklList
,&ptr
->entry
);
350 static void IMM_FreeAllImmHkl(void)
352 ImmHkl
*ptr
,*cursor2
;
354 LIST_FOR_EACH_ENTRY_SAFE(ptr
, cursor2
, &ImmHklList
, ImmHkl
, entry
)
356 list_remove(&ptr
->entry
);
360 FreeLibrary(ptr
->hIME
);
363 DestroyWindow(ptr
->UIWnd
);
364 HeapFree(GetProcessHeap(),0,ptr
);
368 static void IMM_RegisterMessages(void)
370 WM_MSIME_SERVICE
= RegisterWindowMessageA("MSIMEService");
371 WM_MSIME_RECONVERTOPTIONS
= RegisterWindowMessageA("MSIMEReconvertOptions");
372 WM_MSIME_MOUSE
= RegisterWindowMessageA("MSIMEMouseOperation");
373 WM_MSIME_RECONVERTREQUEST
= RegisterWindowMessageA("MSIMEReconvertRequest");
374 WM_MSIME_RECONVERT
= RegisterWindowMessageA("MSIMEReconvert");
375 WM_MSIME_QUERYPOSITION
= RegisterWindowMessageA("MSIMEQueryPosition");
376 WM_MSIME_DOCUMENTFEED
= RegisterWindowMessageA("MSIMEDocumentFeed");
379 static void IMM_RegisterIMEClass(void)
383 ZeroMemory(&wndClass
, sizeof(WNDCLASSW
));
385 wndClass
.style
= CS_GLOBALCLASS
;
386 wndClass
.lpfnWndProc
= (WNDPROC
) DefIME_WindowProc
;
387 wndClass
.cbWndExtra
= 2 * sizeof(LONG_PTR
);
388 wndClass
.hCursor
= LoadCursorW(NULL
, (LPWSTR
)IDC_ARROW
);
389 wndClass
.lpszClassName
= szwIME
;
391 RegisterClassW(&wndClass
);
394 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID lpReserved
)
396 TRACE("%p, %x, %p\n",hInstDLL
,fdwReason
,lpReserved
);
399 case DLL_PROCESS_ATTACH
:
400 IMM_RegisterMessages();
401 tlsIndex
= TlsAlloc();
402 if (tlsIndex
== TLS_OUT_OF_INDEXES
)
404 IMM_RegisterIMEClass();
406 case DLL_THREAD_ATTACH
:
408 case DLL_THREAD_DETACH
:
409 IMM_FreeThreadData();
411 case DLL_PROCESS_DETACH
:
412 if (lpReserved
) break;
413 IMM_FreeThreadData();
416 UnregisterClassW(szwIME
, NULL
);
422 /* for posting messages as the IME */
423 static void ImmInternalPostIMEMessage(InputContextData
*data
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
425 HWND target
= GetFocus();
427 PostMessageW(data
->IMC
.hWnd
,msg
,wParam
,lParam
);
429 PostMessageW(target
, msg
, wParam
, lParam
);
432 static LRESULT
ImmInternalSendIMENotify(InputContextData
*data
, WPARAM notify
, LPARAM lParam
)
436 target
= data
->IMC
.hWnd
;
437 if (!target
) target
= GetFocus();
440 return SendMessageW(target
, WM_IME_NOTIFY
, notify
, lParam
);
445 static HIMCC
ImmCreateBlankCompStr(void)
448 LPCOMPOSITIONSTRING ptr
;
449 rc
= ImmCreateIMCC(sizeof(COMPOSITIONSTRING
));
450 ptr
= ImmLockIMCC(rc
);
451 memset(ptr
,0,sizeof(COMPOSITIONSTRING
));
452 ptr
->dwSize
= sizeof(COMPOSITIONSTRING
);
457 static InputContextData
* get_imc_data(HIMC hIMC
)
459 InputContextData
*data
= hIMC
;
464 if(IsBadReadPtr(data
, sizeof(InputContextData
)) || data
->magic
!= WINE_IMC_VALID_MAGIC
)
466 SetLastError(ERROR_INVALID_HANDLE
);
472 /***********************************************************************
473 * ImmAssociateContext (IMM32.@)
475 HIMC WINAPI
ImmAssociateContext(HWND hWnd
, HIMC hIMC
)
478 InputContextData
*data
= get_imc_data(hIMC
);
480 TRACE("(%p, %p):\n", hWnd
, hIMC
);
485 if (!IMM_GetThreadData()->defaultContext
)
486 IMM_GetThreadData()->defaultContext
= ImmCreateContext();
489 * If already associated just return
491 if (hIMC
&& data
->IMC
.hWnd
== hWnd
)
496 old
= RemovePropW(hWnd
,szwWineIMCProperty
);
499 old
= IMM_GetThreadData()->defaultContext
;
500 else if (old
== (HIMC
)-1)
503 if (hIMC
!= IMM_GetThreadData()->defaultContext
)
505 if (hIMC
== NULL
) /* Meaning disable imm for that window*/
506 SetPropW(hWnd
,szwWineIMCProperty
,(HANDLE
)-1);
508 SetPropW(hWnd
,szwWineIMCProperty
,hIMC
);
513 InputContextData
*old_data
= old
;
514 if (old_data
->IMC
.hWnd
== hWnd
)
515 old_data
->IMC
.hWnd
= NULL
;
522 if (IsWindow(data
->IMC
.hWnd
))
525 * Post a message that your context is switching
527 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, FALSE
, ISC_SHOWUIALL
);
530 data
->IMC
.hWnd
= hWnd
;
532 if (IsWindow(data
->IMC
.hWnd
))
535 * Post a message that your context is switching
537 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, TRUE
, ISC_SHOWUIALL
);
545 * Helper function for ImmAssociateContextEx
547 static BOOL CALLBACK
_ImmAssociateContextExEnumProc(HWND hwnd
, LPARAM lParam
)
549 HIMC hImc
= (HIMC
)lParam
;
550 ImmAssociateContext(hwnd
,hImc
);
554 /***********************************************************************
555 * ImmAssociateContextEx (IMM32.@)
557 BOOL WINAPI
ImmAssociateContextEx(HWND hWnd
, HIMC hIMC
, DWORD dwFlags
)
559 TRACE("(%p, %p, 0x%x):\n", hWnd
, hIMC
, dwFlags
);
561 if (!IMM_GetThreadData()->defaultContext
)
562 IMM_GetThreadData()->defaultContext
= ImmCreateContext();
564 if (!hWnd
) return FALSE
;
569 ImmAssociateContext(hWnd
,hIMC
);
572 ImmAssociateContext(hWnd
,IMM_GetThreadData()->defaultContext
);
574 case IACE_IGNORENOCONTEXT
:
575 if (GetPropW(hWnd
,szwWineIMCProperty
))
576 ImmAssociateContext(hWnd
,hIMC
);
579 EnumChildWindows(hWnd
,_ImmAssociateContextExEnumProc
,(LPARAM
)hIMC
);
582 FIXME("Unknown dwFlags 0x%x\n",dwFlags
);
587 /***********************************************************************
588 * ImmConfigureIMEA (IMM32.@)
590 BOOL WINAPI
ImmConfigureIMEA(
591 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
593 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
595 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
597 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
600 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
602 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| !is_kbd_ime_unicode(immHkl
))
603 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
607 REGISTERWORDA
*rwa
= lpData
;
610 rww
.lpReading
= strdupAtoW(rwa
->lpReading
);
611 rww
.lpWord
= strdupAtoW(rwa
->lpWord
);
612 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rww
);
613 HeapFree(GetProcessHeap(),0,rww
.lpReading
);
614 HeapFree(GetProcessHeap(),0,rww
.lpWord
);
622 /***********************************************************************
623 * ImmConfigureIMEW (IMM32.@)
625 BOOL WINAPI
ImmConfigureIMEW(
626 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
628 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
630 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
632 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
635 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
637 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| is_kbd_ime_unicode(immHkl
))
638 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
641 REGISTERWORDW
*rww
= lpData
;
645 rwa
.lpReading
= strdupWtoA(rww
->lpReading
);
646 rwa
.lpWord
= strdupWtoA(rww
->lpWord
);
647 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rwa
);
648 HeapFree(GetProcessHeap(),0,rwa
.lpReading
);
649 HeapFree(GetProcessHeap(),0,rwa
.lpWord
);
657 /***********************************************************************
658 * ImmCreateContext (IMM32.@)
660 HIMC WINAPI
ImmCreateContext(void)
662 InputContextData
*new_context
;
667 new_context
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(InputContextData
));
670 new_context
->immKbd
= IMM_GetImmHkl(GetKeyboardLayout(0));
672 if (!new_context
->immKbd
->hIME
)
674 TRACE("IME dll could not be loaded\n");
675 HeapFree(GetProcessHeap(),0,new_context
);
679 /* the HIMCCs are never NULL */
680 new_context
->IMC
.hCompStr
= ImmCreateBlankCompStr();
681 new_context
->IMC
.hMsgBuf
= ImmCreateIMCC(0);
682 new_context
->IMC
.hCandInfo
= ImmCreateIMCC(sizeof(CANDIDATEINFO
));
683 ci
= ImmLockIMCC(new_context
->IMC
.hCandInfo
);
684 memset(ci
,0,sizeof(CANDIDATEINFO
));
685 ci
->dwSize
= sizeof(CANDIDATEINFO
);
686 ImmUnlockIMCC(new_context
->IMC
.hCandInfo
);
687 new_context
->IMC
.hGuideLine
= ImmCreateIMCC(sizeof(GUIDELINE
));
688 gl
= ImmLockIMCC(new_context
->IMC
.hGuideLine
);
689 memset(gl
,0,sizeof(GUIDELINE
));
690 gl
->dwSize
= sizeof(GUIDELINE
);
691 ImmUnlockIMCC(new_context
->IMC
.hGuideLine
);
693 for (i
= 0; i
< sizeof(new_context
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
); i
++)
694 new_context
->IMC
.cfCandForm
[i
].dwIndex
= ~0u;
696 /* Initialize the IME Private */
697 new_context
->IMC
.hPrivate
= ImmCreateIMCC(new_context
->immKbd
->imeInfo
.dwPrivateDataSize
);
699 new_context
->IMC
.fdwConversion
= new_context
->immKbd
->imeInfo
.fdwConversionCaps
;
700 new_context
->IMC
.fdwSentence
= new_context
->immKbd
->imeInfo
.fdwSentenceCaps
;
702 if (!new_context
->immKbd
->pImeSelect(new_context
, TRUE
))
704 TRACE("Selection of IME failed\n");
705 IMM_DestroyContext(new_context
);
708 SendMessageW(GetFocus(), WM_IME_SELECT
, TRUE
, (LPARAM
)GetKeyboardLayout(0));
710 new_context
->immKbd
->uSelected
++;
711 TRACE("Created context %p\n",new_context
);
713 new_context
->magic
= WINE_IMC_VALID_MAGIC
;
717 static BOOL
IMM_DestroyContext(HIMC hIMC
)
719 InputContextData
*data
= get_imc_data(hIMC
);
721 TRACE("Destroying %p\n",hIMC
);
726 data
->immKbd
->uSelected
--;
727 data
->immKbd
->pImeSelect(hIMC
, FALSE
);
728 SendMessageW(data
->IMC
.hWnd
, WM_IME_SELECT
, FALSE
, (LPARAM
)GetKeyboardLayout(0));
730 ImmDestroyIMCC(data
->IMC
.hCompStr
);
731 ImmDestroyIMCC(data
->IMC
.hCandInfo
);
732 ImmDestroyIMCC(data
->IMC
.hGuideLine
);
733 ImmDestroyIMCC(data
->IMC
.hPrivate
);
734 ImmDestroyIMCC(data
->IMC
.hMsgBuf
);
737 HeapFree(GetProcessHeap(),0,data
);
742 /***********************************************************************
743 * ImmDestroyContext (IMM32.@)
745 BOOL WINAPI
ImmDestroyContext(HIMC hIMC
)
747 if (hIMC
!= IMM_GetThreadData()->defaultContext
)
748 return IMM_DestroyContext(hIMC
);
753 /***********************************************************************
754 * ImmDisableIME (IMM32.@)
756 BOOL WINAPI
ImmDisableIME(DWORD idThread
)
758 FIXME("(%d): stub\n", idThread
);
762 /***********************************************************************
763 * ImmEnumRegisterWordA (IMM32.@)
765 UINT WINAPI
ImmEnumRegisterWordA(
766 HKL hKL
, REGISTERWORDENUMPROCA lpfnEnumProc
,
767 LPCSTR lpszReading
, DWORD dwStyle
,
768 LPCSTR lpszRegister
, LPVOID lpData
)
770 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
771 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
772 debugstr_a(lpszReading
), dwStyle
, debugstr_a(lpszRegister
), lpData
);
773 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
775 if (!is_kbd_ime_unicode(immHkl
))
776 return immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
777 (LPCWSTR
)lpszReading
, dwStyle
, (LPCWSTR
)lpszRegister
, lpData
);
780 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
781 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
784 rc
= immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
785 lpszwReading
, dwStyle
, lpszwRegister
,
788 HeapFree(GetProcessHeap(),0,lpszwReading
);
789 HeapFree(GetProcessHeap(),0,lpszwRegister
);
797 /***********************************************************************
798 * ImmEnumRegisterWordW (IMM32.@)
800 UINT WINAPI
ImmEnumRegisterWordW(
801 HKL hKL
, REGISTERWORDENUMPROCW lpfnEnumProc
,
802 LPCWSTR lpszReading
, DWORD dwStyle
,
803 LPCWSTR lpszRegister
, LPVOID lpData
)
805 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
806 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
807 debugstr_w(lpszReading
), dwStyle
, debugstr_w(lpszRegister
), lpData
);
808 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
810 if (is_kbd_ime_unicode(immHkl
))
811 return immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, lpszReading
, dwStyle
,
812 lpszRegister
, lpData
);
815 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
816 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
819 rc
= immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, (LPCWSTR
)lpszaReading
,
820 dwStyle
, (LPCWSTR
)lpszaRegister
, lpData
);
822 HeapFree(GetProcessHeap(),0,lpszaReading
);
823 HeapFree(GetProcessHeap(),0,lpszaRegister
);
831 static inline BOOL
EscapeRequiresWA(UINT uEscape
)
833 if (uEscape
== IME_ESC_GET_EUDC_DICTIONARY
||
834 uEscape
== IME_ESC_SET_EUDC_DICTIONARY
||
835 uEscape
== IME_ESC_IME_NAME
||
836 uEscape
== IME_ESC_GETHELPFILENAME
)
841 /***********************************************************************
842 * ImmEscapeA (IMM32.@)
844 LRESULT WINAPI
ImmEscapeA(
846 UINT uEscape
, LPVOID lpData
)
848 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
849 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
851 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
853 if (!EscapeRequiresWA(uEscape
) || !is_kbd_ime_unicode(immHkl
))
854 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
857 WCHAR buffer
[81]; /* largest required buffer should be 80 */
859 if (uEscape
== IME_ESC_SET_EUDC_DICTIONARY
)
861 MultiByteToWideChar(CP_ACP
,0,lpData
,-1,buffer
,81);
862 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
866 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
867 WideCharToMultiByte(CP_ACP
,0,buffer
,-1,lpData
,80, NULL
, NULL
);
876 /***********************************************************************
877 * ImmEscapeW (IMM32.@)
879 LRESULT WINAPI
ImmEscapeW(
881 UINT uEscape
, LPVOID lpData
)
883 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
884 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
886 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
888 if (!EscapeRequiresWA(uEscape
) || is_kbd_ime_unicode(immHkl
))
889 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
892 CHAR buffer
[81]; /* largest required buffer should be 80 */
894 if (uEscape
== IME_ESC_SET_EUDC_DICTIONARY
)
896 WideCharToMultiByte(CP_ACP
,0,lpData
,-1,buffer
,81, NULL
, NULL
);
897 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
901 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
902 MultiByteToWideChar(CP_ACP
,0,buffer
,-1,lpData
,80);
911 /***********************************************************************
912 * ImmGetCandidateListA (IMM32.@)
914 DWORD WINAPI
ImmGetCandidateListA(
915 HIMC hIMC
, DWORD dwIndex
,
916 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
918 InputContextData
*data
= get_imc_data(hIMC
);
919 LPCANDIDATEINFO candinfo
;
920 LPCANDIDATELIST candlist
;
923 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
925 if (!data
|| !data
->IMC
.hCandInfo
)
928 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
929 if ( dwIndex
>= candinfo
->dwCount
||
930 dwIndex
>= (sizeof(candinfo
->dwOffset
) / sizeof(DWORD
)) )
933 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
934 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
937 if ( !is_himc_ime_unicode(data
) )
939 ret
= candlist
->dwSize
;
940 if ( lpCandList
&& dwBufLen
>= ret
)
941 memcpy(lpCandList
, candlist
, ret
);
944 ret
= convert_candidatelist_WtoA( candlist
, lpCandList
, dwBufLen
);
947 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
951 /***********************************************************************
952 * ImmGetCandidateListCountA (IMM32.@)
954 DWORD WINAPI
ImmGetCandidateListCountA(
955 HIMC hIMC
, LPDWORD lpdwListCount
)
957 InputContextData
*data
= get_imc_data(hIMC
);
958 LPCANDIDATEINFO candinfo
;
961 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
963 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
966 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
968 *lpdwListCount
= count
= candinfo
->dwCount
;
970 if ( !is_himc_ime_unicode(data
) )
971 ret
= candinfo
->dwSize
;
974 ret
= sizeof(CANDIDATEINFO
);
976 ret
+= ImmGetCandidateListA(hIMC
, count
, NULL
, 0);
979 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
983 /***********************************************************************
984 * ImmGetCandidateListCountW (IMM32.@)
986 DWORD WINAPI
ImmGetCandidateListCountW(
987 HIMC hIMC
, LPDWORD lpdwListCount
)
989 InputContextData
*data
= get_imc_data(hIMC
);
990 LPCANDIDATEINFO candinfo
;
993 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
995 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
998 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1000 *lpdwListCount
= count
= candinfo
->dwCount
;
1002 if ( is_himc_ime_unicode(data
) )
1003 ret
= candinfo
->dwSize
;
1006 ret
= sizeof(CANDIDATEINFO
);
1008 ret
+= ImmGetCandidateListW(hIMC
, count
, NULL
, 0);
1011 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1015 /***********************************************************************
1016 * ImmGetCandidateListW (IMM32.@)
1018 DWORD WINAPI
ImmGetCandidateListW(
1019 HIMC hIMC
, DWORD dwIndex
,
1020 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
1022 InputContextData
*data
= get_imc_data(hIMC
);
1023 LPCANDIDATEINFO candinfo
;
1024 LPCANDIDATELIST candlist
;
1027 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
1029 if (!data
|| !data
->IMC
.hCandInfo
)
1032 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
1033 if ( dwIndex
>= candinfo
->dwCount
||
1034 dwIndex
>= (sizeof(candinfo
->dwOffset
) / sizeof(DWORD
)) )
1037 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
1038 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
1041 if ( is_himc_ime_unicode(data
) )
1043 ret
= candlist
->dwSize
;
1044 if ( lpCandList
&& dwBufLen
>= ret
)
1045 memcpy(lpCandList
, candlist
, ret
);
1048 ret
= convert_candidatelist_AtoW( candlist
, lpCandList
, dwBufLen
);
1051 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1055 /***********************************************************************
1056 * ImmGetCandidateWindow (IMM32.@)
1058 BOOL WINAPI
ImmGetCandidateWindow(
1059 HIMC hIMC
, DWORD dwIndex
, LPCANDIDATEFORM lpCandidate
)
1061 InputContextData
*data
= get_imc_data(hIMC
);
1063 TRACE("%p, %d, %p\n", hIMC
, dwIndex
, lpCandidate
);
1065 if (!data
|| !lpCandidate
)
1068 if ( dwIndex
>= (sizeof(data
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
)) )
1071 if (data
->IMC
.cfCandForm
[dwIndex
].dwIndex
!= dwIndex
)
1074 *lpCandidate
= data
->IMC
.cfCandForm
[dwIndex
];
1079 /***********************************************************************
1080 * ImmGetCompositionFontA (IMM32.@)
1082 BOOL WINAPI
ImmGetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
1087 TRACE("(%p, %p):\n", hIMC
, lplf
);
1089 rc
= ImmGetCompositionFontW(hIMC
,&lfW
);
1093 memcpy(lplf
,&lfW
,sizeof(LOGFONTA
));
1094 WideCharToMultiByte(CP_ACP
, 0, lfW
.lfFaceName
, -1, lplf
->lfFaceName
,
1095 LF_FACESIZE
, NULL
, NULL
);
1099 /***********************************************************************
1100 * ImmGetCompositionFontW (IMM32.@)
1102 BOOL WINAPI
ImmGetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
1104 InputContextData
*data
= get_imc_data(hIMC
);
1106 TRACE("(%p, %p):\n", hIMC
, lplf
);
1111 *lplf
= data
->IMC
.lfFont
.W
;
1117 /* Helpers for the GetCompositionString functions */
1119 static INT
CopyCompStringIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE target
, INT tlen
,
1124 if (is_himc_ime_unicode(data
) && !unicode
)
1125 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)source
, slen
, (LPSTR
)target
, tlen
, NULL
, NULL
);
1126 else if (!is_himc_ime_unicode(data
) && unicode
)
1127 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)source
, slen
, (LPWSTR
)target
, tlen
) * sizeof(WCHAR
);
1130 int dlen
= (unicode
)?sizeof(WCHAR
):sizeof(CHAR
);
1131 memcpy( target
, source
, min(slen
,tlen
)*dlen
);
1138 static INT
CopyCompAttrIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
, INT sslen
,
1139 LPBYTE target
, INT tlen
, BOOL unicode
)
1143 if (is_himc_ime_unicode(data
) && !unicode
)
1145 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, sslen
, NULL
, 0, NULL
, NULL
);
1148 const BYTE
*src
= source
;
1149 LPBYTE dst
= target
;
1150 int i
, j
= 0, k
= 0;
1154 for (i
= 0; i
< sslen
; ++i
)
1158 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)ssource
+ i
, 1,
1159 NULL
, 0, NULL
, NULL
);
1160 for (; len
> 0; --len
)
1173 else if (!is_himc_ime_unicode(data
) && unicode
)
1175 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, sslen
, NULL
, 0);
1178 const BYTE
*src
= source
;
1179 LPBYTE dst
= target
;
1184 for (i
= 0; i
< sslen
; ++i
)
1186 if (IsDBCSLeadByte(((LPSTR
)ssource
)[i
]))
1199 memcpy( target
, source
, min(slen
,tlen
));
1206 static INT
CopyCompClauseIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
,
1207 LPBYTE target
, INT tlen
, BOOL unicode
)
1211 if (is_himc_ime_unicode(data
) && !unicode
)
1219 tlen
/= sizeof (DWORD
);
1220 for (i
= 0; i
< tlen
; ++i
)
1222 ((DWORD
*)target
)[i
] = WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
,
1223 ((DWORD
*)source
)[i
],
1227 rc
= sizeof (DWORD
) * i
;
1232 else if (!is_himc_ime_unicode(data
) && unicode
)
1240 tlen
/= sizeof (DWORD
);
1241 for (i
= 0; i
< tlen
; ++i
)
1243 ((DWORD
*)target
)[i
] = MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
,
1244 ((DWORD
*)source
)[i
],
1247 rc
= sizeof (DWORD
) * i
;
1254 memcpy( target
, source
, min(slen
,tlen
));
1261 static INT
CopyCompOffsetIMEtoClient(InputContextData
*data
, DWORD offset
, LPBYTE ssource
, BOOL unicode
)
1265 if (is_himc_ime_unicode(data
) && !unicode
)
1267 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, offset
, NULL
, 0, NULL
, NULL
);
1269 else if (!is_himc_ime_unicode(data
) && unicode
)
1271 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, offset
, NULL
, 0);
1279 static LONG
ImmGetCompositionStringT( HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
,
1280 DWORD dwBufLen
, BOOL unicode
)
1283 InputContextData
*data
= get_imc_data(hIMC
);
1284 LPCOMPOSITIONSTRING compstr
;
1287 TRACE("(%p, 0x%x, %p, %d)\n", hIMC
, dwIndex
, lpBuf
, dwBufLen
);
1292 if (!data
->IMC
.hCompStr
)
1295 compdata
= ImmLockIMCC(data
->IMC
.hCompStr
);
1296 compstr
= (LPCOMPOSITIONSTRING
)compdata
;
1301 TRACE("GCS_RESULTSTR\n");
1302 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultStrOffset
, compstr
->dwResultStrLen
, lpBuf
, dwBufLen
, unicode
);
1305 TRACE("GCS_COMPSTR\n");
1306 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
, lpBuf
, dwBufLen
, unicode
);
1309 TRACE("GCS_COMPATTR\n");
1310 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompAttrOffset
, compstr
->dwCompAttrLen
,
1311 compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
,
1312 lpBuf
, dwBufLen
, unicode
);
1314 case GCS_COMPCLAUSE
:
1315 TRACE("GCS_COMPCLAUSE\n");
1316 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompClauseOffset
,compstr
->dwCompClauseLen
,
1317 compdata
+ compstr
->dwCompStrOffset
,
1318 lpBuf
, dwBufLen
, unicode
);
1320 case GCS_RESULTCLAUSE
:
1321 TRACE("GCS_RESULTCLAUSE\n");
1322 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultClauseOffset
,compstr
->dwResultClauseLen
,
1323 compdata
+ compstr
->dwResultStrOffset
,
1324 lpBuf
, dwBufLen
, unicode
);
1326 case GCS_RESULTREADSTR
:
1327 TRACE("GCS_RESULTREADSTR\n");
1328 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultReadStrOffset
, compstr
->dwResultReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1330 case GCS_RESULTREADCLAUSE
:
1331 TRACE("GCS_RESULTREADCLAUSE\n");
1332 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultReadClauseOffset
,compstr
->dwResultReadClauseLen
,
1333 compdata
+ compstr
->dwResultStrOffset
,
1334 lpBuf
, dwBufLen
, unicode
);
1336 case GCS_COMPREADSTR
:
1337 TRACE("GCS_COMPREADSTR\n");
1338 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1340 case GCS_COMPREADATTR
:
1341 TRACE("GCS_COMPREADATTR\n");
1342 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompReadAttrOffset
, compstr
->dwCompReadAttrLen
,
1343 compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
,
1344 lpBuf
, dwBufLen
, unicode
);
1346 case GCS_COMPREADCLAUSE
:
1347 TRACE("GCS_COMPREADCLAUSE\n");
1348 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompReadClauseOffset
,compstr
->dwCompReadClauseLen
,
1349 compdata
+ compstr
->dwCompStrOffset
,
1350 lpBuf
, dwBufLen
, unicode
);
1353 TRACE("GCS_CURSORPOS\n");
1354 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwCursorPos
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1356 case GCS_DELTASTART
:
1357 TRACE("GCS_DELTASTART\n");
1358 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwDeltaStart
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1361 FIXME("Unhandled index 0x%x\n",dwIndex
);
1365 ImmUnlockIMCC(data
->IMC
.hCompStr
);
1370 /***********************************************************************
1371 * ImmGetCompositionStringA (IMM32.@)
1373 LONG WINAPI
ImmGetCompositionStringA(
1374 HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
, DWORD dwBufLen
)
1376 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, FALSE
);
1380 /***********************************************************************
1381 * ImmGetCompositionStringW (IMM32.@)
1383 LONG WINAPI
ImmGetCompositionStringW(
1384 HIMC hIMC
, DWORD dwIndex
,
1385 LPVOID lpBuf
, DWORD dwBufLen
)
1387 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, TRUE
);
1390 /***********************************************************************
1391 * ImmGetCompositionWindow (IMM32.@)
1393 BOOL WINAPI
ImmGetCompositionWindow(HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
1395 InputContextData
*data
= get_imc_data(hIMC
);
1397 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
1402 *lpCompForm
= data
->IMC
.cfCompForm
;
1406 /***********************************************************************
1407 * ImmGetContext (IMM32.@)
1410 HIMC WINAPI
ImmGetContext(HWND hWnd
)
1414 TRACE("%p\n", hWnd
);
1416 if (!IsWindow(hWnd
))
1418 SetLastError(ERROR_INVALID_WINDOW_HANDLE
);
1421 if (!IMM_GetThreadData()->defaultContext
)
1422 IMM_GetThreadData()->defaultContext
= ImmCreateContext();
1424 rc
= GetPropW(hWnd
,szwWineIMCProperty
);
1427 else if (rc
== NULL
)
1428 rc
= IMM_GetThreadData()->defaultContext
;
1432 InputContextData
*data
= rc
;
1433 data
->IMC
.hWnd
= hWnd
;
1435 TRACE("returning %p\n", rc
);
1440 /***********************************************************************
1441 * ImmGetConversionListA (IMM32.@)
1443 DWORD WINAPI
ImmGetConversionListA(
1445 LPCSTR pSrc
, LPCANDIDATELIST lpDst
,
1446 DWORD dwBufLen
, UINT uFlag
)
1448 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1449 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_a(pSrc
), lpDst
,
1451 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1453 if (!is_kbd_ime_unicode(immHkl
))
1454 return immHkl
->pImeConversionList(hIMC
,(LPCWSTR
)pSrc
,lpDst
,dwBufLen
,uFlag
);
1457 LPCANDIDATELIST lpwDst
;
1459 LPWSTR pwSrc
= strdupAtoW(pSrc
);
1461 len
= immHkl
->pImeConversionList(hIMC
, pwSrc
, NULL
, 0, uFlag
);
1462 lpwDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1465 immHkl
->pImeConversionList(hIMC
, pwSrc
, lpwDst
, len
, uFlag
);
1466 ret
= convert_candidatelist_WtoA( lpwDst
, lpDst
, dwBufLen
);
1467 HeapFree(GetProcessHeap(), 0, lpwDst
);
1469 HeapFree(GetProcessHeap(), 0, pwSrc
);
1478 /***********************************************************************
1479 * ImmGetConversionListW (IMM32.@)
1481 DWORD WINAPI
ImmGetConversionListW(
1483 LPCWSTR pSrc
, LPCANDIDATELIST lpDst
,
1484 DWORD dwBufLen
, UINT uFlag
)
1486 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1487 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_w(pSrc
), lpDst
,
1489 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1491 if (is_kbd_ime_unicode(immHkl
))
1492 return immHkl
->pImeConversionList(hIMC
,pSrc
,lpDst
,dwBufLen
,uFlag
);
1495 LPCANDIDATELIST lpaDst
;
1497 LPSTR paSrc
= strdupWtoA(pSrc
);
1499 len
= immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, NULL
, 0, uFlag
);
1500 lpaDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1503 immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, lpaDst
, len
, uFlag
);
1504 ret
= convert_candidatelist_AtoW( lpaDst
, lpDst
, dwBufLen
);
1505 HeapFree(GetProcessHeap(), 0, lpaDst
);
1507 HeapFree(GetProcessHeap(), 0, paSrc
);
1516 /***********************************************************************
1517 * ImmGetConversionStatus (IMM32.@)
1519 BOOL WINAPI
ImmGetConversionStatus(
1520 HIMC hIMC
, LPDWORD lpfdwConversion
, LPDWORD lpfdwSentence
)
1522 InputContextData
*data
= get_imc_data(hIMC
);
1524 TRACE("%p %p %p\n", hIMC
, lpfdwConversion
, lpfdwSentence
);
1529 if (lpfdwConversion
)
1530 *lpfdwConversion
= data
->IMC
.fdwConversion
;
1532 *lpfdwSentence
= data
->IMC
.fdwSentence
;
1537 /***********************************************************************
1538 * ImmGetDefaultIMEWnd (IMM32.@)
1540 HWND WINAPI
ImmGetDefaultIMEWnd(HWND hWnd
)
1542 if (IMM_GetThreadData()->hwndDefault
== NULL
)
1543 IMM_GetThreadData()->hwndDefault
= CreateWindowExW( WS_EX_TOOLWINDOW
,
1544 szwIME
, NULL
, WS_POPUP
, 0, 0, 1, 1, 0, 0, 0, 0);
1545 TRACE("Default is %p\n",IMM_GetThreadData()->hwndDefault
);
1546 return IMM_GetThreadData()->hwndDefault
;
1549 /***********************************************************************
1550 * ImmGetDescriptionA (IMM32.@)
1552 UINT WINAPI
ImmGetDescriptionA(
1553 HKL hKL
, LPSTR lpszDescription
, UINT uBufLen
)
1558 TRACE("%p %p %d\n", hKL
, lpszDescription
, uBufLen
);
1560 /* find out how many characters in the unicode buffer */
1561 len
= ImmGetDescriptionW( hKL
, NULL
, 0 );
1565 /* allocate a buffer of that size */
1566 buf
= HeapAlloc( GetProcessHeap(), 0, (len
+ 1) * sizeof (WCHAR
) );
1570 /* fetch the unicode buffer */
1571 len
= ImmGetDescriptionW( hKL
, buf
, len
+ 1 );
1573 /* convert it back to ASCII */
1574 len
= WideCharToMultiByte( CP_ACP
, 0, buf
, len
+ 1,
1575 lpszDescription
, uBufLen
, NULL
, NULL
);
1577 HeapFree( GetProcessHeap(), 0, buf
);
1585 /***********************************************************************
1586 * ImmGetDescriptionW (IMM32.@)
1588 UINT WINAPI
ImmGetDescriptionW(HKL hKL
, LPWSTR lpszDescription
, UINT uBufLen
)
1590 static const WCHAR name
[] = { 'W','i','n','e',' ','X','I','M',0 };
1592 FIXME("(%p, %p, %d): semi stub\n", hKL
, lpszDescription
, uBufLen
);
1595 if (!uBufLen
) return lstrlenW( name
);
1596 lstrcpynW( lpszDescription
, name
, uBufLen
);
1597 return lstrlenW( lpszDescription
);
1600 /***********************************************************************
1601 * ImmGetGuideLineA (IMM32.@)
1603 DWORD WINAPI
ImmGetGuideLineA(
1604 HIMC hIMC
, DWORD dwIndex
, LPSTR lpBuf
, DWORD dwBufLen
)
1606 FIXME("(%p, %d, %s, %d): stub\n",
1607 hIMC
, dwIndex
, debugstr_a(lpBuf
), dwBufLen
1609 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1613 /***********************************************************************
1614 * ImmGetGuideLineW (IMM32.@)
1616 DWORD WINAPI
ImmGetGuideLineW(HIMC hIMC
, DWORD dwIndex
, LPWSTR lpBuf
, DWORD dwBufLen
)
1618 FIXME("(%p, %d, %s, %d): stub\n",
1619 hIMC
, dwIndex
, debugstr_w(lpBuf
), dwBufLen
1621 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1625 /***********************************************************************
1626 * ImmGetIMEFileNameA (IMM32.@)
1628 UINT WINAPI
ImmGetIMEFileNameA( HKL hKL
, LPSTR lpszFileName
, UINT uBufLen
)
1631 UINT wBufLen
= uBufLen
;
1634 if (uBufLen
&& lpszFileName
)
1635 bufW
= HeapAlloc(GetProcessHeap(),0,uBufLen
* sizeof(WCHAR
));
1636 else /* We need this to get the number of byte required */
1638 bufW
= HeapAlloc(GetProcessHeap(),0,MAX_PATH
* sizeof(WCHAR
));
1642 rc
= ImmGetIMEFileNameW(hKL
,bufW
,wBufLen
);
1646 if (uBufLen
&& lpszFileName
)
1647 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, lpszFileName
,
1648 uBufLen
, NULL
, NULL
);
1649 else /* get the length */
1650 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, NULL
, 0, NULL
,
1654 HeapFree(GetProcessHeap(),0,bufW
);
1658 /***********************************************************************
1659 * ImmGetIMEFileNameW (IMM32.@)
1661 UINT WINAPI
ImmGetIMEFileNameW(HKL hKL
, LPWSTR lpszFileName
, UINT uBufLen
)
1666 WCHAR regKey
[sizeof(szImeRegFmt
)/sizeof(WCHAR
)+8];
1668 wsprintfW( regKey
, szImeRegFmt
, (ULONG_PTR
)hKL
);
1669 rc
= RegOpenKeyW( HKEY_LOCAL_MACHINE
, regKey
, &hkey
);
1670 if (rc
!= ERROR_SUCCESS
)
1677 rc
= RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, NULL
, &length
);
1679 if (rc
!= ERROR_SUCCESS
)
1685 if (length
> uBufLen
* sizeof(WCHAR
) || !lpszFileName
)
1690 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
1694 return length
/ sizeof(WCHAR
);
1697 RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, lpszFileName
, &length
);
1701 return length
/ sizeof(WCHAR
);
1704 /***********************************************************************
1705 * ImmGetOpenStatus (IMM32.@)
1707 BOOL WINAPI
ImmGetOpenStatus(HIMC hIMC
)
1709 InputContextData
*data
= get_imc_data(hIMC
);
1715 TRACE("(%p): semi-stub\n", hIMC
);
1718 FIXME("(%p): semi-stub\n", hIMC
);
1720 return data
->IMC
.fOpen
;
1723 /***********************************************************************
1724 * ImmGetProperty (IMM32.@)
1726 DWORD WINAPI
ImmGetProperty(HKL hKL
, DWORD fdwIndex
)
1731 TRACE("(%p, %d)\n", hKL
, fdwIndex
);
1732 kbd
= IMM_GetImmHkl(hKL
);
1734 if (kbd
&& kbd
->hIME
)
1738 case IGP_PROPERTY
: rc
= kbd
->imeInfo
.fdwProperty
; break;
1739 case IGP_CONVERSION
: rc
= kbd
->imeInfo
.fdwConversionCaps
; break;
1740 case IGP_SENTENCE
: rc
= kbd
->imeInfo
.fdwSentenceCaps
; break;
1741 case IGP_SETCOMPSTR
: rc
= kbd
->imeInfo
.fdwSCSCaps
; break;
1742 case IGP_SELECT
: rc
= kbd
->imeInfo
.fdwSelectCaps
; break;
1743 case IGP_GETIMEVERSION
: rc
= IMEVER_0400
; break;
1744 case IGP_UI
: rc
= 0; break;
1751 /***********************************************************************
1752 * ImmGetRegisterWordStyleA (IMM32.@)
1754 UINT WINAPI
ImmGetRegisterWordStyleA(
1755 HKL hKL
, UINT nItem
, LPSTYLEBUFA lpStyleBuf
)
1757 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1758 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1759 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1761 if (!is_kbd_ime_unicode(immHkl
))
1762 return immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)lpStyleBuf
);
1768 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,&sbw
);
1769 WideCharToMultiByte(CP_ACP
, 0, sbw
.szDescription
, -1,
1770 lpStyleBuf
->szDescription
, 32, NULL
, NULL
);
1771 lpStyleBuf
->dwStyle
= sbw
.dwStyle
;
1779 /***********************************************************************
1780 * ImmGetRegisterWordStyleW (IMM32.@)
1782 UINT WINAPI
ImmGetRegisterWordStyleW(
1783 HKL hKL
, UINT nItem
, LPSTYLEBUFW lpStyleBuf
)
1785 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1786 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1787 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1789 if (is_kbd_ime_unicode(immHkl
))
1790 return immHkl
->pImeGetRegisterWordStyle(nItem
,lpStyleBuf
);
1796 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)&sba
);
1797 MultiByteToWideChar(CP_ACP
, 0, sba
.szDescription
, -1,
1798 lpStyleBuf
->szDescription
, 32);
1799 lpStyleBuf
->dwStyle
= sba
.dwStyle
;
1807 /***********************************************************************
1808 * ImmGetStatusWindowPos (IMM32.@)
1810 BOOL WINAPI
ImmGetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
1812 InputContextData
*data
= get_imc_data(hIMC
);
1814 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
1816 if (!data
|| !lpptPos
)
1819 *lpptPos
= data
->IMC
.ptStatusWndPos
;
1824 /***********************************************************************
1825 * ImmGetVirtualKey (IMM32.@)
1827 UINT WINAPI
ImmGetVirtualKey(HWND hWnd
)
1829 OSVERSIONINFOA version
;
1830 InputContextData
*data
= ImmGetContext( hWnd
);
1831 TRACE("%p\n", hWnd
);
1834 return data
->lastVK
;
1836 version
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFOA
);
1837 GetVersionExA( &version
);
1838 switch(version
.dwPlatformId
)
1840 case VER_PLATFORM_WIN32_WINDOWS
:
1841 return VK_PROCESSKEY
;
1842 case VER_PLATFORM_WIN32_NT
:
1845 FIXME("%d not supported\n",version
.dwPlatformId
);
1846 return VK_PROCESSKEY
;
1850 /***********************************************************************
1851 * ImmInstallIMEA (IMM32.@)
1853 HKL WINAPI
ImmInstallIMEA(
1854 LPCSTR lpszIMEFileName
, LPCSTR lpszLayoutText
)
1856 LPWSTR lpszwIMEFileName
;
1857 LPWSTR lpszwLayoutText
;
1860 TRACE ("(%s, %s)\n", debugstr_a(lpszIMEFileName
),
1861 debugstr_a(lpszLayoutText
));
1863 lpszwIMEFileName
= strdupAtoW(lpszIMEFileName
);
1864 lpszwLayoutText
= strdupAtoW(lpszLayoutText
);
1866 hkl
= ImmInstallIMEW(lpszwIMEFileName
, lpszwLayoutText
);
1868 HeapFree(GetProcessHeap(),0,lpszwIMEFileName
);
1869 HeapFree(GetProcessHeap(),0,lpszwLayoutText
);
1873 /***********************************************************************
1874 * ImmInstallIMEW (IMM32.@)
1876 HKL WINAPI
ImmInstallIMEW(
1877 LPCWSTR lpszIMEFileName
, LPCWSTR lpszLayoutText
)
1879 INT lcid
= GetUserDefaultLCID();
1884 WCHAR regKey
[sizeof(szImeRegFmt
)/sizeof(WCHAR
)+8];
1886 TRACE ("(%s, %s):\n", debugstr_w(lpszIMEFileName
),
1887 debugstr_w(lpszLayoutText
));
1889 /* Start with 2. e001 will be blank and so default to the wine internal IME */
1892 while (count
< 0xfff)
1894 DWORD disposition
= 0;
1896 hkl
= (HKL
)MAKELPARAM( lcid
, 0xe000 | count
);
1897 wsprintfW( regKey
, szImeRegFmt
, (ULONG_PTR
)hkl
);
1899 rc
= RegCreateKeyExW(HKEY_LOCAL_MACHINE
, regKey
, 0, NULL
, 0, KEY_WRITE
, NULL
, &hkey
, &disposition
);
1900 if (rc
== ERROR_SUCCESS
&& disposition
== REG_CREATED_NEW_KEY
)
1902 else if (rc
== ERROR_SUCCESS
)
1910 WARN("Unable to find slot to install IME\n");
1914 if (rc
== ERROR_SUCCESS
)
1916 rc
= RegSetValueExW(hkey
, szImeFileW
, 0, REG_SZ
, (const BYTE
*)lpszIMEFileName
,
1917 (lstrlenW(lpszIMEFileName
) + 1) * sizeof(WCHAR
));
1918 if (rc
== ERROR_SUCCESS
)
1919 rc
= RegSetValueExW(hkey
, szLayoutTextW
, 0, REG_SZ
, (const BYTE
*)lpszLayoutText
,
1920 (lstrlenW(lpszLayoutText
) + 1) * sizeof(WCHAR
));
1926 WARN("Unable to set IME registry values\n");
1931 /***********************************************************************
1932 * ImmIsIME (IMM32.@)
1934 BOOL WINAPI
ImmIsIME(HKL hKL
)
1937 TRACE("(%p):\n", hKL
);
1938 ptr
= IMM_GetImmHkl(hKL
);
1939 return (ptr
&& ptr
->hIME
);
1942 /***********************************************************************
1943 * ImmIsUIMessageA (IMM32.@)
1945 BOOL WINAPI
ImmIsUIMessageA(
1946 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1950 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
1951 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
1952 (msg
== WM_IME_SETCONTEXT
) ||
1953 (msg
== WM_IME_NOTIFY
) ||
1954 (msg
== WM_IME_COMPOSITIONFULL
) ||
1955 (msg
== WM_IME_SELECT
) ||
1956 (msg
== 0x287 /* FIXME: WM_IME_SYSTEM */) ||
1957 (msg
== WM_MSIME_RECONVERTOPTIONS
) ||
1958 (msg
== WM_MSIME_MOUSE
) ||
1959 (msg
== WM_MSIME_RECONVERTREQUEST
) ||
1960 (msg
== WM_MSIME_RECONVERT
) ||
1961 (msg
== WM_MSIME_QUERYPOSITION
) ||
1962 (msg
== WM_MSIME_DOCUMENTFEED
))
1965 SendMessageA(hWndIME
, msg
, wParam
, lParam
);
1972 /***********************************************************************
1973 * ImmIsUIMessageW (IMM32.@)
1975 BOOL WINAPI
ImmIsUIMessageW(
1976 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1980 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
1981 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
1982 (msg
== WM_IME_SETCONTEXT
) ||
1983 (msg
== WM_IME_NOTIFY
) ||
1984 (msg
== WM_IME_COMPOSITIONFULL
) ||
1985 (msg
== WM_IME_SELECT
) ||
1986 (msg
== 0x287 /* FIXME: WM_IME_SYSTEM */) ||
1987 (msg
== WM_MSIME_RECONVERTOPTIONS
) ||
1988 (msg
== WM_MSIME_MOUSE
) ||
1989 (msg
== WM_MSIME_RECONVERTREQUEST
) ||
1990 (msg
== WM_MSIME_RECONVERT
) ||
1991 (msg
== WM_MSIME_QUERYPOSITION
) ||
1992 (msg
== WM_MSIME_DOCUMENTFEED
))
1995 SendMessageW(hWndIME
, msg
, wParam
, lParam
);
2002 /***********************************************************************
2003 * ImmNotifyIME (IMM32.@)
2005 BOOL WINAPI
ImmNotifyIME(
2006 HIMC hIMC
, DWORD dwAction
, DWORD dwIndex
, DWORD dwValue
)
2008 InputContextData
*data
= get_imc_data(hIMC
);
2010 TRACE("(%p, %d, %d, %d)\n",
2011 hIMC
, dwAction
, dwIndex
, dwValue
);
2015 SetLastError(ERROR_SUCCESS
);
2019 if (!data
|| ! data
->immKbd
->pNotifyIME
)
2024 return data
->immKbd
->pNotifyIME(hIMC
,dwAction
,dwIndex
,dwValue
);
2027 /***********************************************************************
2028 * ImmRegisterWordA (IMM32.@)
2030 BOOL WINAPI
ImmRegisterWordA(
2031 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszRegister
)
2033 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2034 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
2035 debugstr_a(lpszRegister
));
2036 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
2038 if (!is_kbd_ime_unicode(immHkl
))
2039 return immHkl
->pImeRegisterWord((LPCWSTR
)lpszReading
,dwStyle
,
2040 (LPCWSTR
)lpszRegister
);
2043 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
2044 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
2047 rc
= immHkl
->pImeRegisterWord(lpszwReading
,dwStyle
,lpszwRegister
);
2048 HeapFree(GetProcessHeap(),0,lpszwReading
);
2049 HeapFree(GetProcessHeap(),0,lpszwRegister
);
2057 /***********************************************************************
2058 * ImmRegisterWordW (IMM32.@)
2060 BOOL WINAPI
ImmRegisterWordW(
2061 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszRegister
)
2063 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2064 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
2065 debugstr_w(lpszRegister
));
2066 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
2068 if (is_kbd_ime_unicode(immHkl
))
2069 return immHkl
->pImeRegisterWord(lpszReading
,dwStyle
,lpszRegister
);
2072 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2073 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
2076 rc
= immHkl
->pImeRegisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2077 (LPCWSTR
)lpszaRegister
);
2078 HeapFree(GetProcessHeap(),0,lpszaReading
);
2079 HeapFree(GetProcessHeap(),0,lpszaRegister
);
2087 /***********************************************************************
2088 * ImmReleaseContext (IMM32.@)
2090 BOOL WINAPI
ImmReleaseContext(HWND hWnd
, HIMC hIMC
)
2092 static BOOL shown
= FALSE
;
2095 FIXME("(%p, %p): stub\n", hWnd
, hIMC
);
2101 /***********************************************************************
2102 * ImmRequestMessageA(IMM32.@)
2104 LRESULT WINAPI
ImmRequestMessageA(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
2106 InputContextData
*data
= get_imc_data(hIMC
);
2108 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
2110 SetLastError(ERROR_INVALID_HANDLE
);
2112 if (data
&& IsWindow(data
->IMC
.hWnd
))
2113 return SendMessageA(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
2118 /***********************************************************************
2119 * ImmRequestMessageW(IMM32.@)
2121 LRESULT WINAPI
ImmRequestMessageW(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
2123 InputContextData
*data
= get_imc_data(hIMC
);
2125 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
2128 SetLastError(ERROR_INVALID_HANDLE
);
2130 if (data
&& IsWindow(data
->IMC
.hWnd
))
2131 return SendMessageW(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
2136 /***********************************************************************
2137 * ImmSetCandidateWindow (IMM32.@)
2139 BOOL WINAPI
ImmSetCandidateWindow(
2140 HIMC hIMC
, LPCANDIDATEFORM lpCandidate
)
2142 InputContextData
*data
= get_imc_data(hIMC
);
2144 TRACE("(%p, %p)\n", hIMC
, lpCandidate
);
2146 if (!data
|| !lpCandidate
)
2149 TRACE("\t%x, %x, (%i,%i), (%i,%i - %i,%i)\n",
2150 lpCandidate
->dwIndex
, lpCandidate
->dwStyle
,
2151 lpCandidate
->ptCurrentPos
.x
, lpCandidate
->ptCurrentPos
.y
,
2152 lpCandidate
->rcArea
.top
, lpCandidate
->rcArea
.left
,
2153 lpCandidate
->rcArea
.bottom
, lpCandidate
->rcArea
.right
);
2155 if ( lpCandidate
->dwIndex
>= (sizeof(data
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
)) )
2158 data
->IMC
.cfCandForm
[lpCandidate
->dwIndex
] = *lpCandidate
;
2159 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCANDIDATEPOS
);
2160 ImmInternalSendIMENotify(data
, IMN_SETCANDIDATEPOS
, 1 << lpCandidate
->dwIndex
);
2165 /***********************************************************************
2166 * ImmSetCompositionFontA (IMM32.@)
2168 BOOL WINAPI
ImmSetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
2170 InputContextData
*data
= get_imc_data(hIMC
);
2171 TRACE("(%p, %p)\n", hIMC
, lplf
);
2175 SetLastError(ERROR_INVALID_HANDLE
);
2179 memcpy(&data
->IMC
.lfFont
.W
,lplf
,sizeof(LOGFONTA
));
2180 MultiByteToWideChar(CP_ACP
, 0, lplf
->lfFaceName
, -1, data
->IMC
.lfFont
.W
.lfFaceName
,
2182 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2183 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2188 /***********************************************************************
2189 * ImmSetCompositionFontW (IMM32.@)
2191 BOOL WINAPI
ImmSetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
2193 InputContextData
*data
= get_imc_data(hIMC
);
2194 TRACE("(%p, %p)\n", hIMC
, lplf
);
2198 SetLastError(ERROR_INVALID_HANDLE
);
2202 data
->IMC
.lfFont
.W
= *lplf
;
2203 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2204 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2209 /***********************************************************************
2210 * ImmSetCompositionStringA (IMM32.@)
2212 BOOL WINAPI
ImmSetCompositionStringA(
2213 HIMC hIMC
, DWORD dwIndex
,
2214 LPCVOID lpComp
, DWORD dwCompLen
,
2215 LPCVOID lpRead
, DWORD dwReadLen
)
2219 WCHAR
*CompBuffer
= NULL
;
2220 WCHAR
*ReadBuffer
= NULL
;
2222 InputContextData
*data
= get_imc_data(hIMC
);
2224 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2225 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2230 if (!(dwIndex
== SCS_SETSTR
||
2231 dwIndex
== SCS_CHANGEATTR
||
2232 dwIndex
== SCS_CHANGECLAUSE
||
2233 dwIndex
== SCS_SETRECONVERTSTRING
||
2234 dwIndex
== SCS_QUERYRECONVERTSTRING
))
2237 if (!is_himc_ime_unicode(data
))
2238 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2239 dwCompLen
, lpRead
, dwReadLen
);
2241 comp_len
= MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0);
2244 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
* sizeof(WCHAR
));
2245 MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
);
2248 read_len
= MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0);
2251 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
* sizeof(WCHAR
));
2252 MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
);
2255 rc
= ImmSetCompositionStringW(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2256 ReadBuffer
, read_len
);
2258 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2259 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2264 /***********************************************************************
2265 * ImmSetCompositionStringW (IMM32.@)
2267 BOOL WINAPI
ImmSetCompositionStringW(
2268 HIMC hIMC
, DWORD dwIndex
,
2269 LPCVOID lpComp
, DWORD dwCompLen
,
2270 LPCVOID lpRead
, DWORD dwReadLen
)
2274 CHAR
*CompBuffer
= NULL
;
2275 CHAR
*ReadBuffer
= NULL
;
2277 InputContextData
*data
= get_imc_data(hIMC
);
2279 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2280 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2285 if (!(dwIndex
== SCS_SETSTR
||
2286 dwIndex
== SCS_CHANGEATTR
||
2287 dwIndex
== SCS_CHANGECLAUSE
||
2288 dwIndex
== SCS_SETRECONVERTSTRING
||
2289 dwIndex
== SCS_QUERYRECONVERTSTRING
))
2292 if (is_himc_ime_unicode(data
))
2293 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2294 dwCompLen
, lpRead
, dwReadLen
);
2296 comp_len
= WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0, NULL
,
2300 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
);
2301 WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
,
2305 read_len
= WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0, NULL
,
2309 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
);
2310 WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
,
2314 rc
= ImmSetCompositionStringA(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2315 ReadBuffer
, read_len
);
2317 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2318 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2323 /***********************************************************************
2324 * ImmSetCompositionWindow (IMM32.@)
2326 BOOL WINAPI
ImmSetCompositionWindow(
2327 HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
2329 BOOL reshow
= FALSE
;
2330 InputContextData
*data
= get_imc_data(hIMC
);
2332 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
2333 TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm
->dwStyle
,
2334 lpCompForm
->ptCurrentPos
.x
, lpCompForm
->ptCurrentPos
.y
, lpCompForm
->rcArea
.top
,
2335 lpCompForm
->rcArea
.left
, lpCompForm
->rcArea
.bottom
, lpCompForm
->rcArea
.right
);
2339 SetLastError(ERROR_INVALID_HANDLE
);
2343 data
->IMC
.cfCompForm
= *lpCompForm
;
2345 if (IsWindowVisible(data
->immKbd
->UIWnd
))
2348 ShowWindow(data
->immKbd
->UIWnd
,SW_HIDE
);
2351 /* FIXME: this is a partial stub */
2354 ShowWindow(data
->immKbd
->UIWnd
,SW_SHOWNOACTIVATE
);
2356 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONWINDOW
, 0);
2360 /***********************************************************************
2361 * ImmSetConversionStatus (IMM32.@)
2363 BOOL WINAPI
ImmSetConversionStatus(
2364 HIMC hIMC
, DWORD fdwConversion
, DWORD fdwSentence
)
2366 DWORD oldConversion
, oldSentence
;
2367 InputContextData
*data
= get_imc_data(hIMC
);
2369 TRACE("%p %d %d\n", hIMC
, fdwConversion
, fdwSentence
);
2373 SetLastError(ERROR_INVALID_HANDLE
);
2377 if ( fdwConversion
!= data
->IMC
.fdwConversion
)
2379 oldConversion
= data
->IMC
.fdwConversion
;
2380 data
->IMC
.fdwConversion
= fdwConversion
;
2381 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldConversion
, IMC_SETCONVERSIONMODE
);
2382 ImmInternalSendIMENotify(data
, IMN_SETCONVERSIONMODE
, 0);
2384 if ( fdwSentence
!= data
->IMC
.fdwSentence
)
2386 oldSentence
= data
->IMC
.fdwSentence
;
2387 data
->IMC
.fdwSentence
= fdwSentence
;
2388 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldSentence
, IMC_SETSENTENCEMODE
);
2389 ImmInternalSendIMENotify(data
, IMN_SETSENTENCEMODE
, 0);
2395 /***********************************************************************
2396 * ImmSetOpenStatus (IMM32.@)
2398 BOOL WINAPI
ImmSetOpenStatus(HIMC hIMC
, BOOL fOpen
)
2400 InputContextData
*data
= get_imc_data(hIMC
);
2402 TRACE("%p %d\n", hIMC
, fOpen
);
2406 SetLastError(ERROR_INVALID_HANDLE
);
2410 if (data
->immKbd
->UIWnd
== NULL
)
2412 /* create the ime window */
2413 data
->immKbd
->UIWnd
= CreateWindowExW( WS_EX_TOOLWINDOW
,
2414 data
->immKbd
->imeClassName
, NULL
, WS_POPUP
, 0, 0, 1, 1, 0,
2415 0, data
->immKbd
->hIME
, 0);
2416 SetWindowLongPtrW(data
->immKbd
->UIWnd
, IMMGWL_IMC
, (LONG_PTR
)data
);
2419 SetWindowLongPtrW(data
->immKbd
->UIWnd
, IMMGWL_IMC
, (LONG_PTR
)data
);
2421 if (!fOpen
!= !data
->IMC
.fOpen
)
2423 data
->IMC
.fOpen
= fOpen
;
2424 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETOPENSTATUS
);
2425 ImmInternalSendIMENotify(data
, IMN_SETOPENSTATUS
, 0);
2431 /***********************************************************************
2432 * ImmSetStatusWindowPos (IMM32.@)
2434 BOOL WINAPI
ImmSetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
2436 InputContextData
*data
= get_imc_data(hIMC
);
2438 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
2440 if (!data
|| !lpptPos
)
2442 SetLastError(ERROR_INVALID_HANDLE
);
2446 TRACE("\t(%i,%i)\n", lpptPos
->x
, lpptPos
->y
);
2448 data
->IMC
.ptStatusWndPos
= *lpptPos
;
2449 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETSTATUSWINDOWPOS
);
2450 ImmInternalSendIMENotify(data
, IMN_SETSTATUSWINDOWPOS
, 0);
2455 /***********************************************************************
2456 * ImmCreateSoftKeyboard(IMM32.@)
2458 HWND WINAPI
ImmCreateSoftKeyboard(UINT uType
, UINT hOwner
, int x
, int y
)
2460 FIXME("(%d, %d, %d, %d): stub\n", uType
, hOwner
, x
, y
);
2461 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2465 /***********************************************************************
2466 * ImmDestroySoftKeyboard(IMM32.@)
2468 BOOL WINAPI
ImmDestroySoftKeyboard(HWND hSoftWnd
)
2470 FIXME("(%p): stub\n", hSoftWnd
);
2471 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2475 /***********************************************************************
2476 * ImmShowSoftKeyboard(IMM32.@)
2478 BOOL WINAPI
ImmShowSoftKeyboard(HWND hSoftWnd
, int nCmdShow
)
2480 FIXME("(%p, %d): stub\n", hSoftWnd
, nCmdShow
);
2481 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2485 /***********************************************************************
2486 * ImmSimulateHotKey (IMM32.@)
2488 BOOL WINAPI
ImmSimulateHotKey(HWND hWnd
, DWORD dwHotKeyID
)
2490 FIXME("(%p, %d): stub\n", hWnd
, dwHotKeyID
);
2491 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2495 /***********************************************************************
2496 * ImmUnregisterWordA (IMM32.@)
2498 BOOL WINAPI
ImmUnregisterWordA(
2499 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszUnregister
)
2501 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2502 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
2503 debugstr_a(lpszUnregister
));
2504 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2506 if (!is_kbd_ime_unicode(immHkl
))
2507 return immHkl
->pImeUnregisterWord((LPCWSTR
)lpszReading
,dwStyle
,
2508 (LPCWSTR
)lpszUnregister
);
2511 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
2512 LPWSTR lpszwUnregister
= strdupAtoW(lpszUnregister
);
2515 rc
= immHkl
->pImeUnregisterWord(lpszwReading
,dwStyle
,lpszwUnregister
);
2516 HeapFree(GetProcessHeap(),0,lpszwReading
);
2517 HeapFree(GetProcessHeap(),0,lpszwUnregister
);
2525 /***********************************************************************
2526 * ImmUnregisterWordW (IMM32.@)
2528 BOOL WINAPI
ImmUnregisterWordW(
2529 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszUnregister
)
2531 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2532 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
2533 debugstr_w(lpszUnregister
));
2534 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2536 if (is_kbd_ime_unicode(immHkl
))
2537 return immHkl
->pImeUnregisterWord(lpszReading
,dwStyle
,lpszUnregister
);
2540 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2541 LPSTR lpszaUnregister
= strdupWtoA(lpszUnregister
);
2544 rc
= immHkl
->pImeUnregisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2545 (LPCWSTR
)lpszaUnregister
);
2546 HeapFree(GetProcessHeap(),0,lpszaReading
);
2547 HeapFree(GetProcessHeap(),0,lpszaUnregister
);
2555 /***********************************************************************
2556 * ImmGetImeMenuItemsA (IMM32.@)
2558 DWORD WINAPI
ImmGetImeMenuItemsA( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2559 LPIMEMENUITEMINFOA lpImeParentMenu
, LPIMEMENUITEMINFOA lpImeMenu
,
2562 InputContextData
*data
= get_imc_data(hIMC
);
2563 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2564 lpImeParentMenu
, lpImeMenu
, dwSize
);
2568 SetLastError(ERROR_INVALID_HANDLE
);
2572 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2574 if (!is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2575 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2576 (IMEMENUITEMINFOW
*)lpImeParentMenu
,
2577 (IMEMENUITEMINFOW
*)lpImeMenu
, dwSize
);
2580 IMEMENUITEMINFOW lpImeParentMenuW
;
2581 IMEMENUITEMINFOW
*lpImeMenuW
, *parent
= NULL
;
2584 if (lpImeParentMenu
)
2585 parent
= &lpImeParentMenuW
;
2588 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOA
);
2589 dwSize
= count
* sizeof(IMEMENUITEMINFOW
);
2590 lpImeMenuW
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2595 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2596 parent
, lpImeMenuW
, dwSize
);
2598 if (lpImeParentMenu
)
2600 memcpy(lpImeParentMenu
,&lpImeParentMenuW
,sizeof(IMEMENUITEMINFOA
));
2601 lpImeParentMenu
->hbmpItem
= lpImeParentMenuW
.hbmpItem
;
2602 WideCharToMultiByte(CP_ACP
, 0, lpImeParentMenuW
.szString
,
2603 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
,
2606 if (lpImeMenu
&& rc
)
2609 for (i
= 0; i
< rc
; i
++)
2611 memcpy(&lpImeMenu
[i
],&lpImeMenuW
[1],sizeof(IMEMENUITEMINFOA
));
2612 lpImeMenu
[i
].hbmpItem
= lpImeMenuW
[i
].hbmpItem
;
2613 WideCharToMultiByte(CP_ACP
, 0, lpImeMenuW
[i
].szString
,
2614 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
,
2618 HeapFree(GetProcessHeap(),0,lpImeMenuW
);
2626 /***********************************************************************
2627 * ImmGetImeMenuItemsW (IMM32.@)
2629 DWORD WINAPI
ImmGetImeMenuItemsW( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2630 LPIMEMENUITEMINFOW lpImeParentMenu
, LPIMEMENUITEMINFOW lpImeMenu
,
2633 InputContextData
*data
= get_imc_data(hIMC
);
2634 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2635 lpImeParentMenu
, lpImeMenu
, dwSize
);
2639 SetLastError(ERROR_INVALID_HANDLE
);
2643 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2645 if (is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2646 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2647 lpImeParentMenu
, lpImeMenu
, dwSize
);
2650 IMEMENUITEMINFOA lpImeParentMenuA
;
2651 IMEMENUITEMINFOA
*lpImeMenuA
, *parent
= NULL
;
2654 if (lpImeParentMenu
)
2655 parent
= &lpImeParentMenuA
;
2658 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOW
);
2659 dwSize
= count
* sizeof(IMEMENUITEMINFOA
);
2660 lpImeMenuA
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2665 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2666 (IMEMENUITEMINFOW
*)parent
,
2667 (IMEMENUITEMINFOW
*)lpImeMenuA
, dwSize
);
2669 if (lpImeParentMenu
)
2671 memcpy(lpImeParentMenu
,&lpImeParentMenuA
,sizeof(IMEMENUITEMINFOA
));
2672 lpImeParentMenu
->hbmpItem
= lpImeParentMenuA
.hbmpItem
;
2673 MultiByteToWideChar(CP_ACP
, 0, lpImeParentMenuA
.szString
,
2674 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
);
2676 if (lpImeMenu
&& rc
)
2679 for (i
= 0; i
< rc
; i
++)
2681 memcpy(&lpImeMenu
[i
],&lpImeMenuA
[1],sizeof(IMEMENUITEMINFOA
));
2682 lpImeMenu
[i
].hbmpItem
= lpImeMenuA
[i
].hbmpItem
;
2683 MultiByteToWideChar(CP_ACP
, 0, lpImeMenuA
[i
].szString
,
2684 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
);
2687 HeapFree(GetProcessHeap(),0,lpImeMenuA
);
2695 /***********************************************************************
2696 * ImmLockIMC(IMM32.@)
2698 LPINPUTCONTEXT WINAPI
ImmLockIMC(HIMC hIMC
)
2700 InputContextData
*data
= get_imc_data(hIMC
);
2708 /***********************************************************************
2709 * ImmUnlockIMC(IMM32.@)
2711 BOOL WINAPI
ImmUnlockIMC(HIMC hIMC
)
2713 InputContextData
*data
= get_imc_data(hIMC
);
2722 /***********************************************************************
2723 * ImmGetIMCLockCount(IMM32.@)
2725 DWORD WINAPI
ImmGetIMCLockCount(HIMC hIMC
)
2727 InputContextData
*data
= get_imc_data(hIMC
);
2730 return data
->dwLock
;
2733 /***********************************************************************
2734 * ImmCreateIMCC(IMM32.@)
2736 HIMCC WINAPI
ImmCreateIMCC(DWORD size
)
2738 return GlobalAlloc(GMEM_ZEROINIT
| GMEM_MOVEABLE
, size
);
2741 /***********************************************************************
2742 * ImmDestroyIMCC(IMM32.@)
2744 HIMCC WINAPI
ImmDestroyIMCC(HIMCC block
)
2746 return GlobalFree(block
);
2749 /***********************************************************************
2750 * ImmLockIMCC(IMM32.@)
2752 LPVOID WINAPI
ImmLockIMCC(HIMCC imcc
)
2754 return GlobalLock(imcc
);
2757 /***********************************************************************
2758 * ImmUnlockIMCC(IMM32.@)
2760 BOOL WINAPI
ImmUnlockIMCC(HIMCC imcc
)
2762 return GlobalUnlock(imcc
);
2765 /***********************************************************************
2766 * ImmGetIMCCLockCount(IMM32.@)
2768 DWORD WINAPI
ImmGetIMCCLockCount(HIMCC imcc
)
2770 return GlobalFlags(imcc
) & GMEM_LOCKCOUNT
;
2773 /***********************************************************************
2774 * ImmReSizeIMCC(IMM32.@)
2776 HIMCC WINAPI
ImmReSizeIMCC(HIMCC imcc
, DWORD size
)
2778 return GlobalReAlloc(imcc
, size
, GMEM_ZEROINIT
| GMEM_MOVEABLE
);
2781 /***********************************************************************
2782 * ImmGetIMCCSize(IMM32.@)
2784 DWORD WINAPI
ImmGetIMCCSize(HIMCC imcc
)
2786 return GlobalSize(imcc
);
2789 /***********************************************************************
2790 * ImmGenerateMessage(IMM32.@)
2792 BOOL WINAPI
ImmGenerateMessage(HIMC hIMC
)
2794 InputContextData
*data
= get_imc_data(hIMC
);
2798 SetLastError(ERROR_INVALID_HANDLE
);
2802 TRACE("%i messages queued\n",data
->IMC
.dwNumMsgBuf
);
2803 if (data
->IMC
.dwNumMsgBuf
> 0)
2805 LPTRANSMSG lpTransMsg
;
2808 lpTransMsg
= ImmLockIMCC(data
->IMC
.hMsgBuf
);
2809 for (i
= 0; i
< data
->IMC
.dwNumMsgBuf
; i
++)
2810 ImmInternalPostIMEMessage(data
, lpTransMsg
[i
].message
, lpTransMsg
[i
].wParam
, lpTransMsg
[i
].lParam
);
2812 ImmUnlockIMCC(data
->IMC
.hMsgBuf
);
2814 data
->IMC
.dwNumMsgBuf
= 0;
2820 /***********************************************************************
2821 * ImmTranslateMessage(IMM32.@)
2822 * ( Undocumented, call internally and from user32.dll )
2824 BOOL WINAPI
ImmTranslateMessage(HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lKeyData
)
2826 InputContextData
*data
;
2827 HIMC imc
= ImmGetContext(hwnd
);
2833 static const DWORD list_count
= 10;
2835 TRACE("%p %x %x %x\n",hwnd
, msg
, (UINT
)wParam
, (UINT
)lKeyData
);
2842 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeToAsciiEx
)
2845 GetKeyboardState(state
);
2846 scancode
= lKeyData
>> 0x10 & 0xff;
2848 list
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, list_count
* sizeof(TRANSMSG
) + sizeof(DWORD
));
2849 ((DWORD
*)list
)[0] = list_count
;
2851 if (data
->immKbd
->imeInfo
.fdwProperty
& IME_PROP_KBD_CHAR_FIRST
)
2855 if (!is_himc_ime_unicode(data
))
2856 ToAscii(data
->lastVK
, scancode
, state
, &chr
, 0);
2858 ToUnicodeEx(data
->lastVK
, scancode
, state
, &chr
, 1, 0, GetKeyboardLayout(0));
2859 uVirtKey
= MAKELONG(data
->lastVK
,chr
);
2862 uVirtKey
= data
->lastVK
;
2864 msg_count
= data
->immKbd
->pImeToAsciiEx(uVirtKey
, scancode
, state
, list
, 0, imc
);
2865 TRACE("%i messages generated\n",msg_count
);
2866 if (msg_count
&& msg_count
<= list_count
)
2869 LPTRANSMSG msgs
= (LPTRANSMSG
)((LPBYTE
)list
+ sizeof(DWORD
));
2871 for (i
= 0; i
< msg_count
; i
++)
2872 ImmInternalPostIMEMessage(data
, msgs
[i
].message
, msgs
[i
].wParam
, msgs
[i
].lParam
);
2874 else if (msg_count
> list_count
)
2875 ImmGenerateMessage(imc
);
2877 HeapFree(GetProcessHeap(),0,list
);
2879 data
->lastVK
= VK_PROCESSKEY
;
2881 return (msg_count
> 0);
2884 /***********************************************************************
2885 * ImmProcessKey(IMM32.@)
2886 * ( Undocumented, called from user32.dll )
2888 BOOL WINAPI
ImmProcessKey(HWND hwnd
, HKL hKL
, UINT vKey
, LPARAM lKeyData
, DWORD unknown
)
2890 InputContextData
*data
;
2891 HIMC imc
= ImmGetContext(hwnd
);
2894 TRACE("%p %p %x %x %x\n",hwnd
, hKL
, vKey
, (UINT
)lKeyData
, unknown
);
2901 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeProcessKey
)
2904 GetKeyboardState(state
);
2905 if (data
->immKbd
->pImeProcessKey(imc
, vKey
, lKeyData
, state
))
2907 data
->lastVK
= vKey
;
2911 data
->lastVK
= VK_PROCESSKEY
;
2915 /***********************************************************************
2916 * ImmDisableTextFrameService(IMM32.@)
2918 BOOL WINAPI
ImmDisableTextFrameService(DWORD idThread
)
2924 /***********************************************************************
2925 * ImmEnumInputContext(IMM32.@)
2928 BOOL WINAPI
ImmEnumInputContext(DWORD idThread
, IMCENUMPROC lpfn
, LPARAM lParam
)
2934 /***********************************************************************
2935 * ImmGetHotKey(IMM32.@)
2938 BOOL WINAPI
ImmGetHotKey(DWORD hotkey
, UINT
*modifiers
, UINT
*key
, HKL hkl
)
2940 FIXME("%x, %p, %p, %p: stub\n", hotkey
, modifiers
, key
, hkl
);
2946 * Window Proc for the Default IME window class
2948 static LRESULT WINAPI
DefIME_WindowProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
,
2956 case WM_IME_STARTCOMPOSITION
:
2957 case WM_IME_ENDCOMPOSITION
:
2958 case WM_IME_COMPOSITION
:
2959 case WM_IME_SETCONTEXT
:
2961 case WM_IME_CONTROL
:
2962 case WM_IME_COMPOSITIONFULL
:
2965 case WM_IME_REQUEST
:
2966 case WM_IME_KEYDOWN
:
2969 ImmHkl
*immHkl
= IMM_GetImmHkl(GetKeyboardLayout(0));
2971 return SendMessageW(immHkl
->UIWnd
,uMsg
,wParam
,lParam
);
2976 if ((uMsg
== WM_MSIME_RECONVERTOPTIONS
) ||
2977 (uMsg
== WM_MSIME_SERVICE
) ||
2978 (uMsg
== WM_MSIME_MOUSE
) ||
2979 (uMsg
== WM_MSIME_RECONVERTREQUEST
) ||
2980 (uMsg
== WM_MSIME_RECONVERT
) ||
2981 (uMsg
== WM_MSIME_QUERYPOSITION
) ||
2982 (uMsg
== WM_MSIME_DOCUMENTFEED
))
2984 ImmHkl
*immHkl
= IMM_GetImmHkl(GetKeyboardLayout(0));
2986 return SendMessageW(immHkl
->UIWnd
,uMsg
,wParam
,lParam
);
2990 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);