precomp.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <wingdi.h>
#include <winuser.h>
#include <winnls.h>
#include <winreg.h>
#include <winnls32.h>
#include <winver.h>
#include <imm.h>
#include <ddk/immdev.h>
#include <ndk/umtypes.h>
#include <ndk/pstypes.h>
#include <ndk/rtlfuncs.h>
#include "ntuser.h"
#include "ntwin32.h"
#include <undocuser.h>
#include <imm32_undoc.h>
#include <strsafe.h>
#include <wine/debug.h>
#include <wine/list.h>

Include dependency graph for precomp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	REG_IME

Macros
#define	WIN32_NO_STATUS
#define	NTOS_MODE_USER
#define	IMM_INIT_MAGIC   0x19650412
#define	IMM_INVALID_CANDFORM   ULONG_MAX
#define	INVALID_HOTKEY_ID   0xFFFFFFFF
#define	MAX_CANDIDATEFORM   4
#define	MAX_IMM_FILENAME   80
#define	LANGID_CHINESE_SIMPLIFIED   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED)
#define	LANGID_CHINESE_TRADITIONAL   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL)
#define	LANGID_JAPANESE   MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT)
#define	REGKEY_KEYBOARD_LAYOUTS   L"System\\CurrentControlSet\\Control\\Keyboard Layouts"
#define	REGKEY_IMM   L"Software\\Microsoft\\Windows NT\\CurrentVersion\\IMM"
#define	ROUNDUP4(n)   (((n) + 3) & ~3) /* DWORD alignment */
#define	ValidateHwndNoErr(hwnd)   ValidateHandleNoErr((hwnd), TYPE_WINDOW)
#define	ValidateHwnd(hwnd)   ValidateHandle((hwnd), TYPE_WINDOW)
#define	ImmLocalFree(lpData)   HeapFree(ghImmHeap, 0, (lpData))
#define	ImeDpi_IsUnicode(pImeDpi)   ((pImeDpi)->ImeInfo.fdwProperty & IME_PROP_UNICODE)
#define	IS_16BIT_MODE()   (GetWin32ClientInfo()->dwTIFlags & TIF_16BIT)

Typedefs
typedef struct REG_IME	REG_IME
typedef struct REG_IME *	PREG_IME

Functions
BOOL	Imm32GetSystemLibraryPath (LPWSTR pszPath, DWORD cchPath, LPCWSTR pszFileName)
VOID APIENTRY	LogFontAnsiToWide (const LOGFONTA *plfA, LPLOGFONTW plfW)
VOID APIENTRY	LogFontWideToAnsi (const LOGFONTW *plfW, LPLOGFONTA plfA)
LPVOID FASTCALL	ValidateHandleNoErr (HANDLE hObject, UINT uType)
LPVOID FASTCALL	ValidateHandle (HANDLE hObject, UINT uType)
BOOL APIENTRY	Imm32CheckImcProcess (PIMC pIMC)
LPVOID APIENTRY	ImmLocalAlloc (DWORD dwFlags, DWORD dwBytes)
LPWSTR APIENTRY	Imm32WideFromAnsi (LPCSTR pszA)
LPSTR APIENTRY	Imm32AnsiFromWide (LPCWSTR pszW)
LONG APIENTRY	IchWideFromAnsi (LONG cchAnsi, LPCSTR pchAnsi, UINT uCodePage)
LONG APIENTRY	IchAnsiFromWide (LONG cchWide, LPCWSTR pchWide, UINT uCodePage)
PIMEDPI APIENTRY	Imm32FindOrLoadImeDpi (HKL hKL)
LPINPUTCONTEXT APIENTRY	Imm32InternalLockIMC (HIMC hIMC, BOOL fSelect)
BOOL APIENTRY	Imm32ReleaseIME (HKL hKL)
BOOL APIENTRY	Imm32IsSystemJapaneseOrKorean (VOID)
static BOOL	Imm32IsCrossThreadAccess (HIMC hIMC)
static BOOL	Imm32IsCrossProcessAccess (HWND hWnd)
BOOL WINAPI	Imm32IsImcAnsi (HIMC hIMC)
DWORD APIENTRY	CandidateListWideToAnsi (const CANDIDATELIST *pWideCL, LPCANDIDATELIST pAnsiCL, DWORD dwBufLen, UINT uCodePage)
DWORD APIENTRY	CandidateListAnsiToWide (const CANDIDATELIST *pAnsiCL, LPCANDIDATELIST pWideCL, DWORD dwBufLen, UINT uCodePage)
BOOL APIENTRY	Imm32MakeIMENotify (HIMC hIMC, HWND hwnd, DWORD dwAction, DWORD_PTR dwIndex, DWORD_PTR dwValue, DWORD_PTR dwCommand, DWORD_PTR dwData)
DWORD APIENTRY	Imm32BuildHimcList (DWORD dwThreadId, HIMC **pphList)
INT APIENTRY	Imm32ImeMenuAnsiToWide (const IMEMENUITEMINFOA *pItemA, LPIMEMENUITEMINFOW pItemW, UINT uCodePage, BOOL bBitmap)
INT APIENTRY	Imm32ImeMenuWideToAnsi (const IMEMENUITEMINFOW *pItemW, LPIMEMENUITEMINFOA pItemA, UINT uCodePage)
PIME_STATE APIENTRY	Imm32FetchImeState (LPINPUTCONTEXTDX pIC, HKL hKL)
PIME_SUBSTATE APIENTRY	Imm32FetchImeSubState (PIME_STATE pState, HKL hKL)
BOOL APIENTRY	Imm32LoadImeStateSentence (LPINPUTCONTEXTDX pIC, PIME_STATE pState, HKL hKL)
BOOL APIENTRY	Imm32SaveImeStateSentence (LPINPUTCONTEXTDX pIC, PIME_STATE pState, HKL hKL)
DWORD APIENTRY	Imm32ReconvertAnsiFromWide (LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
DWORD APIENTRY	Imm32ReconvertWideFromAnsi (LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
HRESULT APIENTRY	Imm32StrToUInt (LPCWSTR pszText, LPDWORD pdwValue, ULONG nBase)
HRESULT APIENTRY	Imm32UIntToStr (DWORD dwValue, ULONG nBase, LPWSTR pszBuff, USHORT cchBuff)
BOOL APIENTRY	Imm32LoadImeVerInfo (PIMEINFOEX pImeInfoEx)
UINT APIENTRY	Imm32GetImeLayout (PREG_IME pLayouts, UINT cLayouts)
BOOL APIENTRY	Imm32WriteImeLayout (HKL hKL, LPCWSTR pchFilePart, LPCWSTR pszLayout)
HKL APIENTRY	Imm32AssignNewLayout (UINT cKLs, const REG_IME *pLayouts, WORD wLangID)
BOOL APIENTRY	Imm32CopyImeFile (LPWSTR pszOldFile, LPCWSTR pszNewFile)
static PTHREADINFO FASTCALL	Imm32CurrentPti (VOID)
HBITMAP	Imm32LoadBitmapFromBytes (const BYTE *pb)
BOOL	Imm32StoreBitmapToBytes (HBITMAP hbm, LPBYTE pbData, DWORD cbDataMax)

Variables
HMODULE	ghImm32Inst
RTL_CRITICAL_SECTION	gcsImeDpi
PIMEDPI	gpImeDpiList
PSERVERINFO	gpsi
SHAREDINFO	gSharedInfo
HANDLE	ghImmHeap

Macro Definition Documentation

ImeDpi_IsUnicode

#define ImeDpi_IsUnicode

(

pImeDpi

)

((pImeDpi)->ImeInfo.fdwProperty & IME_PROP_UNICODE)

Definition at line 116 of file precomp.h.

IMM_INIT_MAGIC

#define IMM_INIT_MAGIC   0x19650412

Definition at line 50 of file precomp.h.

IMM_INVALID_CANDFORM

#define IMM_INVALID_CANDFORM   ULONG_MAX

Definition at line 51 of file precomp.h.

ImmLocalFree

#define ImmLocalFree

(

lpData

)

HeapFree(ghImmHeap, 0, (lpData))

Definition at line 89 of file precomp.h.

INVALID_HOTKEY_ID

#define INVALID_HOTKEY_ID   0xFFFFFFFF

Definition at line 52 of file precomp.h.

IS_16BIT_MODE

#define IS_16BIT_MODE

(

)

(GetWin32ClientInfo()->dwTIFlags & TIF_16BIT)

Definition at line 117 of file precomp.h.

LANGID_CHINESE_SIMPLIFIED

#define LANGID_CHINESE_SIMPLIFIED   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED)

Definition at line 56 of file precomp.h.

LANGID_CHINESE_TRADITIONAL

#define LANGID_CHINESE_TRADITIONAL   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL)

Definition at line 57 of file precomp.h.

LANGID_JAPANESE

#define LANGID_JAPANESE   MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT)

Definition at line 58 of file precomp.h.

MAX_CANDIDATEFORM

#define MAX_CANDIDATEFORM   4

Definition at line 53 of file precomp.h.

MAX_IMM_FILENAME

#define MAX_IMM_FILENAME   80

Definition at line 54 of file precomp.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 32 of file precomp.h.

REGKEY_IMM

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

Definition at line 61 of file precomp.h.

REGKEY_KEYBOARD_LAYOUTS

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

Definition at line 60 of file precomp.h.

ROUNDUP4

#define ROUNDUP4

(

n

)

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

Definition at line 63 of file precomp.h.

ValidateHwnd

#define ValidateHwnd

(

hwnd

)

ValidateHandle((hwnd), TYPE_WINDOW)

Definition at line 85 of file precomp.h.

ValidateHwndNoErr

#define ValidateHwndNoErr

(

hwnd

)

ValidateHandleNoErr((hwnd), TYPE_WINDOW)

Definition at line 84 of file precomp.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 19 of file precomp.h.

Typedef Documentation

PREG_IME

typedef struct REG_IME * PREG_IME

REG_IME

typedef struct REG_IME REG_IME

Function Documentation

CandidateListAnsiToWide()

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

Definition at line 84 of file candidate.c.

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

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

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

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

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

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

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

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

    return dwBufLen;
}

Referenced by ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetConversionListW(), and ImmGetGuideLineAW().

CandidateListWideToAnsi()

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

Definition at line 14 of file candidate.c.

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

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

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

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

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

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

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

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

    return dwBufLen;
}

Referenced by ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetConversionListA(), and ImmGetGuideLineAW().

IchAnsiFromWide()

LONG APIENTRY IchAnsiFromWide	(	LONG	cchWide,
		LPCWSTR	pchWide,
		UINT	uCodePage
	)

Definition at line 230 of file utils.c.

{
    LONG cb, cchAnsi;
    for (cchAnsi = 0; cchWide > 0; ++cchAnsi, ++pchWide, --cchWide)
    {
        cb = WideCharToMultiByte(uCodePage, 0, pchWide, 1, NULL, 0, NULL, NULL);
        if (cb > 1)
            ++cchAnsi;
    }
    return cchAnsi;
}

Referenced by Imm32GetCompStrA(), Imm32ProcessRequest(), and Imm32ReconvertAnsiFromWide().

IchWideFromAnsi()

LONG APIENTRY IchWideFromAnsi	(	LONG	cchAnsi,
		LPCSTR	pchAnsi,
		UINT	uCodePage
	)

Definition at line 210 of file utils.c.

{
    LONG cchWide;
    for (cchWide = 0; cchAnsi > 0; ++cchWide)
    {
        if (IsDBCSLeadByteEx(uCodePage, *pchAnsi) && pchAnsi[1])
        {
            cchAnsi -= 2;
            pchAnsi += 2;
        }
        else
        {
            --cchAnsi;
            ++pchAnsi;
        }
    }
    return cchWide;
}

Referenced by Imm32GetCompStrW(), Imm32ProcessRequest(), and Imm32ReconvertWideFromAnsi().

Imm32AnsiFromWide()

LPSTR APIENTRY Imm32AnsiFromWide

(

LPCWSTR

pszW

)

Definition at line 197 of file utils.c.

{
    INT cchW = lstrlenW(pszW);
    INT cchA = (cchW + 1) * sizeof(WCHAR);
    LPSTR pszA = ImmLocalAlloc(0, cchA);
    if (!pszA)
        return NULL;
    cchA = WideCharToMultiByte(CP_ACP, 0, pszW, cchW, pszA, cchA, NULL, NULL);
    pszA[cchA] = 0;
    return pszA;
}

Referenced by Imm32EnumWordProcW2A(), ImmConfigureIMEW(), ImmEnumRegisterWordW(), ImmGetConversionListW(), ImmRegisterWordW(), and ImmUnregisterWordW().

Imm32AssignNewLayout()

HKL APIENTRY Imm32AssignNewLayout	(	UINT	cKLs,
		const REG_IME *	pLayouts,
		WORD	wLangID
	)

Definition at line 819 of file utils.c.

{
    UINT iKL, wID, wLow = 0xE0FF, wHigh = 0xE01F, wNextID = 0;

    for (iKL = 0; iKL < cKLs; ++iKL)
    {
        wHigh = max(wHigh, HIWORD(pLayouts[iKL].hKL));
        wLow = min(wLow, HIWORD(pLayouts[iKL].hKL));
    }

    if (wHigh < 0xE0FF)
    {
        wNextID = wHigh + 1;
    }
    else if (wLow > 0xE001)
    {
        wNextID = wLow - 1;
    }
    else
    {
        for (wID = 0xE020; wID <= 0xE0FF; ++wID)
        {
            for (iKL = 0; iKL < cKLs; ++iKL)
            {
                if (LOWORD(pLayouts[iKL].hKL) == wLangID &&
                    HIWORD(pLayouts[iKL].hKL) == wID)
                {
                    break;
                }
            }

            if (iKL >= cKLs)
                break;
        }

        if (wID <= 0xE0FF)
            wNextID = wID;
    }

    if (!wNextID)
        return NULL;

    return (HKL)(DWORD_PTR)MAKELONG(wLangID, wNextID);
}

Referenced by ImmInstallIMEW().

Imm32BuildHimcList()

DWORD APIENTRY Imm32BuildHimcList	(	DWORD	dwThreadId,
		HIMC **	pphList
	)

Definition at line 400 of file utils.c.

{
#define INITIAL_COUNT 0x40
#define MAX_RETRY 10
    NTSTATUS Status;
    DWORD dwCount = INITIAL_COUNT, cRetry = 0;
    HIMC *phNewList;

    phNewList = ImmLocalAlloc(0, dwCount * sizeof(HIMC));
    if (phNewList == NULL)
        return 0;

    Status = NtUserBuildHimcList(dwThreadId, dwCount, phNewList, &dwCount);
    while (Status == STATUS_BUFFER_TOO_SMALL)
    {
        ImmLocalFree(phNewList);
        if (cRetry++ >= MAX_RETRY)
            return 0;

        phNewList = ImmLocalAlloc(0, dwCount * sizeof(HIMC));
        if (phNewList == NULL)
            return 0;

        Status = NtUserBuildHimcList(dwThreadId, dwCount, phNewList, &dwCount);
    }

    if (NT_ERROR(Status) || !dwCount)
    {
        ImmLocalFree(phNewList);
        return 0;
    }

    *pphList = phNewList;
    return dwCount;
#undef INITIAL_COUNT
#undef MAX_RETRY
}

Referenced by ImmEnumInputContext().

Imm32CheckImcProcess()

BOOL APIENTRY Imm32CheckImcProcess

(

PIMC

pIMC

)

Definition at line 342 of file utils.c.

{
    HIMC hIMC;
    DWORD dwProcessID;
    if (pIMC->head.pti == Imm32CurrentPti())
        return TRUE;

    hIMC = pIMC->head.h;
    dwProcessID = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTPROCESSID);
    return dwProcessID == (DWORD_PTR)NtCurrentTeb()->ClientId.UniqueProcess;
}

Referenced by ImmLockClientImc().

Imm32CopyImeFile()

BOOL APIENTRY Imm32CopyImeFile	(	LPWSTR	pszOldFile,
		LPCWSTR	pszNewFile
	)

Definition at line 1031 of file utils.c.

{
    BOOL ret = FALSE, bLoaded = FALSE;
    HMODULE hinstLZ32;
    WCHAR szLZ32Path[MAX_PATH];
    CHAR szDestA[MAX_PATH];
    OFSTRUCT OFStruct;
    FN_LZOpenFileW fnLZOpenFileW;
    FN_LZCopy fnLZCopy;
    FN_LZClose fnLZClose;
    HFILE hfDest, hfSrc;

    /* Load LZ32.dll for copying/decompressing file */
    Imm32GetSystemLibraryPath(szLZ32Path, _countof(szLZ32Path), L"LZ32");
    hinstLZ32 = GetModuleHandleW(szLZ32Path);
    if (!hinstLZ32)
    {
        hinstLZ32 = LoadLibraryW(szLZ32Path);
        if (!hinstLZ32)
            return FALSE;
        bLoaded = TRUE;
    }

#define GET_FN(name) do { \
    fn##name = (FN_##name)GetProcAddress(hinstLZ32, #name); \
    if (!fn##name) goto Quit; \
} while (0)
    GET_FN(LZOpenFileW);
    GET_FN(LZCopy);
    GET_FN(LZClose);
#undef GET_FN

    if (!WideCharToMultiByte(CP_ACP, 0, pszNewFile, -1, szDestA, _countof(szDestA), NULL, NULL))
        goto Quit;
    szDestA[_countof(szDestA) - 1] = 0;

    hfSrc = fnLZOpenFileW(pszOldFile, &OFStruct, OF_READ);
    if (hfSrc < 0)
        goto Quit;

    hfDest = OpenFile(szDestA, &OFStruct, OF_CREATE);
    if (hfDest != HFILE_ERROR)
    {
        ret = (fnLZCopy(hfSrc, hfDest) >= 0);
        _lclose(hfDest);
    }

    fnLZClose(hfSrc);

Quit:
    if (bLoaded)
        FreeLibrary(hinstLZ32);
    return ret;
}

Referenced by ImmInstallIMEW().

Imm32CurrentPti()

static PTHREADINFO FASTCALL Imm32CurrentPti ( VOID  )

inlinestatic

Definition at line 160 of file precomp.h.

{
    if (NtCurrentTeb()->Win32ThreadInfo == NULL)
        NtUserGetThreadState(THREADSTATE_GETTHREADINFO);
    return NtCurrentTeb()->Win32ThreadInfo;
}

Referenced by Imm32CheckImcProcess(), Imm32DestroyInputContext(), and ImmRequestMessageAW().

Imm32FetchImeState()

PIME_STATE APIENTRY Imm32FetchImeState	(	LPINPUTCONTEXTDX	pIC,
		HKL	hKL
	)

Definition at line 491 of file utils.c.

{
    PIME_STATE pState;
    WORD Lang = PRIMARYLANGID(LOWORD(hKL));
    for (pState = pIC->pState; pState; pState = pState->pNext)
    {
        if (pState->wLang == Lang)
            break;
    }
    if (!pState)
    {
        pState = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(IME_STATE));
        if (pState)
        {
            pState->wLang = Lang;
            pState->pNext = pIC->pState;
            pIC->pState = pState;
        }
    }
    return pState;
}

Referenced by Imm32SelectInputContext().

Imm32FetchImeSubState()

PIME_SUBSTATE APIENTRY Imm32FetchImeSubState	(	PIME_STATE	pState,
		HKL	hKL
	)

Definition at line 515 of file utils.c.

{
    PIME_SUBSTATE pSubState;
    for (pSubState = pState->pSubState; pSubState; pSubState = pSubState->pNext)
    {
        if (pSubState->hKL == hKL)
            return pSubState;
    }
    pSubState = ImmLocalAlloc(0, sizeof(IME_SUBSTATE));
    if (!pSubState)
        return NULL;
    pSubState->dwValue = 0;
    pSubState->hKL = hKL;
    pSubState->pNext = pState->pSubState;
    pState->pSubState = pSubState;
    return pSubState;
}

Referenced by Imm32LoadImeStateSentence(), and Imm32SaveImeStateSentence().

Imm32FindOrLoadImeDpi()

PIMEDPI APIENTRY Imm32FindOrLoadImeDpi

(

HKL

hKL

)

Definition at line 295 of file ime.c.

{
    PIMEDPI pImeDpi;

    if (!IS_IME_HKL(hKL) && (!IS_CICERO_MODE() || IS_16BIT_MODE()))
        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().

Imm32GetImeLayout()

UINT APIENTRY Imm32GetImeLayout	(	PREG_IME	pLayouts,
		UINT	cLayouts
	)

Definition at line 865 of file utils.c.

{
    HKEY hkeyLayouts, hkeyIME;
    WCHAR szImeFileName[80], szImeKey[20];
    UINT iKey, nCount;
    DWORD cbData;
    LONG lError;
    ULONG Value;
    HKL hKL;

    /* Open the registry keyboard layouts */
    lError = RegOpenKeyW(HKEY_LOCAL_MACHINE, REGKEY_KEYBOARD_LAYOUTS, &hkeyLayouts);
    if (lError != ERROR_SUCCESS)
        return 0;

    for (iKey = nCount = 0; ; ++iKey)
    {
        /* Get the key name */
        lError = RegEnumKeyW(hkeyLayouts, iKey, szImeKey, _countof(szImeKey));
        if (lError != ERROR_SUCCESS)
            break;

        if (szImeKey[0] != L'E' && szImeKey[0] != L'e')
            continue; /* Not an IME layout */

        if (pLayouts == NULL) /* for counting only */
        {
            ++nCount;
            continue;
        }

        if (cLayouts <= nCount)
            break;

        lError = RegOpenKeyW(hkeyLayouts, szImeKey, &hkeyIME); /* Open the IME key */
        if (lError != ERROR_SUCCESS)
            break;

        /* Load the "Ime File" value */
        szImeFileName[0] = 0;
        cbData = sizeof(szImeFileName);
        RegQueryValueExW(hkeyIME, L"Ime File", NULL, NULL, (LPBYTE)szImeFileName, &cbData);
        szImeFileName[_countof(szImeFileName) - 1] = 0;

        RegCloseKey(hkeyIME);

        /* We don't allow the invalid "IME File" values for security reason */
        if (!szImeFileName[0] || wcscspn(szImeFileName, L":\\/") != wcslen(szImeFileName))
            break;

        Imm32StrToUInt(szImeKey, &Value, 16);
        hKL = (HKL)(DWORD_PTR)Value;
        if (!IS_IME_HKL(hKL))
            break;

        /* Store the IME key and the IME filename */
        pLayouts[nCount].hKL = hKL;
        StringCchCopyW(pLayouts[nCount].szImeKey, _countof(pLayouts[nCount].szImeKey), szImeKey);
        CharUpperW(szImeFileName);
        StringCchCopyW(pLayouts[nCount].szFileName, _countof(pLayouts[nCount].szFileName),
                       szImeFileName);
        ++nCount;
    }

    RegCloseKey(hkeyLayouts);
    return nCount;
}

Referenced by ImmInstallIMEW().

Imm32GetSystemLibraryPath()

BOOL Imm32GetSystemLibraryPath	(	LPWSTR	pszPath,
		DWORD	cchPath,
		LPCWSTR	pszFileName
	)

Definition at line 243 of file utils.c.

{
    if (!pszFileName[0] || !GetSystemDirectoryW(pszPath, cchPath))
        return FALSE;
    StringCchCatW(pszPath, cchPath, L"\\");
    StringCchCatW(pszPath, cchPath, pszFileName);
    return TRUE;
}

Referenced by Imm32CopyImeFile(), Imm32LoadIME(), Imm32LoadImeVerInfo(), and ImmInstallIMEW().

Imm32ImeMenuAnsiToWide()

INT APIENTRY Imm32ImeMenuAnsiToWide	(	const IMEMENUITEMINFOA *	pItemA,
		LPIMEMENUITEMINFOW	pItemW,
		UINT	uCodePage,
		BOOL	bBitmap
	)

Definition at line 440 of file utils.c.

{
    INT ret;
    pItemW->cbSize = pItemA->cbSize;
    pItemW->fType = pItemA->fType;
    pItemW->fState = pItemA->fState;
    pItemW->wID = pItemA->wID;
    if (bBitmap)
    {
        pItemW->hbmpChecked = pItemA->hbmpChecked;
        pItemW->hbmpUnchecked = pItemA->hbmpUnchecked;
        pItemW->hbmpItem = pItemA->hbmpItem;
    }
    pItemW->dwItemData = pItemA->dwItemData;
    ret = MultiByteToWideChar(uCodePage, 0, pItemA->szString, -1,
                              pItemW->szString, _countof(pItemW->szString));
    if (ret >= _countof(pItemW->szString))
    {
        ret = 0;
        pItemW->szString[0] = 0;
    }
    return ret;
}

Referenced by ImmGetImeMenuItemsAW().

Imm32ImeMenuWideToAnsi()

INT APIENTRY Imm32ImeMenuWideToAnsi	(	const IMEMENUITEMINFOW *	pItemW,
		LPIMEMENUITEMINFOA	pItemA,
		UINT	uCodePage
	)

Definition at line 467 of file utils.c.

{
    INT ret;
    pItemA->cbSize = pItemW->cbSize;
    pItemA->fType = pItemW->fType;
    pItemA->fState = pItemW->fState;
    pItemA->wID = pItemW->wID;
    pItemA->hbmpChecked = pItemW->hbmpChecked;
    pItemA->hbmpUnchecked = pItemW->hbmpUnchecked;
    pItemA->dwItemData = pItemW->dwItemData;
    pItemA->hbmpItem = pItemW->hbmpItem;
    ret = WideCharToMultiByte(uCodePage, 0, pItemW->szString, -1,
                              pItemA->szString, _countof(pItemA->szString), NULL, NULL);
    if (ret >= _countof(pItemA->szString))
    {
        ret = 0;
        pItemA->szString[0] = 0;
    }
    return ret;
}

Referenced by ImmGetImeMenuItemsAW().

Imm32InternalLockIMC()

LPINPUTCONTEXT APIENTRY Imm32InternalLockIMC	(	HIMC	hIMC,
		BOOL	fSelect
	)

Definition at line 808 of file imm.c.

{
    HANDLE hIC;
    LPINPUTCONTEXT pIC = NULL;
    PCLIENTIMC pClientImc;
    WORD LangID;
    DWORD dwThreadId;
    HKL hOldKL, hNewKL;
    PIMEDPI pImeDpi = NULL;

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

    RtlEnterCriticalSection(&pClientImc->cs);

    if (pClientImc->hInputContext)
    {
        pIC = LocalLock(pClientImc->hInputContext);
        if (pIC)
            goto Success;
        else
            goto Failure;
    }

    dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    if (dwThreadId == GetCurrentThreadId() && IS_CICERO_MODE() && !IS_16BIT_MODE())
    {
        hOldKL = GetKeyboardLayout(0);
        LangID = LOWORD(hOldKL);
        hNewKL = (HKL)(DWORD_PTR)MAKELONG(LangID, LangID);

        pImeDpi = Imm32FindOrLoadImeDpi(hNewKL);
        if (pImeDpi)
        {
            CtfImmTIMActivate(hNewKL);
        }
    }

    if (!NtUserQueryInputContext(hIMC, QIC_DEFAULTWINDOWIME))
        goto Failure;

    hIC = LocalAlloc(LHND, sizeof(INPUTCONTEXTDX));
    pIC = LocalLock(hIC);
    if (!pIC)
    {
        LocalFree(hIC);
        goto Failure;
    }
    pClientImc->hInputContext = hIC;

    hNewKL = GetKeyboardLayout(dwThreadId);
    if (!Imm32CreateInputContext(hIMC, pIC, pClientImc, hNewKL, fSelect))
    {
        pClientImc->hInputContext = LocalFree(pClientImc->hInputContext);
        goto Failure;
    }

Success:
    CtfImmTIMCreateInputContext(hIMC);
    RtlLeaveCriticalSection(&pClientImc->cs);
    InterlockedIncrement(&pClientImc->cLockObj);
    ImmUnlockClientImc(pClientImc);
    return pIC;

Failure:
    RtlLeaveCriticalSection(&pClientImc->cs);
    ImmUnlockClientImc(pClientImc);
    return NULL;
}

Referenced by Imm32SelectInputContext(), and ImmLockIMC().

Imm32IsCrossProcessAccess()

static BOOL Imm32IsCrossProcessAccess ( HWND  hWnd )

inlinestatic

Definition at line 108 of file precomp.h.

{
    return (NtUserQueryWindow(hWnd, QUERY_WINDOW_UNIQUE_PROCESS_ID) !=
            (DWORD_PTR)NtCurrentTeb()->ClientId.UniqueProcess);
}

Referenced by ImmConfigureIMEA(), ImmConfigureIMEW(), and ImmGetSaveContext().

Imm32IsCrossThreadAccess()

static BOOL Imm32IsCrossThreadAccess ( HIMC  hIMC )

inlinestatic

Definition at line 100 of file precomp.h.

{
    DWORD dwImeThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    DWORD dwThreadId = GetCurrentThreadId();
    return (dwImeThreadId != dwThreadId);
}

Referenced by Imm32ProcessHotKey(), ImmAssociateContext(), ImmAssociateContextEx(), ImmDestroyContext(), ImmGenerateMessage(), ImmNotifyIME(), ImmRequestMessageAW(), ImmSetCandidateWindow(), ImmSetCompositionFontA(), ImmSetCompositionFontW(), ImmSetCompositionWindow(), ImmSetConversionStatus(), ImmSetOpenStatus(), and ImmSetStatusWindowPos().

Imm32IsImcAnsi()

BOOL WINAPI Imm32IsImcAnsi

(

HIMC

hIMC

)

Definition at line 175 of file utils.c.

{
    BOOL ret;
    PCLIENTIMC pClientImc = ImmLockClientImc(hIMC);
    if (!pClientImc)
        return -1;
    ret = !(pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);
    return ret;
}

Referenced by ImmGetImeMenuItemsAW().

Imm32IsSystemJapaneseOrKorean()

BOOL APIENTRY Imm32IsSystemJapaneseOrKorean

(

VOID

)

Definition at line 45 of file utils.c.

{
    LCID lcid = GetSystemDefaultLCID();
    LANGID LangID = LANGIDFROMLCID(lcid);
    WORD wPrimary = PRIMARYLANGID(LangID);
    return (wPrimary == LANG_JAPANESE || wPrimary == LANG_KOREAN);
}

Referenced by ImmWINNLSEnableIME(), and ImmWINNLSGetEnableStatus().

Imm32LoadBitmapFromBytes()

HBITMAP Imm32LoadBitmapFromBytes

(

const BYTE *

pb

)

Definition at line 59 of file utils.c.

{
    HBITMAP hbm = NULL;
    const BITMAPCOREINFO256 *pbmci;
    LPVOID pvBits;
    DWORD ib, cbBytes, cColors;
    BITMAP bm;

    cbBytes = *(const DWORD *)pb;
    if (cbBytes == 0)
        return NULL;

    pb += sizeof(DWORD);
    ib = sizeof(DWORD);

    pbmci = (const BITMAPCOREINFO256 *)pb;
    hbm = CreateDIBSection(NULL, (LPBITMAPINFO)pbmci, DIB_RGB_COLORS, &pvBits, NULL, 0);
    if (!hbm || !GetObject(hbm, sizeof(BITMAP), &bm))
        return NULL;

    switch (pbmci->bmciHeader.bcBitCount)
    {
        case 1: cColors = 2; break;
        case 4: cColors = 16; break;
        case 8: cColors = 256; break;
        case 24: case 32:
            cColors = 0;
            break;
        default:
            DeleteObject(hbm);
            return NULL;
    }

    ib += sizeof(BITMAPCOREHEADER);
    pb += sizeof(BITMAPCOREHEADER);

    ib += cColors * sizeof(RGBTRIPLE);
    pb += cColors * sizeof(RGBTRIPLE);

    ib += bm.bmWidthBytes * bm.bmHeight;
    if (ib > cbBytes)
    {
        DeleteObject(hbm);
        return NULL;
    }
    CopyMemory(pvBits, pb, bm.bmWidthBytes * bm.bmHeight);

    return hbm;
}

Referenced by Imm32GetImeMenuItemWInterProcess().

Imm32LoadImeStateSentence()

BOOL APIENTRY Imm32LoadImeStateSentence	(	LPINPUTCONTEXTDX	pIC,
		PIME_STATE	pState,
		HKL	hKL
	)

Definition at line 535 of file utils.c.

{
    PIME_SUBSTATE pSubState = Imm32FetchImeSubState(pState, hKL);
    if (pSubState)
    {
        pIC->fdwSentence |= pSubState->dwValue;
        return TRUE;
    }
    return FALSE;
}

Referenced by Imm32SelectInputContext().

Imm32LoadImeVerInfo()

BOOL APIENTRY Imm32LoadImeVerInfo

(

PIMEINFOEX

pImeInfoEx

)

Definition at line 763 of file utils.c.

{
    HINSTANCE hinstVersion;
    BOOL ret = FALSE, bLoaded = FALSE;
    WCHAR szPath[MAX_PATH];
    LPVOID pVerInfo;
    DWORD cbVerInfo, dwHandle;

    /* Load version.dll to use the version info API */
    Imm32GetSystemLibraryPath(szPath, _countof(szPath), L"version.dll");
    hinstVersion = GetModuleHandleW(szPath);
    if (!hinstVersion)
    {
        hinstVersion = LoadLibraryW(szPath);
        if (!hinstVersion)
            return FALSE;

        bLoaded = TRUE;
    }

#define GET_FN(name) do { \
    s_fn##name = (FN_##name)GetProcAddress(hinstVersion, #name); \
    if (!s_fn##name) goto Quit; \
} while (0)
    GET_FN(GetFileVersionInfoW);
    GET_FN(GetFileVersionInfoSizeW);
    GET_FN(VerQueryValueW);
#undef GET_FN

    /* The path of the IME module */
    Imm32GetSystemLibraryPath(szPath, _countof(szPath), pImeInfoEx->wszImeFile);

    cbVerInfo = s_fnGetFileVersionInfoSizeW(szPath, &dwHandle);
    if (!cbVerInfo)
        goto Quit;

    pVerInfo = ImmLocalAlloc(0, cbVerInfo);
    if (!pVerInfo)
        goto Quit;

    /* Load the version info of the IME module */
    if (s_fnGetFileVersionInfoW(szPath, dwHandle, cbVerInfo, pVerInfo) &&
        Imm32LoadImeFixedInfo(pImeInfoEx, pVerInfo))
    {
        ret = Imm32LoadImeLangAndDesc(pImeInfoEx, pVerInfo);
    }

    ImmLocalFree(pVerInfo);

Quit:
    if (bLoaded)
        FreeLibrary(hinstVersion);
    return ret;
}

Referenced by ImmInstallIMEW(), and ImmLoadLayout().

Imm32MakeIMENotify()

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

Definition at line 368 of file utils.c.

{
    DWORD dwThreadId;
    HKL hKL;
    PIMEDPI pImeDpi;

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

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

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

    return TRUE;
}

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

Imm32ReconvertAnsiFromWide()

DWORD APIENTRY Imm32ReconvertAnsiFromWide	(	LPRECONVERTSTRING	pDest,
		const RECONVERTSTRING *	pSrc,
		UINT	uCodePage
	)

Definition at line 625 of file utils.c.

{
    DWORD cch0, cch1, cchDest, cbDest;
    LPCWSTR pchSrc = (LPCWSTR)((LPCSTR)pSrc + pSrc->dwStrOffset);
    LPSTR pchDest;

    if (pSrc->dwVersion != 0)
        return 0;

    cchDest = WideCharToMultiByte(uCodePage, 0, pchSrc, pSrc->dwStrLen,
                                  NULL, 0, NULL, NULL);
    cbDest = sizeof(RECONVERTSTRING) + (cchDest + 1) * sizeof(CHAR);
    if (!pDest)
        return cbDest;

    if (pDest->dwSize < cbDest)
        return 0;

    /* dwSize */
    pDest->dwSize = cbDest;

    /* dwVersion */
    pDest->dwVersion = 0;

    /* dwStrOffset */
    pDest->dwStrOffset = sizeof(RECONVERTSTRING);

    /* dwCompStrOffset */
    cch1 = pSrc->dwCompStrOffset / sizeof(WCHAR);
    cch0 = IchAnsiFromWide(cch1, pchSrc, uCodePage);
    pDest->dwCompStrOffset = cch0 * sizeof(CHAR);

    /* dwCompStrLen */
    cch0 = IchAnsiFromWide(cch1 + pSrc->dwCompStrLen, pchSrc, uCodePage);
    pDest->dwCompStrLen = cch0 * sizeof(CHAR) - pDest->dwCompStrOffset;

    /* dwTargetStrOffset */
    cch1 = pSrc->dwTargetStrOffset / sizeof(WCHAR);
    cch0 = IchAnsiFromWide(cch1, pchSrc, uCodePage);
    pDest->dwTargetStrOffset = cch0 * sizeof(CHAR);

    /* dwTargetStrLen */
    cch0 = IchAnsiFromWide(cch1 + pSrc->dwTargetStrLen, pchSrc, uCodePage);
    pDest->dwTargetStrLen = cch0 * sizeof(CHAR) - pDest->dwTargetStrOffset;

    /* dwStrLen */
    pDest->dwStrLen = cchDest;

    /* the string */
    pchDest = (LPSTR)pDest + pDest->dwStrOffset;
    cchDest = WideCharToMultiByte(uCodePage, 0, pchSrc, pSrc->dwStrLen,
                                  pchDest, cchDest, NULL, NULL);
    pchDest[cchDest] = 0;

    return cbDest;
}

Referenced by Imm32ProcessRequest(), and ImmSetCompositionStringAW().

Imm32ReconvertWideFromAnsi()

DWORD APIENTRY Imm32ReconvertWideFromAnsi	(	LPRECONVERTSTRING	pDest,
		const RECONVERTSTRING *	pSrc,
		UINT	uCodePage
	)

Definition at line 569 of file utils.c.

{
    DWORD cch0, cchDest, cbDest;
    LPCSTR pchSrc = (LPCSTR)pSrc + pSrc->dwStrOffset;
    LPWSTR pchDest;

    if (pSrc->dwVersion != 0)
        return 0;

    cchDest = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, pchSrc, pSrc->dwStrLen,
                                  NULL, 0);
    cbDest = sizeof(RECONVERTSTRING) + (cchDest + 1) * sizeof(WCHAR);
    if (!pDest)
        return cbDest;

    if (pDest->dwSize < cbDest)
        return 0;

    /* dwSize */
    pDest->dwSize = cbDest;

    /* dwVersion */
    pDest->dwVersion = 0;

    /* dwStrOffset */
    pDest->dwStrOffset = sizeof(RECONVERTSTRING);

    /* dwCompStrOffset */
    cch0 = IchWideFromAnsi(pSrc->dwCompStrOffset, pchSrc, uCodePage);
    pDest->dwCompStrOffset = cch0 * sizeof(WCHAR);

    /* dwCompStrLen */
    cch0 = IchWideFromAnsi(pSrc->dwCompStrOffset + pSrc->dwCompStrLen, pchSrc, uCodePage);
    pDest->dwCompStrLen = (cch0 * sizeof(WCHAR) - pDest->dwCompStrOffset) / sizeof(WCHAR);

    /* dwTargetStrOffset */
    cch0 = IchWideFromAnsi(pSrc->dwTargetStrOffset, pchSrc, uCodePage);
    pDest->dwTargetStrOffset = cch0 * sizeof(WCHAR);

    /* dwTargetStrLen */
    cch0 = IchWideFromAnsi(pSrc->dwTargetStrOffset + pSrc->dwTargetStrLen, pchSrc, uCodePage);
    pDest->dwTargetStrLen = (cch0 * sizeof(WCHAR) - pSrc->dwTargetStrOffset) / sizeof(WCHAR);

    /* dwStrLen */
    pDest->dwStrLen = cchDest;

    /* the string */
    pchDest = (LPWSTR)((LPBYTE)pDest + pDest->dwStrOffset);
    cchDest = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, pchSrc, pSrc->dwStrLen,
                                  pchDest, cchDest);
    pchDest[cchDest] = 0;

    return cbDest;
}

Referenced by Imm32ProcessRequest(), and ImmSetCompositionStringAW().

Imm32ReleaseIME()

BOOL APIENTRY Imm32ReleaseIME

(

HKL

hKL

)

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

Imm32SaveImeStateSentence()

BOOL APIENTRY Imm32SaveImeStateSentence	(	LPINPUTCONTEXTDX	pIC,
		PIME_STATE	pState,
		HKL	hKL
	)

Definition at line 548 of file utils.c.

{
    PIME_SUBSTATE pSubState = Imm32FetchImeSubState(pState, hKL);
    if (pSubState)
    {
        pSubState->dwValue = (pIC->fdwSentence & 0xffff0000);
        return TRUE;
    }
    return FALSE;
}

Referenced by Imm32SelectInputContext().

Imm32StoreBitmapToBytes()

BOOL Imm32StoreBitmapToBytes	(	HBITMAP	hbm,
		LPBYTE	pbData,
		DWORD	cbDataMax
	)

Definition at line 109 of file utils.c.

{
    HDC hDC;
    BITMAP bm;
    DWORD cbBytes, cColors;
    BITMAPCOREINFO256 bmci;
    BOOL ret;
    LPBYTE pb = pbData;

    *(LPDWORD)pb = 0;

    if (!GetObject(hbm, sizeof(BITMAP), &bm))
        return FALSE;

    ZeroMemory(&bmci, sizeof(bmci));
    bmci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);
    bmci.bmciHeader.bcWidth = bm.bmWidth;
    bmci.bmciHeader.bcHeight = bm.bmHeight;
    bmci.bmciHeader.bcPlanes = 1;
    bmci.bmciHeader.bcBitCount = bm.bmBitsPixel;

    switch (bm.bmBitsPixel)
    {
        case 1: cColors = 2; break;
        case 4: cColors = 16; break;
        case 8: cColors = 256; break;
        case 24: case 32:
            cColors = 0;
            break;
        default:
            return FALSE;
    }

    cbBytes = sizeof(DWORD);
    cbBytes += sizeof(BITMAPCOREHEADER);
    cbBytes += cColors * sizeof(RGBTRIPLE);
    cbBytes += bm.bmWidthBytes * bm.bmHeight;
    if (cbBytes > cbDataMax)
        return FALSE;

    hDC = CreateCompatibleDC(NULL);

    ret = GetDIBits(hDC, hbm, 0, bm.bmHeight, NULL, (LPBITMAPINFO)&bmci, DIB_RGB_COLORS);

    if (ret)
    {
        *(LPDWORD)pb = cbBytes;
        pb += sizeof(DWORD);

        CopyMemory(pb, &bmci.bmciHeader, sizeof(BITMAPCOREHEADER));
        pb += sizeof(BITMAPCOREHEADER);

        CopyMemory(pb, &bmci.bmciColors, cColors * sizeof(RGBTRIPLE));
        pb += cColors * sizeof(RGBTRIPLE);

        ret = GetDIBits(hDC, hbm, 0, bm.bmHeight, pb, (LPBITMAPINFO)&bmci, DIB_RGB_COLORS);
        if (!ret)
            *(LPDWORD)pbData = 0;
    }

    DeleteDC(hDC);

    return ret;
}

Referenced by ImmPutImeMenuItemsIntoMappedFile().

Imm32StrToUInt()

HRESULT APIENTRY Imm32StrToUInt	(	LPCWSTR	pszText,
		LPDWORD	pdwValue,
		ULONG	nBase
	)

Definition at line 20 of file utils.c.

{
    NTSTATUS Status;
    UNICODE_STRING UnicodeString;
    RtlInitUnicodeString(&UnicodeString, pszText);
    Status = RtlUnicodeStringToInteger(&UnicodeString, nBase, pdwValue);
    if (!NT_SUCCESS(Status))
        return E_FAIL;
    return S_OK;
}

Referenced by Imm32GetImeLayout().

Imm32UIntToStr()

HRESULT APIENTRY Imm32UIntToStr	(	DWORD	dwValue,
		ULONG	nBase,
		LPWSTR	pszBuff,
		USHORT	cchBuff
	)

Definition at line 33 of file utils.c.

{
    NTSTATUS Status;
    UNICODE_STRING UnicodeString;
    UnicodeString.Buffer = pszBuff;
    UnicodeString.MaximumLength = cchBuff * sizeof(WCHAR);
    Status = RtlIntegerToUnicodeString(dwValue, nBase, &UnicodeString);
    if (!NT_SUCCESS(Status))
        return E_FAIL;
    return S_OK;
}

Referenced by Imm32WriteImeLayout(), and ImmInstallIMEW().

Imm32WideFromAnsi()

LPWSTR APIENTRY Imm32WideFromAnsi

(

LPCSTR

pszA

)

Definition at line 186 of file utils.c.

{
    INT cch = lstrlenA(pszA);
    LPWSTR pszW = ImmLocalAlloc(0, (cch + 1) * sizeof(WCHAR));
    if (pszW == NULL)
        return NULL;
    cch = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pszA, cch, pszW, cch + 1);
    pszW[cch] = 0;
    return pszW;
}

Referenced by Imm32EnumWordProcA2W(), ImmConfigureIMEA(), ImmEnumRegisterWordA(), ImmGetConversionListA(), ImmInstallIMEA(), ImmRegisterWordA(), and ImmUnregisterWordA().

Imm32WriteImeLayout()

BOOL APIENTRY Imm32WriteImeLayout	(	HKL	hKL,
		LPCWSTR	pchFilePart,
		LPCWSTR	pszLayout
	)

Definition at line 934 of file utils.c.

{
    UINT iPreload;
    HKEY hkeyLayouts, hkeyIME, hkeyPreload;
    WCHAR szImeKey[20], szPreloadNumber[20], szPreloadKey[20], szImeFileName[80];
    DWORD cbData;
    LANGID LangID;
    LONG lError;
    LPCWSTR pszLayoutFile;

    /* Open the registry keyboard layouts */
    lError = RegOpenKeyW(HKEY_LOCAL_MACHINE, REGKEY_KEYBOARD_LAYOUTS, &hkeyLayouts);
    if (lError != ERROR_SUCCESS)
        return FALSE;

    /* Get the IME key from hKL */
    Imm32UIntToStr((DWORD)(DWORD_PTR)hKL, 16, szImeKey, _countof(szImeKey));

    /* Create a registry IME key */
    lError = RegCreateKeyW(hkeyLayouts, szImeKey, &hkeyIME);
    if (lError != ERROR_SUCCESS)
        goto Failure;

    /* Write "Ime File" */
    cbData = (wcslen(pchFilePart) + 1) * sizeof(WCHAR);
    lError = RegSetValueExW(hkeyIME, L"Ime File", 0, REG_SZ, (LPBYTE)pchFilePart, cbData);
    if (lError != ERROR_SUCCESS)
        goto Failure;

    /* Write "Layout Text" */
    cbData = (wcslen(pszLayout) + 1) * sizeof(WCHAR);
    lError = RegSetValueExW(hkeyIME, L"Layout Text", 0, REG_SZ, (LPBYTE)pszLayout, cbData);
    if (lError != ERROR_SUCCESS)
        goto Failure;

    /* Choose "Layout File" from hKL */
    LangID = LOWORD(hKL);
    switch (LOBYTE(LangID))
    {
        case LANG_JAPANESE: pszLayoutFile = L"kbdjpn.dll"; break;
        case LANG_KOREAN:   pszLayoutFile = L"kbdkor.dll"; break;
        default:            pszLayoutFile = L"kbdus.dll"; break;
    }
    StringCchCopyW(szImeFileName, _countof(szImeFileName), pszLayoutFile);

    /* Write "Layout File" */
    cbData = (wcslen(szImeFileName) + 1) * sizeof(WCHAR);
    lError = RegSetValueExW(hkeyIME, L"Layout File", 0, REG_SZ, (LPBYTE)szImeFileName, cbData);
    if (lError != ERROR_SUCCESS)
        goto Failure;

    RegCloseKey(hkeyIME);
    RegCloseKey(hkeyLayouts);

    /* Create "Preload" key */
    RegCreateKeyW(HKEY_CURRENT_USER, L"Keyboard Layout\\Preload", &hkeyPreload);

#define MAX_PRELOAD 0x400
    for (iPreload = 1; iPreload < MAX_PRELOAD; ++iPreload)
    {
        Imm32UIntToStr(iPreload, 10, szPreloadNumber, _countof(szPreloadNumber));

        /* Load the key of the preload number */
        cbData = sizeof(szPreloadKey);
        lError = RegQueryValueExW(hkeyPreload, szPreloadNumber, NULL, NULL,
                                  (LPBYTE)szPreloadKey, &cbData);
        szPreloadKey[_countof(szPreloadKey) - 1] = 0;

        if (lError != ERROR_SUCCESS || lstrcmpiW(szImeKey, szPreloadKey) == 0)
            break; /* Found an empty room or the same key */
    }

    if (iPreload >= MAX_PRELOAD) /* Not found */
    {
        RegCloseKey(hkeyPreload);
        return FALSE;
    }
#undef MAX_PRELOAD

    /* Write the IME key to the preload number */
    cbData = (wcslen(szImeKey) + 1) * sizeof(WCHAR);
    lError = RegSetValueExW(hkeyPreload, szPreloadNumber, 0, REG_SZ, (LPBYTE)szImeKey, cbData);
    RegCloseKey(hkeyPreload);
    return lError == ERROR_SUCCESS;

Failure:
    RegCloseKey(hkeyIME);
    RegDeleteKeyW(hkeyLayouts, szImeKey);
    RegCloseKey(hkeyLayouts);
    return FALSE;
}

Referenced by ImmInstallIMEW().

ImmLocalAlloc()

LPVOID APIENTRY ImmLocalAlloc	(	DWORD	dwFlags,
		DWORD	dwBytes
	)

Definition at line 355 of file utils.c.

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

Referenced by CtfImmSetLangBand(), Imm32AnsiFromWide(), Imm32BuildHimcList(), Imm32FetchImeState(), Imm32FetchImeSubState(), Imm32LoadImeDpi(), Imm32LoadImeVerInfo(), Imm32PostMessages(), Imm32ProcessRequest(), Imm32WideFromAnsi(), ImmCreateContext(), ImmFreeLayout(), ImmGenerateMessage(), ImmGetConversionListA(), ImmGetConversionListW(), ImmGetImeMenuItemsAW(), ImmGetRegisterWordStyleA(), ImmGetRegisterWordStyleW(), ImmInstallIMEW(), ImmLockClientImc(), ImmPutImeMenuItemsIntoMappedFile(), ImmSetCompositionStringAW(), and ImmTranslateMessage().

LogFontAnsiToWide()

VOID APIENTRY LogFontAnsiToWide	(	const LOGFONTA *	plfA,
		LPLOGFONTW	plfW
	)

Definition at line 253 of file utils.c.

{
    size_t cch;
    RtlCopyMemory(plfW, plfA, offsetof(LOGFONTA, lfFaceName));
    StringCchLengthA(plfA->lfFaceName, _countof(plfA->lfFaceName), &cch);
    cch = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, plfA->lfFaceName, (INT)cch,
                              plfW->lfFaceName, _countof(plfW->lfFaceName));
    if (cch > _countof(plfW->lfFaceName) - 1)
        cch = _countof(plfW->lfFaceName) - 1;
    plfW->lfFaceName[cch] = 0;
}

Referenced by Imm32ProcessRequest(), Imm32SelectInputContext(), ImmGetCompositionFontW(), and ImmSetCompositionFontA().

LogFontWideToAnsi()

VOID APIENTRY LogFontWideToAnsi	(	const LOGFONTW *	plfW,
		LPLOGFONTA	plfA
	)

Definition at line 266 of file utils.c.

{
    size_t cch;
    RtlCopyMemory(plfA, plfW, offsetof(LOGFONTW, lfFaceName));
    StringCchLengthW(plfW->lfFaceName, _countof(plfW->lfFaceName), &cch);
    cch = WideCharToMultiByte(CP_ACP, 0, plfW->lfFaceName, (INT)cch,
                              plfA->lfFaceName, _countof(plfA->lfFaceName), NULL, NULL);
    if (cch > _countof(plfA->lfFaceName) - 1)
        cch = _countof(plfA->lfFaceName) - 1;
    plfA->lfFaceName[cch] = 0;
}

Referenced by Imm32ProcessRequest(), Imm32SelectInputContext(), ImmGetCompositionFontA(), and ImmSetCompositionFontW().

ValidateHandle()

LPVOID FASTCALL ValidateHandle	(	HANDLE	hObject,
		UINT	uType
	)

Definition at line 328 of file utils.c.

{
    LPVOID pvObj = ValidateHandleNoErr(hObject, uType);
    if (pvObj)
        return pvObj;

    if (uType == TYPE_WINDOW)
        SetLastError(ERROR_INVALID_WINDOW_HANDLE);
    else
        SetLastError(ERROR_INVALID_HANDLE);
    return NULL;
}

Referenced by CheckMenuItem(), GetMenuContextHelpId(), GetMenuDefaultItem(), GetMenuInfo(), GetMenuItemCount(), GetThemeBool(), GetThemeColor(), GetThemeEnumValue(), GetThemeFilename(), GetThemeFont(), GetThemeInt(), GetThemeIntList(), GetThemeMargins(), GetThemeMetric(), GetThemePosition(), GetThemePropertyOrigin(), GetThemeRect(), GetThemeString(), GetThemeSysBool(), GetThemeSysColor(), GetThemeSysFont(), GetThemeSysInt(), GetThemeSysSize(), GetThemeSysString(), Imm32DestroyInputContext(), ImmLockClientImc(), IsMenu(), User32CanSetImeWindowToImc(), User32SetImeWindowOfImc(), UXTHEME_LoadImage(), and UXTHEME_SelectImage().

ValidateHandleNoErr()

LPVOID FASTCALL ValidateHandleNoErr	(	HANDLE	hObject,
		UINT	uType
	)

Definition at line 292 of file utils.c.

{
    UINT index;
    PUSER_HANDLE_TABLE ht;
    PUSER_HANDLE_ENTRY he;
    WORD generation;
    LPVOID ptr;

    if (!NtUserValidateHandleSecure(hObject))
        return NULL;

    ht = gSharedInfo.aheList; /* handle table */
    ASSERT(ht);
    /* ReactOS-Specific! */
    ASSERT(gSharedInfo.ulSharedDelta != 0);
    he = (PUSER_HANDLE_ENTRY)((ULONG_PTR)ht->handles - gSharedInfo.ulSharedDelta);

    index = (LOWORD(hObject) - FIRST_USER_HANDLE) >> 1;
    if ((INT)index < 0 || ht->nb_handles <= index || he[index].type != uType)
        return NULL;

    if (he[index].flags & HANDLEENTRY_DESTROY)
        return NULL;

    generation = HIWORD(hObject);
    if (generation != he[index].generation && generation && generation != 0xFFFF)
        return NULL;

    ptr = he[index].ptr;
    if (ptr)
        ptr = DesktopPtrToUser(ptr);

    return ptr;
}

Referenced by MENU_GetMenu().

Variable Documentation

gcsImeDpi

RTL_CRITICAL_SECTION gcsImeDpi

Definition at line 16 of file ime.c.

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

ghImm32Inst

HMODULE ghImm32Inst

Definition at line 16 of file imm.c.

Referenced by ImmInitializeGlobals().

ghImmHeap

HANDLE ghImmHeap

Definition at line 16 of file utils.c.

Referenced by ImmLocalAlloc().

gpImeDpiList

PIMEDPI gpImeDpiList

Definition at line 17 of file ime.c.

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

gpsi

PSERVERINFO gpsi

Definition at line 17 of file imm.c.

gSharedInfo

SHAREDINFO gSharedInfo

Definition at line 18 of file imm.c.