ctf.c File Reference

#include "precomp.h"
#include <ndk/ldrfuncs.h>
#include <msctf.h>
#include <objidl.h>
#include <compat_undoc.h>
#include <CtfImeTable.h>

Include dependency graph for ctf.c:

Go to the source code of this file.

Classes
struct	IMMTLSDATA
struct	ISPY
struct	IMM_DELAY_SET_LANG_BAND

Macros
#define	IMM32_GET_FN(ppfn, phinstDLL, dll_name, func_name)    Imm32GetFn((FARPROC*)(ppfn), (phinstDLL), (dll_name), #func_name)
#define	OLE32_FN(name)   g_pfnOLE32_##name
#define	Imm32GetOle32Fn(func_name)    IMM32_GET_FN(&OLE32_FN(func_name), &g_hOle32, L"ole32.dll", #func_name)
#define	MSCTF_FN(name)   g_pfnMSCTF_##name
#define	Imm32GetMsctfFn(func_name)    IMM32_GET_FN(&MSCTF_FN(func_name), &g_hMsctf, L"msctf.dll", #func_name)
#define	DEFINE_CTF_IME_FN(func_name, ret_type, params)    typedef ret_type (WINAPI *FN_##func_name)params;
#define	DEFINE_CTF_IME_FN(func_name, ret_type, params)    FN_##func_name g_pfn##func_name = NULL;
#define	CTF_IME_FN(func_name)   g_pfn##func_name
#define	Imm32DeleteIMMISPY(pSpy)   ImmLocalFree(pSpy)
#define	DEFINE_CTF_IME_FN(func_name, ret_type, params)
#define	DEFINE_CTF_IME_FN(func_name, ret_type, params)   CTF_IME_FN(func_name) = NULL;

Typedefs
typedef HRESULT(WINAPI *	FN_CoInitializeEx) (LPVOID, DWORD)
typedef VOID(WINAPI *	FN_CoUninitialize) (VOID)
typedef HRESULT(WINAPI *	FN_CoRegisterInitializeSpy) (IInitializeSpy *, ULARGE_INTEGER *)
typedef HRESULT(WINAPI *	FN_CoRevokeInitializeSpy) (ULARGE_INTEGER)
typedef HRESULT(WINAPI *	FN_TF_CreateLangBarMgr) (ITfLangBarMgr **)
typedef VOID(WINAPI *	FN_TF_InvalidAssemblyListCacheIfExist) (VOID)
typedef BOOL(WINAPI *	FN_ApphelpCheckIME) (_In_z_ LPCWSTR AppName)
typedef struct IMMTLSDATA	IMMTLSDATA
typedef struct IMMTLSDATA *	PIMMTLSDATA
typedef struct ISPY	ISPY
typedef struct ISPY *	PISPY
typedef struct IMM_DELAY_SET_LANG_BAND	IMM_DELAY_SET_LANG_BAND
typedef struct IMM_DELAY_SET_LANG_BAND *	PIMM_DELAY_SET_LANG_BAND

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
static BOOL	Imm32InsideLoaderLock (VOID)
static BOOL	Imm32IsInteractiveUserLogon (VOID)
static BOOL	Imm32IsRunningInMsoobe (VOID)
static BOOL	Imm32IsCUASEnabledInRegistry (VOID)
BOOL	Imm32GetFn (_Inout_opt_ FARPROC *ppfn, _Inout_ HINSTANCE *phinstDLL, _In_ LPCWSTR pszDllName, _In_ LPCSTR pszFuncName)
FN_CoInitializeEx	OLE32_FN (CoInitializeEx)
FN_CoUninitialize	OLE32_FN (CoUninitialize)
FN_CoRegisterInitializeSpy	OLE32_FN (CoRegisterInitializeSpy)
FN_CoRevokeInitializeSpy	OLE32_FN (CoRevokeInitializeSpy)
HRESULT	Imm32CoInitializeEx (VOID)
VOID	Imm32CoUninitialize (VOID)
HRESULT	Imm32CoRegisterInitializeSpy (IInitializeSpy *spy, ULARGE_INTEGER *cookie)
HRESULT	Imm32CoRevokeInitializeSpy (ULARGE_INTEGER cookie)
FN_TF_CreateLangBarMgr	MSCTF_FN (TF_CreateLangBarMgr)
FN_TF_InvalidAssemblyListCacheIfExist	MSCTF_FN (TF_InvalidAssemblyListCacheIfExist)
HRESULT	Imm32TF_CreateLangBarMgr (_Inout_ ITfLangBarMgr **ppBarMgr)
VOID	Imm32TF_InvalidAssemblyListCacheIfExist (VOID)
BOOL	Imm32CheckAndApplyAppCompat (_In_ ULONG dwReason, _In_z_ LPCWSTR pszAppName)
static VOID	Imm32InitTLS (VOID)
static IMMTLSDATA *	Imm32AllocateTLS (VOID)
static IMMTLSDATA *	Imm32GetTLS (VOID)
static DWORD	Imm32GetCoInitCountSkip (VOID)
static DWORD	Imm32IncCoInitCountSkip (VOID)
static DWORD	Imm32DecCoInitCountSkip (VOID)
VOID WINAPI	CtfImmEnterCoInitCountSkipMode (VOID)
BOOL WINAPI	CtfImmLeaveCoInitCountSkipMode (VOID)
static STDMETHODIMP	ISPY_QueryInterface (_Inout_ IInitializeSpy *pThis, _In_ REFIID riid, _Inout_ LPVOID *ppvObj)
static	STDMETHODIMP_ (ULONG)
static STDMETHODIMP	ISPY_PreInitialize (_Inout_ IInitializeSpy *pThis, _In_ DWORD dwCoInit, _In_ DWORD dwCurThreadAptRefs)
static STDMETHODIMP	ISPY_PostInitialize (_Inout_ IInitializeSpy *pThis, _In_ HRESULT hrCoInit, _In_ DWORD dwCoInit, _In_ DWORD dwNewThreadAptRefs)
static STDMETHODIMP	ISPY_PreUninitialize (_Inout_ IInitializeSpy *pThis, _In_ DWORD dwCurThreadAptRefs)
static STDMETHODIMP	ISPY_PostUninitialize (_In_ IInitializeSpy *pThis, _In_ DWORD dwNewThreadAptRefs)
static ISPY *	Imm32AllocIMMISPY (VOID)
HRESULT	CtfImmCoInitialize (VOID)
VOID WINAPI	CtfImmCoUninitialize (VOID)
HINSTANCE	Imm32LoadCtfIme (VOID)
HRESULT	CtfImeCreateThreadMgr (VOID)
BOOL	CtfImeProcessCicHotkey (_In_ HIMC hIMC, _In_ UINT vKey, _In_ LPARAM lParam)
HRESULT	CtfImeDestroyThreadMgr (VOID)
BOOL WINAPI	CtfAImmIsIME (_In_ HKL hKL)
BOOL WINAPI	CtfImmIsCiceroStartedInThread (VOID)
VOID WINAPI	CtfImmSetCiceroStartInThread (_In_ BOOL bStarted)
VOID WINAPI	CtfImmSetAppCompatFlags (_In_ DWORD dwFlags)
HRESULT	CtfImeCreateInputContext (_In_ HIMC hIMC)
HRESULT	CtfImeDestroyInputContext (_In_ HIMC hIMC)
HRESULT	CtfImeSetActiveContextAlways (_In_ HIMC hIMC, _In_ BOOL fActive, _In_ HWND hWnd, _In_ HKL hKL)
static BOOL CALLBACK	Imm32EnumCreateCtfICProc (_In_ HIMC hIMC, _In_ LPARAM lParam)
static BOOL	Imm32IsTIMDisabledInRegistry (VOID)
HRESULT	Imm32ActivateOrDeactivateTIM (_In_ BOOL bCreate)
HRESULT	CtfImmTIMDestroyInputContext (_In_ HIMC hIMC)
HRESULT	CtfImmTIMCreateInputContext (_In_ HIMC hIMC)
HRESULT WINAPI	CtfImmLastEnabledWndDestroy (_In_ BOOL bCreate)
HRESULT WINAPI	CtfAImmActivate (_Out_opt_ HINSTANCE *phinstCtfIme)
HRESULT WINAPI	CtfAImmDeactivate (_In_ BOOL bDestroy)
BOOL WINAPI	CtfImmIsCiceroEnabled (VOID)
BOOL WINAPI	CtfImmIsTextFrameServiceDisabled (VOID)
BOOL WINAPI	ImmDisableTextFrameService (_In_ DWORD dwThreadId)
HRESULT WINAPI	CtfImmTIMActivate (_In_ HKL hKL)
static DWORD APIENTRY	Imm32DelaySetLangBandProc (LPVOID arg)
LRESULT	CtfImmSetLangBand (_In_ HWND hWnd, _In_ BOOL fSet)
BOOL WINAPI	CtfImmGenerateMessage (_In_ HIMC hIMC, _In_ BOOL bSend)
DWORD WINAPI	CtfImmHideToolbarWnd (VOID)
VOID WINAPI	CtfImmRestoreToolbarWnd (_In_ LPVOID pUnused, _In_ DWORD dwShowFlags)
LRESULT WINAPI	CtfImmDispatchDefImeMessage (_In_ HWND hWnd, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam)
BOOL WINAPI	CtfImmIsGuidMapEnable (_In_ HIMC hIMC)
HRESULT WINAPI	CtfImmGetGuidAtom (_In_ HIMC hIMC, _In_ DWORD dwUnknown, _Out_ LPDWORD pdwGuidAtom)

Variables
HINSTANCE	g_hOle32 = NULL
HINSTANCE	g_hMsctf = NULL
DWORD	g_aimm_compat_flags = 0
BOOL	g_disable_CUAS_flag = FALSE
HINSTANCE	g_hCtfIme = NULL
DWORD	g_dwTLSIndex = -1
static const IInitializeSpyVtbl	g_vtblISPY

Macro Definition Documentation

CTF_IME_FN

#define CTF_IME_FN

(

func_name

)

g_pfn##func_name

Definition at line 225 of file ctf.c.

DEFINE_CTF_IME_FN [1/4]

#define DEFINE_CTF_IME_FN	(		func_name,
			ret_type,
			params
	)		typedef ret_type (WINAPI *FN_##func_name)params;

Definition at line 220 of file ctf.c.

DEFINE_CTF_IME_FN [2/4]

#define DEFINE_CTF_IME_FN	(		func_name,
			ret_type,
			params
	)		FN_##func_name g_pfn##func_name = NULL;

Definition at line 220 of file ctf.c.

DEFINE_CTF_IME_FN [3/4]

#define DEFINE_CTF_IME_FN	(		func_name,
			ret_type,
			params
	)

Value:

        CTF_IME_FN(func_name) = (FN_##func_name)GetProcAddress(g_hCtfIme, #func_name); \
        if (!CTF_IME_FN(func_name)) \
        { \
            bSuccess = FALSE; /* Failed */ \
            break; \
        }

Definition at line 220 of file ctf.c.

DEFINE_CTF_IME_FN [4/4]

#define DEFINE_CTF_IME_FN	(		func_name,
			ret_type,
			params
	)		CTF_IME_FN(func_name) = NULL;

Definition at line 220 of file ctf.c.

IMM32_GET_FN

#define IMM32_GET_FN	(		ppfn,
			phinstDLL,
			dll_name,
			func_name
	)		Imm32GetFn((FARPROC*)(ppfn), (phinstDLL), (dll_name), #func_name)

Definition at line 106 of file ctf.c.

Imm32DeleteIMMISPY

#define Imm32DeleteIMMISPY

(

pSpy

)

ImmLocalFree(pSpy)

Definition at line 568 of file ctf.c.

Imm32GetMsctfFn

#define Imm32GetMsctfFn

(

func_name

)

IMM32_GET_FN(&MSCTF_FN(func_name), &g_hMsctf, L"msctf.dll", #func_name)

Definition at line 176 of file ctf.c.

Imm32GetOle32Fn

#define Imm32GetOle32Fn

(

func_name

)

IMM32_GET_FN(&OLE32_FN(func_name), &g_hOle32, L"ole32.dll", #func_name)

Definition at line 127 of file ctf.c.

MSCTF_FN

#define MSCTF_FN

(

name

)

g_pfnMSCTF_##name

Definition at line 168 of file ctf.c.

OLE32_FN

#define OLE32_FN

(

name

)

g_pfnOLE32_##name

Definition at line 115 of file ctf.c.

Typedef Documentation

FN_ApphelpCheckIME

typedef BOOL(WINAPI * FN_ApphelpCheckIME) (_In_z_ LPCWSTR AppName)

Definition at line 228 of file ctf.c.

FN_CoInitializeEx

typedef HRESULT(WINAPI * FN_CoInitializeEx) (LPVOID, DWORD)

Definition at line 117 of file ctf.c.

FN_CoRegisterInitializeSpy

typedef HRESULT(WINAPI * FN_CoRegisterInitializeSpy) (IInitializeSpy *, ULARGE_INTEGER *)

Definition at line 119 of file ctf.c.

FN_CoRevokeInitializeSpy

typedef HRESULT(WINAPI * FN_CoRevokeInitializeSpy) (ULARGE_INTEGER)

Definition at line 120 of file ctf.c.

FN_CoUninitialize

typedef VOID(WINAPI * FN_CoUninitialize) (VOID)

Definition at line 118 of file ctf.c.

FN_TF_CreateLangBarMgr

typedef HRESULT(WINAPI * FN_TF_CreateLangBarMgr) (ITfLangBarMgr **)

Definition at line 170 of file ctf.c.

FN_TF_InvalidAssemblyListCacheIfExist

typedef VOID(WINAPI * FN_TF_InvalidAssemblyListCacheIfExist) (VOID)

Definition at line 171 of file ctf.c.

IMM_DELAY_SET_LANG_BAND

typedef struct IMM_DELAY_SET_LANG_BAND IMM_DELAY_SET_LANG_BAND

IMMTLSDATA

typedef struct IMMTLSDATA IMMTLSDATA

ISPY

typedef struct ISPY ISPY

PIMM_DELAY_SET_LANG_BAND

typedef struct IMM_DELAY_SET_LANG_BAND * PIMM_DELAY_SET_LANG_BAND

PIMMTLSDATA

typedef struct IMMTLSDATA * PIMMTLSDATA

PISPY

typedef struct ISPY * PISPY

Function Documentation

CtfAImmActivate()

HRESULT WINAPI CtfAImmActivate

(

_Out_opt_ HINSTANCE *

phinstCtfIme

)

Definition at line 1009 of file ctf.c.

{
    HRESULT hr;
    HINSTANCE hinstCtfIme;
 
    TRACE("(%p)\n", phinstCtfIme);
 
    /* Load a CTF IME file if necessary */
    hinstCtfIme = Imm32LoadCtfIme();
 
    /* Create a thread manager of the CTF IME */
    hr = CtfImeCreateThreadMgr();
    if (hr == S_OK)
    {
        /* Update CI_... flags of the thread client info */
        GetWin32ClientInfo()->CI_flags |= CI_AIMMACTIVATED; /* Activate AIMM */
        GetWin32ClientInfo()->CI_flags &= ~CI_TSFDISABLED;  /* Enable TSF */
 
        /* Create the CTF input contexts */
        ImmEnumInputContext(0, Imm32EnumCreateCtfICProc, 0);
    }
 
    if (phinstCtfIme)
        *phinstCtfIme = hinstCtfIme;
 
    return hr;
}

CtfAImmDeactivate()

HRESULT WINAPI CtfAImmDeactivate

(

_In_ BOOL

bDestroy

)

Definition at line 1044 of file ctf.c.

{
    HRESULT hr;
 
    if (!bDestroy)
        return E_FAIL;
 
    hr = CtfImeDestroyThreadMgr();
    if (hr == S_OK)
    {
        GetWin32ClientInfo()->CI_flags &= ~CI_AIMMACTIVATED; /* Deactivate AIMM */
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;    /* Disable TSF */
    }
 
    return hr;
}

CtfAImmIsIME()

BOOL WINAPI CtfAImmIsIME

(

_In_ HKL

hKL

)

Definition at line 767 of file ctf.c.

{
    TRACE("(%p)\n", hKL);
    if (!Imm32LoadCtfIme())
        return ImmIsIME(hKL);
    return CTF_IME_FN(CtfImeIsIME)(hKL);
}

CtfImeCreateInputContext()

HRESULT CtfImeCreateInputContext

(

_In_ HIMC

hIMC

)

Definition at line 816 of file ctf.c.

{
    TRACE("(%p)\n", hIMC);
 
    if (!Imm32LoadCtfIme())
        return E_FAIL;
 
    return CTF_IME_FN(CtfImeCreateInputContext)(hIMC);
}

Referenced by CtfImeCreateInputContext(), CtfImmTIMCreateInputContext(), and Imm32EnumCreateCtfICProc().

CtfImeCreateThreadMgr()

HRESULT CtfImeCreateThreadMgr

(

VOID

)

Definition at line 723 of file ctf.c.

{
    TRACE("()\n");
 
    if (!Imm32LoadCtfIme())
        return E_FAIL;
 
    return CTF_IME_FN(CtfImeCreateThreadMgr)();
}

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

CtfImeDestroyInputContext()

HRESULT CtfImeDestroyInputContext

(

_In_ HIMC

hIMC

)

Definition at line 831 of file ctf.c.

{
    TRACE("(%p)\n", hIMC);
 
    if (!Imm32LoadCtfIme())
        return E_FAIL;
 
    return CTF_IME_FN(CtfImeDestroyInputContext)(hIMC);
}

Referenced by CtfImeDestroyInputContext(), and CtfImmTIMDestroyInputContext().

CtfImeDestroyThreadMgr()

HRESULT CtfImeDestroyThreadMgr

(

VOID

)

Definition at line 751 of file ctf.c.

{
    TRACE("()\n");
 
    if (!Imm32LoadCtfIme())
        return E_FAIL;
 
    return CTF_IME_FN(CtfImeDestroyThreadMgr)();
}

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

CtfImeProcessCicHotkey()

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

Definition at line 737 of file ctf.c.

{
    TRACE("(%p, %u, %p)\n", hIMC, vKey, lParam);
 
    if (!Imm32LoadCtfIme())
        return FALSE;
 
    return CTF_IME_FN(CtfImeProcessCicHotkey)(hIMC, vKey, lParam);
}

Referenced by CtfImeProcessCicHotkey().

CtfImeSetActiveContextAlways()

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

Definition at line 845 of file ctf.c.

{
    TRACE("(%p, %d, %p, %p)\n", hIMC, fActive, hWnd, hKL);
 
    if (!Imm32LoadCtfIme())
        return E_FAIL;
 
    return CTF_IME_FN(CtfImeSetActiveContextAlways)(hIMC, fActive, hWnd, hKL);
}

Referenced by CtfImeSetActiveContextAlways().

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

CtfImmCoUninitialize()

VOID WINAPI CtfImmCoUninitialize

(

VOID

)

Definition at line 614 of file ctf.c.

{
    IMMTLSDATA *pData;
 
    if (!(GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT))
        return; /* Not CoInitialize'd */
 
    pData = Imm32GetTLS();
    if (pData)
    {
        pData->bUninitializing = TRUE;
        Imm32CoUninitialize(); /* Do CoUninitialize */
        pData->bUninitializing = FALSE;
 
        GetWin32ClientInfo()->CI_flags &= ~CI_CTFCOINIT;
    }
 
    pData = Imm32AllocateTLS();
    if (!pData || !pData->pSpy)
        return; /* There were no spy */
 
    /* Our work is done. We don't need spies like you anymore. */
    Imm32CoRevokeInitializeSpy(pData->uliCookie);
    ISPY_Release(pData->pSpy);
    pData->pSpy = NULL;
    pData->uliCookie.QuadPart = 0;
}

Referenced by ImmDisableTextFrameService(), and ISPY_PreInitialize().

CtfImmDispatchDefImeMessage()

LRESULT WINAPI CtfImmDispatchDefImeMessage	(	_In_ HWND	hWnd,
		_In_ UINT	uMsg,
		_In_ WPARAM	wParam,
		_In_ LPARAM	lParam
	)

Definition at line 1416 of file ctf.c.

{
    TRACE("(%p, %u, %p, %p)\n", hWnd, uMsg, wParam, lParam);
 
    if (RtlDllShutdownInProgress() || Imm32InsideLoaderLock() || !Imm32LoadCtfIme())
        return 0;
 
    return CTF_IME_FN(CtfImeDispatchDefImeMessage)(hWnd, uMsg, wParam, lParam);
}

Referenced by ImeWndProc_common().

CtfImmEnterCoInitCountSkipMode()

VOID WINAPI CtfImmEnterCoInitCountSkipMode

(

VOID

)

Definition at line 381 of file ctf.c.

{
    IMMTLSDATA *pData;
 
    TRACE("()\n");
 
    pData = Imm32GetTLS();
    if (pData)
        ++(pData->bDoCount);
}

CtfImmGenerateMessage()

BOOL WINAPI CtfImmGenerateMessage	(	_In_ HIMC	hIMC,
		_In_ BOOL	bSend
	)

Definition at line 1272 of file ctf.c.

{
    DWORD_PTR dwImeThreadId, dwCurrentThreadId;
    PCLIENTIMC pClientImc;
    BOOL bUnicode;
    LPINPUTCONTEXT pIC;
    DWORD iMsg, dwNumMsgBuf;
    LPTRANSMSG pOldTransMsg, pNewTransMsg;
    SIZE_T cbTransMsg;
 
    TRACE("(%p, %d)\n", hIMC, bSend);
 
    dwImeThreadId = NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    dwCurrentThreadId = GetCurrentThreadId();
    if (dwImeThreadId != dwCurrentThreadId)
    {
        ERR("%p vs %p\n", dwImeThreadId, dwCurrentThreadId);
        return FALSE;
    }
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return FALSE;
 
    bUnicode = !!(pClientImc->dwFlags & CLIENTIMC_WIDE);
    ImmUnlockClientImc(pClientImc);
 
    pIC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    dwNumMsgBuf = pIC->dwNumMsgBuf;
    pOldTransMsg = (LPTRANSMSG)ImmLockIMCC(pIC->hMsgBuf);
    if (IS_NULL_UNEXPECTEDLY(pOldTransMsg))
    {
        pIC->dwNumMsgBuf = 0;
        ImmUnlockIMC(hIMC);
        return TRUE;
    }
 
    cbTransMsg = sizeof(TRANSMSG) * dwNumMsgBuf;
    pNewTransMsg = (PTRANSMSG)ImmLocalAlloc(0, cbTransMsg);
    if (IS_NULL_UNEXPECTEDLY(pNewTransMsg))
    {
        ImmUnlockIMCC(pIC->hMsgBuf);
        pIC->dwNumMsgBuf = 0;
        ImmUnlockIMC(hIMC);
        return TRUE;
    }
 
    RtlCopyMemory(pNewTransMsg, pOldTransMsg, cbTransMsg);
 
    for (iMsg = 0; iMsg < dwNumMsgBuf; ++iMsg)
    {
        HWND hWnd = pIC->hWnd;
        UINT uMsg = pNewTransMsg[iMsg].message;
        WPARAM wParam = pNewTransMsg[iMsg].wParam;
        LPARAM lParam = pNewTransMsg[iMsg].lParam;
        if (bSend)
        {
            if (bUnicode)
                SendMessageW(hWnd, uMsg, wParam, lParam);
            else
                SendMessageA(hWnd, uMsg, wParam, lParam);
        }
        else
        {
            if (bUnicode)
                PostMessageW(hWnd, uMsg, wParam, lParam);
            else
                PostMessageA(hWnd, uMsg, wParam, lParam);
        }
    }
 
    ImmLocalFree(pNewTransMsg);
    ImmUnlockIMCC(pIC->hMsgBuf);
    pIC->dwNumMsgBuf = 0; /* Processed */
    ImmUnlockIMC(hIMC);
 
    return TRUE;
}

CtfImmGetGuidAtom()

HRESULT WINAPI CtfImmGetGuidAtom	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwUnknown,
		_Out_ LPDWORD	pdwGuidAtom
	)

Definition at line 1467 of file ctf.c.

{
    HRESULT hr = E_FAIL;
    PIMEDPI pImeDpi;
    DWORD dwThreadId;
    HKL hKL;
 
    TRACE("(%p, 0xlX, %p)\n", hIMC, dwUnknown, pdwGuidAtom);
 
    *pdwGuidAtom = 0;
 
    if (!IS_CICERO_MODE() || IS_16BIT_MODE())
        return hr;
 
    dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    hKL = GetKeyboardLayout(dwThreadId);
    if (IS_IME_HKL(hKL))
        return S_OK;
 
    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return hr;
 
    hr = pImeDpi->CtfImeGetGuidAtom(hIMC, dwUnknown, pdwGuidAtom);
 
    ImmUnlockImeDpi(pImeDpi);
    return hr;
}

CtfImmHideToolbarWnd()

DWORD WINAPI CtfImmHideToolbarWnd

(

VOID

)

Definition at line 1362 of file ctf.c.

{
    ITfLangBarMgr *pBarMgr;
    DWORD dwShowFlags = 0;
    BOOL bShown;
 
    TRACE("()\n");
 
    if (FAILED(Imm32TF_CreateLangBarMgr(&pBarMgr)))
        return dwShowFlags;
 
    if (SUCCEEDED(pBarMgr->lpVtbl->GetShowFloatingStatus(pBarMgr, &dwShowFlags)))
    {
        bShown = !(dwShowFlags & 0x800);
        dwShowFlags &= 0xF;
        if (bShown)
            pBarMgr->lpVtbl->ShowFloating(pBarMgr, 8);
    }
 
    pBarMgr->lpVtbl->Release(pBarMgr);
    return dwShowFlags;
}

Referenced by ImeWnd_OnImeControl().

CtfImmIsCiceroEnabled()

BOOL WINAPI CtfImmIsCiceroEnabled

(

VOID

)

Definition at line 1068 of file ctf.c.

{
    return IS_CICERO_MODE();
}

CtfImmIsCiceroStartedInThread()

BOOL WINAPI CtfImmIsCiceroStartedInThread

(

VOID

)

Definition at line 781 of file ctf.c.

{
    TRACE("()\n");
    return !!(GetWin32ClientInfo()->CI_flags & CI_CICERO_STARTED);
}

Referenced by CtfImeProcessCicHotkey(), and ImmProcessKey().

CtfImmIsGuidMapEnable()

BOOL WINAPI CtfImmIsGuidMapEnable

(

_In_ HIMC

hIMC

)

Definition at line 1434 of file ctf.c.

{
    DWORD dwThreadId;
    HKL hKL;
    PIMEDPI pImeDpi;
    BOOL ret = FALSE;
 
    TRACE("(%p)\n", hIMC);
 
    if (!IS_CICERO_MODE() || IS_16BIT_MODE())
        return ret;
 
    dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    hKL = GetKeyboardLayout(dwThreadId);
 
    if (IS_IME_HKL(hKL))
        return ret;
 
    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return ret;
 
    ret = pImeDpi->CtfImeIsGuidMapEnable(hIMC);
 
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

CtfImmIsTextFrameServiceDisabled()

BOOL WINAPI CtfImmIsTextFrameServiceDisabled

(

VOID

)

Definition at line 1079 of file ctf.c.

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

Referenced by Imm32SelectInputContext(), and ImmGetImeInfoEx().

CtfImmLastEnabledWndDestroy()

HRESULT WINAPI CtfImmLastEnabledWndDestroy

(

_In_ BOOL

bCreate

)

Definition at line 996 of file ctf.c.

{
    TRACE("(%d)\n", bCreate);
    return Imm32ActivateOrDeactivateTIM(bCreate);
}

CtfImmLeaveCoInitCountSkipMode()

BOOL WINAPI CtfImmLeaveCoInitCountSkipMode

(

VOID

)

Definition at line 395 of file ctf.c.

{
    IMMTLSDATA *pData;
 
    TRACE("()\n");
 
    pData = Imm32GetTLS();
    if (!pData || !pData->bDoCount)
        return FALSE;
 
    --(pData->bDoCount);
    return TRUE;
}

CtfImmRestoreToolbarWnd()

VOID WINAPI CtfImmRestoreToolbarWnd	(	_In_ LPVOID	pUnused,
		_In_ DWORD	dwShowFlags
	)

Definition at line 1391 of file ctf.c.

{
    HRESULT hr;
    ITfLangBarMgr *pBarMgr;
 
    UNREFERENCED_PARAMETER(pUnused);
 
    TRACE("(%p, 0x%X)\n", pUnused, dwShowFlags);
 
    hr = Imm32TF_CreateLangBarMgr(&pBarMgr);
    if (FAILED_UNEXPECTEDLY(hr))
        return;
 
    if (dwShowFlags)
        pBarMgr->lpVtbl->ShowFloating(pBarMgr, dwShowFlags);
 
    pBarMgr->lpVtbl->Release(pBarMgr);
}

Referenced by ImeWnd_OnImeControl().

CtfImmSetAppCompatFlags()

VOID WINAPI CtfImmSetAppCompatFlags

(

_In_ DWORD

dwFlags

)

Definition at line 805 of file ctf.c.

{
    TRACE("(0x%08X)\n", dwFlags);
    if (!(dwFlags & 0xF0FFFFFF))
        g_aimm_compat_flags = dwFlags;
}

CtfImmSetCiceroStartInThread()

VOID WINAPI CtfImmSetCiceroStartInThread

(

_In_ BOOL

bStarted

)

Definition at line 790 of file ctf.c.

{
    TRACE("(%d)\n", bStarted);
    if (bStarted)
        GetWin32ClientInfo()->CI_flags |= CI_CICERO_STARTED;
    else
        GetWin32ClientInfo()->CI_flags &= ~CI_CICERO_STARTED;
}

CtfImmSetLangBand()

LRESULT CtfImmSetLangBand	(	_In_ HWND	hWnd,
		_In_ BOOL	fSet
	)

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

CtfImmTIMActivate()

HRESULT WINAPI CtfImmTIMActivate

(

_In_ HKL

hKL

)

Definition at line 1123 of file ctf.c.

{
    HRESULT hr = S_OK;
 
    TRACE("(%p)\n", hKL);
 
    if (g_disable_CUAS_flag)
    {
        TRACE("g_disable_CUAS_flag\n");
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
        return FALSE;
    }
 
    if (GetWin32ClientInfo()->CI_flags & CI_TSFDISABLED)
    {
        TRACE("CI_TSFDISABLED\n");
        return FALSE;
    }
 
    if (Imm32IsTIMDisabledInRegistry())
    {
        TRACE("TIM is disabled in registry\n");
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
        return FALSE;
    }
 
    if (!Imm32IsInteractiveUserLogon() || Imm32IsRunningInMsoobe())
    {
        TRACE("TIM is disabled due to LOGON or MSOBE\n");
        return FALSE;
    }
 
    if (!Imm32IsCUASEnabledInRegistry())
    {
        TRACE("CUAS is disabled in registry\n");
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
        return FALSE;
    }
 
    if (NtCurrentTeb()->ProcessEnvironmentBlock->AppCompatFlags.LowPart & 0x100)
    {
        TRACE("CUAS is disabled by AppCompatFlags\n");
        GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
        return FALSE;
    }
 
    if (RtlIsThreadWithinLoaderCallout() || Imm32InsideLoaderLock())
    {
        TRACE("TIM is disabled by Loader\n");
        return FALSE;
    }
 
    if (!IS_CICERO_MODE() || IS_16BIT_MODE())
    {
        TRACE("TIM is disabled because CICERO mode is unset\n");
        return FALSE;
    }
 
    if (IS_IME_HKL(hKL))
        hKL = (HKL)UlongToHandle(MAKELONG(LOWORD(hKL), LOWORD(hKL)));
 
    if (!ImmLoadIME(hKL))
        Imm32TF_InvalidAssemblyListCacheIfExist();
 
    CtfImmCoInitialize();
 
    if ((GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT) &&
        !(GetWin32ClientInfo()->CI_flags & CI_CTFTIM))
    {
        hr = CtfImeCreateThreadMgr();
        if (SUCCEEDED(hr))
            GetWin32ClientInfo()->CI_flags |= CI_CTFTIM;
    }
 
    return hr;
}

Referenced by CtfLoadThreadLayout(), and Imm32InternalLockIMC().

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() || (GetWin32ClientInfo()->dwCompatFlags2 & 2))
        return E_NOINTERFACE;
 
    return CtfImeDestroyInputContext(hIMC);
}

Referenced by Imm32DestroyInputContext().

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

Imm32AllocateTLS()

static IMMTLSDATA * Imm32AllocateTLS ( VOID  )

static

Definition at line 296 of file ctf.c.

{
    IMMTLSDATA *pData;
 
    if (g_dwTLSIndex == -1)
        return NULL;
 
    pData = (IMMTLSDATA*)TlsGetValue(g_dwTLSIndex);
    if (pData)
        return pData;
 
    pData = (IMMTLSDATA*)ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(IMMTLSDATA));
    if (IS_NULL_UNEXPECTEDLY(pData))
        return NULL;
 
    if (IS_FALSE_UNEXPECTEDLY(TlsSetValue(g_dwTLSIndex, pData)))
    {
        ImmLocalFree(pData);
        return NULL;
    }
 
    return pData;
}

Referenced by CtfImmCoInitialize(), and CtfImmCoUninitialize().

Imm32AllocIMMISPY()

static ISPY * Imm32AllocIMMISPY ( VOID  )

static

Definition at line 557 of file ctf.c.

{
    ISPY *pSpy = (ISPY*)ImmLocalAlloc(0, sizeof(ISPY));
    if (!pSpy)
        return NULL;
 
    pSpy->m_pSpyVtbl = &g_vtblISPY;
    pSpy->m_cRefs = 1;
    return pSpy;
}

Referenced by CtfImmCoInitialize().

Imm32CheckAndApplyAppCompat()

BOOL Imm32CheckAndApplyAppCompat	(	_In_ ULONG	dwReason,
		_In_z_ LPCWSTR	pszAppName
	)

Definition at line 235 of file ctf.c.

{
    HINSTANCE hinstApphelp;
    FN_ApphelpCheckIME pApphelpCheckIME;
 
    /* Query the application compatibility patcher */
    if (BaseCheckAppcompatCache(pszAppName, INVALID_HANDLE_VALUE, NULL, &dwReason))
        return TRUE; /* The app's IME is not disabled */
 
    /* Load apphelp.dll if necessary */
    hinstApphelp = GetModuleHandleW(L"apphelp.dll");
    if (!hinstApphelp)
    {
        hinstApphelp = LoadLibraryW(L"apphelp.dll");
        if (!hinstApphelp)
            return TRUE; /* There is no apphelp.dll. The app's IME is not disabled */
    }
 
    /* Is ApphelpCheckIME implemented? */
    pApphelpCheckIME = (FN_ApphelpCheckIME)GetProcAddress(hinstApphelp, "ApphelpCheckIME");
    if (!pApphelpCheckIME)
        return TRUE; /* Not implemented. The app's IME is not disabled */
 
    /* Is the app's IME disabled or not? */
    return pApphelpCheckIME(pszAppName);
}

Referenced by Imm32LoadCtfIme().

Imm32CoInitializeEx()

HRESULT Imm32CoInitializeEx

(

VOID

)

Definition at line 130 of file ctf.c.

{
    if (!Imm32GetOle32Fn(CoInitializeEx))
        return E_FAIL;
 
    return OLE32_FN(CoInitializeEx)(NULL, COINIT_APARTMENTTHREADED);
}

Referenced by CtfImmCoInitialize(), and ISPY_PreUninitialize().

Imm32CoRegisterInitializeSpy()

HRESULT Imm32CoRegisterInitializeSpy	(	IInitializeSpy *	spy,
		ULARGE_INTEGER *	cookie
	)

Definition at line 146 of file ctf.c.

{
    if (!Imm32GetOle32Fn(CoRegisterInitializeSpy))
        return E_FAIL;
 
    return OLE32_FN(CoRegisterInitializeSpy)(spy, cookie);
}

Referenced by CtfImmCoInitialize().

Imm32CoRevokeInitializeSpy()

HRESULT Imm32CoRevokeInitializeSpy

(

ULARGE_INTEGER

cookie

)

Definition at line 154 of file ctf.c.

{
    if (!Imm32GetOle32Fn(CoRevokeInitializeSpy))
        return E_FAIL;
 
    return OLE32_FN(CoRevokeInitializeSpy)(cookie);
}

Referenced by CtfImmCoUninitialize().

Imm32CoUninitialize()

VOID Imm32CoUninitialize

(

VOID

)

Definition at line 138 of file ctf.c.

{
    if (!Imm32GetOle32Fn(CoUninitialize))
        return;
 
    OLE32_FN(CoUninitialize)();
}

Referenced by CtfImmCoUninitialize().

Imm32DecCoInitCountSkip()

static DWORD Imm32DecCoInitCountSkip ( VOID  )

static

Definition at line 359 of file ctf.c.

{
    DWORD dwSkipCount;
    IMMTLSDATA *pData;
 
    pData = Imm32GetTLS();;
    if (!pData)
        return 0;
 
    dwSkipCount = pData->dwSkipCount;
    if (pData->bDoCount)
    {
        if (dwSkipCount)
            pData->dwSkipCount = dwSkipCount - 1;
    }
 
    return dwSkipCount;
}

Referenced by ISPY_PostUninitialize().

Imm32DelaySetLangBandProc()

static DWORD APIENTRY Imm32DelaySetLangBandProc ( LPVOID  arg )

static

Definition at line 1211 of file ctf.c.

{
    HWND hwndDefIME;
    WPARAM wParam;
    DWORD_PTR lResult;
    PIMM_DELAY_SET_LANG_BAND pSetBand = arg;
 
    Sleep(3000); /* Delay 3 seconds! */
 
    hwndDefIME = ImmGetDefaultIMEWnd(pSetBand->hWnd);
    if (hwndDefIME)
    {
        wParam = (pSetBand->fSet ? IMS_SETLANGBAND : IMS_UNSETLANGBAND);
        SendMessageTimeoutW(hwndDefIME, WM_IME_SYSTEM, wParam, (LPARAM)pSetBand->hWnd,
                            SMTO_BLOCK | SMTO_ABORTIFHUNG, 5000, &lResult);
    }
    ImmLocalFree(pSetBand);
    return FALSE;
}

Referenced by CtfImmSetLangBand().

Imm32EnumCreateCtfICProc()

static BOOL CALLBACK Imm32EnumCreateCtfICProc ( _In_ HIMC  hIMC, _In_ LPARAM  lParam  )

static

Definition at line 863 of file ctf.c.

{
    UNREFERENCED_PARAMETER(lParam);
    CtfImeCreateInputContext(hIMC);
    return TRUE; /* Continue */
}

Referenced by CtfAImmActivate().

Imm32GetCoInitCountSkip()

static DWORD Imm32GetCoInitCountSkip ( VOID  )

static

Definition at line 331 of file ctf.c.

{
    IMMTLSDATA *pData = Imm32GetTLS();
    if (!pData)
        return 0;
    return pData->dwSkipCount;
}

Referenced by ISPY_PostInitialize().

Imm32GetFn()

BOOL Imm32GetFn	(	_Inout_opt_ FARPROC *	ppfn,
		_Inout_ HINSTANCE *	phinstDLL,
		_In_ LPCWSTR	pszDllName,
		_In_ LPCSTR	pszFuncName
	)

Definition at line 83 of file ctf.c.

{
    WCHAR szPath[MAX_PATH];
 
    if (*ppfn)
        return TRUE;
 
    if (*phinstDLL == NULL)
    {
        Imm32GetSystemLibraryPath(szPath, _countof(szPath), pszDllName);
        *phinstDLL = LoadLibraryExW(szPath, NULL, 0);
        if (*phinstDLL == NULL)
            return FALSE;
    }
 
    *ppfn = (FARPROC)GetProcAddress(*phinstDLL, pszFuncName);
    return *ppfn != NULL;
}

Imm32GetTLS()

static IMMTLSDATA * Imm32GetTLS ( VOID  )

static

Definition at line 321 of file ctf.c.

{
    if (g_dwTLSIndex == -1)
        return NULL;
 
    return (IMMTLSDATA*)TlsGetValue(g_dwTLSIndex);
}

Referenced by CtfImmCoUninitialize(), CtfImmEnterCoInitCountSkipMode(), CtfImmLeaveCoInitCountSkipMode(), Imm32DecCoInitCountSkip(), Imm32GetCoInitCountSkip(), Imm32IncCoInitCountSkip(), and ISPY_PreUninitialize().

Imm32IncCoInitCountSkip()

static DWORD Imm32IncCoInitCountSkip ( VOID  )

static

Definition at line 341 of file ctf.c.

{
    IMMTLSDATA *pData;
    DWORD dwOldSkipCount;
 
    pData = Imm32GetTLS();
    if (!pData)
        return 0;
 
    dwOldSkipCount = pData->dwSkipCount;
    if (pData->bDoCount)
        pData->dwSkipCount = dwOldSkipCount + 1;
 
    return dwOldSkipCount;
}

Referenced by ISPY_PreInitialize().

Imm32InitTLS()

static VOID Imm32InitTLS ( VOID  )

static

Definition at line 285 of file ctf.c.

{
    RtlEnterCriticalSection(&gcsImeDpi);
 
    if (g_dwTLSIndex == -1)
        g_dwTLSIndex = TlsAlloc();
 
    RtlLeaveCriticalSection(&gcsImeDpi);
}

Referenced by CtfImmCoInitialize().

Imm32InsideLoaderLock()

static BOOL Imm32InsideLoaderLock ( VOID  )

static

Definition at line 16 of file ctf.c.

{
    return NtCurrentTeb()->ProcessEnvironmentBlock->LoaderLock->OwningThread ==
           NtCurrentTeb()->ClientId.UniqueThread;
}

Referenced by CtfImmDispatchDefImeMessage(), CtfImmTIMActivate(), and ISPY_PreUninitialize().

Imm32IsCUASEnabledInRegistry()

static BOOL Imm32IsCUASEnabledInRegistry ( VOID  )

static

Definition at line 61 of file ctf.c.

{
    HKEY hKey;
    LSTATUS error;
    DWORD dwType, dwData, cbData;
 
    error = RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\CTF\\SystemShared", &hKey);
    if (error != ERROR_SUCCESS)
        return FALSE;
 
    dwData = 0;
    cbData = sizeof(dwData);
    error = RegQueryValueExW(hKey, L"CUAS", NULL, &dwType, (LPBYTE)&dwData, &cbData);
    RegCloseKey(hKey);
 
    if (error != ERROR_SUCCESS || dwType != REG_DWORD)
        return FALSE;
 
    return !!dwData;
}

Referenced by CtfImmTIMActivate().

Imm32IsInteractiveUserLogon()

static BOOL Imm32IsInteractiveUserLogon ( VOID  )

static

Definition at line 23 of file ctf.c.

{
    BOOL bOK, IsMember = FALSE;
    PSID pSid;
    SID_IDENTIFIER_AUTHORITY IdentAuth = { SECURITY_NT_AUTHORITY };
 
    if (!AllocateAndInitializeSid(&IdentAuth, 1, SECURITY_INTERACTIVE_RID,
                                  0, 0, 0, 0, 0, 0, 0, &pSid))
    {
        ERR("Error: %ld\n", GetLastError());
        return FALSE;
    }
 
    bOK = CheckTokenMembership(NULL, pSid, &IsMember);
 
    if (pSid)
        FreeSid(pSid);
 
    return bOK && IsMember;
}

Referenced by CtfImmTIMActivate().

Imm32IsRunningInMsoobe()

static BOOL Imm32IsRunningInMsoobe ( VOID  )

static

Definition at line 45 of file ctf.c.

{
    LPWSTR pchFilePart = NULL;
    WCHAR Buffer[MAX_PATH], FileName[MAX_PATH];
 
    if (!GetModuleFileNameW(NULL, FileName, _countof(FileName)))
        return FALSE;
 
    GetFullPathNameW(FileName, _countof(Buffer), Buffer, &pchFilePart);
    if (!pchFilePart)
        return FALSE;
 
    return lstrcmpiW(pchFilePart, L"msoobe.exe") == 0;
}

Referenced by CtfImmTIMActivate().

Imm32IsTIMDisabledInRegistry()

static BOOL Imm32IsTIMDisabledInRegistry ( VOID  )

static

Definition at line 877 of file ctf.c.

{
    DWORD dwData, cbData;
    HKEY hKey;
    LSTATUS error;
 
    error = RegOpenKeyW(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\CTF", &hKey);
    if (error != ERROR_SUCCESS)
        return FALSE;
 
    dwData = 0;
    cbData = sizeof(dwData);
    RegQueryValueExW(hKey, L"Disable Thread Input Manager", NULL, NULL, (LPBYTE)&dwData, &cbData);
    RegCloseKey(hKey);
    return !!dwData;
}

Referenced by CtfImmTIMActivate().

Imm32LoadCtfIme()

HINSTANCE Imm32LoadCtfIme

(

VOID

)

Definition at line 647 of file ctf.c.

{
    BOOL bSuccess = FALSE;
    IMEINFOEX ImeInfoEx;
    WCHAR szImeFile[MAX_PATH];
 
    /* Lock the IME interface */
    RtlEnterCriticalSection(&gcsImeDpi);
 
    do
    {
        if (g_hCtfIme) /* Already loaded? */
        {
            bSuccess = TRUE;
            break;
        }
 
        /*
         * NOTE: (HKL)0x04090409 is English US keyboard (default).
         * The Cicero keyboard logically uses English US keyboard.
         */
        if (!ImmLoadLayout((HKL)ULongToHandle(0x04090409), &ImeInfoEx))
            break;
 
        /* Build a path string in system32. The installed IME file must be in system32. */
        Imm32GetSystemLibraryPath(szImeFile, _countof(szImeFile), ImeInfoEx.wszImeFile);
 
        /* Is the CTF IME disabled by app compatibility patcher? */
        if (!Imm32CheckAndApplyAppCompat(0, szImeFile))
            break; /* This IME is disabled */
 
        /* Load a CTF IME file */
        g_hCtfIme = LoadLibraryW(szImeFile);
        if (!g_hCtfIme)
            break;
 
        /* Assume success */
        bSuccess = TRUE;
 
        /* Retrieve the CTF IME functions */
#undef DEFINE_CTF_IME_FN
#define DEFINE_CTF_IME_FN(func_name, ret_type, params) \
        CTF_IME_FN(func_name) = (FN_##func_name)GetProcAddress(g_hCtfIme, #func_name); \
        if (!CTF_IME_FN(func_name)) \
        { \
            bSuccess = FALSE; /* Failed */ \
            break; \
        }
#include <CtfImeTable.h>
    } while (0);
 
    /* Unload the CTF IME if failed */
    if (!bSuccess)
    {
        /* Set NULL to the function pointers */
#undef DEFINE_CTF_IME_FN
#define DEFINE_CTF_IME_FN(func_name, ret_type, params) CTF_IME_FN(func_name) = NULL;
#include <CtfImeTable.h>
 
        if (g_hCtfIme)
        {
            FreeLibrary(g_hCtfIme);
            g_hCtfIme = NULL;
        }
    }
 
    /* Unlock the IME interface */
    RtlLeaveCriticalSection(&gcsImeDpi);
 
    return g_hCtfIme;
}

Referenced by CtfAImmActivate(), CtfAImmIsIME(), CtfImeCreateInputContext(), CtfImeCreateThreadMgr(), CtfImeDestroyInputContext(), CtfImeDestroyThreadMgr(), CtfImeProcessCicHotkey(), CtfImeSetActiveContextAlways(), and CtfImmDispatchDefImeMessage().

Imm32TF_CreateLangBarMgr()

HRESULT Imm32TF_CreateLangBarMgr

(

_Inout_ ITfLangBarMgr **

ppBarMgr

)

Definition at line 179 of file ctf.c.

{
    TRACE("TF_CreateLangBarMgr(%p)\n", ppBarMgr);
 
    if (!Imm32GetMsctfFn(TF_CreateLangBarMgr))
        return E_FAIL;
 
    return MSCTF_FN(TF_CreateLangBarMgr)(ppBarMgr);
}

Referenced by CtfImmHideToolbarWnd(), and CtfImmRestoreToolbarWnd().

Imm32TF_InvalidAssemblyListCacheIfExist()

VOID Imm32TF_InvalidAssemblyListCacheIfExist

(

VOID

)

Definition at line 189 of file ctf.c.

{
    TRACE("TF_InvalidAssemblyListCacheIfExist()\n");
 
    if (!Imm32GetMsctfFn(TF_InvalidAssemblyListCacheIfExist))
        return;
 
    MSCTF_FN(TF_InvalidAssemblyListCacheIfExist)();
}

Referenced by CtfImmTIMActivate().

ImmDisableTextFrameService()

BOOL WINAPI ImmDisableTextFrameService

(

_In_ DWORD

dwThreadId

)

Definition at line 1088 of file ctf.c.

{
    HRESULT hr = S_OK;
 
    TRACE("(0x%lX)\n", dwThreadId);
 
    if (dwThreadId == -1)
        g_disable_CUAS_flag = TRUE;
 
    if ((dwThreadId && !g_disable_CUAS_flag) || (GetWin32ClientInfo()->CI_flags & CI_TSFDISABLED))
        return TRUE;
 
    GetWin32ClientInfo()->CI_flags |= CI_TSFDISABLED;
 
    if (IS_CICERO_MODE() && !IS_16BIT_MODE() &&
        (GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT) &&
        (GetWin32ClientInfo()->CI_flags & CI_CTFTIM))
    {
        hr = CtfImeDestroyThreadMgr();
        if (SUCCEEDED(hr))
        {
            GetWin32ClientInfo()->CI_flags &= ~CI_CTFTIM;
            CtfImmCoUninitialize();
        }
    }
 
    return hr == S_OK;
}

ISPY_PostInitialize()

static STDMETHODIMP ISPY_PostInitialize ( _Inout_ IInitializeSpy *  pThis, _In_ HRESULT  hrCoInit, _In_ DWORD  dwCoInit, _In_ DWORD  dwNewThreadAptRefs  )

static

Definition at line 491 of file ctf.c.

{
    DWORD CoInitCountSkip;
 
    UNREFERENCED_PARAMETER(pThis);
    UNREFERENCED_PARAMETER(dwCoInit);
 
    CoInitCountSkip = Imm32GetCoInitCountSkip();
 
    if ((hrCoInit != S_FALSE) ||
        (dwNewThreadAptRefs != CoInitCountSkip + 2) ||
        !(GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT))
    {
        return hrCoInit;
    }
 
    return S_OK;
}

ISPY_PostUninitialize()

static STDMETHODIMP ISPY_PostUninitialize ( _In_ IInitializeSpy *  pThis, _In_ DWORD  dwNewThreadAptRefs  )

static

Definition at line 535 of file ctf.c.

{
    UNREFERENCED_PARAMETER(pThis);
    UNREFERENCED_PARAMETER(dwNewThreadAptRefs);
    Imm32DecCoInitCountSkip();
    return S_OK;
}

ISPY_PreInitialize()

static STDMETHODIMP ISPY_PreInitialize ( _Inout_ IInitializeSpy *  pThis, _In_ DWORD  dwCoInit, _In_ DWORD  dwCurThreadAptRefs  )

static

Definition at line 469 of file ctf.c.

{
    DWORD cCount;
 
    UNREFERENCED_PARAMETER(pThis);
 
    cCount = Imm32IncCoInitCountSkip();
    if (!dwCoInit &&
        (dwCurThreadAptRefs == cCount + 1) &&
        (GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT))
    {
        Imm32ActivateOrDeactivateTIM(FALSE);
        CtfImmCoUninitialize();
    }
 
    return S_OK;
}

ISPY_PreUninitialize()

static STDMETHODIMP ISPY_PreUninitialize ( _Inout_ IInitializeSpy *  pThis, _In_ DWORD  dwCurThreadAptRefs  )

static

Definition at line 515 of file ctf.c.

{
    UNREFERENCED_PARAMETER(pThis);
 
    if (dwCurThreadAptRefs == 1 &&
        !RtlDllShutdownInProgress() &&
        !Imm32InsideLoaderLock() &&
        (GetWin32ClientInfo()->CI_flags & CI_CTFCOINIT))
    {
        IMMTLSDATA *pData = Imm32GetTLS();
        if (pData && !pData->bUninitializing)
            Imm32CoInitializeEx();
    }
 
    return S_OK;
}

ISPY_QueryInterface()

static STDMETHODIMP ISPY_QueryInterface ( _Inout_ IInitializeSpy *  pThis, _In_ REFIID  riid, _Inout_ LPVOID *  ppvObj  )

static

Definition at line 422 of file ctf.c.

{
    ISPY *pSpy = (ISPY*)pThis;
 
    if (!ppvObj)
        return E_INVALIDARG;
 
    *ppvObj = NULL;
 
    if (!IsEqualIID(riid, &IID_IUnknown) && !IsEqualIID(riid, &IID_IInitializeSpy))
        return E_NOINTERFACE;
 
    ++(pSpy->m_cRefs);
    *ppvObj = pSpy;
    return S_OK;
}

MSCTF_FN() [1/2]

FN_TF_CreateLangBarMgr MSCTF_FN

(

TF_CreateLangBarMgr

)

MSCTF_FN() [2/2]

FN_TF_InvalidAssemblyListCacheIfExist MSCTF_FN

(

TF_InvalidAssemblyListCacheIfExist

)

OLE32_FN() [1/4]

FN_CoInitializeEx OLE32_FN

(

CoInitializeEx

)

OLE32_FN() [2/4]

FN_CoRegisterInitializeSpy OLE32_FN

(

CoRegisterInitializeSpy

)

OLE32_FN() [3/4]

FN_CoRevokeInitializeSpy OLE32_FN

(

CoRevokeInitializeSpy

)

OLE32_FN() [4/4]

FN_CoUninitialize OLE32_FN

(

CoUninitialize

)

STDMETHODIMP_()

static STDMETHODIMP_ ( ULONG  )

static

Definition at line 442 of file ctf.c.

{
    ISPY *pSpy = (ISPY*)pThis;
    return ++pSpy->m_cRefs;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)

Variable Documentation

g_aimm_compat_flags

DWORD g_aimm_compat_flags = 0

Definition at line 204 of file ctf.c.

Referenced by CtfImmSetAppCompatFlags(), and ImmGetAppCompatFlags().

g_disable_CUAS_flag

BOOL g_disable_CUAS_flag = FALSE

Definition at line 207 of file ctf.c.

Referenced by CtfImmTIMActivate(), and ImmDisableTextFrameService().

g_dwTLSIndex

DWORD g_dwTLSIndex = -1

Definition at line 270 of file ctf.c.

Referenced by Imm32AllocateTLS(), Imm32GetTLS(), and Imm32InitTLS().

g_hCtfIme

HINSTANCE g_hCtfIme = NULL

Definition at line 210 of file ctf.c.

Referenced by Imm32LoadCtfIme().

g_hMsctf

HINSTANCE g_hMsctf = NULL

Definition at line 166 of file ctf.c.

g_hOle32

HINSTANCE g_hOle32 = NULL

Definition at line 113 of file ctf.c.

g_vtblISPY

const IInitializeSpyVtbl g_vtblISPY

static

Initial value:

=
{
    ISPY_QueryInterface,
    ISPY_AddRef,
    ISPY_Release,
    ISPY_PreInitialize,
    ISPY_PostInitialize,
    ISPY_PreUninitialize,
    ISPY_PostUninitialize,
}

Definition at line 545 of file ctf.c.

Referenced by Imm32AllocIMMISPY().