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 <immdev.h>
#include <imm32_undoc.h>
#include <ndk/umtypes.h>
#include <ndk/pstypes.h>
#include <ndk/rtlfuncs.h>
#include "ntuser.h"
#include "ntwin32.h"
#include <undocuser.h>
#include <strsafe.h>
#include <wine/debug.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.

Macros
#define	WIN32_NO_STATUS
#define	NTOS_MODE_USER
#define	ERR_PRINTF(fmt, ...)
#define	FAILED_UNEXPECTEDLY(hr)   FAILED(hr)
#define	IS_NULL_UNEXPECTEDLY(p)   (!(p))
#define	IS_ZERO_UNEXPECTEDLY(p)   (!(p))
#define	IS_TRUE_UNEXPECTEDLY(x)   (x)
#define	IS_ERROR_UNEXPECTEDLY(x)   ((x) != ERROR_SUCCESS)
#define	IS_CROSS_THREAD_HIMC(hIMC)   IS_TRUE_UNEXPECTEDLY(Imm32IsCrossThreadAccess(hIMC))
#define	IS_CROSS_PROCESS_HWND(hWnd)   IS_TRUE_UNEXPECTEDLY(Imm32IsCrossProcessAccess(hWnd))
#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	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)

Functions
BOOL	Imm32GetSystemLibraryPath (LPWSTR pszPath, DWORD cchPath, LPCWSTR pszFileName)
VOID	LogFontAnsiToWide (const LOGFONTA *plfA, LPLOGFONTW plfW)
VOID	LogFontWideToAnsi (const LOGFONTW *plfW, LPLOGFONTA plfA)
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)
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)
PIMEDPI	Imm32FindOrLoadImeDpi (HKL hKL)
LPINPUTCONTEXT	Imm32InternalLockIMC (HIMC hIMC, BOOL fSelect)
BOOL	Imm32ReleaseIME (_In_ HKL hKL)
BOOL	Imm32IsSystemJapaneseOrKorean (VOID)
BOOL	Imm32IsCrossThreadAccess (HIMC hIMC)
BOOL	Imm32IsCrossProcessAccess (HWND hWnd)
BOOL	Imm32IsImcAnsi (HIMC hIMC)
BOOL	Imm32LoadImeVerInfo (_Out_ PIMEINFOEX pImeInfoEx)
DWORD	CandidateListWideToAnsi (const CANDIDATELIST *pWideCL, LPCANDIDATELIST pAnsiCL, DWORD dwBufLen, UINT uCodePage)
DWORD	CandidateListAnsiToWide (const CANDIDATELIST *pAnsiCL, LPCANDIDATELIST pWideCL, DWORD dwBufLen, UINT uCodePage)
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	Imm32ReconvertAnsiFromWide (LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
DWORD	Imm32ReconvertWideFromAnsi (LPRECONVERTSTRING pDest, const RECONVERTSTRING *pSrc, UINT uCodePage)
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)
PTHREADINFO FASTCALL	Imm32CurrentPti (VOID)
HRESULT	CtfImmTIMCreateInputContext (_In_ HIMC hIMC)
HRESULT	CtfImmTIMDestroyInputContext (_In_ HIMC hIMC)
HRESULT	CtfImmCoInitialize (VOID)
HRESULT	CtfImeCreateThreadMgr (VOID)
HRESULT	CtfImeDestroyThreadMgr (VOID)
HRESULT	Imm32ActivateOrDeactivateTIM (_In_ BOOL bCreate)
HRESULT	CtfImeSetActiveContextAlways (_In_ HIMC hIMC, _In_ BOOL fActive, _In_ HWND hWnd, _In_ HKL hKL)
BOOL	CtfImeProcessCicHotkey (_In_ HIMC hIMC, _In_ UINT vKey, _In_ LPARAM lParam)
LRESULT	CtfImmSetLangBand (_In_ HWND hWnd, _In_ BOOL fSet)

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

Macro Definition Documentation

ERR_PRINTF

#define ERR_PRINTF	(		fmt,
			...
	)

Value:

    (__WINE_IS_DEBUG_ON(_ERR, __wine_dbch___default) ? \
    (wine_dbg_printf("err:(%s:%d) " fmt, __RELFILE__, __LINE__, ##__VA_ARGS__), TRUE) : TRUE)

Definition at line 49 of file precomp.h.

FAILED_UNEXPECTEDLY

#define FAILED_UNEXPECTEDLY

(

hr

)

FAILED(hr)

Definition at line 65 of file precomp.h.

ImeDpi_IsUnicode

#define ImeDpi_IsUnicode

(

pImeDpi

)

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

Definition at line 120 of file precomp.h.

IMM_INIT_MAGIC

#define IMM_INIT_MAGIC   0x19650412

Definition at line 75 of file precomp.h.

IMM_INVALID_CANDFORM

#define IMM_INVALID_CANDFORM   ULONG_MAX

Definition at line 76 of file precomp.h.

ImmLocalFree

#define ImmLocalFree

(

lpData

)

HeapFree(ghImmHeap, 0, (lpData))

Definition at line 105 of file precomp.h.

INVALID_HOTKEY_ID

#define INVALID_HOTKEY_ID   0xFFFFFFFF

Definition at line 77 of file precomp.h.

IS_CROSS_PROCESS_HWND

#define IS_CROSS_PROCESS_HWND

(

hWnd

)

IS_TRUE_UNEXPECTEDLY(Imm32IsCrossProcessAccess(hWnd))

Definition at line 73 of file precomp.h.

IS_CROSS_THREAD_HIMC

#define IS_CROSS_THREAD_HIMC

(

hIMC

)

IS_TRUE_UNEXPECTEDLY(Imm32IsCrossThreadAccess(hIMC))

Definition at line 72 of file precomp.h.

IS_ERROR_UNEXPECTEDLY

#define IS_ERROR_UNEXPECTEDLY

(

x

)

((x) != ERROR_SUCCESS)

Definition at line 69 of file precomp.h.

IS_NULL_UNEXPECTEDLY

#define IS_NULL_UNEXPECTEDLY

(

p

)

(!(p))

Definition at line 66 of file precomp.h.

IS_TRUE_UNEXPECTEDLY

#define IS_TRUE_UNEXPECTEDLY

(

x

)

(x)

Definition at line 68 of file precomp.h.

IS_ZERO_UNEXPECTEDLY

#define IS_ZERO_UNEXPECTEDLY

(

p

)

(!(p))

Definition at line 67 of file precomp.h.

LANGID_CHINESE_SIMPLIFIED

#define LANGID_CHINESE_SIMPLIFIED   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED)

Definition at line 81 of file precomp.h.

LANGID_CHINESE_TRADITIONAL

#define LANGID_CHINESE_TRADITIONAL   MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL)

Definition at line 82 of file precomp.h.

LANGID_JAPANESE

#define LANGID_JAPANESE   MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT)

Definition at line 83 of file precomp.h.

MAX_CANDIDATEFORM

#define MAX_CANDIDATEFORM   4

Definition at line 78 of file precomp.h.

MAX_IMM_FILENAME

#define MAX_IMM_FILENAME   80

Definition at line 79 of file precomp.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 33 of file precomp.h.

REGKEY_KEYBOARD_LAYOUTS

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

Definition at line 85 of file precomp.h.

ValidateHwnd

#define ValidateHwnd

(

hwnd

)

ValidateHandle((hwnd), TYPE_WINDOW)

Definition at line 101 of file precomp.h.

ValidateHwndNoErr

#define ValidateHwndNoErr

(

hwnd

)

ValidateHandleNoErr((hwnd), TYPE_WINDOW)

Definition at line 100 of file precomp.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 19 of file precomp.h.

Function Documentation

CandidateListAnsiToWide()

DWORD 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 CandidateListWideToAnsi	(	const CANDIDATELIST *	pWideCL,
		LPCANDIDATELIST	pAnsiCL,
		DWORD	dwBufLen,
		UINT	uCodePage
	)

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

CtfImeCreateThreadMgr()

HRESULT CtfImeCreateThreadMgr

(

VOID

)

Definition at line 666 of file msctfime.cpp.

{
    TRACE("()\n");
 
    TLS *pTLS = TLS::GetTLS();
    if (!pTLS)
        return E_OUTOFMEMORY;
 
    if (!pTLS->m_pBridge)
    {
        pTLS->m_pBridge = new(cicNoThrow) CicBridge();
        if (!pTLS->m_pBridge)
            return E_OUTOFMEMORY;
    }
 
    HRESULT hr = S_OK;
    if (!g_bWinLogon && !(pTLS->m_dwSystemInfoFlags & IME_SYSINFO_WINLOGON))
    {
        hr = pTLS->m_pBridge->InitIMMX(pTLS);
        if (SUCCEEDED(hr))
        {
            if (!pTLS->m_pThreadMgr)
                return E_OUTOFMEMORY;
 
            hr = pTLS->m_pBridge->ActivateIMMX(pTLS, pTLS->m_pThreadMgr);
            if (FAILED(hr))
                pTLS->m_pBridge->UnInitIMMX(pTLS);
        }
    }
 
    return hr;
}

Referenced by CtfAImmActivate(), CtfImeCreateThreadMgr(), CtfImmTIMActivate(), and Imm32ActivateOrDeactivateTIM().

CtfImeDestroyThreadMgr()

HRESULT CtfImeDestroyThreadMgr

(

VOID

)

Definition at line 705 of file msctfime.cpp.

{
    TRACE("()\n");
 
    TLS *pTLS = TLS::PeekTLS();
    if (!pTLS)
        return E_OUTOFMEMORY;
 
    if (pTLS->m_pBridge)
    {
        pTLS->m_pBridge = new(cicNoThrow) CicBridge();
        if (!pTLS->m_pBridge)
            return E_OUTOFMEMORY;
    }
 
    if (!pTLS->m_pThreadMgr)
        return E_OUTOFMEMORY;
 
    if (pTLS->m_dwSystemInfoFlags & IME_SYSINFO_WINLOGON)
        return S_OK;
 
    HRESULT hr = pTLS->m_pBridge->DeactivateIMMX(pTLS, pTLS->m_pThreadMgr);
    if (hr == S_OK)
        pTLS->m_pBridge->UnInitIMMX(pTLS);
 
    return hr;
}

Referenced by CtfAImmDeactivate(), CtfImeDestroyThreadMgr(), Imm32ActivateOrDeactivateTIM(), and ImmDisableTextFrameService().

CtfImeProcessCicHotkey()

BOOL CtfImeProcessCicHotkey	(	_In_ HIMC	hIMC,
		_In_ UINT	vKey,
		_In_ LPARAM	lParam
	)

Definition at line 795 of file msctfime.cpp.

{
    TRACE("(%p, %u, %p)\n", hIMC, vKey, lParam);
 
    TLS *pTLS = TLS::GetTLS();
    if (!pTLS)
        return S_OK;
 
    HRESULT hr = S_OK;
    ITfThreadMgr *pThreadMgr = NULL;
    ITfThreadMgr_P *pThreadMgr_P = NULL;
    if ((TF_GetThreadMgr(&pThreadMgr) == S_OK) &&
        (pThreadMgr->QueryInterface(IID_ITfThreadMgr_P, (void**)&pThreadMgr_P) == S_OK) &&
        CtfImmIsCiceroStartedInThread())
    {
        HRESULT hr2;
        if (SUCCEEDED(pThreadMgr_P->CallImm32HotkeyHandler(vKey, lParam, &hr2)))
            hr = hr2;
    }
 
    if (pThreadMgr)
        pThreadMgr->Release();
    if (pThreadMgr_P)
        pThreadMgr_P->Release();
 
    return hr;
}

Referenced by CtfImeProcessCicHotkey(), and ImmProcessKey().

CtfImeSetActiveContextAlways()

HRESULT CtfImeSetActiveContextAlways	(	_In_ HIMC	hIMC,
		_In_ BOOL	fActive,
		_In_ HWND	hWnd,
		_In_ HKL	hKL
	)

Definition at line 775 of file msctfime.cpp.

{
    TRACE("(%p, %d, %p, %p)\n", hIMC, fActive, hWnd, hKL);
 
    TLS *pTLS = TLS::GetTLS();
    if (!pTLS || !pTLS->m_pBridge)
        return E_OUTOFMEMORY;
    return pTLS->m_pBridge->SetActiveContextAlways(pTLS, hIMC, fActive, hWnd, hKL);
}

Referenced by CtfImeSetActiveContextAlways(), and ImmSetActiveContext().

CtfImmCoInitialize()

HRESULT CtfImmCoInitialize

(

VOID

)

Definition at line 574 of file ctf.c.

{
    HRESULT hr;
    IMMTLSDATA *pData;
    ISPY *pSpy;
 
    if (GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT)
        return S_OK; /* Already initialized */
 
    hr = Imm32CoInitializeEx();
    if (FAILED_UNEXPECTEDLY(hr))
        return hr; /* CoInitializeEx failed */
 
    GetWin32ClientInfo()->CI_flags |= CI_CTFCOINIT;
    Imm32InitTLS();
 
    pData = Imm32AllocateTLS();
    if (!pData || pData->pSpy)
        return S_OK; /* Cannot allocate or already it has a spy */
 
    pSpy = Imm32AllocIMMISPY();
    pData->pSpy = (IInitializeSpy*)pSpy;
    if (IS_NULL_UNEXPECTEDLY(pSpy))
        return S_OK; /* Cannot allocate a spy */
 
    if (FAILED_UNEXPECTEDLY(Imm32CoRegisterInitializeSpy(pData->pSpy, &pData->uliCookie)))
    {
        /* Failed to register the spy */
        Imm32DeleteIMMISPY(pData->pSpy);
        pData->pSpy = NULL;
        pData->uliCookie.QuadPart = 0;
    }
 
    return S_OK;
}

Referenced by CtfImmTIMActivate().

CtfImmSetLangBand()

LRESULT CtfImmSetLangBand	(	_In_ HWND	hWnd,
		_In_ BOOL	fSet
	)

Definition at line 1234 of file ctf.c.

{
    HANDLE hThread;
    PWND pWnd = NULL;
    PIMM_DELAY_SET_LANG_BAND pSetBand;
    DWORD_PTR lResult = 0;
 
    if (hWnd && gpsi)
        pWnd = ValidateHwndNoErr(hWnd);
 
    if (IS_NULL_UNEXPECTEDLY(pWnd))
        return 0;
 
    if (pWnd->state2 & WNDS2_WMCREATEMSGPROCESSED)
    {
        SendMessageTimeoutW(hWnd, WM_USER + 0x105, 0, fSet, SMTO_BLOCK | SMTO_ABORTIFHUNG,
                            5000, &lResult);
        return lResult;
    }
 
    pSetBand = ImmLocalAlloc(0, sizeof(IMM_DELAY_SET_LANG_BAND));
    if (IS_NULL_UNEXPECTEDLY(pSetBand))
        return 0;
 
    pSetBand->hWnd = hWnd;
    pSetBand->fSet = fSet;
 
    hThread = CreateThread(NULL, 0, Imm32DelaySetLangBandProc, pSetBand, 0, NULL);
    if (hThread)
        CloseHandle(hThread);
    return 0;
}

Referenced by ImmSystemHandler().

CtfImmTIMCreateInputContext()

HRESULT CtfImmTIMCreateInputContext

(

_In_ HIMC

hIMC

)

Definition at line 939 of file ctf.c.

{
    PCLIENTIMC pClientImc;
    DWORD_PTR dwImeThreadId, dwCurrentThreadId;
    HRESULT hr = S_FALSE;
 
    TRACE("(%p)\n", hIMC);
 
    pClientImc = ImmLockClientImc(hIMC);
    if (!pClientImc)
        return E_FAIL;
 
    if (GetWin32ClientInfo()->CI_flags & CI_AIMMACTIVATED)
    {
        if (!pClientImc->bCtfIme)
        {
            dwImeThreadId = NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
            dwCurrentThreadId = GetCurrentThreadId();
            if (dwImeThreadId == dwCurrentThreadId)
            {
                pClientImc->bCtfIme = TRUE;
                hr = CtfImeCreateInputContext(hIMC);
                if (FAILED_UNEXPECTEDLY(hr))
                    pClientImc->bCtfIme = FALSE;
            }
        }
    }
    else
    {
        if (!(GetWin32ClientInfo()->CI_flags & CI_CTFTIM))
            return S_OK;
 
        if (!pClientImc->bCtfIme)
        {
            dwImeThreadId = NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
            dwCurrentThreadId = GetCurrentThreadId();
            if ((dwImeThreadId == dwCurrentThreadId) && IS_CICERO_MODE() && !IS_16BIT_MODE())
            {
                pClientImc->bCtfIme = TRUE;
                hr = CtfImeCreateInputContext(hIMC);
                if (FAILED_UNEXPECTEDLY(hr))
                    pClientImc->bCtfIme = FALSE;
            }
        }
    }
 
    ImmUnlockClientImc(pClientImc);
    return hr;
}

Referenced by Imm32CreateInputContext(), and Imm32InternalLockIMC().

CtfImmTIMDestroyInputContext()

HRESULT CtfImmTIMDestroyInputContext

(

_In_ HIMC

hIMC

)

Definition at line 929 of file ctf.c.

{
    if (!IS_CICERO_MODE() || IS_CICERO_COMPAT_DISABLED())
        return E_NOINTERFACE;
 
    return CtfImeDestroyInputContext(hIMC);
}

Referenced by Imm32DestroyInputContext().

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

Imm32ActivateOrDeactivateTIM()

HRESULT Imm32ActivateOrDeactivateTIM

(

_In_ BOOL

bCreate

)

Definition at line 895 of file ctf.c.

{
    HRESULT hr = S_OK;
 
    if (!IS_CICERO_MODE() || IS_16BIT_MODE() ||
        !(GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT))
    {
        return S_OK; /* No need to activate/de-activate TIM */
    }
 
    if (bCreate)
    {
        if (!(GetWin32ClientInfo()->CI_flags & CI_CTFTIM))
        {
            hr = CtfImeCreateThreadMgr();
            if (SUCCEEDED(hr))
                GetWin32ClientInfo()->CI_flags |= CI_CTFTIM;
        }
    }
    else /* Destroy */
    {
        if (GetWin32ClientInfo()->CI_flags & CI_CTFTIM)
        {
            hr = CtfImeDestroyThreadMgr();
            if (SUCCEEDED(hr))
                GetWin32ClientInfo()->CI_flags &= ~CI_CTFTIM;
        }
    }
 
    return hr;
}

Referenced by CtfImmLastEnabledWndDestroy(), and ISPY_PreInitialize().

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

Imm32FindOrLoadImeDpi()

PIMEDPI Imm32FindOrLoadImeDpi

(

HKL

hKL

)

Definition at line 350 of file ime.c.

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

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

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

Imm32InternalLockIMC()

LPINPUTCONTEXT Imm32InternalLockIMC	(	HIMC	hIMC,
		BOOL	fSelect
	)

Definition at line 852 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 (IS_NULL_UNEXPECTEDLY(pIC))
            goto Failure;
 
        CtfImmTIMCreateInputContext(hIMC);
        goto Success;
    }
 
    dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    if (dwThreadId == GetCurrentThreadId() && IS_CICERO_MODE() && !IS_16BIT_MODE())
    {
        hOldKL = GetKeyboardLayout(0);
        LangID = LOWORD(hOldKL);
        hNewKL = UlongToHandle(MAKELONG(LangID, LangID));
 
        pImeDpi = Imm32FindOrLoadImeDpi(hNewKL);
        if (pImeDpi)
        {
            CtfImmTIMActivate(hNewKL);
        }
    }
 
    if (!NtUserQueryInputContext(hIMC, QIC_DEFAULTWINDOWIME))
    {
        ERR("No default IME window\n");
        goto Failure;
    }
 
    hIC = LocalAlloc(LHND, sizeof(INPUTCONTEXTDX));
    pIC = LocalLock(hIC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
    {
        LocalFree(hIC);
        goto Failure;
    }
    pClientImc->hInputContext = hIC;
 
    hNewKL = GetKeyboardLayout(dwThreadId);
    if (!Imm32CreateInputContext(hIMC, pIC, pClientImc, hNewKL, fSelect))
    {
        LocalUnlock(hIC);
        pClientImc->hInputContext = LocalFree(hIC);
        goto Failure;
    }
 
Success:
    RtlLeaveCriticalSection(&pClientImc->cs);
    InterlockedIncrement(&pClientImc->cLockObj);
    ImmUnlockClientImc(pClientImc);
    return pIC;
 
Failure:
    RtlLeaveCriticalSection(&pClientImc->cs);
    ImmUnlockClientImc(pClientImc);
    return NULL;
}

Referenced by Imm32SelectInputContext(), and ImmLockIMC().

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

Imm32LoadImeVerInfo()

BOOL Imm32LoadImeVerInfo

(

_Out_ PIMEINFOEX

pImeInfoEx

)

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

Imm32ReleaseIME()

BOOL Imm32ReleaseIME

(

_In_ HKL

hKL

)

Definition at line 378 of file ime.c.

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

Referenced by ImmFreeLayout().

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

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

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 ImmCallImeConsoleIME(), and MENU_GetMenu().

Variable Documentation

g_aimm_compat_flags

DWORD g_aimm_compat_flags

extern

Definition at line 204 of file ctf.c.

Referenced by CtfImmSetAppCompatFlags(), and ImmGetAppCompatFlags().

gcsImeDpi

RTL_CRITICAL_SECTION gcsImeDpi

extern

Definition at line 16 of file ime.c.

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

ghImm32Inst

HMODULE ghImm32Inst

extern

Definition at line 17 of file imm.c.

Referenced by C1_DrawLabel(), Imm32DrawBitmap(), Imm32RegisterSoftKeyboard(), ImmCreateSoftKeyboard(), ImmInitializeGlobals(), and T1_DrawLabels().

ghImmHeap

HANDLE ghImmHeap

extern

Definition at line 16 of file utils.c.

Referenced by ImmLocalAlloc().

gpImeDpiList

PIMEDPI gpImeDpiList

extern

Definition at line 17 of file ime.c.

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

gpsi

PSERVERINFO gpsi

extern

Definition at line 18 of file imm.c.

gSharedInfo

SHAREDINFO gSharedInfo

extern

Definition at line 19 of file imm.c.