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

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
PTHREADINFO FASTCALL	Imm32CurrentPti (VOID)
BOOL	Imm32IsCrossThreadAccess (HIMC hIMC)
BOOL	Imm32IsCrossProcessAccess (HWND hWnd)
HRESULT	Imm32StrToUInt (_In_ PCWSTR pszText, _Out_ PDWORD pdwValue, _In_ ULONG nBase)
HRESULT	Imm32UIntToStr (_In_ DWORD dwValue, _In_ ULONG nBase, _Out_ PWSTR pszBuff, _In_ USHORT cchBuff)
BOOL	Imm32IsSystemJapaneseOrKorean (VOID)
BOOL	Imm32IsImcAnsi (HIMC hIMC)
LPWSTR	Imm32WideFromAnsi (UINT uCodePage, LPCSTR pszA)
LPSTR	Imm32AnsiFromWide (UINT uCodePage, LPCWSTR pszW)
LONG	IchWideFromAnsi (LONG cchAnsi, LPCSTR pchAnsi, UINT uCodePage)
LONG	IchAnsiFromWide (LONG cchWide, LPCWSTR pchWide, UINT uCodePage)
BOOL	Imm32GetSystemLibraryPath (LPWSTR pszPath, DWORD cchPath, LPCWSTR pszFileName)
VOID	LogFontAnsiToWide (const LOGFONTA *plfA, LPLOGFONTW plfW)
VOID	LogFontWideToAnsi (const LOGFONTW *plfW, LPLOGFONTA plfA)
static PVOID FASTCALL	DesktopPtrToUser (PVOID ptr)
LPVOID FASTCALL	ValidateHandleNoErr (HANDLE hObject, UINT uType)
LPVOID FASTCALL	ValidateHandle (HANDLE hObject, UINT uType)
BOOL	Imm32CheckImcProcess (PIMC pIMC)
LPVOID	ImmLocalAlloc (_In_ DWORD dwFlags, _In_ DWORD dwBytes)
BOOL	Imm32MakeIMENotify (_In_ HIMC hIMC, _In_ HWND hwnd, _In_ DWORD dwAction, _In_ DWORD dwIndex, _Inout_opt_ DWORD_PTR dwValue, _In_ DWORD dwCommand, _Inout_opt_ DWORD_PTR dwData)
DWORD	Imm32BuildHimcList (DWORD dwThreadId, HIMC **pphList)
PIME_STATE	Imm32FetchImeState (LPINPUTCONTEXTDX pIC, HKL hKL)
PIME_SUBSTATE	Imm32FetchImeSubState (PIME_STATE pState, HKL hKL)
BOOL	Imm32LoadImeStateSentence (LPINPUTCONTEXTDX pIC, PIME_STATE pState, HKL hKL)
BOOL	Imm32SaveImeStateSentence (LPINPUTCONTEXTDX pIC, PIME_STATE pState, HKL hKL)
DWORD	Imm32ReconvertWideFromAnsi (LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
DWORD	Imm32ReconvertAnsiFromWide (LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
HIMCC WINAPI	ImmCreateIMCC (_In_ DWORD size)
HIMCC WINAPI	ImmDestroyIMCC (_In_ HIMCC block)
LPVOID WINAPI	ImmLockIMCC (_In_ HIMCC imcc)
BOOL WINAPI	ImmUnlockIMCC (_In_ HIMCC imcc)
DWORD WINAPI	ImmGetIMCCLockCount (_In_ HIMCC imcc)
HIMCC WINAPI	ImmReSizeIMCC (_In_ HIMCC imcc, _In_ DWORD size)
DWORD WINAPI	ImmGetIMCCSize (_In_ HIMCC imcc)
DWORD WINAPI	ImmGetIMCLockCount (_In_ HIMC hIMC)

Variables
HANDLE	ghImmHeap = NULL

Macro Definition Documentation

INITIAL_COUNT

#define INITIAL_COUNT   0x40

MAX_RETRY

#define MAX_RETRY   10

Function Documentation

DesktopPtrToUser()

static PVOID FASTCALL DesktopPtrToUser ( PVOID  ptr )

static

Definition at line 188 of file utils.c.

{
    PCLIENTINFO pci = GetWin32ClientInfo();
    PDESKTOPINFO pdi = pci->pDeskInfo;
 
    ASSERT(ptr != NULL);
    ASSERT(pdi != NULL);
    if (pdi->pvDesktopBase <= ptr && ptr < pdi->pvDesktopLimit)
        return (PVOID)((ULONG_PTR)ptr - pci->ulClientDelta);
    else
        return (PVOID)NtUserCallOneParam((DWORD_PTR)ptr, ONEPARAM_ROUTINE_GETDESKTOPMAPPING);
}

Referenced by CallNextHookEx(), GetAncestor(), GetClassLongA(), GetClassLongW(), GetClassWord(), GetLastActivePopup(), GetMenuItemInfo_common(), GetMenuState(), GetMenuStringA(), GetMenuStringW(), GetParent(), GetSubMenu(), GetThreadDesktopWnd(), GetWindow(), GetWindowInfo(), IntCallMessageProc(), IntFindChildWindowToOwner(), IntGetMenuDefaultItem(), IntGetSBData(), IntGetWndProc(), IntScrollGetScrollBarRect(), IsChild(), IsWindowVisible(), MENU_FindItem(), RealDefWindowProcA(), RealDefWindowProcW(), User32DefWindowProc(), ValidateHandle(), and ValidateHandleNoErr().

IchAnsiFromWide()

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

Definition at line 140 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 IchWideFromAnsi	(	LONG	cchAnsi,
		LPCSTR	pchAnsi,
		UINT	uCodePage
	)

Definition at line 120 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 Imm32AnsiFromWide	(	UINT	uCodePage,
		LPCWSTR	pszW
	)

Definition at line 107 of file utils.c.

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

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

Imm32BuildHimcList()

DWORD Imm32BuildHimcList	(	DWORD	dwThreadId,
		HIMC **	pphList
	)

Definition at line 338 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 (IS_NULL_UNEXPECTEDLY(phNewList))
        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 (IS_NULL_UNEXPECTEDLY(phNewList))
            return 0;
 
        Status = NtUserBuildHimcList(dwThreadId, dwCount, phNewList, &dwCount);
    }
 
    if (NT_ERROR(Status) || !dwCount)
    {
        ERR("Abnormal status\n");
        ImmLocalFree(phNewList);
        return 0;
    }
 
    *pphList = phNewList;
    return dwCount;
#undef INITIAL_COUNT
#undef MAX_RETRY
}

Referenced by ImmEnumInputContext().

Imm32CheckImcProcess()

BOOL Imm32CheckImcProcess

(

PIMC

pIMC

)

Definition at line 252 of file utils.c.

{
    HIMC hIMC;
    DWORD_PTR dwPID1, dwPID2;
 
    if (IS_NULL_UNEXPECTEDLY(pIMC))
        return FALSE;
 
    if (pIMC->head.pti == Imm32CurrentPti())
        return TRUE;
 
    hIMC = pIMC->head.h;
    dwPID1 = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTPROCESSID);
    dwPID2 = (DWORD_PTR)NtCurrentTeb()->ClientId.UniqueProcess;
    if (dwPID1 != dwPID2)
    {
        WARN("PID 0x%X != 0x%X\n", dwPID1, dwPID2);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by ImmLockClientImc().

Imm32CurrentPti()

PTHREADINFO FASTCALL Imm32CurrentPti

(

VOID

)

Definition at line 18 of file utils.c.

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

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

Imm32FetchImeState()

PIME_STATE Imm32FetchImeState	(	LPINPUTCONTEXTDX	pIC,
		HKL	hKL
	)

Definition at line 378 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 Imm32FetchImeSubState	(	PIME_STATE	pState,
		HKL	hKL
	)

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

Imm32GetSystemLibraryPath()

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

Definition at line 152 of file utils.c.

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

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

Imm32IsCrossProcessAccess()

BOOL Imm32IsCrossProcessAccess

(

HWND

hWnd

)

Definition at line 32 of file utils.c.

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

Imm32IsCrossThreadAccess()

BOOL Imm32IsCrossThreadAccess

(

HIMC

hIMC

)

Definition at line 25 of file utils.c.

{
    DWORD_PTR dwImeThreadId = NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    DWORD_PTR dwCurrentThreadId = GetCurrentThreadId();
    return dwImeThreadId != dwCurrentThreadId;
}

Referenced by ImmSetCompositionWindow().

Imm32IsImcAnsi()

BOOL Imm32IsImcAnsi

(

HIMC

hIMC

)

Definition at line 85 of file utils.c.

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

Referenced by ImmGetImeMenuItemsAW().

Imm32IsSystemJapaneseOrKorean()

BOOL Imm32IsSystemJapaneseOrKorean

(

VOID

)

Definition at line 72 of file utils.c.

{
    LCID lcid = GetSystemDefaultLCID();
    LANGID LangID = LANGIDFROMLCID(lcid);
    WORD wPrimary = PRIMARYLANGID(LangID);
    if (wPrimary != LANG_JAPANESE || wPrimary != LANG_KOREAN)
    {
        TRACE("The country has no special IME support\n");
        return FALSE;
    }
    return TRUE;
}

Referenced by ImmIMPGetIMEA(), ImmIMPGetIMEW(), ImmIMPQueryIMEA(), ImmIMPQueryIMEW(), ImmIMPSetIMEA(), ImmIMPSetIMEW(), ImmWINNLSEnableIME(), and ImmWINNLSGetEnableStatus().

Imm32LoadImeStateSentence()

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

Definition at line 420 of file utils.c.

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

Referenced by Imm32SelectInputContext().

Imm32MakeIMENotify()

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

Definition at line 287 of file utils.c.

{
    DWORD dwThreadId;
    HKL hKL;
    PIMEDPI pImeDpi;
 
    if (dwAction != 0)
    {
        dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
        if (dwThreadId)
        {
            /* find keyboard layout and lock it */
            hKL = GetKeyboardLayout(dwThreadId);
            pImeDpi = ImmLockImeDpi(hKL);
            if (pImeDpi)
            {
                /* do notify */
                TRACE("NotifyIME(%p, %lu, %lu, %p)\n", hIMC, dwAction, dwIndex, dwValue);
                if (!pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue))
                    WARN("NotifyIME(%p, %lu, %lu, %p) failed\n", hIMC, dwAction, dwIndex, dwValue);
 
                ImmUnlockImeDpi(pImeDpi); /* unlock */
            }
            else
            {
                WARN("pImeDpi was NULL\n");
            }
        }
        else
        {
            WARN("dwThreadId was zero\n");
        }
    }
    else
    {
        WARN("dwAction was zero\n");
    }
 
    if (hwnd && dwCommand)
        SendMessageW(hwnd, WM_IME_NOTIFY, dwCommand, dwData);
 
    return TRUE;
}

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

Imm32ReconvertAnsiFromWide()

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

Definition at line 514 of file utils.c.

{
    DWORD cch0, cch1, cchDest, cbDest;
    LPCWSTR pchSrc = (LPCWSTR)((LPCSTR)pSrc + pSrc->dwStrOffset);
    LPSTR pchDest;
 
    if (pSrc->dwVersion != 0)
    {
        ERR("\n");
        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)
    {
        ERR("Too small\n");
        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] = ANSI_NULL;
 
    TRACE("cchDest: 0x%X\n", cchDest);
    return cbDest;
}

Referenced by Imm32ProcessRequest(), and ImmSetCompositionStringAW().

Imm32ReconvertWideFromAnsi()

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

Definition at line 451 of file utils.c.

{
    DWORD cch0, cchDest, cbDest;
    LPCSTR pchSrc = (LPCSTR)pSrc + pSrc->dwStrOffset;
    LPWSTR pchDest;
 
    if (pSrc->dwVersion != 0)
    {
        ERR("\n");
        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)
    {
        ERR("Too small\n");
        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] = UNICODE_NULL;
 
    TRACE("cbDest: 0x%X\n", cbDest);
    return cbDest;
}

Referenced by Imm32ProcessRequest(), and ImmSetCompositionStringAW().

Imm32SaveImeStateSentence()

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

Definition at line 431 of file utils.c.

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

Referenced by Imm32SelectInputContext().

Imm32StrToUInt()

HRESULT Imm32StrToUInt	(	_In_ PCWSTR	pszText,
		_Out_ PDWORD	pdwValue,
		_In_ ULONG	nBase
	)

Definition at line 40 of file utils.c.

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

Referenced by Imm32GetImeLayoutList(), and Imm32UnitTest().

Imm32UIntToStr()

HRESULT Imm32UIntToStr	(	_In_ DWORD	dwValue,
		_In_ ULONG	nBase,
		_Out_ PWSTR	pszBuff,
		_In_ USHORT	cchBuff
	)

Definition at line 56 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 Imm32UnitTest(), and Imm32WriteImeLayout().

Imm32WideFromAnsi()

LPWSTR Imm32WideFromAnsi	(	UINT	uCodePage,
		LPCSTR	pszA
	)

Definition at line 96 of file utils.c.

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

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

ImmCreateIMCC()

HIMCC WINAPI ImmCreateIMCC

(

_In_ DWORD

size

)

Definition at line 582 of file utils.c.

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

Referenced by CicIMCLock::ClearCand(), CicBridge::CreateInputContext(), Imm32CreateInputContext(), Imm32SelectInputContext(), START_TEST(), test_ImmDestroyIMCC(), and test_ImmGetIMCCLockCount().

ImmDestroyIMCC()

HIMCC WINAPI ImmDestroyIMCC

(

_In_ HIMCC

block

)

Definition at line 593 of file utils.c.

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

Referenced by CicIMCLock::ClearCand(), CicBridge::DestroyInputContext(), Imm32CreateInputContext(), Imm32DestroyInputContext(), Imm32SelectInputContext(), START_TEST(), test_ImmDestroyIMCC(), and test_ImmGetIMCCLockCount().

ImmGetIMCCLockCount()

DWORD WINAPI ImmGetIMCCLockCount

(

_In_ HIMCC

imcc

)

Definition at line 626 of file utils.c.

{
    return LocalFlags(imcc) & LMEM_LOCKCOUNT;
}

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

ImmGetIMCCSize()

DWORD WINAPI ImmGetIMCCSize

(

_In_ HIMCC

imcc

)

Definition at line 648 of file utils.c.

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

Referenced by Imm32SelectInputContext(), START_TEST(), Test1(), test_ImmDestroyIMCC(), and CicIMCLock::ValidCompositionString().

ImmGetIMCLockCount()

DWORD WINAPI ImmGetIMCLockCount

(

_In_ HIMC

hIMC

)

Definition at line 659 of file utils.c.

{
    DWORD ret;
    HANDLE hInputContext;
    PCLIENTIMC pClientImc;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        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().

ImmLocalAlloc()

LPVOID ImmLocalAlloc	(	_In_ DWORD	dwFlags,
		_In_ DWORD	dwBytes
	)

Definition at line 275 of file utils.c.

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

Referenced by CtfImmGenerateMessage(), CtfImmSetLangBand(), Imm32AllocateTLS(), Imm32AllocIMMISPY(), Imm32AnsiFromWide(), Imm32BuildHimcList(), Imm32FetchImeState(), Imm32FetchImeSubState(), Imm32LoadImeDpi(), Imm32LoadImeVerInfo(), Imm32ProcessRequest(), Imm32WideFromAnsi(), ImmCreateContext(), ImmFreeLayout(), ImmGenerateMessage(), ImmGetConversionListA(), ImmGetConversionListW(), ImmGetImeMenuItemsAW(), ImmGetRegisterWordStyleA(), ImmGetRegisterWordStyleW(), ImmIMPQueryIMEW(), ImmIMPSetIMEW(), ImmInstallIMEW(), ImmLockClientImc(), ImmPostMessages(), ImmSetCompositionStringAW(), and ImmTranslateMessage().

ImmLockIMCC()

LPVOID WINAPI ImmLockIMCC

(

_In_ HIMCC

imcc

)

Definition at line 604 of file utils.c.

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

Referenced by CicIMCCLock< T_DATA >::_LockIMCC(), CtfImmGenerateMessage(), Imm32CreateInputContext(), Imm32OpenICAndCS(), Imm32SelectInputContext(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmTranslateMessage(), test_ImmDestroyIMCC(), test_ImmGetIMCCLockCount(), and test_ImmMessages().

ImmReSizeIMCC()

HIMCC WINAPI ImmReSizeIMCC	(	_In_ HIMCC	imcc,
		_In_ DWORD	size
	)

Definition at line 635 of file utils.c.

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

Referenced by CicIMCLock::ClearCand(), Imm32SelectInputContext(), and test_ImmMessages().

ImmUnlockIMCC()

BOOL WINAPI ImmUnlockIMCC

(

_In_ HIMCC

imcc

)

Definition at line 615 of file utils.c.

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

Referenced by CicIMCCLock< T_DATA >::_UnlockIMCC(), CtfImmGenerateMessage(), Imm32CreateInputContext(), Imm32SelectInputContext(), ImmGenerateMessage(), ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetCompositionStringA(), ImmGetCompositionStringW(), ImmGetGuideLineAW(), ImmSetCompositionStringAW(), ImmTranslateMessage(), test_ImmDestroyIMCC(), test_ImmGetIMCCLockCount(), and test_ImmMessages().

LogFontAnsiToWide()

VOID LogFontAnsiToWide	(	const LOGFONTA *	plfA,
		LPLOGFONTW	plfW
	)

Definition at line 164 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] = UNICODE_NULL;
}

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

LogFontWideToAnsi()

VOID LogFontWideToAnsi	(	const LOGFONTW *	plfW,
		LPLOGFONTA	plfA
	)

Definition at line 176 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] = ANSI_NULL;
}

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

ValidateHandle()

LPVOID FASTCALL ValidateHandle	(	HANDLE	hObject,
		UINT	uType
	)

Definition at line 239 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;
}

ValidateHandleNoErr()

LPVOID FASTCALL ValidateHandleNoErr	(	HANDLE	hObject,
		UINT	uType
	)

Definition at line 201 of file utils.c.

{
    UINT index;
    PUSER_HANDLE_TABLE ht;
    PUSER_HANDLE_ENTRY he;
    WORD generation;
    LPVOID ptr;
 
    if (!NtUserValidateHandleSecure(hObject))
    {
        WARN("Not a handle\n");
        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 ValidateHandle().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)

Variable Documentation

ghImmHeap

HANDLE ghImmHeap = NULL

Definition at line 16 of file utils.c.

Referenced by ImmLocalAlloc().