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/gdi_driver.h"
36 #include "wine/list.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(imm
);
40 typedef struct tagIMCCInternal
46 #define MAKE_FUNCPTR(f) typeof(f) * p##f
47 typedef struct _tagImmHkl
{
52 WCHAR imeClassName
[17]; /* 16 character max */
56 /* Function Pointers */
57 MAKE_FUNCPTR(ImeInquire
);
58 MAKE_FUNCPTR(ImeConfigure
);
59 MAKE_FUNCPTR(ImeDestroy
);
60 MAKE_FUNCPTR(ImeEscape
);
61 MAKE_FUNCPTR(ImeSelect
);
62 MAKE_FUNCPTR(ImeSetActiveContext
);
63 MAKE_FUNCPTR(ImeToAsciiEx
);
64 MAKE_FUNCPTR(NotifyIME
);
65 MAKE_FUNCPTR(ImeRegisterWord
);
66 MAKE_FUNCPTR(ImeUnregisterWord
);
67 MAKE_FUNCPTR(ImeEnumRegisterWord
);
68 MAKE_FUNCPTR(ImeSetCompositionString
);
69 MAKE_FUNCPTR(ImeConversionList
);
70 MAKE_FUNCPTR(ImeProcessKey
);
71 MAKE_FUNCPTR(ImeGetRegisterWordStyle
);
72 MAKE_FUNCPTR(ImeGetImeMenuItems
);
76 typedef struct tagInputContextData
85 typedef struct _tagTRANSMSG
{
89 } TRANSMSG
, *LPTRANSMSG
;
91 typedef struct _tagIMMThreadData
{
96 static DWORD tlsIndex
= 0;
97 static struct list ImmHklList
= LIST_INIT(ImmHklList
);
100 static UINT WM_MSIME_SERVICE
;
101 static UINT WM_MSIME_RECONVERTOPTIONS
;
102 static UINT WM_MSIME_MOUSE
;
103 static UINT WM_MSIME_RECONVERTREQUEST
;
104 static UINT WM_MSIME_RECONVERT
;
105 static UINT WM_MSIME_QUERYPOSITION
;
106 static UINT WM_MSIME_DOCUMENTFEED
;
108 static const WCHAR szwWineIMCProperty
[] = {'W','i','n','e','I','m','m','H','I','M','C','P','r','o','p','e','r','t','y',0};
110 static const WCHAR szImeFileW
[] = {'I','m','e',' ','F','i','l','e',0};
111 static const WCHAR szLayoutTextW
[] = {'L','a','y','o','u','t',' ','T','e','x','t',0};
112 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};
114 static const WCHAR szwIME
[] = {'I','M','E',0};
116 static LRESULT WINAPI
DefIME_WindowProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
,
119 #define is_himc_ime_unicode(p) (p->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE)
120 #define is_kbd_ime_unicode(p) (p->imeInfo.fdwProperty & IME_PROP_UNICODE)
122 static BOOL
IMM_DestroyContext(HIMC hIMC
);
124 static inline WCHAR
*strdupAtoW( const char *str
)
129 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
130 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
131 MultiByteToWideChar( CP_ACP
, 0, str
, -1, ret
, len
);
136 static inline CHAR
*strdupWtoA( const WCHAR
*str
)
141 DWORD len
= WideCharToMultiByte( CP_ACP
, 0, str
, -1, NULL
, 0, NULL
, NULL
);
142 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
)))
143 WideCharToMultiByte( CP_ACP
, 0, str
, -1, ret
, len
, NULL
, NULL
);
148 static DWORD
convert_candidatelist_WtoA(
149 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
153 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
154 if ( lpDst
&& dwBufLen
> 0 )
157 lpDst
->dwOffset
[0] = ret
;
160 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
162 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
164 if ( lpDst
&& dwBufLen
> 0 )
166 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
168 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1,
169 (LPSTR
)dest
, dwBufLen
, NULL
, NULL
);
171 if ( i
+ 1 < lpSrc
->dwCount
)
172 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(char);
173 dwBufLen
-= len
* sizeof(char);
176 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1, NULL
, 0, NULL
, NULL
);
178 ret
+= len
* sizeof(char);
187 static DWORD
convert_candidatelist_AtoW(
188 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
192 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
193 if ( lpDst
&& dwBufLen
> 0 )
196 lpDst
->dwOffset
[0] = ret
;
199 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
201 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
203 if ( lpDst
&& dwBufLen
> 0 )
205 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
207 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1,
208 (LPWSTR
)dest
, dwBufLen
);
210 if ( i
+ 1 < lpSrc
->dwCount
)
211 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(WCHAR
);
212 dwBufLen
-= len
* sizeof(WCHAR
);
215 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1, NULL
, 0);
217 ret
+= len
* sizeof(WCHAR
);
226 static IMMThreadData
* IMM_GetThreadData(void)
228 IMMThreadData
* data
= TlsGetValue(tlsIndex
);
231 data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
232 sizeof(IMMThreadData
));
233 TlsSetValue(tlsIndex
,data
);
234 TRACE("Thread Data Created\n");
239 static void IMM_FreeThreadData(void)
241 IMMThreadData
* data
= TlsGetValue(tlsIndex
);
244 IMM_DestroyContext(data
->defaultContext
);
245 DestroyWindow(data
->hwndDefault
);
246 HeapFree(GetProcessHeap(),0,data
);
247 TRACE("Thread Data Destroyed\n");
251 /* ImmHkl loading and freeing */
252 #define LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}
253 static ImmHkl
*IMM_GetImmHkl(HKL hkl
)
256 WCHAR filename
[MAX_PATH
];
258 TRACE("Seeking ime for keyboard %p\n",hkl
);
260 LIST_FOR_EACH_ENTRY(ptr
, &ImmHklList
, ImmHkl
, entry
)
265 /* not found... create it */
267 ptr
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ImmHkl
));
270 if (ImmGetIMEFileNameW(hkl
, filename
, MAX_PATH
)) ptr
->hIME
= LoadLibraryW(filename
);
273 HDC hdc
= GetDC( 0 );
274 GetModuleHandleExW( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
,
275 (LPCWSTR
)__wine_get_driver_module( hdc
), &ptr
->hIME
);
280 LOAD_FUNCPTR(ImeInquire
);
281 if (!ptr
->pImeInquire
|| !ptr
->pImeInquire(&ptr
->imeInfo
, ptr
->imeClassName
, NULL
))
283 FreeLibrary(ptr
->hIME
);
288 LOAD_FUNCPTR(ImeDestroy
);
289 LOAD_FUNCPTR(ImeSelect
);
290 if (!ptr
->pImeSelect
|| !ptr
->pImeDestroy
)
292 FreeLibrary(ptr
->hIME
);
297 LOAD_FUNCPTR(ImeConfigure
);
298 LOAD_FUNCPTR(ImeEscape
);
299 LOAD_FUNCPTR(ImeSetActiveContext
);
300 LOAD_FUNCPTR(ImeToAsciiEx
);
301 LOAD_FUNCPTR(NotifyIME
);
302 LOAD_FUNCPTR(ImeRegisterWord
);
303 LOAD_FUNCPTR(ImeUnregisterWord
);
304 LOAD_FUNCPTR(ImeEnumRegisterWord
);
305 LOAD_FUNCPTR(ImeSetCompositionString
);
306 LOAD_FUNCPTR(ImeConversionList
);
307 LOAD_FUNCPTR(ImeProcessKey
);
308 LOAD_FUNCPTR(ImeGetRegisterWordStyle
);
309 LOAD_FUNCPTR(ImeGetImeMenuItems
);
310 /* make sure our classname is WCHAR */
311 if (!is_kbd_ime_unicode(ptr
))
314 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ptr
->imeClassName
,
316 lstrcpyW(ptr
->imeClassName
, bufW
);
321 list_add_head(&ImmHklList
,&ptr
->entry
);
327 static void IMM_FreeAllImmHkl(void)
329 ImmHkl
*ptr
,*cursor2
;
331 LIST_FOR_EACH_ENTRY_SAFE(ptr
, cursor2
, &ImmHklList
, ImmHkl
, entry
)
333 list_remove(&ptr
->entry
);
337 FreeLibrary(ptr
->hIME
);
340 DestroyWindow(ptr
->UIWnd
);
341 HeapFree(GetProcessHeap(),0,ptr
);
345 static void IMM_RegisterMessages(void)
347 WM_MSIME_SERVICE
= RegisterWindowMessageA("MSIMEService");
348 WM_MSIME_RECONVERTOPTIONS
= RegisterWindowMessageA("MSIMEReconvertOptions");
349 WM_MSIME_MOUSE
= RegisterWindowMessageA("MSIMEMouseOperation");
350 WM_MSIME_RECONVERTREQUEST
= RegisterWindowMessageA("MSIMEReconvertRequest");
351 WM_MSIME_RECONVERT
= RegisterWindowMessageA("MSIMEReconvert");
352 WM_MSIME_QUERYPOSITION
= RegisterWindowMessageA("MSIMEQueryPosition");
353 WM_MSIME_DOCUMENTFEED
= RegisterWindowMessageA("MSIMEDocumentFeed");
356 static void IMM_RegisterIMEClass(void)
360 ZeroMemory(&wndClass
, sizeof(WNDCLASSW
));
362 wndClass
.style
= CS_GLOBALCLASS
;
363 wndClass
.lpfnWndProc
= (WNDPROC
) DefIME_WindowProc
;
364 wndClass
.cbWndExtra
= 2 * sizeof(LONG_PTR
);
365 wndClass
.hCursor
= LoadCursorW(NULL
, (LPWSTR
)IDC_ARROW
);
366 wndClass
.lpszClassName
= szwIME
;
368 RegisterClassW(&wndClass
);
371 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID lpReserved
)
373 TRACE("%p, %x, %p\n",hInstDLL
,fdwReason
,lpReserved
);
376 case DLL_PROCESS_ATTACH
:
377 IMM_RegisterMessages();
378 tlsIndex
= TlsAlloc();
379 if (tlsIndex
== TLS_OUT_OF_INDEXES
)
381 IMM_RegisterIMEClass();
383 case DLL_THREAD_ATTACH
:
385 case DLL_THREAD_DETACH
:
386 IMM_FreeThreadData();
388 case DLL_PROCESS_DETACH
:
389 if (lpReserved
) break;
390 IMM_FreeThreadData();
393 UnregisterClassW(szwIME
, NULL
);
399 /* for posting messages as the IME */
400 static void ImmInternalPostIMEMessage(InputContextData
*data
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
402 HWND target
= GetFocus();
404 PostMessageW(data
->IMC
.hWnd
,msg
,wParam
,lParam
);
406 PostMessageW(target
, msg
, wParam
, lParam
);
409 static LRESULT
ImmInternalSendIMENotify(InputContextData
*data
, WPARAM notify
, LPARAM lParam
)
413 target
= data
->IMC
.hWnd
;
414 if (!target
) target
= GetFocus();
417 return SendMessageW(target
, WM_IME_NOTIFY
, notify
, lParam
);
422 static HIMCC
ImmCreateBlankCompStr(void)
425 LPCOMPOSITIONSTRING ptr
;
426 rc
= ImmCreateIMCC(sizeof(COMPOSITIONSTRING
));
427 ptr
= ImmLockIMCC(rc
);
428 memset(ptr
,0,sizeof(COMPOSITIONSTRING
));
429 ptr
->dwSize
= sizeof(COMPOSITIONSTRING
);
434 /***********************************************************************
435 * ImmAssociateContext (IMM32.@)
437 HIMC WINAPI
ImmAssociateContext(HWND hWnd
, HIMC hIMC
)
440 InputContextData
*data
= hIMC
;
442 TRACE("(%p, %p):\n", hWnd
, hIMC
);
444 if (!IMM_GetThreadData()->defaultContext
)
445 IMM_GetThreadData()->defaultContext
= ImmCreateContext();
448 * If already associated just return
450 if (hIMC
&& data
->IMC
.hWnd
== hWnd
)
455 old
= RemovePropW(hWnd
,szwWineIMCProperty
);
458 old
= IMM_GetThreadData()->defaultContext
;
459 else if (old
== (HIMC
)-1)
462 if (hIMC
!= IMM_GetThreadData()->defaultContext
)
464 if (hIMC
== NULL
) /* Meaning disable imm for that window*/
465 SetPropW(hWnd
,szwWineIMCProperty
,(HANDLE
)-1);
467 SetPropW(hWnd
,szwWineIMCProperty
,hIMC
);
472 InputContextData
*old_data
= old
;
473 if (old_data
->IMC
.hWnd
== hWnd
)
474 old_data
->IMC
.hWnd
= NULL
;
481 if (IsWindow(data
->IMC
.hWnd
))
484 * Post a message that your context is switching
486 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, FALSE
, ISC_SHOWUIALL
);
489 data
->IMC
.hWnd
= hWnd
;
491 if (IsWindow(data
->IMC
.hWnd
))
494 * Post a message that your context is switching
496 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, TRUE
, ISC_SHOWUIALL
);
504 * Helper function for ImmAssociateContextEx
506 static BOOL CALLBACK
_ImmAssociateContextExEnumProc(HWND hwnd
, LPARAM lParam
)
508 HIMC hImc
= (HIMC
)lParam
;
509 ImmAssociateContext(hwnd
,hImc
);
513 /***********************************************************************
514 * ImmAssociateContextEx (IMM32.@)
516 BOOL WINAPI
ImmAssociateContextEx(HWND hWnd
, HIMC hIMC
, DWORD dwFlags
)
518 TRACE("(%p, %p, 0x%x):\n", hWnd
, hIMC
, dwFlags
);
520 if (!IMM_GetThreadData()->defaultContext
)
521 IMM_GetThreadData()->defaultContext
= ImmCreateContext();
523 if (!hWnd
) return FALSE
;
528 ImmAssociateContext(hWnd
,hIMC
);
531 ImmAssociateContext(hWnd
,IMM_GetThreadData()->defaultContext
);
533 case IACE_IGNORENOCONTEXT
:
534 if (GetPropW(hWnd
,szwWineIMCProperty
))
535 ImmAssociateContext(hWnd
,hIMC
);
538 EnumChildWindows(hWnd
,_ImmAssociateContextExEnumProc
,(LPARAM
)hIMC
);
541 FIXME("Unknown dwFlags 0x%x\n",dwFlags
);
546 /***********************************************************************
547 * ImmConfigureIMEA (IMM32.@)
549 BOOL WINAPI
ImmConfigureIMEA(
550 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
552 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
554 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
556 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
559 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
561 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| !is_kbd_ime_unicode(immHkl
))
562 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
566 REGISTERWORDA
*rwa
= lpData
;
569 rww
.lpReading
= strdupAtoW(rwa
->lpReading
);
570 rww
.lpWord
= strdupAtoW(rwa
->lpWord
);
571 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rww
);
572 HeapFree(GetProcessHeap(),0,rww
.lpReading
);
573 HeapFree(GetProcessHeap(),0,rww
.lpWord
);
581 /***********************************************************************
582 * ImmConfigureIMEW (IMM32.@)
584 BOOL WINAPI
ImmConfigureIMEW(
585 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
587 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
589 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
591 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
594 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
596 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| is_kbd_ime_unicode(immHkl
))
597 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
600 REGISTERWORDW
*rww
= lpData
;
604 rwa
.lpReading
= strdupWtoA(rww
->lpReading
);
605 rwa
.lpWord
= strdupWtoA(rww
->lpWord
);
606 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rwa
);
607 HeapFree(GetProcessHeap(),0,rwa
.lpReading
);
608 HeapFree(GetProcessHeap(),0,rwa
.lpWord
);
616 /***********************************************************************
617 * ImmCreateContext (IMM32.@)
619 HIMC WINAPI
ImmCreateContext(void)
621 InputContextData
*new_context
;
625 new_context
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(InputContextData
));
628 new_context
->immKbd
= IMM_GetImmHkl(GetKeyboardLayout(0));
630 if (!new_context
->immKbd
->hIME
)
632 TRACE("IME dll could not be loaded\n");
633 HeapFree(GetProcessHeap(),0,new_context
);
637 /* the HIMCCs are never NULL */
638 new_context
->IMC
.hCompStr
= ImmCreateBlankCompStr();
639 new_context
->IMC
.hMsgBuf
= ImmCreateIMCC(0);
640 new_context
->IMC
.hCandInfo
= ImmCreateIMCC(sizeof(CANDIDATEINFO
));
641 ci
= ImmLockIMCC(new_context
->IMC
.hCandInfo
);
642 memset(ci
,0,sizeof(CANDIDATEINFO
));
643 ci
->dwSize
= sizeof(CANDIDATEINFO
);
644 ImmUnlockIMCC(new_context
->IMC
.hCandInfo
);
645 new_context
->IMC
.hGuideLine
= ImmCreateIMCC(sizeof(GUIDELINE
));
646 gl
= ImmLockIMCC(new_context
->IMC
.hGuideLine
);
647 memset(gl
,0,sizeof(GUIDELINE
));
648 gl
->dwSize
= sizeof(GUIDELINE
);
649 ImmUnlockIMCC(new_context
->IMC
.hGuideLine
);
651 /* Initialize the IME Private */
652 new_context
->IMC
.hPrivate
= ImmCreateIMCC(new_context
->immKbd
->imeInfo
.dwPrivateDataSize
);
654 if (!new_context
->immKbd
->pImeSelect(new_context
, TRUE
))
656 TRACE("Selection of IME failed\n");
657 IMM_DestroyContext(new_context
);
660 SendMessageW(GetFocus(), WM_IME_SELECT
, TRUE
, (LPARAM
)GetKeyboardLayout(0));
662 new_context
->immKbd
->uSelected
++;
663 TRACE("Created context %p\n",new_context
);
668 static BOOL
IMM_DestroyContext(HIMC hIMC
)
670 InputContextData
*data
= hIMC
;
672 TRACE("Destroying %p\n",hIMC
);
676 data
->immKbd
->uSelected
--;
677 data
->immKbd
->pImeSelect(hIMC
, FALSE
);
678 SendMessageW(data
->IMC
.hWnd
, WM_IME_SELECT
, FALSE
, (LPARAM
)GetKeyboardLayout(0));
680 ImmDestroyIMCC(data
->IMC
.hCompStr
);
681 ImmDestroyIMCC(data
->IMC
.hCandInfo
);
682 ImmDestroyIMCC(data
->IMC
.hGuideLine
);
683 ImmDestroyIMCC(data
->IMC
.hPrivate
);
684 ImmDestroyIMCC(data
->IMC
.hMsgBuf
);
686 HeapFree(GetProcessHeap(),0,data
);
691 /***********************************************************************
692 * ImmDestroyContext (IMM32.@)
694 BOOL WINAPI
ImmDestroyContext(HIMC hIMC
)
696 if (hIMC
!= IMM_GetThreadData()->defaultContext
)
697 return IMM_DestroyContext(hIMC
);
702 /***********************************************************************
703 * ImmDisableIME (IMM32.@)
705 BOOL WINAPI
ImmDisableIME(DWORD idThread
)
707 FIXME("(%d): stub\n", idThread
);
711 /***********************************************************************
712 * ImmEnumRegisterWordA (IMM32.@)
714 UINT WINAPI
ImmEnumRegisterWordA(
715 HKL hKL
, REGISTERWORDENUMPROCA lpfnEnumProc
,
716 LPCSTR lpszReading
, DWORD dwStyle
,
717 LPCSTR lpszRegister
, LPVOID lpData
)
719 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
720 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
721 debugstr_a(lpszReading
), dwStyle
, debugstr_a(lpszRegister
), lpData
);
722 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
724 if (!is_kbd_ime_unicode(immHkl
))
725 return immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
726 (LPCWSTR
)lpszReading
, dwStyle
, (LPCWSTR
)lpszRegister
, lpData
);
729 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
730 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
733 rc
= immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
734 lpszwReading
, dwStyle
, lpszwRegister
,
737 HeapFree(GetProcessHeap(),0,lpszwReading
);
738 HeapFree(GetProcessHeap(),0,lpszwRegister
);
746 /***********************************************************************
747 * ImmEnumRegisterWordW (IMM32.@)
749 UINT WINAPI
ImmEnumRegisterWordW(
750 HKL hKL
, REGISTERWORDENUMPROCW lpfnEnumProc
,
751 LPCWSTR lpszReading
, DWORD dwStyle
,
752 LPCWSTR lpszRegister
, LPVOID lpData
)
754 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
755 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
756 debugstr_w(lpszReading
), dwStyle
, debugstr_w(lpszRegister
), lpData
);
757 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
759 if (is_kbd_ime_unicode(immHkl
))
760 return immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, lpszReading
, dwStyle
,
761 lpszRegister
, lpData
);
764 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
765 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
768 rc
= immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, (LPCWSTR
)lpszaReading
,
769 dwStyle
, (LPCWSTR
)lpszaRegister
, lpData
);
771 HeapFree(GetProcessHeap(),0,lpszaReading
);
772 HeapFree(GetProcessHeap(),0,lpszaRegister
);
780 static inline BOOL
EscapeRequiresWA(UINT uEscape
)
782 if (uEscape
== IME_ESC_GET_EUDC_DICTIONARY
||
783 uEscape
== IME_ESC_SET_EUDC_DICTIONARY
||
784 uEscape
== IME_ESC_IME_NAME
||
785 uEscape
== IME_ESC_GETHELPFILENAME
)
790 /***********************************************************************
791 * ImmEscapeA (IMM32.@)
793 LRESULT WINAPI
ImmEscapeA(
795 UINT uEscape
, LPVOID lpData
)
797 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
798 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
800 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
802 if (!EscapeRequiresWA(uEscape
) || !is_kbd_ime_unicode(immHkl
))
803 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
806 WCHAR buffer
[81]; /* largest required buffer should be 80 */
808 if (uEscape
== IME_ESC_SET_EUDC_DICTIONARY
)
810 MultiByteToWideChar(CP_ACP
,0,lpData
,-1,buffer
,81);
811 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
815 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
816 WideCharToMultiByte(CP_ACP
,0,buffer
,-1,lpData
,80, NULL
, NULL
);
825 /***********************************************************************
826 * ImmEscapeW (IMM32.@)
828 LRESULT WINAPI
ImmEscapeW(
830 UINT uEscape
, LPVOID lpData
)
832 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
833 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
835 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
837 if (!EscapeRequiresWA(uEscape
) || is_kbd_ime_unicode(immHkl
))
838 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
841 CHAR buffer
[81]; /* largest required buffer should be 80 */
843 if (uEscape
== IME_ESC_SET_EUDC_DICTIONARY
)
845 WideCharToMultiByte(CP_ACP
,0,lpData
,-1,buffer
,81, NULL
, NULL
);
846 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
850 rc
= immHkl
->pImeEscape(hIMC
,uEscape
,buffer
);
851 MultiByteToWideChar(CP_ACP
,0,buffer
,-1,lpData
,80);
860 /***********************************************************************
861 * ImmGetCandidateListA (IMM32.@)
863 DWORD WINAPI
ImmGetCandidateListA(
864 HIMC hIMC
, DWORD dwIndex
,
865 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
867 InputContextData
*data
= hIMC
;
868 LPCANDIDATEINFO candinfo
;
869 LPCANDIDATELIST candlist
;
872 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
874 if (!data
|| !data
->IMC
.hCandInfo
)
877 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
878 if ( dwIndex
>= candinfo
->dwCount
||
879 dwIndex
>= (sizeof(candinfo
->dwOffset
) / sizeof(DWORD
)) )
882 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
883 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
886 if ( !is_himc_ime_unicode(data
) )
888 ret
= candlist
->dwSize
;
889 if ( lpCandList
&& dwBufLen
>= ret
)
890 memcpy(lpCandList
, candlist
, ret
);
893 ret
= convert_candidatelist_WtoA( candlist
, lpCandList
, dwBufLen
);
896 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
900 /***********************************************************************
901 * ImmGetCandidateListCountA (IMM32.@)
903 DWORD WINAPI
ImmGetCandidateListCountA(
904 HIMC hIMC
, LPDWORD lpdwListCount
)
906 InputContextData
*data
= hIMC
;
907 LPCANDIDATEINFO candinfo
;
910 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
912 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
915 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
917 *lpdwListCount
= count
= candinfo
->dwCount
;
919 if ( !is_himc_ime_unicode(data
) )
920 ret
= candinfo
->dwSize
;
923 ret
= sizeof(CANDIDATEINFO
);
925 ret
+= ImmGetCandidateListA(hIMC
, count
, NULL
, 0);
928 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
932 /***********************************************************************
933 * ImmGetCandidateListCountW (IMM32.@)
935 DWORD WINAPI
ImmGetCandidateListCountW(
936 HIMC hIMC
, LPDWORD lpdwListCount
)
938 InputContextData
*data
= hIMC
;
939 LPCANDIDATEINFO candinfo
;
942 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
944 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
947 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
949 *lpdwListCount
= count
= candinfo
->dwCount
;
951 if ( is_himc_ime_unicode(data
) )
952 ret
= candinfo
->dwSize
;
955 ret
= sizeof(CANDIDATEINFO
);
957 ret
+= ImmGetCandidateListW(hIMC
, count
, NULL
, 0);
960 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
964 /***********************************************************************
965 * ImmGetCandidateListW (IMM32.@)
967 DWORD WINAPI
ImmGetCandidateListW(
968 HIMC hIMC
, DWORD dwIndex
,
969 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
971 InputContextData
*data
= hIMC
;
972 LPCANDIDATEINFO candinfo
;
973 LPCANDIDATELIST candlist
;
976 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
978 if (!data
|| !data
->IMC
.hCandInfo
)
981 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
982 if ( dwIndex
>= candinfo
->dwCount
||
983 dwIndex
>= (sizeof(candinfo
->dwOffset
) / sizeof(DWORD
)) )
986 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
987 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
990 if ( is_himc_ime_unicode(data
) )
992 ret
= candlist
->dwSize
;
993 if ( lpCandList
&& dwBufLen
>= ret
)
994 memcpy(lpCandList
, candlist
, ret
);
997 ret
= convert_candidatelist_AtoW( candlist
, lpCandList
, dwBufLen
);
1000 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
1004 /***********************************************************************
1005 * ImmGetCandidateWindow (IMM32.@)
1007 BOOL WINAPI
ImmGetCandidateWindow(
1008 HIMC hIMC
, DWORD dwIndex
, LPCANDIDATEFORM lpCandidate
)
1010 InputContextData
*data
= hIMC
;
1012 TRACE("%p, %d, %p\n", hIMC
, dwIndex
, lpCandidate
);
1014 if (!data
|| !lpCandidate
)
1017 if ( dwIndex
>= (sizeof(data
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
)) )
1020 *lpCandidate
= data
->IMC
.cfCandForm
[dwIndex
];
1025 /***********************************************************************
1026 * ImmGetCompositionFontA (IMM32.@)
1028 BOOL WINAPI
ImmGetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
1033 TRACE("(%p, %p):\n", hIMC
, lplf
);
1035 rc
= ImmGetCompositionFontW(hIMC
,&lfW
);
1039 memcpy(lplf
,&lfW
,sizeof(LOGFONTA
));
1040 WideCharToMultiByte(CP_ACP
, 0, lfW
.lfFaceName
, -1, lplf
->lfFaceName
,
1041 LF_FACESIZE
, NULL
, NULL
);
1045 /***********************************************************************
1046 * ImmGetCompositionFontW (IMM32.@)
1048 BOOL WINAPI
ImmGetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
1050 InputContextData
*data
= hIMC
;
1052 TRACE("(%p, %p):\n", hIMC
, lplf
);
1057 *lplf
= data
->IMC
.lfFont
.W
;
1063 /* Helpers for the GetCompositionString functions */
1065 static INT
CopyCompStringIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE target
, INT tlen
,
1070 if (is_himc_ime_unicode(data
) && !unicode
)
1071 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)source
, slen
, (LPSTR
)target
, tlen
, NULL
, NULL
);
1072 else if (!is_himc_ime_unicode(data
) && unicode
)
1073 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)source
, slen
, (LPWSTR
)target
, tlen
) * sizeof(WCHAR
);
1076 int dlen
= (unicode
)?sizeof(WCHAR
):sizeof(CHAR
);
1077 memcpy( target
, source
, min(slen
,tlen
)*dlen
);
1084 static INT
CopyCompAttrIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
, INT sslen
,
1085 LPBYTE target
, INT tlen
, BOOL unicode
)
1089 if (is_himc_ime_unicode(data
) && !unicode
)
1091 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, sslen
, NULL
, 0, NULL
, NULL
);
1094 const BYTE
*src
= source
;
1095 LPBYTE dst
= target
;
1096 int i
, j
= 0, k
= 0;
1100 for (i
= 0; i
< sslen
; ++i
)
1104 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)ssource
+ i
, 1,
1105 NULL
, 0, NULL
, NULL
);
1106 for (; len
> 0; --len
)
1119 else if (!is_himc_ime_unicode(data
) && unicode
)
1121 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, sslen
, NULL
, 0);
1124 const BYTE
*src
= source
;
1125 LPBYTE dst
= target
;
1130 for (i
= 0; i
< sslen
; ++i
)
1132 if (IsDBCSLeadByte(((LPSTR
)ssource
)[i
]))
1145 memcpy( target
, source
, min(slen
,tlen
));
1152 static INT
CopyCompClauseIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
,
1153 LPBYTE target
, INT tlen
, BOOL unicode
)
1157 if (is_himc_ime_unicode(data
) && !unicode
)
1165 tlen
/= sizeof (DWORD
);
1166 for (i
= 0; i
< tlen
; ++i
)
1168 ((DWORD
*)target
)[i
] = WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
,
1169 ((DWORD
*)source
)[i
],
1173 rc
= sizeof (DWORD
) * i
;
1178 else if (!is_himc_ime_unicode(data
) && unicode
)
1186 tlen
/= sizeof (DWORD
);
1187 for (i
= 0; i
< tlen
; ++i
)
1189 ((DWORD
*)target
)[i
] = MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
,
1190 ((DWORD
*)source
)[i
],
1193 rc
= sizeof (DWORD
) * i
;
1200 memcpy( target
, source
, min(slen
,tlen
));
1207 static INT
CopyCompOffsetIMEtoClient(InputContextData
*data
, DWORD offset
, LPBYTE ssource
, BOOL unicode
)
1211 if (is_himc_ime_unicode(data
) && !unicode
)
1213 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, offset
, NULL
, 0, NULL
, NULL
);
1215 else if (!is_himc_ime_unicode(data
) && unicode
)
1217 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, offset
, NULL
, 0);
1225 static LONG
ImmGetCompositionStringT( HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
,
1226 DWORD dwBufLen
, BOOL unicode
)
1229 InputContextData
*data
= hIMC
;
1230 LPCOMPOSITIONSTRING compstr
;
1233 TRACE("(%p, 0x%x, %p, %d)\n", hIMC
, dwIndex
, lpBuf
, dwBufLen
);
1238 if (!data
->IMC
.hCompStr
)
1241 compdata
= ImmLockIMCC(data
->IMC
.hCompStr
);
1242 compstr
= (LPCOMPOSITIONSTRING
)compdata
;
1247 TRACE("GCS_RESULTSTR\n");
1248 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultStrOffset
, compstr
->dwResultStrLen
, lpBuf
, dwBufLen
, unicode
);
1251 TRACE("GCS_COMPSTR\n");
1252 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
, lpBuf
, dwBufLen
, unicode
);
1255 TRACE("GCS_COMPATTR\n");
1256 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompAttrOffset
, compstr
->dwCompAttrLen
,
1257 compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
,
1258 lpBuf
, dwBufLen
, unicode
);
1260 case GCS_COMPCLAUSE
:
1261 TRACE("GCS_COMPCLAUSE\n");
1262 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompClauseOffset
,compstr
->dwCompClauseLen
,
1263 compdata
+ compstr
->dwCompStrOffset
,
1264 lpBuf
, dwBufLen
, unicode
);
1266 case GCS_RESULTCLAUSE
:
1267 TRACE("GCS_RESULTCLAUSE\n");
1268 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultClauseOffset
,compstr
->dwResultClauseLen
,
1269 compdata
+ compstr
->dwResultStrOffset
,
1270 lpBuf
, dwBufLen
, unicode
);
1272 case GCS_RESULTREADSTR
:
1273 TRACE("GCS_RESULTREADSTR\n");
1274 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultReadStrOffset
, compstr
->dwResultReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1276 case GCS_RESULTREADCLAUSE
:
1277 TRACE("GCS_RESULTREADCLAUSE\n");
1278 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultReadClauseOffset
,compstr
->dwResultReadClauseLen
,
1279 compdata
+ compstr
->dwResultStrOffset
,
1280 lpBuf
, dwBufLen
, unicode
);
1282 case GCS_COMPREADSTR
:
1283 TRACE("GCS_COMPREADSTR\n");
1284 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1286 case GCS_COMPREADATTR
:
1287 TRACE("GCS_COMPREADATTR\n");
1288 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompReadAttrOffset
, compstr
->dwCompReadAttrLen
,
1289 compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
,
1290 lpBuf
, dwBufLen
, unicode
);
1292 case GCS_COMPREADCLAUSE
:
1293 TRACE("GCS_COMPREADCLAUSE\n");
1294 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompReadClauseOffset
,compstr
->dwCompReadClauseLen
,
1295 compdata
+ compstr
->dwCompStrOffset
,
1296 lpBuf
, dwBufLen
, unicode
);
1299 TRACE("GCS_CURSORPOS\n");
1300 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwCursorPos
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1302 case GCS_DELTASTART
:
1303 TRACE("GCS_DELTASTART\n");
1304 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwDeltaStart
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1307 FIXME("Unhandled index 0x%x\n",dwIndex
);
1311 ImmUnlockIMCC(data
->IMC
.hCompStr
);
1316 /***********************************************************************
1317 * ImmGetCompositionStringA (IMM32.@)
1319 LONG WINAPI
ImmGetCompositionStringA(
1320 HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
, DWORD dwBufLen
)
1322 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, FALSE
);
1326 /***********************************************************************
1327 * ImmGetCompositionStringW (IMM32.@)
1329 LONG WINAPI
ImmGetCompositionStringW(
1330 HIMC hIMC
, DWORD dwIndex
,
1331 LPVOID lpBuf
, DWORD dwBufLen
)
1333 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, TRUE
);
1336 /***********************************************************************
1337 * ImmGetCompositionWindow (IMM32.@)
1339 BOOL WINAPI
ImmGetCompositionWindow(HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
1341 InputContextData
*data
= hIMC
;
1343 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
1348 *lpCompForm
= data
->IMC
.cfCompForm
;
1352 /***********************************************************************
1353 * ImmGetContext (IMM32.@)
1356 HIMC WINAPI
ImmGetContext(HWND hWnd
)
1360 TRACE("%p\n", hWnd
);
1362 if (!IsWindow(hWnd
))
1364 SetLastError(ERROR_INVALID_WINDOW_HANDLE
);
1367 if (!IMM_GetThreadData()->defaultContext
)
1368 IMM_GetThreadData()->defaultContext
= ImmCreateContext();
1370 rc
= GetPropW(hWnd
,szwWineIMCProperty
);
1373 else if (rc
== NULL
)
1374 rc
= IMM_GetThreadData()->defaultContext
;
1378 InputContextData
*data
= rc
;
1379 data
->IMC
.hWnd
= hWnd
;
1381 TRACE("returning %p\n", rc
);
1386 /***********************************************************************
1387 * ImmGetConversionListA (IMM32.@)
1389 DWORD WINAPI
ImmGetConversionListA(
1391 LPCSTR pSrc
, LPCANDIDATELIST lpDst
,
1392 DWORD dwBufLen
, UINT uFlag
)
1394 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1395 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_a(pSrc
), lpDst
,
1397 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1399 if (!is_kbd_ime_unicode(immHkl
))
1400 return immHkl
->pImeConversionList(hIMC
,(LPCWSTR
)pSrc
,lpDst
,dwBufLen
,uFlag
);
1403 LPCANDIDATELIST lpwDst
;
1405 LPWSTR pwSrc
= strdupAtoW(pSrc
);
1407 len
= immHkl
->pImeConversionList(hIMC
, pwSrc
, NULL
, 0, uFlag
);
1408 lpwDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1411 immHkl
->pImeConversionList(hIMC
, pwSrc
, lpwDst
, len
, uFlag
);
1412 ret
= convert_candidatelist_WtoA( lpwDst
, lpDst
, dwBufLen
);
1413 HeapFree(GetProcessHeap(), 0, lpwDst
);
1415 HeapFree(GetProcessHeap(), 0, pwSrc
);
1424 /***********************************************************************
1425 * ImmGetConversionListW (IMM32.@)
1427 DWORD WINAPI
ImmGetConversionListW(
1429 LPCWSTR pSrc
, LPCANDIDATELIST lpDst
,
1430 DWORD dwBufLen
, UINT uFlag
)
1432 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1433 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_w(pSrc
), lpDst
,
1435 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1437 if (is_kbd_ime_unicode(immHkl
))
1438 return immHkl
->pImeConversionList(hIMC
,pSrc
,lpDst
,dwBufLen
,uFlag
);
1441 LPCANDIDATELIST lpaDst
;
1443 LPSTR paSrc
= strdupWtoA(pSrc
);
1445 len
= immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, NULL
, 0, uFlag
);
1446 lpaDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1449 immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, lpaDst
, len
, uFlag
);
1450 ret
= convert_candidatelist_AtoW( lpaDst
, lpDst
, dwBufLen
);
1451 HeapFree(GetProcessHeap(), 0, lpaDst
);
1453 HeapFree(GetProcessHeap(), 0, paSrc
);
1462 /***********************************************************************
1463 * ImmGetConversionStatus (IMM32.@)
1465 BOOL WINAPI
ImmGetConversionStatus(
1466 HIMC hIMC
, LPDWORD lpfdwConversion
, LPDWORD lpfdwSentence
)
1468 InputContextData
*data
= hIMC
;
1470 TRACE("%p %p %p\n", hIMC
, lpfdwConversion
, lpfdwSentence
);
1475 if (lpfdwConversion
)
1476 *lpfdwConversion
= data
->IMC
.fdwConversion
;
1478 *lpfdwSentence
= data
->IMC
.fdwSentence
;
1483 /***********************************************************************
1484 * ImmGetDefaultIMEWnd (IMM32.@)
1486 HWND WINAPI
ImmGetDefaultIMEWnd(HWND hWnd
)
1488 if (IMM_GetThreadData()->hwndDefault
== NULL
)
1489 IMM_GetThreadData()->hwndDefault
= CreateWindowExW( WS_EX_TOOLWINDOW
,
1490 szwIME
, NULL
, WS_POPUP
, 0, 0, 1, 1, 0, 0, 0, 0);
1491 TRACE("Default is %p\n",IMM_GetThreadData()->hwndDefault
);
1492 return IMM_GetThreadData()->hwndDefault
;
1495 /***********************************************************************
1496 * ImmGetDescriptionA (IMM32.@)
1498 UINT WINAPI
ImmGetDescriptionA(
1499 HKL hKL
, LPSTR lpszDescription
, UINT uBufLen
)
1504 TRACE("%p %p %d\n", hKL
, lpszDescription
, uBufLen
);
1506 /* find out how many characters in the unicode buffer */
1507 len
= ImmGetDescriptionW( hKL
, NULL
, 0 );
1509 /* allocate a buffer of that size */
1510 buf
= HeapAlloc( GetProcessHeap(), 0, (len
+ 1) * sizeof (WCHAR
) );
1514 /* fetch the unicode buffer */
1515 len
= ImmGetDescriptionW( hKL
, buf
, len
+ 1 );
1517 /* convert it back to ASCII */
1518 len
= WideCharToMultiByte( CP_ACP
, 0, buf
, len
+ 1,
1519 lpszDescription
, uBufLen
, NULL
, NULL
);
1521 HeapFree( GetProcessHeap(), 0, buf
);
1526 /***********************************************************************
1527 * ImmGetDescriptionW (IMM32.@)
1529 UINT WINAPI
ImmGetDescriptionW(HKL hKL
, LPWSTR lpszDescription
, UINT uBufLen
)
1531 static const WCHAR name
[] = { 'W','i','n','e',' ','X','I','M',0 };
1533 FIXME("(%p, %p, %d): semi stub\n", hKL
, lpszDescription
, uBufLen
);
1535 if (!uBufLen
) return lstrlenW( name
);
1536 lstrcpynW( lpszDescription
, name
, uBufLen
);
1537 return lstrlenW( lpszDescription
);
1540 /***********************************************************************
1541 * ImmGetGuideLineA (IMM32.@)
1543 DWORD WINAPI
ImmGetGuideLineA(
1544 HIMC hIMC
, DWORD dwIndex
, LPSTR lpBuf
, DWORD dwBufLen
)
1546 FIXME("(%p, %d, %s, %d): stub\n",
1547 hIMC
, dwIndex
, debugstr_a(lpBuf
), dwBufLen
1549 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1553 /***********************************************************************
1554 * ImmGetGuideLineW (IMM32.@)
1556 DWORD WINAPI
ImmGetGuideLineW(HIMC hIMC
, DWORD dwIndex
, LPWSTR lpBuf
, DWORD dwBufLen
)
1558 FIXME("(%p, %d, %s, %d): stub\n",
1559 hIMC
, dwIndex
, debugstr_w(lpBuf
), dwBufLen
1561 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1565 /***********************************************************************
1566 * ImmGetIMEFileNameA (IMM32.@)
1568 UINT WINAPI
ImmGetIMEFileNameA( HKL hKL
, LPSTR lpszFileName
, UINT uBufLen
)
1571 UINT wBufLen
= uBufLen
;
1574 if (uBufLen
&& lpszFileName
)
1575 bufW
= HeapAlloc(GetProcessHeap(),0,uBufLen
* sizeof(WCHAR
));
1576 else /* We need this to get the number of byte required */
1578 bufW
= HeapAlloc(GetProcessHeap(),0,MAX_PATH
* sizeof(WCHAR
));
1582 rc
= ImmGetIMEFileNameW(hKL
,bufW
,wBufLen
);
1586 if (uBufLen
&& lpszFileName
)
1587 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, lpszFileName
,
1588 uBufLen
, NULL
, NULL
);
1589 else /* get the length */
1590 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, NULL
, 0, NULL
,
1594 HeapFree(GetProcessHeap(),0,bufW
);
1598 /***********************************************************************
1599 * ImmGetIMEFileNameW (IMM32.@)
1601 UINT WINAPI
ImmGetIMEFileNameW(HKL hKL
, LPWSTR lpszFileName
, UINT uBufLen
)
1606 WCHAR regKey
[sizeof(szImeRegFmt
)/sizeof(WCHAR
)+8];
1608 wsprintfW( regKey
, szImeRegFmt
, (ULONG_PTR
)hKL
);
1609 rc
= RegOpenKeyW( HKEY_LOCAL_MACHINE
, regKey
, &hkey
);
1610 if (rc
!= ERROR_SUCCESS
)
1617 rc
= RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, NULL
, &length
);
1619 if (rc
!= ERROR_SUCCESS
)
1625 if (length
> uBufLen
* sizeof(WCHAR
) || !lpszFileName
)
1630 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
1634 return length
/ sizeof(WCHAR
);
1637 RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, lpszFileName
, &length
);
1641 return length
/ sizeof(WCHAR
);
1644 /***********************************************************************
1645 * ImmGetOpenStatus (IMM32.@)
1647 BOOL WINAPI
ImmGetOpenStatus(HIMC hIMC
)
1649 InputContextData
*data
= hIMC
;
1655 TRACE("(%p): semi-stub\n", hIMC
);
1658 FIXME("(%p): semi-stub\n", hIMC
);
1660 return data
->IMC
.fOpen
;
1663 /***********************************************************************
1664 * ImmGetProperty (IMM32.@)
1666 DWORD WINAPI
ImmGetProperty(HKL hKL
, DWORD fdwIndex
)
1671 TRACE("(%p, %d)\n", hKL
, fdwIndex
);
1672 kbd
= IMM_GetImmHkl(hKL
);
1674 if (kbd
&& kbd
->hIME
)
1678 case IGP_PROPERTY
: rc
= kbd
->imeInfo
.fdwProperty
; break;
1679 case IGP_CONVERSION
: rc
= kbd
->imeInfo
.fdwConversionCaps
; break;
1680 case IGP_SENTENCE
: rc
= kbd
->imeInfo
.fdwSentenceCaps
; break;
1681 case IGP_SETCOMPSTR
: rc
= kbd
->imeInfo
.fdwSCSCaps
; break;
1682 case IGP_SELECT
: rc
= kbd
->imeInfo
.fdwSelectCaps
; break;
1683 case IGP_GETIMEVERSION
: rc
= IMEVER_0400
; break;
1684 case IGP_UI
: rc
= 0; break;
1691 /***********************************************************************
1692 * ImmGetRegisterWordStyleA (IMM32.@)
1694 UINT WINAPI
ImmGetRegisterWordStyleA(
1695 HKL hKL
, UINT nItem
, LPSTYLEBUFA lpStyleBuf
)
1697 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1698 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1699 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1701 if (!is_kbd_ime_unicode(immHkl
))
1702 return immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)lpStyleBuf
);
1708 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,&sbw
);
1709 WideCharToMultiByte(CP_ACP
, 0, sbw
.szDescription
, -1,
1710 lpStyleBuf
->szDescription
, 32, NULL
, NULL
);
1711 lpStyleBuf
->dwStyle
= sbw
.dwStyle
;
1719 /***********************************************************************
1720 * ImmGetRegisterWordStyleW (IMM32.@)
1722 UINT WINAPI
ImmGetRegisterWordStyleW(
1723 HKL hKL
, UINT nItem
, LPSTYLEBUFW lpStyleBuf
)
1725 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1726 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1727 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1729 if (is_kbd_ime_unicode(immHkl
))
1730 return immHkl
->pImeGetRegisterWordStyle(nItem
,lpStyleBuf
);
1736 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)&sba
);
1737 MultiByteToWideChar(CP_ACP
, 0, sba
.szDescription
, -1,
1738 lpStyleBuf
->szDescription
, 32);
1739 lpStyleBuf
->dwStyle
= sba
.dwStyle
;
1747 /***********************************************************************
1748 * ImmGetStatusWindowPos (IMM32.@)
1750 BOOL WINAPI
ImmGetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
1752 InputContextData
*data
= hIMC
;
1754 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
1756 if (!data
|| !lpptPos
)
1759 *lpptPos
= data
->IMC
.ptStatusWndPos
;
1764 /***********************************************************************
1765 * ImmGetVirtualKey (IMM32.@)
1767 UINT WINAPI
ImmGetVirtualKey(HWND hWnd
)
1769 OSVERSIONINFOA version
;
1770 InputContextData
*data
= ImmGetContext( hWnd
);
1771 TRACE("%p\n", hWnd
);
1774 return data
->lastVK
;
1776 version
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFOA
);
1777 GetVersionExA( &version
);
1778 switch(version
.dwPlatformId
)
1780 case VER_PLATFORM_WIN32_WINDOWS
:
1781 return VK_PROCESSKEY
;
1782 case VER_PLATFORM_WIN32_NT
:
1785 FIXME("%d not supported\n",version
.dwPlatformId
);
1786 return VK_PROCESSKEY
;
1790 /***********************************************************************
1791 * ImmInstallIMEA (IMM32.@)
1793 HKL WINAPI
ImmInstallIMEA(
1794 LPCSTR lpszIMEFileName
, LPCSTR lpszLayoutText
)
1796 LPWSTR lpszwIMEFileName
;
1797 LPWSTR lpszwLayoutText
;
1800 TRACE ("(%s, %s)\n", debugstr_a(lpszIMEFileName
),
1801 debugstr_a(lpszLayoutText
));
1803 lpszwIMEFileName
= strdupAtoW(lpszIMEFileName
);
1804 lpszwLayoutText
= strdupAtoW(lpszLayoutText
);
1806 hkl
= ImmInstallIMEW(lpszwIMEFileName
, lpszwLayoutText
);
1808 HeapFree(GetProcessHeap(),0,lpszwIMEFileName
);
1809 HeapFree(GetProcessHeap(),0,lpszwLayoutText
);
1813 /***********************************************************************
1814 * ImmInstallIMEW (IMM32.@)
1816 HKL WINAPI
ImmInstallIMEW(
1817 LPCWSTR lpszIMEFileName
, LPCWSTR lpszLayoutText
)
1819 INT lcid
= GetUserDefaultLCID();
1824 WCHAR regKey
[sizeof(szImeRegFmt
)/sizeof(WCHAR
)+8];
1826 TRACE ("(%s, %s):\n", debugstr_w(lpszIMEFileName
),
1827 debugstr_w(lpszLayoutText
));
1829 /* Start with 2. e001 will be blank and so default to the wine internal IME */
1832 while (count
< 0xfff)
1834 DWORD disposition
= 0;
1836 hkl
= (HKL
)MAKELPARAM( lcid
, 0xe000 | count
);
1837 wsprintfW( regKey
, szImeRegFmt
, (ULONG_PTR
)hkl
);
1839 rc
= RegCreateKeyExW(HKEY_LOCAL_MACHINE
, regKey
, 0, NULL
, 0, KEY_WRITE
, NULL
, &hkey
, &disposition
);
1840 if (rc
== ERROR_SUCCESS
&& disposition
== REG_CREATED_NEW_KEY
)
1842 else if (rc
== ERROR_SUCCESS
)
1850 WARN("Unable to find slot to install IME\n");
1854 if (rc
== ERROR_SUCCESS
)
1856 rc
= RegSetValueExW(hkey
, szImeFileW
, 0, REG_SZ
, (const BYTE
*)lpszIMEFileName
,
1857 (lstrlenW(lpszIMEFileName
) + 1) * sizeof(WCHAR
));
1858 if (rc
== ERROR_SUCCESS
)
1859 rc
= RegSetValueExW(hkey
, szLayoutTextW
, 0, REG_SZ
, (const BYTE
*)lpszLayoutText
,
1860 (lstrlenW(lpszLayoutText
) + 1) * sizeof(WCHAR
));
1866 WARN("Unable to set IME registry values\n");
1871 /***********************************************************************
1872 * ImmIsIME (IMM32.@)
1874 BOOL WINAPI
ImmIsIME(HKL hKL
)
1877 TRACE("(%p):\n", hKL
);
1878 ptr
= IMM_GetImmHkl(hKL
);
1879 return (ptr
&& ptr
->hIME
);
1882 /***********************************************************************
1883 * ImmIsUIMessageA (IMM32.@)
1885 BOOL WINAPI
ImmIsUIMessageA(
1886 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1890 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
1891 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
1892 (msg
== WM_IME_SETCONTEXT
) ||
1893 (msg
== WM_IME_NOTIFY
) ||
1894 (msg
== WM_IME_COMPOSITIONFULL
) ||
1895 (msg
== WM_IME_SELECT
) ||
1896 (msg
== 0x287 /* FIXME: WM_IME_SYSTEM */) ||
1897 (msg
== WM_MSIME_RECONVERTOPTIONS
) ||
1898 (msg
== WM_MSIME_MOUSE
) ||
1899 (msg
== WM_MSIME_RECONVERTREQUEST
) ||
1900 (msg
== WM_MSIME_RECONVERT
) ||
1901 (msg
== WM_MSIME_QUERYPOSITION
) ||
1902 (msg
== WM_MSIME_DOCUMENTFEED
))
1905 SendMessageA(hWndIME
, msg
, wParam
, lParam
);
1912 /***********************************************************************
1913 * ImmIsUIMessageW (IMM32.@)
1915 BOOL WINAPI
ImmIsUIMessageW(
1916 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1920 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
1921 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
1922 (msg
== WM_IME_SETCONTEXT
) ||
1923 (msg
== WM_IME_NOTIFY
) ||
1924 (msg
== WM_IME_COMPOSITIONFULL
) ||
1925 (msg
== WM_IME_SELECT
) ||
1926 (msg
== 0x287 /* FIXME: WM_IME_SYSTEM */) ||
1927 (msg
== WM_MSIME_RECONVERTOPTIONS
) ||
1928 (msg
== WM_MSIME_MOUSE
) ||
1929 (msg
== WM_MSIME_RECONVERTREQUEST
) ||
1930 (msg
== WM_MSIME_RECONVERT
) ||
1931 (msg
== WM_MSIME_QUERYPOSITION
) ||
1932 (msg
== WM_MSIME_DOCUMENTFEED
))
1935 SendMessageW(hWndIME
, msg
, wParam
, lParam
);
1942 /***********************************************************************
1943 * ImmNotifyIME (IMM32.@)
1945 BOOL WINAPI
ImmNotifyIME(
1946 HIMC hIMC
, DWORD dwAction
, DWORD dwIndex
, DWORD dwValue
)
1948 InputContextData
*data
= hIMC
;
1950 TRACE("(%p, %d, %d, %d)\n",
1951 hIMC
, dwAction
, dwIndex
, dwValue
);
1953 if (!data
|| ! data
->immKbd
->pNotifyIME
)
1956 return data
->immKbd
->pNotifyIME(hIMC
,dwAction
,dwIndex
,dwValue
);
1959 /***********************************************************************
1960 * ImmRegisterWordA (IMM32.@)
1962 BOOL WINAPI
ImmRegisterWordA(
1963 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszRegister
)
1965 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1966 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
1967 debugstr_a(lpszRegister
));
1968 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
1970 if (!is_kbd_ime_unicode(immHkl
))
1971 return immHkl
->pImeRegisterWord((LPCWSTR
)lpszReading
,dwStyle
,
1972 (LPCWSTR
)lpszRegister
);
1975 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
1976 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
1979 rc
= immHkl
->pImeRegisterWord(lpszwReading
,dwStyle
,lpszwRegister
);
1980 HeapFree(GetProcessHeap(),0,lpszwReading
);
1981 HeapFree(GetProcessHeap(),0,lpszwRegister
);
1989 /***********************************************************************
1990 * ImmRegisterWordW (IMM32.@)
1992 BOOL WINAPI
ImmRegisterWordW(
1993 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszRegister
)
1995 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1996 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
1997 debugstr_w(lpszRegister
));
1998 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
2000 if (is_kbd_ime_unicode(immHkl
))
2001 return immHkl
->pImeRegisterWord(lpszReading
,dwStyle
,lpszRegister
);
2004 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2005 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
2008 rc
= immHkl
->pImeRegisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2009 (LPCWSTR
)lpszaRegister
);
2010 HeapFree(GetProcessHeap(),0,lpszaReading
);
2011 HeapFree(GetProcessHeap(),0,lpszaRegister
);
2019 /***********************************************************************
2020 * ImmReleaseContext (IMM32.@)
2022 BOOL WINAPI
ImmReleaseContext(HWND hWnd
, HIMC hIMC
)
2024 static int shown
= 0;
2027 FIXME("(%p, %p): stub\n", hWnd
, hIMC
);
2033 /***********************************************************************
2034 * ImmRequestMessageA(IMM32.@)
2036 LRESULT WINAPI
ImmRequestMessageA(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
2038 InputContextData
*data
= hIMC
;
2040 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
2042 if (data
&& IsWindow(data
->IMC
.hWnd
))
2043 return SendMessageA(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
2048 /***********************************************************************
2049 * ImmRequestMessageW(IMM32.@)
2051 LRESULT WINAPI
ImmRequestMessageW(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
2053 InputContextData
*data
= hIMC
;
2055 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
2057 if (data
&& IsWindow(data
->IMC
.hWnd
))
2058 return SendMessageW(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
2063 /***********************************************************************
2064 * ImmSetCandidateWindow (IMM32.@)
2066 BOOL WINAPI
ImmSetCandidateWindow(
2067 HIMC hIMC
, LPCANDIDATEFORM lpCandidate
)
2069 InputContextData
*data
= hIMC
;
2071 TRACE("(%p, %p)\n", hIMC
, lpCandidate
);
2073 if (!data
|| !lpCandidate
)
2076 TRACE("\t%x, %x, (%i,%i), (%i,%i - %i,%i)\n",
2077 lpCandidate
->dwIndex
, lpCandidate
->dwStyle
,
2078 lpCandidate
->ptCurrentPos
.x
, lpCandidate
->ptCurrentPos
.y
,
2079 lpCandidate
->rcArea
.top
, lpCandidate
->rcArea
.left
,
2080 lpCandidate
->rcArea
.bottom
, lpCandidate
->rcArea
.right
);
2082 if ( lpCandidate
->dwIndex
>= (sizeof(data
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
)) )
2085 data
->IMC
.cfCandForm
[lpCandidate
->dwIndex
] = *lpCandidate
;
2086 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCANDIDATEPOS
);
2087 ImmInternalSendIMENotify(data
, IMN_SETCANDIDATEPOS
, 1 << lpCandidate
->dwIndex
);
2092 /***********************************************************************
2093 * ImmSetCompositionFontA (IMM32.@)
2095 BOOL WINAPI
ImmSetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
2097 InputContextData
*data
= hIMC
;
2098 TRACE("(%p, %p)\n", hIMC
, lplf
);
2103 memcpy(&data
->IMC
.lfFont
.W
,lplf
,sizeof(LOGFONTA
));
2104 MultiByteToWideChar(CP_ACP
, 0, lplf
->lfFaceName
, -1, data
->IMC
.lfFont
.W
.lfFaceName
,
2106 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2107 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2112 /***********************************************************************
2113 * ImmSetCompositionFontW (IMM32.@)
2115 BOOL WINAPI
ImmSetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
2117 InputContextData
*data
= hIMC
;
2118 TRACE("(%p, %p)\n", hIMC
, lplf
);
2123 data
->IMC
.lfFont
.W
= *lplf
;
2124 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2125 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2130 /***********************************************************************
2131 * ImmSetCompositionStringA (IMM32.@)
2133 BOOL WINAPI
ImmSetCompositionStringA(
2134 HIMC hIMC
, DWORD dwIndex
,
2135 LPCVOID lpComp
, DWORD dwCompLen
,
2136 LPCVOID lpRead
, DWORD dwReadLen
)
2140 WCHAR
*CompBuffer
= NULL
;
2141 WCHAR
*ReadBuffer
= NULL
;
2143 InputContextData
*data
= hIMC
;
2145 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2146 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2151 if (!(dwIndex
== SCS_SETSTR
||
2152 dwIndex
== SCS_CHANGEATTR
||
2153 dwIndex
== SCS_CHANGECLAUSE
||
2154 dwIndex
== SCS_SETRECONVERTSTRING
||
2155 dwIndex
== SCS_QUERYRECONVERTSTRING
))
2158 if (!is_himc_ime_unicode(data
))
2159 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2160 dwCompLen
, lpRead
, dwReadLen
);
2162 comp_len
= MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0);
2165 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
* sizeof(WCHAR
));
2166 MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
);
2169 read_len
= MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0);
2172 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
* sizeof(WCHAR
));
2173 MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
);
2176 rc
= ImmSetCompositionStringW(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2177 ReadBuffer
, read_len
);
2179 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2180 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2185 /***********************************************************************
2186 * ImmSetCompositionStringW (IMM32.@)
2188 BOOL WINAPI
ImmSetCompositionStringW(
2189 HIMC hIMC
, DWORD dwIndex
,
2190 LPCVOID lpComp
, DWORD dwCompLen
,
2191 LPCVOID lpRead
, DWORD dwReadLen
)
2195 CHAR
*CompBuffer
= NULL
;
2196 CHAR
*ReadBuffer
= NULL
;
2198 InputContextData
*data
= hIMC
;
2200 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2201 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2206 if (!(dwIndex
== SCS_SETSTR
||
2207 dwIndex
== SCS_CHANGEATTR
||
2208 dwIndex
== SCS_CHANGECLAUSE
||
2209 dwIndex
== SCS_SETRECONVERTSTRING
||
2210 dwIndex
== SCS_QUERYRECONVERTSTRING
))
2213 if (is_himc_ime_unicode(data
))
2214 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2215 dwCompLen
, lpRead
, dwReadLen
);
2217 comp_len
= WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0, NULL
,
2221 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
);
2222 WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
,
2226 read_len
= WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0, NULL
,
2230 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
);
2231 WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
,
2235 rc
= ImmSetCompositionStringA(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2236 ReadBuffer
, read_len
);
2238 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2239 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2244 /***********************************************************************
2245 * ImmSetCompositionWindow (IMM32.@)
2247 BOOL WINAPI
ImmSetCompositionWindow(
2248 HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
2250 BOOL reshow
= FALSE
;
2251 InputContextData
*data
= hIMC
;
2253 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
2254 TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm
->dwStyle
,
2255 lpCompForm
->ptCurrentPos
.x
, lpCompForm
->ptCurrentPos
.y
, lpCompForm
->rcArea
.top
,
2256 lpCompForm
->rcArea
.left
, lpCompForm
->rcArea
.bottom
, lpCompForm
->rcArea
.right
);
2261 data
->IMC
.cfCompForm
= *lpCompForm
;
2263 if (IsWindowVisible(data
->immKbd
->UIWnd
))
2266 ShowWindow(data
->immKbd
->UIWnd
,SW_HIDE
);
2269 /* FIXME: this is a partial stub */
2272 ShowWindow(data
->immKbd
->UIWnd
,SW_SHOWNOACTIVATE
);
2274 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONWINDOW
, 0);
2278 /***********************************************************************
2279 * ImmSetConversionStatus (IMM32.@)
2281 BOOL WINAPI
ImmSetConversionStatus(
2282 HIMC hIMC
, DWORD fdwConversion
, DWORD fdwSentence
)
2284 DWORD oldConversion
, oldSentence
;
2285 InputContextData
*data
= hIMC
;
2287 TRACE("%p %d %d\n", hIMC
, fdwConversion
, fdwSentence
);
2292 if ( fdwConversion
!= data
->IMC
.fdwConversion
)
2294 oldConversion
= data
->IMC
.fdwConversion
;
2295 data
->IMC
.fdwConversion
= fdwConversion
;
2296 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldConversion
, IMC_SETCONVERSIONMODE
);
2297 ImmInternalSendIMENotify(data
, IMN_SETCONVERSIONMODE
, 0);
2299 if ( fdwSentence
!= data
->IMC
.fdwSentence
)
2301 oldSentence
= data
->IMC
.fdwSentence
;
2302 data
->IMC
.fdwSentence
= fdwSentence
;
2303 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldSentence
, IMC_SETSENTENCEMODE
);
2304 ImmInternalSendIMENotify(data
, IMN_SETSENTENCEMODE
, 0);
2310 /***********************************************************************
2311 * ImmSetOpenStatus (IMM32.@)
2313 BOOL WINAPI
ImmSetOpenStatus(HIMC hIMC
, BOOL fOpen
)
2315 InputContextData
*data
= hIMC
;
2317 TRACE("%p %d\n", hIMC
, fOpen
);
2322 if (data
->immKbd
->UIWnd
== NULL
)
2324 /* create the ime window */
2325 data
->immKbd
->UIWnd
= CreateWindowExW( WS_EX_TOOLWINDOW
,
2326 data
->immKbd
->imeClassName
, NULL
, WS_POPUP
, 0, 0, 1, 1, 0,
2327 0, data
->immKbd
->hIME
, 0);
2328 SetWindowLongPtrW(data
->immKbd
->UIWnd
, IMMGWL_IMC
, (LONG_PTR
)data
);
2331 SetWindowLongPtrW(data
->immKbd
->UIWnd
, IMMGWL_IMC
, (LONG_PTR
)data
);
2333 if (!fOpen
!= !data
->IMC
.fOpen
)
2335 data
->IMC
.fOpen
= fOpen
;
2336 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETOPENSTATUS
);
2337 ImmInternalSendIMENotify(data
, IMN_SETOPENSTATUS
, 0);
2343 /***********************************************************************
2344 * ImmSetStatusWindowPos (IMM32.@)
2346 BOOL WINAPI
ImmSetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
2348 InputContextData
*data
= hIMC
;
2350 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
2352 if (!data
|| !lpptPos
)
2355 TRACE("\t(%i,%i)\n", lpptPos
->x
, lpptPos
->y
);
2357 data
->IMC
.ptStatusWndPos
= *lpptPos
;
2358 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETSTATUSWINDOWPOS
);
2359 ImmInternalSendIMENotify(data
, IMN_SETSTATUSWINDOWPOS
, 0);
2364 /***********************************************************************
2365 * ImmCreateSoftKeyboard(IMM32.@)
2367 HWND WINAPI
ImmCreateSoftKeyboard(UINT uType
, UINT hOwner
, int x
, int y
)
2369 FIXME("(%d, %d, %d, %d): stub\n", uType
, hOwner
, x
, y
);
2370 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2374 /***********************************************************************
2375 * ImmDestroySoftKeyboard(IMM32.@)
2377 BOOL WINAPI
ImmDestroySoftKeyboard(HWND hSoftWnd
)
2379 FIXME("(%p): stub\n", hSoftWnd
);
2380 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2384 /***********************************************************************
2385 * ImmShowSoftKeyboard(IMM32.@)
2387 BOOL WINAPI
ImmShowSoftKeyboard(HWND hSoftWnd
, int nCmdShow
)
2389 FIXME("(%p, %d): stub\n", hSoftWnd
, nCmdShow
);
2390 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2394 /***********************************************************************
2395 * ImmSimulateHotKey (IMM32.@)
2397 BOOL WINAPI
ImmSimulateHotKey(HWND hWnd
, DWORD dwHotKeyID
)
2399 FIXME("(%p, %d): stub\n", hWnd
, dwHotKeyID
);
2400 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2404 /***********************************************************************
2405 * ImmUnregisterWordA (IMM32.@)
2407 BOOL WINAPI
ImmUnregisterWordA(
2408 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszUnregister
)
2410 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2411 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
2412 debugstr_a(lpszUnregister
));
2413 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2415 if (!is_kbd_ime_unicode(immHkl
))
2416 return immHkl
->pImeUnregisterWord((LPCWSTR
)lpszReading
,dwStyle
,
2417 (LPCWSTR
)lpszUnregister
);
2420 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
2421 LPWSTR lpszwUnregister
= strdupAtoW(lpszUnregister
);
2424 rc
= immHkl
->pImeUnregisterWord(lpszwReading
,dwStyle
,lpszwUnregister
);
2425 HeapFree(GetProcessHeap(),0,lpszwReading
);
2426 HeapFree(GetProcessHeap(),0,lpszwUnregister
);
2434 /***********************************************************************
2435 * ImmUnregisterWordW (IMM32.@)
2437 BOOL WINAPI
ImmUnregisterWordW(
2438 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszUnregister
)
2440 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2441 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
2442 debugstr_w(lpszUnregister
));
2443 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2445 if (is_kbd_ime_unicode(immHkl
))
2446 return immHkl
->pImeUnregisterWord(lpszReading
,dwStyle
,lpszUnregister
);
2449 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2450 LPSTR lpszaUnregister
= strdupWtoA(lpszUnregister
);
2453 rc
= immHkl
->pImeUnregisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2454 (LPCWSTR
)lpszaUnregister
);
2455 HeapFree(GetProcessHeap(),0,lpszaReading
);
2456 HeapFree(GetProcessHeap(),0,lpszaUnregister
);
2464 /***********************************************************************
2465 * ImmGetImeMenuItemsA (IMM32.@)
2467 DWORD WINAPI
ImmGetImeMenuItemsA( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2468 LPIMEMENUITEMINFOA lpImeParentMenu
, LPIMEMENUITEMINFOA lpImeMenu
,
2471 InputContextData
*data
= hIMC
;
2472 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2473 lpImeParentMenu
, lpImeMenu
, dwSize
);
2474 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2476 if (!is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2477 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2478 (IMEMENUITEMINFOW
*)lpImeParentMenu
,
2479 (IMEMENUITEMINFOW
*)lpImeMenu
, dwSize
);
2482 IMEMENUITEMINFOW lpImeParentMenuW
;
2483 IMEMENUITEMINFOW
*lpImeMenuW
, *parent
= NULL
;
2486 if (lpImeParentMenu
)
2487 parent
= &lpImeParentMenuW
;
2490 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOA
);
2491 dwSize
= count
* sizeof(IMEMENUITEMINFOW
);
2492 lpImeMenuW
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2497 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2498 parent
, lpImeMenuW
, dwSize
);
2500 if (lpImeParentMenu
)
2502 memcpy(lpImeParentMenu
,&lpImeParentMenuW
,sizeof(IMEMENUITEMINFOA
));
2503 lpImeParentMenu
->hbmpItem
= lpImeParentMenuW
.hbmpItem
;
2504 WideCharToMultiByte(CP_ACP
, 0, lpImeParentMenuW
.szString
,
2505 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
,
2508 if (lpImeMenu
&& rc
)
2511 for (i
= 0; i
< rc
; i
++)
2513 memcpy(&lpImeMenu
[i
],&lpImeMenuW
[1],sizeof(IMEMENUITEMINFOA
));
2514 lpImeMenu
[i
].hbmpItem
= lpImeMenuW
[i
].hbmpItem
;
2515 WideCharToMultiByte(CP_ACP
, 0, lpImeMenuW
[i
].szString
,
2516 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
,
2520 HeapFree(GetProcessHeap(),0,lpImeMenuW
);
2528 /***********************************************************************
2529 * ImmGetImeMenuItemsW (IMM32.@)
2531 DWORD WINAPI
ImmGetImeMenuItemsW( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2532 LPIMEMENUITEMINFOW lpImeParentMenu
, LPIMEMENUITEMINFOW lpImeMenu
,
2535 InputContextData
*data
= hIMC
;
2536 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2537 lpImeParentMenu
, lpImeMenu
, dwSize
);
2538 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2540 if (is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2541 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2542 lpImeParentMenu
, lpImeMenu
, dwSize
);
2545 IMEMENUITEMINFOA lpImeParentMenuA
;
2546 IMEMENUITEMINFOA
*lpImeMenuA
, *parent
= NULL
;
2549 if (lpImeParentMenu
)
2550 parent
= &lpImeParentMenuA
;
2553 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOW
);
2554 dwSize
= count
* sizeof(IMEMENUITEMINFOA
);
2555 lpImeMenuA
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2560 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2561 (IMEMENUITEMINFOW
*)parent
,
2562 (IMEMENUITEMINFOW
*)lpImeMenuA
, dwSize
);
2564 if (lpImeParentMenu
)
2566 memcpy(lpImeParentMenu
,&lpImeParentMenuA
,sizeof(IMEMENUITEMINFOA
));
2567 lpImeParentMenu
->hbmpItem
= lpImeParentMenuA
.hbmpItem
;
2568 MultiByteToWideChar(CP_ACP
, 0, lpImeParentMenuA
.szString
,
2569 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
);
2571 if (lpImeMenu
&& rc
)
2574 for (i
= 0; i
< rc
; i
++)
2576 memcpy(&lpImeMenu
[i
],&lpImeMenuA
[1],sizeof(IMEMENUITEMINFOA
));
2577 lpImeMenu
[i
].hbmpItem
= lpImeMenuA
[i
].hbmpItem
;
2578 MultiByteToWideChar(CP_ACP
, 0, lpImeMenuA
[i
].szString
,
2579 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
);
2582 HeapFree(GetProcessHeap(),0,lpImeMenuA
);
2590 /***********************************************************************
2591 * ImmLockIMC(IMM32.@)
2593 LPINPUTCONTEXT WINAPI
ImmLockIMC(HIMC hIMC
)
2595 InputContextData
*data
= hIMC
;
2603 /***********************************************************************
2604 * ImmUnlockIMC(IMM32.@)
2606 BOOL WINAPI
ImmUnlockIMC(HIMC hIMC
)
2608 InputContextData
*data
= hIMC
;
2610 return (data
->dwLock
!=0);
2613 /***********************************************************************
2614 * ImmGetIMCLockCount(IMM32.@)
2616 DWORD WINAPI
ImmGetIMCLockCount(HIMC hIMC
)
2618 InputContextData
*data
= hIMC
;
2619 return data
->dwLock
;
2622 /***********************************************************************
2623 * ImmCreateIMCC(IMM32.@)
2625 HIMCC WINAPI
ImmCreateIMCC(DWORD size
)
2627 IMCCInternal
*internal
;
2628 int real_size
= size
+ sizeof(IMCCInternal
);
2630 internal
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, real_size
);
2631 if (internal
== NULL
)
2634 internal
->dwSize
= size
;
2638 /***********************************************************************
2639 * ImmDestroyIMCC(IMM32.@)
2641 HIMCC WINAPI
ImmDestroyIMCC(HIMCC block
)
2643 HeapFree(GetProcessHeap(),0,block
);
2647 /***********************************************************************
2648 * ImmLockIMCC(IMM32.@)
2650 LPVOID WINAPI
ImmLockIMCC(HIMCC imcc
)
2652 IMCCInternal
*internal
;
2655 internal
->dwLock
++;
2656 return internal
+ 1;
2659 /***********************************************************************
2660 * ImmUnlockIMCC(IMM32.@)
2662 BOOL WINAPI
ImmUnlockIMCC(HIMCC imcc
)
2664 IMCCInternal
*internal
;
2667 internal
->dwLock
--;
2668 return (internal
->dwLock
!=0);
2671 /***********************************************************************
2672 * ImmGetIMCCLockCount(IMM32.@)
2674 DWORD WINAPI
ImmGetIMCCLockCount(HIMCC imcc
)
2676 IMCCInternal
*internal
;
2679 return internal
->dwLock
;
2682 /***********************************************************************
2683 * ImmReSizeIMCC(IMM32.@)
2685 HIMCC WINAPI
ImmReSizeIMCC(HIMCC imcc
, DWORD size
)
2687 IMCCInternal
*internal
,*newone
;
2688 int real_size
= size
+ sizeof(IMCCInternal
);
2692 newone
= HeapReAlloc(GetProcessHeap(), 0, internal
, real_size
);
2693 newone
->dwSize
= size
;
2698 /***********************************************************************
2699 * ImmGetIMCCSize(IMM32.@)
2701 DWORD WINAPI
ImmGetIMCCSize(HIMCC imcc
)
2703 IMCCInternal
*internal
;
2706 return internal
->dwSize
;
2709 /***********************************************************************
2710 * ImmGenerateMessage(IMM32.@)
2712 BOOL WINAPI
ImmGenerateMessage(HIMC hIMC
)
2714 InputContextData
*data
= hIMC
;
2716 TRACE("%i messages queued\n",data
->IMC
.dwNumMsgBuf
);
2717 if (data
->IMC
.dwNumMsgBuf
> 0)
2719 LPTRANSMSG lpTransMsg
;
2722 lpTransMsg
= ImmLockIMCC(data
->IMC
.hMsgBuf
);
2723 for (i
= 0; i
< data
->IMC
.dwNumMsgBuf
; i
++)
2724 ImmInternalPostIMEMessage(data
, lpTransMsg
[i
].message
, lpTransMsg
[i
].wParam
, lpTransMsg
[i
].lParam
);
2726 ImmUnlockIMCC(data
->IMC
.hMsgBuf
);
2728 data
->IMC
.dwNumMsgBuf
= 0;
2734 /***********************************************************************
2735 * ImmTranslateMessage(IMM32.@)
2736 * ( Undocumented, call internally and from user32.dll )
2738 BOOL WINAPI
ImmTranslateMessage(HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lKeyData
)
2740 InputContextData
*data
;
2741 HIMC imc
= ImmGetContext(hwnd
);
2747 static const DWORD list_count
= 10;
2749 TRACE("%p %x %x %x\n",hwnd
, msg
, (UINT
)wParam
, (UINT
)lKeyData
);
2756 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeToAsciiEx
)
2759 GetKeyboardState(state
);
2760 scancode
= lKeyData
>> 0x10 & 0xff;
2762 list
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, list_count
* sizeof(TRANSMSG
) + sizeof(DWORD
));
2763 ((DWORD
*)list
)[0] = list_count
;
2765 if (data
->immKbd
->imeInfo
.fdwProperty
& IME_PROP_KBD_CHAR_FIRST
)
2769 if (!is_himc_ime_unicode(data
))
2770 ToAscii(data
->lastVK
, scancode
, state
, &chr
, 0);
2772 ToUnicodeEx(data
->lastVK
, scancode
, state
, &chr
, 1, 0, GetKeyboardLayout(0));
2773 uVirtKey
= MAKELONG(data
->lastVK
,chr
);
2776 uVirtKey
= data
->lastVK
;
2778 msg_count
= data
->immKbd
->pImeToAsciiEx(uVirtKey
, scancode
, state
, list
, 0, imc
);
2779 TRACE("%i messages generated\n",msg_count
);
2780 if (msg_count
&& msg_count
<= list_count
)
2783 LPTRANSMSG msgs
= (LPTRANSMSG
)((LPBYTE
)list
+ sizeof(DWORD
));
2785 for (i
= 0; i
< msg_count
; i
++)
2786 ImmInternalPostIMEMessage(data
, msgs
[i
].message
, msgs
[i
].wParam
, msgs
[i
].lParam
);
2788 else if (msg_count
> list_count
)
2789 ImmGenerateMessage(imc
);
2791 HeapFree(GetProcessHeap(),0,list
);
2793 data
->lastVK
= VK_PROCESSKEY
;
2795 return (msg_count
> 0);
2798 /***********************************************************************
2799 * ImmProcessKey(IMM32.@)
2800 * ( Undocumented, called from user32.dll )
2802 BOOL WINAPI
ImmProcessKey(HWND hwnd
, HKL hKL
, UINT vKey
, LPARAM lKeyData
, DWORD unknown
)
2804 InputContextData
*data
;
2805 HIMC imc
= ImmGetContext(hwnd
);
2808 TRACE("%p %p %x %x %x\n",hwnd
, hKL
, vKey
, (UINT
)lKeyData
, unknown
);
2815 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeProcessKey
)
2818 GetKeyboardState(state
);
2819 if (data
->immKbd
->pImeProcessKey(imc
, vKey
, lKeyData
, state
))
2821 data
->lastVK
= vKey
;
2825 data
->lastVK
= VK_PROCESSKEY
;
2829 /***********************************************************************
2830 * ImmDisableTextFrameService(IMM32.@)
2832 BOOL WINAPI
ImmDisableTextFrameService(DWORD idThread
)
2838 /***********************************************************************
2839 * ImmEnumInputContext(IMM32.@)
2842 BOOL WINAPI
ImmEnumInputContext(DWORD idThread
, IMCENUMPROC lpfn
, LPARAM lParam
)
2848 /***********************************************************************
2849 * ImmGetHotKey(IMM32.@)
2852 BOOL WINAPI
ImmGetHotKey(DWORD hotkey
, UINT
*modifiers
, UINT
*key
, HKL hkl
)
2854 FIXME("%x, %p, %p, %p: stub\n", hotkey
, modifiers
, key
, hkl
);
2860 * Window Proc for the Default IME window class
2862 static LRESULT WINAPI
DefIME_WindowProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
,
2870 case WM_IME_STARTCOMPOSITION
:
2871 case WM_IME_ENDCOMPOSITION
:
2872 case WM_IME_COMPOSITION
:
2873 case WM_IME_SETCONTEXT
:
2875 case WM_IME_CONTROL
:
2876 case WM_IME_COMPOSITIONFULL
:
2879 case WM_IME_REQUEST
:
2880 case WM_IME_KEYDOWN
:
2883 ImmHkl
*immHkl
= IMM_GetImmHkl(GetKeyboardLayout(0));
2885 return SendMessageW(immHkl
->UIWnd
,uMsg
,wParam
,lParam
);
2890 if ((uMsg
== WM_MSIME_RECONVERTOPTIONS
) ||
2891 (uMsg
== WM_MSIME_SERVICE
) ||
2892 (uMsg
== WM_MSIME_MOUSE
) ||
2893 (uMsg
== WM_MSIME_RECONVERTREQUEST
) ||
2894 (uMsg
== WM_MSIME_RECONVERT
) ||
2895 (uMsg
== WM_MSIME_QUERYPOSITION
) ||
2896 (uMsg
== WM_MSIME_DOCUMENTFEED
))
2898 ImmHkl
*immHkl
= IMM_GetImmHkl(GetKeyboardLayout(0));
2900 return SendMessageW(immHkl
->UIWnd
,uMsg
,wParam
,lParam
);
2904 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);