imm.c File Reference

#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 <stdlib.h>
#include <ndk/umtypes.h>
#include <ndk/pstypes.h>
#include <ndk/rtlfuncs.h>
#include "../../../win32ss/include/ntuser.h"
#include "../../../win32ss/include/ntwin32.h"
#include <imm32_undoc.h>
#include <strsafe.h>

Include dependency graph for imm.c:

Go to the source code of this file.

Classes
struct	_tagImmHkl
struct	tagInputContextData
struct	_tagTRANSMSG
struct	_tagIMMThreadData

Macros
#define	WIN32_NO_STATUS
#define	IMM_INIT_MAGIC   0x19650412
#define	IMM_INVALID_CANDFORM   ULONG_MAX
#define	REGKEY_KEYBOARD_LAYOUTS   L"System\\CurrentControlSet\\Control\\Keyboard Layouts"
#define	REGKEY_IMM   L"Software\\Microsoft\\Windows NT\\CurrentVersion\\IMM"
#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);}
#define	ROUNDUP4(n)   (((n) + 3) & ~3) /* DWORD alignment */
#define	IMM32_FLAG_UNKNOWN   0x4
#define	IMM32_FLAG_CICERO_ENABLED   0x20

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 DWORD APIENTRY	Imm32QueryInputContext (HIMC hIMC, DWORD dwUnknown2)
static DWORD APIENTRY	Imm32NotifyIMEStatus (HWND hwnd, HIMC hIMC, DWORD dwConversion)
static VOID APIENTRY	Imm32FreeImeDpi (PIMEDPI pImeDpi, BOOL bDestroy)
static BOOL APIENTRY	Imm32NotifyAction (HIMC hIMC, HWND hwnd, DWORD dwAction, DWORD_PTR dwIndex, DWORD_PTR dwValue, DWORD_PTR dwCommand, DWORD_PTR dwData)
HKL WINAPI	ImmLoadLayout (HKL hKL, PIMEINFOEX pImeInfoEx)
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 dwThreadId)
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)
LPVOID APIENTRY	Imm32HeapAlloc (DWORD dwFlags, DWORD dwBytes)
static DWORD_PTR APIENTRY	Imm32GetThreadState (DWORD Routine)
static DWORD_PTR APIENTRY	Imm32QueryWindow (HWND hWnd, DWORD Index)
static DWORD APIENTRY	Imm32UpdateInputContext (HIMC hIMC, DWORD Unknown1, PCLIENTIMC pClientImc)
static PCLIENTIMC APIENTRY	Imm32GetClientImcCache (void)
PCLIENTIMC WINAPI	ImmLockClientImc (HIMC hImc)
VOID WINAPI	ImmUnlockClientImc (PCLIENTIMC pClientImc)
static DWORD APIENTRY	CandidateListWideToAnsi (const CANDIDATELIST *pWideCL, LPCANDIDATELIST pAnsiCL, DWORD dwBufLen, UINT uCodePage)
static DWORD APIENTRY	CandidateListAnsiToWide (const CANDIDATELIST *pAnsiCL, LPCANDIDATELIST pWideCL, DWORD dwBufLen, UINT uCodePage)
static DWORD APIENTRY	ImmGetCandidateListAW (HIMC hIMC, DWORD dwIndex, LPCANDIDATELIST lpCandList, DWORD dwBufLen, BOOL bAnsi)
DWORD APIENTRY	ImmGetCandidateListCountAW (HIMC hIMC, LPDWORD lpdwListCount, BOOL bAnsi)
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)
static VOID APIENTRY	LogFontAnsiToWide (const LOGFONTA *plfA, LPLOGFONTW plfW)
static VOID APIENTRY	LogFontWideToAnsi (const LOGFONTW *plfW, LPLOGFONTA plfA)
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)
BOOL WINAPI	CtfImmIsCiceroEnabled (VOID)
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)
PIMEDPI WINAPI	ImmLockImeDpi (HKL hKL)
VOID WINAPI	ImmUnlockImeDpi (PIMEDPI pImeDpi)
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 dwThreadId)
BOOL WINAPI	ImmEnumInputContext (DWORD dwThreadId, IMCENUMPROC lpfn, LPARAM lParam)
BOOL WINAPI	ImmGetHotKey (IN DWORD dwHotKey, OUT LPUINT lpuModifiers, OUT LPUINT lpuVKey, OUT LPHKL lphKL)
BOOL WINAPI	ImmDisableLegacyIME (void)
BOOL WINAPI	ImmSetActiveContext (HWND hwnd, HIMC hIMC, BOOL fFlag)
BOOL WINAPI	ImmSetActiveContextConsoleIME (HWND hwnd, BOOL fFlag)
BOOL WINAPI	ImmRegisterClient (PVOID ptr, HINSTANCE hMod)
BOOL WINAPI	CtfImmIsTextFrameServiceDisabled (VOID)
static BOOL APIENTRY	Imm32GetImeInfoEx (PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType)
BOOL WINAPI	ImmGetImeInfoEx (PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType, PVOID pvSearchKey)

Variables
RTL_CRITICAL_SECTION	g_csImeDpi
PIMEDPI	g_pImeDpiList = NULL
PSERVERINFO	g_psi = NULL
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
HANDLE	g_hImm32Heap = NULL
DWORD	g_dwImm32Flags = 0

Macro Definition Documentation

IMM32_FLAG_CICERO_ENABLED

#define IMM32_FLAG_CICERO_ENABLED   0x20

Definition at line 1128 of file imm.c.

IMM32_FLAG_UNKNOWN

#define IMM32_FLAG_UNKNOWN   0x4

Definition at line 1127 of file imm.c.

IMM_INIT_MAGIC

#define IMM_INIT_MAGIC   0x19650412

Definition at line 48 of file imm.c.

IMM_INVALID_CANDFORM

#define IMM_INVALID_CANDFORM   ULONG_MAX

Definition at line 49 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 455 of file imm.c.

REGKEY_IMM

#define REGKEY_IMM   L"Software\\Microsoft\\Windows NT\\CurrentVersion\\IMM"

Definition at line 53 of file imm.c.

REGKEY_KEYBOARD_LAYOUTS

#define REGKEY_KEYBOARD_LAYOUTS   L"System\\CurrentControlSet\\Control\\Keyboard Layouts"

Definition at line 51 of file imm.c.

ROUNDUP4

#define ROUNDUP4

(

n

)

(((n) + 3) & ~3) /* DWORD alignment */

Definition at line 1121 of file imm.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 25 of file imm.c.

WINE_IMC_VALID_MAGIC

#define WINE_IMC_VALID_MAGIC   0x56434D49

Definition at line 206 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 524 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 2146 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 2199 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 755 of file imm.c.

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

Referenced by ImmAssociateContextEx().

CandidateListAnsiToWide()

static DWORD APIENTRY CandidateListAnsiToWide ( const CANDIDATELIST *  pAnsiCL, LPCANDIDATELIST  pWideCL, DWORD  dwBufLen, UINT  uCodePage  )

static

Definition at line 1290 of file imm.c.

{
    DWORD dwSize, dwIndex, cchGot, cbGot, cbLeft;
    const BYTE *pbAnsi;
    LPBYTE pbWide;
    LPDWORD pibOffsets;

    /* calculate total wide size */
    if (pAnsiCL->dwCount > 0)
    {
        dwSize = sizeof(CANDIDATELIST) + ((pAnsiCL->dwCount - 1) * sizeof(DWORD));
        for (dwIndex = 0; dwIndex < pAnsiCL->dwCount; ++dwIndex)
        {
            pbAnsi = (const BYTE *)pAnsiCL + pAnsiCL->dwOffset[dwIndex];
            cchGot = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, (LPCSTR)pbAnsi, -1, NULL, 0);
            dwSize += cchGot * sizeof(WCHAR);
        }
    }
    else
    {
        dwSize = sizeof(CANDIDATELIST);
    }

    dwSize = ROUNDUP4(dwSize);
    if (dwBufLen == 0)
        return dwSize;
    if (dwBufLen < dwSize)
        return 0;

    /* store to wide */
    pWideCL->dwSize = dwBufLen;
    pWideCL->dwStyle = pAnsiCL->dwStyle;
    pWideCL->dwCount = pAnsiCL->dwCount;
    pWideCL->dwSelection = pAnsiCL->dwSelection;
    pWideCL->dwPageStart = pAnsiCL->dwPageStart;
    pWideCL->dwPageSize = pAnsiCL->dwPageSize;

    pibOffsets = pWideCL->dwOffset;
    if (pAnsiCL->dwCount > 0)
    {
        pibOffsets[0] = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) * sizeof(DWORD));
        cbLeft = dwBufLen - pibOffsets[0];

        for (dwIndex = 0; dwIndex < pAnsiCL->dwCount; ++dwIndex)
        {
            pbAnsi = (const BYTE *)pAnsiCL + pAnsiCL->dwOffset[dwIndex];
            pbWide = (LPBYTE)pWideCL + pibOffsets[dwIndex];

            /* convert to wide */
            cchGot = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, (LPCSTR)pbAnsi, -1,
                                         (LPWSTR)pbWide, cbLeft / sizeof(WCHAR));
            cbGot = cchGot * sizeof(WCHAR);
            cbLeft -= cbGot;

            if (dwIndex + 1 < pAnsiCL->dwCount)
                pibOffsets[dwIndex + 1] = pibOffsets[dwIndex] + cbGot;
        }
    }
    else
    {
        pibOffsets[0] = sizeof(CANDIDATELIST);
    }

    return dwBufLen;
}

Referenced by ImmGetCandidateListAW(), and ImmGetCandidateListCountAW().

CandidateListWideToAnsi()

static DWORD APIENTRY CandidateListWideToAnsi ( const CANDIDATELIST *  pWideCL, LPCANDIDATELIST  pAnsiCL, DWORD  dwBufLen, UINT  uCodePage  )

static

Definition at line 1221 of file imm.c.

{
    BOOL bUsedDefault;
    DWORD dwSize, dwIndex, cbGot, cbLeft;
    const BYTE *pbWide;
    LPBYTE pbAnsi;
    LPDWORD pibOffsets;

    /* calculate total ansi size */
    if (pWideCL->dwCount > 0)
    {
        dwSize = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) * sizeof(DWORD));
        for (dwIndex = 0; dwIndex < pWideCL->dwCount; ++dwIndex)
        {
            pbWide = (const BYTE *)pWideCL + pWideCL->dwOffset[dwIndex];
            cbGot = WideCharToMultiByte(uCodePage, 0, (LPCWSTR)pbWide, -1, NULL, 0,
                                        NULL, &bUsedDefault);
            dwSize += cbGot;
        }
    }
    else
    {
        dwSize = sizeof(CANDIDATELIST);
    }

    dwSize = ROUNDUP4(dwSize);
    if (dwBufLen == 0)
        return dwSize;
    if (dwBufLen < dwSize)
        return 0;

    /* store to ansi */
    pAnsiCL->dwSize = dwBufLen;
    pAnsiCL->dwStyle = pWideCL->dwStyle;
    pAnsiCL->dwCount = pWideCL->dwCount;
    pAnsiCL->dwSelection = pWideCL->dwSelection;
    pAnsiCL->dwPageStart = pWideCL->dwPageStart;
    pAnsiCL->dwPageSize = pWideCL->dwPageSize;

    pibOffsets = pAnsiCL->dwOffset;
    if (pWideCL->dwCount > 0)
    {
        pibOffsets[0] = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) * sizeof(DWORD));
        cbLeft = dwBufLen - pibOffsets[0];

        for (dwIndex = 0; dwIndex < pWideCL->dwCount; ++dwIndex)
        {
            pbWide = (const BYTE *)pWideCL + pWideCL->dwOffset[dwIndex];
            pbAnsi = (LPBYTE)pAnsiCL + pibOffsets[dwIndex];

            /* convert to ansi */
            cbGot = WideCharToMultiByte(uCodePage, 0, (LPCWSTR)pbWide, -1,
                                        (LPSTR)pbAnsi, cbLeft, NULL, &bUsedDefault);
            cbLeft -= cbGot;

            if (dwIndex < pWideCL->dwCount - 1)
                pibOffsets[dwIndex + 1] = pibOffsets[dwIndex] + cbGot;
        }
    }
    else
    {
        pibOffsets[0] = sizeof(CANDIDATELIST);
    }

    return dwBufLen;
}

Referenced by ImmGetCandidateListAW(), and ImmGetCandidateListCountAW().

convert_candidatelist_AtoW()

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

static

Definition at line 321 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 ImmGetConversionListW().

convert_candidatelist_WtoA()

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

static

Definition at line 282 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 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 1721 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 1792 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 1847 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 1691 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().

CtfImmIsCiceroEnabled()

BOOL WINAPI CtfImmIsCiceroEnabled

(

VOID

)

Definition at line 2240 of file imm.c.

{
    return !!(g_dwImm32Flags & IMM32_FLAG_CICERO_ENABLED);
}

CtfImmIsTextFrameServiceDisabled()

BOOL WINAPI CtfImmIsTextFrameServiceDisabled

(

VOID

)

Definition at line 3807 of file imm.c.

{
    PTEB pTeb = NtCurrentTeb();
    if (((PW32CLIENTINFO)pTeb->Win32ClientInfo)->CI_flags & CI_TFSDISABLED)
        return TRUE;
    return FALSE;
}

Referenced by ImmGetImeInfoEx().

DllMain()

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

Definition at line 548 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 1041 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 633 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 618 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(), ImmGetCompositionStringT(), ImmGetImeMenuItemsA(), ImmGetImeMenuItemsW(), ImmLockIMC(), ImmRequestMessageA(), ImmRequestMessageW(), ImmSetCandidateWindow(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmSetCompositionStringA(), ImmSetCompositionStringW(), and ImmSetConversionStatus().

Imm32FreeImeDpi()

static VOID APIENTRY Imm32FreeImeDpi ( PIMEDPI  pImeDpi, BOOL  bDestroy  )

static

Definition at line 72 of file imm.c.

{
    if (pImeDpi->hInst == NULL)
        return;
    if (bDestroy)
        pImeDpi->ImeDestroy(0);
    FreeLibrary(pImeDpi->hInst);
    pImeDpi->hInst = NULL;
}

Referenced by ImmUnlockImeDpi().

Imm32GetClientImcCache()

static PCLIENTIMC APIENTRY Imm32GetClientImcCache ( void  )

static

Definition at line 1158 of file imm.c.

{
    // FIXME: Do something properly here
    return NULL;
}

Referenced by ImmLockClientImc().

Imm32GetImeInfoEx()

static BOOL APIENTRY Imm32GetImeInfoEx ( PIMEINFOEX  pImeInfoEx, IMEINFOEXCLASS  SearchType  )

static

Definition at line 3819 of file imm.c.

{
    return NtUserGetImeInfoEx(pImeInfoEx, SearchType);
}

Referenced by ImmGetImeInfoEx().

Imm32GetThreadState()

static DWORD_PTR APIENTRY Imm32GetThreadState ( DWORD  Routine )

static

Definition at line 1142 of file imm.c.

{
    return NtUserGetThreadState(Routine);
}

Referenced by ImmGetDefaultIMEWnd(), and ImmLockClientImc().

Imm32HeapAlloc()

LPVOID APIENTRY Imm32HeapAlloc	(	DWORD	dwFlags,
		DWORD	dwBytes
	)

Definition at line 1130 of file imm.c.

{
    if (!g_hImm32Heap)
    {
        g_hImm32Heap = RtlGetProcessHeap();
        if (g_hImm32Heap == NULL)
            return NULL;
    }
    return HeapAlloc(g_hImm32Heap, dwFlags, dwBytes);
}

Referenced by ImmLockClientImc().

Imm32NotifyAction()

static BOOL APIENTRY Imm32NotifyAction ( HIMC  hIMC, HWND  hwnd, DWORD  dwAction, DWORD_PTR  dwIndex, DWORD_PTR  dwValue, DWORD_PTR  dwCommand, DWORD_PTR  dwData  )

static

Definition at line 83 of file imm.c.

{
    DWORD dwLayout;
    HKL hKL;
    PIMEDPI pImeDpi;

    if (dwAction)
    {
        dwLayout = Imm32QueryInputContext(hIMC, 1);
        if (dwLayout)
        {
            /* find keyboard layout and lock it */
            hKL = GetKeyboardLayout(dwLayout);
            pImeDpi = ImmLockImeDpi(hKL);
            if (pImeDpi)
            {
                /* do notify */
                pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue);

                ImmUnlockImeDpi(pImeDpi); /* unlock */
            }
        }
    }

    if (hwnd && dwCommand)
        SendMessageW(hwnd, WM_IME_NOTIFY, dwCommand, dwData);

    return TRUE;
}

Referenced by ImmSetCompositionWindow(), ImmSetOpenStatus(), and ImmSetStatusWindowPos().

Imm32NotifyIMEStatus()

static DWORD APIENTRY Imm32NotifyIMEStatus ( HWND  hwnd, HIMC  hIMC, DWORD  dwConversion  )

static

Definition at line 67 of file imm.c.

{
    return NtUserNotifyIMEStatus(hwnd, hIMC, dwConversion);
}

Referenced by ImmSetOpenStatus().

Imm32QueryInputContext()

static DWORD APIENTRY Imm32QueryInputContext ( HIMC  hIMC, DWORD  dwUnknown2  )

static

Definition at line 62 of file imm.c.

{
    return NtUserQueryInputContext(hIMC, dwUnknown2);
}

Referenced by Imm32NotifyAction(), ImmSetOpenStatus(), and ImmSetStatusWindowPos().

Imm32QueryWindow()

static DWORD_PTR APIENTRY Imm32QueryWindow ( HWND  hWnd, DWORD  Index  )

static

Definition at line 1147 of file imm.c.

{
    return NtUserQueryWindow(hWnd, Index);
}

Referenced by ImmGetDefaultIMEWnd(), and ImmNotifyIME().

Imm32UpdateInputContext()

static DWORD APIENTRY Imm32UpdateInputContext ( HIMC  hIMC, DWORD  Unknown1, PCLIENTIMC  pClientImc  )

static

Definition at line 1153 of file imm.c.

{
    return NtUserUpdateInputContext(hIMC, Unknown1, pClientImc);
}

Referenced by ImmLockClientImc().

IMM_DestroyContext()

static BOOL IMM_DestroyContext ( HIMC  hIMC )

static

Definition at line 928 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 530 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 402 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 456 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(), ImmProcessKey(), ImmRegisterWordA(), ImmRegisterWordW(), ImmUnregisterWordA(), and ImmUnregisterWordW().

IMM_GetThreadData()

static IMMThreadData* IMM_GetThreadData ( HWND  hwnd, DWORD  thread  )

static

Definition at line 360 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(), and get_default_context().

IMM_IsCrossThreadAccess()

static BOOL IMM_IsCrossThreadAccess ( HWND  hWnd, HIMC  hIMC  )

static

Definition at line 674 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(), and ImmSetConversionStatus().

IMM_IsDefaultContext()

static BOOL IMM_IsDefaultContext ( HIMC  imc )

static

Definition at line 392 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 693 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 765 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 800 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 835 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 606 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 870 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 3511 of file imm.c.

{
    if (size < 4)
        size = 4;
    return LocalAlloc(LHND, size);
}

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

ImmCreateSoftKeyboard()

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

Definition at line 3215 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 956 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 3521 of file imm.c.

{
    if (block)
        return LocalFree(block);
    return NULL;
}

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

ImmDestroySoftKeyboard()

BOOL WINAPI ImmDestroySoftKeyboard

(

HWND

hSoftWnd

)

Definition at line 3225 of file imm.c.

{
    TRACE("(%p)\n", hSoftWnd);
    return DestroyWindow(hSoftWnd);
}

ImmDisableIME()

BOOL WINAPI ImmDisableIME

(

DWORD

dwThreadId

)

Definition at line 967 of file imm.c.

{
    return NtUserDisableThreadIme(dwThreadId);
}

Referenced by ActiveIMMApp_DisableIME(), and test_default_ime_disabled_cb().

ImmDisableLegacyIME()

BOOL WINAPI ImmDisableLegacyIME

(

void

)

Definition at line 3764 of file imm.c.

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

ImmDisableTextFrameService()

BOOL WINAPI ImmDisableTextFrameService

(

DWORD

dwThreadId

)

Definition at line 3729 of file imm.c.

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

ImmEnumInputContext()

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

Definition at line 3739 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 975 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 1010 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 1054 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 1089 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 3579 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 1527 of file imm.c.

{
    return ImmGetCandidateListAW(hIMC, dwIndex, lpCandList, dwBufLen, TRUE);
}

Referenced by ActiveIMMApp_GetCandidateListA(), and test_InvalidIMC().

ImmGetCandidateListAW()

static DWORD APIENTRY ImmGetCandidateListAW ( HIMC  hIMC, DWORD  dwIndex, LPCANDIDATELIST  lpCandList, DWORD  dwBufLen, BOOL  bAnsi  )

static

Definition at line 1358 of file imm.c.

{
    DWORD ret = 0;
    LPINPUTCONTEXT pIC;
    PCLIENTIMC pClientImc;
    LPCANDIDATEINFO pCI;
    LPCANDIDATELIST pCL;
    DWORD dwSize;

    pClientImc = ImmLockClientImc(hIMC);
    if (!pClientImc)
        return 0;

    pIC = ImmLockIMC(hIMC);
    if (pIC == NULL)
    {
        ImmUnlockClientImc(pClientImc);
        return 0;
    }

    pCI = ImmLockIMCC(pIC->hCandInfo);
    if (pCI == NULL)
    {
        ImmUnlockIMC(hIMC);
        ImmUnlockClientImc(pClientImc);
        return 0;
    }

    if (pCI->dwSize < sizeof(CANDIDATEINFO) || pCI->dwCount <= dwIndex)
        goto Quit;

    /* get required size */
    pCL = (LPCANDIDATELIST)((LPBYTE)pCI + pCI->dwOffset[dwIndex]);
    if (bAnsi)
    {
        if (pClientImc->dwFlags & CLIENTIMC_WIDE)
            dwSize = CandidateListAnsiToWide(pCL, NULL, 0, CP_ACP);
        else
            dwSize = pCL->dwSize;
    }
    else
    {
        if (pClientImc->dwFlags & CLIENTIMC_WIDE)
            dwSize = pCL->dwSize;
        else
            dwSize = CandidateListWideToAnsi(pCL, NULL, 0, CP_ACP);
    }

    if (dwBufLen != 0 && dwSize != 0)
    {
        if (lpCandList == NULL || dwBufLen < dwSize)
            goto Quit;

        /* store */
        if (bAnsi)
        {
            if (pClientImc->dwFlags & CLIENTIMC_WIDE)
                CandidateListAnsiToWide(pCL, lpCandList, dwSize, CP_ACP);
            else
                RtlCopyMemory(lpCandList, pCL, dwSize);
        }
        else
        {
            if (pClientImc->dwFlags & CLIENTIMC_WIDE)
                RtlCopyMemory(lpCandList, pCL, dwSize);
            else
                CandidateListWideToAnsi(pCL, lpCandList, dwSize, CP_ACP);
        }
    }

    ret = dwSize;

Quit:
    ImmUnlockIMCC(pIC->hCandInfo);
    ImmUnlockIMC(hIMC);
    ImmUnlockClientImc(pClientImc);
    return ret;
}

Referenced by ImmGetCandidateListA(), and ImmGetCandidateListW().

ImmGetCandidateListCountA()

DWORD WINAPI ImmGetCandidateListCountA	(	HIMC	hIMC,
		LPDWORD	lpdwListCount
	)

Definition at line 1537 of file imm.c.

{
    return ImmGetCandidateListCountAW(hIMC, lpdwListCount, TRUE);
}

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

ImmGetCandidateListCountAW()

DWORD APIENTRY ImmGetCandidateListCountAW	(	HIMC	hIMC,
		LPDWORD	lpdwListCount,
		BOOL	bAnsi
	)

Definition at line 1438 of file imm.c.

{
    DWORD ret = 0, cbGot, dwIndex;
    PCLIENTIMC pClientImc;
    LPINPUTCONTEXT pIC;
    const CANDIDATEINFO *pCI;
    const BYTE *pb;
    const CANDIDATELIST *pCL;
    const DWORD *pdwOffsets;

    if (lpdwListCount == NULL)
        return 0;

    *lpdwListCount = 0;

    pClientImc = ImmLockClientImc(hIMC);
    if (pClientImc == NULL)
        return 0;

    pIC = ImmLockIMC(hIMC);
    if (pIC == NULL)
    {
        ImmUnlockClientImc(pClientImc);
        return 0;
    }

    pCI = ImmLockIMCC(pIC->hCandInfo);
    if (pCI == NULL)
    {
        ImmUnlockIMC(hIMC);
        ImmUnlockClientImc(pClientImc);
        return 0;
    }

    if (pCI->dwSize < sizeof(CANDIDATEINFO))
        goto Quit;

    *lpdwListCount = pCI->dwCount; /* the number of candidate lists */

    /* calculate total size of candidate lists */
    if (bAnsi)
    {
        if (pClientImc->dwFlags & CLIENTIMC_WIDE)
        {
            ret = ROUNDUP4(pCI->dwPrivateSize);
            pdwOffsets = pCI->dwOffset;
            for (dwIndex = 0; dwIndex < pCI->dwCount; ++dwIndex)
            {
                pb = (const BYTE *)pCI + pdwOffsets[dwIndex];
                pCL = (const CANDIDATELIST *)pb;
                cbGot = CandidateListWideToAnsi(pCL, NULL, 0, CP_ACP);
                ret += cbGot;
            }
        }
        else
        {
            ret = pCI->dwSize;
        }
    }
    else
    {
        if (pClientImc->dwFlags & CLIENTIMC_WIDE)
        {
            ret = pCI->dwSize;
        }
        else
        {
            ret = ROUNDUP4(pCI->dwPrivateSize);
            pdwOffsets = pCI->dwOffset;
            for (dwIndex = 0; dwIndex < pCI->dwCount; ++dwIndex)
            {
                pb = (const BYTE *)pCI + pdwOffsets[dwIndex];
                pCL = (const CANDIDATELIST *)pb;
                cbGot = CandidateListAnsiToWide(pCL, NULL, 0, CP_ACP);
                ret += cbGot;
            }
        }
    }

Quit:
    ImmUnlockIMCC(pIC->hCandInfo);
    ImmUnlockIMC(hIMC);
    ImmUnlockClientImc(pClientImc);
    return ret;
}

Referenced by ImmGetCandidateListCountA(), and ImmGetCandidateListCountW().

ImmGetCandidateListCountW()

DWORD WINAPI ImmGetCandidateListCountW	(	HIMC	hIMC,
		LPDWORD	lpdwListCount
	)

Definition at line 1546 of file imm.c.

{
    return ImmGetCandidateListCountAW(hIMC, lpdwListCount, FALSE);
}

ImmGetCandidateListW()

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

Definition at line 1555 of file imm.c.

{
    return ImmGetCandidateListAW(hIMC, dwIndex, lpCandList, dwBufLen, FALSE);
}

Referenced by ActiveIMMApp_GetCandidateListW().

ImmGetCandidateWindow()

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

Definition at line 1565 of file imm.c.

{
    BOOL ret = FALSE;
    LPINPUTCONTEXT pIC;
    LPCANDIDATEFORM pCF;

    TRACE("ImmGetCandidateWindow(%p, %lu, %p)\n", hIMC, dwIndex, lpCandidate);

    pIC = ImmLockIMC(hIMC);
    if (pIC  == NULL)
        return FALSE;

    pCF = &pIC->cfCandForm[dwIndex];
    if (pCF->dwIndex != IMM_INVALID_CANDFORM)
    {
        *lpCandidate = *pCF;
        ret = TRUE;
    }

    ImmUnlockIMC(hIMC);
    return ret;
}

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

ImmGetCompositionFontA()

BOOL WINAPI ImmGetCompositionFontA	(	HIMC	hIMC,
		LPLOGFONTA	lplf
	)

Definition at line 1616 of file imm.c.

{
    PCLIENTIMC pClientImc;
    BOOL ret = FALSE, bWide;
    LPINPUTCONTEXT pIC;

    TRACE("ImmGetCompositionFontA(%p, %p)\n", hIMC, lplf);

    pClientImc = ImmLockClientImc(hIMC);
    if (pClientImc == NULL)
        return FALSE;

    bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);

    pIC = ImmLockIMC(hIMC);
    if (pIC == NULL)
        return FALSE;

    if (pIC->fdwInit & INIT_LOGFONT)
    {
        if (bWide)
            LogFontWideToAnsi(&pIC->lfFont.W, lplf);
        else
            *lplf = pIC->lfFont.A;

        ret = TRUE;
    }

    ImmUnlockIMC(hIMC);
    return ret;
}

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

ImmGetCompositionFontW()

BOOL WINAPI ImmGetCompositionFontW	(	HIMC	hIMC,
		LPLOGFONTW	lplf
	)

Definition at line 1652 of file imm.c.

{
    PCLIENTIMC pClientImc;
    BOOL bWide;
    LPINPUTCONTEXT pIC;
    BOOL ret = FALSE;

    TRACE("ImmGetCompositionFontW(%p, %p)\n", hIMC, lplf);

    pClientImc = ImmLockClientImc(hIMC);
    if (pClientImc == NULL)
        return FALSE;

    bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);

    pIC = ImmLockIMC(hIMC);
    if (pIC == NULL)
        return FALSE;

    if (pIC->fdwInit & INIT_LOGFONT)
    {
        if (bWide)
            *lplf = pIC->lfFont.W;
        else
            LogFontAnsiToWide(&pIC->lfFont.A, lplf);

        ret = TRUE;
    }

    ImmUnlockIMC(hIMC);
    return ret;
}

Referenced by ActiveIMMApp_GetCompositionFontW().

ImmGetCompositionStringA()

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

Definition at line 1959 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 1865 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 1969 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 1979 of file imm.c.

{
    LPINPUTCONTEXT pIC;
    BOOL ret = FALSE;

    TRACE("ImmGetCompositionWindow(%p, %p)\n", hIMC, lpCompForm);

    pIC = ImmLockIMC(hIMC);
    if (!pIC)
        return FALSE;

    if (pIC->fdwInit & INIT_COMPFORM)
    {
        *lpCompForm = pIC->cfCompForm;
        ret = TRUE;
    }

    ImmUnlockIMC(hIMC);
    return ret;
}

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

ImmGetContext()

HIMC WINAPI ImmGetContext

(

HWND

hWnd

)

Definition at line 2004 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(), ImmSetActiveContextConsoleIME(), 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 2036 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 2074 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 2112 of file imm.c.

{
    LPINPUTCONTEXT pIC;