utils.c File Reference

#include "precomp.h"

Include dependency graph for utils.c:

Go to the source code of this file.

Macros
#define	INITIAL_COUNT   0x40
#define	MAX_RETRY   10
#define	GET_FN(name)
#define	MAX_PRELOAD   0x400
#define	GET_FN(name)

Typedefs
typedef BOOL(WINAPI *	FN_GetFileVersionInfoW) (LPCWSTR, DWORD, DWORD, LPVOID)
typedef DWORD(WINAPI *	FN_GetFileVersionInfoSizeW) (LPCWSTR, LPDWORD)
typedef BOOL(WINAPI *	FN_VerQueryValueW) (LPCVOID, LPCWSTR, LPVOID *, PUINT)
typedef INT(WINAPI *	FN_LZOpenFileW) (LPWSTR, LPOFSTRUCT, WORD)
typedef LONG(WINAPI *	FN_LZCopy) (INT, INT)
typedef VOID(WINAPI *	FN_LZClose) (INT)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
HRESULT APIENTRY	Imm32StrToUInt (LPCWSTR pszText, LPDWORD pdwValue, ULONG nBase)
HRESULT APIENTRY	Imm32UIntToStr (DWORD dwValue, ULONG nBase, LPWSTR pszBuff, USHORT cchBuff)
BOOL WINAPI	Imm32IsImcAnsi (HIMC hIMC)
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)
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)
PWND FASTCALL	ValidateHwndNoErr (HWND hwnd)
BOOL APIENTRY	Imm32CheckImcProcess (PIMC pIMC)
LPVOID APIENTRY	Imm32HeapAlloc (DWORD dwFlags, DWORD dwBytes)
BOOL APIENTRY	Imm32NotifyAction (HIMC hIMC, HWND hwnd, DWORD dwAction, DWORD_PTR dwIndex, DWORD_PTR dwValue, DWORD_PTR dwCommand, DWORD_PTR dwData)
DWORD APIENTRY	Imm32AllocAndBuildHimcList (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	Imm32ReconvertWideFromAnsi (LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
DWORD APIENTRY	Imm32ReconvertAnsiFromWide (LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
static BOOL APIENTRY	Imm32LoadImeFixedInfo (PIMEINFOEX pInfoEx, LPCVOID pVerInfo)
static LPWSTR APIENTRY	Imm32GetVerInfoValue (LPCVOID pVerInfo, LPWSTR pszKey, DWORD cchKey, LPCWSTR pszName)
BOOL APIENTRY	Imm32LoadImeLangAndDesc (PIMEINFOEX pInfoEx, LPCVOID pVerInfo)
BOOL APIENTRY	Imm32LoadImeVerInfo (PIMEINFOEX pImeInfoEx)
HKL APIENTRY	Imm32GetNextHKL (UINT cKLs, const REG_IME *pLayouts, WORD wLangID)
UINT APIENTRY	Imm32GetRegImes (PREG_IME pLayouts, UINT cLayouts)
BOOL APIENTRY	Imm32WriteRegIme (HKL hKL, LPCWSTR pchFilePart, LPCWSTR pszLayout)
BOOL APIENTRY	Imm32CopyFile (LPWSTR pszOldFile, LPCWSTR pszNewFile)
BOOL WINAPI	CtfImmIsTextFrameServiceDisabled (VOID)
HIMCC WINAPI	ImmCreateIMCC (DWORD size)
HIMCC WINAPI	ImmDestroyIMCC (HIMCC block)
LPVOID WINAPI	ImmLockIMCC (HIMCC imcc)
BOOL WINAPI	ImmUnlockIMCC (HIMCC imcc)
DWORD WINAPI	ImmGetIMCCLockCount (HIMCC imcc)
HIMCC WINAPI	ImmReSizeIMCC (HIMCC imcc, DWORD size)
DWORD WINAPI	ImmGetIMCCSize (HIMCC imcc)
DWORD WINAPI	ImmGetIMCLockCount (HIMC hIMC)
BOOL WINAPI	ImmIMPGetIMEA (HWND hWnd, LPIMEPROA pImePro)
BOOL WINAPI	ImmIMPGetIMEW (HWND hWnd, LPIMEPROW pImePro)
BOOL WINAPI	ImmIMPQueryIMEA (LPIMEPROA pImePro)
BOOL WINAPI	ImmIMPQueryIMEW (LPIMEPROW pImePro)
BOOL WINAPI	ImmIMPSetIMEA (HWND hWnd, LPIMEPROA pImePro)
BOOL WINAPI	ImmIMPSetIMEW (HWND hWnd, LPIMEPROW pImePro)

Variables
HANDLE	g_hImm32Heap = NULL
static FN_GetFileVersionInfoW	s_fnGetFileVersionInfoW = NULL
static FN_GetFileVersionInfoSizeW	s_fnGetFileVersionInfoSizeW = NULL
static FN_VerQueryValueW	s_fnVerQueryValueW = NULL

Macro Definition Documentation

GET_FN [1/2]

#define GET_FN

(

name

)

Value:

do { \
    s_fn##name = (FN_##name)GetProcAddress(hinstVersion, #name); \
    if (!s_fn##name) goto Quit; \
} while (0)

GET_FN [2/2]

#define GET_FN

(

name

)

Value:

do { \
    fn##name = (FN_##name)GetProcAddress(hinstLZ32, #name); \
    if (!fn##name) goto Quit; \
} while (0)

INITIAL_COUNT

#define INITIAL_COUNT   0x40

MAX_PRELOAD

#define MAX_PRELOAD   0x400

MAX_RETRY

#define MAX_RETRY   10

Typedef Documentation

FN_GetFileVersionInfoSizeW

typedef DWORD(WINAPI * FN_GetFileVersionInfoSizeW) (LPCWSTR, LPDWORD)

Definition at line 513 of file utils.c.

FN_GetFileVersionInfoW

typedef BOOL(WINAPI * FN_GetFileVersionInfoW) (LPCWSTR, DWORD, DWORD, LPVOID)

Definition at line 512 of file utils.c.

FN_LZClose

typedef VOID(WINAPI * FN_LZClose) (INT)

Definition at line 849 of file utils.c.

FN_LZCopy

typedef LONG(WINAPI * FN_LZCopy) (INT, INT)

Definition at line 848 of file utils.c.

FN_LZOpenFileW

typedef INT(WINAPI * FN_LZOpenFileW) (LPWSTR, LPOFSTRUCT, WORD)

Definition at line 847 of file utils.c.

FN_VerQueryValueW

typedef BOOL(WINAPI * FN_VerQueryValueW) (LPCVOID, LPCWSTR, LPVOID *, PUINT)

Definition at line 514 of file utils.c.

Function Documentation

CtfImmIsTextFrameServiceDisabled()

BOOL WINAPI CtfImmIsTextFrameServiceDisabled

(

VOID

)

Definition at line 909 of file utils.c.

{
    return !!(GetWin32ClientInfo()->CI_flags & CI_TFSDISABLED);
}

Referenced by Imm32SelectLayout(), and ImmGetImeInfoEx().

IchAnsiFromWide()

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

Definition at line 99 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 79 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().

Imm32AllocAndBuildHimcList()

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

Definition at line 236 of file utils.c.

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

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

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

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

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

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

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

Referenced by ImmEnumInputContext().

Imm32AnsiFromWide()

LPSTR APIENTRY Imm32AnsiFromWide

(

LPCWSTR

pszW

)

Definition at line 66 of file utils.c.

{
    INT cchW = lstrlenW(pszW);
    INT cchA = (cchW + 1) * sizeof(WCHAR);
    LPSTR pszA = Imm32HeapAlloc(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().

Imm32CheckImcProcess()

BOOL APIENTRY Imm32CheckImcProcess

(

PIMC

pIMC

)

Definition at line 181 of file utils.c.

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

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

Referenced by ImmLockClientImc().

Imm32CopyFile()

BOOL APIENTRY Imm32CopyFile	(	LPWSTR	pszOldFile,
		LPCWSTR	pszNewFile
	)

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

Imm32FetchImeState()

PIME_STATE APIENTRY Imm32FetchImeState	(	LPINPUTCONTEXTDX	pIC,
		HKL	hKL
	)

Definition at line 324 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 = Imm32HeapAlloc(HEAP_ZERO_MEMORY, sizeof(IME_STATE));
        if (pState)
        {
            pState->wLang = Lang;
            pState->pNext = pIC->pState;
            pIC->pState = pState;
        }
    }
    return pState;
}

Referenced by Imm32SelectLayout().

Imm32FetchImeSubState()

PIME_SUBSTATE APIENTRY Imm32FetchImeSubState	(	PIME_STATE	pState,
		HKL	hKL
	)

Definition at line 347 of file utils.c.

{
    PIME_SUBSTATE pSubState;
    for (pSubState = pState->pSubState; pSubState; pSubState = pSubState->pNext)
    {
        if (pSubState->hKL == hKL)
            return pSubState;
    }
    pSubState = Imm32HeapAlloc(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().

Imm32GetNextHKL()

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

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

Imm32GetRegImes()

UINT APIENTRY Imm32GetRegImes	(	PREG_IME	pLayouts,
		UINT	cLayouts
	)

Definition at line 688 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);

        if (!szImeFileName[0])
            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 111 of file utils.c.

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

Referenced by Imm32CopyFile(), Imm32LoadImeInfo(), Imm32LoadImeVerInfo(), and ImmInstallIMEW().

Imm32GetVerInfoValue()

static LPWSTR APIENTRY Imm32GetVerInfoValue ( LPCVOID  pVerInfo, LPWSTR  pszKey, DWORD  cchKey, LPCWSTR  pszName  )

static

Definition at line 537 of file utils.c.

{
    size_t cchExtra;
    LPWSTR pszValue;
    UINT cbValue = 0;

    StringCchLengthW(pszKey, cchKey, &cchExtra);

    StringCchCatW(pszKey, cchKey, pszName);
    s_fnVerQueryValueW(pVerInfo, pszKey, (LPVOID*)&pszValue, &cbValue);
    pszKey[cchExtra] = 0;

    return (cbValue ? pszValue : NULL);
}

Referenced by Imm32LoadImeLangAndDesc().

Imm32HeapAlloc()

LPVOID APIENTRY Imm32HeapAlloc	(	DWORD	dwFlags,
		DWORD	dwBytes
	)

Definition at line 193 of file utils.c.

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

Referenced by Ime32LoadImeDpi(), Imm32AllocAndBuildHimcList(), Imm32AnsiFromWide(), Imm32FetchImeState(), Imm32FetchImeSubState(), Imm32GetImeMenuItemsAW(), Imm32LoadImeVerInfo(), Imm32PostMessages(), Imm32ProcessRequest(), Imm32SetCompositionStringAW(), Imm32UnknownProcess1(), Imm32WideFromAnsi(), ImmCreateContext(), ImmFreeLayout(), ImmGenerateMessage(), ImmGetConversionListA(), ImmGetConversionListW(), ImmGetRegisterWordStyleA(), ImmGetRegisterWordStyleW(), ImmInstallIMEW(), ImmLockClientImc(), and ImmTranslateMessage().

Imm32ImeMenuAnsiToWide()

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

Definition at line 275 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 Imm32GetImeMenuItemsAW().

Imm32ImeMenuWideToAnsi()

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

Definition at line 301 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 Imm32GetImeMenuItemsAW().

Imm32IsImcAnsi()

BOOL WINAPI Imm32IsImcAnsi

(

HIMC

hIMC

)

Definition at line 44 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 Imm32GetImeMenuItemsAW().

Imm32LoadImeFixedInfo()

static BOOL APIENTRY Imm32LoadImeFixedInfo ( PIMEINFOEX  pInfoEx, LPCVOID  pVerInfo  )

static

Definition at line 520 of file utils.c.

{
    UINT cbFixed = 0;
    VS_FIXEDFILEINFO *pFixed;
    if (!s_fnVerQueryValueW(pVerInfo, L"\\", (LPVOID*)&pFixed, &cbFixed) || !cbFixed)
        return FALSE;

    /* NOTE: The IME module must contain a version info of input method driver. */
    if (pFixed->dwFileType != VFT_DRV || pFixed->dwFileSubtype != VFT2_DRV_INPUTMETHOD)
        return FALSE;

    pInfoEx->dwProdVersion = pFixed->dwProductVersionMS;
    pInfoEx->dwImeWinVersion = 0x40000;
    return TRUE;
}

Referenced by Imm32LoadImeVerInfo().

Imm32LoadImeLangAndDesc()

BOOL APIENTRY Imm32LoadImeLangAndDesc	(	PIMEINFOEX	pInfoEx,
		LPCVOID	pVerInfo
	)

Definition at line 552 of file utils.c.

{
    BOOL ret;
    WCHAR szKey[80];
    LPWSTR pszDesc;
    LPWORD pw;
    UINT cbData;
    LANGID LangID;

    /* Getting the version info. See VerQueryValue */
    ret = s_fnVerQueryValueW(pVerInfo, L"\\VarFileInfo\\Translation", (LPVOID*)&pw, &cbData);
    if (!ret || !cbData)
        return FALSE;

    if (pInfoEx->hkl == NULL)
        pInfoEx->hkl = (HKL)(DWORD_PTR)*pw; /* This is an invalid HKL */

    /* Try the current language and the Unicode codepage (0x04B0) */
    LangID = LANGIDFROMLCID(GetThreadLocale());
    StringCchPrintfW(szKey, _countof(szKey), L"\\StringFileInfo\\%04X04B0\\", LangID);
    pszDesc = Imm32GetVerInfoValue(pVerInfo, szKey, _countof(szKey), L"FileDescription");
    if (!pszDesc)
    {
        /* Retry the language and codepage of the IME module */
        StringCchPrintfW(szKey, _countof(szKey), L"\\StringFileInfo\\%04X%04X\\", pw[0], pw[1]);
        pszDesc = Imm32GetVerInfoValue(pVerInfo, szKey, _countof(szKey), L"FileDescription");
    }

    /* The description */
    if (pszDesc)
        StringCchCopyW(pInfoEx->wszImeDescription, _countof(pInfoEx->wszImeDescription), pszDesc);
    else
        pInfoEx->wszImeDescription[0] = 0;

    return TRUE;
}

Referenced by Imm32LoadImeVerInfo().

Imm32LoadImeStateSentence()

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

Definition at line 366 of file utils.c.

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

Referenced by Imm32SelectLayout().

Imm32LoadImeVerInfo()

BOOL APIENTRY Imm32LoadImeVerInfo

(

PIMEINFOEX

pImeInfoEx

)

Definition at line 589 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 = Imm32HeapAlloc(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);
    }

    Imm32HeapFree(pVerInfo);

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

Referenced by ImmInstallIMEW(), and ImmLoadLayout().

Imm32NotifyAction()

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

Definition at line 205 of file utils.c.

{
    DWORD dwThreadId;
    HKL hKL;
    PIMEDPI pImeDpi;

    if (dwAction)
    {
        dwThreadId = NtUserQueryInputContext(hIMC, 1);
        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 455 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 Imm32SetCompositionStringAW().

Imm32ReconvertWideFromAnsi()

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

Definition at line 399 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 Imm32SetCompositionStringAW().

Imm32SaveImeStateSentence()

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

Definition at line 378 of file utils.c.

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

Referenced by Imm32SelectLayout().

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 Imm32GetRegImes().

Imm32UIntToStr()

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

Definition at line 32 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 Imm32WriteRegIme(), ImmInstallIMEW(), and ImmLoadLayout().

Imm32WideFromAnsi()

LPWSTR APIENTRY Imm32WideFromAnsi

(

LPCSTR

pszA

)

Definition at line 55 of file utils.c.

{
    INT cch = lstrlenA(pszA);
    LPWSTR pszW = Imm32HeapAlloc(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().

Imm32WriteRegIme()

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

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

ImmCreateIMCC()

HIMCC WINAPI ImmCreateIMCC

(

DWORD

size

)

Definition at line 917 of file utils.c.

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

Referenced by Imm32InitContext(), Imm32SelectLayout(), START_TEST(), test_ImmDestroyIMCC(), and test_ImmGetIMCCLockCount().

ImmDestroyIMCC()

HIMCC WINAPI ImmDestroyIMCC

(

HIMCC

block

)

Definition at line 927 of file utils.c.

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

Referenced by Imm32CleanupContext(), Imm32InitContext(), Imm32SelectLayout(), START_TEST(), test_ImmDestroyIMCC(), and test_ImmGetIMCCLockCount().

ImmGetIMCCLockCount()

DWORD WINAPI ImmGetIMCCLockCount

(

HIMCC

imcc

)

Definition at line 957 of file utils.c.

{
    return LocalFlags(imcc) & LMEM_LOCKCOUNT;
}

Referenced by Imm32SelectLayout(), START_TEST(), test_ImmDestroyIMCC(), and test_ImmGetIMCCLockCount().

ImmGetIMCCSize()

DWORD WINAPI ImmGetIMCCSize

(

HIMCC

imcc

)

Definition at line 975 of file utils.c.

{
    if (imcc)
        return LocalSize(imcc);
    return 0;
}

Referenced by Imm32SelectLayout(), START_TEST(), and test_ImmDestroyIMCC().

ImmGetIMCLockCount()

DWORD WINAPI ImmGetIMCLockCount

(

HIMC

hIMC

)

Definition at line 985 of file utils.c.

{
    DWORD ret;
    HANDLE hInputContext;
    PCLIENTIMC pClientImc;

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

    ret = 0;
    hInputContext = pClientImc->hInputContext;
    if (hInputContext)
        ret = (LocalFlags(hInputContext) & LMEM_LOCKCOUNT);

    ImmUnlockClientImc(pClientImc);
    return ret;
}

Referenced by test_ImmDestroyContext(), and test_ImmGetIMCLockCount().

ImmIMPGetIMEA()

BOOL WINAPI ImmIMPGetIMEA	(	HWND	hWnd,
		LPIMEPROA	pImePro
	)

Definition at line 1007 of file utils.c.

{
    FIXME("(%p, %p)\n", hWnd, pImePro);
    return FALSE;
}

Referenced by IMPGetIMEA().

ImmIMPGetIMEW()

BOOL WINAPI ImmIMPGetIMEW	(	HWND	hWnd,
		LPIMEPROW	pImePro
	)

Definition at line 1016 of file utils.c.

{
    FIXME("(%p, %p)\n", hWnd, pImePro);
    return FALSE;
}

Referenced by IMPGetIMEW().

ImmIMPQueryIMEA()

BOOL WINAPI ImmIMPQueryIMEA

(

LPIMEPROA

pImePro

)

Definition at line 1025 of file utils.c.

{
    FIXME("(%p)\n", pImePro);
    return FALSE;
}

Referenced by IMPQueryIMEA().

ImmIMPQueryIMEW()

BOOL WINAPI ImmIMPQueryIMEW

(

LPIMEPROW

pImePro

)

Definition at line 1034 of file utils.c.

{
    FIXME("(%p)\n", pImePro);
    return FALSE;
}

Referenced by IMPQueryIMEW().

ImmIMPSetIMEA()

BOOL WINAPI ImmIMPSetIMEA	(	HWND	hWnd,
		LPIMEPROA	pImePro
	)

Definition at line 1043 of file utils.c.

{
    FIXME("(%p, %p)\n", hWnd, pImePro);
    return FALSE;
}

Referenced by IMPSetIMEA().

ImmIMPSetIMEW()

BOOL WINAPI ImmIMPSetIMEW	(	HWND	hWnd,
		LPIMEPROW	pImePro
	)

Definition at line 1052 of file utils.c.

{
    FIXME("(%p, %p)\n", hWnd, pImePro);
    return FALSE;
}

Referenced by IMPSetIMEW().

ImmLockIMCC()

LPVOID WINAPI ImmLockIMCC

(

HIMCC

imcc

)

Definition at line 937 of file utils.c.

{
    if (imcc)
        return LocalLock(imcc);
    return NULL;
}

Referenced by Imm32InitContext(), Imm32OpenICAndCS(), Imm32SelectLayout(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmTranslateMessage(), test_ImmDestroyIMCC(), test_ImmGetIMCCLockCount(), and test_ImmMessages().

ImmReSizeIMCC()

HIMCC WINAPI ImmReSizeIMCC	(	HIMCC	imcc,
		DWORD	size
	)

Definition at line 965 of file utils.c.

{
    if (!imcc)
        return NULL;
    return LocalReAlloc(imcc, size, LHND);
}

Referenced by Imm32SelectLayout(), and test_ImmMessages().

ImmUnlockIMCC()

BOOL WINAPI ImmUnlockIMCC

(

HIMCC

imcc

)

Definition at line 947 of file utils.c.

{
    if (imcc)
        return LocalUnlock(imcc);
    return FALSE;
}

Referenced by Imm32InitContext(), Imm32SelectLayout(), Imm32SetCompositionStringAW(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmTranslateMessage(), test_ImmDestroyIMCC(), test_ImmGetIMCCLockCount(), and test_ImmMessages().

LogFontAnsiToWide()

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

Definition at line 120 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(), Imm32SelectLayout(), ImmGetCompositionFontW(), and ImmSetCompositionFontA().

LogFontWideToAnsi()

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

Definition at line 132 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(), Imm32SelectLayout(), ImmGetCompositionFontA(), and ImmSetCompositionFontW().

ValidateHandleNoErr()

LPVOID FASTCALL ValidateHandleNoErr	(	HANDLE	hObject,
		UINT	uType
	)

Definition at line 144 of file utils.c.

{
    INT index;
    PUSER_HANDLE_TABLE ht;
    PUSER_HANDLE_ENTRY he;
    WORD generation;

    if (!NtUserValidateHandleSecure(hObject))
        return NULL;

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

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

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

    return &he[index];
}

Referenced by ValidateHwndNoErr().

ValidateHwndNoErr()

PWND FASTCALL ValidateHwndNoErr

(

HWND

hwnd

)

Definition at line 171 of file utils.c.

{
    /* See if the window is cached */
    PCLIENTINFO ClientInfo = GetWin32ClientInfo();
    if (hwnd == ClientInfo->CallbackWnd.hWnd)
        return ClientInfo->CallbackWnd.pWnd;

    return ValidateHandleNoErr(hwnd, TYPE_WINDOW);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)

Variable Documentation

g_hImm32Heap

HANDLE g_hImm32Heap = NULL

Definition at line 17 of file utils.c.

Referenced by Imm32HeapAlloc().

s_fnGetFileVersionInfoSizeW

FN_GetFileVersionInfoSizeW s_fnGetFileVersionInfoSizeW = NULL

static

Definition at line 517 of file utils.c.

Referenced by Imm32LoadImeVerInfo().

s_fnGetFileVersionInfoW

FN_GetFileVersionInfoW s_fnGetFileVersionInfoW = NULL

static

Definition at line 516 of file utils.c.

Referenced by Imm32LoadImeVerInfo().

s_fnVerQueryValueW

FN_VerQueryValueW s_fnVerQueryValueW = NULL

static

Definition at line 518 of file utils.c.

Referenced by Imm32GetVerInfoValue(), Imm32LoadImeFixedInfo(), and Imm32LoadImeLangAndDesc().