#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "wine/debug.h"
#include "imm.h"
#include "ddk/imm.h"
#include "winnls.h"
#include "winreg.h"
#include "wine/list.h"

Include dependency graph for imm.c:

Classes
struct	_tagImmHkl

struct	tagInputContextData

struct	_tagTRANSMSG

struct	_tagIMMThreadData

Macros
#define	IMM_INIT_MAGIC 0x19650412

#define	WINE_IMC_VALID_MAGIC 0x56434D49

#define	LOAD_FUNCPTR(f) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}

Typedefs
typedef struct _tagImmHkl	ImmHkl

typedef struct tagInputContextData	InputContextData

typedef struct _tagTRANSMSG	TRANSMSG

typedef struct _tagTRANSMSG *	LPTRANSMSG

typedef struct _tagIMMThreadData	IMMThreadData

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)

BOOL WINAPI	User32InitializeImmEntryTable (DWORD)

static BOOL	is_himc_ime_unicode (const InputContextData *data)

static BOOL	is_kbd_ime_unicode (const ImmHkl *hkl)

static BOOL	IMM_DestroyContext (HIMC hIMC)

static InputContextData *	get_imc_data (HIMC hIMC)

static WCHAR *	strdupAtoW (const char *str)

static CHAR *	strdupWtoA (const WCHAR *str)

static DWORD	convert_candidatelist_WtoA (LPCANDIDATELIST lpSrc, LPCANDIDATELIST lpDst, DWORD dwBufLen)

static DWORD	convert_candidatelist_AtoW (LPCANDIDATELIST lpSrc, LPCANDIDATELIST lpDst, DWORD dwBufLen)

static IMMThreadData *	IMM_GetThreadData (HWND hwnd, DWORD thread)

static BOOL	IMM_IsDefaultContext (HIMC imc)

static void	IMM_FreeThreadData (void)

static HMODULE	load_graphics_driver (void)

static ImmHkl *	IMM_GetImmHkl (HKL hkl)

HWND WINAPI	__wine_get_ui_window (HKL hkl)

static void	IMM_FreeAllImmHkl (void)

BOOL WINAPI	DllMain (HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpReserved)

static void	ImmInternalPostIMEMessage (InputContextData *data, UINT msg, WPARAM wParam, LPARAM lParam)

static void	ImmInternalSendIMEMessage (InputContextData *data, UINT msg, WPARAM wParam, LPARAM lParam)

static LRESULT	ImmInternalSendIMENotify (InputContextData *data, WPARAM notify, LPARAM lParam)

static HIMCC	ImmCreateBlankCompStr (void)

static HIMC	get_default_context (HWND hwnd)

static BOOL	IMM_IsCrossThreadAccess (HWND hWnd, HIMC hIMC)

HIMC WINAPI	ImmAssociateContext (HWND hWnd, HIMC hIMC)

static BOOL CALLBACK	_ImmAssociateContextExEnumProc (HWND hwnd, LPARAM lParam)

BOOL WINAPI	ImmAssociateContextEx (HWND hWnd, HIMC hIMC, DWORD dwFlags)

BOOL WINAPI	ImmConfigureIMEA (HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)

BOOL WINAPI	ImmConfigureIMEW (HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)

HIMC WINAPI	ImmCreateContext (void)

BOOL WINAPI	ImmDestroyContext (HIMC hIMC)

BOOL WINAPI	ImmDisableIME (DWORD idThread)

UINT WINAPI	ImmEnumRegisterWordA (HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister, LPVOID lpData)

UINT WINAPI	ImmEnumRegisterWordW (HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister, LPVOID lpData)

static BOOL	EscapeRequiresWA (UINT uEscape)

LRESULT WINAPI	ImmEscapeA (HKL hKL, HIMC hIMC, UINT uEscape, LPVOID lpData)

LRESULT WINAPI	ImmEscapeW (HKL hKL, HIMC hIMC, UINT uEscape, LPVOID lpData)

DWORD WINAPI	ImmGetCandidateListA (HIMC hIMC, DWORD dwIndex, LPCANDIDATELIST lpCandList, DWORD dwBufLen)

DWORD WINAPI	ImmGetCandidateListCountA (HIMC hIMC, LPDWORD lpdwListCount)

DWORD WINAPI	ImmGetCandidateListCountW (HIMC hIMC, LPDWORD lpdwListCount)

DWORD WINAPI	ImmGetCandidateListW (HIMC hIMC, DWORD dwIndex, LPCANDIDATELIST lpCandList, DWORD dwBufLen)

BOOL WINAPI	ImmGetCandidateWindow (HIMC hIMC, DWORD dwIndex, LPCANDIDATEFORM lpCandidate)

BOOL WINAPI	ImmGetCompositionFontA (HIMC hIMC, LPLOGFONTA lplf)

BOOL WINAPI	ImmGetCompositionFontW (HIMC hIMC, LPLOGFONTW lplf)

static INT	CopyCompStringIMEtoClient (const InputContextData data, const void src, INT src_len, void *dst, INT dst_len, BOOL unicode)

static INT	CopyCompAttrIMEtoClient (const InputContextData data, const BYTE src, INT src_len, const void comp_string, INT str_len, BYTE dst, INT dst_len, BOOL unicode)

static INT	CopyCompClauseIMEtoClient (InputContextData *data, LPBYTE source, INT slen, LPBYTE ssource, LPBYTE target, INT tlen, BOOL unicode)

static INT	CopyCompOffsetIMEtoClient (InputContextData *data, DWORD offset, LPBYTE ssource, BOOL unicode)

static LONG	ImmGetCompositionStringT (HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen, BOOL unicode)

LONG WINAPI	ImmGetCompositionStringA (HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)

LONG WINAPI	ImmGetCompositionStringW (HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)

BOOL WINAPI	ImmGetCompositionWindow (HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)

HIMC WINAPI	ImmGetContext (HWND hWnd)

DWORD WINAPI	ImmGetConversionListA (HKL hKL, HIMC hIMC, LPCSTR pSrc, LPCANDIDATELIST lpDst, DWORD dwBufLen, UINT uFlag)

DWORD WINAPI	ImmGetConversionListW (HKL hKL, HIMC hIMC, LPCWSTR pSrc, LPCANDIDATELIST lpDst, DWORD dwBufLen, UINT uFlag)

BOOL WINAPI	ImmGetConversionStatus (HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)

static BOOL	needs_ime_window (HWND hwnd)

BOOL WINAPI	__wine_register_window (HWND hwnd)

void WINAPI	__wine_unregister_window (HWND hwnd)

HWND WINAPI	ImmGetDefaultIMEWnd (HWND hWnd)

UINT WINAPI	ImmGetDescriptionA (HKL hKL, LPSTR lpszDescription, UINT uBufLen)

UINT WINAPI	ImmGetDescriptionW (HKL hKL, LPWSTR lpszDescription, UINT uBufLen)

DWORD WINAPI	ImmGetGuideLineA (HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)

DWORD WINAPI	ImmGetGuideLineW (HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)

UINT WINAPI	ImmGetIMEFileNameA (HKL hKL, LPSTR lpszFileName, UINT uBufLen)

UINT WINAPI	ImmGetIMEFileNameW (HKL hKL, LPWSTR lpszFileName, UINT uBufLen)

BOOL WINAPI	ImmGetOpenStatus (HIMC hIMC)

DWORD WINAPI	ImmGetProperty (HKL hKL, DWORD fdwIndex)

UINT WINAPI	ImmGetRegisterWordStyleA (HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)

UINT WINAPI	ImmGetRegisterWordStyleW (HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)

BOOL WINAPI	ImmGetStatusWindowPos (HIMC hIMC, LPPOINT lpptPos)

UINT WINAPI	ImmGetVirtualKey (HWND hWnd)

HKL WINAPI	ImmInstallIMEA (LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)

HKL WINAPI	ImmInstallIMEW (LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)

BOOL WINAPI	ImmIsIME (HKL hKL)

BOOL WINAPI	ImmIsUIMessageA (HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)

BOOL WINAPI	ImmIsUIMessageW (HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)

BOOL WINAPI	ImmNotifyIME (HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)

BOOL WINAPI	ImmRegisterWordA (HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)

BOOL WINAPI	ImmRegisterWordW (HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)

BOOL WINAPI	ImmReleaseContext (HWND hWnd, HIMC hIMC)

LRESULT WINAPI	ImmRequestMessageA (HIMC hIMC, WPARAM wParam, LPARAM lParam)

LRESULT WINAPI	ImmRequestMessageW (HIMC hIMC, WPARAM wParam, LPARAM lParam)

BOOL WINAPI	ImmSetCandidateWindow (HIMC hIMC, LPCANDIDATEFORM lpCandidate)

BOOL WINAPI	ImmSetCompositionFontA (HIMC hIMC, LPLOGFONTA lplf)

BOOL WINAPI	ImmSetCompositionFontW (HIMC hIMC, LPLOGFONTW lplf)

BOOL WINAPI	ImmSetCompositionStringA (HIMC hIMC, DWORD dwIndex, LPCVOID lpComp, DWORD dwCompLen, LPCVOID lpRead, DWORD dwReadLen)

BOOL WINAPI	ImmSetCompositionStringW (HIMC hIMC, DWORD dwIndex, LPCVOID lpComp, DWORD dwCompLen, LPCVOID lpRead, DWORD dwReadLen)

BOOL WINAPI	ImmSetCompositionWindow (HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)

BOOL WINAPI	ImmSetConversionStatus (HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)

BOOL WINAPI	ImmSetOpenStatus (HIMC hIMC, BOOL fOpen)

BOOL WINAPI	ImmSetStatusWindowPos (HIMC hIMC, LPPOINT lpptPos)

HWND WINAPI	ImmCreateSoftKeyboard (UINT uType, UINT hOwner, int x, int y)

BOOL WINAPI	ImmDestroySoftKeyboard (HWND hSoftWnd)

BOOL WINAPI	ImmShowSoftKeyboard (HWND hSoftWnd, int nCmdShow)

BOOL WINAPI	ImmSimulateHotKey (HWND hWnd, DWORD dwHotKeyID)

BOOL WINAPI	ImmUnregisterWordA (HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)

BOOL WINAPI	ImmUnregisterWordW (HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)

DWORD WINAPI	ImmGetImeMenuItemsA (HIMC hIMC, DWORD dwFlags, DWORD dwType, LPIMEMENUITEMINFOA lpImeParentMenu, LPIMEMENUITEMINFOA lpImeMenu, DWORD dwSize)

DWORD WINAPI	ImmGetImeMenuItemsW (HIMC hIMC, DWORD dwFlags, DWORD dwType, LPIMEMENUITEMINFOW lpImeParentMenu, LPIMEMENUITEMINFOW lpImeMenu, DWORD dwSize)

LPINPUTCONTEXT WINAPI	ImmLockIMC (HIMC hIMC)

BOOL WINAPI	ImmUnlockIMC (HIMC hIMC)

DWORD WINAPI	ImmGetIMCLockCount (HIMC hIMC)

HIMCC WINAPI	ImmCreateIMCC (DWORD size)

HIMCC WINAPI	ImmDestroyIMCC (HIMCC block)

LPVOID WINAPI	ImmLockIMCC (HIMCC imcc)

BOOL WINAPI	ImmUnlockIMCC (HIMCC imcc)

DWORD WINAPI	ImmGetIMCCLockCount (HIMCC imcc)

HIMCC WINAPI	ImmReSizeIMCC (HIMCC imcc, DWORD size)

DWORD WINAPI	ImmGetIMCCSize (HIMCC imcc)

BOOL WINAPI	ImmGenerateMessage (HIMC hIMC)

BOOL WINAPI	ImmTranslateMessage (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lKeyData)

BOOL WINAPI	ImmProcessKey (HWND hwnd, HKL hKL, UINT vKey, LPARAM lKeyData, DWORD unknown)

BOOL WINAPI	ImmDisableTextFrameService (DWORD idThread)

BOOL WINAPI	ImmEnumInputContext (DWORD idThread, IMCENUMPROC lpfn, LPARAM lParam)

BOOL WINAPI	ImmGetHotKey (DWORD hotkey, UINT modifiers, UINT key, HKL hkl)

BOOL WINAPI	ImmDisableLegacyIME (void)

Variables
static struct list	ImmHklList = LIST_INIT(ImmHklList)

static struct list	ImmThreadDataList = LIST_INIT(ImmThreadDataList)

static const WCHAR	szwWineIMCProperty [] = {'W','i','n','e','I','m','m','H','I','M','C','P','r','o','p','e','r','t','y',0}

static const WCHAR	szImeFileW [] = {'I','m','e',' ','F','i','l','e',0}

static const WCHAR	szLayoutTextW [] = {'L','a','y','o','u','t',' ','T','e','x','t',0}

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}

static const WCHAR	szwIME [] = {'I','M','E',0}

static const WCHAR	szwDefaultIME [] = {'D','e','f','a','u','l','t',' ','I','M','E',0}

static CRITICAL_SECTION	threaddata_cs = { &critsect_debug, -1, 0, 0, 0, 0 }

static CRITICAL_SECTION_DEBUG	critsect_debug

static BOOL	disable_ime

Macro Definition Documentation

◆ IMM_INIT_MAGIC

#define IMM_INIT_MAGIC 0x19650412

Definition at line 47 of file imm.c.

◆ LOAD_FUNCPTR

#define LOAD_FUNCPTR ( f ) if((ptr->p##f = (LPVOID)GetProcAddress(ptr->hIME, #f)) == NULL){WARN("Can't find function %s in ime\n", #f);}

Definition at line 339 of file imm.c.

◆ WINE_IMC_VALID_MAGIC

#define WINE_IMC_VALID_MAGIC 0x56434D49

Definition at line 90 of file imm.c.

Typedef Documentation

◆ ImmHkl

typedef struct _tagImmHkl ImmHkl

◆ IMMThreadData

typedef struct _tagIMMThreadData IMMThreadData

◆ InputContextData

typedef struct tagInputContextData InputContextData

◆ LPTRANSMSG

typedef struct _tagTRANSMSG * LPTRANSMSG

◆ TRANSMSG

typedef struct _tagTRANSMSG TRANSMSG

Function Documentation

◆ __wine_get_ui_window()

HWND WINAPI __wine_get_ui_window ( HKL hkl )

Definition at line 408 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hkl);
     return immHkl->UIWnd;
 }

◆ __wine_register_window()

BOOL WINAPI __wine_register_window ( HWND hwnd )

Definition at line 1666 of file imm.c.

 {
     HWND new = NULL;
     IMMThreadData *thread_data;
     TRACE("(%p)\n", hwnd);
 
     if (!needs_ime_window(hwnd))
         return FALSE;
 
     thread_data = IMM_GetThreadData(hwnd, 0);
     if (!thread_data)
         return FALSE;
 
     if (thread_data->disableIME || disable_ime)
     {
         TRACE("IME for this thread is disabled\n");
         LeaveCriticalSection(&threaddata_cs);
         return FALSE;
     }
     thread_data->windowRefs++;
     TRACE("windowRefs=%u, hwndDefault=%p\n",
           thread_data->windowRefs, thread_data->hwndDefault);
 
     /* Create default IME window */
     if (thread_data->windowRefs == 1)
     {
         /* Do not create the window inside of a critical section */
         LeaveCriticalSection(&threaddata_cs);
         new = CreateWindowExW( 0, szwIME, szwDefaultIME,
                                WS_POPUP | WS_DISABLED | WS_CLIPSIBLINGS,
                                0, 0, 1, 1, 0, 0, 0, 0);
         /* thread_data is in the current thread so we can assume it's still valid */
         EnterCriticalSection(&threaddata_cs);
         /* See if anyone beat us */
         if (thread_data->hwndDefault == NULL)
         {
             thread_data->hwndDefault = new;
             new = NULL;
             TRACE("Default is %p\n", thread_data->hwndDefault);
         }
     }
 
     LeaveCriticalSection(&threaddata_cs);
 
     /* Clean up an unused new window outside of the critical section */
     if (new != NULL)
         DestroyWindow(new);
     return TRUE;
 }

◆ __wine_unregister_window()

void WINAPI __wine_unregister_window ( HWND hwnd )

Definition at line 1719 of file imm.c.

 {
     HWND to_destroy = 0;
     IMMThreadData *thread_data;
     TRACE("(%p)\n", hwnd);
 
     thread_data = IMM_GetThreadData(hwnd, 0);
     if (!thread_data) return;
 
     thread_data->windowRefs--;
     TRACE("windowRefs=%u, hwndDefault=%p\n",
           thread_data->windowRefs, thread_data->hwndDefault);
 
     /* Destroy default IME window */
     if (thread_data->windowRefs == 0 && thread_data->hwndDefault)
     {
         to_destroy = thread_data->hwndDefault;
         thread_data->hwndDefault = NULL;
     }
     LeaveCriticalSection(&threaddata_cs);
 
     if (to_destroy) DestroyWindow( to_destroy );
 }

◆ _ImmAssociateContextExEnumProc()

static BOOL CALLBACK _ImmAssociateContextExEnumProc	(	HWND	hwnd,
		LPARAM	lParam
	)

static

Definition at line 639 of file imm.c.

 {
     HIMC hImc = (HIMC)lParam;
     ImmAssociateContext(hwnd,hImc);
     return TRUE;
 }

Referenced by ImmAssociateContextEx().

◆ convert_candidatelist_AtoW()

static DWORD convert_candidatelist_AtoW	(	LPCANDIDATELIST	lpSrc,
		LPCANDIDATELIST	lpDst,
		DWORD	dwBufLen
	)

static

Definition at line 205 of file imm.c.

 {
     DWORD ret, i, len;
 
     ret = FIELD_OFFSET( CANDIDATELIST, dwOffset[lpSrc->dwCount] );
     if ( lpDst && dwBufLen > 0 )
     {
         *lpDst = *lpSrc;
         lpDst->dwOffset[0] = ret;
     }
 
     for ( i = 0; i < lpSrc->dwCount; i++)
     {
         LPBYTE src = (LPBYTE)lpSrc + lpSrc->dwOffset[i];
 
         if ( lpDst && dwBufLen > 0 )
         {
             LPBYTE dest = (LPBYTE)lpDst + lpDst->dwOffset[i];
 
             len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)src, -1,
                                       (LPWSTR)dest, dwBufLen);
 
             if ( i + 1 < lpSrc->dwCount )
                 lpDst->dwOffset[i+1] = lpDst->dwOffset[i] + len * sizeof(WCHAR);
             dwBufLen -= len * sizeof(WCHAR);
         }
         else
             len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)src, -1, NULL, 0);
 
         ret += len * sizeof(WCHAR);
     }
 
     if ( lpDst )
         lpDst->dwSize = ret;
 
     return ret;
 }

Referenced by ImmGetCandidateListW(), and ImmGetConversionListW().

◆ convert_candidatelist_WtoA()

static DWORD convert_candidatelist_WtoA	(	LPCANDIDATELIST	lpSrc,
		LPCANDIDATELIST	lpDst,
		DWORD	dwBufLen
	)

static

Definition at line 166 of file imm.c.

 {
     DWORD ret, i, len;
 
     ret = FIELD_OFFSET( CANDIDATELIST, dwOffset[lpSrc->dwCount] );
     if ( lpDst && dwBufLen > 0 )
     {
         *lpDst = *lpSrc;
         lpDst->dwOffset[0] = ret;
     }
 
     for ( i = 0; i < lpSrc->dwCount; i++)
     {
         LPBYTE src = (LPBYTE)lpSrc + lpSrc->dwOffset[i];
 
         if ( lpDst && dwBufLen > 0 )
         {
             LPBYTE dest = (LPBYTE)lpDst + lpDst->dwOffset[i];
 
             len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)src, -1,
                                       (LPSTR)dest, dwBufLen, NULL, NULL);
 
             if ( i + 1 < lpSrc->dwCount )
                 lpDst->dwOffset[i+1] = lpDst->dwOffset[i] + len * sizeof(char);
             dwBufLen -= len * sizeof(char);
         }
         else
             len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)src, -1, NULL, 0, NULL, NULL);
 
         ret += len * sizeof(char);
     }
 
     if ( lpDst )
         lpDst->dwSize = ret;
 
     return ret;
 }

Referenced by ImmGetCandidateListA(), and ImmGetConversionListA().

◆ CopyCompAttrIMEtoClient()

static INT CopyCompAttrIMEtoClient	(	const InputContextData *	data,
		const BYTE *	src,
		INT	src_len,
		const void *	comp_string,
		INT	str_len,
		BYTE *	dst,
		INT	dst_len,
		BOOL	unicode
	)

static

Definition at line 1251 of file imm.c.

 {
     union
     {
         const void *str;
         const WCHAR *strW;
         const char *strA;
     } string;
     INT rc;
 
     string.str = comp_string;
 
     if (is_himc_ime_unicode(data) && !unicode)
     {
         rc = WideCharToMultiByte(CP_ACP, 0, string.strW, str_len, NULL, 0, NULL, NULL);
         if (dst_len)
         {
             int i, j = 0, k = 0;
 
             if (rc < dst_len)
                 dst_len = rc;
             for (i = 0; i < str_len; ++i)
             {
                 int len;
 
                 len = WideCharToMultiByte(CP_ACP, 0, string.strW + i, 1, NULL, 0, NULL, NULL);
                 for (; len > 0; --len)
                 {
                     dst[j++] = src[k];
 
                     if (j >= dst_len)
                         goto end;
                 }
                 ++k;
             }
         end:
             rc = j;
         }
     }
     else if (!is_himc_ime_unicode(data) && unicode)
     {
         rc = MultiByteToWideChar(CP_ACP, 0, string.strA, str_len, NULL, 0);
         if (dst_len)
         {
             int i, j = 0;
 
             if (rc < dst_len)
                 dst_len = rc;
             for (i = 0; i < str_len; ++i)
             {
                 if (IsDBCSLeadByte(string.strA[i]))
                     continue;
 
                 dst[j++] = src[i];
 
                 if (j >= dst_len)
                     break;
             }
             rc = j;
         }
     }
     else
     {
         memcpy(dst, src, min(src_len, dst_len));
         rc = src_len;
     }
 
     return rc;
 }

Referenced by ImmGetCompositionStringT().

◆ CopyCompClauseIMEtoClient()

static INT CopyCompClauseIMEtoClient	(	InputContextData *	data,
		LPBYTE	source,
		INT	slen,
		LPBYTE	ssource,
		LPBYTE	target,
		INT	tlen,
		BOOL	unicode
	)

static

Definition at line 1322 of file imm.c.

 {
     INT rc;
 
     if (is_himc_ime_unicode(data) && !unicode)
     {
         if (tlen)
         {
             int i;
 
             if (slen < tlen)
                 tlen = slen;
             tlen /= sizeof (DWORD);
             for (i = 0; i < tlen; ++i)
             {
                 ((DWORD *)target)[i] = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource,
                                                           ((DWORD *)source)[i],
                                                           NULL, 0,
                                                           NULL, NULL);
             }
             rc = sizeof (DWORD) * i;
         }
         else
             rc = slen;
     }
     else if (!is_himc_ime_unicode(data) && unicode)
     {
         if (tlen)
         {
             int i;
 
             if (slen < tlen)
                 tlen = slen;
             tlen /= sizeof (DWORD);
             for (i = 0; i < tlen; ++i)
             {
                 ((DWORD *)target)[i] = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource,
                                                           ((DWORD *)source)[i],
                                                           NULL, 0);
             }
             rc = sizeof (DWORD) * i;
         }
         else
             rc = slen;
     }
     else
     {
         memcpy( target, source, min(slen,tlen));
         rc = slen;
     }
 
     return rc;
 }

Referenced by ImmGetCompositionStringT().

◆ CopyCompOffsetIMEtoClient()

static INT CopyCompOffsetIMEtoClient	(	InputContextData *	data,
		DWORD	offset,
		LPBYTE	ssource,
		BOOL	unicode
	)

static

Definition at line 1377 of file imm.c.

 {
     int rc;
 
     if (is_himc_ime_unicode(data) && !unicode)
     {
         rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource, offset, NULL, 0, NULL, NULL);
     }
     else if (!is_himc_ime_unicode(data) && unicode)
     {
         rc = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource, offset, NULL, 0);
     }
     else
         rc = offset;
 
     return rc;
 }

Referenced by ImmGetCompositionStringT().

◆ CopyCompStringIMEtoClient()

static INT CopyCompStringIMEtoClient	(	const InputContextData *	data,
		const void *	src,
		INT	src_len,
		void *	dst,
		INT	dst_len,
		BOOL	unicode
	)

static

Definition at line 1221 of file imm.c.

 {
     int char_size = unicode ? sizeof(WCHAR) : sizeof(char);
     INT ret;
 
     if (is_himc_ime_unicode(data) ^ unicode)
     {
         if (unicode)
             ret = MultiByteToWideChar(CP_ACP, 0, src, src_len, dst, dst_len / sizeof(WCHAR));
         else
             ret = WideCharToMultiByte(CP_ACP, 0, src, src_len, dst, dst_len, NULL, NULL);
         ret *= char_size;
     }
     else
     {
         if (dst_len)
         {
             ret = min(src_len * char_size, dst_len);
             memcpy(dst, src, ret);
         }
         else
             ret = src_len * char_size;
     }
 
     return ret;
 }

Referenced by ImmGetCompositionStringT().

◆ DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	hInstDLL,
		DWORD	fdwReason,
		LPVOID	lpReserved
	)

Definition at line 432 of file imm.c.

 {
     TRACE("%p, %x, %p\n",hInstDLL,fdwReason,lpReserved);
     switch (fdwReason)
     {
         case DLL_PROCESS_ATTACH:
             if (!User32InitializeImmEntryTable(IMM_INIT_MAGIC))
             {
                 return FALSE;
             }
             break;
         case DLL_THREAD_ATTACH:
             break;
         case DLL_THREAD_DETACH:
             IMM_FreeThreadData();
             break;
         case DLL_PROCESS_DETACH:
             if (lpReserved) break;
             IMM_FreeThreadData();
             IMM_FreeAllImmHkl();
             break;
     }
     return TRUE;
 }

◆ EscapeRequiresWA()

static BOOL EscapeRequiresWA ( UINT uEscape )

inlinestatic

Definition at line 933 of file imm.c.

 {
         if (uEscape == IME_ESC_GET_EUDC_DICTIONARY ||
             uEscape == IME_ESC_SET_EUDC_DICTIONARY ||
             uEscape == IME_ESC_IME_NAME ||
             uEscape == IME_ESC_GETHELPFILENAME)
         return TRUE;
     return FALSE;
 }

Referenced by ImmEscapeA(), and ImmEscapeW().

◆ get_default_context()

static HIMC get_default_context ( HWND hwnd )

static

Definition at line 517 of file imm.c.

 {
     HIMC ret;
     IMMThreadData* thread_data = IMM_GetThreadData( hwnd, 0 );
 
     if (!thread_data) return 0;
 
     if (thread_data->defaultContext)
     {
         ret = thread_data->defaultContext;
         LeaveCriticalSection(&threaddata_cs);
         return ret;
     }
 
     /* can't create a default context in another thread */
     if (thread_data->threadID != GetCurrentThreadId())
     {
         LeaveCriticalSection(&threaddata_cs);
         return 0;
     }
 
     LeaveCriticalSection(&threaddata_cs);
 
     ret = ImmCreateContext();
     if (!ret) return 0;
     ((InputContextData*)ret)->threadDefault = TRUE;
 
     /* thread_data is in the current thread so we can assume it's still valid */
     EnterCriticalSection(&threaddata_cs);
 
     if (thread_data->defaultContext) /* someone beat us */
     {
         IMM_DestroyContext( ret );
         ret = thread_data->defaultContext;
     }
     else thread_data->defaultContext = ret;
 
     LeaveCriticalSection(&threaddata_cs);
     return ret;
 }

Referenced by ImmAssociateContext(), ImmAssociateContextEx(), and ImmGetContext().

◆ get_imc_data()

static InputContextData * get_imc_data ( HIMC hIMC )

static

Definition at line 502 of file imm.c.

 {
     InputContextData *data = hIMC;
 
     if (hIMC == NULL)
         return NULL;
 
     if(IsBadReadPtr(data, sizeof(InputContextData)) || data->magic != WINE_IMC_VALID_MAGIC)
     {
         SetLastError(ERROR_INVALID_HANDLE);
         return NULL;
     }
     return data;
 }

Referenced by IMM_DestroyContext(), IMM_IsCrossThreadAccess(), IMM_IsDefaultContext(), ImmAssociateContext(), ImmGenerateMessage(), ImmGetCandidateListA(), ImmGetCandidateListCountA(), ImmGetCandidateListCountW(), ImmGetCandidateListW(), ImmGetCandidateWindow(), ImmGetCompositionFontW(), ImmGetCompositionStringT(), ImmGetCompositionWindow(), ImmGetConversionStatus(), ImmGetIMCLockCount(), ImmGetImeMenuItemsA(), ImmGetImeMenuItemsW(), ImmGetOpenStatus(), ImmGetStatusWindowPos(), ImmLockIMC(), ImmNotifyIME(), ImmRequestMessageA(), ImmRequestMessageW(), ImmSetCandidateWindow(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmSetCompositionStringA(), ImmSetCompositionStringW(), ImmSetCompositionWindow(), ImmSetConversionStatus(), ImmSetOpenStatus(), ImmSetStatusWindowPos(), and ImmUnlockIMC().

◆ IMM_DestroyContext()

static BOOL IMM_DestroyContext ( HIMC hIMC )

static

Definition at line 812 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
 
     TRACE("Destroying %p\n",hIMC);
 
     if (!data)
         return FALSE;
 
     data->immKbd->uSelected --;
     data->immKbd->pImeSelect(hIMC, FALSE);
     SendMessageW(data->IMC.hWnd, WM_IME_SELECT, FALSE, (LPARAM)data->immKbd);
 
     ImmDestroyIMCC(data->IMC.hCompStr);
     ImmDestroyIMCC(data->IMC.hCandInfo);
     ImmDestroyIMCC(data->IMC.hGuideLine);
     ImmDestroyIMCC(data->IMC.hPrivate);
     ImmDestroyIMCC(data->IMC.hMsgBuf);
 
     data->magic = 0;
     HeapFree(GetProcessHeap(),0,data);
 
     return TRUE;
 }

Referenced by get_default_context(), IMM_FreeThreadData(), ImmCreateContext(), and ImmDestroyContext().

◆ IMM_FreeAllImmHkl()

static void IMM_FreeAllImmHkl ( void )

static

Definition at line 414 of file imm.c.

 {
     ImmHkl *ptr,*cursor2;
 
     LIST_FOR_EACH_ENTRY_SAFE(ptr, cursor2, &ImmHklList, ImmHkl, entry)
     {
         list_remove(&ptr->entry);
         if (ptr->hIME)
         {
             ptr->pImeDestroy(1);
             FreeLibrary(ptr->hIME);
         }
         if (ptr->UIWnd)
             DestroyWindow(ptr->UIWnd);
         HeapFree(GetProcessHeap(),0,ptr);
     }
 }

Referenced by DllMain().

◆ IMM_FreeThreadData()

static void IMM_FreeThreadData ( void )

static

Definition at line 286 of file imm.c.

 {
     IMMThreadData *data;
 
     EnterCriticalSection(&threaddata_cs);
     LIST_FOR_EACH_ENTRY(data, &ImmThreadDataList, IMMThreadData, entry)
     {
         if (data->threadID == GetCurrentThreadId())
         {
             list_remove(&data->entry);
             LeaveCriticalSection(&threaddata_cs);
             IMM_DestroyContext(data->defaultContext);
             HeapFree(GetProcessHeap(),0,data);
             TRACE("Thread Data Destroyed\n");
             return;
         }
     }
     LeaveCriticalSection(&threaddata_cs);
 }

Referenced by DllMain().

◆ IMM_GetImmHkl()

static ImmHkl* IMM_GetImmHkl ( HKL hkl )

static

Definition at line 340 of file imm.c.

 {
     ImmHkl *ptr;
     WCHAR filename[MAX_PATH];
 
     TRACE("Seeking ime for keyboard %p\n",hkl);
 
     LIST_FOR_EACH_ENTRY(ptr, &ImmHklList, ImmHkl, entry)
     {
         if (ptr->hkl == hkl)
             return ptr;
     }
     /* not found... create it */
 
     ptr = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ImmHkl));
 
     ptr->hkl = hkl;
     if (ImmGetIMEFileNameW(hkl, filename, MAX_PATH)) ptr->hIME = LoadLibraryW(filename);
     if (!ptr->hIME) ptr->hIME = load_graphics_driver();
     if (ptr->hIME)
     {
         LOAD_FUNCPTR(ImeInquire);
         if (!ptr->pImeInquire || !ptr->pImeInquire(&ptr->imeInfo, ptr->imeClassName, NULL))
         {
             FreeLibrary(ptr->hIME);
             ptr->hIME = NULL;
         }
         else
         {
             LOAD_FUNCPTR(ImeDestroy);
             LOAD_FUNCPTR(ImeSelect);
             if (!ptr->pImeSelect || !ptr->pImeDestroy)
             {
                 FreeLibrary(ptr->hIME);
                 ptr->hIME = NULL;
             }
             else
             {
                 LOAD_FUNCPTR(ImeConfigure);
                 LOAD_FUNCPTR(ImeEscape);
                 LOAD_FUNCPTR(ImeSetActiveContext);
                 LOAD_FUNCPTR(ImeToAsciiEx);
                 LOAD_FUNCPTR(NotifyIME);
                 LOAD_FUNCPTR(ImeRegisterWord);
                 LOAD_FUNCPTR(ImeUnregisterWord);
                 LOAD_FUNCPTR(ImeEnumRegisterWord);
                 LOAD_FUNCPTR(ImeSetCompositionString);
                 LOAD_FUNCPTR(ImeConversionList);
                 LOAD_FUNCPTR(ImeProcessKey);
                 LOAD_FUNCPTR(ImeGetRegisterWordStyle);
                 LOAD_FUNCPTR(ImeGetImeMenuItems);
                 /* make sure our classname is WCHAR */
                 if (!is_kbd_ime_unicode(ptr))
                 {
                     WCHAR bufW[17];
                     MultiByteToWideChar(CP_ACP, 0, (LPSTR)ptr->imeClassName,
                                         -1, bufW, 17);
                     lstrcpyW(ptr->imeClassName, bufW);
                 }
             }
         }
     }
     list_add_head(&ImmHklList,&ptr->entry);
 
     return ptr;
 }

Referenced by __wine_get_ui_window(), ImmConfigureIMEA(), ImmConfigureIMEW(), ImmCreateContext(), ImmEnumRegisterWordA(), ImmEnumRegisterWordW(), ImmEscapeA(), ImmEscapeW(), ImmGetConversionListA(), ImmGetConversionListW(), ImmGetProperty(), ImmGetRegisterWordStyleA(), ImmGetRegisterWordStyleW(), ImmIsIME(), ImmProcessKey(), ImmRegisterWordA(), ImmRegisterWordW(), ImmUnregisterWordA(), and ImmUnregisterWordW().

◆ IMM_GetThreadData()

static IMMThreadData* IMM_GetThreadData	(	HWND	hwnd,
		DWORD	thread
	)

static

Definition at line 244 of file imm.c.

 {
     IMMThreadData *data;
     DWORD process;
 
     if (hwnd)
     {
         if (!(thread = GetWindowThreadProcessId(hwnd, &process))) return NULL;
         if (process != GetCurrentProcessId()) return NULL;
     }
     else if (thread)
     {
         HANDLE h = OpenThread(THREAD_QUERY_INFORMATION, FALSE, thread);
         if (!h) return NULL;
         process = GetProcessIdOfThread(h);
         CloseHandle(h);
         if (process != GetCurrentProcessId()) return NULL;
     }
     else
         thread = GetCurrentThreadId();
 
     EnterCriticalSection(&threaddata_cs);
     LIST_FOR_EACH_ENTRY(data, &ImmThreadDataList, IMMThreadData, entry)
         if (data->threadID == thread) return data;
 
     data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data));
     data->threadID = thread;
     list_add_head(&ImmThreadDataList,&data->entry);
     TRACE("Thread Data Created (%x)\n",thread);
     return data;
 }

Referenced by __wine_register_window(), __wine_unregister_window(), get_default_context(), ImmDisableIME(), and ImmGetDefaultIMEWnd().

◆ IMM_IsCrossThreadAccess()

static BOOL IMM_IsCrossThreadAccess	(	HWND	hWnd,
		HIMC	hIMC
	)

static

Definition at line 558 of file imm.c.

 {
     InputContextData *data;
 
     if (hWnd)
     {
         DWORD thread = GetWindowThreadProcessId(hWnd, NULL);
         if (thread != GetCurrentThreadId()) return TRUE;
     }
     data = get_imc_data(hIMC);
     if (data && data->threadID != GetCurrentThreadId())
         return TRUE;
 
     return FALSE;
 }

Referenced by ImmAssociateContext(), ImmDestroyContext(), ImmSetCandidateWindow(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmSetCompositionWindow(), ImmSetConversionStatus(), ImmSetOpenStatus(), and ImmSetStatusWindowPos().

◆ IMM_IsDefaultContext()

static BOOL IMM_IsDefaultContext ( HIMC imc )

static

Definition at line 276 of file imm.c.

 {
     InputContextData *data = get_imc_data(imc);
 
     if (!data)
         return FALSE;
 
     return data->threadDefault;
 }

Referenced by ImmDestroyContext().

◆ ImmAssociateContext()

HIMC WINAPI ImmAssociateContext	(	HWND	hWnd,
		HIMC	hIMC
	)

Definition at line 577 of file imm.c.

 {
     HIMC old = NULL;
     InputContextData *data = get_imc_data(hIMC);
 
     TRACE("(%p, %p):\n", hWnd, hIMC);
 
     if(hIMC && !data)
         return NULL;
 
     /*
      * If already associated just return
      */
     if (hIMC && data->IMC.hWnd == hWnd)
         return hIMC;
 
     if (hIMC && IMM_IsCrossThreadAccess(hWnd, hIMC))
         return NULL;
 
     if (hWnd)
     {
         HIMC defaultContext = get_default_context( hWnd );
         old = RemovePropW(hWnd,szwWineIMCProperty);
 
         if (old == NULL)
             old = defaultContext;
         else if (old == (HIMC)-1)
             old = NULL;
 
         if (hIMC != defaultContext)
         {
             if (hIMC == NULL) /* Meaning disable imm for that window*/
                 SetPropW(hWnd,szwWineIMCProperty,(HANDLE)-1);
             else
                 SetPropW(hWnd,szwWineIMCProperty,hIMC);
         }
 
         if (old)
         {
             InputContextData *old_data = old;
             if (old_data->IMC.hWnd == hWnd)
                 old_data->IMC.hWnd = NULL;
         }
     }
 
     if (!hIMC)
         return old;
 
     if(GetActiveWindow() == data->IMC.hWnd)
     {
         SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
         data->IMC.hWnd = hWnd;
         SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
     }
 
     return old;
 }

Referenced by _ImmAssociateContextExEnumProc(), ActiveIMMApp_AssociateContext(), ImmAssociateContextEx(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmAssociateContextEx()

BOOL WINAPI ImmAssociateContextEx	(	HWND	hWnd,
		HIMC	hIMC,
		DWORD	dwFlags
	)

Definition at line 649 of file imm.c.

 {
     TRACE("(%p, %p, 0x%x):\n", hWnd, hIMC, dwFlags);
 
     if (!hWnd)
         return FALSE;
 
     switch (dwFlags)
     {
     case 0:
         ImmAssociateContext(hWnd,hIMC);
         return TRUE;
     case IACE_DEFAULT:
     {
         HIMC defaultContext = get_default_context( hWnd );
         if (!defaultContext) return FALSE;
         ImmAssociateContext(hWnd,defaultContext);
         return TRUE;
     }
     case IACE_IGNORENOCONTEXT:
         if (GetPropW(hWnd,szwWineIMCProperty))
             ImmAssociateContext(hWnd,hIMC);
         return TRUE;
     case IACE_CHILDREN:
         EnumChildWindows(hWnd,_ImmAssociateContextExEnumProc,(LPARAM)hIMC);
         return TRUE;
     default:
         FIXME("Unknown dwFlags 0x%x\n",dwFlags);
         return FALSE;
     }
 }

Referenced by ActiveIMMApp_AssociateContextEx().

◆ ImmConfigureIMEA()

BOOL WINAPI ImmConfigureIMEA	(	HKL	hKL,
		HWND	hWnd,
		DWORD	dwMode,
		LPVOID	lpData
	)

Definition at line 684 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 
     TRACE("(%p, %p, %d, %p):\n", hKL, hWnd, dwMode, lpData);
 
     if (dwMode == IME_CONFIG_REGISTERWORD && !lpData)
         return FALSE;
 
     if (immHkl->hIME && immHkl->pImeConfigure)
     {
         if (dwMode != IME_CONFIG_REGISTERWORD || !is_kbd_ime_unicode(immHkl))
             return immHkl->pImeConfigure(hKL,hWnd,dwMode,lpData);
         else
         {
             REGISTERWORDW rww;
             REGISTERWORDA *rwa = lpData;
             BOOL rc;
 
             rww.lpReading = strdupAtoW(rwa->lpReading);
             rww.lpWord = strdupAtoW(rwa->lpWord);
             rc = immHkl->pImeConfigure(hKL,hWnd,dwMode,&rww);
             HeapFree(GetProcessHeap(),0,rww.lpReading);
             HeapFree(GetProcessHeap(),0,rww.lpWord);
             return rc;
         }
     }
     else
         return FALSE;
 }

Referenced by ActiveIMMApp_ConfigureIMEA(), and test_ImmIME().

◆ ImmConfigureIMEW()

BOOL WINAPI ImmConfigureIMEW	(	HKL	hKL,
		HWND	hWnd,
		DWORD	dwMode,
		LPVOID	lpData
	)

Definition at line 719 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
 
     TRACE("(%p, %p, %d, %p):\n", hKL, hWnd, dwMode, lpData);
 
     if (dwMode == IME_CONFIG_REGISTERWORD && !lpData)
         return FALSE;
 
     if (immHkl->hIME && immHkl->pImeConfigure)
     {
         if (dwMode != IME_CONFIG_REGISTERWORD || is_kbd_ime_unicode(immHkl))
             return immHkl->pImeConfigure(hKL,hWnd,dwMode,lpData);
         else
         {
             REGISTERWORDW *rww = lpData;
             REGISTERWORDA rwa;
             BOOL rc;
 
             rwa.lpReading = strdupWtoA(rww->lpReading);
             rwa.lpWord = strdupWtoA(rww->lpWord);
             rc = immHkl->pImeConfigure(hKL,hWnd,dwMode,&rwa);
             HeapFree(GetProcessHeap(),0,rwa.lpReading);
             HeapFree(GetProcessHeap(),0,rwa.lpWord);
             return rc;
         }
     }
     else
         return FALSE;
 }

Referenced by ActiveIMMApp_ConfigureIMEW(), and test_ImmIME().

◆ ImmCreateBlankCompStr()

static HIMCC ImmCreateBlankCompStr ( void )

static

Definition at line 490 of file imm.c.

 {
     HIMCC rc;
     LPCOMPOSITIONSTRING ptr;
     rc = ImmCreateIMCC(sizeof(COMPOSITIONSTRING));
     ptr = ImmLockIMCC(rc);
     memset(ptr,0,sizeof(COMPOSITIONSTRING));
     ptr->dwSize = sizeof(COMPOSITIONSTRING);
     ImmUnlockIMCC(rc);
     return rc;
 }

Referenced by ImmCreateContext().

◆ ImmCreateContext()

HIMC WINAPI ImmCreateContext ( void )

Definition at line 754 of file imm.c.

 {
     InputContextData *new_context;
     LPGUIDELINE gl;
     LPCANDIDATEINFO ci;
     int i;
 
     new_context = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(InputContextData));
 
     /* Load the IME */
     new_context->immKbd = IMM_GetImmHkl(GetKeyboardLayout(0));
 
     if (!new_context->immKbd->hIME)
     {
         TRACE("IME dll could not be loaded\n");
         HeapFree(GetProcessHeap(),0,new_context);
         return 0;
     }
 
     /* the HIMCCs are never NULL */
     new_context->IMC.hCompStr = ImmCreateBlankCompStr();
     new_context->IMC.hMsgBuf = ImmCreateIMCC(0);
     new_context->IMC.hCandInfo = ImmCreateIMCC(sizeof(CANDIDATEINFO));
     ci = ImmLockIMCC(new_context->IMC.hCandInfo);
     memset(ci,0,sizeof(CANDIDATEINFO));
     ci->dwSize = sizeof(CANDIDATEINFO);
     ImmUnlockIMCC(new_context->IMC.hCandInfo);
     new_context->IMC.hGuideLine = ImmCreateIMCC(sizeof(GUIDELINE));
     gl = ImmLockIMCC(new_context->IMC.hGuideLine);
     memset(gl,0,sizeof(GUIDELINE));
     gl->dwSize = sizeof(GUIDELINE);
     ImmUnlockIMCC(new_context->IMC.hGuideLine);
 
     for (i = 0; i < ARRAY_SIZE(new_context->IMC.cfCandForm); i++)
         new_context->IMC.cfCandForm[i].dwIndex = ~0u;
 
     /* Initialize the IME Private */
     new_context->IMC.hPrivate = ImmCreateIMCC(new_context->immKbd->imeInfo.dwPrivateDataSize);
 
     new_context->IMC.fdwConversion = new_context->immKbd->imeInfo.fdwConversionCaps;
     new_context->IMC.fdwSentence = new_context->immKbd->imeInfo.fdwSentenceCaps;
 
     if (!new_context->immKbd->pImeSelect(new_context, TRUE))
     {
         TRACE("Selection of IME failed\n");
         IMM_DestroyContext(new_context);
         return 0;
     }
     new_context->threadID = GetCurrentThreadId();
     SendMessageW(GetFocus(), WM_IME_SELECT, TRUE, (LPARAM)new_context->immKbd);
 
     new_context->immKbd->uSelected++;
     TRACE("Created context %p\n",new_context);
 
     new_context->magic = WINE_IMC_VALID_MAGIC;
     return new_context;
 }

Referenced by ActiveIMMApp_CreateContext(), get_default_context(), ImmGetContextThreadFunc(), test_ImmAssociateContextEx(), test_ImmDefaultHwnd(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmNotifyIME(), and test_InvalidIMC().

◆ ImmCreateIMCC()

HIMCC WINAPI ImmCreateIMCC ( DWORD size )

Definition at line 2956 of file imm.c.

 {
     return GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE, size);
 }

Referenced by ImmCreateBlankCompStr(), ImmCreateContext(), ImmGenerateMessage(), test_ImmDestroyIMCC(), and test_ImmGetIMCCLockCount().

◆ ImmCreateSoftKeyboard()

HWND WINAPI ImmCreateSoftKeyboard	(	UINT	uType,
		UINT	hOwner,
		int	x,
		int	y
	)

Definition at line 2667 of file imm.c.

 {
     FIXME("(%d, %d, %d, %d): stub\n", uType, hOwner, x, y);
     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     return 0;
 }

◆ ImmDestroyContext()

BOOL WINAPI ImmDestroyContext ( HIMC hIMC )

Definition at line 840 of file imm.c.

 {
     if (!IMM_IsDefaultContext(hIMC) && !IMM_IsCrossThreadAccess(NULL, hIMC))
         return IMM_DestroyContext(hIMC);
     else
         return FALSE;
 }

Referenced by ActiveIMMApp_DestroyContext(), test_ImmDefaultHwnd(), test_ImmDestroyContext(), test_ImmGetIMCLockCount(), test_ImmNotifyIME(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmDestroyIMCC()

HIMCC WINAPI ImmDestroyIMCC ( HIMCC block )

Definition at line 2964 of file imm.c.

 {
     return GlobalFree(block);
 }

Referenced by IMM_DestroyContext(), ImmGenerateMessage(), test_ImmDestroyIMCC(), and test_ImmGetIMCCLockCount().

◆ ImmDestroySoftKeyboard()

BOOL WINAPI ImmDestroySoftKeyboard ( HWND hSoftWnd )

Definition at line 2677 of file imm.c.

 {
 #ifdef __REACTOS__
     TRACE("(%p)\n", hSoftWnd);
     return DestroyWindow(hSoftWnd);
 #else
     FIXME("(%p): stub\n", hSoftWnd);
     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     return FALSE;
 #endif
 }

◆ ImmDisableIME()

BOOL WINAPI ImmDisableIME ( DWORD idThread )

Definition at line 851 of file imm.c.

 {
     if (idThread == (DWORD)-1)
         disable_ime = TRUE;
     else {
         IMMThreadData *thread_data = IMM_GetThreadData(NULL, idThread);
         if (!thread_data) return FALSE;
         thread_data->disableIME = TRUE;
         LeaveCriticalSection(&threaddata_cs);
     }
     return TRUE;
 }

Referenced by ActiveIMMApp_DisableIME(), and test_default_ime_disabled_cb().

◆ ImmDisableLegacyIME()

BOOL WINAPI ImmDisableLegacyIME ( void )

Definition at line 3205 of file imm.c.

 {
     FIXME("stub\n");
     return TRUE;
 }

◆ ImmDisableTextFrameService()

BOOL WINAPI ImmDisableTextFrameService ( DWORD idThread )

Definition at line 3162 of file imm.c.

 {
     FIXME("Stub\n");
     return FALSE;
 }

◆ ImmEnumInputContext()

BOOL WINAPI ImmEnumInputContext	(	DWORD	idThread,
		IMCENUMPROC	lpfn,
		LPARAM	lParam
	)

Definition at line 3172 of file imm.c.

 {
     FIXME("Stub\n");
     return FALSE;
 }

◆ ImmEnumRegisterWordA()

UINT WINAPI ImmEnumRegisterWordA	(	HKL	hKL,
		REGISTERWORDENUMPROCA	lpfnEnumProc,
		LPCSTR	lpszReading,
		DWORD	dwStyle,
		LPCSTR	lpszRegister,
		LPVOID	lpData
	)

Definition at line 867 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
     TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL, lpfnEnumProc,
         debugstr_a(lpszReading), dwStyle, debugstr_a(lpszRegister), lpData);
     if (immHkl->hIME && immHkl->pImeEnumRegisterWord)
     {
         if (!is_kbd_ime_unicode(immHkl))
             return immHkl->pImeEnumRegisterWord((REGISTERWORDENUMPROCW)lpfnEnumProc,
                 (LPCWSTR)lpszReading, dwStyle, (LPCWSTR)lpszRegister, lpData);
         else
         {
             LPWSTR lpszwReading = strdupAtoW(lpszReading);
             LPWSTR lpszwRegister = strdupAtoW(lpszRegister);
             BOOL rc;
 
             rc = immHkl->pImeEnumRegisterWord((REGISTERWORDENUMPROCW)lpfnEnumProc,
                                               lpszwReading, dwStyle, lpszwRegister,
                                               lpData);
 
             HeapFree(GetProcessHeap(),0,lpszwReading);
             HeapFree(GetProcessHeap(),0,lpszwRegister);
             return rc;
         }
     }
     else
         return 0;
 }

◆ ImmEnumRegisterWordW()

UINT WINAPI ImmEnumRegisterWordW	(	HKL	hKL,
		REGISTERWORDENUMPROCW	lpfnEnumProc,
		LPCWSTR	lpszReading,
		DWORD	dwStyle,
		LPCWSTR	lpszRegister,
		LPVOID	lpData
	)

Definition at line 902 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
     TRACE("(%p, %p, %s, %d, %s, %p):\n", hKL, lpfnEnumProc,
         debugstr_w(lpszReading), dwStyle, debugstr_w(lpszRegister), lpData);
     if (immHkl->hIME && immHkl->pImeEnumRegisterWord)
     {
         if (is_kbd_ime_unicode(immHkl))
             return immHkl->pImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
                                             lpszRegister, lpData);
         else
         {
             LPSTR lpszaReading = strdupWtoA(lpszReading);
             LPSTR lpszaRegister = strdupWtoA(lpszRegister);
             BOOL rc;
 
             rc = immHkl->pImeEnumRegisterWord(lpfnEnumProc, (LPCWSTR)lpszaReading,
                                               dwStyle, (LPCWSTR)lpszaRegister, lpData);
 
             HeapFree(GetProcessHeap(),0,lpszaReading);
             HeapFree(GetProcessHeap(),0,lpszaRegister);
             return rc;
         }
     }
     else
         return 0;
 }

◆ ImmEscapeA()

LRESULT WINAPI ImmEscapeA	(	HKL	hKL,
		HIMC	hIMC,
		UINT	uEscape,
		LPVOID	lpData
	)

Definition at line 946 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
     TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
 
     if (immHkl->hIME && immHkl->pImeEscape)
     {
         if (!EscapeRequiresWA(uEscape) || !is_kbd_ime_unicode(immHkl))
             return immHkl->pImeEscape(hIMC,uEscape,lpData);
         else
         {
             WCHAR buffer[81]; /* largest required buffer should be 80 */
             LRESULT rc;
             if (uEscape == IME_ESC_SET_EUDC_DICTIONARY)
             {
                 MultiByteToWideChar(CP_ACP,0,lpData,-1,buffer,81);
                 rc = immHkl->pImeEscape(hIMC,uEscape,buffer);
             }
             else
             {
                 rc = immHkl->pImeEscape(hIMC,uEscape,buffer);
                 WideCharToMultiByte(CP_ACP,0,buffer,-1,lpData,80, NULL, NULL);
             }
             return rc;
         }
     }
     else
         return 0;
 }

Referenced by ActiveIMMApp_EscapeA().

◆ ImmEscapeW()

LRESULT WINAPI ImmEscapeW	(	HKL	hKL,
		HIMC	hIMC,
		UINT	uEscape,
		LPVOID	lpData
	)

Definition at line 981 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
     TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
 
     if (immHkl->hIME && immHkl->pImeEscape)
     {
         if (!EscapeRequiresWA(uEscape) || is_kbd_ime_unicode(immHkl))
             return immHkl->pImeEscape(hIMC,uEscape,lpData);
         else
         {
             CHAR buffer[81]; /* largest required buffer should be 80 */
             LRESULT rc;
             if (uEscape == IME_ESC_SET_EUDC_DICTIONARY)
             {
                 WideCharToMultiByte(CP_ACP,0,lpData,-1,buffer,81, NULL, NULL);
                 rc = immHkl->pImeEscape(hIMC,uEscape,buffer);
             }
             else
             {
                 rc = immHkl->pImeEscape(hIMC,uEscape,buffer);
                 MultiByteToWideChar(CP_ACP,0,buffer,-1,lpData,80);
             }
             return rc;
         }
     }
     else
         return 0;
 }

Referenced by ActiveIMMApp_EscapeW().

◆ ImmGenerateMessage()

BOOL WINAPI ImmGenerateMessage ( HIMC hIMC )

Definition at line 3012 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
 
     if (!data)
     {
         SetLastError(ERROR_INVALID_HANDLE);
         return FALSE;
     }
 
     TRACE("%i messages queued\n",data->IMC.dwNumMsgBuf);
     if (data->IMC.dwNumMsgBuf > 0)
     {
         LPTRANSMSG lpTransMsg;
         HIMCC hMsgBuf;
         DWORD i, dwNumMsgBuf;
 
         /* We are going to detach our hMsgBuff so that if processing messages
            generates new messages they go into a new buffer */
         hMsgBuf = data->IMC.hMsgBuf;
         dwNumMsgBuf = data->IMC.dwNumMsgBuf;
 
         data->IMC.hMsgBuf = ImmCreateIMCC(0);
         data->IMC.dwNumMsgBuf = 0;
 
         lpTransMsg = ImmLockIMCC(hMsgBuf);
         for (i = 0; i < dwNumMsgBuf; i++)
             ImmInternalSendIMEMessage(data, lpTransMsg[i].message, lpTransMsg[i].wParam, lpTransMsg[i].lParam);
 
         ImmUnlockIMCC(hMsgBuf);
         ImmDestroyIMCC(hMsgBuf);
     }
 
     return TRUE;
 }

Referenced by ImmTranslateMessage(), test_ImmMessages(), and test_InvalidIMC().

◆ ImmGetCandidateListA()

DWORD WINAPI ImmGetCandidateListA	(	HIMC	hIMC,
		DWORD	dwIndex,
		LPCANDIDATELIST	lpCandList,
		DWORD	dwBufLen
	)

Definition at line 1016 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
     LPCANDIDATEINFO candinfo;
     LPCANDIDATELIST candlist;
     DWORD ret = 0;
 
     TRACE("%p, %d, %p, %d\n", hIMC, dwIndex, lpCandList, dwBufLen);
 
     if (!data || !data->IMC.hCandInfo)
        return 0;
 
     candinfo = ImmLockIMCC(data->IMC.hCandInfo);
     if (dwIndex >= candinfo->dwCount || dwIndex >= ARRAY_SIZE(candinfo->dwOffset))
         goto done;
 
     candlist = (LPCANDIDATELIST)((LPBYTE)candinfo + candinfo->dwOffset[dwIndex]);
     if ( !candlist->dwSize || !candlist->dwCount )
         goto done;
 
     if ( !is_himc_ime_unicode(data) )
     {
         ret = candlist->dwSize;
         if ( lpCandList && dwBufLen >= ret )
             memcpy(lpCandList, candlist, ret);
     }
     else
         ret = convert_candidatelist_WtoA( candlist, lpCandList, dwBufLen);
 
 done:
     ImmUnlockIMCC(data->IMC.hCandInfo);
     return ret;
 }

Referenced by ActiveIMMApp_GetCandidateListA(), ImmGetCandidateListCountA(), and test_InvalidIMC().

◆ ImmGetCandidateListCountA()

DWORD WINAPI ImmGetCandidateListCountA	(	HIMC	hIMC,
		LPDWORD	lpdwListCount
	)

Definition at line 1055 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
     LPCANDIDATEINFO candinfo;
     DWORD ret, count;
 
     TRACE("%p, %p\n", hIMC, lpdwListCount);
 
     if (!data || !lpdwListCount || !data->IMC.hCandInfo)
        return 0;
 
     candinfo = ImmLockIMCC(data->IMC.hCandInfo);
 
     *lpdwListCount = count = candinfo->dwCount;
 
     if ( !is_himc_ime_unicode(data) )
         ret = candinfo->dwSize;
     else
     {
         ret = sizeof(CANDIDATEINFO);
         while ( count-- )
             ret += ImmGetCandidateListA(hIMC, count, NULL, 0);
     }
 
     ImmUnlockIMCC(data->IMC.hCandInfo);
     return ret;
 }

Referenced by ActiveIMMApp_GetCandidateListCountA(), ActiveIMMApp_GetCandidateListCountW(), and test_InvalidIMC().

◆ ImmGetCandidateListCountW()

DWORD WINAPI ImmGetCandidateListCountW	(	HIMC	hIMC,
		LPDWORD	lpdwListCount
	)

Definition at line 1087 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
     LPCANDIDATEINFO candinfo;
     DWORD ret, count;
 
     TRACE("%p, %p\n", hIMC, lpdwListCount);
 
     if (!data || !lpdwListCount || !data->IMC.hCandInfo)
        return 0;
 
     candinfo = ImmLockIMCC(data->IMC.hCandInfo);
 
     *lpdwListCount = count = candinfo->dwCount;
 
     if ( is_himc_ime_unicode(data) )
         ret = candinfo->dwSize;
     else
     {
         ret = sizeof(CANDIDATEINFO);
         while ( count-- )
             ret += ImmGetCandidateListW(hIMC, count, NULL, 0);
     }
 
     ImmUnlockIMCC(data->IMC.hCandInfo);
     return ret;
 }

◆ ImmGetCandidateListW()

DWORD WINAPI ImmGetCandidateListW	(	HIMC	hIMC,
		DWORD	dwIndex,
		LPCANDIDATELIST	lpCandList,
		DWORD	dwBufLen
	)

Definition at line 1119 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
     LPCANDIDATEINFO candinfo;
     LPCANDIDATELIST candlist;
     DWORD ret = 0;
 
     TRACE("%p, %d, %p, %d\n", hIMC, dwIndex, lpCandList, dwBufLen);
 
     if (!data || !data->IMC.hCandInfo)
        return 0;
 
     candinfo = ImmLockIMCC(data->IMC.hCandInfo);
     if (dwIndex >= candinfo->dwCount || dwIndex >= ARRAY_SIZE(candinfo->dwOffset))
         goto done;
 
     candlist = (LPCANDIDATELIST)((LPBYTE)candinfo + candinfo->dwOffset[dwIndex]);
     if ( !candlist->dwSize || !candlist->dwCount )
         goto done;
 
     if ( is_himc_ime_unicode(data) )
     {
         ret = candlist->dwSize;
         if ( lpCandList && dwBufLen >= ret )
             memcpy(lpCandList, candlist, ret);
     }
     else
         ret = convert_candidatelist_AtoW( candlist, lpCandList, dwBufLen);
 
 done:
     ImmUnlockIMCC(data->IMC.hCandInfo);
     return ret;
 }

Referenced by ActiveIMMApp_GetCandidateListW(), and ImmGetCandidateListCountW().

◆ ImmGetCandidateWindow()

BOOL WINAPI ImmGetCandidateWindow	(	HIMC	hIMC,
		DWORD	dwIndex,
		LPCANDIDATEFORM	lpCandidate
	)

Definition at line 1158 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
 
     TRACE("%p, %d, %p\n", hIMC, dwIndex, lpCandidate);
 
     if (!data || !lpCandidate)
         return FALSE;
 
     if (dwIndex >= ARRAY_SIZE(data->IMC.cfCandForm))
         return FALSE;
 
     if (data->IMC.cfCandForm[dwIndex].dwIndex != dwIndex)
         return FALSE;
 
     *lpCandidate = data->IMC.cfCandForm[dwIndex];
 
     return TRUE;
 }

Referenced by ActiveIMMApp_GetCandidateWindow(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmGetCompositionFontA()

BOOL WINAPI ImmGetCompositionFontA	(	HIMC	hIMC,
		LPLOGFONTA	lplf
	)

Definition at line 1182 of file imm.c.

 {
     LOGFONTW lfW;
     BOOL rc;
 
     TRACE("(%p, %p):\n", hIMC, lplf);
 
     rc = ImmGetCompositionFontW(hIMC,&lfW);
     if (!rc || !lplf)
         return FALSE;
 
     memcpy(lplf,&lfW,sizeof(LOGFONTA));
     WideCharToMultiByte(CP_ACP, 0, lfW.lfFaceName, -1, lplf->lfFaceName,
                         LF_FACESIZE, NULL, NULL);
     return TRUE;
 }

Referenced by ActiveIMMApp_GetCompositionFontA(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmGetCompositionFontW()

BOOL WINAPI ImmGetCompositionFontW	(	HIMC	hIMC,
		LPLOGFONTW	lplf
	)

Definition at line 1202 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
 
     TRACE("(%p, %p):\n", hIMC, lplf);
 
     if (!data || !lplf)
         return FALSE;
 
     *lplf = data->IMC.lfFont.W;
 
     return TRUE;
 }

Referenced by ActiveIMMApp_GetCompositionFontW(), and ImmGetCompositionFontA().

◆ ImmGetCompositionStringA()

LONG WINAPI ImmGetCompositionStringA	(	HIMC	hIMC,
		DWORD	dwIndex,
		LPVOID	lpBuf,
		DWORD	dwBufLen
	)

Definition at line 1489 of file imm.c.

 {
     return ImmGetCompositionStringT(hIMC, dwIndex, lpBuf, dwBufLen, FALSE);
 }

Referenced by ActiveIMMApp_GetCompositionStringA(), RealDefWindowProcA(), test_ImmGetCompositionString(), test_ImmNotifyIME(), and test_InvalidIMC().

◆ ImmGetCompositionStringT()

static LONG ImmGetCompositionStringT	(	HIMC	hIMC,
		DWORD	dwIndex,
		LPVOID	lpBuf,
		DWORD	dwBufLen,
		BOOL	unicode
	)

static

Definition at line 1395 of file imm.c.

 {
     LONG rc = 0;
     InputContextData *data = get_imc_data(hIMC);
     LPCOMPOSITIONSTRING compstr;
     LPBYTE compdata;
 
     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 
     if (!data)
        return FALSE;
 
     if (!data->IMC.hCompStr)
        return FALSE;
 
     compdata = ImmLockIMCC(data->IMC.hCompStr);
     compstr = (LPCOMPOSITIONSTRING)compdata;
 
     switch (dwIndex)
     {
     case GCS_RESULTSTR:
         TRACE("GCS_RESULTSTR\n");
         rc = CopyCompStringIMEtoClient(data, compdata + compstr->dwResultStrOffset, compstr->dwResultStrLen, lpBuf, dwBufLen, unicode);
         break;
     case GCS_COMPSTR:
         TRACE("GCS_COMPSTR\n");
         rc = CopyCompStringIMEtoClient(data, compdata + compstr->dwCompStrOffset, compstr->dwCompStrLen, lpBuf, dwBufLen, unicode);
         break;
     case GCS_COMPATTR:
         TRACE("GCS_COMPATTR\n");
         rc = CopyCompAttrIMEtoClient(data, compdata + compstr->dwCompAttrOffset, compstr->dwCompAttrLen,
                                      compdata + compstr->dwCompStrOffset, compstr->dwCompStrLen,
                                      lpBuf, dwBufLen, unicode);
         break;
     case GCS_COMPCLAUSE:
         TRACE("GCS_COMPCLAUSE\n");
         rc = CopyCompClauseIMEtoClient(data, compdata + compstr->dwCompClauseOffset,compstr->dwCompClauseLen,
                                        compdata + compstr->dwCompStrOffset,
                                        lpBuf, dwBufLen, unicode);
         break;
     case GCS_RESULTCLAUSE:
         TRACE("GCS_RESULTCLAUSE\n");
         rc = CopyCompClauseIMEtoClient(data, compdata + compstr->dwResultClauseOffset,compstr->dwResultClauseLen,
                                        compdata + compstr->dwResultStrOffset,
                                        lpBuf, dwBufLen, unicode);
         break;
     case GCS_RESULTREADSTR:
         TRACE("GCS_RESULTREADSTR\n");
         rc = CopyCompStringIMEtoClient(data, compdata + compstr->dwResultReadStrOffset, compstr->dwResultReadStrLen, lpBuf, dwBufLen, unicode);
         break;
     case GCS_RESULTREADCLAUSE:
         TRACE("GCS_RESULTREADCLAUSE\n");
         rc = CopyCompClauseIMEtoClient(data, compdata + compstr->dwResultReadClauseOffset,compstr->dwResultReadClauseLen,
                                        compdata + compstr->dwResultStrOffset,
                                        lpBuf, dwBufLen, unicode);
         break;
     case GCS_COMPREADSTR:
         TRACE("GCS_COMPREADSTR\n");
         rc = CopyCompStringIMEtoClient(data, compdata + compstr->dwCompReadStrOffset, compstr->dwCompReadStrLen, lpBuf, dwBufLen, unicode);
         break;
     case GCS_COMPREADATTR:
         TRACE("GCS_COMPREADATTR\n");
         rc = CopyCompAttrIMEtoClient(data, compdata + compstr->dwCompReadAttrOffset, compstr->dwCompReadAttrLen,
                                      compdata + compstr->dwCompReadStrOffset, compstr->dwCompReadStrLen,
                                      lpBuf, dwBufLen, unicode);
         break;
     case GCS_COMPREADCLAUSE:
         TRACE("GCS_COMPREADCLAUSE\n");
         rc = CopyCompClauseIMEtoClient(data, compdata + compstr->dwCompReadClauseOffset,compstr->dwCompReadClauseLen,
                                        compdata + compstr->dwCompStrOffset,
                                        lpBuf, dwBufLen, unicode);
         break;
     case GCS_CURSORPOS:
         TRACE("GCS_CURSORPOS\n");
         rc = CopyCompOffsetIMEtoClient(data, compstr->dwCursorPos, compdata + compstr->dwCompStrOffset, unicode);
         break;
     case GCS_DELTASTART:
         TRACE("GCS_DELTASTART\n");
         rc = CopyCompOffsetIMEtoClient(data, compstr->dwDeltaStart, compdata + compstr->dwCompStrOffset, unicode);
         break;
     default:
         FIXME("Unhandled index 0x%x\n",dwIndex);
         break;
     }
 
     ImmUnlockIMCC(data->IMC.hCompStr);
 
     return rc;
 }

Referenced by ImmGetCompositionStringA(), and ImmGetCompositionStringW().

◆ ImmGetCompositionStringW()

LONG WINAPI ImmGetCompositionStringW	(	HIMC	hIMC,
		DWORD	dwIndex,
		LPVOID	lpBuf,
		DWORD	dwBufLen
	)

Definition at line 1499 of file imm.c.

 {
     return ImmGetCompositionStringT(hIMC, dwIndex, lpBuf, dwBufLen, TRUE);
 }

Referenced by ActiveIMMApp_GetCompositionStringW(), EDIT_GetCompositionStr(), EDIT_GetResultStr(), EDIT_ImeComposition(), ME_HandleMessage(), RealDefWindowProcW(), test_ime_wnd_proc(), and test_ImmGetCompositionString().

◆ ImmGetCompositionWindow()

BOOL WINAPI ImmGetCompositionWindow	(	HIMC	hIMC,
		LPCOMPOSITIONFORM	lpCompForm
	)

Definition at line 1509 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
 
     TRACE("(%p, %p)\n", hIMC, lpCompForm);
 
     if (!data)
         return FALSE;
 
     *lpCompForm = data->IMC.cfCompForm;
     return TRUE;
 }

Referenced by ActiveIMMApp_GetCompositionWindow(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmGetContext()

HIMC WINAPI ImmGetContext ( HWND hWnd )

Definition at line 1526 of file imm.c.

 {
     HIMC rc;
 
     TRACE("%p\n", hWnd);
 
     if (!IsWindow(hWnd))
     {
         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
         return NULL;
     }
 
     rc = GetPropW(hWnd,szwWineIMCProperty);
     if (rc == (HIMC)-1)
         rc = NULL;
     else if (rc == NULL)
         rc = get_default_context( hWnd );
 
     if (rc)
     {
         InputContextData *data = rc;
         data->IMC.hWnd = hWnd;
     }
 
     TRACE("returning %p\n", rc);
 
     return rc;
 }

Referenced by ActiveIMMApp_GetContext(), EDIT_ImeComposition(), ImmGetContextThreadFunc(), ImmGetVirtualKey(), ImmProcessKey(), ImmTranslateMessage(), init(), ITextHostImpl_TxImmGetContext(), RealDefWindowProcA(), RealDefWindowProcW(), test_ime_processkey(), test_ime_wnd_proc(), test_ImmAssociateContextEx(), test_ImmDefaultHwnd(), test_ImmGetCompositionString(), test_ImmGetContext(), test_ImmIME(), test_ImmMessages(), test_ImmNotifyIME(), test_ImmSetCompositionString(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmGetConversionListA()

DWORD WINAPI ImmGetConversionListA	(	HKL	hKL,
		HIMC	hIMC,
		LPCSTR	pSrc,
		LPCANDIDATELIST	lpDst,
		DWORD	dwBufLen,
		UINT	uFlag
	)

Definition at line 1558 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
     TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL, hIMC, debugstr_a(pSrc), lpDst,
                 dwBufLen, uFlag);
     if (immHkl->hIME && immHkl->pImeConversionList)
     {
         if (!is_kbd_ime_unicode(immHkl))
             return immHkl->pImeConversionList(hIMC,(LPCWSTR)pSrc,lpDst,dwBufLen,uFlag);
         else
         {
             LPCANDIDATELIST lpwDst;
             DWORD ret = 0, len;
             LPWSTR pwSrc = strdupAtoW(pSrc);
 
             len = immHkl->pImeConversionList(hIMC, pwSrc, NULL, 0, uFlag);
             lpwDst = HeapAlloc(GetProcessHeap(), 0, len);
             if ( lpwDst )
             {
                 immHkl->pImeConversionList(hIMC, pwSrc, lpwDst, len, uFlag);
                 ret = convert_candidatelist_WtoA( lpwDst, lpDst, dwBufLen);
                 HeapFree(GetProcessHeap(), 0, lpwDst);
             }
             HeapFree(GetProcessHeap(), 0, pwSrc);
 
             return ret;
         }
     }
     else
         return 0;
 }

Referenced by ActiveIMMApp_GetConversionListA().

◆ ImmGetConversionListW()

DWORD WINAPI ImmGetConversionListW	(	HKL	hKL,
		HIMC	hIMC,
		LPCWSTR	pSrc,
		LPCANDIDATELIST	lpDst,
		DWORD	dwBufLen,
		UINT	uFlag
	)

Definition at line 1596 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
     TRACE("(%p, %p, %s, %p, %d, %d):\n", hKL, hIMC, debugstr_w(pSrc), lpDst,
                 dwBufLen, uFlag);
     if (immHkl->hIME && immHkl->pImeConversionList)
     {
         if (is_kbd_ime_unicode(immHkl))
             return immHkl->pImeConversionList(hIMC,pSrc,lpDst,dwBufLen,uFlag);
         else
         {
             LPCANDIDATELIST lpaDst;
             DWORD ret = 0, len;
             LPSTR paSrc = strdupWtoA(pSrc);
 
             len = immHkl->pImeConversionList(hIMC, (LPCWSTR)paSrc, NULL, 0, uFlag);
             lpaDst = HeapAlloc(GetProcessHeap(), 0, len);
             if ( lpaDst )
             {
                 immHkl->pImeConversionList(hIMC, (LPCWSTR)paSrc, lpaDst, len, uFlag);
                 ret = convert_candidatelist_AtoW( lpaDst, lpDst, dwBufLen);
                 HeapFree(GetProcessHeap(), 0, lpaDst);
             }
             HeapFree(GetProcessHeap(), 0, paSrc);
 
             return ret;
         }
     }
     else
         return 0;
 }

Referenced by ActiveIMMApp_GetConversionListW().

◆ ImmGetConversionStatus()

BOOL WINAPI ImmGetConversionStatus	(	HIMC	hIMC,
		LPDWORD	lpfdwConversion,
		LPDWORD	lpfdwSentence
	)

Definition at line 1634 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
 
     TRACE("%p %p %p\n", hIMC, lpfdwConversion, lpfdwSentence);
 
     if (!data)
         return FALSE;
 
     if (lpfdwConversion)
         *lpfdwConversion = data->IMC.fdwConversion;
     if (lpfdwSentence)
         *lpfdwSentence = data->IMC.fdwSentence;
 
     return TRUE;
 }

Referenced by ActiveIMMApp_GetConversionStatus(), and test_ImmThreads().

◆ ImmGetDefaultIMEWnd()

HWND WINAPI ImmGetDefaultIMEWnd ( HWND hWnd )

Definition at line 1746 of file imm.c.

 {
     HWND ret;
     IMMThreadData* thread_data = IMM_GetThreadData(hWnd, 0);
     if (!thread_data)
         return NULL;
     ret = thread_data->hwndDefault;
     LeaveCriticalSection(&threaddata_cs);
     TRACE("Default is %p\n",ret);
     return ret;
 }

Referenced by ActiveIMMApp_GetDefaultIMEWnd(), RealDefWindowProcA(), RealDefWindowProcW(), test_default_ime_disabled_cb(), test_default_ime_window_cancel_cb(), test_default_ime_window_cb(), test_default_ime_with_message_only_window_cb(), test_ime_wnd_proc(), test_ImmDefaultHwnd(), test_ImmGetDefaultIMEWnd_thread(), and test_ImmMessages().

◆ ImmGetDescriptionA()

UINT WINAPI ImmGetDescriptionA	(	HKL	hKL,
		LPSTR	lpszDescription,
		UINT	uBufLen
	)

Definition at line 1761 of file imm.c.

 {
   WCHAR *buf;
   DWORD len;
 
   TRACE("%p %p %d\n", hKL, lpszDescription, uBufLen);
 
   /* find out how many characters in the unicode buffer */
   len = ImmGetDescriptionW( hKL, NULL, 0 );
   if (!len)
     return 0;
 
   /* allocate a buffer of that size */
   buf = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof (WCHAR) );
   if( !buf )
   return 0;
 
   /* fetch the unicode buffer */
   len = ImmGetDescriptionW( hKL, buf, len + 1 );
 
   /* convert it back to ASCII */
   len = WideCharToMultiByte( CP_ACP, 0, buf, len + 1,
                              lpszDescription, uBufLen, NULL, NULL );
 
   HeapFree( GetProcessHeap(), 0, buf );
 
   if (len == 0)
     return 0;
 
   return len - 1;
 }

Referenced by ActiveIMMApp_GetDescriptionA(), and test_ImmGetDescription().

◆ ImmGetDescriptionW()

UINT WINAPI ImmGetDescriptionW	(	HKL	hKL,
		LPWSTR	lpszDescription,
		UINT	uBufLen
	)

Definition at line 1797 of file imm.c.

 {
   static const WCHAR name[] = { 'W','i','n','e',' ','X','I','M',0 };
 
   FIXME("(%p, %p, %d): semi stub\n", hKL, lpszDescription, uBufLen);
 
   if (!hKL) return 0;
   if (!uBufLen) return lstrlenW( name );
   lstrcpynW( lpszDescription, name, uBufLen );
   return lstrlenW( lpszDescription );
 }

Referenced by ActiveIMMApp_GetDescriptionW(), ImmGetDescriptionA(), and test_ImmGetDescription().

◆ ImmGetGuideLineA()

DWORD WINAPI ImmGetGuideLineA	(	HIMC	hIMC,
		DWORD	dwIndex,
		LPSTR	lpBuf,
		DWORD	dwBufLen
	)

Definition at line 1812 of file imm.c.

 {
   FIXME("(%p, %d, %s, %d): stub\n",
     hIMC, dwIndex, debugstr_a(lpBuf), dwBufLen
   );
   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
   return 0;
 }

Referenced by ActiveIMMApp_GetGuideLineA().

◆ ImmGetGuideLineW()

DWORD WINAPI ImmGetGuideLineW	(	HIMC	hIMC,
		DWORD	dwIndex,
		LPWSTR	lpBuf,
		DWORD	dwBufLen
	)

Definition at line 1825 of file imm.c.

 {
   FIXME("(%p, %d, %s, %d): stub\n",
     hIMC, dwIndex, debugstr_w(lpBuf), dwBufLen
   );
   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
   return 0;
 }

Referenced by ActiveIMMApp_GetGuideLineW().

◆ ImmGetHotKey()

BOOL WINAPI ImmGetHotKey	(	DWORD	hotkey,
		UINT *	modifiers,
		UINT *	key,
		HKL	hkl
	)

Definition at line 3195 of file imm.c.

 {
     FIXME("%x, %p, %p, %p: stub\n", hotkey, modifiers, key, hkl);
     return FALSE;
 }

◆ ImmGetIMCCLockCount()

DWORD WINAPI ImmGetIMCCLockCount ( HIMCC imcc )

Definition at line 2988 of file imm.c.

 {
     return GlobalFlags(imcc) & GMEM_LOCKCOUNT;
 }

Referenced by test_ImmDestroyIMCC(), and test_ImmGetIMCCLockCount().

◆ ImmGetIMCCSize()

DWORD WINAPI ImmGetIMCCSize ( HIMCC imcc )

Definition at line 3004 of file imm.c.

 {
     return GlobalSize(imcc);
 }

Referenced by test_ImmDestroyIMCC().

◆ ImmGetIMCLockCount()

DWORD WINAPI ImmGetIMCLockCount ( HIMC hIMC )

Definition at line 2945 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
     if (!data)
         return 0;
     return data->dwLock;
 }

Referenced by test_ImmDestroyContext(), and test_ImmGetIMCLockCount().

◆ ImmGetIMEFileNameA()

UINT WINAPI ImmGetIMEFileNameA	(	HKL	hKL,
		LPSTR	lpszFileName,
		UINT	uBufLen
	)

Definition at line 1837 of file imm.c.

 {
     LPWSTR bufW = NULL;
     UINT wBufLen = uBufLen;
     UINT rc;
 
     if (uBufLen && lpszFileName)
         bufW = HeapAlloc(GetProcessHeap(),0,uBufLen * sizeof(WCHAR));
     else /* We need this to get the number of byte required */
     {
         bufW = HeapAlloc(GetProcessHeap(),0,MAX_PATH * sizeof(WCHAR));
         wBufLen = MAX_PATH;
     }
 
     rc = ImmGetIMEFileNameW(hKL,bufW,wBufLen);
 
     if (rc > 0)
     {
         if (uBufLen && lpszFileName)
             rc = WideCharToMultiByte(CP_ACP, 0, bufW, -1, lpszFileName,
                                  uBufLen, NULL, NULL);
         else /* get the length */
             rc = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL,
                                      NULL);
     }
 
     HeapFree(GetProcessHeap(),0,bufW);
     return rc;
 }

Referenced by ActiveIMMApp_GetIMEFileNameA().

◆ ImmGetIMEFileNameW()

UINT WINAPI ImmGetIMEFileNameW	(	HKL	hKL,
		LPWSTR	lpszFileName,
		UINT	uBufLen
	)

Definition at line 1870 of file imm.c.

 {
     HKEY hkey;
     DWORD length;
     DWORD rc;
     WCHAR regKey[ARRAY_SIZE(szImeRegFmt)+8];
 
     wsprintfW( regKey, szImeRegFmt, (ULONG_PTR)hKL );
     rc = RegOpenKeyW( HKEY_LOCAL_MACHINE, regKey, &hkey);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         return 0;
     }
 
     length = 0;
     rc = RegGetValueW(hkey, NULL, szImeFileW, RRF_RT_REG_SZ, NULL, NULL, &length);
 
     if (rc != ERROR_SUCCESS)
     {
         RegCloseKey(hkey);
         SetLastError(rc);
         return 0;
     }
     if (length > uBufLen * sizeof(WCHAR) || !lpszFileName)
     {
         RegCloseKey(hkey);
         if (lpszFileName)
         {
             SetLastError(ERROR_INSUFFICIENT_BUFFER);
             return 0;
         }
         else
             return length / sizeof(WCHAR);
     }
 
     RegGetValueW(hkey, NULL, szImeFileW, RRF_RT_REG_SZ, NULL, lpszFileName, &length);
 
     RegCloseKey(hkey);
 
     return length / sizeof(WCHAR);
 }

Referenced by ActiveIMMApp_GetIMEFileNameW(), IMM_GetImmHkl(), and ImmGetIMEFileNameA().

◆ ImmGetImeMenuItemsA()

DWORD WINAPI ImmGetImeMenuItemsA	(	HIMC	hIMC,
		DWORD	dwFlags,
		DWORD	dwType,
		LPIMEMENUITEMINFOA	lpImeParentMenu,
		LPIMEMENUITEMINFOA	lpImeMenu,
		DWORD	dwSize
	)

Definition at line 2778 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
     TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC, dwFlags, dwType,
         lpImeParentMenu, lpImeMenu, dwSize);
 
     if (!data)
     {
         SetLastError(ERROR_INVALID_HANDLE);
         return 0;
     }
 
     if (data->immKbd->hIME && data->immKbd->pImeGetImeMenuItems)
     {
         if (!is_himc_ime_unicode(data) || (!lpImeParentMenu && !lpImeMenu))
             return data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
                                 (IMEMENUITEMINFOW*)lpImeParentMenu,
                                 (IMEMENUITEMINFOW*)lpImeMenu, dwSize);
         else
         {
             IMEMENUITEMINFOW lpImeParentMenuW;
             IMEMENUITEMINFOW *lpImeMenuW, *parent = NULL;
             DWORD rc;
 
             if (lpImeParentMenu)
                 parent = &lpImeParentMenuW;
             if (lpImeMenu)
             {
                 int count = dwSize / sizeof(LPIMEMENUITEMINFOA);
                 dwSize = count * sizeof(IMEMENUITEMINFOW);
                 lpImeMenuW = HeapAlloc(GetProcessHeap(), 0, dwSize);
             }
             else
                 lpImeMenuW = NULL;
 
             rc = data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
                                 parent, lpImeMenuW, dwSize);
 
             if (lpImeParentMenu)
             {
                 memcpy(lpImeParentMenu,&lpImeParentMenuW,sizeof(IMEMENUITEMINFOA));
                 lpImeParentMenu->hbmpItem = lpImeParentMenuW.hbmpItem;
                 WideCharToMultiByte(CP_ACP, 0, lpImeParentMenuW.szString,
                     -1, lpImeParentMenu->szString, IMEMENUITEM_STRING_SIZE,
                     NULL, NULL);
             }
             if (lpImeMenu && rc)
             {
                 unsigned int i;
                 for (i = 0; i < rc; i++)
                 {
                     memcpy(&lpImeMenu[i],&lpImeMenuW[1],sizeof(IMEMENUITEMINFOA));
                     lpImeMenu[i].hbmpItem = lpImeMenuW[i].hbmpItem;
                     WideCharToMultiByte(CP_ACP, 0, lpImeMenuW[i].szString,
                         -1, lpImeMenu[i].szString, IMEMENUITEM_STRING_SIZE,
                         NULL, NULL);
                 }
             }
             HeapFree(GetProcessHeap(),0,lpImeMenuW);
             return rc;
         }
     }
     else
         return 0;
 }

Referenced by ActiveIMMApp_GetImeMenuItemsA(), and test_InvalidIMC().

◆ ImmGetImeMenuItemsW()

DWORD WINAPI ImmGetImeMenuItemsW	(	HIMC	hIMC,
		DWORD	dwFlags,
		DWORD	dwType,
		LPIMEMENUITEMINFOW	lpImeParentMenu,
		LPIMEMENUITEMINFOW	lpImeMenu,
		DWORD	dwSize
	)

Definition at line 2849 of file imm.c.

 {
     InputContextData *data = get_imc_data(hIMC);
     TRACE("(%p, %i, %i, %p, %p, %i):\n", hIMC, dwFlags, dwType,
         lpImeParentMenu, lpImeMenu, dwSize);
 
     if (!data)
     {
         SetLastError(ERROR_INVALID_HANDLE);
         return 0;
     }
 
     if (data->immKbd->hIME && data->immKbd->pImeGetImeMenuItems)
     {
         if (is_himc_ime_unicode(data) || (!lpImeParentMenu && !lpImeMenu))
             return data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
                                 lpImeParentMenu, lpImeMenu, dwSize);
         else
         {
             IMEMENUITEMINFOA lpImeParentMenuA;
             IMEMENUITEMINFOA *lpImeMenuA, *parent = NULL;
             DWORD rc;
 
             if (lpImeParentMenu)
                 parent = &lpImeParentMenuA;
             if (lpImeMenu)
             {
                 int count = dwSize / sizeof(LPIMEMENUITEMINFOW);
                 dwSize = count * sizeof(IMEMENUITEMINFOA);
                 lpImeMenuA = HeapAlloc(GetProcessHeap(), 0, dwSize);
             }
             else
                 lpImeMenuA = NULL;
 
             rc = data->immKbd->pImeGetImeMenuItems(hIMC, dwFlags, dwType,
                                 (IMEMENUITEMINFOW*)parent,
                                 (IMEMENUITEMINFOW*)lpImeMenuA, dwSize);
 
             if (lpImeParentMenu)
             {
                 memcpy(lpImeParentMenu,&lpImeParentMenuA,sizeof(IMEMENUITEMINFOA));
                 lpImeParentMenu->hbmpItem = lpImeParentMenuA.hbmpItem;
                 MultiByteToWideChar(CP_ACP, 0, lpImeParentMenuA.szString,
                     -1, lpImeParentMenu->szString, IMEMENUITEM_STRING_SIZE);
             }
             if (lpImeMenu && rc)
             {
                 unsigned int i;
                 for (i = 0; i < rc; i++)
                 {
                     memcpy(&lpImeMenu[i],&lpImeMenuA[1],sizeof(IMEMENUITEMINFOA));
                     lpImeMenu[i].hbmpItem = lpImeMenuA[i].hbmpItem;
                     MultiByteToWideChar(CP_ACP, 0, lpImeMenuA[i].szString,
                         -1, lpImeMenu[i].szString, IMEMENUITEM_STRING_SIZE);
                 }
             }
             HeapFree(GetProcessHeap(),0,lpImeMenuA);
             return rc;
         }
     }
     else
         return 0;
 }

Referenced by ActiveIMMApp_GetImeMenuItemsW().

◆ ImmGetOpenStatus()

BOOL WINAPI ImmGetOpenStatus ( HIMC hIMC )

Definition at line 1916 of file imm.c.

 {
   InputContextData *data = get_imc_data(hIMC);
   static int i;
 
     if (!data)
         return FALSE;
 
     TRACE("(%p): semi-stub\n", hIMC);
 
     if (!i++)
       FIXME("(%p): semi-stub\n", hIMC);
 
   return data->IMC.fOpen;
 }

Referenced by ActiveIMMApp_GetOpenStatus(), test_ImmThreads(), and test_InvalidIMC().

◆ ImmGetProperty()

DWORD WINAPI ImmGetProperty	(	HKL	hKL,
		DWORD	fdwIndex
	)

Definition at line 1935 of file imm.c.

 {
     DWORD rc = 0;
     ImmHkl *kbd;
 
     TRACE("(%p, %d)\n", hKL, fdwIndex);
     kbd = IMM_GetImmHkl(hKL);
 
     if (kbd && kbd->hIME)
     {
         switch (fdwIndex)
         {
             case IGP_PROPERTY: rc = kbd->imeInfo.fdwProperty; break;
             case IGP_CONVERSION: rc = kbd->imeInfo.fdwConversionCaps; break;
             case IGP_SENTENCE: rc = kbd->imeInfo.fdwSentenceCaps; break;
             case IGP_SETCOMPSTR: rc = kbd->imeInfo.fdwSCSCaps; break;
             case IGP_SELECT: rc = kbd->imeInfo.fdwSelectCaps; break;
             case IGP_GETIMEVERSION: rc = IMEVER_0400; break;
             case IGP_UI: rc = 0; break;
             default: rc = 0;
         }
     }
     return rc;
 }

Referenced by ActiveIMMApp_GetProperty(), and test_ImmGetCompositionString().

◆ ImmGetRegisterWordStyleA()

UINT WINAPI ImmGetRegisterWordStyleA	(	HKL	hKL,
		UINT	nItem,
		LPSTYLEBUFA	lpStyleBuf
	)

Definition at line 1963 of file imm.c.

 {
     ImmHkl *immHkl = IMM_GetImmHkl(hKL);
     TRACE("(%p, %d, %p):\n", hKL, nItem, lpStyleBuf);
     if (immHkl->hIME && immHkl->pImeGetRegisterWordStyle)
     {
         if (!is_kbd_ime_unicode(immHkl))
             return immHkl->pImeGetRegisterWordStyle(nItem,(LPSTYLEBUFW)lpStyleBuf);
         else
         {
             STYLEBUFW sbw;
             UINT rc;
 
             rc = immHkl->pImeGetRegisterWordStyle(nItem,&sbw);
             WideCharToMultiByte(CP_ACP, 0, sbw.szDescription, -1,
                 lpStyleBuf->szDescription, 32, NULL, NULL);
             lpStyleBuf->dwStyle = sbw.dwStyle

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ IMM_INIT_MAGIC

◆ LOAD_FUNCPTR

◆ WINE_IMC_VALID_MAGIC

Typedef Documentation

◆ ImmHkl

◆ IMMThreadData

◆ InputContextData

◆ LPTRANSMSG

◆ TRANSMSG

Function Documentation

◆ __wine_get_ui_window()

◆ __wine_register_window()

◆ __wine_unregister_window()

◆ _ImmAssociateContextExEnumProc()

◆ convert_candidatelist_AtoW()

◆ convert_candidatelist_WtoA()

◆ CopyCompAttrIMEtoClient()

◆ CopyCompClauseIMEtoClient()

◆ CopyCompOffsetIMEtoClient()

◆ CopyCompStringIMEtoClient()

◆ DllMain()

◆ EscapeRequiresWA()

◆ get_default_context()

◆ get_imc_data()

◆ IMM_DestroyContext()

◆ IMM_FreeAllImmHkl()

◆ IMM_FreeThreadData()

◆ IMM_GetImmHkl()

◆ IMM_GetThreadData()

◆ IMM_IsCrossThreadAccess()

◆ IMM_IsDefaultContext()

◆ ImmAssociateContext()

◆ ImmAssociateContextEx()

◆ ImmConfigureIMEA()

◆ ImmConfigureIMEW()

◆ ImmCreateBlankCompStr()

◆ ImmCreateContext()

◆ ImmCreateIMCC()

◆ ImmCreateSoftKeyboard()

◆ ImmDestroyContext()

◆ ImmDestroyIMCC()

◆ ImmDestroySoftKeyboard()

◆ ImmDisableIME()

◆ ImmDisableLegacyIME()

◆ ImmDisableTextFrameService()

◆ ImmEnumInputContext()

◆ ImmEnumRegisterWordA()

◆ ImmEnumRegisterWordW()

◆ ImmEscapeA()

◆ ImmEscapeW()

◆ ImmGenerateMessage()

◆ ImmGetCandidateListA()

◆ ImmGetCandidateListCountA()

◆ ImmGetCandidateListCountW()

◆ ImmGetCandidateListW()

◆ ImmGetCandidateWindow()

◆ ImmGetCompositionFontA()

◆ ImmGetCompositionFontW()

◆ ImmGetCompositionStringA()

◆ ImmGetCompositionStringT()

◆ ImmGetCompositionStringW()

◆ ImmGetCompositionWindow()

◆ ImmGetContext()

◆ ImmGetConversionListA()

◆ ImmGetConversionListW()

◆ ImmGetConversionStatus()

◆ ImmGetDefaultIMEWnd()

◆ ImmGetDescriptionA()

◆ ImmGetDescriptionW()

◆ ImmGetGuideLineA()

◆ ImmGetGuideLineW()

◆ ImmGetHotKey()

◆ ImmGetIMCCLockCount()

◆ ImmGetIMCCSize()