ime.c File Reference

#include "precomp.h"
#include <imetable.h>

Include dependency graph for ime.c:

Go to the source code of this file.

Classes
struct	tagIMEMENUITEM
struct	tagIMEMENU

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)
#define	DEFINE_IME_ENTRY(type, name, params, optional)   pImeDpi->name = Stub##name;
#define	DEFINE_IME_ENTRY(type, name, params, optional)
#define	MAX_IMEMENU_BITMAP_BYTES   0xF00

Typedefs
typedef struct tagIMEMENUITEM	IMEMENUITEM
typedef struct tagIMEMENUITEM *	PIMEMENUITEM
typedef struct tagIMEMENU	IMEMENU
typedef struct tagIMEMENU *	PIMEMENU

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
PIMEDPI APIENTRY	Imm32FindImeDpi (HKL hKL)
VOID APIENTRY	Imm32FreeIME (PIMEDPI pImeDpi, BOOL bDestroy)
BOOL APIENTRY	Imm32InquireIme (PIMEDPI pImeDpi)
BOOL APIENTRY	Imm32LoadIME (PIMEINFOEX pImeInfoEx, PIMEDPI pImeDpi)
PIMEDPI APIENTRY	Imm32LoadImeDpi (HKL hKL, BOOL bLock)
PIMEDPI APIENTRY	Imm32FindOrLoadImeDpi (HKL hKL)
static LRESULT APIENTRY	ImeDpi_Escape (PIMEDPI pImeDpi, HIMC hIMC, UINT uSubFunc, LPVOID lpData, HKL hKL)
BOOL APIENTRY	Imm32ReleaseIME (HKL hKL)
LRESULT WINAPI	ImmPutImeMenuItemsIntoMappedFile (HIMC hIMC)
DWORD APIENTRY	Imm32GetImeMenuItemWInterProcess (HIMC hIMC, DWORD dwFlags, DWORD dwType, LPVOID lpImeParentMenu, LPVOID lpImeMenu, DWORD dwSize)
DWORD APIENTRY	ImmGetImeMenuItemsAW (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_PTR dwValue)
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)
BOOL WINAPI	ImmWINNLSEnableIME (HWND hWnd, BOOL enable)

Variables
RTL_CRITICAL_SECTION	gcsImeDpi
PIMEDPI	gpImeDpiList = NULL

Macro Definition Documentation

DEFINE_IME_ENTRY [1/3]

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

Value:

    type APIENTRY Stub##name params { \
        FIXME("%s: Why stub called?\n", #name); \
        return (type)0; \
    }

Definition at line 189 of file ime.c.

DEFINE_IME_ENTRY [2/3]

#define DEFINE_IME_ENTRY	(		type,
			name,
			params,
			optional
	)		pImeDpi->name = Stub##name;

Definition at line 189 of file ime.c.

DEFINE_IME_ENTRY [3/3]

#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 IME module '%S'.\n", #name, szPath); \
            goto Failed; \
        } \
    } while (0);

Definition at line 189 of file ime.c.

MAX_IMEMENU_BITMAP_BYTES

#define MAX_IMEMENU_BITMAP_BYTES   0xF00

Definition at line 421 of file ime.c.

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)

Typedef Documentation

IMEMENU

typedef struct tagIMEMENU IMEMENU

IMEMENUITEM

typedef struct tagIMEMENUITEM IMEMENUITEM

PIMEMENU

typedef struct tagIMEMENU * PIMEMENU

PIMEMENUITEM

typedef struct tagIMEMENUITEM * PIMEMENUITEM

Function Documentation

ImeDpi_Escape()

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

static

Definition at line 360 of file ime.c.

{
    if (IS_IME_HKL(hKL))
        return pImeDpi->ImeEscape(hIMC, uSubFunc, lpData);
    if (IS_CICERO_MODE() && !IS_16BIT_MODE())
        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(&gcsImeDpi);
    for (pImeDpi = gpImeDpiList; pImeDpi != NULL; pImeDpi = pImeDpi->pNext)
    {
        if (pImeDpi->hKL == hKL)
            break;
    }
    RtlLeaveCriticalSection(&gcsImeDpi);
 
    return pImeDpi;
}

Referenced by Imm32LoadImeDpi(), and ImmLoadIME().

Imm32FindOrLoadImeDpi()

PIMEDPI APIENTRY Imm32FindOrLoadImeDpi

(

HKL

hKL

)

Definition at line 343 of file ime.c.

{
    PIMEDPI pImeDpi;
 
    if (!IS_IME_HKL(hKL) && (!IS_CICERO_MODE() || IS_16BIT_MODE()))
    {
        TRACE("\n");
        return NULL;
    }
 
    pImeDpi = ImmLockImeDpi(hKL);
    if (pImeDpi == NULL)
        pImeDpi = Imm32LoadImeDpi(hKL, TRUE);
    return pImeDpi;
}

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

Imm32FreeIME()

VOID APIENTRY Imm32FreeIME	(	PIMEDPI	pImeDpi,
		BOOL	bDestroy
	)

Definition at line 36 of file ime.c.

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

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

Imm32GetImeMenuItemWInterProcess()

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

Definition at line 525 of file ime.c.

{
    HANDLE hMapping;
    PIMEMENU pView;
    DWORD i, cbView, dwItemCount, ret = 0;
    HWND hImeWnd;
    PIMEMENUITEM pGotItem;
    LPIMEMENUITEMINFOW pSetInfo;
 
    hImeWnd = (HWND)NtUserQueryInputContext(hIMC, QIC_DEFAULTWINDOWIME);
    if (!hImeWnd || !IsWindow(hImeWnd))
    {
        ERR("\n");
        return 0;
    }
 
    dwItemCount = (lpImeMenu ? (dwSize / sizeof(IMEMENUITEMINFOW)) : 0);
    cbView = sizeof(IMEMENU) + ((size_t)dwItemCount - 1) * sizeof(IMEMENUITEM);
 
    RtlEnterCriticalSection(&gcsImeDpi);
 
    // create a file mapping
    hMapping = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
                                  0, cbView, L"ImmMenuInfo");
    pView = MapViewOfFile(hMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
    if (IS_NULL_UNEXPECTEDLY(pView))
        goto Quit;
 
    ZeroMemory(pView, cbView);
    pView->dwVersion = 1;
    pView->dwFlags = dwFlags;
    pView->dwType = dwType;
    pView->dwItemCount = dwItemCount;
    if (lpImeParentMenu)
    {
        pView->Parent = *(LPIMEMENUITEMINFOW)lpImeParentMenu;
        pView->Parent.cbSize = sizeof(IMEMENUITEMINFOW);
    }
 
    if (!SendMessageW(hImeWnd, WM_IME_SYSTEM, IMS_GETIMEMENU, (LPARAM)hIMC))
    {
        ERR("\n");
        goto Quit;
    }
 
    ret = pView->dwItemCount;
 
    if (!lpImeMenu)
        goto Quit;
 
    for (i = 0; i < ret; ++i)
    {
        pGotItem = &(pView->Items[i]);
        pSetInfo = &((LPIMEMENUITEMINFOW)lpImeMenu)[i];
 
        *pSetInfo = pGotItem->Info;
 
        // load bitmaps from bytes
        if (pSetInfo->hbmpChecked)
        {
            pSetInfo->hbmpChecked = Imm32LoadBitmapFromBytes(pGotItem->abChecked);
        }
        if (pSetInfo->hbmpUnchecked)
        {
            pSetInfo->hbmpUnchecked = Imm32LoadBitmapFromBytes(pGotItem->abUnchecked);
        }
        if (pSetInfo->hbmpItem)
        {
            pSetInfo->hbmpItem = Imm32LoadBitmapFromBytes(pGotItem->abItem);
        }
    }
 
Quit:
    RtlLeaveCriticalSection(&gcsImeDpi);
    if (pView)
        UnmapViewOfFile(pView);
    if (hMapping)
        CloseHandle(hMapping);
    return ret;
}

Referenced by ImmGetImeMenuItemsAW().

Imm32InquireIme()

BOOL APIENTRY Imm32InquireIme

(

PIMEDPI

pImeDpi

)

Definition at line 47 of file ime.c.

{
    WCHAR szUIClass[64];
    WNDCLASSW wcW;
    DWORD dwSysInfoFlags = 0;
    LPIMEINFO pImeInfo = &pImeDpi->ImeInfo;
 
    if (NtUserGetThreadState(THREADSTATE_ISWINLOGON))
        dwSysInfoFlags |= IME_SYSINFO_WINLOGON;
 
    if (GetWin32ClientInfo()->dwTIFlags & TIF_16BIT)
        dwSysInfoFlags |= IME_SYSINFO_WOW16;
 
    if (IS_IME_HKL(pImeDpi->hKL))
    {
        if (!pImeDpi->ImeInquire(pImeInfo, szUIClass, dwSysInfoFlags))
        {
            ERR("\n");
            return FALSE;
        }
    }
    else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
    {
        if (pImeDpi->CtfImeInquireExW(pImeInfo, szUIClass, dwSysInfoFlags, pImeDpi->hKL) != S_OK)
        {
            ERR("\n");
            return FALSE;
        }
    }
    else
    {
        ERR("\n");
        return FALSE;
    }
 
    szUIClass[_countof(szUIClass) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
 
    if (pImeInfo->dwPrivateDataSize < sizeof(DWORD))
        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)
    {
        ERR("Bad flags\n");
        return FALSE;
    }
    if (pImeInfo->fdwConversionCaps & ~VALID_CMODE_CAPS)
    {
        ERR("Bad flags\n");
        return FALSE;
    }
    if (pImeInfo->fdwSentenceCaps & ~VALID_SMODE_CAPS)
    {
        ERR("Bad flags\n");
        return FALSE;
    }
    if (pImeInfo->fdwUICaps & ~VALID_UI_CAPS)
    {
        ERR("Bad flags\n");
        return FALSE;
    }
    if (pImeInfo->fdwSCSCaps & ~VALID_SCS_CAPS)
    {
        ERR("Bad flags\n");
        return FALSE;
    }
    if (pImeInfo->fdwSelectCaps & ~VALID_SELECT_CAPS)
    {
        ERR("Bad flags\n");
        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 != CP_ACP)
            return FALSE;
 
        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPSTR)szUIClass, -1,
                            pImeDpi->szUIClass, _countof(pImeDpi->szUIClass));
 
        pImeDpi->szUIClass[_countof(pImeDpi->szUIClass) - 1] = UNICODE_NULL;
    }
 
    if (!GetClassInfoW(pImeDpi->hInst, pImeDpi->szUIClass, &wcW))
    {
        ERR("\n");
        return FALSE;
    }
 
    return TRUE;
}

Referenced by Imm32LoadIME().

Imm32LoadIME()

BOOL APIENTRY Imm32LoadIME	(	PIMEINFOEX	pImeInfoEx,
		PIMEDPI	pImeDpi
	)

Definition at line 198 of file ime.c.

{
    WCHAR szPath[MAX_PATH];
    HINSTANCE hIME;
    FARPROC fn;
    BOOL ret = FALSE;
 
    if (!Imm32GetSystemLibraryPath(szPath, _countof(szPath), pImeInfoEx->wszImeFile))
        return FALSE;
 
    pImeDpi->hInst = hIME = LoadLibraryW(szPath);
    if (hIME == NULL)
    {
        ERR("LoadLibraryW(%S) failed\n", szPath);
        return FALSE;
    }
 
    /* Populate the table by stub IME functions */
#define DEFINE_IME_ENTRY(type, name, params, optional) pImeDpi->name = Stub##name;
#include <imetable.h>
#undef DEFINE_IME_ENTRY
 
    /* Populate the table by real IME functions */
#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 IME module '%S'.\n", #name, szPath); \
            goto Failed; \
        } \
    } while (0);
#include <imetable.h>
#undef DEFINE_IME_ENTRY
 
    if (Imm32InquireIme(pImeDpi))
    {
        ret = TRUE;
    }
    else
    {
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 Imm32LoadImeDpi().

Imm32LoadImeDpi()

PIMEDPI APIENTRY Imm32LoadImeDpi	(	HKL	hKL,
		BOOL	bLock
	)

Definition at line 267 of file ime.c.

{
    IMEINFOEX ImeInfoEx;
    CHARSETINFO ci;
    PIMEDPI pImeDpiNew, pImeDpiFound;
    UINT uCodePage;
    LCID lcid;
 
    if (!IS_IME_HKL(hKL))
    {
        TRACE("\n");
        return NULL;
    }
 
    if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
    {
        ERR("\n");
        return NULL;
    }
 
    if (ImeInfoEx.fLoadFlag == 1)
    {
        ERR("\n");
        return NULL;
    }
 
    pImeDpiNew = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(IMEDPI));
    if (IS_NULL_UNEXPECTEDLY(pImeDpiNew))
        return NULL;
 
    pImeDpiNew->hKL = hKL;
 
    lcid = LOWORD(hKL);
    if (TranslateCharsetInfo(UlongToPtr(lcid), &ci, TCI_SRCLOCALE))
        uCodePage = ci.ciACP;
    else
        uCodePage = CP_ACP;
    pImeDpiNew->uCodePage = uCodePage;
 
    if (!Imm32LoadIME(&ImeInfoEx, pImeDpiNew))
    {
        ERR("\n");
        ImmLocalFree(pImeDpiNew);
        return FALSE;
    }
 
    RtlEnterCriticalSection(&gcsImeDpi);
 
    pImeDpiFound = Imm32FindImeDpi(hKL);
    if (pImeDpiFound)
    {
        if (!bLock)
            pImeDpiFound->dwFlags &= ~IMEDPI_FLAG_LOCKED;
 
        RtlLeaveCriticalSection(&gcsImeDpi);
        Imm32FreeIME(pImeDpiNew, FALSE);
        ImmLocalFree(pImeDpiNew);
        return pImeDpiFound;
    }
    else
    {
        if (bLock)
        {
            pImeDpiNew->dwFlags |= IMEDPI_FLAG_LOCKED;
            pImeDpiNew->cLockObj = 1;
        }
 
        pImeDpiNew->pNext = gpImeDpiList;
        gpImeDpiList = pImeDpiNew;
 
        RtlLeaveCriticalSection(&gcsImeDpi);
        return pImeDpiNew;
    }
}

Referenced by Imm32FindOrLoadImeDpi(), and ImmLoadIME().

Imm32ReleaseIME()

BOOL APIENTRY Imm32ReleaseIME

(

HKL

hKL

)

Definition at line 371 of file ime.c.

{
    BOOL ret = TRUE;
    PIMEDPI pImeDpi0, pImeDpi1;
 
    RtlEnterCriticalSection(&gcsImeDpi);
 
    for (pImeDpi0 = gpImeDpiList; pImeDpi0; pImeDpi0 = pImeDpi0->pNext)
    {
        if (pImeDpi0->hKL == hKL)
            break;
    }
 
    if (!pImeDpi0)
        goto Quit;
 
    if (pImeDpi0->cLockObj)
    {
        pImeDpi0->dwFlags |= IMEDPI_FLAG_UNLOADED;
        ret = FALSE;
        goto Quit;
    }
 
    if (gpImeDpiList == pImeDpi0)
    {
        gpImeDpiList = pImeDpi0->pNext;
    }
    else if (gpImeDpiList)
    {
        for (pImeDpi1 = gpImeDpiList; pImeDpi1; pImeDpi1 = pImeDpi1->pNext)
        {
            if (pImeDpi1->pNext == pImeDpi0)
            {
                pImeDpi1->pNext = pImeDpi0->pNext;
                break;
            }
        }
    }
 
    Imm32FreeIME(pImeDpi0, TRUE);
    ImmLocalFree(pImeDpi0);
 
Quit:
    RtlLeaveCriticalSection(&gcsImeDpi);
    return ret;
}

Referenced by ImmFreeLayout().

ImmConfigureIMEA()

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

Definition at line 1998 of file ime.c.

{
    BOOL ret = FALSE;
    PIMEDPI pImeDpi;
    REGISTERWORDW RegWordW;
    LPREGISTERWORDA pRegWordA;
 
    TRACE("(%p, %p, 0x%lX, %p)\n", hKL, hWnd, dwMode, lpData);
 
    if (IS_NULL_UNEXPECTEDLY(ValidateHwnd(hWnd)) || IS_CROSS_PROCESS_HWND(hWnd))
        return FALSE;
 
    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return FALSE;
 
    RtlZeroMemory(&RegWordW, sizeof(RegWordW));
 
    if (!ImeDpi_IsUnicode(pImeDpi) || !lpData || dwMode != IME_CONFIG_REGISTERWORD)
        goto DoIt; /* No conversion needed */
 
    pRegWordA = lpData;
 
    if (pRegWordA->lpReading)
    {
        RegWordW.lpReading = Imm32WideFromAnsi(pImeDpi->uCodePage, pRegWordA->lpReading);
        if (IS_NULL_UNEXPECTEDLY(RegWordW.lpReading))
            goto Quit;
    }
 
    if (pRegWordA->lpWord)
    {
        RegWordW.lpWord = Imm32WideFromAnsi(pImeDpi->uCodePage, pRegWordA->lpWord);
        if (IS_NULL_UNEXPECTEDLY(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:
    ImmLocalFree(RegWordW.lpReading);
    ImmLocalFree(RegWordW.lpWord);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %d\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_ConfigureIMEA(), and test_ImmIME().

ImmConfigureIMEW()

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

Definition at line 2053 of file ime.c.

{
    BOOL ret = FALSE;
    PIMEDPI pImeDpi;
    REGISTERWORDA RegWordA;
    LPREGISTERWORDW pRegWordW;
 
    TRACE("(%p, %p, 0x%lX, %p)\n", hKL, hWnd, dwMode, lpData);
 
    if (IS_NULL_UNEXPECTEDLY(ValidateHwnd(hWnd)) || IS_CROSS_PROCESS_HWND(hWnd))
        return FALSE;
 
    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return FALSE;
 
    RtlZeroMemory(&RegWordA, sizeof(RegWordA));
 
    if (ImeDpi_IsUnicode(pImeDpi) || !lpData || dwMode != IME_CONFIG_REGISTERWORD)
        goto DoIt; /* No conversion needed */
 
    pRegWordW = lpData;
 
    if (pRegWordW->lpReading)
    {
        RegWordA.lpReading = Imm32AnsiFromWide(pImeDpi->uCodePage, pRegWordW->lpReading);
        if (IS_NULL_UNEXPECTEDLY(RegWordA.lpReading))
            goto Quit;
    }
 
    if (pRegWordW->lpWord)
    {
        RegWordA.lpWord = Imm32AnsiFromWide(pImeDpi->uCodePage, pRegWordW->lpWord);
        if (IS_NULL_UNEXPECTEDLY(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:
    ImmLocalFree(RegWordA.lpReading);
    ImmLocalFree(RegWordA.lpWord);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %d\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_ConfigureIMEW(), ImeWnd_OnImeSystem(), and test_ImmIME().

ImmDisableIME()

BOOL WINAPI ImmDisableIME

(

DWORD

dwThreadId

)

Definition at line 1074 of file ime.c.

{
    return NtUserDisableThreadIme(dwThreadId);
}

Referenced by ActiveIMMApp_DisableIME(), and test_default_ime_disabled_cb().

ImmEscapeA()

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

Definition at line 1277 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 = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;
 
    if (!ImeDpi_IsUnicode(pImeDpi) || !lpData) /* No conversion needed */
    {
        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] = UNICODE_NULL; /* Avoid buffer overrun */
                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] = UNICODE_NULL; /* Avoid buffer overrun */
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szW, hKL);
            break;
 
        default:
            ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
            break;
    }
 
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %p\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_EscapeA().

ImmEscapeW()

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

Definition at line 1365 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 = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;
 
    if (ImeDpi_IsUnicode(pImeDpi) || !lpData) /* No conversion needed */
    {
        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] = UNICODE_NULL; /* Avoid buffer overrun */
            }
            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);
    TRACE("ret: %p\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_EscapeW(), and User32DoImeHelp().

ImmGetCompositionFontA()

BOOL WINAPI ImmGetCompositionFontA	(	HIMC	hIMC,
		LPLOGFONTA	lplf
	)

Definition at line 1615 of file ime.c.

{
    PCLIENTIMC pClientImc;
    BOOL ret = FALSE, bWide;
    LPINPUTCONTEXT pIC;
 
    TRACE("(%p, %p)\n", hIMC, lplf);
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return FALSE;
 
    bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        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(), ImeWnd_OnImeControl(), test_ImmThreads(), and test_InvalidIMC().

ImmGetCompositionFontW()

BOOL WINAPI ImmGetCompositionFontW	(	HIMC	hIMC,
		LPLOGFONTW	lplf
	)

Definition at line 1651 of file ime.c.

{
    PCLIENTIMC pClientImc;
    BOOL bWide;
    LPINPUTCONTEXT pIC;
    BOOL ret = FALSE;
 
    TRACE("(%p, %p)\n", hIMC, lplf);
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return FALSE;
 
    bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        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(), and ImeWnd_OnImeControl().

ImmGetCompositionWindow()

BOOL WINAPI ImmGetCompositionWindow	(	HIMC	hIMC,
		LPCOMPOSITIONFORM	lpCompForm
	)

Definition at line 1559 of file ime.c.

{
    LPINPUTCONTEXT pIC;
    BOOL ret = FALSE;
 
    TRACE("(%p, %p)\n", hIMC, lpCompForm);
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    if (pIC->fdwInit & INIT_COMPFORM)
    {
        *lpCompForm = pIC->cfCompForm;
        ret = TRUE;
    }
 
    ImmUnlockIMC(hIMC);
    return ret;
}

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

ImmGetConversionListA()

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

Definition at line 1801 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, pSrc, lpDst, dwBufLen, uFlag);
 
    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;
 
    if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }
 
    if (pSrc)
    {
        pszSrcW = Imm32WideFromAnsi(pImeDpi->uCodePage, pSrc);
        if (IS_NULL_UNEXPECTEDLY(pszSrcW))
            goto Quit;
    }
 
    cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, NULL, 0, uFlag);
    if (IS_ZERO_UNEXPECTEDLY(cb))
        goto Quit;
 
    pCL = ImmLocalAlloc(0, cb);
    if (IS_NULL_UNEXPECTEDLY(pCL))
        goto Quit;
 
    cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, pCL, cb, uFlag);
    if (IS_ZERO_UNEXPECTEDLY(cb))
        goto Quit;
 
    ret = CandidateListWideToAnsi(pCL, lpDst, dwBufLen, pImeDpi->uCodePage);
 
Quit:
    ImmLocalFree(pszSrcW);
    ImmLocalFree(pCL);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: 0x%X\n", ret);
    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 1856 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, pSrc, lpDst, dwBufLen, uFlag);
 
    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;
 
    if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }
 
    if (pSrc)
    {
        pszSrcA = Imm32AnsiFromWide(pImeDpi->uCodePage, pSrc);
        if (IS_NULL_UNEXPECTEDLY(pszSrcA))
            goto Quit;
    }
 
    cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, NULL, 0, uFlag);
    if (IS_ZERO_UNEXPECTEDLY(cb))
        goto Quit;
 
    pCL = ImmLocalAlloc(0, cb);
    if (IS_NULL_UNEXPECTEDLY(pCL))
        goto Quit;
 
    cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, pCL, cb, uFlag);
    if (IS_ZERO_UNEXPECTEDLY(cb))
        goto Quit;
 
    ret = CandidateListAnsiToWide(pCL, lpDst, dwBufLen, pImeDpi->uCodePage);
 
Quit:
    ImmLocalFree(pszSrcA);
    ImmLocalFree(pCL);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: 0x%X\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_GetConversionListW().

ImmGetConversionStatus()

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

Definition at line 1910 of file ime.c.

{
    LPINPUTCONTEXT pIC;
 
    TRACE("(%p %p %p)\n", hIMC, lpfdwConversion, lpfdwSentence);
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    if (lpfdwConversion)
    {
        *lpfdwConversion = pIC->fdwConversion;
        TRACE("0x%X\n", *lpfdwConversion);
    }
 
    if (lpfdwSentence)
    {
        *lpfdwSentence = pIC->fdwSentence;
        TRACE("0x%X\n", *lpfdwSentence);
    }
 
    ImmUnlockIMC(hIMC);
    return TRUE;
}

Referenced by ActiveIMMApp_GetConversionStatus(), ImeWnd_OnImeControl(), ImeWnd_OnImeSystem(), OnTimer(), and test_ImmThreads().

ImmGetDefaultIMEWnd()

HWND WINAPI ImmGetDefaultIMEWnd

(

HWND

hWnd

)

Definition at line 890 of file ime.c.

{
    if (!IS_IMM_MODE())
    {
        TRACE("\n");
        return NULL;
    }
 
    if (hWnd == NULL)
        return (HWND)NtUserGetThreadState(THREADSTATE_DEFAULTIMEWINDOW);
 
    return (HWND)NtUserQueryWindow(hWnd, QUERY_WINDOW_DEFAULT_IME);
}

Referenced by ActiveIMMApp_GetDefaultIMEWnd(), DoTest_BUTTON(), DoTest_EDIT(), GetTargetWindow(), CIMEUIWindowHandler::ImeUINotifyHandler(), Imm32DelaySetLangBandProc(), ImmActivateLayout(), ImmSetActiveContext(), ImmWINNLSEnableIME(), InnerWindowProc(), RealDefWindowProcA(), RealDefWindowProcW(), UIComposition::SendMessageToUI(), CTipbarWnd::SetLangBand(), 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 1082 of file ime.c.

{
    IMEINFOEX info;
    size_t cch;
 
    TRACE("(%p,%p,%d)\n", hKL, lpszDescription, uBufLen);
 
    if (!IS_IME_HKL(hKL))
    {
        TRACE("\n");
        return 0;
    }
 
    if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL))
    {
        ERR("\n");
        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 1112 of file ime.c.

{
    IMEINFOEX info;
    size_t cch;
 
    TRACE("(%p, %p, %d)\n", hKL, lpszDescription, uBufLen);
 
    if (!IS_IME_HKL(hKL))
    {
        TRACE("\n");
        return 0;
    }
 
    if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL))
    {
        ERR("\n");
        return 0;
    }
 
    if (uBufLen != 0)
        StringCchCopyW(lpszDescription, uBufLen, info.wszImeDescription);
 
    StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription), &cch);
    return (UINT)cch;
}

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

ImmGetIMEFileNameA()

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

Definition at line 1141 of file ime.c.

{
    BOOL bDefUsed;
    IMEINFOEX info;
    size_t cch;
 
    TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);
 
    if (!IS_IME_HKL(hKL))
    {
        TRACE("\n");
        if (uBufLen > 0)
            lpszFileName[0] = 0;
        return 0;
    }
 
    if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL))
    {
        ERR("\n");
        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 1182 of file ime.c.

{
    IMEINFOEX info;
    size_t cch;
 
    TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);
 
    if (!IS_IME_HKL(hKL))
    {
        TRACE("\n");
        if (uBufLen > 0)
            lpszFileName[0] = 0;
        return 0;
    }
 
    if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL))
    {
        ERR("\n");
        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(), and GetHKLDesctription().

ImmGetImeInfoEx()

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

Definition at line 932 of file ime.c.

{
    HKL hKL;
    if (SearchType == ImeInfoExKeyboardLayout || SearchType == ImeInfoExKeyboardLayoutTFS)
    {
        hKL = *(HKL*)pvSearchKey;
        pImeInfoEx->hkl = hKL;
 
        if (SearchType == ImeInfoExKeyboardLayoutTFS)
        {
            if (!IS_IME_HKL(hKL))
            {
                if (CtfImmIsTextFrameServiceDisabled() || !IS_CICERO_MODE() || IS_16BIT_MODE())
                {
                    TRACE("\n");
                    return FALSE;
                }
            }
 
            SearchType = ImeInfoExKeyboardLayout;
        }
        else
        {
            if (!IS_IME_HKL(hKL))
            {
                TRACE("\n");
                return FALSE;
            }
        }
    }
    else if (SearchType == ImeInfoExImeFileName)
    {
        StringCchCopyW(pImeInfoEx->wszImeFile, _countof(pImeInfoEx->wszImeFile),
                       pvSearchKey);
    }
    else
    {
        return FALSE;
    }
 
    return NtUserGetImeInfoEx(pImeInfoEx, SearchType);
}

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

ImmGetImeMenuItemsA()

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

Definition at line 2109 of file ime.c.

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

Referenced by ActiveIMMApp_GetImeMenuItemsA(), and test_InvalidIMC().

ImmGetImeMenuItemsAW()

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

Definition at line 609 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 (IS_NULL_UNEXPECTEDLY(hIMC))
        return 0;
 
    dwProcessId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTPROCESSID);
    if (IS_ZERO_UNEXPECTEDLY(dwProcessId))
        return 0;
 
    if (dwProcessId != GetCurrentProcessId())
    {
        if (bTargetIsAnsi)
            return 0;
        return Imm32GetImeMenuItemWInterProcess(hIMC, dwFlags, dwType, lpImeParentMenu,
                                                lpImeMenu, dwSize);
    }
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return 0;
 
    dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    if (IS_ZERO_UNEXPECTEDLY(dwThreadId))
    {
        ImmUnlockIMC(hIMC);
        return 0;
    }
 
    hKL = GetKeyboardLayout(dwThreadId);
    pImeDpi = ImmLockImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
    {
        ImmUnlockIMC(hIMC);
        return 0;
    }
 
    bImcIsAnsi = Imm32IsImcAnsi(hIMC);
 
    if (bImcIsAnsi != bTargetIsAnsi)
    {
        if (bTargetIsAnsi)
        {
            if (lpImeParentMenu)
                pNewParent = &ParentW;
 
            if (lpImeMenu)
            {
                cbTotal = ((dwSize / sizeof(IMEMENUITEMINFOA)) * sizeof(IMEMENUITEMINFOW));
                pNewItems = ImmLocalAlloc(0, cbTotal);
                if (IS_NULL_UNEXPECTEDLY(pNewItems))
                    goto Quit;
            }
        }
        else
        {
            if (lpImeParentMenu)
                pNewParent = &ParentA;
 
            if (lpImeMenu)
            {
                cbTotal = ((dwSize / sizeof(IMEMENUITEMINFOW)) * sizeof(IMEMENUITEMINFOA));
                pNewItems = ImmLocalAlloc(0, cbTotal);
                if (IS_NULL_UNEXPECTEDLY(pNewItems))
                    goto Quit;
            }
        }
    }
    else
    {
        pNewItems = lpImeMenu;
        pNewParent = lpImeParentMenu;
    }
 
    ret = pImeDpi->ImeGetImeMenuItems(hIMC, dwFlags, dwType, pNewParent, pNewItems, dwSize);
    if (IS_ZERO_UNEXPECTEDLY(ret) || !lpImeMenu)
        goto Quit;
 
    if (bImcIsAnsi != bTargetIsAnsi)
    {
        if (bTargetIsAnsi)
        {
            if (pNewParent)
                Imm32ImeMenuWideToAnsi(pNewParent, lpImeParentMenu, pImeDpi->uCodePage);
 
            pItemW = pNewItems;
            pItemA = lpImeMenu;
            for (iItem = 0; iItem < ret; ++iItem, ++pItemW, ++pItemA)
            {
                if (!Imm32ImeMenuWideToAnsi(pItemW, pItemA, pImeDpi->uCodePage))
                {
                    ERR("\n");
                    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))
                {
                    ERR("\n");
                    ret = 0;
                    break;
                }
            }
        }
    }
 
Quit:
    if (pNewItems != lpImeMenu)
        ImmLocalFree(pNewItems);
    ImmUnlockImeDpi(pImeDpi);
    ImmUnlockIMC(hIMC);
    TRACE("ret: 0x%X\n", ret);
    return ret;
}

Referenced by ImmGetImeMenuItemsA(), and ImmGetImeMenuItemsW().

ImmGetImeMenuItemsW()

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

Definition at line 2122 of file ime.c.

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

Referenced by ActiveIMMApp_GetImeMenuItemsW(), and ImmPutImeMenuItemsIntoMappedFile().

ImmGetOpenStatus()

BOOL WINAPI ImmGetOpenStatus

(

HIMC

hIMC

)

Definition at line 1443 of file ime.c.

{
    BOOL ret;
    LPINPUTCONTEXT pIC;
 
    TRACE("(%p)\n", hIMC);
 
    if (IS_NULL_UNEXPECTEDLY(hIMC))
        return FALSE;
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    ret = pIC->fOpen;
    ImmUnlockIMC(hIMC);
    TRACE("ret: %d\n", ret);
    return ret;
}

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

ImmGetProperty()

DWORD WINAPI ImmGetProperty	(	HKL	hKL,
		DWORD	fdwIndex
	)

Definition at line 1221 of file ime.c.

{
    IMEINFOEX ImeInfoEx;
    LPIMEINFO pImeInfo;
    DWORD dwValue;
    PIMEDPI pImeDpi = NULL;
 
    TRACE("(%p, %lu)\n", hKL, fdwIndex);
 
    if (!IS_IME_HKL(hKL))
    {
        TRACE("\n");
        return FALSE;
    }
 
    if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
    {
        ERR("\n");
        return FALSE;
    }
 
    if (fdwIndex == IGP_GETIMEVERSION)
        return ImeInfoEx.dwImeWinVersion;
 
    if (ImeInfoEx.fLoadFlag != 2)
    {
        pImeDpi = Imm32FindOrLoadImeDpi(hKL);
        if (IS_NULL_UNEXPECTEDLY(pImeDpi))
            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 1509 of file ime.c.

{
    LPINPUTCONTEXT pIC;
    BOOL ret;
 
    TRACE("(%p, %p)\n", hIMC, lpptPos);
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        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 748 of file ime.c.

{
    HKL hKL = NULL;
    LPWSTR pszFileNameW = NULL, pszLayoutTextW = NULL;
 
    TRACE("(%s, %s)\n", lpszIMEFileName, lpszLayoutText);
 
    pszFileNameW = Imm32WideFromAnsi(CP_ACP, lpszIMEFileName);
    if (IS_NULL_UNEXPECTEDLY(pszFileNameW))
        goto Quit;
 
    pszLayoutTextW = Imm32WideFromAnsi(CP_ACP, lpszLayoutText);
    if (IS_NULL_UNEXPECTEDLY(pszLayoutTextW))
        goto Quit;
 
    hKL = ImmInstallIMEW(pszFileNameW, pszLayoutTextW);
 
Quit:
    ImmLocalFree(pszFileNameW);
    ImmLocalFree(pszLayoutTextW);
    return hKL;
}

Referenced by ActiveIMMApp_InstallIMEA().

ImmInstallIMEW()

HKL WINAPI ImmInstallIMEW	(	LPCWSTR	lpszIMEFileName,
		LPCWSTR	lpszLayoutText
	)

Definition at line 774 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", lpszIMEFileName, lpszLayoutText);
 
    GetFullPathNameW(lpszIMEFileName, _countof(szImeFileName), szImeFileName, &pchFilePart);
    CharUpperW(szImeFileName);
    if (IS_NULL_UNEXPECTEDLY(pchFilePart))
        return NULL;
 
    /* Load the IME version info */
    InfoEx.hkl = hNewKL = NULL;
    StringCchCopyW(InfoEx.wszImeFile, _countof(InfoEx.wszImeFile), pchFilePart);
    if (!Imm32LoadImeVerInfo(&InfoEx) || !InfoEx.hkl)
    {
        ERR("\n");
        return NULL;
    }
    wLangID = LOWORD(InfoEx.hkl);
 
    /* Get the IME layouts from registry */
    cLayouts = Imm32GetImeLayout(NULL, 0);
    if (cLayouts)
    {
        pLayouts = ImmLocalAlloc(0, cLayouts * sizeof(REG_IME));
        if (IS_NULL_UNEXPECTEDLY(pLayouts))
            return NULL;
 
        if (!Imm32GetImeLayout(pLayouts, cLayouts))
        {
            ERR("\n");
            ImmLocalFree(pLayouts);
            return NULL;
        }
 
        for (iLayout = 0; iLayout < cLayouts; ++iLayout)
        {
            if (lstrcmpiW(pLayouts[iLayout].szFileName, pchFilePart) == 0)
            {
                if (wLangID != LOWORD(pLayouts[iLayout].hKL))
                {
                    ERR("\n");
                    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 */
    if (ImmGetImeInfoEx(&InfoEx, ImeInfoExImeFileName, pchFilePart) &&
        !UnloadKeyboardLayout(InfoEx.hkl))
    {
        ERR("\n");
        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 &&
        !Imm32CopyImeFile(szImeFileName, szImeDestPath))
    {
        ERR("\n");
        hNewKL = NULL;
        goto Quit;
    }
 
    if (hNewKL == NULL)
        hNewKL = Imm32AssignNewLayout(cLayouts, pLayouts, wLangID);
 
    if (hNewKL)
    {
        /* Write the IME layout to registry */
        if (Imm32WriteImeLayout(hNewKL, pchFilePart, lpszLayoutText))
        {
            /* Load the keyboard layout */
            StringCchPrintfW(szImeKey, _countof(szImeKey), L"%08X", HandleToUlong(hNewKL));
            hNewKL = LoadKeyboardLayoutW(szImeKey, KLF_REPLACELANG);
        }
        else
        {
            ERR("\n");
            hNewKL = NULL;
        }
    }
 
Quit:
    ImmLocalFree(pLayouts);
    return hNewKL;
}

Referenced by ActiveIMMApp_InstallIMEW(), and ImmInstallIMEA().

ImmIsIME()

BOOL WINAPI ImmIsIME

(

HKL

hKL

)

Definition at line 880 of file ime.c.

{
    IMEINFOEX info;
    TRACE("(%p)\n", hKL);
    return !!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayoutTFS, &hKL);
}

Referenced by ActiveIMMApp_IsIME(), CtfAImmIsIME(), EDIT_SetCaretPos(), EDIT_WM_SetFont(), editor_handle_message(), Imm32CImeNonImeToggle(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32ImeNonImeToggle(), Imm32JCloseOpen(), and update_caret().

ImmLoadIME()

BOOL WINAPI ImmLoadIME

(

HKL

hKL

)

Definition at line 1055 of file ime.c.

{
    PIMEDPI pImeDpi;
 
    if (!IS_IME_HKL(hKL) && (!IS_CICERO_MODE() || IS_16BIT_MODE()))
    {
        TRACE("\n");
        return FALSE;
    }
 
    pImeDpi = Imm32FindImeDpi(hKL);
    if (pImeDpi == NULL)
        pImeDpi = Imm32LoadImeDpi(hKL, FALSE);
    return (pImeDpi != NULL);
}

Referenced by CtfImmTIMActivate(), CtfLoadThreadLayout(), and ImmActivateLayout().

ImmLockImeDpi()

PIMEDPI WINAPI ImmLockImeDpi

(

HKL

hKL

)

Definition at line 978 of file ime.c.

{
    PIMEDPI pImeDpi = NULL;
 
    TRACE("(%p)\n", hKL);
 
    RtlEnterCriticalSection(&gcsImeDpi);
 
    /* Find by hKL */
    for (pImeDpi = gpImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
    {
        if (pImeDpi->hKL == hKL) /* found */
        {
            /* lock if possible */
            if (pImeDpi->dwFlags & IMEDPI_FLAG_UNLOADED)
                pImeDpi = NULL;
            else
                ++(pImeDpi->cLockObj);
            break;
        }
    }
 
    RtlLeaveCriticalSection(&gcsImeDpi);
    return pImeDpi;
}

Referenced by Imm32CreateInputContext(), Imm32DestroyInputContext(), Imm32FindOrLoadImeDpi(), Imm32MakeIMENotify(), Imm32ProcessHotKey(), Imm32SelectInputContext(), ImmActivateLayout(), ImmCallImeConsoleIME(), ImmCreateSoftKeyboard(), ImmGetImeMenuItemsAW(), ImmNotifyIME(), ImmProcessKey(), ImmSetActiveContext(), ImmSetCompositionStringAW(), ImmTranslateMessage(), and User32CreateImeUIWindow().

ImmNotifyIME()

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

Definition at line 907 of file ime.c.

{
    HKL hKL;
    PIMEDPI pImeDpi;
    BOOL ret;
 
    TRACE("(%p, %lu, %lu, %lu)\n", hIMC, dwAction, dwIndex, dwValue);
 
    if (hIMC && IS_CROSS_THREAD_HIMC(hIMC))
        return FALSE;
 
    hKL = GetKeyboardLayout(0);
    pImeDpi = ImmLockImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return FALSE;
 
    ret = pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue);
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

Referenced by ActiveIMMApp_NotifyIME(), EDIT_WindowProc(), editor_handle_message(), Imm32NotifyIMEProc(), ImmSystemHandler(), CicBridge::SetActiveContextAlways(), CicBridge::SetCompositionString(), test_ImmGetCompositionString(), and test_ImmNotifyIME().

ImmPutImeMenuItemsIntoMappedFile()

LRESULT WINAPI ImmPutImeMenuItemsIntoMappedFile

(

HIMC

hIMC

)

Definition at line 448 of file ime.c.

{
    LRESULT ret = FALSE;
    HANDLE hMapping;
    PIMEMENU pView;
    LPIMEMENUITEMINFOW pParent = NULL, pItems = NULL;
    DWORD i, cItems, cbItems = 0;
 
    hMapping = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, L"ImmMenuInfo");
    pView = MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
    if (IS_NULL_UNEXPECTEDLY(pView))
        goto Quit;
 
    if (pView->dwVersion != 1)
    {
        ERR("\n");
        goto Quit;
    }
 
    if (pView->Parent.cbSize > 0)
        pParent = &pView->Parent;
 
    if (pView->dwItemCount > 0)
    {
        cbItems = pView->dwItemCount * sizeof(IMEMENUITEMINFOW);
        pItems = ImmLocalAlloc(HEAP_ZERO_MEMORY, cbItems);
        if (IS_NULL_UNEXPECTEDLY(pItems))
            goto Quit;
    }
 
    cItems = ImmGetImeMenuItemsW(hIMC, pView->dwFlags, pView->dwType, pParent, pItems, cbItems);
    pView->dwItemCount = cItems;
    if (IS_ZERO_UNEXPECTEDLY(cItems))
        goto Quit;
 
    if (pItems)
    {
        for (i = 0; i < cItems; ++i)
        {
            pView->Items[i].Info = pItems[i];
 
            // store bitmaps to bytes
            if (pItems[i].hbmpChecked)
            {
                Imm32StoreBitmapToBytes(pItems[i].hbmpChecked, pView->Items[i].abChecked,
                                        MAX_IMEMENU_BITMAP_BYTES);
                DeleteObject(pItems[i].hbmpChecked);
            }
            if (pItems[i].hbmpUnchecked)
            {
                Imm32StoreBitmapToBytes(pItems[i].hbmpUnchecked, pView->Items[i].abUnchecked,
                                        MAX_IMEMENU_BITMAP_BYTES);
                DeleteObject(pItems[i].hbmpUnchecked);
            }
            if (pItems[i].hbmpItem)
            {
                Imm32StoreBitmapToBytes(pItems[i].hbmpItem, pView->Items[i].abItem,
                                        MAX_IMEMENU_BITMAP_BYTES);
                DeleteObject(pItems[i].hbmpItem);
            }
        }
    }
 
    ret = TRUE;
 
Quit:
    if (pItems)
        ImmLocalFree(pItems);
    if (pView)
        UnmapViewOfFile(pView);
    if (hMapping)
        CloseHandle(hMapping);
    return ret;
}

Referenced by ImeWnd_OnImeSystem().

ImmSetCompositionFontA()

BOOL WINAPI ImmSetCompositionFontA	(	HIMC	hIMC,
		LPLOGFONTA	lplf
	)

Definition at line 1688 of file ime.c.

{
    LOGFONTW lfW;
    PCLIENTIMC pClientImc;
    BOOL bWide;
    LPINPUTCONTEXTDX pIC;
    LANGID LangID;
    HWND hWnd;
 
    TRACE("(%p, %p)\n", hIMC, lplf);
 
    if (IS_CROSS_THREAD_HIMC(hIMC))
        return FALSE;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return FALSE;
 
    bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);
 
    if (bWide)
    {
        LogFontAnsiToWide(lplf, &lfW);
        return ImmSetCompositionFontW(hIMC, &lfW);
    }
 
    pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    if (GetWin32ClientInfo()->dwExpWinVer < _WIN32_WINNT_NT4) /* old version (3.x)? */
    {
        LangID = LANGIDFROMLCID(GetSystemDefaultLCID());
        if (PRIMARYLANGID(LangID) == 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);
 
    Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, 0, IMC_SETCOMPOSITIONFONT,
                       IMN_SETCOMPOSITIONFONT, 0);
    return TRUE;
}

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

ImmSetCompositionFontW()

BOOL WINAPI ImmSetCompositionFontW	(	HIMC	hIMC,
		LPLOGFONTW	lplf
	)

Definition at line 1744 of file ime.c.

{
    LOGFONTA lfA;
    PCLIENTIMC pClientImc;
    BOOL bWide;
    HWND hWnd;
    LPINPUTCONTEXTDX pIC;
    LANGID LangID;
 
    TRACE("(%p, %p)\n", hIMC, lplf);
 
    if (IS_CROSS_THREAD_HIMC(hIMC))
        return FALSE;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return FALSE;
 
    bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);
 
    if (!bWide)
    {
        LogFontWideToAnsi(lplf, &lfA);
        return ImmSetCompositionFontA(hIMC, &lfA);
    }
 
    pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    if (GetWin32ClientInfo()->dwExpWinVer < _WIN32_WINNT_NT4) /* old version (3.x)? */
    {
        LangID = LANGIDFROMLCID(GetSystemDefaultLCID());
        if (PRIMARYLANGID(LangID) == 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);
 
    Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, 0, IMC_SETCOMPOSITIONFONT,
                       IMN_SETCOMPOSITIONFONT, 0);
    return TRUE;
}

Referenced by ActiveIMMApp_SetCompositionFontW(), EDIT_WM_SetFont(), editor_handle_message(), ImeWnd_OnImeControl(), ImeWnd_OnImeSystem(), ImmSetCompositionFontA(), and update_caret().

ImmSetCompositionWindow()

BOOL WINAPI ImmSetCompositionWindow	(	HIMC	hIMC,
		LPCOMPOSITIONFORM	lpCompForm
	)

Definition at line 1583 of file ime.c.

{
    LPINPUTCONTEXTDX pIC;
    HWND hWnd;
 
    if (Imm32IsCrossThreadAccess(hIMC))
        return FALSE;
 
    pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    pIC->cfCompForm = *lpCompForm;
    pIC->fdwInit |= INIT_COMPFORM;
 
    if (pIC->dwUIFlags & 0x8)
        pIC->dwUIFlags &= ~0x8;
    else
        pIC->dwUIFlags &= ~0x2;
 
    hWnd = pIC->hWnd;
 
    ImmUnlockIMC(hIMC);
 
    Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
                       IMC_SETCOMPOSITIONWINDOW, IMN_SETCOMPOSITIONWINDOW, 0);
    return TRUE;
}

Referenced by ActiveIMMApp_SetCompositionWindow(), ImeWnd_OnImeControl(), ImeWnd_OnImeSetContext(), ImeWnd_OnImeSystem(), ImmGetContextThreadFunc(), test_ImmThreads(), test_InvalidIMC(), and update_caret().

ImmSetConversionStatus()

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

Definition at line 1939 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) && IS_CICERO_MODE() && !IS_16BIT_MODE())
        fUseCicero = TRUE;
 
    if (IS_CROSS_THREAD_HIMC(hIMC))
        return FALSE;
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        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)
    {
        Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldConversion,
                           IMC_SETCONVERSIONMODE, IMN_SETCONVERSIONMODE, 0);
        if (fConversionChange)
            NtUserNotifyIMEStatus(hWnd, fOpen, fdwConversion);
    }
 
    if (fSentenceChange || fUseCicero)
    {
        Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldSentence,
                           IMC_SETSENTENCEMODE, IMN_SETSENTENCEMODE, 0);
    }
 
    return TRUE;
}

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

ImmSetOpenStatus()

BOOL WINAPI ImmSetOpenStatus	(	HIMC	hIMC,
		BOOL	fOpen
	)

Definition at line 1466 of file ime.c.

{
    DWORD dwConversion;
    LPINPUTCONTEXT pIC;
    HWND hWnd;
    BOOL bHasChange = FALSE;
 
    TRACE("(%p, %d)\n", hIMC, fOpen);
 
    if (IS_CROSS_THREAD_HIMC(hIMC))
        return FALSE;
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    if (pIC->fOpen != fOpen)
    {
        pIC->fOpen = fOpen;
        hWnd = pIC->hWnd;
        dwConversion = pIC->fdwConversion;
        bHasChange = TRUE;
    }
 
    ImmUnlockIMC(hIMC);
 
    if (bHasChange)
    {
        Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
                           IMC_SETOPENSTATUS, IMN_SETOPENSTATUS, 0);
        NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
    }
    else
    {
        TRACE("No change.\n");
    }
 
    return TRUE;
}

Referenced by ActiveIMMApp_SetOpenStatus(), ImeWnd_OnImeControl(), ImeWnd_OnImeSystem(), Imm32CImeNonImeToggle(), Imm32CShapeToggle(), Imm32CSymbolToggle(), Imm32JCloseOpen(), Imm32KEnglish(), Imm32KShapeToggle(), ImmGetContextThreadFunc(), OnTimer(), Test1(), test_ime_processkey(), test_ImmDefaultHwnd(), test_ImmMessages(), test_ImmThreads(), and test_InvalidIMC().

ImmSetStatusWindowPos()

BOOL WINAPI ImmSetStatusWindowPos	(	HIMC	hIMC,
		LPPOINT	lpptPos
	)

Definition at line 1531 of file ime.c.

{
    LPINPUTCONTEXT pIC;
    HWND hWnd;
 
    TRACE("(%p, {%ld, %ld})\n", hIMC, lpptPos->x, lpptPos->y);
 
    if (IS_CROSS_THREAD_HIMC(hIMC))
        return FALSE;
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    hWnd = pIC->hWnd;
    pIC->ptStatusWndPos = *lpptPos;
    pIC->fdwInit |= INIT_STATUSWNDPOS;
 
    ImmUnlockIMC(hIMC);
 
    Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
                       IMC_SETSTATUSWINDOWPOS, IMN_SETSTATUSWINDOWPOS, 0);
    return TRUE;
}

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

ImmUnlockImeDpi()

VOID WINAPI ImmUnlockImeDpi

(

PIMEDPI

pImeDpi

)

Definition at line 1007 of file ime.c.

{
    PIMEDPI *ppEntry;
 
    TRACE("(%p)\n", pImeDpi);
 
    if (pImeDpi == NULL)
        return;
 
    RtlEnterCriticalSection(&gcsImeDpi);
 
    /* unlock */
    --(pImeDpi->cLockObj);
    if (pImeDpi->cLockObj != 0)
    {
        RtlLeaveCriticalSection(&gcsImeDpi);
        return;
    }
 
    if ((pImeDpi->dwFlags & IMEDPI_FLAG_UNLOADED) == 0)
    {
        if ((pImeDpi->dwFlags & IMEDPI_FLAG_LOCKED) == 0 ||
            (pImeDpi->ImeInfo.fdwProperty & IME_PROP_END_UNLOAD) == 0)
        {
            RtlLeaveCriticalSection(&gcsImeDpi);
            return;
        }
    }
 
    /* Remove from list */
    for (ppEntry = &gpImeDpiList; *ppEntry; ppEntry = &((*ppEntry)->pNext))
    {
        if (*ppEntry == pImeDpi) /* found */
        {
            *ppEntry = pImeDpi->pNext;
            break;
        }
    }
 
    Imm32FreeIME(pImeDpi, TRUE);
    ImmLocalFree(pImeDpi);
 
    RtlLeaveCriticalSection(&gcsImeDpi);
}

Referenced by CtfImmGetGuidAtom(), CtfImmIsGuidMapEnable(), Imm32CreateInputContext(), Imm32DestroyInputContext(), Imm32MakeIMENotify(), Imm32ProcessHotKey(), Imm32SelectInputContext(), ImmActivateLayout(), ImmCallImeConsoleIME(), ImmConfigureIMEA(), ImmConfigureIMEW(), ImmCreateSoftKeyboard(), ImmEnumRegisterWordA(), ImmEnumRegisterWordW(), ImmEscapeA(), ImmEscapeW(), ImmGetConversionListA(), ImmGetConversionListW(), ImmGetImeMenuItemsAW(), ImmGetProperty(), ImmGetRegisterWordStyleA(), ImmGetRegisterWordStyleW(), ImmNotifyIME(), ImmProcessKey(), ImmRegisterWordA(), ImmRegisterWordW(), ImmSetActiveContext(), ImmSetCompositionStringAW(), ImmTranslateMessage(), ImmUnregisterWordA(), ImmUnregisterWordW(), and User32CreateImeUIWindow().

ImmWINNLSEnableIME()

BOOL WINAPI ImmWINNLSEnableIME	(	HWND	hWnd,
		BOOL	enable
	)

Definition at line 2134 of file ime.c.

{
    HIMC hIMC;
    PCLIENTIMC pClientImc;
    HWND hImeWnd;
    BOOL bImeWnd, ret;
 
    TRACE("(%p, %d)\n", hWnd, enable);
 
    if (!Imm32IsSystemJapaneseOrKorean())
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    hIMC = (HIMC)NtUserGetThreadState(THREADSTATE_DEFAULTINPUTCONTEXT);
    if (IS_NULL_UNEXPECTEDLY(hIMC))
        return FALSE;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return FALSE;
 
    ret = !(pClientImc->dwFlags & CLIENTIMC_DISABLEIME);
    if (!!enable == ret)
    {
        TRACE("Same\n");
        ImmUnlockClientImc(pClientImc);
        return ret;
    }
 
    if (!IsWindow(hWnd))
        hWnd = GetFocus();
 
    hImeWnd = ImmGetDefaultIMEWnd(hWnd);
    bImeWnd = IsWindow(hImeWnd);
    if (bImeWnd)
        ImmSetActiveContext(hWnd, (enable ? NULL : hIMC), FALSE);
 
    if (enable)
        pClientImc->dwFlags &= ~CLIENTIMC_DISABLEIME;
    else
        pClientImc->dwFlags |= CLIENTIMC_DISABLEIME;
 
    ImmUnlockClientImc(pClientImc);
 
    if (bImeWnd)
        ImmSetActiveContext(hWnd, (enable ? hIMC : NULL), TRUE);
 
    return ret;
}

Referenced by IntInitializeImmEntryTable(), User32InitializeImmEntryTable(), and WINNLSEnableIME().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)

Variable Documentation

gcsImeDpi

RTL_CRITICAL_SECTION gcsImeDpi

Definition at line 16 of file ime.c.

Referenced by Imm32FindImeDpi(), Imm32GetImeMenuItemWInterProcess(), Imm32InitTLS(), Imm32LoadCtfIme(), Imm32LoadImeDpi(), Imm32ReleaseIME(), ImmDllInitialize(), ImmFreeLayout(), ImmInitializeGlobals(), ImmLockImeDpi(), and ImmUnlockImeDpi().

gpImeDpiList

PIMEDPI gpImeDpiList = NULL

Definition at line 17 of file ime.c.

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