threadmgr.c File Reference

#include <stdarg.h>
#include "wine/debug.h"
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winuser.h"
#include "shlwapi.h"
#include "winerror.h"
#include "objbase.h"
#include "olectl.h"
#include "msctf.h"
#include "msctf_internal.h"

Include dependency graph for threadmgr.c:

Go to the source code of this file.

Classes
struct	tagPreservedKey
struct	tagDocumentMgrs
struct	tagAssociatedWindow
struct	tagACLMulti
struct	tagEnumTfDocumentMgr

Macros
#define	COBJMACROS

Typedefs
typedef struct tagPreservedKey	PreservedKey
typedef struct tagDocumentMgrs	DocumentMgrEntry
typedef struct tagAssociatedWindow	AssociatedWindow
typedef struct tagACLMulti	ThreadMgr
typedef struct tagEnumTfDocumentMgr	EnumTfDocumentMgr

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msctf)
static HRESULT	EnumTfDocumentMgr_Constructor (struct list *head, IEnumTfDocumentMgrs **ppOut)
static ThreadMgr *	impl_from_ITfThreadMgrEx (ITfThreadMgrEx *iface)
static ThreadMgr *	impl_from_ITfSource (ITfSource *iface)
static ThreadMgr *	impl_from_ITfKeystrokeMgr (ITfKeystrokeMgr *iface)
static ThreadMgr *	impl_from_ITfMessagePump (ITfMessagePump *iface)
static ThreadMgr *	impl_from_ITfClientId (ITfClientId *iface)
static ThreadMgr *	impl_from_ITfThreadMgrEventSink (ITfThreadMgrEventSink *iface)
static ThreadMgr *	impl_from_ITfUIElementMgr (ITfUIElementMgr *iface)
static ThreadMgr *	impl_from_ITfSourceSingle (ITfSourceSingle *iface)
static EnumTfDocumentMgr *	impl_from_IEnumTfDocumentMgrs (IEnumTfDocumentMgrs *iface)
static void	ThreadMgr_Destructor (ThreadMgr *This)
static HRESULT WINAPI	ThreadMgr_QueryInterface (ITfThreadMgrEx *iface, REFIID iid, LPVOID *ppvOut)
static ULONG WINAPI	ThreadMgr_AddRef (ITfThreadMgrEx *iface)
static ULONG WINAPI	ThreadMgr_Release (ITfThreadMgrEx *iface)
static HRESULT WINAPI	ThreadMgr_Activate (ITfThreadMgrEx *iface, TfClientId *id)
static HRESULT WINAPI	ThreadMgr_Deactivate (ITfThreadMgrEx *iface)
static HRESULT WINAPI	ThreadMgr_CreateDocumentMgr (ITfThreadMgrEx *iface, ITfDocumentMgr **ppdim)
static HRESULT WINAPI	ThreadMgr_EnumDocumentMgrs (ITfThreadMgrEx *iface, IEnumTfDocumentMgrs **ppEnum)
static HRESULT WINAPI	ThreadMgr_GetFocus (ITfThreadMgrEx *iface, ITfDocumentMgr **ppdimFocus)
static HRESULT WINAPI	ThreadMgr_SetFocus (ITfThreadMgrEx *iface, ITfDocumentMgr *pdimFocus)
static LRESULT CALLBACK	ThreadFocusHookProc (int nCode, WPARAM wParam, LPARAM lParam)
static HRESULT	SetupWindowsHook (ThreadMgr *This)
static HRESULT WINAPI	ThreadMgr_AssociateFocus (ITfThreadMgrEx *iface, HWND hwnd, ITfDocumentMgr *pdimNew, ITfDocumentMgr **ppdimPrev)
static HRESULT WINAPI	ThreadMgr_IsThreadFocus (ITfThreadMgrEx *iface, BOOL *pfThreadFocus)
static HRESULT WINAPI	ThreadMgr_GetFunctionProvider (ITfThreadMgrEx *iface, REFCLSID clsid, ITfFunctionProvider **ppFuncProv)
static HRESULT WINAPI	ThreadMgr_EnumFunctionProviders (ITfThreadMgrEx *iface, IEnumTfFunctionProviders **ppEnum)
static HRESULT WINAPI	ThreadMgr_GetGlobalCompartment (ITfThreadMgrEx *iface, ITfCompartmentMgr **ppCompMgr)
static HRESULT WINAPI	ThreadMgr_ActivateEx (ITfThreadMgrEx *iface, TfClientId *id, DWORD flags)
static HRESULT WINAPI	ThreadMgr_GetActiveFlags (ITfThreadMgrEx *iface, DWORD *flags)
static HRESULT WINAPI	Source_QueryInterface (ITfSource *iface, REFIID iid, LPVOID *ppvOut)
static ULONG WINAPI	Source_AddRef (ITfSource *iface)
static ULONG WINAPI	Source_Release (ITfSource *iface)
static HRESULT WINAPI	ThreadMgrSource_AdviseSink (ITfSource *iface, REFIID riid, IUnknown *punk, DWORD *pdwCookie)
static HRESULT WINAPI	ThreadMgrSource_UnadviseSink (ITfSource *iface, DWORD pdwCookie)
static HRESULT WINAPI	KeystrokeMgr_QueryInterface (ITfKeystrokeMgr *iface, REFIID iid, LPVOID *ppvOut)
static ULONG WINAPI	KeystrokeMgr_AddRef (ITfKeystrokeMgr *iface)
static ULONG WINAPI	KeystrokeMgr_Release (ITfKeystrokeMgr *iface)
static HRESULT WINAPI	KeystrokeMgr_AdviseKeyEventSink (ITfKeystrokeMgr *iface, TfClientId tid, ITfKeyEventSink *pSink, BOOL fForeground)
static HRESULT WINAPI	KeystrokeMgr_UnadviseKeyEventSink (ITfKeystrokeMgr *iface, TfClientId tid)
static HRESULT WINAPI	KeystrokeMgr_GetForeground (ITfKeystrokeMgr *iface, CLSID *pclsid)
static HRESULT WINAPI	KeystrokeMgr_TestKeyDown (ITfKeystrokeMgr *iface, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
static HRESULT WINAPI	KeystrokeMgr_TestKeyUp (ITfKeystrokeMgr *iface, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
static HRESULT WINAPI	KeystrokeMgr_KeyDown (ITfKeystrokeMgr *iface, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
static HRESULT WINAPI	KeystrokeMgr_KeyUp (ITfKeystrokeMgr *iface, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
static HRESULT WINAPI	KeystrokeMgr_GetPreservedKey (ITfKeystrokeMgr *iface, ITfContext *pic, const TF_PRESERVEDKEY *pprekey, GUID *pguid)
static HRESULT WINAPI	KeystrokeMgr_IsPreservedKey (ITfKeystrokeMgr *iface, REFGUID rguid, const TF_PRESERVEDKEY *pprekey, BOOL *pfRegistered)
static HRESULT WINAPI	KeystrokeMgr_PreserveKey (ITfKeystrokeMgr *iface, TfClientId tid, REFGUID rguid, const TF_PRESERVEDKEY *prekey, const WCHAR *pchDesc, ULONG cchDesc)
static HRESULT WINAPI	KeystrokeMgr_UnpreserveKey (ITfKeystrokeMgr *iface, REFGUID rguid, const TF_PRESERVEDKEY *pprekey)
static HRESULT WINAPI	KeystrokeMgr_SetPreservedKeyDescription (ITfKeystrokeMgr *iface, REFGUID rguid, const WCHAR *pchDesc, ULONG cchDesc)
static HRESULT WINAPI	KeystrokeMgr_GetPreservedKeyDescription (ITfKeystrokeMgr *iface, REFGUID rguid, BSTR *pbstrDesc)
static HRESULT WINAPI	KeystrokeMgr_SimulatePreservedKey (ITfKeystrokeMgr *iface, ITfContext *pic, REFGUID rguid, BOOL *pfEaten)
static HRESULT WINAPI	MessagePump_QueryInterface (ITfMessagePump *iface, REFIID iid, LPVOID *ppvOut)
static ULONG WINAPI	MessagePump_AddRef (ITfMessagePump *iface)
static ULONG WINAPI	MessagePump_Release (ITfMessagePump *iface)
static HRESULT WINAPI	MessagePump_PeekMessageA (ITfMessagePump *iface, LPMSG pMsg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg, BOOL *pfResult)
static HRESULT WINAPI	MessagePump_GetMessageA (ITfMessagePump *iface, LPMSG pMsg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax, BOOL *pfResult)
static HRESULT WINAPI	MessagePump_PeekMessageW (ITfMessagePump *iface, LPMSG pMsg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg, BOOL *pfResult)
static HRESULT WINAPI	MessagePump_GetMessageW (ITfMessagePump *iface, LPMSG pMsg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax, BOOL *pfResult)
static HRESULT WINAPI	ClientId_QueryInterface (ITfClientId *iface, REFIID iid, LPVOID *ppvOut)
static ULONG WINAPI	ClientId_AddRef (ITfClientId *iface)
static ULONG WINAPI	ClientId_Release (ITfClientId *iface)
static HRESULT WINAPI	ClientId_GetClientId (ITfClientId *iface, REFCLSID rclsid, TfClientId *ptid)
static HRESULT WINAPI	ThreadMgrEventSink_QueryInterface (ITfThreadMgrEventSink *iface, REFIID iid, LPVOID *ppvOut)
static ULONG WINAPI	ThreadMgrEventSink_AddRef (ITfThreadMgrEventSink *iface)
static ULONG WINAPI	ThreadMgrEventSink_Release (ITfThreadMgrEventSink *iface)
static HRESULT WINAPI	ThreadMgrEventSink_OnInitDocumentMgr (ITfThreadMgrEventSink *iface, ITfDocumentMgr *pdim)
static HRESULT WINAPI	ThreadMgrEventSink_OnUninitDocumentMgr (ITfThreadMgrEventSink *iface, ITfDocumentMgr *pdim)
static HRESULT WINAPI	ThreadMgrEventSink_OnSetFocus (ITfThreadMgrEventSink *iface, ITfDocumentMgr *pdimFocus, ITfDocumentMgr *pdimPrevFocus)
static HRESULT WINAPI	ThreadMgrEventSink_OnPushContext (ITfThreadMgrEventSink *iface, ITfContext *pic)
static HRESULT WINAPI	ThreadMgrEventSink_OnPopContext (ITfThreadMgrEventSink *iface, ITfContext *pic)
static HRESULT WINAPI	UIElementMgr_QueryInterface (ITfUIElementMgr *iface, REFIID iid, void **ppvOut)
static ULONG WINAPI	UIElementMgr_AddRef (ITfUIElementMgr *iface)
static ULONG WINAPI	UIElementMgr_Release (ITfUIElementMgr *iface)
static HRESULT WINAPI	UIElementMgr_BeginUIElement (ITfUIElementMgr *iface, ITfUIElement *element, BOOL *show, DWORD *id)
static HRESULT WINAPI	UIElementMgr_UpdateUIElement (ITfUIElementMgr *iface, DWORD id)
static HRESULT WINAPI	UIElementMgr_EndUIElement (ITfUIElementMgr *iface, DWORD id)
static HRESULT WINAPI	UIElementMgr_GetUIElement (ITfUIElementMgr *iface, DWORD id, ITfUIElement **element)
static HRESULT WINAPI	UIElementMgr_EnumUIElements (ITfUIElementMgr *iface, IEnumTfUIElements **enum_elements)
static HRESULT WINAPI	ThreadMgrSourceSingle_QueryInterface (ITfSourceSingle *iface, REFIID iid, LPVOID *ppvOut)
static ULONG WINAPI	ThreadMgrSourceSingle_AddRef (ITfSourceSingle *iface)
static ULONG WINAPI	ThreadMgrSourceSingle_Release (ITfSourceSingle *iface)
static HRESULT WINAPI	ThreadMgrSourceSingle_AdviseSingleSink (ITfSourceSingle *iface, TfClientId tid, REFIID riid, IUnknown *punk)
static HRESULT WINAPI	ThreadMgrSourceSingle_UnadviseSingleSink (ITfSourceSingle *iface, TfClientId tid, REFIID riid)
HRESULT	ThreadMgr_Constructor (IUnknown *pUnkOuter, IUnknown **ppOut)
static void	EnumTfDocumentMgr_Destructor (EnumTfDocumentMgr *This)
static HRESULT WINAPI	EnumTfDocumentMgr_QueryInterface (IEnumTfDocumentMgrs *iface, REFIID iid, LPVOID *ppvOut)
static ULONG WINAPI	EnumTfDocumentMgr_AddRef (IEnumTfDocumentMgrs *iface)
static ULONG WINAPI	EnumTfDocumentMgr_Release (IEnumTfDocumentMgrs *iface)
static HRESULT WINAPI	EnumTfDocumentMgr_Next (IEnumTfDocumentMgrs *iface, ULONG ulCount, ITfDocumentMgr **rgDocumentMgr, ULONG *pcFetched)
static HRESULT WINAPI	EnumTfDocumentMgr_Skip (IEnumTfDocumentMgrs *iface, ULONG celt)
static HRESULT WINAPI	EnumTfDocumentMgr_Reset (IEnumTfDocumentMgrs *iface)
static HRESULT WINAPI	EnumTfDocumentMgr_Clone (IEnumTfDocumentMgrs *iface, IEnumTfDocumentMgrs **ppenum)
void	ThreadMgr_OnDocumentMgrDestruction (ITfThreadMgr *iface, ITfDocumentMgr *mgr)

Variables
static const ITfThreadMgrExVtbl	ThreadMgrExVtbl
static const ITfSourceVtbl	ThreadMgrSourceVtbl
static const ITfKeystrokeMgrVtbl	KeystrokeMgrVtbl
static const ITfMessagePumpVtbl	MessagePumpVtbl
static const ITfClientIdVtbl	ClientIdVtbl
static const ITfThreadMgrEventSinkVtbl	ThreadMgrEventSinkVtbl
static const ITfUIElementMgrVtbl	ThreadMgrUIElementMgrVtbl
static const ITfSourceSingleVtbl	SourceSingleVtbl
static const IEnumTfDocumentMgrsVtbl	EnumTfDocumentMgrsVtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 23 of file threadmgr.c.

Typedef Documentation

AssociatedWindow

typedef struct tagAssociatedWindow AssociatedWindow

DocumentMgrEntry

typedef struct tagDocumentMgrs DocumentMgrEntry

EnumTfDocumentMgr

typedef struct tagEnumTfDocumentMgr EnumTfDocumentMgr

PreservedKey

typedef struct tagPreservedKey PreservedKey

ThreadMgr

typedef struct tagACLMulti ThreadMgr

Function Documentation

ClientId_AddRef()

static ULONG WINAPI ClientId_AddRef ( ITfClientId *  iface )

static

Definition at line 1059 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfClientId(iface);
    return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
}

ClientId_GetClientId()

static HRESULT WINAPI ClientId_GetClientId ( ITfClientId *  iface, REFCLSID  rclsid, TfClientId *  ptid  )

static

Definition at line 1071 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfClientId(iface);
    HRESULT hr;
    ITfCategoryMgr *catmgr;
 
    TRACE("(%p) %s\n",This,debugstr_guid(rclsid));
 
    CategoryMgr_Constructor(NULL,(IUnknown**)&catmgr);
    hr = ITfCategoryMgr_RegisterGUID(catmgr,rclsid,ptid);
    ITfCategoryMgr_Release(catmgr);
 
    return hr;
}

ClientId_QueryInterface()

static HRESULT WINAPI ClientId_QueryInterface ( ITfClientId *  iface, REFIID  iid, LPVOID *  ppvOut  )

static

Definition at line 1053 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfClientId(iface);
    return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
}

ClientId_Release()

static ULONG WINAPI ClientId_Release ( ITfClientId *  iface )

static

Definition at line 1065 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfClientId(iface);
    return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
}

EnumTfDocumentMgr_AddRef()

static ULONG WINAPI EnumTfDocumentMgr_AddRef ( IEnumTfDocumentMgrs *  iface )

static

Definition at line 1421 of file threadmgr.c.

{
    EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
    return InterlockedIncrement(&This->refCount);
}

EnumTfDocumentMgr_Clone()

static HRESULT WINAPI EnumTfDocumentMgr_Clone ( IEnumTfDocumentMgrs *  iface, IEnumTfDocumentMgrs **  ppenum  )

static

Definition at line 1489 of file threadmgr.c.

{
    EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
    HRESULT res;
 
    TRACE("(%p)\n",This);
 
    if (ppenum == NULL) return E_POINTER;
 
    res = EnumTfDocumentMgr_Constructor(This->head, ppenum);
    if (SUCCEEDED(res))
    {
        EnumTfDocumentMgr *new_This = impl_from_IEnumTfDocumentMgrs(*ppenum);
        new_This->index = This->index;
    }
    return res;
}

EnumTfDocumentMgr_Constructor()

static HRESULT EnumTfDocumentMgr_Constructor ( struct list *  head, IEnumTfDocumentMgrs **  ppOut  )

static

Definition at line 1519 of file threadmgr.c.

{
    EnumTfDocumentMgr *This;
 
    This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(EnumTfDocumentMgr));
    if (This == NULL)
        return E_OUTOFMEMORY;
 
    This->IEnumTfDocumentMgrs_iface.lpVtbl= &EnumTfDocumentMgrsVtbl;
    This->refCount = 1;
    This->head = head;
    This->index = list_head(This->head);
 
    TRACE("returning %p\n", &This->IEnumTfDocumentMgrs_iface);
    *ppOut = &This->IEnumTfDocumentMgrs_iface;
    return S_OK;
}

Referenced by EnumTfDocumentMgr_Clone(), and ThreadMgr_EnumDocumentMgrs().

EnumTfDocumentMgr_Destructor()

static void EnumTfDocumentMgr_Destructor ( EnumTfDocumentMgr *  This )

static

Definition at line 1395 of file threadmgr.c.

{
    TRACE("destroying %p\n", This);
    HeapFree(GetProcessHeap(),0,This);
}

Referenced by EnumTfDocumentMgr_Release().

EnumTfDocumentMgr_Next()

static HRESULT WINAPI EnumTfDocumentMgr_Next ( IEnumTfDocumentMgrs *  iface, ULONG  ulCount, ITfDocumentMgr **  rgDocumentMgr, ULONG *  pcFetched  )

static

Definition at line 1438 of file threadmgr.c.

{
    EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
    ULONG fetched = 0;
 
    TRACE("(%p)\n",This);
 
    if (rgDocumentMgr == NULL) return E_POINTER;
 
    while (fetched < ulCount)
    {
        DocumentMgrEntry *mgrentry;
        if (This->index == NULL)
            break;
 
        mgrentry = LIST_ENTRY(This->index,DocumentMgrEntry,entry);
        if (mgrentry == NULL)
            break;
 
        *rgDocumentMgr = mgrentry->docmgr;
        ITfDocumentMgr_AddRef(*rgDocumentMgr);
 
        This->index = list_next(This->head, This->index);
        ++fetched;
        ++rgDocumentMgr;
    }
 
    if (pcFetched) *pcFetched = fetched;
    return fetched == ulCount ? S_OK : S_FALSE;
}

EnumTfDocumentMgr_QueryInterface()

static HRESULT WINAPI EnumTfDocumentMgr_QueryInterface ( IEnumTfDocumentMgrs *  iface, REFIID  iid, LPVOID *  ppvOut  )

static

Definition at line 1401 of file threadmgr.c.

{
    EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
    *ppvOut = NULL;
 
    if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_IEnumTfDocumentMgrs))
    {
        *ppvOut = &This->IEnumTfDocumentMgrs_iface;
    }
 
    if (*ppvOut)
    {
        IEnumTfDocumentMgrs_AddRef(iface);
        return S_OK;
    }
 
    WARN("unsupported interface: %s\n", debugstr_guid(iid));
    return E_NOINTERFACE;
}

EnumTfDocumentMgr_Release()

static ULONG WINAPI EnumTfDocumentMgr_Release ( IEnumTfDocumentMgrs *  iface )

static

Definition at line 1427 of file threadmgr.c.

{
    EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
    ULONG ret;
 
    ret = InterlockedDecrement(&This->refCount);
    if (ret == 0)
        EnumTfDocumentMgr_Destructor(This);
    return ret;
}

EnumTfDocumentMgr_Reset()

static HRESULT WINAPI EnumTfDocumentMgr_Reset ( IEnumTfDocumentMgrs *  iface )

static

Definition at line 1481 of file threadmgr.c.

{
    EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
    TRACE("(%p)\n",This);
    This->index = list_head(This->head);
    return S_OK;
}

EnumTfDocumentMgr_Skip()

static HRESULT WINAPI EnumTfDocumentMgr_Skip ( IEnumTfDocumentMgrs *  iface, ULONG  celt  )

static

Definition at line 1470 of file threadmgr.c.

{
    EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
    ULONG i;
 
    TRACE("(%p)\n",This);
    for(i = 0; i < celt && This->index != NULL; i++)
        This->index = list_next(This->head, This->index);
    return S_OK;
}

impl_from_IEnumTfDocumentMgrs()

static EnumTfDocumentMgr * impl_from_IEnumTfDocumentMgrs ( IEnumTfDocumentMgrs *  iface )

inlinestatic

Definition at line 153 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, EnumTfDocumentMgr, IEnumTfDocumentMgrs_iface);
}

Referenced by EnumTfDocumentMgr_AddRef(), EnumTfDocumentMgr_Clone(), EnumTfDocumentMgr_Next(), EnumTfDocumentMgr_QueryInterface(), EnumTfDocumentMgr_Release(), EnumTfDocumentMgr_Reset(), and EnumTfDocumentMgr_Skip().

impl_from_ITfClientId()

static ThreadMgr * impl_from_ITfClientId ( ITfClientId *  iface )

inlinestatic

Definition at line 133 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, ThreadMgr, ITfClientId_iface);
}

Referenced by ClientId_AddRef(), ClientId_GetClientId(), ClientId_QueryInterface(), and ClientId_Release().

impl_from_ITfKeystrokeMgr()

static ThreadMgr * impl_from_ITfKeystrokeMgr ( ITfKeystrokeMgr *  iface )

inlinestatic

Definition at line 123 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, ThreadMgr, ITfKeystrokeMgr_iface);
}

Referenced by KeystrokeMgr_AddRef(), KeystrokeMgr_AdviseKeyEventSink(), KeystrokeMgr_GetForeground(), KeystrokeMgr_GetPreservedKey(), KeystrokeMgr_GetPreservedKeyDescription(), KeystrokeMgr_IsPreservedKey(), KeystrokeMgr_KeyDown(), KeystrokeMgr_KeyUp(), KeystrokeMgr_PreserveKey(), KeystrokeMgr_QueryInterface(), KeystrokeMgr_Release(), KeystrokeMgr_SetPreservedKeyDescription(), KeystrokeMgr_SimulatePreservedKey(), KeystrokeMgr_TestKeyDown(), KeystrokeMgr_TestKeyUp(), KeystrokeMgr_UnadviseKeyEventSink(), and KeystrokeMgr_UnpreserveKey().

impl_from_ITfMessagePump()

static ThreadMgr * impl_from_ITfMessagePump ( ITfMessagePump *  iface )

inlinestatic

Definition at line 128 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, ThreadMgr, ITfMessagePump_iface);
}

Referenced by MessagePump_AddRef(), MessagePump_QueryInterface(), and MessagePump_Release().

impl_from_ITfSource()

static ThreadMgr * impl_from_ITfSource ( ITfSource *  iface )

inlinestatic

Definition at line 118 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, ThreadMgr, ITfSource_iface);
}

Referenced by Source_AddRef(), Source_QueryInterface(), Source_Release(), ThreadMgrSource_AdviseSink(), and ThreadMgrSource_UnadviseSink().

impl_from_ITfSourceSingle()

static ThreadMgr * impl_from_ITfSourceSingle ( ITfSourceSingle *  iface )

inlinestatic

Definition at line 148 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, ThreadMgr, ITfSourceSingle_iface);
}

Referenced by ThreadMgrSourceSingle_AddRef(), ThreadMgrSourceSingle_AdviseSingleSink(), ThreadMgrSourceSingle_QueryInterface(), ThreadMgrSourceSingle_Release(), and ThreadMgrSourceSingle_UnadviseSingleSink().

impl_from_ITfThreadMgrEventSink()

static ThreadMgr * impl_from_ITfThreadMgrEventSink ( ITfThreadMgrEventSink *  iface )

inlinestatic

Definition at line 138 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, ThreadMgr, ITfThreadMgrEventSink_iface);
}

Referenced by ThreadMgrEventSink_AddRef(), ThreadMgrEventSink_OnInitDocumentMgr(), ThreadMgrEventSink_OnPopContext(), ThreadMgrEventSink_OnPushContext(), ThreadMgrEventSink_OnSetFocus(), ThreadMgrEventSink_OnUninitDocumentMgr(), ThreadMgrEventSink_QueryInterface(), and ThreadMgrEventSink_Release().

impl_from_ITfThreadMgrEx()

static ThreadMgr * impl_from_ITfThreadMgrEx ( ITfThreadMgrEx *  iface )

inlinestatic

Definition at line 113 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, ThreadMgr, ITfThreadMgrEx_iface);
}

Referenced by ThreadMgr_Activate(), ThreadMgr_ActivateEx(), ThreadMgr_AddRef(), ThreadMgr_AssociateFocus(), ThreadMgr_CreateDocumentMgr(), ThreadMgr_Deactivate(), ThreadMgr_EnumDocumentMgrs(), ThreadMgr_EnumFunctionProviders(), ThreadMgr_GetActiveFlags(), ThreadMgr_GetFocus(), ThreadMgr_GetFunctionProvider(), ThreadMgr_GetGlobalCompartment(), ThreadMgr_IsThreadFocus(), ThreadMgr_OnDocumentMgrDestruction(), ThreadMgr_QueryInterface(), ThreadMgr_Release(), and ThreadMgr_SetFocus().

impl_from_ITfUIElementMgr()

static ThreadMgr * impl_from_ITfUIElementMgr ( ITfUIElementMgr *  iface )

inlinestatic

Definition at line 143 of file threadmgr.c.

{
    return CONTAINING_RECORD(iface, ThreadMgr, ITfUIElementMgr_iface);
}

Referenced by UIElementMgr_AddRef(), UIElementMgr_BeginUIElement(), UIElementMgr_EndUIElement(), UIElementMgr_EnumUIElements(), UIElementMgr_GetUIElement(), UIElementMgr_QueryInterface(), UIElementMgr_Release(), and UIElementMgr_UpdateUIElement().

KeystrokeMgr_AddRef()

static ULONG WINAPI KeystrokeMgr_AddRef ( ITfKeystrokeMgr *  iface )

static

Definition at line 692 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
}

KeystrokeMgr_AdviseKeyEventSink()

static HRESULT WINAPI KeystrokeMgr_AdviseKeyEventSink ( ITfKeystrokeMgr *  iface, TfClientId  tid, ITfKeyEventSink *  pSink, BOOL  fForeground  )

static

Definition at line 704 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    CLSID textservice;
    ITfKeyEventSink *check = NULL;
 
    TRACE("(%p) %x %p %i\n",This,tid,pSink,fForeground);
 
    if (!tid || !pSink)
        return E_INVALIDARG;
 
    textservice = get_textservice_clsid(tid);
    if (IsEqualCLSID(&GUID_NULL,&textservice))
        return E_INVALIDARG;
 
    get_textservice_sink(tid, &IID_ITfKeyEventSink, (IUnknown**)&check);
    if (check != NULL)
        return CONNECT_E_ADVISELIMIT;
 
    if (FAILED(ITfKeyEventSink_QueryInterface(pSink,&IID_ITfKeyEventSink,(LPVOID*) &check)))
        return E_INVALIDARG;
 
    set_textservice_sink(tid, &IID_ITfKeyEventSink, (IUnknown*)check);
 
    if (fForeground)
    {
        if (This->foregroundKeyEventSink)
        {
            ITfKeyEventSink_OnSetFocus(This->foregroundKeyEventSink, FALSE);
            ITfKeyEventSink_Release(This->foregroundKeyEventSink);
        }
        ITfKeyEventSink_AddRef(check);
        ITfKeyEventSink_OnSetFocus(check, TRUE);
        This->foregroundKeyEventSink = check;
        This->foregroundTextService = textservice;
    }
    return S_OK;
}

KeystrokeMgr_GetForeground()

static HRESULT WINAPI KeystrokeMgr_GetForeground ( ITfKeystrokeMgr *  iface, CLSID *  pclsid  )

static

Definition at line 776 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    TRACE("(%p) %p\n",This,pclsid);
    if (!pclsid)
        return E_INVALIDARG;
 
    if (IsEqualCLSID(&This->foregroundTextService,&GUID_NULL))
        return S_FALSE;
 
    *pclsid = This->foregroundTextService;
    return S_OK;
}

KeystrokeMgr_GetPreservedKey()

static HRESULT WINAPI KeystrokeMgr_GetPreservedKey ( ITfKeystrokeMgr *  iface, ITfContext *  pic, const TF_PRESERVEDKEY *  pprekey, GUID *  pguid  )

static

Definition at line 825 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    FIXME("STUB:(%p)\n",This);
    return E_NOTIMPL;
}

KeystrokeMgr_GetPreservedKeyDescription()

static HRESULT WINAPI KeystrokeMgr_GetPreservedKeyDescription ( ITfKeystrokeMgr *  iface, REFGUID  rguid, BSTR *  pbstrDesc  )

static

Definition at line 939 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    FIXME("STUB:(%p)\n",This);
    return E_NOTIMPL;
}

KeystrokeMgr_IsPreservedKey()

static HRESULT WINAPI KeystrokeMgr_IsPreservedKey ( ITfKeystrokeMgr *  iface, REFGUID  rguid, const TF_PRESERVEDKEY *  pprekey, BOOL *  pfRegistered  )

static

Definition at line 833 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    struct list *cursor;
 
    TRACE("(%p) %s (%x %x) %p\n",This,debugstr_guid(rguid), (pprekey)?pprekey->uVKey:0, (pprekey)?pprekey->uModifiers:0, pfRegistered);
 
    if (!rguid || !pprekey || !pfRegistered)
        return E_INVALIDARG;
 
    LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
    {
        PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
        if (IsEqualGUID(rguid,&key->guid) && pprekey->uVKey == key->prekey.uVKey && pprekey->uModifiers == key->prekey.uModifiers)
        {
            *pfRegistered = TRUE;
            return S_OK;
        }
    }
 
    *pfRegistered = FALSE;
    return S_FALSE;
}

KeystrokeMgr_KeyDown()

static HRESULT WINAPI KeystrokeMgr_KeyDown ( ITfKeystrokeMgr *  iface, WPARAM  wParam, LPARAM  lParam, BOOL *  pfEaten  )

static

Definition at line 809 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    FIXME("STUB:(%p)\n",This);
    return E_NOTIMPL;
}

KeystrokeMgr_KeyUp()

static HRESULT WINAPI KeystrokeMgr_KeyUp ( ITfKeystrokeMgr *  iface, WPARAM  wParam, LPARAM  lParam, BOOL *  pfEaten  )

static

Definition at line 817 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    FIXME("STUB:(%p)\n",This);
    return E_NOTIMPL;
}

KeystrokeMgr_PreserveKey()

static HRESULT WINAPI KeystrokeMgr_PreserveKey ( ITfKeystrokeMgr *  iface, TfClientId  tid, REFGUID  rguid, const TF_PRESERVEDKEY *  prekey, const WCHAR *  pchDesc, ULONG  cchDesc  )

static

Definition at line 858 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    struct list *cursor;
    PreservedKey *newkey;
 
    TRACE("(%p) %x %s (%x,%x) %s\n",This,tid, debugstr_guid(rguid),(prekey)?prekey->uVKey:0,(prekey)?prekey->uModifiers:0,debugstr_wn(pchDesc,cchDesc));
 
    if (!tid || ! rguid || !prekey || (cchDesc && !pchDesc))
        return E_INVALIDARG;
 
    LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
    {
        PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
        if (IsEqualGUID(rguid,&key->guid) && prekey->uVKey == key->prekey.uVKey && prekey->uModifiers == key->prekey.uModifiers)
            return TF_E_ALREADY_EXISTS;
    }
 
    newkey = HeapAlloc(GetProcessHeap(),0,sizeof(PreservedKey));
    if (!newkey)
        return E_OUTOFMEMORY;
 
    newkey->guid  = *rguid;
    newkey->prekey = *prekey;
    newkey->tid = tid;
    newkey->description = NULL;
    if (cchDesc)
    {
        newkey->description = HeapAlloc(GetProcessHeap(),0,cchDesc * sizeof(WCHAR));
        if (!newkey->description)
        {
            HeapFree(GetProcessHeap(),0,newkey);
            return E_OUTOFMEMORY;
        }
        memcpy(newkey->description, pchDesc, cchDesc*sizeof(WCHAR));
    }
 
    list_add_head(&This->CurrentPreservedKeys,&newkey->entry);
 
    return S_OK;
}

KeystrokeMgr_QueryInterface()

static HRESULT WINAPI KeystrokeMgr_QueryInterface ( ITfKeystrokeMgr *  iface, REFIID  iid, LPVOID *  ppvOut  )

static

Definition at line 686 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
}

KeystrokeMgr_Release()

static ULONG WINAPI KeystrokeMgr_Release ( ITfKeystrokeMgr *  iface )

static

Definition at line 698 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
}

KeystrokeMgr_SetPreservedKeyDescription()

static HRESULT WINAPI KeystrokeMgr_SetPreservedKeyDescription ( ITfKeystrokeMgr *  iface, REFGUID  rguid, const WCHAR *  pchDesc, ULONG  cchDesc  )

static

Definition at line 931 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    FIXME("STUB:(%p)\n",This);
    return E_NOTIMPL;
}

KeystrokeMgr_SimulatePreservedKey()

static HRESULT WINAPI KeystrokeMgr_SimulatePreservedKey ( ITfKeystrokeMgr *  iface, ITfContext *  pic, REFGUID  rguid, BOOL *  pfEaten  )

static

Definition at line 947 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    FIXME("STUB:(%p)\n",This);
    return E_NOTIMPL;
}

KeystrokeMgr_TestKeyDown()

static HRESULT WINAPI KeystrokeMgr_TestKeyDown ( ITfKeystrokeMgr *  iface, WPARAM  wParam, LPARAM  lParam, BOOL *  pfEaten  )

static

Definition at line 791 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    FIXME("STUB:(%p)\n",This);
    *pfEaten = FALSE;
    return S_OK;
}

KeystrokeMgr_TestKeyUp()

static HRESULT WINAPI KeystrokeMgr_TestKeyUp ( ITfKeystrokeMgr *  iface, WPARAM  wParam, LPARAM  lParam, BOOL *  pfEaten  )

static

Definition at line 800 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    FIXME("STUB:(%p)\n",This);
    *pfEaten = FALSE;
    return S_OK;
}

KeystrokeMgr_UnadviseKeyEventSink()

static HRESULT WINAPI KeystrokeMgr_UnadviseKeyEventSink ( ITfKeystrokeMgr *  iface, TfClientId  tid  )

static

Definition at line 744 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    CLSID textservice;
    ITfKeyEventSink *check = NULL;
    TRACE("(%p) %x\n",This,tid);
 
    if (!tid)
        return E_INVALIDARG;
 
    textservice = get_textservice_clsid(tid);
    if (IsEqualCLSID(&GUID_NULL,&textservice))
        return E_INVALIDARG;
 
    get_textservice_sink(tid, &IID_ITfKeyEventSink, (IUnknown**)&check);
 
    if (!check)
        return CONNECT_E_NOCONNECTION;
 
    set_textservice_sink(tid, &IID_ITfKeyEventSink, NULL);
    ITfKeyEventSink_Release(check);
 
    if (This->foregroundKeyEventSink == check)
    {
        ITfKeyEventSink_Release(This->foregroundKeyEventSink);
        This->foregroundKeyEventSink = NULL;
        This->foregroundTextService = GUID_NULL;
    }
    return S_OK;
}

KeystrokeMgr_UnpreserveKey()

static HRESULT WINAPI KeystrokeMgr_UnpreserveKey ( ITfKeystrokeMgr *  iface, REFGUID  rguid, const TF_PRESERVEDKEY *  pprekey  )

static

Definition at line 902 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
    PreservedKey* key = NULL;
    struct list *cursor;
    TRACE("(%p) %s (%x %x)\n",This,debugstr_guid(rguid),(pprekey)?pprekey->uVKey:0, (pprekey)?pprekey->uModifiers:0);
 
    if (!pprekey || !rguid)
        return E_INVALIDARG;
 
    LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
    {
        key = LIST_ENTRY(cursor,PreservedKey,entry);
        if (IsEqualGUID(rguid,&key->guid) && pprekey->uVKey == key->prekey.uVKey && pprekey->uModifiers == key->prekey.uModifiers)
            break;
        key = NULL;
    }
 
    if (!key)
        return CONNECT_E_NOCONNECTION;
 
    list_remove(&key->entry);
    HeapFree(GetProcessHeap(),0,key->description);
    HeapFree(GetProcessHeap(),0,key);
 
    return S_OK;
}

MessagePump_AddRef()

static ULONG WINAPI MessagePump_AddRef ( ITfMessagePump *  iface )

static

Definition at line 986 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfMessagePump(iface);
    return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
}

MessagePump_GetMessageA()

static HRESULT WINAPI MessagePump_GetMessageA ( ITfMessagePump *  iface, LPMSG  pMsg, HWND  hwnd, UINT  wMsgFilterMin, UINT  wMsgFilterMax, BOOL *  pfResult  )

static

Definition at line 1008 of file threadmgr.c.

{
    if (!pfResult)
        return E_INVALIDARG;
    *pfResult = GetMessageA(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax);
    return S_OK;
}

MessagePump_GetMessageW()

static HRESULT WINAPI MessagePump_GetMessageW ( ITfMessagePump *  iface, LPMSG  pMsg, HWND  hwnd, UINT  wMsgFilterMin, UINT  wMsgFilterMax, BOOL *  pfResult  )

static

Definition at line 1028 of file threadmgr.c.

{
    if (!pfResult)
        return E_INVALIDARG;
    *pfResult = GetMessageW(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax);
    return S_OK;
}

MessagePump_PeekMessageA()

static HRESULT WINAPI MessagePump_PeekMessageA ( ITfMessagePump *  iface, LPMSG  pMsg, HWND  hwnd, UINT  wMsgFilterMin, UINT  wMsgFilterMax, UINT  wRemoveMsg, BOOL *  pfResult  )

static

Definition at line 998 of file threadmgr.c.

{
    if (!pfResult)
        return E_INVALIDARG;
    *pfResult = PeekMessageA(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
    return S_OK;
}

MessagePump_PeekMessageW()

static HRESULT WINAPI MessagePump_PeekMessageW ( ITfMessagePump *  iface, LPMSG  pMsg, HWND  hwnd, UINT  wMsgFilterMin, UINT  wMsgFilterMax, UINT  wRemoveMsg, BOOL *  pfResult  )

static

Definition at line 1018 of file threadmgr.c.

{
    if (!pfResult)
        return E_INVALIDARG;
    *pfResult = PeekMessageW(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
    return S_OK;
}

MessagePump_QueryInterface()

static HRESULT WINAPI MessagePump_QueryInterface ( ITfMessagePump *  iface, REFIID  iid, LPVOID *  ppvOut  )

static

Definition at line 980 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfMessagePump(iface);
    return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
}

MessagePump_Release()

static ULONG WINAPI MessagePump_Release ( ITfMessagePump *  iface )

static

Definition at line 992 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfMessagePump(iface);
    return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
}

SetupWindowsHook()

static HRESULT SetupWindowsHook ( ThreadMgr *  This )

static

Definition at line 423 of file threadmgr.c.

{
    if (!This->focusHook)
    {
        This->focusHook = SetWindowsHookExW(WH_CBT, ThreadFocusHookProc, 0,
                             GetCurrentThreadId());
        if (!This->focusHook)
        {
            ERR("Unable to set focus hook\n");
            return E_FAIL;
        }
        return S_OK;
    }
    return S_FALSE;
}

Referenced by ThreadMgr_AssociateFocus().

Source_AddRef()

static ULONG WINAPI Source_AddRef ( ITfSource *  iface )

static

Definition at line 590 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSource(iface);
    return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
}

Source_QueryInterface()

static HRESULT WINAPI Source_QueryInterface ( ITfSource *  iface, REFIID  iid, LPVOID *  ppvOut  )

static

Definition at line 584 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSource(iface);
    return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
}

Source_Release()

static ULONG WINAPI Source_Release ( ITfSource *  iface )

static

Definition at line 596 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSource(iface);
    return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
}

ThreadFocusHookProc()

static LRESULT CALLBACK ThreadFocusHookProc ( int  nCode, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 387 of file threadmgr.c.

{
    ThreadMgr *This;
 
    This = TlsGetValue(tlsIndex);
    if (!This)
    {
        ERR("Hook proc but no ThreadMgr for this thread. Serious Error\n");
        return 0;
    }
    if (!This->focusHook)
    {
        ERR("Hook proc but no ThreadMgr focus Hook. Serious Error\n");
        return 0;
    }
 
    if (nCode == HCBT_SETFOCUS) /* focus change within our thread */
    {
        struct list *cursor;
 
        LIST_FOR_EACH(cursor, &This->AssociatedFocusWindows)
        {
            AssociatedWindow *wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
            if (wnd->hwnd == (HWND)wParam)
            {
                TRACE("Triggering Associated window focus\n");
                if (This->focus != wnd->docmgr)
                    ThreadMgr_SetFocus(&This->ITfThreadMgrEx_iface, wnd->docmgr);
                break;
            }
        }
    }
 
    return CallNextHookEx(This->focusHook, nCode, wParam, lParam);
}

Referenced by SetupWindowsHook().

ThreadMgr_Activate()

static HRESULT WINAPI ThreadMgr_Activate ( ITfThreadMgrEx *  iface, TfClientId *  id  )

static

Definition at line 278 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 
    TRACE("(%p) %p\n", This, id);
    return ITfThreadMgrEx_ActivateEx(iface, id, 0);
}

ThreadMgr_ActivateEx()

static HRESULT WINAPI ThreadMgr_ActivateEx ( ITfThreadMgrEx *  iface, TfClientId *  id, DWORD  flags  )

static

Definition at line 530 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 
    TRACE("(%p) %p, %#x\n", This, id, flags);
 
    if (!id)
        return E_INVALIDARG;
 
    if (flags)
        FIXME("Unimplemented flags %#x\n", flags);
 
    if (!processId)
    {
        GUID guid;
        CoCreateGuid(&guid);
        ITfClientId_GetClientId(&This->ITfClientId_iface, &guid, &processId);
    }
 
    activate_textservices(iface);
    This->activationCount++;
    *id = processId;
    return S_OK;
}

ThreadMgr_AddRef()

static ULONG WINAPI ThreadMgr_AddRef ( ITfThreadMgrEx *  iface )

static

Definition at line 257 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    return InterlockedIncrement(&This->refCount);
}

Referenced by ThreadMgr_Constructor().

ThreadMgr_AssociateFocus()

static HRESULT WINAPI ThreadMgr_AssociateFocus ( ITfThreadMgrEx *  iface, HWND  hwnd, ITfDocumentMgr *  pdimNew, ITfDocumentMgr **  ppdimPrev  )

static

Definition at line 439 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    struct list *cursor, *cursor2;
    AssociatedWindow *wnd;
 
    TRACE("(%p) %p %p %p\n",This,hwnd,pdimNew,ppdimPrev);
 
    if (!ppdimPrev)
        return E_INVALIDARG;
 
    *ppdimPrev = NULL;
 
    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->AssociatedFocusWindows)
    {
        wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
        if (wnd->hwnd == hwnd)
        {
            if (wnd->docmgr)
                ITfDocumentMgr_AddRef(wnd->docmgr);
            *ppdimPrev = wnd->docmgr;
            wnd->docmgr = pdimNew;
            if (GetFocus() == hwnd)
                ThreadMgr_SetFocus(iface,pdimNew);
            return S_OK;
        }
    }
 
    wnd = HeapAlloc(GetProcessHeap(),0,sizeof(AssociatedWindow));
    wnd->hwnd = hwnd;
    wnd->docmgr = pdimNew;
    list_add_head(&This->AssociatedFocusWindows,&wnd->entry);
 
    if (GetFocus() == hwnd)
        ThreadMgr_SetFocus(iface,pdimNew);
 
    SetupWindowsHook(This);
 
    return S_OK;
}

ThreadMgr_Constructor()

HRESULT ThreadMgr_Constructor	(	IUnknown *	pUnkOuter,
		IUnknown **	ppOut
	)

Definition at line 1342 of file threadmgr.c.

{
    ThreadMgr *This;
    if (pUnkOuter)
        return CLASS_E_NOAGGREGATION;
 
    /* Only 1 ThreadMgr is created per thread */
    This = TlsGetValue(tlsIndex);
    if (This)
    {
        ThreadMgr_AddRef(&This->ITfThreadMgrEx_iface);
        *ppOut = (IUnknown*)&This->ITfThreadMgrEx_iface;
        return S_OK;
    }
 
    This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ThreadMgr));
    if (This == NULL)
        return E_OUTOFMEMORY;
 
    This->ITfThreadMgrEx_iface.lpVtbl = &ThreadMgrExVtbl;
    This->ITfSource_iface.lpVtbl = &ThreadMgrSourceVtbl;
    This->ITfKeystrokeMgr_iface.lpVtbl = &KeystrokeMgrVtbl;
    This->ITfMessagePump_iface.lpVtbl = &MessagePumpVtbl;
    This->ITfClientId_iface.lpVtbl = &ClientIdVtbl;
    This->ITfThreadMgrEventSink_iface.lpVtbl = &ThreadMgrEventSinkVtbl;
    This->ITfUIElementMgr_iface.lpVtbl = &ThreadMgrUIElementMgrVtbl;
    This->ITfSourceSingle_iface.lpVtbl = &SourceSingleVtbl;
    This->refCount = 1;
    TlsSetValue(tlsIndex,This);
 
    CompartmentMgr_Constructor((IUnknown*)&This->ITfThreadMgrEx_iface, &IID_IUnknown, (IUnknown**)&This->CompartmentMgr);
 
    list_init(&This->CurrentPreservedKeys);
    list_init(&This->CreatedDocumentMgrs);
    list_init(&This->AssociatedFocusWindows);
 
    list_init(&This->ActiveLanguageProfileNotifySink);
    list_init(&This->DisplayAttributeNotifySink);
    list_init(&This->KeyTraceEventSink);
    list_init(&This->PreservedKeyNotifySink);
    list_init(&This->ThreadFocusSink);
    list_init(&This->ThreadMgrEventSink);
    list_init(&This->UIElementSink);
    list_init(&This->InputProcessorProfileActivationSink);
 
    TRACE("returning %p\n", This);
    *ppOut = (IUnknown *)&This->ITfThreadMgrEx_iface;
    return S_OK;
}

Referenced by TF_CreateThreadMgr().

ThreadMgr_CreateDocumentMgr()

static HRESULT WINAPI ThreadMgr_CreateDocumentMgr ( ITfThreadMgrEx *  iface, ITfDocumentMgr **  ppdim  )

static

Definition at line 311 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    DocumentMgrEntry *mgrentry;
    HRESULT hr;
 
    TRACE("(%p)\n",iface);
    mgrentry = HeapAlloc(GetProcessHeap(),0,sizeof(DocumentMgrEntry));
    if (mgrentry == NULL)
        return E_OUTOFMEMORY;
 
    hr = DocumentMgr_Constructor(&This->ITfThreadMgrEventSink_iface, ppdim);
 
    if (SUCCEEDED(hr))
    {
        mgrentry->docmgr = *ppdim;
        list_add_head(&This->CreatedDocumentMgrs,&mgrentry->entry);
    }
    else
        HeapFree(GetProcessHeap(),0,mgrentry);
 
    return hr;
}

ThreadMgr_Deactivate()

static HRESULT WINAPI ThreadMgr_Deactivate ( ITfThreadMgrEx *  iface )

static

Definition at line 286 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    TRACE("(%p)\n",This);
 
    if (This->activationCount == 0)
        return E_UNEXPECTED;
 
    This->activationCount --;
 
    if (This->activationCount == 0)
    {
        if (This->focus)
        {
            ITfThreadMgrEventSink_OnSetFocus(&This->ITfThreadMgrEventSink_iface, 0, This->focus);
            ITfDocumentMgr_Release(This->focus);
            This->focus = 0;
        }
    }
 
    deactivate_textservices();
 
    return S_OK;
}

ThreadMgr_Destructor()

static void ThreadMgr_Destructor ( ThreadMgr *  This )

static

Definition at line 158 of file threadmgr.c.

{
    struct list *cursor, *cursor2;
 
    /* unhook right away */
    if (This->focusHook)
        UnhookWindowsHookEx(This->focusHook);
 
    TlsSetValue(tlsIndex,NULL);
    TRACE("destroying %p\n", This);
    if (This->focus)
        ITfDocumentMgr_Release(This->focus);
 
    free_sinks(&This->ActiveLanguageProfileNotifySink);
    free_sinks(&This->DisplayAttributeNotifySink);
    free_sinks(&This->KeyTraceEventSink);
    free_sinks(&This->PreservedKeyNotifySink);
    free_sinks(&This->ThreadFocusSink);
    free_sinks(&This->ThreadMgrEventSink);
    free_sinks(&This->UIElementSink);
    free_sinks(&This->InputProcessorProfileActivationSink);
 
    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->CurrentPreservedKeys)
    {
        PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
        list_remove(cursor);
        HeapFree(GetProcessHeap(),0,key->description);
        HeapFree(GetProcessHeap(),0,key);
    }
 
    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->CreatedDocumentMgrs)
    {
        DocumentMgrEntry *mgr = LIST_ENTRY(cursor,DocumentMgrEntry,entry);
        list_remove(cursor);
        FIXME("Left Over ITfDocumentMgr.  Should we do something with it?\n");
        HeapFree(GetProcessHeap(),0,mgr);
    }
 
    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->AssociatedFocusWindows)
    {
        AssociatedWindow *wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
        list_remove(cursor);
        HeapFree(GetProcessHeap(),0,wnd);
    }
 
    CompartmentMgr_Destructor(This->CompartmentMgr);
 
    HeapFree(GetProcessHeap(),0,This);
}

Referenced by ThreadMgr_Release().

ThreadMgr_EnumDocumentMgrs()

static HRESULT WINAPI ThreadMgr_EnumDocumentMgrs ( ITfThreadMgrEx *  iface, IEnumTfDocumentMgrs **  ppEnum  )

static

Definition at line 335 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    TRACE("(%p) %p\n",This,ppEnum);
 
    if (!ppEnum)
        return E_INVALIDARG;
 
    return EnumTfDocumentMgr_Constructor(&This->CreatedDocumentMgrs, ppEnum);
}

ThreadMgr_EnumFunctionProviders()

static HRESULT WINAPI ThreadMgr_EnumFunctionProviders ( ITfThreadMgrEx *  iface, IEnumTfFunctionProviders **  ppEnum  )

static

Definition at line 500 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    FIXME("STUB:(%p)\n",This);
    return E_NOTIMPL;
}

ThreadMgr_GetActiveFlags()

static HRESULT WINAPI ThreadMgr_GetActiveFlags ( ITfThreadMgrEx *  iface, DWORD *  flags  )

static

Definition at line 555 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 
    FIXME("STUB:(%p)\n", This);
    return E_NOTIMPL;
}

ThreadMgr_GetFocus()

static HRESULT WINAPI ThreadMgr_GetFocus ( ITfThreadMgrEx *  iface, ITfDocumentMgr **  ppdimFocus  )

static

Definition at line 346 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    TRACE("(%p)\n",This);
 
    if (!ppdimFocus)
        return E_INVALIDARG;
 
    *ppdimFocus = This->focus;
 
    TRACE("->%p\n",This->focus);
 
    if (This->focus == NULL)
        return S_FALSE;
 
    ITfDocumentMgr_AddRef(This->focus);
 
    return S_OK;
}

ThreadMgr_GetFunctionProvider()

static HRESULT WINAPI ThreadMgr_GetFunctionProvider ( ITfThreadMgrEx *  iface, REFCLSID  clsid, ITfFunctionProvider **  ppFuncProv  )

static

Definition at line 492 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    FIXME("STUB:(%p)\n",This);
    return E_NOTIMPL;
}

ThreadMgr_GetGlobalCompartment()

static HRESULT WINAPI ThreadMgr_GetGlobalCompartment ( ITfThreadMgrEx *  iface, ITfCompartmentMgr **  ppCompMgr  )

static

Definition at line 508 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    HRESULT hr;
    TRACE("(%p) %p\n",This, ppCompMgr);
 
    if (!ppCompMgr)
        return E_INVALIDARG;
 
    if (!globalCompartmentMgr)
    {
        hr = CompartmentMgr_Constructor(NULL,&IID_ITfCompartmentMgr,(IUnknown**)&globalCompartmentMgr);
        if (FAILED(hr))
            return hr;
    }
 
    ITfCompartmentMgr_AddRef(globalCompartmentMgr);
    *ppCompMgr = globalCompartmentMgr;
    return S_OK;
}

ThreadMgr_IsThreadFocus()

static HRESULT WINAPI ThreadMgr_IsThreadFocus ( ITfThreadMgrEx *  iface, BOOL *  pfThreadFocus  )

static

Definition at line 481 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    HWND focus;
 
    TRACE("(%p) %p\n",This,pfThreadFocus);
    focus = GetFocus();
    *pfThreadFocus = (focus == NULL);
    return S_OK;
}

ThreadMgr_OnDocumentMgrDestruction()

void ThreadMgr_OnDocumentMgrDestruction	(	ITfThreadMgr *	iface,
		ITfDocumentMgr *	mgr
	)

Definition at line 1537 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx((ITfThreadMgrEx *)iface);
    struct list *cursor;
    LIST_FOR_EACH(cursor, &This->CreatedDocumentMgrs)
    {
        DocumentMgrEntry *mgrentry = LIST_ENTRY(cursor,DocumentMgrEntry,entry);
        if (mgrentry->docmgr == mgr)
        {
            list_remove(cursor);
            HeapFree(GetProcessHeap(),0,mgrentry);
            return;
        }
    }
    FIXME("ITfDocumentMgr %p not found in this thread\n",mgr);
}

Referenced by DocumentMgr_Destructor().

ThreadMgr_QueryInterface()

static HRESULT WINAPI ThreadMgr_QueryInterface ( ITfThreadMgrEx *  iface, REFIID  iid, LPVOID *  ppvOut  )

static

Definition at line 208 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    *ppvOut = NULL;
 
    if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfThreadMgr)
        || IsEqualIID(iid, &IID_ITfThreadMgrEx))
    {
        *ppvOut = &This->ITfThreadMgrEx_iface;
    }
    else if (IsEqualIID(iid, &IID_ITfSource))
    {
        *ppvOut = &This->ITfSource_iface;
    }
    else if (IsEqualIID(iid, &IID_ITfKeystrokeMgr))
    {
        *ppvOut = &This->ITfKeystrokeMgr_iface;
    }
    else if (IsEqualIID(iid, &IID_ITfMessagePump))
    {
        *ppvOut = &This->ITfMessagePump_iface;
    }
    else if (IsEqualIID(iid, &IID_ITfClientId))
    {
        *ppvOut = &This->ITfClientId_iface;
    }
    else if (IsEqualIID(iid, &IID_ITfCompartmentMgr))
    {
        *ppvOut = This->CompartmentMgr;
    }
    else if (IsEqualIID(iid, &IID_ITfUIElementMgr))
    {
        *ppvOut = &This->ITfUIElementMgr_iface;
    }
    else if (IsEqualIID(iid, &IID_ITfSourceSingle))
    {
        *ppvOut = &This->ITfSourceSingle_iface;
    }
 
    if (*ppvOut)
    {
        ITfThreadMgrEx_AddRef(iface);
        return S_OK;
    }
 
    WARN("unsupported interface: %s\n", debugstr_guid(iid));
    return E_NOINTERFACE;
}

ThreadMgr_Release()

static ULONG WINAPI ThreadMgr_Release ( ITfThreadMgrEx *  iface )

static

Definition at line 263 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    ULONG ret;
 
    ret = InterlockedDecrement(&This->refCount);
    if (ret == 0)
        ThreadMgr_Destructor(This);
    return ret;
}

ThreadMgr_SetFocus()

static HRESULT WINAPI ThreadMgr_SetFocus ( ITfThreadMgrEx *  iface, ITfDocumentMgr *  pdimFocus  )

static

Definition at line 366 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
    ITfDocumentMgr *check;
 
    TRACE("(%p) %p\n",This,pdimFocus);
 
    if (!pdimFocus)
        check = NULL;
    else if (FAILED(ITfDocumentMgr_QueryInterface(pdimFocus,&IID_ITfDocumentMgr,(LPVOID*) &check)))
        return E_INVALIDARG;
 
    ITfThreadMgrEventSink_OnSetFocus(&This->ITfThreadMgrEventSink_iface, check, This->focus);
 
    if (This->focus)
        ITfDocumentMgr_Release(This->focus);
 
    This->focus = check;
    return S_OK;
}

Referenced by ThreadFocusHookProc(), and ThreadMgr_AssociateFocus().

ThreadMgrEventSink_AddRef()

static ULONG WINAPI ThreadMgrEventSink_AddRef ( ITfThreadMgrEventSink *  iface )

static

Definition at line 1105 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
    return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
}

ThreadMgrEventSink_OnInitDocumentMgr()

static HRESULT WINAPI ThreadMgrEventSink_OnInitDocumentMgr ( ITfThreadMgrEventSink *  iface, ITfDocumentMgr *  pdim  )

static

Definition at line 1118 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p\n",This,pdim);
 
    SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        ITfThreadMgrEventSink_OnInitDocumentMgr(sink, pdim);
    }
 
    return S_OK;
}

ThreadMgrEventSink_OnPopContext()

static HRESULT WINAPI ThreadMgrEventSink_OnPopContext ( ITfThreadMgrEventSink *  iface, ITfContext *  pic  )

static

Definition at line 1187 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p\n",This,pic);
 
    SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        ITfThreadMgrEventSink_OnPopContext(sink, pic);
    }
 
    return S_OK;
}

ThreadMgrEventSink_OnPushContext()

static HRESULT WINAPI ThreadMgrEventSink_OnPushContext ( ITfThreadMgrEventSink *  iface, ITfContext *  pic  )

static

Definition at line 1170 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p\n",This,pic);
 
    SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        ITfThreadMgrEventSink_OnPushContext(sink, pic);
    }
 
    return S_OK;
}

ThreadMgrEventSink_OnSetFocus()

static HRESULT WINAPI ThreadMgrEventSink_OnSetFocus ( ITfThreadMgrEventSink *  iface, ITfDocumentMgr *  pdimFocus, ITfDocumentMgr *  pdimPrevFocus  )

static

Definition at line 1152 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p %p\n",This,pdimFocus, pdimPrevFocus);
 
    SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        ITfThreadMgrEventSink_OnSetFocus(sink, pdimFocus, pdimPrevFocus);
    }
 
    return S_OK;
}

ThreadMgrEventSink_OnUninitDocumentMgr()

static HRESULT WINAPI ThreadMgrEventSink_OnUninitDocumentMgr ( ITfThreadMgrEventSink *  iface, ITfDocumentMgr *  pdim  )

static

Definition at line 1135 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p\n",This,pdim);
 
    SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        ITfThreadMgrEventSink_OnUninitDocumentMgr(sink, pdim);
    }
 
    return S_OK;
}

ThreadMgrEventSink_QueryInterface()

static HRESULT WINAPI ThreadMgrEventSink_QueryInterface ( ITfThreadMgrEventSink *  iface, REFIID  iid, LPVOID *  ppvOut  )

static

Definition at line 1099 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
    return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
}

ThreadMgrEventSink_Release()

static ULONG WINAPI ThreadMgrEventSink_Release ( ITfThreadMgrEventSink *  iface )

static

Definition at line 1111 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
    return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
}

ThreadMgrSource_AdviseSink()

static HRESULT WINAPI ThreadMgrSource_AdviseSink ( ITfSource *  iface, REFIID  riid, IUnknown *  punk, DWORD *  pdwCookie  )

static

Definition at line 605 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSource(iface);
 
    TRACE("(%p) %s %p %p\n",This,debugstr_guid(riid),punk,pdwCookie);
 
    if (!riid || !punk || !pdwCookie)
        return E_INVALIDARG;
 
    if (IsEqualIID(riid, &IID_ITfThreadMgrEventSink))
        return advise_sink(&This->ThreadMgrEventSink, &IID_ITfThreadMgrEventSink, COOKIE_MAGIC_TMSINK, punk, pdwCookie);
 
    if (IsEqualIID(riid, &IID_ITfThreadFocusSink))
    {
        WARN("semi-stub for ITfThreadFocusSink: sink won't be used.\n");
        return advise_sink(&This->ThreadFocusSink, &IID_ITfThreadFocusSink, COOKIE_MAGIC_THREADFOCUSSINK, punk, pdwCookie);
    }
 
    if (IsEqualIID(riid, &IID_ITfActiveLanguageProfileNotifySink))
    {
        WARN("semi-stub for ITfActiveLanguageProfileNotifySink: sink won't be used.\n");
        return advise_sink(&This->ActiveLanguageProfileNotifySink, &IID_ITfActiveLanguageProfileNotifySink,
                            COOKIE_MAGIC_ACTIVELANGSINK, punk, pdwCookie);
    }
 
    if (IsEqualIID(riid, &IID_ITfKeyTraceEventSink))
    {
        WARN("semi-stub for ITfKeyTraceEventSink: sink won't be used.\n");
        return advise_sink(&This->KeyTraceEventSink, &IID_ITfKeyTraceEventSink,
                           COOKIE_MAGIC_KEYTRACESINK, punk, pdwCookie);
    }
 
    if (IsEqualIID(riid, &IID_ITfUIElementSink))
    {
        WARN("semi-stub for ITfUIElementSink: sink won't be used.\n");
        return advise_sink(&This->UIElementSink, &IID_ITfUIElementSink,
                           COOKIE_MAGIC_UIELEMENTSINK, punk, pdwCookie);
    }
 
    if (IsEqualIID(riid, &IID_ITfInputProcessorProfileActivationSink))
    {
        WARN("semi-stub for ITfInputProcessorProfileActivationSink: sink won't be used.\n");
        return advise_sink(&This->InputProcessorProfileActivationSink, &IID_ITfInputProcessorProfileActivationSink,
                           COOKIE_MAGIC_INPUTPROCESSORPROFILEACTIVATIONSINK, punk, pdwCookie);
    }
 
    FIXME("(%p) Unhandled Sink: %s\n",This,debugstr_guid(riid));
    return E_NOTIMPL;
}

ThreadMgrSource_UnadviseSink()

static HRESULT WINAPI ThreadMgrSource_UnadviseSink ( ITfSource *  iface, DWORD  pdwCookie  )

static

Definition at line 656 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSource(iface);
    DWORD magic;
 
    TRACE("(%p) %x\n",This,pdwCookie);
 
    magic = get_Cookie_magic(pdwCookie);
    if (magic != COOKIE_MAGIC_TMSINK && magic != COOKIE_MAGIC_THREADFOCUSSINK
        && magic != COOKIE_MAGIC_KEYTRACESINK && magic != COOKIE_MAGIC_UIELEMENTSINK
        && magic != COOKIE_MAGIC_INPUTPROCESSORPROFILEACTIVATIONSINK
        && magic != COOKIE_MAGIC_KEYTRACESINK)
        return E_INVALIDARG;
 
    return unadvise_sink(pdwCookie);
}

ThreadMgrSourceSingle_AddRef()

static ULONG WINAPI ThreadMgrSourceSingle_AddRef ( ITfSourceSingle *  iface )

static

Definition at line 1305 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSourceSingle(iface);
    return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
}

ThreadMgrSourceSingle_AdviseSingleSink()

static HRESULT WINAPI ThreadMgrSourceSingle_AdviseSingleSink ( ITfSourceSingle *  iface, TfClientId  tid, REFIID  riid, IUnknown *  punk  )

static

Definition at line 1317 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSourceSingle(iface);
    FIXME("STUB:(%p) %i %s %p\n",This, tid, debugstr_guid(riid),punk);
    return E_NOTIMPL;
}

ThreadMgrSourceSingle_QueryInterface()

static HRESULT WINAPI ThreadMgrSourceSingle_QueryInterface ( ITfSourceSingle *  iface, REFIID  iid, LPVOID *  ppvOut  )

static

Definition at line 1299 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSourceSingle(iface);
    return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
}

ThreadMgrSourceSingle_Release()

static ULONG WINAPI ThreadMgrSourceSingle_Release ( ITfSourceSingle *  iface )

static

Definition at line 1311 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSourceSingle(iface);
    return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
}

ThreadMgrSourceSingle_UnadviseSingleSink()

static HRESULT WINAPI ThreadMgrSourceSingle_UnadviseSingleSink ( ITfSourceSingle *  iface, TfClientId  tid, REFIID  riid  )

static

Definition at line 1325 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfSourceSingle(iface);
    FIXME("STUB:(%p) %i %s\n",This, tid, debugstr_guid(riid));
    return E_NOTIMPL;
}

UIElementMgr_AddRef()

static ULONG WINAPI UIElementMgr_AddRef ( ITfUIElementMgr *  iface )

static

Definition at line 1226 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
 
    return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
}

UIElementMgr_BeginUIElement()

static HRESULT WINAPI UIElementMgr_BeginUIElement ( ITfUIElementMgr *  iface, ITfUIElement *  element, BOOL *  show, DWORD *  id  )

static

Definition at line 1240 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
 
    FIXME("STUB:(%p)\n", This);
    return E_NOTIMPL;
}

UIElementMgr_EndUIElement()

static HRESULT WINAPI UIElementMgr_EndUIElement ( ITfUIElementMgr *  iface, DWORD  id  )

static

Definition at line 1257 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
 
    FIXME("STUB:(%p)\n", This);
    return E_NOTIMPL;
}

UIElementMgr_EnumUIElements()

static HRESULT WINAPI UIElementMgr_EnumUIElements ( ITfUIElementMgr *  iface, IEnumTfUIElements **  enum_elements  )

static

Definition at line 1274 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
 
    FIXME("STUB:(%p)\n", This);
    return E_NOTIMPL;
}

UIElementMgr_GetUIElement()

static HRESULT WINAPI UIElementMgr_GetUIElement ( ITfUIElementMgr *  iface, DWORD  id, ITfUIElement **  element  )

static

Definition at line 1265 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
 
    FIXME("STUB:(%p)\n", This);
    return E_NOTIMPL;
}

UIElementMgr_QueryInterface()

static HRESULT WINAPI UIElementMgr_QueryInterface ( ITfUIElementMgr *  iface, REFIID  iid, void **  ppvOut  )

static

Definition at line 1219 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
 
    return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
}

UIElementMgr_Release()

static ULONG WINAPI UIElementMgr_Release ( ITfUIElementMgr *  iface )

static

Definition at line 1233 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
 
    return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
}

UIElementMgr_UpdateUIElement()

static HRESULT WINAPI UIElementMgr_UpdateUIElement ( ITfUIElementMgr *  iface, DWORD  id  )

static

Definition at line 1249 of file threadmgr.c.

{
    ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
 
    FIXME("STUB:(%p)\n", This);
    return E_NOTIMPL;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msctf

)

Variable Documentation

ClientIdVtbl

const ITfClientIdVtbl ClientIdVtbl

static

Initial value:

=
{
    ClientId_QueryInterface,
    ClientId_AddRef,
    ClientId_Release,
    ClientId_GetClientId
}

Definition at line 1088 of file threadmgr.c.

Referenced by ThreadMgr_Constructor().

EnumTfDocumentMgrsVtbl

const IEnumTfDocumentMgrsVtbl EnumTfDocumentMgrsVtbl

static

Initial value:

=
{
    EnumTfDocumentMgr_QueryInterface,
    EnumTfDocumentMgr_AddRef,
    EnumTfDocumentMgr_Release,
    EnumTfDocumentMgr_Clone,
    EnumTfDocumentMgr_Next,
    EnumTfDocumentMgr_Reset,
    EnumTfDocumentMgr_Skip
}

Definition at line 1508 of file threadmgr.c.

Referenced by EnumTfDocumentMgr_Constructor().

KeystrokeMgrVtbl

const ITfKeystrokeMgrVtbl KeystrokeMgrVtbl

static

Initial value:

=
{
    KeystrokeMgr_QueryInterface,
    KeystrokeMgr_AddRef,
    KeystrokeMgr_Release,
    KeystrokeMgr_AdviseKeyEventSink,
    KeystrokeMgr_UnadviseKeyEventSink,
    KeystrokeMgr_GetForeground,
    KeystrokeMgr_TestKeyDown,
    KeystrokeMgr_TestKeyUp,
    KeystrokeMgr_KeyDown,
    KeystrokeMgr_KeyUp,
    KeystrokeMgr_GetPreservedKey,
    KeystrokeMgr_IsPreservedKey,
    KeystrokeMgr_PreserveKey,
    KeystrokeMgr_UnpreserveKey,
    KeystrokeMgr_SetPreservedKeyDescription,
    KeystrokeMgr_GetPreservedKeyDescription,
    KeystrokeMgr_SimulatePreservedKey
}

Definition at line 955 of file threadmgr.c.

Referenced by ThreadMgr_Constructor().

MessagePumpVtbl

const ITfMessagePumpVtbl MessagePumpVtbl

static

Initial value:

=
{
    MessagePump_QueryInterface,
    MessagePump_AddRef,
    MessagePump_Release,
    MessagePump_PeekMessageA,
    MessagePump_GetMessageA,
    MessagePump_PeekMessageW,
    MessagePump_GetMessageW
}

Definition at line 1038 of file threadmgr.c.

Referenced by ThreadMgr_Constructor().

SourceSingleVtbl

const ITfSourceSingleVtbl SourceSingleVtbl

static

Initial value:

=
{
    ThreadMgrSourceSingle_QueryInterface,
    ThreadMgrSourceSingle_AddRef,
    ThreadMgrSourceSingle_Release,
    ThreadMgrSourceSingle_AdviseSingleSink,
    ThreadMgrSourceSingle_UnadviseSingleSink
}

Definition at line 1333 of file threadmgr.c.

Referenced by ThreadMgr_Constructor().

ThreadMgrEventSinkVtbl

const ITfThreadMgrEventSinkVtbl ThreadMgrEventSinkVtbl

static

Initial value:

=
{
    ThreadMgrEventSink_QueryInterface,
    ThreadMgrEventSink_AddRef,
    ThreadMgrEventSink_Release,
    ThreadMgrEventSink_OnInitDocumentMgr,
    ThreadMgrEventSink_OnUninitDocumentMgr,
    ThreadMgrEventSink_OnSetFocus,
    ThreadMgrEventSink_OnPushContext,
    ThreadMgrEventSink_OnPopContext
}

Definition at line 1204 of file threadmgr.c.

Referenced by ThreadMgr_Constructor().

ThreadMgrExVtbl

const ITfThreadMgrExVtbl ThreadMgrExVtbl

static

Initial value:

=
{
    ThreadMgr_QueryInterface,
    ThreadMgr_AddRef,
    ThreadMgr_Release,
    ThreadMgr_Activate,
    ThreadMgr_Deactivate,
    ThreadMgr_CreateDocumentMgr,
    ThreadMgr_EnumDocumentMgrs,
    ThreadMgr_GetFocus,
    ThreadMgr_SetFocus,
    ThreadMgr_AssociateFocus,
    ThreadMgr_IsThreadFocus,
    ThreadMgr_GetFunctionProvider,
    ThreadMgr_EnumFunctionProviders,
    ThreadMgr_GetGlobalCompartment,
 
    ThreadMgr_ActivateEx,
    ThreadMgr_GetActiveFlags
}

Definition at line 563 of file threadmgr.c.

Referenced by ThreadMgr_Constructor().

ThreadMgrSourceVtbl

const ITfSourceVtbl ThreadMgrSourceVtbl

static

Initial value:

=
{
    Source_QueryInterface,
    Source_AddRef,
    Source_Release,
    ThreadMgrSource_AdviseSink,
    ThreadMgrSource_UnadviseSink,
}

Definition at line 673 of file threadmgr.c.

Referenced by ThreadMgr_Constructor().

ThreadMgrUIElementMgrVtbl

const ITfUIElementMgrVtbl ThreadMgrUIElementMgrVtbl

static

Initial value:

=
{
    UIElementMgr_QueryInterface,
    UIElementMgr_AddRef,
    UIElementMgr_Release,
 
    UIElementMgr_BeginUIElement,
    UIElementMgr_UpdateUIElement,
    UIElementMgr_EndUIElement,
    UIElementMgr_GetUIElement,
    UIElementMgr_EnumUIElements
}

Definition at line 1283 of file threadmgr.c.

Referenced by ThreadMgr_Constructor().