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"
37 WINE_DEFAULT_DEBUG_CHANNEL(imm
);
39 typedef struct tagIMCCInternal
45 #define MAKE_FUNCPTR(f) typeof(f) * p##f
46 typedef struct _tagImmHkl
{
51 WCHAR imeClassName
[17]; /* 16 character max */
54 /* Function Pointers */
55 MAKE_FUNCPTR(ImeInquire
);
56 MAKE_FUNCPTR(ImeConfigure
);
57 MAKE_FUNCPTR(ImeDestroy
);
58 MAKE_FUNCPTR(ImeEscape
);
59 MAKE_FUNCPTR(ImeSelect
);
60 MAKE_FUNCPTR(ImeSetActiveContext
);
61 MAKE_FUNCPTR(ImeToAsciiEx
);
62 MAKE_FUNCPTR(NotifyIME
);
63 MAKE_FUNCPTR(ImeRegisterWord
);
64 MAKE_FUNCPTR(ImeUnregisterWord
);
65 MAKE_FUNCPTR(ImeEnumRegisterWord
);
66 MAKE_FUNCPTR(ImeSetCompositionString
);
67 MAKE_FUNCPTR(ImeConversionList
);
68 MAKE_FUNCPTR(ImeProcessKey
);
69 MAKE_FUNCPTR(ImeGetRegisterWordStyle
);
70 MAKE_FUNCPTR(ImeGetImeMenuItems
);
74 typedef struct tagInputContextData
84 typedef struct _tagTRANSMSG
{
88 } TRANSMSG
, *LPTRANSMSG
;
90 typedef struct _tagIMMThreadData
{
95 static DWORD tlsIndex
= 0;
96 static struct list ImmHklList
= LIST_INIT(ImmHklList
);
99 static UINT WM_MSIME_SERVICE
;
100 static UINT WM_MSIME_RECONVERTOPTIONS
;
101 static UINT WM_MSIME_MOUSE
;
102 static UINT WM_MSIME_RECONVERTREQUEST
;
103 static UINT WM_MSIME_RECONVERT
;
104 static UINT WM_MSIME_QUERYPOSITION
;
105 static UINT WM_MSIME_DOCUMENTFEED
;
107 static const WCHAR szwWineIMCProperty
[] = {'W','i','n','e','I','m','m','H','I','M','C','P','r','o','p','e','r','t','y',0};
109 static const WCHAR szImeFileW
[] = {'I','m','e',' ','F','i','l','e',0};
110 static const WCHAR szLayoutTextW
[] = {'L','a','y','o','u','t',' ','T','e','x','t',0};
111 static const WCHAR szImeRegFmt
[] = {'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','s','\\','%','0','8','x',0};
114 #define is_himc_ime_unicode(p) (p->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE)
115 #define is_kbd_ime_unicode(p) (p->imeInfo.fdwProperty & IME_PROP_UNICODE)
117 static BOOL
IMM_DestroyContext(HIMC hIMC
);
119 static inline WCHAR
*strdupAtoW( const char *str
)
124 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
125 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
126 MultiByteToWideChar( CP_ACP
, 0, str
, -1, ret
, len
);
131 static inline CHAR
*strdupWtoA( const WCHAR
*str
)
136 DWORD len
= WideCharToMultiByte( CP_ACP
, 0, str
, -1, NULL
, 0, NULL
, NULL
);
137 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
)))
138 WideCharToMultiByte( CP_ACP
, 0, str
, -1, ret
, len
, NULL
, NULL
);
143 static DWORD
convert_candidatelist_WtoA(
144 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
148 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
149 if ( lpDst
&& dwBufLen
> 0 )
152 lpDst
->dwOffset
[0] = ret
;
155 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
157 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
159 if ( lpDst
&& dwBufLen
> 0 )
161 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
163 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1,
164 (LPSTR
)dest
, dwBufLen
, NULL
, NULL
);
166 if ( i
+ 1 < lpSrc
->dwCount
)
167 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(char);
168 dwBufLen
-= len
* sizeof(char);
171 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)src
, -1, NULL
, 0, NULL
, NULL
);
173 ret
+= len
* sizeof(char);
182 static DWORD
convert_candidatelist_AtoW(
183 LPCANDIDATELIST lpSrc
, LPCANDIDATELIST lpDst
, DWORD dwBufLen
)
187 ret
= FIELD_OFFSET( CANDIDATELIST
, dwOffset
[lpSrc
->dwCount
] );
188 if ( lpDst
&& dwBufLen
> 0 )
191 lpDst
->dwOffset
[0] = ret
;
194 for ( i
= 0; i
< lpSrc
->dwCount
; i
++)
196 LPBYTE src
= (LPBYTE
)lpSrc
+ lpSrc
->dwOffset
[i
];
198 if ( lpDst
&& dwBufLen
> 0 )
200 LPBYTE dest
= (LPBYTE
)lpDst
+ lpDst
->dwOffset
[i
];
202 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1,
203 (LPWSTR
)dest
, dwBufLen
);
205 if ( i
+ 1 < lpSrc
->dwCount
)
206 lpDst
->dwOffset
[i
+1] = lpDst
->dwOffset
[i
] + len
* sizeof(WCHAR
);
207 dwBufLen
-= len
* sizeof(WCHAR
);
210 len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1, NULL
, 0);
212 ret
+= len
* sizeof(WCHAR
);
221 static IMMThreadData
* IMM_GetThreadData(void)
223 return (IMMThreadData
*)TlsGetValue(tlsIndex
);
226 static void IMM_InitThreadData(void)
228 IMMThreadData
* data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
229 sizeof(IMMThreadData
));
230 TlsSetValue(tlsIndex
,data
);
232 TRACE("Thread Data Created\n");
235 static void IMM_FreeThreadData(void)
237 IMMThreadData
* data
= TlsGetValue(tlsIndex
);
238 IMM_DestroyContext(data
->defaultContext
);
239 DestroyWindow(data
->hwndDefault
);
240 HeapFree(GetProcessHeap(),0,data
);
241 TRACE("Thread Data Destroyed\n");
244 static HMODULE
LoadDefaultWineIME(void)
246 char buffer
[MAX_PATH
], libname
[32], *name
, *next
;
250 TRACE("Attempting to fall back to wine default IME\n");
252 strcpy( buffer
, "x11" ); /* default value */
253 /* @@ Wine registry key: HKCU\Software\Wine\Drivers */
254 if (!RegOpenKeyA( HKEY_CURRENT_USER
, "Software\\Wine\\Drivers", &hkey
))
256 DWORD type
, count
= sizeof(buffer
);
257 RegQueryValueExA( hkey
, "Ime", 0, &type
, (LPBYTE
) buffer
, &count
);
264 next
= strchr( name
, ',' );
265 if (next
) *next
++ = 0;
267 snprintf( libname
, sizeof(libname
), "wine%s.drv", name
);
268 if ((module
= LoadLibraryA( libname
)) != 0) break;
275 /* ImmHkl loading and freeing */
276 #define LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}
277 static ImmHkl
*IMM_GetImmHkl(HKL hkl
)
280 WCHAR filename
[MAX_PATH
];
282 TRACE("Seeking ime for keyboard 0x%x\n",(unsigned)hkl
);
284 LIST_FOR_EACH_ENTRY(ptr
, &ImmHklList
, ImmHkl
, entry
)
289 /* not found... create it */
291 ptr
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ImmHkl
));
294 if (ImmGetIMEFileNameW(hkl
, filename
, MAX_PATH
)) ptr
->hIME
= LoadLibraryW(filename
);
296 ptr
->hIME
= LoadDefaultWineIME();
299 LOAD_FUNCPTR(ImeInquire
);
300 if (!ptr
->pImeInquire
|| !ptr
->pImeInquire(&ptr
->imeInfo
, ptr
->imeClassName
, NULL
))
302 FreeLibrary(ptr
->hIME
);
307 LOAD_FUNCPTR(ImeDestroy
);
308 LOAD_FUNCPTR(ImeSelect
);
309 if (!ptr
->pImeSelect
|| !ptr
->pImeDestroy
)
311 FreeLibrary(ptr
->hIME
);
316 LOAD_FUNCPTR(ImeConfigure
);
317 LOAD_FUNCPTR(ImeEscape
);
318 LOAD_FUNCPTR(ImeSetActiveContext
);
319 LOAD_FUNCPTR(ImeToAsciiEx
);
320 LOAD_FUNCPTR(NotifyIME
);
321 LOAD_FUNCPTR(ImeRegisterWord
);
322 LOAD_FUNCPTR(ImeUnregisterWord
);
323 LOAD_FUNCPTR(ImeEnumRegisterWord
);
324 LOAD_FUNCPTR(ImeSetCompositionString
);
325 LOAD_FUNCPTR(ImeConversionList
);
326 LOAD_FUNCPTR(ImeProcessKey
);
327 LOAD_FUNCPTR(ImeGetRegisterWordStyle
);
328 LOAD_FUNCPTR(ImeGetImeMenuItems
);
329 /* make sure our classname is WCHAR */
330 if (!is_kbd_ime_unicode(ptr
))
333 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ptr
->imeClassName
,
335 lstrcpyW(ptr
->imeClassName
, bufW
);
340 list_add_head(&ImmHklList
,&ptr
->entry
);
346 static void IMM_FreeAllImmHkl(void)
348 ImmHkl
*ptr
,*cursor2
;
350 LIST_FOR_EACH_ENTRY_SAFE(ptr
, cursor2
, &ImmHklList
, ImmHkl
, entry
)
352 list_remove(&ptr
->entry
);
356 FreeLibrary(ptr
->hIME
);
358 HeapFree(GetProcessHeap(),0,ptr
);
362 static void IMM_RegisterMessages(void)
364 WM_MSIME_SERVICE
= RegisterWindowMessageA("MSIMEService");
365 WM_MSIME_RECONVERTOPTIONS
= RegisterWindowMessageA("MSIMEReconvertOptions");
366 WM_MSIME_MOUSE
= RegisterWindowMessageA("MSIMEMouseOperation");
367 WM_MSIME_RECONVERTREQUEST
= RegisterWindowMessageA("MSIMEReconvertRequest");
368 WM_MSIME_RECONVERT
= RegisterWindowMessageA("MSIMEReconvert");
369 WM_MSIME_QUERYPOSITION
= RegisterWindowMessageA("MSIMEQueryPosition");
370 WM_MSIME_DOCUMENTFEED
= RegisterWindowMessageA("MSIMEDocumentFeed");
373 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID lpReserved
)
375 TRACE("%p, %x, %p\n",hInstDLL
,fdwReason
,lpReserved
);
378 case DLL_PROCESS_ATTACH
:
379 IMM_RegisterMessages();
380 tlsIndex
= TlsAlloc();
381 IMM_InitThreadData();
383 case DLL_THREAD_ATTACH
:
384 IMM_InitThreadData();
386 case DLL_THREAD_DETACH
:
387 IMM_FreeThreadData();
389 case DLL_PROCESS_DETACH
:
390 IMM_FreeThreadData();
398 /* for posting messages as the IME */
399 static void ImmInternalPostIMEMessage(InputContextData
*data
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
401 HWND target
= GetFocus();
403 PostMessageW(data
->IMC
.hWnd
,msg
,wParam
,lParam
);
405 PostMessageW(target
, msg
, wParam
, lParam
);
408 static LRESULT
ImmInternalSendIMENotify(InputContextData
*data
, WPARAM notify
, LPARAM lParam
)
412 target
= data
->IMC
.hWnd
;
413 if (!target
) target
= GetFocus();
416 return SendMessageW(target
, WM_IME_NOTIFY
, notify
, lParam
);
421 static HIMCC
ImmCreateBlankCompStr(void)
424 LPCOMPOSITIONSTRING ptr
;
425 rc
= ImmCreateIMCC(sizeof(COMPOSITIONSTRING
));
426 ptr
= ImmLockIMCC(rc
);
427 memset(ptr
,0,sizeof(COMPOSITIONSTRING
));
428 ptr
->dwSize
= sizeof(COMPOSITIONSTRING
);
433 /***********************************************************************
434 * ImmAssociateContext (IMM32.@)
436 HIMC WINAPI
ImmAssociateContext(HWND hWnd
, HIMC hIMC
)
439 InputContextData
*data
= (InputContextData
*)hIMC
;
441 TRACE("(%p, %p):\n", hWnd
, hIMC
);
443 if (!IMM_GetThreadData()->defaultContext
)
444 IMM_GetThreadData()->defaultContext
= ImmCreateContext();
447 * If already associated just return
449 if (hIMC
&& data
->IMC
.hWnd
== hWnd
)
454 old
= RemovePropW(hWnd
,szwWineIMCProperty
);
457 old
= IMM_GetThreadData()->defaultContext
;
458 else if (old
== (HIMC
)-1)
461 if (hIMC
!= IMM_GetThreadData()->defaultContext
)
463 if (hIMC
== NULL
) /* Meaning disable imm for that window*/
464 SetPropW(hWnd
,szwWineIMCProperty
,(HANDLE
)-1);
466 SetPropW(hWnd
,szwWineIMCProperty
,hIMC
);
471 InputContextData
*old_data
= (InputContextData
*)old
;
472 if (old_data
->IMC
.hWnd
== hWnd
)
473 old_data
->IMC
.hWnd
= NULL
;
480 if (IsWindow(data
->IMC
.hWnd
))
483 * Post a message that your context is switching
485 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, FALSE
, ISC_SHOWUIALL
);
488 data
->IMC
.hWnd
= hWnd
;
490 if (IsWindow(data
->IMC
.hWnd
))
493 * Post a message that your context is switching
495 SendMessageW(data
->IMC
.hWnd
, WM_IME_SETCONTEXT
, TRUE
, ISC_SHOWUIALL
);
501 /***********************************************************************
502 * ImmAssociateContextEx (IMM32.@)
504 BOOL WINAPI
ImmAssociateContextEx(HWND hWnd
, HIMC hIMC
, DWORD dwFlags
)
506 FIXME("(%p, %p, %d): stub\n", hWnd
, hIMC
, dwFlags
);
507 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
511 /***********************************************************************
512 * ImmConfigureIMEA (IMM32.@)
514 BOOL WINAPI
ImmConfigureIMEA(
515 HKL hKL
, HWND hWnd
, DWORD dwMode
, LPVOID lpData
)
517 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
519 TRACE("(%p, %p, %d, %p):\n", hKL
, hWnd
, dwMode
, lpData
);
521 if (dwMode
== IME_CONFIG_REGISTERWORD
&& !lpData
)
524 if (immHkl
->hIME
&& immHkl
->pImeConfigure
)
526 if (dwMode
!= IME_CONFIG_REGISTERWORD
|| !is_kbd_ime_unicode(immHkl
))
527 return immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,lpData
);
531 REGISTERWORDA
*rwa
= (REGISTERWORDA
*)lpData
;
534 rww
.lpReading
= strdupAtoW(rwa
->lpReading
);
535 rww
.lpWord
= strdupAtoW(rwa
->lpWord
);
536 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rww
);
537 HeapFree(GetProcessHeap(),0,rww
.lpReading
);
538 HeapFree(GetProcessHeap(),0,rww
.lpWord
);
546 /***********************************************************************
547 * ImmConfigureIMEW (IMM32.@)
549 BOOL WINAPI
ImmConfigureIMEW(
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
);
565 REGISTERWORDW
*rww
= (REGISTERWORDW
*)lpData
;
569 rwa
.lpReading
= strdupWtoA(rww
->lpReading
);
570 rwa
.lpWord
= strdupWtoA(rww
->lpWord
);
571 rc
= immHkl
->pImeConfigure(hKL
,hWnd
,dwMode
,&rwa
);
572 HeapFree(GetProcessHeap(),0,rwa
.lpReading
);
573 HeapFree(GetProcessHeap(),0,rwa
.lpWord
);
581 /***********************************************************************
582 * ImmCreateContext (IMM32.@)
584 HIMC WINAPI
ImmCreateContext(void)
586 InputContextData
*new_context
;
590 new_context
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(InputContextData
));
593 new_context
->immKbd
= IMM_GetImmHkl(GetKeyboardLayout(0));
595 if (!new_context
->immKbd
->hIME
)
597 TRACE("IME dll could not be loaded\n");
598 HeapFree(GetProcessHeap(),0,new_context
);
602 /* the HIMCCs are never NULL */
603 new_context
->IMC
.hCompStr
= ImmCreateBlankCompStr();
604 new_context
->IMC
.hMsgBuf
= ImmCreateIMCC(0);
605 new_context
->IMC
.hCandInfo
= ImmCreateIMCC(sizeof(CANDIDATEINFO
));
606 ci
= ImmLockIMCC(new_context
->IMC
.hCandInfo
);
607 memset(ci
,0,sizeof(CANDIDATEINFO
));
608 ci
->dwSize
= sizeof(CANDIDATEINFO
);
609 ImmUnlockIMCC(new_context
->IMC
.hCandInfo
);
610 new_context
->IMC
.hGuideLine
= ImmCreateIMCC(sizeof(GUIDELINE
));
611 gl
= ImmLockIMCC(new_context
->IMC
.hGuideLine
);
612 memset(gl
,0,sizeof(GUIDELINE
));
613 gl
->dwSize
= sizeof(GUIDELINE
);
614 ImmUnlockIMCC(new_context
->IMC
.hGuideLine
);
616 /* Initialize the IME Private */
617 new_context
->IMC
.hPrivate
= ImmCreateIMCC(new_context
->immKbd
->imeInfo
.dwPrivateDataSize
);
619 if (!new_context
->immKbd
->pImeSelect(new_context
, TRUE
))
621 TRACE("Selection of IME failed\n");
622 IMM_DestroyContext(new_context
);
626 new_context
->immKbd
->uSelected
++;
627 TRACE("Created context 0x%x\n",(UINT
)new_context
);
632 static BOOL
IMM_DestroyContext(HIMC hIMC
)
634 InputContextData
*data
= (InputContextData
*)hIMC
;
636 TRACE("Destroying %p\n",hIMC
);
640 data
->immKbd
->uSelected
--;
641 data
->immKbd
->pImeSelect(hIMC
, FALSE
);
643 if (IMM_GetThreadData()->hwndDefault
== data
->imeWnd
)
644 IMM_GetThreadData()->hwndDefault
= NULL
;
645 DestroyWindow(data
->imeWnd
);
647 ImmDestroyIMCC(data
->IMC
.hCompStr
);
648 ImmDestroyIMCC(data
->IMC
.hCandInfo
);
649 ImmDestroyIMCC(data
->IMC
.hGuideLine
);
650 ImmDestroyIMCC(data
->IMC
.hPrivate
);
651 ImmDestroyIMCC(data
->IMC
.hMsgBuf
);
653 HeapFree(GetProcessHeap(),0,data
);
658 /***********************************************************************
659 * ImmDestroyContext (IMM32.@)
661 BOOL WINAPI
ImmDestroyContext(HIMC hIMC
)
663 if (hIMC
!= IMM_GetThreadData()->defaultContext
)
664 return IMM_DestroyContext(hIMC
);
669 /***********************************************************************
670 * ImmDisableIME (IMM32.@)
672 BOOL WINAPI
ImmDisableIME(DWORD idThread
)
674 FIXME("(%d): stub\n", idThread
);
678 /***********************************************************************
679 * ImmEnumRegisterWordA (IMM32.@)
681 UINT WINAPI
ImmEnumRegisterWordA(
682 HKL hKL
, REGISTERWORDENUMPROCA lpfnEnumProc
,
683 LPCSTR lpszReading
, DWORD dwStyle
,
684 LPCSTR lpszRegister
, LPVOID lpData
)
686 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
687 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
688 debugstr_a(lpszReading
), dwStyle
, debugstr_a(lpszRegister
), lpData
);
689 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
691 if (!is_kbd_ime_unicode(immHkl
))
692 return immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
693 (LPCWSTR
)lpszReading
, dwStyle
, (LPCWSTR
)lpszRegister
, lpData
);
696 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
697 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
700 rc
= immHkl
->pImeEnumRegisterWord((REGISTERWORDENUMPROCW
)lpfnEnumProc
,
701 lpszwReading
, dwStyle
, lpszwRegister
,
704 HeapFree(GetProcessHeap(),0,lpszwReading
);
705 HeapFree(GetProcessHeap(),0,lpszwRegister
);
713 /***********************************************************************
714 * ImmEnumRegisterWordW (IMM32.@)
716 UINT WINAPI
ImmEnumRegisterWordW(
717 HKL hKL
, REGISTERWORDENUMPROCW lpfnEnumProc
,
718 LPCWSTR lpszReading
, DWORD dwStyle
,
719 LPCWSTR lpszRegister
, LPVOID lpData
)
721 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
722 TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL
, lpfnEnumProc
,
723 debugstr_w(lpszReading
), dwStyle
, debugstr_w(lpszRegister
), lpData
);
724 if (immHkl
->hIME
&& immHkl
->pImeEnumRegisterWord
)
726 if (is_kbd_ime_unicode(immHkl
))
727 return immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, lpszReading
, dwStyle
,
728 lpszRegister
, lpData
);
731 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
732 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
735 rc
= immHkl
->pImeEnumRegisterWord(lpfnEnumProc
, (LPCWSTR
)lpszaReading
,
736 dwStyle
, (LPCWSTR
)lpszaRegister
, lpData
);
738 HeapFree(GetProcessHeap(),0,lpszaReading
);
739 HeapFree(GetProcessHeap(),0,lpszaRegister
);
747 /***********************************************************************
748 * ImmEscapeA (IMM32.@)
750 LRESULT WINAPI
ImmEscapeA(
752 UINT uEscape
, LPVOID lpData
)
754 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
755 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
757 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
759 if (!is_kbd_ime_unicode(immHkl
))
760 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
763 FIXME("A procedure called with W ime back end\n");
764 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
772 /***********************************************************************
773 * ImmEscapeW (IMM32.@)
775 LRESULT WINAPI
ImmEscapeW(
777 UINT uEscape
, LPVOID lpData
)
779 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
780 TRACE("(%p, %p, %d, %p):\n", hKL
, hIMC
, uEscape
, lpData
);
782 if (immHkl
->hIME
&& immHkl
->pImeEscape
)
784 if (is_kbd_ime_unicode(immHkl
))
785 return immHkl
->pImeEscape(hIMC
,uEscape
,lpData
);
788 FIXME("W procedure called with A ime back end\n");
789 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
797 /***********************************************************************
798 * ImmGetCandidateListA (IMM32.@)
800 DWORD WINAPI
ImmGetCandidateListA(
801 HIMC hIMC
, DWORD dwIndex
,
802 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
804 InputContextData
*data
= (InputContextData
*)hIMC
;
805 LPCANDIDATEINFO candinfo
;
806 LPCANDIDATELIST candlist
;
809 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
811 if (!data
|| !data
->IMC
.hCandInfo
)
814 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
815 if ( dwIndex
>= candinfo
->dwCount
||
816 dwIndex
>= (sizeof(candinfo
->dwOffset
) / sizeof(DWORD
)) )
819 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
820 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
823 if ( !is_himc_ime_unicode(data
) )
825 ret
= candlist
->dwSize
;
826 if ( lpCandList
&& dwBufLen
>= ret
)
827 memcpy(lpCandList
, candlist
, ret
);
830 ret
= convert_candidatelist_WtoA( candlist
, lpCandList
, dwBufLen
);
833 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
837 /***********************************************************************
838 * ImmGetCandidateListCountA (IMM32.@)
840 DWORD WINAPI
ImmGetCandidateListCountA(
841 HIMC hIMC
, LPDWORD lpdwListCount
)
843 InputContextData
*data
= (InputContextData
*)hIMC
;
844 LPCANDIDATEINFO candinfo
;
847 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
849 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
852 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
854 *lpdwListCount
= count
= candinfo
->dwCount
;
856 if ( !is_himc_ime_unicode(data
) )
857 ret
= candinfo
->dwSize
;
860 ret
= sizeof(CANDIDATEINFO
);
862 ret
+= ImmGetCandidateListA(hIMC
, count
, NULL
, 0);
865 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
869 /***********************************************************************
870 * ImmGetCandidateListCountW (IMM32.@)
872 DWORD WINAPI
ImmGetCandidateListCountW(
873 HIMC hIMC
, LPDWORD lpdwListCount
)
875 InputContextData
*data
= (InputContextData
*)hIMC
;
876 LPCANDIDATEINFO candinfo
;
879 TRACE("%p, %p\n", hIMC
, lpdwListCount
);
881 if (!data
|| !lpdwListCount
|| !data
->IMC
.hCandInfo
)
884 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
886 *lpdwListCount
= count
= candinfo
->dwCount
;
888 if ( is_himc_ime_unicode(data
) )
889 ret
= candinfo
->dwSize
;
892 ret
= sizeof(CANDIDATEINFO
);
894 ret
+= ImmGetCandidateListW(hIMC
, count
, NULL
, 0);
897 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
901 /***********************************************************************
902 * ImmGetCandidateListW (IMM32.@)
904 DWORD WINAPI
ImmGetCandidateListW(
905 HIMC hIMC
, DWORD dwIndex
,
906 LPCANDIDATELIST lpCandList
, DWORD dwBufLen
)
908 InputContextData
*data
= (InputContextData
*)hIMC
;
909 LPCANDIDATEINFO candinfo
;
910 LPCANDIDATELIST candlist
;
913 TRACE("%p, %d, %p, %d\n", hIMC
, dwIndex
, lpCandList
, dwBufLen
);
915 if (!data
|| !data
->IMC
.hCandInfo
)
918 candinfo
= ImmLockIMCC(data
->IMC
.hCandInfo
);
919 if ( dwIndex
>= candinfo
->dwCount
||
920 dwIndex
>= (sizeof(candinfo
->dwOffset
) / sizeof(DWORD
)) )
923 candlist
= (LPCANDIDATELIST
)((LPBYTE
)candinfo
+ candinfo
->dwOffset
[dwIndex
]);
924 if ( !candlist
->dwSize
|| !candlist
->dwCount
)
927 if ( is_himc_ime_unicode(data
) )
929 ret
= candlist
->dwSize
;
930 if ( lpCandList
&& dwBufLen
>= ret
)
931 memcpy(lpCandList
, candlist
, ret
);
934 ret
= convert_candidatelist_AtoW( candlist
, lpCandList
, dwBufLen
);
937 ImmUnlockIMCC(data
->IMC
.hCandInfo
);
941 /***********************************************************************
942 * ImmGetCandidateWindow (IMM32.@)
944 BOOL WINAPI
ImmGetCandidateWindow(
945 HIMC hIMC
, DWORD dwIndex
, LPCANDIDATEFORM lpCandidate
)
947 InputContextData
*data
= (InputContextData
*)hIMC
;
949 TRACE("%p, %d, %p\n", hIMC
, dwIndex
, lpCandidate
);
951 if (!data
|| !lpCandidate
)
954 if ( dwIndex
>= (sizeof(data
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
)) )
957 *lpCandidate
= data
->IMC
.cfCandForm
[dwIndex
];
962 /***********************************************************************
963 * ImmGetCompositionFontA (IMM32.@)
965 BOOL WINAPI
ImmGetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
970 TRACE("(%p, %p):\n", hIMC
, lplf
);
972 rc
= ImmGetCompositionFontW(hIMC
,&lfW
);
976 memcpy(lplf
,&lfW
,sizeof(LOGFONTA
));
977 WideCharToMultiByte(CP_ACP
, 0, lfW
.lfFaceName
, -1, lplf
->lfFaceName
,
978 LF_FACESIZE
, NULL
, NULL
);
982 /***********************************************************************
983 * ImmGetCompositionFontW (IMM32.@)
985 BOOL WINAPI
ImmGetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
987 InputContextData
*data
= (InputContextData
*)hIMC
;
989 TRACE("(%p, %p):\n", hIMC
, lplf
);
994 *lplf
= data
->IMC
.lfFont
.W
;
1000 /* Helpers for the GetCompositionString functions */
1002 static INT
CopyCompStringIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE target
, INT tlen
,
1007 if (is_himc_ime_unicode(data
) && !unicode
)
1008 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)source
, slen
, (LPSTR
)target
, tlen
, NULL
, NULL
);
1009 else if (!is_himc_ime_unicode(data
) && unicode
)
1010 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)source
, slen
, (LPWSTR
)target
, tlen
) * sizeof(WCHAR
);
1013 int dlen
= (unicode
)?sizeof(WCHAR
):sizeof(CHAR
);
1014 memcpy( target
, source
, min(slen
,tlen
)*dlen
);
1021 static INT
CopyCompAttrIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
, INT sslen
,
1022 LPBYTE target
, INT tlen
, BOOL unicode
)
1026 if (is_himc_ime_unicode(data
) && !unicode
)
1028 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, sslen
, NULL
, 0, NULL
, NULL
);
1031 const BYTE
*src
= source
;
1032 LPBYTE dst
= target
;
1033 int i
, j
= 0, k
= 0;
1037 for (i
= 0; i
< sslen
; ++i
)
1041 len
= WideCharToMultiByte(CP_ACP
, 0, (LPCWSTR
)ssource
+ i
, 1,
1042 NULL
, 0, NULL
, NULL
);
1043 for (; len
> 0; --len
)
1056 else if (!is_himc_ime_unicode(data
) && unicode
)
1058 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, sslen
, NULL
, 0);
1061 const BYTE
*src
= source
;
1062 LPBYTE dst
= target
;
1067 for (i
= 0; i
< sslen
; ++i
)
1069 if (IsDBCSLeadByte(((LPSTR
)ssource
)[i
]))
1082 memcpy( target
, source
, min(slen
,tlen
));
1089 static INT
CopyCompClauseIMEtoClient(InputContextData
*data
, LPBYTE source
, INT slen
, LPBYTE ssource
, INT sslen
,
1090 LPBYTE target
, INT tlen
, BOOL unicode
)
1094 if (is_himc_ime_unicode(data
) && !unicode
)
1102 tlen
/= sizeof (DWORD
);
1103 for (i
= 0; i
< tlen
; ++i
)
1105 ((DWORD
*)target
)[i
] = WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
,
1106 ((DWORD
*)source
)[i
],
1110 rc
= sizeof (DWORD
) * i
;
1115 else if (!is_himc_ime_unicode(data
) && unicode
)
1123 tlen
/= sizeof (DWORD
);
1124 for (i
= 0; i
< tlen
; ++i
)
1126 ((DWORD
*)target
)[i
] = MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
,
1127 ((DWORD
*)source
)[i
],
1130 rc
= sizeof (DWORD
) * i
;
1137 memcpy( target
, source
, min(slen
,tlen
));
1144 static INT
CopyCompOffsetIMEtoClient(InputContextData
*data
, DWORD offset
, LPBYTE ssource
, BOOL unicode
)
1148 if (is_himc_ime_unicode(data
) && !unicode
)
1150 rc
= WideCharToMultiByte(CP_ACP
, 0, (LPWSTR
)ssource
, offset
, NULL
, 0, NULL
, NULL
);
1152 else if (!is_himc_ime_unicode(data
) && unicode
)
1154 rc
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)ssource
, offset
, NULL
, 0);
1162 static LONG
ImmGetCompositionStringT( HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
,
1163 DWORD dwBufLen
, BOOL unicode
)
1166 InputContextData
*data
= (InputContextData
*)hIMC
;
1167 LPCOMPOSITIONSTRING compstr
;
1170 TRACE("(%p, 0x%x, %p, %d)\n", hIMC
, dwIndex
, lpBuf
, dwBufLen
);
1175 if (!data
->IMC
.hCompStr
)
1178 compdata
= ImmLockIMCC(data
->IMC
.hCompStr
);
1179 compstr
= (LPCOMPOSITIONSTRING
)compdata
;
1184 TRACE("GCS_RESULTSTR\n");
1185 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultStrOffset
, compstr
->dwResultStrLen
, lpBuf
, dwBufLen
, unicode
);
1188 TRACE("GCS_COMPSTR\n");
1189 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
, lpBuf
, dwBufLen
, unicode
);
1192 TRACE("GCS_COMPATTR\n");
1193 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompAttrOffset
, compstr
->dwCompAttrLen
,
1194 compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
,
1195 lpBuf
, dwBufLen
, unicode
);
1197 case GCS_COMPCLAUSE
:
1198 TRACE("GCS_COMPCLAUSE\n");
1199 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompClauseOffset
,compstr
->dwCompClauseLen
,
1200 compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
,
1201 lpBuf
, dwBufLen
, unicode
);
1203 case GCS_RESULTCLAUSE
:
1204 TRACE("GCS_RESULTCLAUSE\n");
1205 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultClauseOffset
,compstr
->dwResultClauseLen
,
1206 compdata
+ compstr
->dwResultStrOffset
, compstr
->dwResultStrLen
,
1207 lpBuf
, dwBufLen
, unicode
);
1209 case GCS_RESULTREADSTR
:
1210 TRACE("GCS_RESULTREADSTR\n");
1211 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwResultReadStrOffset
, compstr
->dwResultReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1213 case GCS_RESULTREADCLAUSE
:
1214 TRACE("GCS_RESULTREADCLAUSE\n");
1215 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwResultReadClauseOffset
,compstr
->dwResultReadClauseLen
,
1216 compdata
+ compstr
->dwResultStrOffset
, compstr
->dwResultStrLen
,
1217 lpBuf
, dwBufLen
, unicode
);
1219 case GCS_COMPREADSTR
:
1220 TRACE("GCS_COMPREADSTR\n");
1221 rc
= CopyCompStringIMEtoClient(data
, compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
, lpBuf
, dwBufLen
, unicode
);
1223 case GCS_COMPREADATTR
:
1224 TRACE("GCS_COMPREADATTR\n");
1225 rc
= CopyCompAttrIMEtoClient(data
, compdata
+ compstr
->dwCompReadAttrOffset
, compstr
->dwCompReadAttrLen
,
1226 compdata
+ compstr
->dwCompReadStrOffset
, compstr
->dwCompReadStrLen
,
1227 lpBuf
, dwBufLen
, unicode
);
1229 case GCS_COMPREADCLAUSE
:
1230 TRACE("GCS_COMPREADCLAUSE\n");
1231 rc
= CopyCompClauseIMEtoClient(data
, compdata
+ compstr
->dwCompReadClauseOffset
,compstr
->dwCompReadClauseLen
,
1232 compdata
+ compstr
->dwCompStrOffset
, compstr
->dwCompStrLen
,
1233 lpBuf
, dwBufLen
, unicode
);
1236 TRACE("GCS_CURSORPOS\n");
1237 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwCursorPos
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1239 case GCS_DELTASTART
:
1240 TRACE("GCS_DELTASTART\n");
1241 rc
= CopyCompOffsetIMEtoClient(data
, compstr
->dwDeltaStart
, compdata
+ compstr
->dwCompStrOffset
, unicode
);
1244 FIXME("Unhandled index 0x%x\n",dwIndex
);
1248 ImmUnlockIMCC(data
->IMC
.hCompStr
);
1253 /***********************************************************************
1254 * ImmGetCompositionStringA (IMM32.@)
1256 LONG WINAPI
ImmGetCompositionStringA(
1257 HIMC hIMC
, DWORD dwIndex
, LPVOID lpBuf
, DWORD dwBufLen
)
1259 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, FALSE
);
1263 /***********************************************************************
1264 * ImmGetCompositionStringW (IMM32.@)
1266 LONG WINAPI
ImmGetCompositionStringW(
1267 HIMC hIMC
, DWORD dwIndex
,
1268 LPVOID lpBuf
, DWORD dwBufLen
)
1270 return ImmGetCompositionStringT(hIMC
, dwIndex
, lpBuf
, dwBufLen
, TRUE
);
1273 /***********************************************************************
1274 * ImmGetCompositionWindow (IMM32.@)
1276 BOOL WINAPI
ImmGetCompositionWindow(HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
1278 InputContextData
*data
= (InputContextData
*)hIMC
;
1280 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
1285 *lpCompForm
= data
->IMC
.cfCompForm
;
1289 /***********************************************************************
1290 * ImmGetContext (IMM32.@)
1293 HIMC WINAPI
ImmGetContext(HWND hWnd
)
1297 TRACE("%p\n", hWnd
);
1298 if (!IMM_GetThreadData()->defaultContext
)
1299 IMM_GetThreadData()->defaultContext
= ImmCreateContext();
1301 rc
= GetPropW(hWnd
,szwWineIMCProperty
);
1304 else if (rc
== NULL
)
1305 rc
= IMM_GetThreadData()->defaultContext
;
1309 InputContextData
*data
= (InputContextData
*)rc
;
1310 data
->IMC
.hWnd
= hWnd
;
1312 TRACE("returning %p\n", rc
);
1317 /***********************************************************************
1318 * ImmGetConversionListA (IMM32.@)
1320 DWORD WINAPI
ImmGetConversionListA(
1322 LPCSTR pSrc
, LPCANDIDATELIST lpDst
,
1323 DWORD dwBufLen
, UINT uFlag
)
1325 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1326 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_a(pSrc
), lpDst
,
1328 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1330 if (!is_kbd_ime_unicode(immHkl
))
1331 return immHkl
->pImeConversionList(hIMC
,(LPCWSTR
)pSrc
,lpDst
,dwBufLen
,uFlag
);
1334 LPCANDIDATELIST lpwDst
;
1336 LPWSTR pwSrc
= strdupAtoW(pSrc
);
1338 len
= immHkl
->pImeConversionList(hIMC
, pwSrc
, NULL
, 0, uFlag
);
1339 lpwDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1342 immHkl
->pImeConversionList(hIMC
, pwSrc
, lpwDst
, len
, uFlag
);
1343 ret
= convert_candidatelist_WtoA( lpwDst
, lpDst
, dwBufLen
);
1344 HeapFree(GetProcessHeap(), 0, lpwDst
);
1346 HeapFree(GetProcessHeap(), 0, pwSrc
);
1355 /***********************************************************************
1356 * ImmGetConversionListW (IMM32.@)
1358 DWORD WINAPI
ImmGetConversionListW(
1360 LPCWSTR pSrc
, LPCANDIDATELIST lpDst
,
1361 DWORD dwBufLen
, UINT uFlag
)
1363 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1364 TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL
, hIMC
, debugstr_w(pSrc
), lpDst
,
1366 if (immHkl
->hIME
&& immHkl
->pImeConversionList
)
1368 if (is_kbd_ime_unicode(immHkl
))
1369 return immHkl
->pImeConversionList(hIMC
,pSrc
,lpDst
,dwBufLen
,uFlag
);
1372 LPCANDIDATELIST lpaDst
;
1374 LPSTR paSrc
= strdupWtoA(pSrc
);
1376 len
= immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, NULL
, 0, uFlag
);
1377 lpaDst
= HeapAlloc(GetProcessHeap(), 0, len
);
1380 immHkl
->pImeConversionList(hIMC
, (LPCWSTR
)paSrc
, lpaDst
, len
, uFlag
);
1381 ret
= convert_candidatelist_AtoW( lpaDst
, lpDst
, dwBufLen
);
1382 HeapFree(GetProcessHeap(), 0, lpaDst
);
1384 HeapFree(GetProcessHeap(), 0, paSrc
);
1393 /***********************************************************************
1394 * ImmGetConversionStatus (IMM32.@)
1396 BOOL WINAPI
ImmGetConversionStatus(
1397 HIMC hIMC
, LPDWORD lpfdwConversion
, LPDWORD lpfdwSentence
)
1399 InputContextData
*data
= (InputContextData
*)hIMC
;
1401 TRACE("%p %p %p\n", hIMC
, lpfdwConversion
, lpfdwSentence
);
1406 if (lpfdwConversion
)
1407 *lpfdwConversion
= data
->IMC
.fdwConversion
;
1409 *lpfdwSentence
= data
->IMC
.fdwSentence
;
1414 /***********************************************************************
1415 * ImmGetDefaultIMEWnd (IMM32.@)
1417 HWND WINAPI
ImmGetDefaultIMEWnd(HWND hWnd
)
1419 TRACE("Default is %x\n",(unsigned)IMM_GetThreadData()->hwndDefault
);
1420 return IMM_GetThreadData()->hwndDefault
;
1423 /***********************************************************************
1424 * ImmGetDescriptionA (IMM32.@)
1426 UINT WINAPI
ImmGetDescriptionA(
1427 HKL hKL
, LPSTR lpszDescription
, UINT uBufLen
)
1432 TRACE("%p %p %d\n", hKL
, lpszDescription
, uBufLen
);
1434 /* find out how many characters in the unicode buffer */
1435 len
= ImmGetDescriptionW( hKL
, NULL
, 0 );
1437 /* allocate a buffer of that size */
1438 buf
= HeapAlloc( GetProcessHeap(), 0, (len
+ 1) * sizeof (WCHAR
) );
1442 /* fetch the unicode buffer */
1443 len
= ImmGetDescriptionW( hKL
, buf
, len
+ 1 );
1445 /* convert it back to ASCII */
1446 len
= WideCharToMultiByte( CP_ACP
, 0, buf
, len
+ 1,
1447 lpszDescription
, uBufLen
, NULL
, NULL
);
1449 HeapFree( GetProcessHeap(), 0, buf
);
1454 /***********************************************************************
1455 * ImmGetDescriptionW (IMM32.@)
1457 UINT WINAPI
ImmGetDescriptionW(HKL hKL
, LPWSTR lpszDescription
, UINT uBufLen
)
1459 static const WCHAR name
[] = { 'W','i','n','e',' ','X','I','M',0 };
1461 FIXME("(%p, %p, %d): semi stub\n", hKL
, lpszDescription
, uBufLen
);
1463 if (!uBufLen
) return lstrlenW( name
);
1464 lstrcpynW( lpszDescription
, name
, uBufLen
);
1465 return lstrlenW( lpszDescription
);
1468 /***********************************************************************
1469 * ImmGetGuideLineA (IMM32.@)
1471 DWORD WINAPI
ImmGetGuideLineA(
1472 HIMC hIMC
, DWORD dwIndex
, LPSTR lpBuf
, DWORD dwBufLen
)
1474 FIXME("(%p, %d, %s, %d): stub\n",
1475 hIMC
, dwIndex
, debugstr_a(lpBuf
), dwBufLen
1477 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1481 /***********************************************************************
1482 * ImmGetGuideLineW (IMM32.@)
1484 DWORD WINAPI
ImmGetGuideLineW(HIMC hIMC
, DWORD dwIndex
, LPWSTR lpBuf
, DWORD dwBufLen
)
1486 FIXME("(%p, %d, %s, %d): stub\n",
1487 hIMC
, dwIndex
, debugstr_w(lpBuf
), dwBufLen
1489 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1493 /***********************************************************************
1494 * ImmGetIMEFileNameA (IMM32.@)
1496 UINT WINAPI
ImmGetIMEFileNameA( HKL hKL
, LPSTR lpszFileName
, UINT uBufLen
)
1499 UINT wBufLen
= uBufLen
;
1502 if (uBufLen
&& lpszFileName
)
1503 bufW
= HeapAlloc(GetProcessHeap(),0,uBufLen
* sizeof(WCHAR
));
1504 else /* We need this to get the number of byte required */
1506 bufW
= HeapAlloc(GetProcessHeap(),0,MAX_PATH
* sizeof(WCHAR
));
1510 rc
= ImmGetIMEFileNameW(hKL
,bufW
,wBufLen
);
1514 if (uBufLen
&& lpszFileName
)
1515 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, lpszFileName
,
1516 uBufLen
, NULL
, NULL
);
1517 else /* get the length */
1518 rc
= WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, NULL
, 0, NULL
,
1522 HeapFree(GetProcessHeap(),0,bufW
);
1526 /***********************************************************************
1527 * ImmGetIMEFileNameW (IMM32.@)
1529 UINT WINAPI
ImmGetIMEFileNameW(HKL hKL
, LPWSTR lpszFileName
, UINT uBufLen
)
1534 WCHAR regKey
[sizeof(szImeRegFmt
)/sizeof(WCHAR
)+8];
1536 wsprintfW( regKey
, szImeRegFmt
, (unsigned)hKL
);
1537 rc
= RegOpenKeyW( HKEY_LOCAL_MACHINE
, regKey
, &hkey
);
1538 if (rc
!= ERROR_SUCCESS
)
1545 rc
= RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, NULL
, &length
);
1547 if (rc
!= ERROR_SUCCESS
)
1553 if (length
> uBufLen
* sizeof(WCHAR
) || !lpszFileName
)
1558 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
1562 return length
/ sizeof(WCHAR
);
1565 RegGetValueW(hkey
, NULL
, szImeFileW
, RRF_RT_REG_SZ
, NULL
, lpszFileName
, &length
);
1569 return length
/ sizeof(WCHAR
);
1572 /***********************************************************************
1573 * ImmGetOpenStatus (IMM32.@)
1575 BOOL WINAPI
ImmGetOpenStatus(HIMC hIMC
)
1577 InputContextData
*data
= (InputContextData
*)hIMC
;
1581 FIXME("(%p): semi-stub\n", hIMC
);
1583 return data
->IMC
.fOpen
;
1586 /***********************************************************************
1587 * ImmGetProperty (IMM32.@)
1589 DWORD WINAPI
ImmGetProperty(HKL hKL
, DWORD fdwIndex
)
1594 TRACE("(%p, %d)\n", hKL
, fdwIndex
);
1595 kbd
= IMM_GetImmHkl(hKL
);
1597 if (kbd
&& kbd
->hIME
)
1601 case IGP_PROPERTY
: rc
= kbd
->imeInfo
.fdwProperty
; break;
1602 case IGP_CONVERSION
: rc
= kbd
->imeInfo
.fdwConversionCaps
; break;
1603 case IGP_SENTENCE
: rc
= kbd
->imeInfo
.fdwSentenceCaps
; break;
1604 case IGP_SETCOMPSTR
: rc
= kbd
->imeInfo
.fdwSCSCaps
; break;
1605 case IGP_SELECT
: rc
= kbd
->imeInfo
.fdwSelectCaps
; break;
1606 case IGP_GETIMEVERSION
: rc
= IMEVER_0400
; break;
1607 case IGP_UI
: rc
= 0; break;
1614 /***********************************************************************
1615 * ImmGetRegisterWordStyleA (IMM32.@)
1617 UINT WINAPI
ImmGetRegisterWordStyleA(
1618 HKL hKL
, UINT nItem
, LPSTYLEBUFA lpStyleBuf
)
1620 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1621 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1622 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1624 if (!is_kbd_ime_unicode(immHkl
))
1625 return immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)lpStyleBuf
);
1631 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,&sbw
);
1632 WideCharToMultiByte(CP_ACP
, 0, sbw
.szDescription
, -1,
1633 lpStyleBuf
->szDescription
, 32, NULL
, NULL
);
1634 lpStyleBuf
->dwStyle
= sbw
.dwStyle
;
1642 /***********************************************************************
1643 * ImmGetRegisterWordStyleW (IMM32.@)
1645 UINT WINAPI
ImmGetRegisterWordStyleW(
1646 HKL hKL
, UINT nItem
, LPSTYLEBUFW lpStyleBuf
)
1648 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1649 TRACE("(%p, %d, %p):\n", hKL
, nItem
, lpStyleBuf
);
1650 if (immHkl
->hIME
&& immHkl
->pImeGetRegisterWordStyle
)
1652 if (is_kbd_ime_unicode(immHkl
))
1653 return immHkl
->pImeGetRegisterWordStyle(nItem
,lpStyleBuf
);
1659 rc
= immHkl
->pImeGetRegisterWordStyle(nItem
,(LPSTYLEBUFW
)&sba
);
1660 MultiByteToWideChar(CP_ACP
, 0, sba
.szDescription
, -1,
1661 lpStyleBuf
->szDescription
, 32);
1662 lpStyleBuf
->dwStyle
= sba
.dwStyle
;
1670 /***********************************************************************
1671 * ImmGetStatusWindowPos (IMM32.@)
1673 BOOL WINAPI
ImmGetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
1675 InputContextData
*data
= (InputContextData
*)hIMC
;
1677 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
1679 if (!data
|| !lpptPos
)
1682 *lpptPos
= data
->IMC
.ptStatusWndPos
;
1687 /***********************************************************************
1688 * ImmGetVirtualKey (IMM32.@)
1690 UINT WINAPI
ImmGetVirtualKey(HWND hWnd
)
1692 OSVERSIONINFOA version
;
1693 InputContextData
*data
= (InputContextData
*)ImmGetContext( hWnd
);
1694 TRACE("%p\n", hWnd
);
1697 return data
->lastVK
;
1699 GetVersionExA( &version
);
1700 switch(version
.dwPlatformId
)
1702 case VER_PLATFORM_WIN32_WINDOWS
:
1703 return VK_PROCESSKEY
;
1704 case VER_PLATFORM_WIN32_NT
:
1707 FIXME("%d not supported\n",version
.dwPlatformId
);
1708 return VK_PROCESSKEY
;
1712 /***********************************************************************
1713 * ImmInstallIMEA (IMM32.@)
1715 HKL WINAPI
ImmInstallIMEA(
1716 LPCSTR lpszIMEFileName
, LPCSTR lpszLayoutText
)
1718 LPWSTR lpszwIMEFileName
;
1719 LPWSTR lpszwLayoutText
;
1722 TRACE ("(%s, %s)\n", debugstr_a(lpszIMEFileName
),
1723 debugstr_a(lpszLayoutText
));
1725 lpszwIMEFileName
= strdupAtoW(lpszIMEFileName
);
1726 lpszwLayoutText
= strdupAtoW(lpszLayoutText
);
1728 hkl
= ImmInstallIMEW(lpszwIMEFileName
, lpszwLayoutText
);
1730 HeapFree(GetProcessHeap(),0,lpszwIMEFileName
);
1731 HeapFree(GetProcessHeap(),0,lpszwLayoutText
);
1735 /***********************************************************************
1736 * ImmInstallIMEW (IMM32.@)
1738 HKL WINAPI
ImmInstallIMEW(
1739 LPCWSTR lpszIMEFileName
, LPCWSTR lpszLayoutText
)
1741 INT lcid
= GetUserDefaultLCID();
1746 WCHAR regKey
[sizeof(szImeRegFmt
)/sizeof(WCHAR
)+8];
1748 TRACE ("(%s, %s):\n", debugstr_w(lpszIMEFileName
),
1749 debugstr_w(lpszLayoutText
));
1751 /* Start with 2. e001 will be blank and so default to the wine internal IME */
1754 while (count
< 0xfff)
1756 DWORD disposition
= 0;
1758 hkl
= (HKL
)(((0xe000|count
)<<16) | lcid
);
1759 wsprintfW( regKey
, szImeRegFmt
, (unsigned)hkl
);
1761 rc
= RegCreateKeyExW(HKEY_LOCAL_MACHINE
, regKey
, 0, NULL
, 0, KEY_WRITE
, NULL
, &hkey
, &disposition
);
1762 if (rc
== ERROR_SUCCESS
&& disposition
== REG_CREATED_NEW_KEY
)
1764 else if (rc
== ERROR_SUCCESS
)
1772 WARN("Unable to find slot to install IME\n");
1776 if (rc
== ERROR_SUCCESS
)
1778 rc
= RegSetValueExW(hkey
, szImeFileW
, 0, REG_SZ
, (LPBYTE
)lpszIMEFileName
,
1779 (lstrlenW(lpszIMEFileName
) + 1) * sizeof(WCHAR
));
1780 if (rc
== ERROR_SUCCESS
)
1781 rc
= RegSetValueExW(hkey
, szLayoutTextW
, 0, REG_SZ
, (LPBYTE
)lpszLayoutText
,
1782 (lstrlenW(lpszLayoutText
) + 1) * sizeof(WCHAR
));
1788 WARN("Unable to set IME registry values\n");
1793 /***********************************************************************
1794 * ImmIsIME (IMM32.@)
1796 BOOL WINAPI
ImmIsIME(HKL hKL
)
1799 TRACE("(%p):\n", hKL
);
1800 ptr
= IMM_GetImmHkl(hKL
);
1801 return (ptr
&& ptr
->hIME
);
1804 /***********************************************************************
1805 * ImmIsUIMessageA (IMM32.@)
1807 BOOL WINAPI
ImmIsUIMessageA(
1808 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1812 TRACE("(%p, %x, %ld, %ld)\n", hWndIME
, msg
, wParam
, lParam
);
1813 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
1814 (msg
>= WM_IME_SETCONTEXT
&& msg
<= WM_IME_KEYUP
) ||
1815 (msg
== WM_MSIME_SERVICE
) ||
1816 (msg
== WM_MSIME_RECONVERTOPTIONS
) ||
1817 (msg
== WM_MSIME_MOUSE
) ||
1818 (msg
== WM_MSIME_RECONVERTREQUEST
) ||
1819 (msg
== WM_MSIME_RECONVERT
) ||
1820 (msg
== WM_MSIME_QUERYPOSITION
) ||
1821 (msg
== WM_MSIME_DOCUMENTFEED
))
1824 if (!IMM_GetThreadData()->hwndDefault
)
1825 ImmGetDefaultIMEWnd(NULL
);
1827 if (hWndIME
== NULL
)
1828 PostMessageA(IMM_GetThreadData()->hwndDefault
, msg
, wParam
, lParam
);
1835 /***********************************************************************
1836 * ImmIsUIMessageW (IMM32.@)
1838 BOOL WINAPI
ImmIsUIMessageW(
1839 HWND hWndIME
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1842 TRACE("(%p, %d, %ld, %ld):\n", hWndIME
, msg
, wParam
, lParam
);
1843 if ((msg
>= WM_IME_STARTCOMPOSITION
&& msg
<= WM_IME_KEYLAST
) ||
1844 (msg
>= WM_IME_SETCONTEXT
&& msg
<= WM_IME_KEYUP
) ||
1845 (msg
== WM_MSIME_SERVICE
) ||
1846 (msg
== WM_MSIME_RECONVERTOPTIONS
) ||
1847 (msg
== WM_MSIME_MOUSE
) ||
1848 (msg
== WM_MSIME_RECONVERTREQUEST
) ||
1849 (msg
== WM_MSIME_RECONVERT
) ||
1850 (msg
== WM_MSIME_QUERYPOSITION
) ||
1851 (msg
== WM_MSIME_DOCUMENTFEED
))
1856 /***********************************************************************
1857 * ImmNotifyIME (IMM32.@)
1859 BOOL WINAPI
ImmNotifyIME(
1860 HIMC hIMC
, DWORD dwAction
, DWORD dwIndex
, DWORD dwValue
)
1862 InputContextData
*data
= (InputContextData
*)hIMC
;
1864 TRACE("(%p, %d, %d, %d)\n",
1865 hIMC
, dwAction
, dwIndex
, dwValue
);
1867 if (!data
|| ! data
->immKbd
->pNotifyIME
)
1870 return data
->immKbd
->pNotifyIME(hIMC
,dwAction
,dwIndex
,dwValue
);
1873 /***********************************************************************
1874 * ImmRegisterWordA (IMM32.@)
1876 BOOL WINAPI
ImmRegisterWordA(
1877 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszRegister
)
1879 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1880 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
1881 debugstr_a(lpszRegister
));
1882 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
1884 if (!is_kbd_ime_unicode(immHkl
))
1885 return immHkl
->pImeRegisterWord((LPCWSTR
)lpszReading
,dwStyle
,
1886 (LPCWSTR
)lpszRegister
);
1889 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
1890 LPWSTR lpszwRegister
= strdupAtoW(lpszRegister
);
1893 rc
= immHkl
->pImeRegisterWord(lpszwReading
,dwStyle
,lpszwRegister
);
1894 HeapFree(GetProcessHeap(),0,lpszwReading
);
1895 HeapFree(GetProcessHeap(),0,lpszwRegister
);
1903 /***********************************************************************
1904 * ImmRegisterWordW (IMM32.@)
1906 BOOL WINAPI
ImmRegisterWordW(
1907 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszRegister
)
1909 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
1910 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
1911 debugstr_w(lpszRegister
));
1912 if (immHkl
->hIME
&& immHkl
->pImeRegisterWord
)
1914 if (is_kbd_ime_unicode(immHkl
))
1915 return immHkl
->pImeRegisterWord(lpszReading
,dwStyle
,lpszRegister
);
1918 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
1919 LPSTR lpszaRegister
= strdupWtoA(lpszRegister
);
1922 rc
= immHkl
->pImeRegisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
1923 (LPCWSTR
)lpszaRegister
);
1924 HeapFree(GetProcessHeap(),0,lpszaReading
);
1925 HeapFree(GetProcessHeap(),0,lpszaRegister
);
1933 /***********************************************************************
1934 * ImmReleaseContext (IMM32.@)
1936 BOOL WINAPI
ImmReleaseContext(HWND hWnd
, HIMC hIMC
)
1938 static int shown
= 0;
1941 FIXME("(%p, %p): stub\n", hWnd
, hIMC
);
1947 /***********************************************************************
1948 * ImmRequestMessageA(IMM32.@)
1950 LRESULT WINAPI
ImmRequestMessageA(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
1952 InputContextData
*data
= (InputContextData
*)hIMC
;
1954 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
1956 if (data
&& IsWindow(data
->IMC
.hWnd
))
1957 return SendMessageA(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
1962 /***********************************************************************
1963 * ImmRequestMessageW(IMM32.@)
1965 LRESULT WINAPI
ImmRequestMessageW(HIMC hIMC
, WPARAM wParam
, LPARAM lParam
)
1967 InputContextData
*data
= (InputContextData
*)hIMC
;
1969 TRACE("%p %ld %ld\n", hIMC
, wParam
, wParam
);
1971 if (data
&& IsWindow(data
->IMC
.hWnd
))
1972 return SendMessageW(data
->IMC
.hWnd
, WM_IME_REQUEST
, wParam
, lParam
);
1977 /***********************************************************************
1978 * ImmSetCandidateWindow (IMM32.@)
1980 BOOL WINAPI
ImmSetCandidateWindow(
1981 HIMC hIMC
, LPCANDIDATEFORM lpCandidate
)
1983 InputContextData
*data
= (InputContextData
*)hIMC
;
1985 TRACE("(%p, %p)\n", hIMC
, lpCandidate
);
1987 if (!data
|| !lpCandidate
)
1990 TRACE("\t%x, %x, (%i,%i), (%i,%i - %i,%i)\n",
1991 lpCandidate
->dwIndex
, lpCandidate
->dwStyle
,
1992 lpCandidate
->ptCurrentPos
.x
, lpCandidate
->ptCurrentPos
.y
,
1993 lpCandidate
->rcArea
.top
, lpCandidate
->rcArea
.left
,
1994 lpCandidate
->rcArea
.bottom
, lpCandidate
->rcArea
.right
);
1996 if ( lpCandidate
->dwIndex
>= (sizeof(data
->IMC
.cfCandForm
) / sizeof(CANDIDATEFORM
)) )
1999 data
->IMC
.cfCandForm
[lpCandidate
->dwIndex
] = *lpCandidate
;
2000 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCANDIDATEPOS
);
2001 ImmInternalSendIMENotify(data
, IMN_SETCANDIDATEPOS
, 1 << lpCandidate
->dwIndex
);
2006 /***********************************************************************
2007 * ImmSetCompositionFontA (IMM32.@)
2009 BOOL WINAPI
ImmSetCompositionFontA(HIMC hIMC
, LPLOGFONTA lplf
)
2011 InputContextData
*data
= (InputContextData
*)hIMC
;
2012 TRACE("(%p, %p)\n", hIMC
, lplf
);
2017 memcpy(&data
->IMC
.lfFont
.W
,lplf
,sizeof(LOGFONTA
));
2018 MultiByteToWideChar(CP_ACP
, 0, lplf
->lfFaceName
, -1, data
->IMC
.lfFont
.W
.lfFaceName
,
2020 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2021 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2026 /***********************************************************************
2027 * ImmSetCompositionFontW (IMM32.@)
2029 BOOL WINAPI
ImmSetCompositionFontW(HIMC hIMC
, LPLOGFONTW lplf
)
2031 InputContextData
*data
= (InputContextData
*)hIMC
;
2032 TRACE("(%p, %p)\n", hIMC
, lplf
);
2037 data
->IMC
.lfFont
.W
= *lplf
;
2038 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETCOMPOSITIONFONT
);
2039 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONFONT
, 0);
2044 /***********************************************************************
2045 * ImmSetCompositionStringA (IMM32.@)
2047 BOOL WINAPI
ImmSetCompositionStringA(
2048 HIMC hIMC
, DWORD dwIndex
,
2049 LPCVOID lpComp
, DWORD dwCompLen
,
2050 LPCVOID lpRead
, DWORD dwReadLen
)
2054 WCHAR
*CompBuffer
= NULL
;
2055 WCHAR
*ReadBuffer
= NULL
;
2057 InputContextData
*data
= (InputContextData
*)hIMC
;
2059 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2060 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2065 if (!is_himc_ime_unicode(data
))
2066 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2067 dwCompLen
, lpRead
, dwReadLen
);
2069 comp_len
= MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0);
2072 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
* sizeof(WCHAR
));
2073 MultiByteToWideChar(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
);
2076 read_len
= MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0);
2079 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
* sizeof(WCHAR
));
2080 MultiByteToWideChar(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
);
2083 rc
= ImmSetCompositionStringW(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2084 ReadBuffer
, read_len
);
2086 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2087 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2092 /***********************************************************************
2093 * ImmSetCompositionStringW (IMM32.@)
2095 BOOL WINAPI
ImmSetCompositionStringW(
2096 HIMC hIMC
, DWORD dwIndex
,
2097 LPCVOID lpComp
, DWORD dwCompLen
,
2098 LPCVOID lpRead
, DWORD dwReadLen
)
2102 CHAR
*CompBuffer
= NULL
;
2103 CHAR
*ReadBuffer
= NULL
;
2105 InputContextData
*data
= (InputContextData
*)hIMC
;
2107 TRACE("(%p, %d, %p, %d, %p, %d):\n",
2108 hIMC
, dwIndex
, lpComp
, dwCompLen
, lpRead
, dwReadLen
);
2113 if (is_himc_ime_unicode(data
))
2114 return data
->immKbd
->pImeSetCompositionString(hIMC
, dwIndex
, lpComp
,
2115 dwCompLen
, lpRead
, dwReadLen
);
2117 comp_len
= WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, NULL
, 0, NULL
,
2121 CompBuffer
= HeapAlloc(GetProcessHeap(),0,comp_len
);
2122 WideCharToMultiByte(CP_ACP
, 0, lpComp
, dwCompLen
, CompBuffer
, comp_len
,
2126 read_len
= WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, NULL
, 0, NULL
,
2130 ReadBuffer
= HeapAlloc(GetProcessHeap(),0,read_len
);
2131 WideCharToMultiByte(CP_ACP
, 0, lpRead
, dwReadLen
, ReadBuffer
, read_len
,
2135 rc
= ImmSetCompositionStringA(hIMC
, dwIndex
, CompBuffer
, comp_len
,
2136 ReadBuffer
, read_len
);
2138 HeapFree(GetProcessHeap(), 0, CompBuffer
);
2139 HeapFree(GetProcessHeap(), 0, ReadBuffer
);
2144 /***********************************************************************
2145 * ImmSetCompositionWindow (IMM32.@)
2147 BOOL WINAPI
ImmSetCompositionWindow(
2148 HIMC hIMC
, LPCOMPOSITIONFORM lpCompForm
)
2150 BOOL reshow
= FALSE
;
2151 InputContextData
*data
= (InputContextData
*)hIMC
;
2153 TRACE("(%p, %p)\n", hIMC
, lpCompForm
);
2154 TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm
->dwStyle
,
2155 lpCompForm
->ptCurrentPos
.x
, lpCompForm
->ptCurrentPos
.y
, lpCompForm
->rcArea
.top
,
2156 lpCompForm
->rcArea
.left
, lpCompForm
->rcArea
.bottom
, lpCompForm
->rcArea
.right
);
2161 data
->IMC
.cfCompForm
= *lpCompForm
;
2163 if (IsWindowVisible(IMM_GetThreadData()->hwndDefault
))
2166 ShowWindow(IMM_GetThreadData()->hwndDefault
,SW_HIDE
);
2169 /* FIXME: this is a partial stub */
2172 ShowWindow(IMM_GetThreadData()->hwndDefault
,SW_SHOWNOACTIVATE
);
2174 ImmInternalSendIMENotify(data
, IMN_SETCOMPOSITIONWINDOW
, 0);
2178 /***********************************************************************
2179 * ImmSetConversionStatus (IMM32.@)
2181 BOOL WINAPI
ImmSetConversionStatus(
2182 HIMC hIMC
, DWORD fdwConversion
, DWORD fdwSentence
)
2184 DWORD oldConversion
, oldSentence
;
2185 InputContextData
*data
= (InputContextData
*)hIMC
;
2187 TRACE("%p %d %d\n", hIMC
, fdwConversion
, fdwSentence
);
2192 if ( fdwConversion
!= data
->IMC
.fdwConversion
)
2194 oldConversion
= data
->IMC
.fdwConversion
;
2195 data
->IMC
.fdwConversion
= fdwConversion
;
2196 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldConversion
, IMC_SETCONVERSIONMODE
);
2197 ImmInternalSendIMENotify(data
, IMN_SETCONVERSIONMODE
, 0);
2199 if ( fdwSentence
!= data
->IMC
.fdwSentence
)
2201 oldSentence
= data
->IMC
.fdwSentence
;
2202 data
->IMC
.fdwSentence
= fdwSentence
;
2203 ImmNotifyIME(hIMC
, NI_CONTEXTUPDATED
, oldSentence
, IMC_SETSENTENCEMODE
);
2204 ImmInternalSendIMENotify(data
, IMN_SETSENTENCEMODE
, 0);
2210 /***********************************************************************
2211 * ImmSetOpenStatus (IMM32.@)
2213 BOOL WINAPI
ImmSetOpenStatus(HIMC hIMC
, BOOL fOpen
)
2215 InputContextData
*data
= (InputContextData
*)hIMC
;
2217 TRACE("%p %d\n", hIMC
, fOpen
);
2222 if (data
->imeWnd
== NULL
)
2224 /* create the ime window */
2225 data
->imeWnd
= CreateWindowExW( WS_EX_TOOLWINDOW
,
2226 data
->immKbd
->imeClassName
, NULL
, WS_POPUP
, 0, 0, 1, 1, 0,
2227 0, data
->immKbd
->hIME
, 0);
2228 SetWindowLongW(data
->imeWnd
, IMMGWL_IMC
, (LONG
)data
);
2229 IMM_GetThreadData()->hwndDefault
= data
->imeWnd
;
2232 if (!fOpen
!= !data
->IMC
.fOpen
)
2234 data
->IMC
.fOpen
= fOpen
;
2235 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETOPENSTATUS
);
2236 ImmInternalSendIMENotify(data
, IMN_SETOPENSTATUS
, 0);
2242 /***********************************************************************
2243 * ImmSetStatusWindowPos (IMM32.@)
2245 BOOL WINAPI
ImmSetStatusWindowPos(HIMC hIMC
, LPPOINT lpptPos
)
2247 InputContextData
*data
= (InputContextData
*)hIMC
;
2249 TRACE("(%p, %p)\n", hIMC
, lpptPos
);
2251 if (!data
|| !lpptPos
)
2254 TRACE("\t(%i,%i)\n", lpptPos
->x
, lpptPos
->y
);
2256 data
->IMC
.ptStatusWndPos
= *lpptPos
;
2257 ImmNotifyIME( hIMC
, NI_CONTEXTUPDATED
, 0, IMC_SETSTATUSWINDOWPOS
);
2258 ImmInternalSendIMENotify(data
, IMN_SETSTATUSWINDOWPOS
, 0);
2263 /***********************************************************************
2264 * ImmCreateSoftKeyboard(IMM32.@)
2266 HWND WINAPI
ImmCreateSoftKeyboard(UINT uType
, UINT hOwner
, int x
, int y
)
2268 FIXME("(%d, %d, %d, %d): stub\n", uType
, hOwner
, x
, y
);
2269 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2273 /***********************************************************************
2274 * ImmDestroySoftKeyboard(IMM32.@)
2276 BOOL WINAPI
ImmDestroySoftKeyboard(HWND hSoftWnd
)
2278 FIXME("(%p): stub\n", hSoftWnd
);
2279 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2283 /***********************************************************************
2284 * ImmShowSoftKeyboard(IMM32.@)
2286 BOOL WINAPI
ImmShowSoftKeyboard(HWND hSoftWnd
, int nCmdShow
)
2288 FIXME("(%p, %d): stub\n", hSoftWnd
, nCmdShow
);
2289 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2293 /***********************************************************************
2294 * ImmSimulateHotKey (IMM32.@)
2296 BOOL WINAPI
ImmSimulateHotKey(HWND hWnd
, DWORD dwHotKeyID
)
2298 FIXME("(%p, %d): stub\n", hWnd
, dwHotKeyID
);
2299 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2303 /***********************************************************************
2304 * ImmUnregisterWordA (IMM32.@)
2306 BOOL WINAPI
ImmUnregisterWordA(
2307 HKL hKL
, LPCSTR lpszReading
, DWORD dwStyle
, LPCSTR lpszUnregister
)
2309 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2310 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_a(lpszReading
), dwStyle
,
2311 debugstr_a(lpszUnregister
));
2312 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2314 if (!is_kbd_ime_unicode(immHkl
))
2315 return immHkl
->pImeUnregisterWord((LPCWSTR
)lpszReading
,dwStyle
,
2316 (LPCWSTR
)lpszUnregister
);
2319 LPWSTR lpszwReading
= strdupAtoW(lpszReading
);
2320 LPWSTR lpszwUnregister
= strdupAtoW(lpszUnregister
);
2323 rc
= immHkl
->pImeUnregisterWord(lpszwReading
,dwStyle
,lpszwUnregister
);
2324 HeapFree(GetProcessHeap(),0,lpszwReading
);
2325 HeapFree(GetProcessHeap(),0,lpszwUnregister
);
2333 /***********************************************************************
2334 * ImmUnregisterWordW (IMM32.@)
2336 BOOL WINAPI
ImmUnregisterWordW(
2337 HKL hKL
, LPCWSTR lpszReading
, DWORD dwStyle
, LPCWSTR lpszUnregister
)
2339 ImmHkl
*immHkl
= IMM_GetImmHkl(hKL
);
2340 TRACE("(%p, %s, %d, %s):\n", hKL
, debugstr_w(lpszReading
), dwStyle
,
2341 debugstr_w(lpszUnregister
));
2342 if (immHkl
->hIME
&& immHkl
->pImeUnregisterWord
)
2344 if (is_kbd_ime_unicode(immHkl
))
2345 return immHkl
->pImeUnregisterWord(lpszReading
,dwStyle
,lpszUnregister
);
2348 LPSTR lpszaReading
= strdupWtoA(lpszReading
);
2349 LPSTR lpszaUnregister
= strdupWtoA(lpszUnregister
);
2352 rc
= immHkl
->pImeUnregisterWord((LPCWSTR
)lpszaReading
,dwStyle
,
2353 (LPCWSTR
)lpszaUnregister
);
2354 HeapFree(GetProcessHeap(),0,lpszaReading
);
2355 HeapFree(GetProcessHeap(),0,lpszaUnregister
);
2363 /***********************************************************************
2364 * ImmGetImeMenuItemsA (IMM32.@)
2366 DWORD WINAPI
ImmGetImeMenuItemsA( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2367 LPIMEMENUITEMINFOA lpImeParentMenu
, LPIMEMENUITEMINFOA lpImeMenu
,
2370 InputContextData
*data
= (InputContextData
*)hIMC
;
2371 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2372 lpImeParentMenu
, lpImeMenu
, dwSize
);
2373 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2375 if (!is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2376 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2377 (IMEMENUITEMINFOW
*)lpImeParentMenu
,
2378 (IMEMENUITEMINFOW
*)lpImeMenu
, dwSize
);
2381 IMEMENUITEMINFOW lpImeParentMenuW
;
2382 IMEMENUITEMINFOW
*lpImeMenuW
, *parent
= NULL
;
2385 if (lpImeParentMenu
)
2386 parent
= &lpImeParentMenuW
;
2389 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOA
);
2390 dwSize
= count
* sizeof(IMEMENUITEMINFOW
);
2391 lpImeMenuW
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2396 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2397 parent
, lpImeMenuW
, dwSize
);
2399 if (lpImeParentMenu
)
2401 memcpy(lpImeParentMenu
,&lpImeParentMenuW
,sizeof(IMEMENUITEMINFOA
));
2402 lpImeParentMenu
->hbmpItem
= lpImeParentMenuW
.hbmpItem
;
2403 WideCharToMultiByte(CP_ACP
, 0, lpImeParentMenuW
.szString
,
2404 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
,
2407 if (lpImeMenu
&& rc
)
2410 for (i
= 0; i
< rc
; i
++)
2412 memcpy(&lpImeMenu
[i
],&lpImeMenuW
[1],sizeof(IMEMENUITEMINFOA
));
2413 lpImeMenu
[i
].hbmpItem
= lpImeMenuW
[i
].hbmpItem
;
2414 WideCharToMultiByte(CP_ACP
, 0, lpImeMenuW
[i
].szString
,
2415 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
,
2419 HeapFree(GetProcessHeap(),0,lpImeMenuW
);
2427 /***********************************************************************
2428 * ImmGetImeMenuItemsW (IMM32.@)
2430 DWORD WINAPI
ImmGetImeMenuItemsW( HIMC hIMC
, DWORD dwFlags
, DWORD dwType
,
2431 LPIMEMENUITEMINFOW lpImeParentMenu
, LPIMEMENUITEMINFOW lpImeMenu
,
2434 InputContextData
*data
= (InputContextData
*)hIMC
;
2435 TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC
, dwFlags
, dwType
,
2436 lpImeParentMenu
, lpImeMenu
, dwSize
);
2437 if (data
->immKbd
->hIME
&& data
->immKbd
->pImeGetImeMenuItems
)
2439 if (is_himc_ime_unicode(data
) || (!lpImeParentMenu
&& !lpImeMenu
))
2440 return data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2441 lpImeParentMenu
, lpImeMenu
, dwSize
);
2444 IMEMENUITEMINFOA lpImeParentMenuA
;
2445 IMEMENUITEMINFOA
*lpImeMenuA
, *parent
= NULL
;
2448 if (lpImeParentMenu
)
2449 parent
= &lpImeParentMenuA
;
2452 int count
= dwSize
/ sizeof(LPIMEMENUITEMINFOW
);
2453 dwSize
= count
* sizeof(IMEMENUITEMINFOA
);
2454 lpImeMenuA
= HeapAlloc(GetProcessHeap(), 0, dwSize
);
2459 rc
= data
->immKbd
->pImeGetImeMenuItems(hIMC
, dwFlags
, dwType
,
2460 (IMEMENUITEMINFOW
*)parent
,
2461 (IMEMENUITEMINFOW
*)lpImeMenuA
, dwSize
);
2463 if (lpImeParentMenu
)
2465 memcpy(lpImeParentMenu
,&lpImeParentMenuA
,sizeof(IMEMENUITEMINFOA
));
2466 lpImeParentMenu
->hbmpItem
= lpImeParentMenuA
.hbmpItem
;
2467 MultiByteToWideChar(CP_ACP
, 0, lpImeParentMenuA
.szString
,
2468 -1, lpImeParentMenu
->szString
, IMEMENUITEM_STRING_SIZE
);
2470 if (lpImeMenu
&& rc
)
2473 for (i
= 0; i
< rc
; i
++)
2475 memcpy(&lpImeMenu
[i
],&lpImeMenuA
[1],sizeof(IMEMENUITEMINFOA
));
2476 lpImeMenu
[i
].hbmpItem
= lpImeMenuA
[i
].hbmpItem
;
2477 MultiByteToWideChar(CP_ACP
, 0, lpImeMenuA
[i
].szString
,
2478 -1, lpImeMenu
[i
].szString
, IMEMENUITEM_STRING_SIZE
);
2481 HeapFree(GetProcessHeap(),0,lpImeMenuA
);
2489 /***********************************************************************
2490 * ImmLockIMC(IMM32.@)
2492 LPINPUTCONTEXT WINAPI
ImmLockIMC(HIMC hIMC
)
2494 InputContextData
*data
= (InputContextData
*)hIMC
;
2502 /***********************************************************************
2503 * ImmUnlockIMC(IMM32.@)
2505 BOOL WINAPI
ImmUnlockIMC(HIMC hIMC
)
2507 InputContextData
*data
= (InputContextData
*)hIMC
;
2509 return (data
->dwLock
!=0);
2512 /***********************************************************************
2513 * ImmGetIMCLockCount(IMM32.@)
2515 DWORD WINAPI
ImmGetIMCLockCount(HIMC hIMC
)
2517 InputContextData
*data
= (InputContextData
*)hIMC
;
2518 return data
->dwLock
;
2521 /***********************************************************************
2522 * ImmCreateIMCC(IMM32.@)
2524 HIMCC WINAPI
ImmCreateIMCC(DWORD size
)
2526 IMCCInternal
*internal
;
2527 int real_size
= size
+ sizeof(IMCCInternal
);
2529 internal
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, real_size
);
2530 if (internal
== NULL
)
2533 internal
->dwSize
= size
;
2537 /***********************************************************************
2538 * ImmDestroyIMCC(IMM32.@)
2540 HIMCC WINAPI
ImmDestroyIMCC(HIMCC block
)
2542 HeapFree(GetProcessHeap(),0,block
);
2546 /***********************************************************************
2547 * ImmLockIMCC(IMM32.@)
2549 LPVOID WINAPI
ImmLockIMCC(HIMCC imcc
)
2551 IMCCInternal
*internal
;
2552 internal
= (IMCCInternal
*) imcc
;
2554 internal
->dwLock
++;
2555 return internal
+ 1;
2558 /***********************************************************************
2559 * ImmUnlockIMCC(IMM32.@)
2561 BOOL WINAPI
ImmUnlockIMCC(HIMCC imcc
)
2563 IMCCInternal
*internal
;
2564 internal
= (IMCCInternal
*) imcc
;
2566 internal
->dwLock
--;
2567 return (internal
->dwLock
!=0);
2570 /***********************************************************************
2571 * ImmGetIMCCLockCount(IMM32.@)
2573 DWORD WINAPI
ImmGetIMCCLockCount(HIMCC imcc
)
2575 IMCCInternal
*internal
;
2576 internal
= (IMCCInternal
*) imcc
;
2578 return internal
->dwLock
;
2581 /***********************************************************************
2582 * ImmReSizeIMCC(IMM32.@)
2584 HIMCC WINAPI
ImmReSizeIMCC(HIMCC imcc
, DWORD size
)
2586 IMCCInternal
*internal
,*newone
;
2587 int real_size
= size
+ sizeof(IMCCInternal
);
2589 internal
= (IMCCInternal
*) imcc
;
2591 newone
= HeapReAlloc(GetProcessHeap(), 0, internal
, real_size
);
2592 newone
->dwSize
= size
;
2597 /***********************************************************************
2598 * ImmGetIMCCSize(IMM32.@)
2600 DWORD WINAPI
ImmGetIMCCSize(HIMCC imcc
)
2602 IMCCInternal
*internal
;
2603 internal
= (IMCCInternal
*) imcc
;
2605 return internal
->dwSize
;
2608 /***********************************************************************
2609 * ImmGenerateMessage(IMM32.@)
2611 BOOL WINAPI
ImmGenerateMessage(HIMC hIMC
)
2613 InputContextData
*data
= (InputContextData
*)hIMC
;
2615 TRACE("%i messages queued\n",data
->IMC
.dwNumMsgBuf
);
2616 if (data
->IMC
.dwNumMsgBuf
> 0)
2618 LPTRANSMSG lpTransMsg
;
2621 lpTransMsg
= ImmLockIMCC(data
->IMC
.hMsgBuf
);
2622 for (i
= 0; i
< data
->IMC
.dwNumMsgBuf
; i
++)
2623 ImmInternalPostIMEMessage(data
, lpTransMsg
[i
].message
, lpTransMsg
[i
].wParam
, lpTransMsg
[i
].lParam
);
2625 ImmUnlockIMCC(data
->IMC
.hMsgBuf
);
2627 data
->IMC
.dwNumMsgBuf
= 0;
2633 /***********************************************************************
2634 * ImmTranslateMessage(IMM32.@)
2635 * ( Undocumented, call internally and from user32.dll )
2637 BOOL WINAPI
ImmTranslateMessage(HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lKeyData
)
2639 InputContextData
*data
;
2640 HIMC imc
= ImmGetContext(hwnd
);
2646 static const DWORD list_count
= 10;
2648 TRACE("%p %x %x %x\n",hwnd
, msg
, (UINT
)wParam
, (UINT
)lKeyData
);
2651 data
= (InputContextData
*)imc
;
2655 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeToAsciiEx
)
2658 GetKeyboardState(state
);
2659 scancode
= lKeyData
>> 0x10 & 0xff;
2661 list
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, list_count
* sizeof(TRANSMSG
) + sizeof(DWORD
));
2662 ((DWORD
*)list
)[0] = list_count
;
2664 if (data
->immKbd
->imeInfo
.fdwProperty
& IME_PROP_KBD_CHAR_FIRST
)
2668 if (!is_himc_ime_unicode(data
))
2669 ToAscii(data
->lastVK
, scancode
, state
, &chr
, 0);
2671 ToUnicodeEx(data
->lastVK
, scancode
, state
, &chr
, 1, 0, GetKeyboardLayout(0));
2672 uVirtKey
= MAKELONG(data
->lastVK
,chr
);
2675 uVirtKey
= data
->lastVK
;
2677 msg_count
= data
->immKbd
->pImeToAsciiEx(uVirtKey
, scancode
, state
, list
, 0, imc
);
2678 TRACE("%i messages generated\n",msg_count
);
2679 if (msg_count
&& msg_count
<= list_count
)
2682 LPTRANSMSG msgs
= (LPTRANSMSG
)((LPBYTE
)list
+ sizeof(DWORD
));
2684 for (i
= 0; i
< msg_count
; i
++)
2685 ImmInternalPostIMEMessage(data
, msgs
[i
].message
, msgs
[i
].wParam
, msgs
[i
].lParam
);
2687 else if (msg_count
> list_count
)
2688 ImmGenerateMessage(imc
);
2690 HeapFree(GetProcessHeap(),0,list
);
2692 data
->lastVK
= VK_PROCESSKEY
;
2694 return (msg_count
> 0);
2697 /***********************************************************************
2698 * ImmProcessKey(IMM32.@)
2699 * ( Undocumented, called from user32.dll )
2701 BOOL WINAPI
ImmProcessKey(HWND hwnd
, HKL hKL
, UINT vKey
, LPARAM lKeyData
, DWORD unknown
)
2703 InputContextData
*data
;
2704 HIMC imc
= ImmGetContext(hwnd
);
2707 TRACE("%p %p %x %x %x\n",hwnd
, hKL
, vKey
, (UINT
)lKeyData
, unknown
);
2710 data
= (InputContextData
*)imc
;
2714 if (!data
->immKbd
->hIME
|| !data
->immKbd
->pImeProcessKey
)
2717 GetKeyboardState(state
);
2718 if (data
->immKbd
->pImeProcessKey(imc
, vKey
, lKeyData
, state
))
2720 data
->lastVK
= vKey
;
2724 data
->lastVK
= VK_PROCESSKEY
;