ime.c File Reference

#include "precomp.h"
#include "imetable.h"

Include dependency graph for ime.c:

Go to the source code of this file.

Macros
#define	VALID_IME_PROP
#define	VALID_CMODE_CAPS
#define	VALID_SMODE_CAPS
#define	VALID_UI_CAPS
#define	VALID_SCS_CAPS
#define	VALID_SELECT_CAPS   (SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE)
#define	DEFINE_IME_ENTRY(type, name, params, optional)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
PIMEDPI APIENTRY	Imm32FindImeDpi (HKL hKL)
VOID APIENTRY	Imm32FreeImeDpi (PIMEDPI pImeDpi, BOOL bDestroy)
BOOL APIENTRY	Imm32InquireIme (PIMEDPI pImeDpi)
BOOL APIENTRY	Imm32LoadImeInfo (PIMEINFOEX pImeInfoEx, PIMEDPI pImeDpi)
PIMEDPI APIENTRY	Ime32LoadImeDpi (HKL hKL, BOOL bLock)
PIMEDPI APIENTRY	ImmLockOrLoadImeDpi (HKL hKL)
static LRESULT APIENTRY	ImeDpi_Escape (PIMEDPI pImeDpi, HIMC hIMC, UINT uSubFunc, LPVOID lpData, HKL hKL)
BOOL APIENTRY	Imm32ReleaseIME (HKL hKL)
DWORD APIENTRY	Imm32GetImeMenuItemWCrossProcess (HIMC hIMC, DWORD dwFlags, DWORD dwType, LPVOID lpImeParentMenu, LPVOID lpImeMenu, DWORD dwSize)
DWORD APIENTRY	Imm32GetImeMenuItemsAW (HIMC hIMC, DWORD dwFlags, DWORD dwType, LPVOID lpImeParentMenu, LPVOID lpImeMenu, DWORD dwSize, BOOL bTargetIsAnsi)
HKL WINAPI	ImmInstallIMEA (LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
HKL WINAPI	ImmInstallIMEW (LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
BOOL WINAPI	ImmIsIME (HKL hKL)
HWND WINAPI	ImmGetDefaultIMEWnd (HWND hWnd)
BOOL WINAPI	ImmNotifyIME (HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
BOOL WINAPI	ImmDisableLegacyIME (void)
BOOL WINAPI	ImmGetImeInfoEx (PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType, PVOID pvSearchKey)
PIMEDPI WINAPI	ImmLockImeDpi (HKL hKL)
VOID WINAPI	ImmUnlockImeDpi (PIMEDPI pImeDpi)
BOOL WINAPI	ImmLoadIME (HKL hKL)
BOOL WINAPI	ImmDisableIME (DWORD dwThreadId)
UINT WINAPI	ImmGetDescriptionA (HKL hKL, LPSTR lpszDescription, UINT uBufLen)
UINT WINAPI	ImmGetDescriptionW (HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
UINT WINAPI	ImmGetIMEFileNameA (HKL hKL, LPSTR lpszFileName, UINT uBufLen)
UINT WINAPI	ImmGetIMEFileNameW (HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
DWORD WINAPI	ImmGetProperty (HKL hKL, DWORD fdwIndex)
LRESULT WINAPI	ImmEscapeA (HKL hKL, HIMC hIMC, UINT uSubFunc, LPVOID lpData)
LRESULT WINAPI	ImmEscapeW (HKL hKL, HIMC hIMC, UINT uSubFunc, LPVOID lpData)
BOOL WINAPI	ImmGetOpenStatus (HIMC hIMC)
BOOL WINAPI	ImmSetOpenStatus (HIMC hIMC, BOOL fOpen)
BOOL WINAPI	ImmGetStatusWindowPos (HIMC hIMC, LPPOINT lpptPos)
BOOL WINAPI	ImmSetStatusWindowPos (HIMC hIMC, LPPOINT lpptPos)
BOOL WINAPI	ImmGetCompositionWindow (HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
BOOL WINAPI	ImmSetCompositionWindow (HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
BOOL WINAPI	ImmGetCompositionFontA (HIMC hIMC, LPLOGFONTA lplf)
BOOL WINAPI	ImmGetCompositionFontW (HIMC hIMC, LPLOGFONTW lplf)
BOOL WINAPI	ImmSetCompositionFontA (HIMC hIMC, LPLOGFONTA lplf)
BOOL WINAPI	ImmSetCompositionFontW (HIMC hIMC, LPLOGFONTW lplf)
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)
BOOL WINAPI	ImmSetConversionStatus (HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
BOOL WINAPI	ImmConfigureIMEA (HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
BOOL WINAPI	ImmConfigureIMEW (HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
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)

Variables
RTL_CRITICAL_SECTION	g_csImeDpi
PIMEDPI	g_pImeDpiList = NULL

Macro Definition Documentation

DEFINE_IME_ENTRY

#define DEFINE_IME_ENTRY	(		type,
			name,
			params,
			optional
	)

Value:

do { \
        fn = GetProcAddress(hIME, #name); \
        if (fn) pImeDpi->name = (FN_##name)fn; \
        else if (!(optional)) { \
            ERR("'%s' not found in the IME module '%s'.\n", #name, debugstr_w(szPath)); \
            goto Failed; \
        } \
    } while (0);

VALID_CMODE_CAPS

#define VALID_CMODE_CAPS

Value:

(IME_CMODE_ALPHANUMERIC | \
                          IME_CMODE_NATIVE       | \
                          IME_CMODE_KATAKANA     | \
                          IME_CMODE_LANGUAGE     | \
                          IME_CMODE_FULLSHAPE    | \
                          IME_CMODE_ROMAN        | \
                          IME_CMODE_CHARCODE     | \
                          IME_CMODE_HANJACONVERT | \
                          IME_CMODE_SOFTKBD      | \
                          IME_CMODE_NOCONVERSION | \
                          IME_CMODE_EUDC         | \
                          IME_CMODE_SYMBOL       | \
                          IME_CMODE_FIXED)

VALID_IME_PROP

#define VALID_IME_PROP

Value:

(IME_PROP_AT_CARET              | \
                        IME_PROP_SPECIAL_UI            | \
                        IME_PROP_CANDLIST_START_FROM_1 | \
                        IME_PROP_UNICODE               | \
                        IME_PROP_COMPLETE_ON_UNSELECT  | \
                        IME_PROP_END_UNLOAD            | \
                        IME_PROP_KBD_CHAR_FIRST        | \
                        IME_PROP_IGNORE_UPKEYS         | \
                        IME_PROP_NEED_ALTKEY           | \
                        IME_PROP_NO_KEYS_ON_CLOSE      | \
                        IME_PROP_ACCEPT_WIDE_VKEY)

VALID_SCS_CAPS

#define VALID_SCS_CAPS

Value:

(SCS_CAP_COMPSTR            | \
                        SCS_CAP_MAKEREAD           | \
                        SCS_CAP_SETRECONVERTSTRING)

VALID_SELECT_CAPS

#define VALID_SELECT_CAPS   (SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE)

VALID_SMODE_CAPS

#define VALID_SMODE_CAPS

Value:

(IME_SMODE_NONE          | \
                          IME_SMODE_PLAURALCLAUSE | \
                          IME_SMODE_SINGLECONVERT | \
                          IME_SMODE_AUTOMATIC     | \
                          IME_SMODE_PHRASEPREDICT | \
                          IME_SMODE_CONVERSATION)

VALID_UI_CAPS

#define VALID_UI_CAPS

Value:

(UI_CAP_2700    | \
                       UI_CAP_ROT90   | \
                       UI_CAP_ROTANY  | \
                       UI_CAP_SOFTKBD)

Function Documentation

Ime32LoadImeDpi()

PIMEDPI APIENTRY Ime32LoadImeDpi	(	HKL	hKL,
		BOOL	bLock
	)

Definition at line 218 of file ime.c.

{
    IMEINFOEX ImeInfoEx;
    CHARSETINFO ci;
    PIMEDPI pImeDpiNew, pImeDpiFound;
    UINT uCodePage;
    LCID lcid;

    if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL) ||
        ImeInfoEx.fLoadFlag == 1)
    {
        return NULL;
    }

    pImeDpiNew = Imm32HeapAlloc(HEAP_ZERO_MEMORY, sizeof(IMEDPI));
    if (pImeDpiNew == NULL)
        return NULL;

    pImeDpiNew->hKL = hKL;

    lcid = LOWORD(hKL);
    if (TranslateCharsetInfo((LPDWORD)(DWORD_PTR)lcid, &ci, TCI_SRCLOCALE))
        uCodePage = ci.ciACP;
    else
        uCodePage = CP_ACP;
    pImeDpiNew->uCodePage = uCodePage;

    if (!Imm32LoadImeInfo(&ImeInfoEx, pImeDpiNew))
    {
        Imm32HeapFree(pImeDpiNew);
        return FALSE;
    }

    RtlEnterCriticalSection(&g_csImeDpi);

    pImeDpiFound = Imm32FindImeDpi(hKL);
    if (pImeDpiFound)
    {
        if (!bLock)
            pImeDpiFound->dwFlags &= ~IMEDPI_FLAG_LOCKED;

        RtlLeaveCriticalSection(&g_csImeDpi);

        Imm32FreeImeDpi(pImeDpiNew, FALSE);
        Imm32HeapFree(pImeDpiNew);
        return pImeDpiFound;
    }
    else
    {
        if (bLock)
        {
            pImeDpiNew->dwFlags |= IMEDPI_FLAG_LOCKED;
            pImeDpiNew->cLockObj = 1;
        }

        pImeDpiNew->pNext = g_pImeDpiList;
        g_pImeDpiList = pImeDpiNew;

        RtlLeaveCriticalSection(&g_csImeDpi);
        return pImeDpiNew;
    }
}

Referenced by ImmLoadIME(), and ImmLockOrLoadImeDpi().

ImeDpi_Escape()

static LRESULT APIENTRY ImeDpi_Escape ( PIMEDPI  pImeDpi, HIMC  hIMC, UINT  uSubFunc, LPVOID  lpData, HKL  hKL  )

static

Definition at line 295 of file ime.c.

{
    if (IS_IME_HKL(hKL))
        return pImeDpi->ImeEscape(hIMC, uSubFunc, lpData);

    if (Imm32IsCiceroMode() && pImeDpi->CtfImeEscapeEx)
        return pImeDpi->CtfImeEscapeEx(hIMC, uSubFunc, lpData, hKL);

    return 0;
}

Referenced by ImmEscapeA(), and ImmEscapeW().

Imm32FindImeDpi()

PIMEDPI APIENTRY Imm32FindImeDpi

(

HKL

hKL

)

Definition at line 20 of file ime.c.

{
    PIMEDPI pImeDpi;

    RtlEnterCriticalSection(&g_csImeDpi);
    for (pImeDpi = g_pImeDpiList; pImeDpi != NULL; pImeDpi = pImeDpi->pNext)
    {
        if (pImeDpi->hKL == hKL)
            break;
    }
    RtlLeaveCriticalSection(&g_csImeDpi);

    return pImeDpi;
}

Referenced by Ime32LoadImeDpi(), and ImmLoadIME().

Imm32FreeImeDpi()

VOID APIENTRY Imm32FreeImeDpi	(	PIMEDPI	pImeDpi,
		BOOL	bDestroy
	)

Definition at line 35 of file ime.c.

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

Referenced by Ime32LoadImeDpi(), Imm32ReleaseIME(), and ImmUnlockImeDpi().

Imm32GetImeMenuItemsAW()

DWORD APIENTRY Imm32GetImeMenuItemsAW	(	HIMC	hIMC,
		DWORD	dwFlags,
		DWORD	dwType,
		LPVOID	lpImeParentMenu,
		LPVOID	lpImeMenu,
		DWORD	dwSize,
		BOOL	bTargetIsAnsi
	)

Definition at line 362 of file ime.c.

{
    DWORD ret = 0, cbTotal, dwProcessId, dwThreadId, iItem;
    LPINPUTCONTEXT pIC;
    PIMEDPI pImeDpi = NULL;
    IMEMENUITEMINFOA ParentA;
    IMEMENUITEMINFOW ParentW;
    LPIMEMENUITEMINFOA pItemA;
    LPIMEMENUITEMINFOW pItemW;
    LPVOID pNewItems = NULL, pNewParent = NULL;
    BOOL bImcIsAnsi;
    HKL hKL;

    if (!hIMC)
        return 0;

    dwProcessId = NtUserQueryInputContext(hIMC, 0);
    if (dwProcessId == 0)
        return 0;

    if (dwProcessId != GetCurrentProcessId())
    {
        if (bTargetIsAnsi)
            return 0;
        return Imm32GetImeMenuItemWCrossProcess(hIMC, dwFlags, dwType, lpImeParentMenu,
                                                lpImeMenu, dwSize);
    }

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

    dwThreadId = NtUserQueryInputContext(hIMC, 1);
    if (dwThreadId == 0)
    {
        ImmUnlockIMC(hIMC);
        return 0;
    }

    hKL = GetKeyboardLayout(dwThreadId);
    pImeDpi = ImmLockImeDpi(hKL);
    if (!pImeDpi)
    {
        ImmUnlockIMC(hIMC);
        return 0;
    }

    if (pImeDpi->ImeGetImeMenuItems == NULL)
        goto Quit;

    bImcIsAnsi = Imm32IsImcAnsi(hIMC);

    if (bImcIsAnsi != bTargetIsAnsi)
    {
        if (bTargetIsAnsi)
        {
            if (lpImeParentMenu)
                pNewParent = &ParentW;

            if (lpImeMenu)
            {
                cbTotal = ((dwSize / sizeof(IMEMENUITEMINFOA)) * sizeof(IMEMENUITEMINFOW));
                pNewItems = Imm32HeapAlloc(0, cbTotal);
                if (!pNewItems)
                    goto Quit;
            }
        }
        else
        {
            if (lpImeParentMenu)
                pNewParent = &ParentA;

            if (lpImeMenu)
            {
                cbTotal = ((dwSize / sizeof(IMEMENUITEMINFOW)) * sizeof(IMEMENUITEMINFOA));
                pNewItems = Imm32HeapAlloc(0, cbTotal);
                if (!pNewItems)
                    goto Quit;
            }
        }
    }
    else
    {
        pNewItems = lpImeMenu;
        pNewParent = lpImeParentMenu;
    }

    ret = pImeDpi->ImeGetImeMenuItems(hIMC, dwFlags, dwType, pNewParent, pNewItems, dwSize);
    if (!ret || !lpImeMenu)
        goto Quit;

    if (bImcIsAnsi != bTargetIsAnsi)
    {
        if (bTargetIsAnsi)
        {
            if (pNewParent)
                Imm32ImeMenuWideToAnsi(pNewParent, lpImeParentMenu, CP_ACP);

            pItemW = pNewItems;
            pItemA = lpImeMenu;
            for (iItem = 0; iItem < ret; ++iItem, ++pItemW, ++pItemA)
            {
                if (!Imm32ImeMenuWideToAnsi(pItemW, pItemA, CP_ACP))
                {
                    ret = 0;
                    break;
                }
            }
        }
        else
        {
            if (pNewParent)
                Imm32ImeMenuAnsiToWide(pNewParent, lpImeParentMenu, pImeDpi->uCodePage, TRUE);

            pItemA = pNewItems;
            pItemW = lpImeMenu;
            for (iItem = 0; iItem < dwSize; ++iItem, ++pItemA, ++pItemW)
            {
                if (!Imm32ImeMenuAnsiToWide(pItemA, pItemW, pImeDpi->uCodePage, TRUE))
                {
                    ret = 0;
                    break;
                }
            }
        }
    }

Quit:
    if (pNewItems != lpImeMenu)
        Imm32HeapFree(pNewItems);
    ImmUnlockImeDpi(pImeDpi);
    ImmUnlockIMC(hIMC);
    return ret;
}

Referenced by ImmGetImeMenuItemsA(), and ImmGetImeMenuItemsW().

Imm32GetImeMenuItemWCrossProcess()

DWORD APIENTRY Imm32GetImeMenuItemWCrossProcess	(	HIMC	hIMC,
		DWORD	dwFlags,
		DWORD	dwType,
		LPVOID	lpImeParentMenu,
		LPVOID	lpImeMenu,
		DWORD	dwSize
	)

Definition at line 354 of file ime.c.

{
    FIXME("We have to do something\n");
    return 0;
}

Referenced by Imm32GetImeMenuItemsAW().

Imm32InquireIme()

BOOL APIENTRY Imm32InquireIme

(

PIMEDPI

pImeDpi

)

Definition at line 45 of file ime.c.

{
    WCHAR szUIClass[64];
    WNDCLASSW wcW;
    DWORD dwSysInfoFlags = 0;
    LPIMEINFO pImeInfo = &pImeDpi->ImeInfo;

    if (NtUserGetThreadState(16))
        dwSysInfoFlags |= IME_SYSINFO_WINLOGON;

    if (IS_IME_HKL(pImeDpi->hKL))
    {
        if (!pImeDpi->ImeInquire(pImeInfo, szUIClass, dwSysInfoFlags))
            return FALSE;
    }
    else if (Imm32IsCiceroMode() && pImeDpi->CtfImeInquireExW)
    {
        if (!pImeDpi->CtfImeInquireExW(pImeInfo, szUIClass, dwSysInfoFlags, pImeDpi->hKL))
            return FALSE;
    }
    else
    {
        return FALSE;
    }

    szUIClass[_countof(szUIClass) - 1] = 0;

    if (pImeInfo->dwPrivateDataSize == 0)
        pImeInfo->dwPrivateDataSize = sizeof(DWORD);

#define VALID_IME_PROP (IME_PROP_AT_CARET              | \
                        IME_PROP_SPECIAL_UI            | \
                        IME_PROP_CANDLIST_START_FROM_1 | \
                        IME_PROP_UNICODE               | \
                        IME_PROP_COMPLETE_ON_UNSELECT  | \
                        IME_PROP_END_UNLOAD            | \
                        IME_PROP_KBD_CHAR_FIRST        | \
                        IME_PROP_IGNORE_UPKEYS         | \
                        IME_PROP_NEED_ALTKEY           | \
                        IME_PROP_NO_KEYS_ON_CLOSE      | \
                        IME_PROP_ACCEPT_WIDE_VKEY)
#define VALID_CMODE_CAPS (IME_CMODE_ALPHANUMERIC | \
                          IME_CMODE_NATIVE       | \
                          IME_CMODE_KATAKANA     | \
                          IME_CMODE_LANGUAGE     | \
                          IME_CMODE_FULLSHAPE    | \
                          IME_CMODE_ROMAN        | \
                          IME_CMODE_CHARCODE     | \
                          IME_CMODE_HANJACONVERT | \
                          IME_CMODE_SOFTKBD      | \
                          IME_CMODE_NOCONVERSION | \
                          IME_CMODE_EUDC         | \
                          IME_CMODE_SYMBOL       | \
                          IME_CMODE_FIXED)
#define VALID_SMODE_CAPS (IME_SMODE_NONE          | \
                          IME_SMODE_PLAURALCLAUSE | \
                          IME_SMODE_SINGLECONVERT | \
                          IME_SMODE_AUTOMATIC     | \
                          IME_SMODE_PHRASEPREDICT | \
                          IME_SMODE_CONVERSATION)
#define VALID_UI_CAPS (UI_CAP_2700    | \
                       UI_CAP_ROT90   | \
                       UI_CAP_ROTANY  | \
                       UI_CAP_SOFTKBD)
#define VALID_SCS_CAPS (SCS_CAP_COMPSTR            | \
                        SCS_CAP_MAKEREAD           | \
                        SCS_CAP_SETRECONVERTSTRING)
#define VALID_SELECT_CAPS (SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE)

    if (pImeInfo->fdwProperty & ~VALID_IME_PROP)
        return FALSE;
    if (pImeInfo->fdwConversionCaps & ~VALID_CMODE_CAPS)
        return FALSE;
    if (pImeInfo->fdwSentenceCaps & ~VALID_SMODE_CAPS)
        return FALSE;
    if (pImeInfo->fdwUICaps & ~VALID_UI_CAPS)
        return FALSE;
    if (pImeInfo->fdwSCSCaps & ~VALID_SCS_CAPS)
        return FALSE;
    if (pImeInfo->fdwSelectCaps & ~VALID_SELECT_CAPS)
        return FALSE;

#undef VALID_IME_PROP
#undef VALID_CMODE_CAPS
#undef VALID_SMODE_CAPS
#undef VALID_UI_CAPS
#undef VALID_SCS_CAPS
#undef VALID_SELECT_CAPS

    if (pImeInfo->fdwProperty & IME_PROP_UNICODE)
    {
        StringCchCopyW(pImeDpi->szUIClass, _countof(pImeDpi->szUIClass), szUIClass);
    }
    else
    {
        if (pImeDpi->uCodePage != GetACP() && pImeDpi->uCodePage)
            return FALSE;

        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPSTR)szUIClass, -1,
                            pImeDpi->szUIClass, _countof(pImeDpi->szUIClass));
    }

    return GetClassInfoW(pImeDpi->hInst, pImeDpi->szUIClass, &wcW);
}

Referenced by Imm32LoadImeInfo().

Imm32LoadImeInfo()

BOOL APIENTRY Imm32LoadImeInfo	(	PIMEINFOEX	pImeInfoEx,
		PIMEDPI	pImeDpi
	)

Definition at line 150 of file ime.c.

{
    WCHAR szPath[MAX_PATH];
    HINSTANCE hIME;
    FARPROC fn;
    BOOL ret = FALSE;

    if (!Imm32GetSystemLibraryPath(szPath, _countof(szPath), pImeInfoEx->wszImeFile))
        return FALSE;

    hIME = GetModuleHandleW(szPath);
    if (hIME == NULL)
    {
        hIME = LoadLibraryW(szPath);
        if (hIME == NULL)
        {
            ERR("Imm32LoadImeInfo: LoadLibraryW(%S) failed\n", szPath);
            return FALSE;
        }
    }
    pImeDpi->hInst = hIME;

#define DEFINE_IME_ENTRY(type, name, params, optional) \
    do { \
        fn = GetProcAddress(hIME, #name); \
        if (fn) pImeDpi->name = (FN_##name)fn; \
        else if (!(optional)) { \
            ERR("'%s' not found in the IME module '%s'.\n", #name, debugstr_w(szPath)); \
            goto Failed; \
        } \
    } while (0);
#include "imetable.h"
#undef DEFINE_IME_ENTRY

    if (Imm32InquireIme(pImeDpi))
    {
        ret = TRUE;
    }
    else
    {
        ERR("Imm32InquireIme failed\n");
Failed:
        ret = FALSE;
        FreeLibrary(pImeDpi->hInst);
        pImeDpi->hInst = NULL;
    }

    if (pImeInfoEx->fLoadFlag == 0)
    {
        if (ret)
        {
            C_ASSERT(sizeof(pImeInfoEx->wszUIClass) == sizeof(pImeDpi->szUIClass));
            pImeInfoEx->ImeInfo = pImeDpi->ImeInfo;
            RtlCopyMemory(pImeInfoEx->wszUIClass, pImeDpi->szUIClass,
                          sizeof(pImeInfoEx->wszUIClass));
            pImeInfoEx->fLoadFlag = 2;
        }
        else
        {
            pImeInfoEx->fLoadFlag = 1;
        }

        NtUserSetImeInfoEx(pImeInfoEx);
    }

    return ret;
}

Referenced by Ime32LoadImeDpi().

Imm32ReleaseIME()

BOOL APIENTRY Imm32ReleaseIME

(

HKL

hKL

)

Definition at line 306 of file ime.c.

{
    BOOL ret = TRUE;
    PIMEDPI pImeDpi0, pImeDpi1;

    RtlEnterCriticalSection(&g_csImeDpi);

    for (pImeDpi0 = g_pImeDpiList; pImeDpi0; pImeDpi0 = pImeDpi0->pNext)
    {
        if (pImeDpi0->hKL == hKL)
            break;
    }

    if (!pImeDpi0)
        goto Quit;

    if (pImeDpi0->cLockObj)
    {
        pImeDpi0->dwFlags |= IMEDPI_FLAG_UNKNOWN;
        ret = FALSE;
        goto Quit;
    }

    if (g_pImeDpiList == pImeDpi0)
    {
        g_pImeDpiList = pImeDpi0->pNext;
    }
    else if (g_pImeDpiList)
    {
        for (pImeDpi1 = g_pImeDpiList; pImeDpi1; pImeDpi1 = pImeDpi1->pNext)
        {
            if (pImeDpi1->pNext == pImeDpi0)
            {
                pImeDpi1->pNext = pImeDpi0->pNext;
                break;
            }
        }
    }

    Imm32FreeImeDpi(pImeDpi0, TRUE);
    Imm32HeapFree(pImeDpi0);

Quit:
    RtlLeaveCriticalSection(&g_csImeDpi);
    return ret;
}

Referenced by ImmFreeLayout().

ImmConfigureIMEA()

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

Definition at line 1683 of file ime.c.

{
    BOOL ret = FALSE;
    PIMEDPI pImeDpi;
    REGISTERWORDW RegWordW;
    LPREGISTERWORDA pRegWordA;

    TRACE("(%p, %p, 0x%lX, %p)", hKL, hWnd, dwMode, lpData);

    if (!ValidateHwndNoErr(hWnd) || Imm32IsCrossProcessAccess(hWnd))
        return FALSE;

    pImeDpi = ImmLockOrLoadImeDpi(hKL);
    if (!pImeDpi)
        return FALSE;

    RtlZeroMemory(&RegWordW, sizeof(RegWordW));

    if (!ImeDpi_IsUnicode(pImeDpi) || !lpData || dwMode != IME_CONFIG_REGISTERWORD)
        goto DoIt;

    pRegWordA = lpData;

    if (pRegWordA->lpReading)
    {
        RegWordW.lpReading = Imm32WideFromAnsi(pRegWordA->lpReading);
        if (!RegWordW.lpReading)
            goto Quit;
    }

    if (pRegWordA->lpWord)
    {
        RegWordW.lpWord = Imm32WideFromAnsi(pRegWordA->lpWord);
        if (!RegWordW.lpWord)
            goto Quit;
    }

    lpData = &RegWordW;

DoIt:
    SendMessageW(hWnd, WM_IME_SYSTEM, 0x1B, 0);
    ret = pImeDpi->ImeConfigure(hKL, hWnd, dwMode, lpData);
    SendMessageW(hWnd, WM_IME_SYSTEM, 0x1A, 0);

Quit:
    Imm32HeapFree(RegWordW.lpReading);
    Imm32HeapFree(RegWordW.lpWord);
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ActiveIMMApp_ConfigureIMEA(), and test_ImmIME().

ImmConfigureIMEW()

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

Definition at line 1737 of file ime.c.

{
    BOOL ret = FALSE;
    PIMEDPI pImeDpi;
    REGISTERWORDA RegWordA;
    LPREGISTERWORDW pRegWordW;

    TRACE("(%p, %p, 0x%lX, %p)", hKL, hWnd, dwMode, lpData);

    if (!ValidateHwndNoErr(hWnd) || Imm32IsCrossProcessAccess(hWnd))
        return FALSE;

    pImeDpi = ImmLockOrLoadImeDpi(hKL);
    if (!pImeDpi)
        return FALSE;

    RtlZeroMemory(&RegWordA, sizeof(RegWordA));

    if (ImeDpi_IsUnicode(pImeDpi) || !lpData || dwMode != IME_CONFIG_REGISTERWORD)
        goto DoIt;

    pRegWordW = lpData;

    if (pRegWordW->lpReading)
    {
        RegWordA.lpReading = Imm32AnsiFromWide(pRegWordW->lpReading);
        if (!RegWordA.lpReading)
            goto Quit;
    }

    if (pRegWordW->lpWord)
    {
        RegWordA.lpWord = Imm32AnsiFromWide(pRegWordW->lpWord);
        if (!RegWordA.lpWord)
            goto Quit;
    }

    lpData = &RegWordA;

DoIt:
    SendMessageW(hWnd, WM_IME_SYSTEM, 0x1B, 0);
    ret = pImeDpi->ImeConfigure(hKL, hWnd, dwMode, lpData);
    SendMessageW(hWnd, WM_IME_SYSTEM, 0x1A, 0);

Quit:
    Imm32HeapFree(RegWordA.lpReading);
    Imm32HeapFree(RegWordA.lpWord);
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ActiveIMMApp_ConfigureIMEW(), and test_ImmIME().

ImmDisableIME()

BOOL WINAPI ImmDisableIME

(

DWORD

dwThreadId

)

Definition at line 819 of file ime.c.

{
    return NtUserDisableThreadIme(dwThreadId);
}

Referenced by ActiveIMMApp_DisableIME(), and test_default_ime_disabled_cb().

ImmDisableLegacyIME()

BOOL WINAPI ImmDisableLegacyIME

(

void

)

Definition at line 672 of file ime.c.

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

ImmEscapeA()

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

Definition at line 977 of file ime.c.

{
    LRESULT ret;
    PIMEDPI pImeDpi;
    INT cch;
    CHAR szA[MAX_IMM_FILENAME];
    WCHAR szW[MAX_IMM_FILENAME];

    TRACE("(%p, %p, %u, %p)\n", hKL, hIMC, uSubFunc, lpData);

    pImeDpi = ImmLockOrLoadImeDpi(hKL);
    if (!pImeDpi)
        return 0;

    if (!ImeDpi_IsUnicode(pImeDpi) || !lpData)
    {
        ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    switch (uSubFunc)
    {
        case IME_ESC_SEQUENCE_TO_INTERNAL:
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);

            cch = 0;
            if (HIWORD(ret))
                szW[cch++] = HIWORD(ret);
            if (LOWORD(ret))
                szW[cch++] = LOWORD(ret);

            cch = WideCharToMultiByte(pImeDpi->uCodePage, 0, szW, cch, szA, _countof(szA),
                                      NULL, NULL);
            switch (cch)
            {
                case 1:
                    ret = MAKEWORD(szA[0], 0);
                    break;
                case 2:
                    ret = MAKEWORD(szA[1], szA[0]);
                    break;
                case 3:
                    ret = MAKELONG(MAKEWORD(szA[2], szA[1]), MAKEWORD(szA[0], 0));
                    break;
                case 4:
                    ret = MAKELONG(MAKEWORD(szA[3], szA[2]), MAKEWORD(szA[1], szA[0]));
                    break;
                default:
                    ret = 0;
                    break;
            }
            break;

        case IME_ESC_GET_EUDC_DICTIONARY:
        case IME_ESC_IME_NAME:
        case IME_ESC_GETHELPFILENAME:
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szW, hKL);
            if (ret)
            {
                szW[_countof(szW) - 1] = 0;
                WideCharToMultiByte(pImeDpi->uCodePage, 0, szW, -1,
                                    lpData, MAX_IMM_FILENAME, NULL, NULL);
                ((LPSTR)lpData)[MAX_IMM_FILENAME - 1] = 0;
            }
            break;

        case IME_ESC_SET_EUDC_DICTIONARY:
        case IME_ESC_HANJA_MODE:
            MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
                                lpData, -1, szW, _countof(szW));
            szW[_countof(szW) - 1] = 0;
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szW, hKL);
            break;

        default:
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
            break;
    }

    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ActiveIMMApp_EscapeA().

ImmEscapeW()

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

Definition at line 1064 of file ime.c.

{
    LRESULT ret;
    PIMEDPI pImeDpi;
    INT cch;
    CHAR szA[MAX_IMM_FILENAME];
    WCHAR szW[MAX_IMM_FILENAME];
    WORD word;

    TRACE("(%p, %p, %u, %p)\n", hKL, hIMC, uSubFunc, lpData);

    pImeDpi = ImmLockOrLoadImeDpi(hKL);
    if (!pImeDpi)
        return 0;

    if (ImeDpi_IsUnicode(pImeDpi) || !lpData)
    {
        ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    switch (uSubFunc)
    {
        case IME_ESC_SEQUENCE_TO_INTERNAL:
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);

            word = LOWORD(ret);
            cch = 0;
            if (HIBYTE(word))
                szA[cch++] = HIBYTE(word);
            if (LOBYTE(word))
                szA[cch++] = LOBYTE(word);

            cch = MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
                                      szA, cch, szW, _countof(szW));
            switch (cch)
            {
                case 1:  ret = szW[0]; break;
                case 2:  ret = MAKELONG(szW[1], szW[0]); break;
                default: ret = 0; break;
            }
            break;

        case IME_ESC_GET_EUDC_DICTIONARY:
        case IME_ESC_IME_NAME:
        case IME_ESC_GETHELPFILENAME:
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szA, hKL);
            if (ret)
            {
                szA[_countof(szA) - 1] = 0;
                MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
                                    szA, -1, lpData, MAX_IMM_FILENAME);
                ((LPWSTR)lpData)[MAX_IMM_FILENAME - 1] = 0;
            }
            break;

        case IME_ESC_SET_EUDC_DICTIONARY:
        case IME_ESC_HANJA_MODE:
            WideCharToMultiByte(pImeDpi->uCodePage, 0,
                                lpData, -1, szA, _countof(szA), NULL, NULL);
            szA[_countof(szA) - 1] = 0;
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szA, hKL);
            break;

        default:
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
            break;
    }

    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ActiveIMMApp_EscapeW().

ImmGetCompositionFontA()

BOOL WINAPI ImmGetCompositionFontA	(	HIMC	hIMC,
		LPLOGFONTA	lplf
	)

Definition at line 1304 of file ime.c.

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

    TRACE("(%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 1340 of file ime.c.

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

    TRACE("(%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().

ImmGetCompositionWindow()

BOOL WINAPI ImmGetCompositionWindow	(	HIMC	hIMC,
		LPCOMPOSITIONFORM	lpCompForm
	)

Definition at line 1253 of file ime.c.

{
    LPINPUTCONTEXT pIC;
    BOOL ret = FALSE;

    TRACE("(%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().

ImmGetConversionListA()

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

Definition at line 1493 of file ime.c.

{
    DWORD ret = 0;
    UINT cb;
    LPWSTR pszSrcW = NULL;
    LPCANDIDATELIST pCL = NULL;
    PIMEDPI pImeDpi;

    TRACE("(%p, %p, %s, %p, %lu, 0x%lX)\n", hKL, hIMC, debugstr_a(pSrc),
          lpDst, dwBufLen, uFlag);

    pImeDpi = ImmLockOrLoadImeDpi(hKL);
    if (pImeDpi == NULL)
        return 0;

    if (!ImeDpi_IsUnicode(pImeDpi))
    {
        ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    if (pSrc)
    {
        pszSrcW = Imm32WideFromAnsi(pSrc);
        if (pszSrcW == NULL)
            goto Quit;
    }

    cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, NULL, 0, uFlag);
    if (cb == 0)
        goto Quit;

    pCL = Imm32HeapAlloc(0, cb);
    if (pCL == NULL)
        goto Quit;

    cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, pCL, cb, uFlag);
    if (cb == 0)
        goto Quit;

    ret = CandidateListWideToAnsi(pCL, lpDst, dwBufLen, CP_ACP);

Quit:
    Imm32HeapFree(pszSrcW);
    Imm32HeapFree(pCL);
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ActiveIMMApp_GetConversionListA().

ImmGetConversionListW()

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

Definition at line 1548 of file ime.c.

{
    DWORD ret = 0;
    INT cb;
    PIMEDPI pImeDpi;
    LPCANDIDATELIST pCL = NULL;
    LPSTR pszSrcA = NULL;

    TRACE("(%p, %p, %s, %p, %lu, 0x%lX)\n", hKL, hIMC, debugstr_w(pSrc),
          lpDst, dwBufLen, uFlag);

    pImeDpi = ImmLockOrLoadImeDpi(hKL);
    if (!pImeDpi)
        return 0;

    if (ImeDpi_IsUnicode(pImeDpi))
    {
        ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    if (pSrc)
    {
        pszSrcA = Imm32AnsiFromWide(pSrc);
        if (pszSrcA == NULL)
            goto Quit;
    }

    cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, NULL, 0, uFlag);
    if (cb == 0)
        goto Quit;

    pCL = Imm32HeapAlloc(0, cb);
    if (!pCL)
        goto Quit;

    cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, pCL, cb, uFlag);
    if (!cb)
        goto Quit;

    ret = CandidateListAnsiToWide(pCL, lpDst, dwBufLen, CP_ACP);

Quit:
    Imm32HeapFree(pszSrcA);
    Imm32HeapFree(pCL);
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ActiveIMMApp_GetConversionListW().

ImmGetConversionStatus()

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

Definition at line 1602 of file ime.c.

{
    LPINPUTCONTEXT pIC;

    TRACE("(%p %p %p)\n", hIMC, lpfdwConversion, lpfdwSentence);

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

    if (lpfdwConversion)
        *lpfdwConversion = pIC->fdwConversion;
    if (lpfdwSentence)
        *lpfdwSentence = pIC->fdwSentence;

    ImmUnlockIMC(hIMC);
    return TRUE;
}

Referenced by ActiveIMMApp_GetConversionStatus(), and test_ImmThreads().

ImmGetDefaultIMEWnd()

HWND WINAPI ImmGetDefaultIMEWnd

(

HWND

hWnd

)

Definition at line 633 of file ime.c.

{
    if (!Imm32IsImmMode())
        return NULL;

    // FIXME: NtUserGetThreadState and enum ThreadStateRoutines are broken.
    if (hWnd == NULL)
        return (HWND)NtUserGetThreadState(3);

    return (HWND)NtUserQueryWindow(hWnd, QUERY_WINDOW_DEFAULT_IME);
}

Referenced by ActiveIMMApp_GetDefaultIMEWnd(), DoTest_BUTTON(), DoTest_EDIT(), Imm32UnknownProcess1Proc(), ImmActivateLayout(), ImmSetActiveContext(), 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 827 of file ime.c.

{
    IMEINFOEX info;
    size_t cch;

    TRACE("(%p,%p,%d)\n", hKL, lpszDescription, uBufLen);

    if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) || !IS_IME_HKL(hKL))
        return 0;

    StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription), &cch);
    cch = WideCharToMultiByte(CP_ACP, 0, info.wszImeDescription, (INT)cch,
                              lpszDescription, uBufLen, NULL, NULL);
    if (uBufLen)
        lpszDescription[cch] = 0;
    return (UINT)cch;
}

Referenced by ActiveIMMApp_GetDescriptionA(), and test_ImmGetDescription().

ImmGetDescriptionW()

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

Definition at line 848 of file ime.c.

{
    IMEINFOEX info;
    size_t cch;

    TRACE("(%p, %p, %d)\n", hKL, lpszDescription, uBufLen);

    if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) || !IS_IME_HKL(hKL))
        return 0;

    if (uBufLen != 0)
        StringCchCopyW(lpszDescription, uBufLen, info.wszImeDescription);

    StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription), &cch);
    return (UINT)cch;
}

Referenced by ActiveIMMApp_GetDescriptionW(), and test_ImmGetDescription().

ImmGetIMEFileNameA()

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

Definition at line 868 of file ime.c.

{
    BOOL bDefUsed;
    IMEINFOEX info;
    size_t cch;

    TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);

    if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) || !IS_IME_HKL(hKL))
    {
        if (uBufLen > 0)
            lpszFileName[0] = 0;
        return 0;
    }

    StringCchLengthW(info.wszImeFile, _countof(info.wszImeFile), &cch);

    cch = WideCharToMultiByte(CP_ACP, 0, info.wszImeFile, (INT)cch,
                              lpszFileName, uBufLen, NULL, &bDefUsed);
    if (uBufLen == 0)
        return (UINT)cch;

    if (cch > uBufLen - 1)
        cch = uBufLen - 1;

    lpszFileName[cch] = 0;
    return (UINT)cch;
}

Referenced by ActiveIMMApp_GetIMEFileNameA().

ImmGetIMEFileNameW()

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

Definition at line 900 of file ime.c.

{
    IMEINFOEX info;
    size_t cch;

    TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);

    if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) || !IS_IME_HKL(hKL))
    {
        if (uBufLen > 0)
            lpszFileName[0] = 0;
        return 0;
    }

    StringCchLengthW(info.wszImeFile, _countof(info.wszImeFile), &cch);
    if (uBufLen == 0)
        return (UINT)cch;

    StringCchCopyNW(lpszFileName, uBufLen, info.wszImeFile, cch);

    if (cch > uBufLen - 1)
        cch = uBufLen - 1;

    lpszFileName[cch] = 0;
    return (UINT)cch;
}

Referenced by ActiveIMMApp_GetIMEFileNameW().

ImmGetImeInfoEx()

BOOL WINAPI ImmGetImeInfoEx	(	PIMEINFOEX	pImeInfoEx,
		IMEINFOEXCLASS	SearchType,
		PVOID	pvSearchKey
	)

Definition at line 682 of file ime.c.

{
    BOOL bDisabled = FALSE;
    HKL hKL;

    /* FIXME: broken */
    switch (SearchType)
    {
        case ImeInfoExKeyboardLayout:
            break;

        case ImeInfoExImeWindow:
            bDisabled = CtfImmIsTextFrameServiceDisabled();
            SearchType = ImeInfoExKeyboardLayout;
            break;

        case ImeInfoExImeFileName:
            StringCchCopyW(pImeInfoEx->wszImeFile, _countof(pImeInfoEx->wszImeFile),
                           pvSearchKey);
            goto Quit;
    }

    hKL = *(HKL*)pvSearchKey;
    pImeInfoEx->hkl = hKL;

    if (!IS_IME_HKL(hKL))
    {
        if (Imm32IsCiceroMode())
        {
            if (Imm32Is16BitMode())
                return FALSE;
            if (!bDisabled)
                goto Quit;
        }
        return FALSE;
    }

Quit:
    return NtUserGetImeInfoEx(pImeInfoEx, SearchType);
}

Referenced by Ime32LoadImeDpi(), ImmGetDescriptionA(), ImmGetDescriptionW(), ImmGetIMEFileNameA(), ImmGetIMEFileNameW(), ImmGetProperty(), ImmInstallIMEW(), and ImmIsIME().

ImmGetImeMenuItemsA()

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

Definition at line 1792 of file ime.c.

{
    TRACE("(%p, 0x%lX, 0x%lX, %p, %p, 0x%lX)\n",
          hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize);
    return Imm32GetImeMenuItemsAW(hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu,
                                  dwSize, TRUE);
}

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 1806 of file ime.c.

{
    TRACE("(%p, 0x%lX, 0x%lX, %p, %p, 0x%lX)\n",
          hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize);
    return Imm32GetImeMenuItemsAW(hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu,
                                  dwSize, FALSE);
}

Referenced by ActiveIMMApp_GetImeMenuItemsW().

ImmGetOpenStatus()

BOOL WINAPI ImmGetOpenStatus

(

HIMC

hIMC

)

Definition at line 1141 of file ime.c.

{
    BOOL ret;
    LPINPUTCONTEXT pIC;

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

    if (!hIMC)
        return FALSE;

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

    ret = pIC->fOpen;

    ImmUnlockIMC(hIMC);
    return ret;
}

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

ImmGetProperty()

DWORD WINAPI ImmGetProperty	(	HKL	hKL,
		DWORD	fdwIndex
	)

Definition at line 930 of file ime.c.

{
    IMEINFOEX ImeInfoEx;
    LPIMEINFO pImeInfo;
    DWORD dwValue;
    PIMEDPI pImeDpi = NULL;

    TRACE("(%p, %lu)\n", hKL, fdwIndex);

    if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
        return FALSE;

    if (fdwIndex == IGP_GETIMEVERSION)
        return ImeInfoEx.dwImeWinVersion;

    if (ImeInfoEx.fLoadFlag != 2)
    {
        pImeDpi = ImmLockOrLoadImeDpi(hKL);
        if (pImeDpi == NULL)
            return FALSE;

        pImeInfo = &pImeDpi->ImeInfo;
    }
    else
    {
        pImeInfo = &ImeInfoEx.ImeInfo;
    }

    switch (fdwIndex)
    {
        case IGP_PROPERTY:      dwValue = pImeInfo->fdwProperty; break;
        case IGP_CONVERSION:    dwValue = pImeInfo->fdwConversionCaps; break;
        case IGP_SENTENCE:      dwValue = pImeInfo->fdwSentenceCaps; break;
        case IGP_UI:            dwValue = pImeInfo->fdwUICaps; break;
        case IGP_SETCOMPSTR:    dwValue = pImeInfo->fdwSCSCaps; break;
        case IGP_SELECT:        dwValue = pImeInfo->fdwSelectCaps; break;
        default:                dwValue = 0; break;
    }

    if (pImeDpi)
        ImmUnlockImeDpi(pImeDpi);
    return dwValue;
}

Referenced by ActiveIMMApp_GetProperty(), and test_ImmGetCompositionString().

ImmGetStatusWindowPos()

BOOL WINAPI ImmGetStatusWindowPos	(	HIMC	hIMC,
		LPPOINT	lpptPos
	)

Definition at line 1203 of file ime.c.

{
    LPINPUTCONTEXT pIC;
    BOOL ret;

    TRACE("(%p, %p)\n", hIMC, lpptPos);

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

    ret = !!(pIC->fdwInit & INIT_STATUSWNDPOS);
    if (ret)
        *lpptPos = pIC->ptStatusWndPos;

    ImmUnlockIMC(hIMC);
    return ret;
}

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

ImmInstallIMEA()

HKL WINAPI ImmInstallIMEA	(	LPCSTR	lpszIMEFileName,
		LPCSTR	lpszLayoutText
	)

Definition at line 501 of file ime.c.

{
    HKL hKL = NULL;
    LPWSTR pszFileNameW = NULL, pszLayoutTextW = NULL;

    TRACE("(%s, %s)\n", debugstr_a(lpszIMEFileName), debugstr_a(lpszLayoutText));

    pszFileNameW = Imm32WideFromAnsi(lpszIMEFileName);
    if (!pszFileNameW)
        goto Quit;

    pszLayoutTextW = Imm32WideFromAnsi(lpszLayoutText);
    if (!pszLayoutTextW)
        goto Quit;

    hKL = ImmInstallIMEW(pszFileNameW, pszLayoutTextW);

Quit:
    Imm32HeapFree(pszFileNameW);
    Imm32HeapFree(pszLayoutTextW);
    return hKL;
}

Referenced by ActiveIMMApp_InstallIMEA().

ImmInstallIMEW()

HKL WINAPI ImmInstallIMEW	(	LPCWSTR	lpszIMEFileName,
		LPCWSTR	lpszLayoutText
	)

Definition at line 527 of file ime.c.

{
    WCHAR szImeFileName[MAX_PATH], szImeDestPath[MAX_PATH], szImeKey[20];
    IMEINFOEX InfoEx;
    LPWSTR pchFilePart;
    UINT iLayout, cLayouts;
    HKL hNewKL;
    WORD wLangID;
    PREG_IME pLayouts = NULL;

    TRACE("(%s, %s)\n", debugstr_w(lpszIMEFileName), debugstr_w(lpszLayoutText));

    GetFullPathNameW(lpszIMEFileName, _countof(szImeFileName), szImeFileName, &pchFilePart);
    CharUpperW(szImeFileName);
    if (!pchFilePart)
        return NULL;

    /* Load the IME version info */
    InfoEx.hkl = hNewKL = NULL;
    StringCchCopyW(InfoEx.wszImeFile, _countof(InfoEx.wszImeFile), pchFilePart);
    if (Imm32LoadImeVerInfo(&InfoEx) && InfoEx.hkl)
        wLangID = LOWORD(InfoEx.hkl);
    else
        return NULL;

    /* Get the IME layouts from registry */
    cLayouts = Imm32GetRegImes(NULL, 0);
    if (cLayouts)
    {
        pLayouts = Imm32HeapAlloc(0, cLayouts * sizeof(REG_IME));
        if (!pLayouts || !Imm32GetRegImes(pLayouts, cLayouts))
        {
            Imm32HeapFree(pLayouts);
            return NULL;
        }

        for (iLayout = 0; iLayout < cLayouts; ++iLayout)
        {
            if (lstrcmpiW(pLayouts[iLayout].szFileName, pchFilePart) == 0)
            {
                if (wLangID != LOWORD(pLayouts[iLayout].hKL))
                    goto Quit; /* The language is different */

                hNewKL = pLayouts[iLayout].hKL; /* Found */
                break;
            }
        }
    }

    /* If the IME for the specified filename is valid, then unload it now */
    /* FIXME: ImmGetImeInfoEx is broken */
    if (ImmGetImeInfoEx(&InfoEx, 3, pchFilePart) &&
        !UnloadKeyboardLayout(InfoEx.hkl))
    {
        hNewKL = NULL;
        goto Quit;
    }

    Imm32GetSystemLibraryPath(szImeDestPath, _countof(szImeDestPath), pchFilePart);
    CharUpperW(szImeDestPath);

    /* If the source and the destination pathnames were different, then copy the IME file */
    if (lstrcmpiW(szImeFileName, szImeDestPath) != 0 &&
        !Imm32CopyFile(szImeFileName, szImeDestPath))
    {
        hNewKL = NULL;
        goto Quit;
    }

    if (hNewKL == NULL)
        hNewKL = Imm32GetNextHKL(cLayouts, pLayouts, wLangID);

    if (hNewKL)
    {
        /* Write the IME layout to registry */
        if (Imm32WriteRegIme(hNewKL, pchFilePart, lpszLayoutText))
        {
            /* Load the keyboard layout */
            Imm32UIntToStr((DWORD)(DWORD_PTR)hNewKL, 16, szImeKey, _countof(szImeKey));
            hNewKL = LoadKeyboardLayoutW(szImeKey, KLF_REPLACELANG);
        }
        else
        {
            hNewKL = NULL;
        }
    }

Quit:
    Imm32HeapFree(pLayouts);
    return hNewKL;
}

Referenced by ActiveIMMApp_InstallIMEW(), and ImmInstallIMEA().

ImmIsIME()

BOOL WINAPI ImmIsIME

(

HKL

hKL

)

Definition at line 622 of file ime.c.

{
    IMEINFOEX info;
    TRACE("(%p)\n", hKL);
    /* FIXME: ImmGetImeInfoEx is broken */
    return !!ImmGetImeInfoEx(&info, 1, &hKL);
}

Referenced by ActiveIMMApp_IsIME(), and Imm32JCloseOpen().

ImmLoadIME()

BOOL WINAPI ImmLoadIME

(

HKL

hKL

)

Definition at line 803 of file ime.c.

{
    PIMEDPI pImeDpi;

    if (!IS_IME_HKL(hKL) && (!Imm32IsCiceroMode() || Imm32Is16BitMode()))
        return FALSE;

    pImeDpi = Imm32FindImeDpi(hKL);
    if (pImeDpi == NULL)
        pImeDpi = Ime32LoadImeDpi(hKL, FALSE);
    return (pImeDpi != NULL);
}

Referenced by ImmActivateLayout().

ImmLockImeDpi()

PIMEDPI WINAPI ImmLockImeDpi

(

HKL

hKL

)

Definition at line 726 of file ime.c.

{
    PIMEDPI pImeDpi = NULL;

    TRACE("(%p)\n", hKL);

    RtlEnterCriticalSection(&g_csImeDpi);

    /* Find by hKL */
    for (pImeDpi = g_pImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
    {
        if (pImeDpi->hKL == hKL) /* found */
        {
            /* lock if possible */
            if (pImeDpi->dwFlags & IMEDPI_FLAG_UNKNOWN)
                pImeDpi = NULL;
            else
                ++(pImeDpi->cLockObj);
            break;
        }
    }

    RtlLeaveCriticalSection(&g_csImeDpi);
    return pImeDpi;
}

Referenced by Imm32CleanupContext(), Imm32GetImeMenuItemsAW(), Imm32InitContext(), Imm32NotifyAction(), Imm32ProcessHotKey(), Imm32SelectLayout(), Imm32SetCompositionStringAW(), ImmActivateLayout(), ImmLockOrLoadImeDpi(), ImmNotifyIME(), ImmProcessKey(), ImmSetActiveContext(), and ImmTranslateMessage().

ImmLockOrLoadImeDpi()

PIMEDPI APIENTRY ImmLockOrLoadImeDpi

(

HKL

hKL

)

Definition at line 281 of file ime.c.

{
    PIMEDPI pImeDpi;

    if (!IS_IME_HKL(hKL) && (!Imm32IsCiceroMode() || Imm32Is16BitMode()))
        return NULL;

    pImeDpi = ImmLockImeDpi(hKL);
    if (pImeDpi == NULL)
        pImeDpi = Ime32LoadImeDpi(hKL, TRUE);
    return pImeDpi;
}

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

ImmNotifyIME()

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

Definition at line 648 of file ime.c.

{
    HKL hKL;
    PIMEDPI pImeDpi;
    BOOL ret;

    TRACE("(%p, %lu, %lu, %lu)\n", hIMC, dwAction, dwIndex, dwValue);

    if (hIMC && Imm32IsCrossThreadAccess(hIMC))
        return FALSE;

    hKL = GetKeyboardLayout(0);
    pImeDpi = ImmLockImeDpi(hKL);
    if (pImeDpi == NULL)
        return FALSE;

    ret = pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue);
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ActiveIMMApp_NotifyIME(), Imm32NotifyCompStrProc(), ImmSystemHandler(), test_ImmGetCompositionString(), and test_ImmNotifyIME().

ImmSetCompositionFontA()

BOOL WINAPI ImmSetCompositionFontA	(	HIMC	hIMC,
		LPLOGFONTA	lplf
	)

Definition at line 1377 of file ime.c.

{
    LOGFONTW lfW;
    PCLIENTIMC pClientImc;
    BOOL bWide;
    LPINPUTCONTEXTDX pIC;
    LCID lcid;
    HWND hWnd;
    PTEB pTeb;

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

    if (Imm32IsCrossThreadAccess(hIMC))
        return FALSE;

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

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

    if (bWide)
    {
        LogFontAnsiToWide(lplf, &lfW);
        return ImmSetCompositionFontW(hIMC, &lfW);
    }

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

    pTeb = NtCurrentTeb();
    if (pTeb->Win32ClientInfo[2] < 0x400)
    {
        lcid = GetSystemDefaultLCID();
        if (PRIMARYLANGID(lcid) == LANG_JAPANESE && !(pIC->dwUIFlags & 2) &&
            pIC->cfCompForm.dwStyle != CFS_DEFAULT)
        {
            PostMessageA(pIC->hWnd, WM_IME_REPORT, IR_CHANGECONVERT, 0);
        }
    }

    pIC->lfFont.A = *lplf;
    pIC->fdwInit |= INIT_LOGFONT;
    hWnd = pIC->hWnd;

    ImmUnlockIMC(hIMC);

    Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0, IMC_SETCOMPOSITIONFONT,
                      IMN_SETCOMPOSITIONFONT, 0);
    return TRUE;
}

Referenced by ActiveIMMApp_SetCompositionFontA(), ImmSetCompositionFontW(), test_ImmThreads(), and test_InvalidIMC().

ImmSetCompositionFontW()

BOOL WINAPI ImmSetCompositionFontW	(	HIMC	hIMC,
		LPLOGFONTW	lplf
	)

Definition at line 1434 of file ime.c.

{
    LOGFONTA lfA;
    PCLIENTIMC pClientImc;
    BOOL bWide;
    HWND hWnd;
    LPINPUTCONTEXTDX pIC;
    PTEB pTeb;
    LCID lcid;

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

    if (Imm32IsCrossThreadAccess(hIMC))
        return FALSE;

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

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

    if (!bWide)
    {
        LogFontWideToAnsi(lplf, &lfA);
        return ImmSetCompositionFontA(hIMC, &lfA);
    }

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

    pTeb = NtCurrentTeb();
    if (pTeb->Win32ClientInfo[2] < 0x400)
    {
        lcid = GetSystemDefaultLCID();
        if (PRIMARYLANGID(lcid) == LANG_JAPANESE &&
            !(pIC->dwUIFlags & 2) &&
            pIC->cfCompForm.dwStyle != CFS_DEFAULT)
        {
            PostMessageW(pIC->hWnd, WM_IME_REPORT, IR_CHANGECONVERT, 0);
        }
    }

    pIC->lfFont.W = *lplf;
    pIC->fdwInit |= INIT_LOGFONT;
    hWnd = pIC->hWnd;

    ImmUnlockIMC(hIMC);

    Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0, IMC_SETCOMPOSITIONFONT,
                      IMN_SETCOMPOSITIONFONT, 0);
    return TRUE;
}

Referenced by ActiveIMMApp_SetCompositionFontW(), and ImmSetCompositionFontA().

ImmSetCompositionWindow()

BOOL WINAPI ImmSetCompositionWindow	(	HIMC	hIMC,
		LPCOMPOSITIONFORM	lpCompForm
	)

Definition at line 1277 of file ime.c.

{
    LPINPUTCONTEXT pIC;
    HWND hWnd;

    if (Imm32IsCrossThreadAccess(hIMC))
        return FALSE;

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

    pIC->cfCompForm = *lpCompForm;
    pIC->fdwInit |= INIT_COMPFORM;

    hWnd = pIC->hWnd;

    ImmUnlockIMC(hIMC);

    Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
                      IMC_SETCOMPOSITIONWINDOW, IMN_SETCOMPOSITIONWINDOW, 0);
    return TRUE;
}

Referenced by ActiveIMMApp_SetCompositionWindow(), ImmGetContextThreadFunc(), test_ImmThreads(), and test_InvalidIMC().

ImmSetConversionStatus()

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

Definition at line 1624 of file ime.c.

{
    HKL hKL;
    LPINPUTCONTEXT pIC;
    DWORD dwOldConversion, dwOldSentence;
    BOOL fOpen = FALSE, fConversionChange = FALSE, fSentenceChange = FALSE, fUseCicero = FALSE;
    HWND hWnd;

    TRACE("(%p, 0x%lX, 0x%lX)\n", hIMC, fdwConversion, fdwSentence);

    hKL = GetKeyboardLayout(0);
    if (!IS_IME_HKL(hKL) && Imm32IsCiceroMode() && !Imm32Is16BitMode())
        fUseCicero = TRUE;

    if (Imm32IsCrossThreadAccess(hIMC))
        return FALSE;

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

    if (pIC->fdwConversion != fdwConversion)
    {
        dwOldConversion = pIC->fdwConversion;
        pIC->fdwConversion = fdwConversion;
        fConversionChange = TRUE;
    }

    if (pIC->fdwSentence != fdwSentence)
    {
        dwOldSentence = pIC->fdwSentence;
        pIC->fdwSentence = fdwSentence;
        fSentenceChange = TRUE;
    }

    hWnd = pIC->hWnd;
    fOpen = pIC->fOpen;
    ImmUnlockIMC(hIMC);

    if (fConversionChange || fUseCicero)
    {
        Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldConversion,
                          IMC_SETCONVERSIONMODE, IMN_SETCONVERSIONMODE, 0);
        if (fConversionChange)
            NtUserNotifyIMEStatus(hWnd, fOpen, fdwConversion);
    }

    if (fSentenceChange || fUseCicero)
    {
        Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldSentence,
                          IMC_SETSENTENCEMODE, IMN_SETSENTENCEMODE, 0);
    }

    return TRUE;
}

Referenced by ActiveIMMApp_SetConversionStatus(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32KEnglish(), Imm32KHanjaConvert(), Imm32KShapeToggle(), test_ImmThreads(), and test_InvalidIMC().

ImmSetOpenStatus()

BOOL WINAPI ImmSetOpenStatus	(	HIMC	hIMC,
		BOOL	fOpen
	)

Definition at line 1164 of file ime.c.

{
    DWORD dwConversion;
    LPINPUTCONTEXT pIC;
    HWND hWnd;
    BOOL bHasChange = FALSE;

    TRACE("(%p, %d)\n", hIMC, fOpen);

    if (Imm32IsCrossThreadAccess(hIMC))
        return FALSE;

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

    if (pIC->fOpen != fOpen)
    {
        pIC->fOpen = fOpen;
        hWnd = pIC->hWnd;
        dwConversion = pIC->fdwConversion;
        bHasChange = TRUE;
    }

    ImmUnlockIMC(hIMC);

    if (bHasChange)
    {
        Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
                          IMC_SETOPENSTATUS, IMN_SETOPENSTATUS, 0);
        NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
    }

    return TRUE;
}

Referenced by ActiveIMMApp_SetOpenStatus(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32ImeNonImeToggle(), Imm32JCloseOpen(), Imm32KEnglish(), Imm32KShapeToggle(), ImmGetContextThreadFunc(), START_TEST(), test_ime_processkey(), test_ImmDefaultHwnd(), test_ImmMessages(), test_ImmThreads(), and test_InvalidIMC().

ImmSetStatusWindowPos()

BOOL WINAPI ImmSetStatusWindowPos	(	HIMC	hIMC,
		LPPOINT	lpptPos
	)

Definition at line 1225 of file ime.c.

{
    LPINPUTCONTEXT pIC;
    HWND hWnd;

    TRACE("(%p, {%ld, %ld})\n", hIMC, lpptPos->x, lpptPos->y);

    if (Imm32IsCrossThreadAccess(hIMC))
        return FALSE;

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

    hWnd = pIC->hWnd;
    pIC->ptStatusWndPos = *lpptPos;
    pIC->fdwInit |= INIT_STATUSWNDPOS;

    ImmUnlockIMC(hIMC);

    Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
                      IMC_SETSTATUSWINDOWPOS, IMN_SETSTATUSWINDOWPOS, 0);
    return TRUE;
}

Referenced by ActiveIMMApp_SetStatusWindowPos(), ImmGetContextThreadFunc(), test_ImmThreads(), and test_InvalidIMC().

ImmUnlockImeDpi()

VOID WINAPI ImmUnlockImeDpi

(

PIMEDPI

pImeDpi

)

Definition at line 755 of file ime.c.

{
    PIMEDPI *ppEntry;

    TRACE("(%p)\n", pImeDpi);

    if (pImeDpi == NULL)
        return;

    RtlEnterCriticalSection(&g_csImeDpi);

    /* unlock */
    --(pImeDpi->cLockObj);
    if (pImeDpi->cLockObj != 0)
    {
        RtlLeaveCriticalSection(&g_csImeDpi);
        return;
    }

    if ((pImeDpi->dwFlags & IMEDPI_FLAG_UNKNOWN) == 0)
    {
        if ((pImeDpi->dwFlags & IMEDPI_FLAG_LOCKED) == 0 ||
            (pImeDpi->ImeInfo.fdwProperty & IME_PROP_END_UNLOAD) == 0)
        {
            RtlLeaveCriticalSection(&g_csImeDpi);
            return;
        }
    }

    /* Remove from list */
    for (ppEntry = &g_pImeDpiList; *ppEntry; ppEntry = &((*ppEntry)->pNext))
    {
        if (*ppEntry == pImeDpi) /* found */
        {
            *ppEntry = pImeDpi->pNext;
            break;
        }
    }

    Imm32FreeImeDpi(pImeDpi, TRUE);
    Imm32HeapFree(pImeDpi);

    RtlLeaveCriticalSection(&g_csImeDpi);
}

Referenced by Imm32CleanupContext(), Imm32GetImeMenuItemsAW(), Imm32InitContext(), Imm32NotifyAction(), Imm32ProcessHotKey(), Imm32SelectLayout(), Imm32SetCompositionStringAW(), ImmActivateLayout(), ImmConfigureIMEA(), ImmConfigureIMEW(), ImmEnumRegisterWordA(), ImmEnumRegisterWordW(), ImmEscapeA(), ImmEscapeW(), ImmGetConversionListA(), ImmGetConversionListW(), ImmGetProperty(), ImmGetRegisterWordStyleA(), ImmGetRegisterWordStyleW(), ImmNotifyIME(), ImmProcessKey(), ImmRegisterWordA(), ImmRegisterWordW(), ImmSetActiveContext(), ImmTranslateMessage(), ImmUnregisterWordA(), and ImmUnregisterWordW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)

Variable Documentation

g_csImeDpi

RTL_CRITICAL_SECTION g_csImeDpi

Definition at line 17 of file ime.c.

Referenced by DllMain(), Ime32LoadImeDpi(), Imm32FindImeDpi(), Imm32InitInstance(), Imm32ReleaseIME(), ImmFreeLayout(), ImmLockImeDpi(), and ImmUnlockImeDpi().

g_pImeDpiList

PIMEDPI g_pImeDpiList = NULL

Definition at line 18 of file ime.c.

Referenced by Ime32LoadImeDpi(), Imm32FindImeDpi(), Imm32ReleaseIME(), ImmFreeLayout(), ImmLockImeDpi(), and ImmUnlockImeDpi().