CThreadMgr Class Reference

Inheritance diagram for CThreadMgr:

Collaboration diagram for CThreadMgr:

Public Member Functions
	CThreadMgr ()
virtual	~CThreadMgr ()
void	OnDocumentMgrDestruction (ITfDocumentMgr *mgr)
STDMETHODIMP	QueryInterface (REFIID iid, LPVOID *ppvObject) override
	STDMETHODIMP_ (ULONG) AddRef() override
	STDMETHODIMP_ (ULONG) Release() override
STDMETHODIMP	Activate (_Out_ TfClientId *ptid) override
STDMETHODIMP	Deactivate () override
STDMETHODIMP	CreateDocumentMgr (_Out_ ITfDocumentMgr **ppdim) override
STDMETHODIMP	EnumDocumentMgrs (_Out_ IEnumTfDocumentMgrs **ppEnum) override
STDMETHODIMP	GetFocus (_Out_ ITfDocumentMgr **ppdimFocus) override
STDMETHODIMP	SetFocus (_In_ ITfDocumentMgr *pdimFocus) override
STDMETHODIMP	AssociateFocus (_In_ HWND hwnd, _In_ ITfDocumentMgr *pdimNew, _Out_ ITfDocumentMgr **ppdimPrev) override
STDMETHODIMP	IsThreadFocus (_Out_ BOOL *pfThreadFocus) override
STDMETHODIMP	GetFunctionProvider (_In_ REFCLSID clsid, _Out_ ITfFunctionProvider **ppFuncProv) override
STDMETHODIMP	EnumFunctionProviders (_Out_ IEnumTfFunctionProviders **ppEnum) override
STDMETHODIMP	GetGlobalCompartment (_Out_ ITfCompartmentMgr **ppCompMgr) override
STDMETHODIMP	ActivateEx (_Out_ TfClientId *id, _In_ DWORD flags) override
STDMETHODIMP	GetActiveFlags (_Out_ DWORD *flags) override
STDMETHODIMP	AdviseSink (_In_ REFIID riid, _In_ IUnknown *punk, _Out_ DWORD *pdwCookie) override
STDMETHODIMP	UnadviseSink (_In_ DWORD dwCookie) override
STDMETHODIMP	AdviseKeyEventSink (_In_ TfClientId tid, _In_ ITfKeyEventSink *pSink, _In_ BOOL fForeground) override
STDMETHODIMP	UnadviseKeyEventSink (_In_ TfClientId tid) override
STDMETHODIMP	GetForeground (_Out_ CLSID *pclsid) override
STDMETHODIMP	TestKeyDown (_In_ WPARAM wParam, _In_ LPARAM lParam, _Out_ BOOL *pfEaten) override
STDMETHODIMP	TestKeyUp (_In_ WPARAM wParam, _In_ LPARAM lParam, _Out_ BOOL *pfEaten) override
STDMETHODIMP	KeyDown (_In_ WPARAM wParam, _In_ LPARAM lParam, _Out_ BOOL *pfEaten) override
STDMETHODIMP	KeyUp (_In_ WPARAM wParam, _In_ LPARAM lParam, _Out_ BOOL *pfEaten) override
STDMETHODIMP	GetPreservedKey (_In_ ITfContext *pic, _In_ const TF_PRESERVEDKEY *pprekey, _Out_ GUID *pguid) override
STDMETHODIMP	IsPreservedKey (_In_ REFGUID rguid, _In_ const TF_PRESERVEDKEY *pprekey, _Out_ BOOL *pfRegistered) override
STDMETHODIMP	PreserveKey (_In_ TfClientId tid, _In_ REFGUID rguid, _In_ const TF_PRESERVEDKEY *prekey, _In_ const WCHAR *pchDesc, _In_ ULONG cchDesc) override
STDMETHODIMP	UnpreserveKey (_In_ REFGUID rguid, _In_ const TF_PRESERVEDKEY *pprekey) override
STDMETHODIMP	SetPreservedKeyDescription (_In_ REFGUID rguid, _In_ const WCHAR *pchDesc, _In_ ULONG cchDesc) override
STDMETHODIMP	GetPreservedKeyDescription (_In_ REFGUID rguid, _Out_ BSTR *pbstrDesc) override
STDMETHODIMP	SimulatePreservedKey (_In_ ITfContext *pic, _In_ REFGUID rguid, _Out_ BOOL *pfEaten) override
STDMETHODIMP	PeekMessageA (_Out_ LPMSG pMsg, _In_ HWND hwnd, _In_ UINT wMsgFilterMin, _In_ UINT wMsgFilterMax, _In_ UINT wRemoveMsg, _Out_ BOOL *pfResult) override
STDMETHODIMP	GetMessageA (_Out_ LPMSG pMsg, _In_ HWND hwnd, _In_ UINT wMsgFilterMin, _In_ UINT wMsgFilterMax, _Out_ BOOL *pfResult) override
STDMETHODIMP	PeekMessageW (_Out_ LPMSG pMsg, _In_ HWND hwnd, _In_ UINT wMsgFilterMin, _In_ UINT wMsgFilterMax, _In_ UINT wRemoveMsg, _Out_ BOOL *pfResult) override
STDMETHODIMP	GetMessageW (_Out_ LPMSG pMsg, _In_ HWND hwnd, _In_ UINT wMsgFilterMin, _In_ UINT wMsgFilterMax, _Out_ BOOL *pfResult) override
STDMETHODIMP	GetClientId (_In_ REFCLSID rclsid, _Out_ TfClientId *ptid) override
STDMETHODIMP	BeginUIElement (_In_ ITfUIElement *element, _Inout_ BOOL *show, _Out_ DWORD *id) override
STDMETHODIMP	UpdateUIElement (_In_ DWORD id) override
STDMETHODIMP	EndUIElement (_In_ DWORD id) override
STDMETHODIMP	GetUIElement (_In_ DWORD id, _Out_ ITfUIElement **element) override
STDMETHODIMP	EnumUIElements (_Out_ IEnumTfUIElements **enum_elements) override
STDMETHODIMP	AdviseSingleSink (_In_ TfClientId tid, _In_ REFIID riid, _In_ IUnknown *punk) override
STDMETHODIMP	UnadviseSingleSink (_In_ TfClientId tid, _In_ REFIID riid) override
STDMETHODIMP	OnInitDocumentMgr (_In_ ITfDocumentMgr *pdim) override
STDMETHODIMP	OnUninitDocumentMgr (_In_ ITfDocumentMgr *pdim) override
STDMETHODIMP	OnSetFocus (_In_ ITfDocumentMgr *pdimFocus, _In_ ITfDocumentMgr *pdimPrevFocus) override
STDMETHODIMP	OnPushContext (_In_ ITfContext *pic) override
STDMETHODIMP	OnPopContext (_In_ ITfContext *pic) override
Public Member Functions inherited from ITfThreadMgrEx
HRESULT	ActivateEx ([out] TfClientId *id, [in] DWORD flags)
HRESULT	GetActiveFlags ([out] DWORD *flags)
Public Member Functions inherited from ITfThreadMgr
HRESULT	Activate ([out] TfClientId *ptid)
HRESULT	Deactivate ()
HRESULT	CreateDocumentMgr ([out] ITfDocumentMgr **ppdim)
HRESULT	EnumDocumentMgrs ([out] IEnumTfDocumentMgrs **ppEnum)
HRESULT	GetFocus ([out] ITfDocumentMgr **ppdimFocus)
HRESULT	SetFocus ([in] ITfDocumentMgr *pdimFocus)
HRESULT	AssociateFocus ([in] HWND hwnd, [in, unique] ITfDocumentMgr *pdimNew, [out] ITfDocumentMgr **ppdimPrev)
HRESULT	IsThreadFocus ([out] BOOL *pfThreadFocus)
HRESULT	GetFunctionProvider ([in] REFCLSID clsid, [out] ITfFunctionProvider **ppFuncProv)
HRESULT	EnumFunctionProviders ([out] IEnumTfFunctionProviders **ppEnum)
HRESULT	GetGlobalCompartment ([out] ITfCompartmentMgr **ppCompMgr)
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()
Public Member Functions inherited from ITfSource
HRESULT	AdviseSink ([in] REFIID riid, [in, iid_is(riid)] IUnknown *punk, [out] DWORD *pdwCookie)
HRESULT	UnadviseSink ([in] DWORD dwCookie)
Public Member Functions inherited from ITfKeystrokeMgr
HRESULT	AdviseKeyEventSink ([in] TfClientId tid, [in] ITfKeyEventSink *pSink, [in] BOOL fForeground)
HRESULT	UnadviseKeyEventSink ([in] TfClientId tid)
HRESULT	GetForeground ([out] CLSID *pclsid)
HRESULT	TestKeyDown ([in] WPARAM wParam, [in] LPARAM lParam, [out] BOOL *pfEaten)
HRESULT	TestKeyUp ([in] WPARAM wParam, [in] LPARAM lParam, [out] BOOL *pfEaten)
HRESULT	KeyDown ([in] WPARAM wParam, [in] LPARAM lParam, [out] BOOL *pfEaten)
HRESULT	KeyUp ([in] WPARAM wParam, [in] LPARAM lParam, [out] BOOL *pfEaten)
HRESULT	GetPreservedKey ([in] ITfContext *pic, [in] const TF_PRESERVEDKEY *pprekey, [out] GUID *pguid)
HRESULT	IsPreservedKey ([in] REFGUID rguid, [in] const TF_PRESERVEDKEY *pprekey, [out] BOOL *pfRegistered)
HRESULT	PreserveKey ([in] TfClientId tid, [in] REFGUID rguid, [in] const TF_PRESERVEDKEY *prekey, [in, size_is(cchDesc)] const WCHAR *pchDesc, [in] ULONG cchDesc)
HRESULT	UnpreserveKey ([in] REFGUID rguid, [in] const TF_PRESERVEDKEY *pprekey)
HRESULT	SetPreservedKeyDescription ([in] REFGUID rguid, [in, size_is(cchDesc)] const WCHAR *pchDesc, [in] ULONG cchDesc)
HRESULT	GetPreservedKeyDescription ([in] REFGUID rguid, [out] BSTR *pbstrDesc)
HRESULT	SimulatePreservedKey ([in] ITfContext *pic, [in] REFGUID rguid, [out] BOOL *pfEaten)
Public Member Functions inherited from ITfMessagePump
HRESULT	PeekMessageA ([out] LPMSG pMsg, [in] HWND hwnd, [in] UINT wMsgFilterMin, [in] UINT wMsgFilterMax, [in] UINT wRemoveMsg, [out] BOOL *pfResult)
HRESULT	GetMessageA ([out] LPMSG pMsg, [in] HWND hwnd, [in] UINT wMsgFilterMin, [in] UINT wMsgFilterMax, [out] BOOL *pfResult)
HRESULT	PeekMessageW ([out] LPMSG pMsg, [in] HWND hwnd, [in] UINT wMsgFilterMin, [in] UINT wMsgFilterMax, [in] UINT wRemoveMsg, [out] BOOL *pfResult)
HRESULT	GetMessageW ([out] LPMSG pMsg, [in] HWND hwnd, [in] UINT wMsgFilterMin, [in] UINT wMsgFilterMax, [out] BOOL *pfResult)
Public Member Functions inherited from ITfClientId
HRESULT	GetClientId ([in] REFCLSID rclsid, [out] TfClientId *ptid)
Public Member Functions inherited from ITfUIElementMgr
HRESULT	BeginUIElement ([in] ITfUIElement *element, [in, out] BOOL *show, [out] DWORD *id)
HRESULT	UpdateUIElement ([in] DWORD id)
HRESULT	EndUIElement ([in] DWORD id)
HRESULT	GetUIElement ([in] DWORD id, [out] ITfUIElement **element)
HRESULT	EnumUIElements ([out] IEnumTfUIElements **enum_elements)
Public Member Functions inherited from ITfSourceSingle
HRESULT	AdviseSingleSink ([in] TfClientId tid, [in] REFIID riid, [in, iid_is(riid)] IUnknown *punk)
HRESULT	UnadviseSingleSink ([in] TfClientId tid, [in] REFIID riid)
Public Member Functions inherited from ITfThreadMgrEventSink
HRESULT	OnInitDocumentMgr ([in] ITfDocumentMgr *pdim)
HRESULT	OnUninitDocumentMgr ([in] ITfDocumentMgr *pdim)
HRESULT	OnSetFocus ([in] ITfDocumentMgr *pdimFocus, [in] ITfDocumentMgr *pdimPrevFocus)
HRESULT	OnPushContext ([in] ITfContext *pic)
HRESULT	OnPopContext ([in] ITfContext *pic)

Static Public Member Functions
static HRESULT	CreateInstance (IUnknown *pUnkOuter, CThreadMgr **ppOut)

Protected Member Functions
LRESULT	_ThreadFocusHookProc (INT nCode, WPARAM wParam, LPARAM lParam)
HRESULT	SetupWindowsHook ()

Static Protected Member Functions
static LRESULT CALLBACK	ThreadFocusHookProc (INT nCode, WPARAM wParam, LPARAM lParam)

Protected Attributes
LONG	m_cRefs
ITfCompartmentMgr *	m_CompartmentMgr
ITfDocumentMgr *	m_focus
LONG	m_activationCount
ITfKeyEventSink *	m_foregroundKeyEventSink
CLSID	m_foregroundTextService
struct list	m_CurrentPreservedKeys
struct list	m_CreatedDocumentMgrs
struct list	m_AssociatedFocusWindows
HHOOK	m_focusHook
struct list	m_ActiveLanguageProfileNotifySink
struct list	m_DisplayAttributeNotifySink
struct list	m_KeyTraceEventSink
struct list	m_PreservedKeyNotifySink
struct list	m_ThreadFocusSink
struct list	m_ThreadMgrEventSink
struct list	m_UIElementSink
struct list	m_InputProcessorProfileActivationSink

Additional Inherited Members
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN

Detailed Description

Definition at line 40 of file threadmgr.cpp.

Constructor & Destructor Documentation

CThreadMgr()

CThreadMgr::CThreadMgr

(

)

Definition at line 277 of file threadmgr.cpp.

    : m_cRefs(1)
    , m_CompartmentMgr(NULL)
    , m_focus(NULL)
    , m_activationCount(0)
    , m_foregroundKeyEventSink(NULL)
{
    m_foregroundTextService = GUID_NULL;
 
    list_init(&m_CurrentPreservedKeys);
    list_init(&m_CreatedDocumentMgrs);
 
    list_init(&m_AssociatedFocusWindows);
    m_focusHook = NULL;
 
    /* kept as separate lists to reduce unnecessary iterations */
    list_init(&m_ActiveLanguageProfileNotifySink);
    list_init(&m_DisplayAttributeNotifySink);
    list_init(&m_KeyTraceEventSink);
    list_init(&m_PreservedKeyNotifySink);
    list_init(&m_ThreadFocusSink);
    list_init(&m_ThreadMgrEventSink);
    list_init(&m_UIElementSink);
    list_init(&m_InputProcessorProfileActivationSink);
}

Referenced by CreateInstance().

~CThreadMgr()

CThreadMgr::~CThreadMgr ( )

virtual

Definition at line 303 of file threadmgr.cpp.

{
    struct list *cursor, *cursor2;
 
    /* unhook right away */
    if (m_focusHook)
        UnhookWindowsHookEx(m_focusHook);
 
    TlsSetValue(g_dwTLSIndex, NULL);
    TRACE("destroying %p\n", this);
 
    if (m_focus)
        m_focus->Release();
 
    free_sinks(&m_ActiveLanguageProfileNotifySink);
    free_sinks(&m_DisplayAttributeNotifySink);
    free_sinks(&m_KeyTraceEventSink);
    free_sinks(&m_PreservedKeyNotifySink);
    free_sinks(&m_ThreadFocusSink);
    free_sinks(&m_ThreadMgrEventSink);
    free_sinks(&m_UIElementSink);
    free_sinks(&m_InputProcessorProfileActivationSink);
 
    LIST_FOR_EACH_SAFE(cursor, cursor2, &m_CurrentPreservedKeys)
    {
        PreservedKey* key = LIST_ENTRY(cursor, PreservedKey, entry);
        list_remove(cursor);
        cicMemFree(key->description);
        cicMemFree(key);
    }
 
    LIST_FOR_EACH_SAFE(cursor, cursor2, &m_CreatedDocumentMgrs)
    {
        DocumentMgrEntry *mgr = LIST_ENTRY(cursor, DocumentMgrEntry, entry);
        list_remove(cursor);
        FIXME("Left Over ITfDocumentMgr.  Should we do something with it?\n");
        cicMemFree(mgr);
    }
 
    LIST_FOR_EACH_SAFE(cursor, cursor2, &m_AssociatedFocusWindows)
    {
        AssociatedWindow *wnd = LIST_ENTRY(cursor, AssociatedWindow, entry);
        list_remove(cursor);
        cicMemFree(wnd);
    }
 
    m_CompartmentMgr->Release();
}

Member Function Documentation

_ThreadFocusHookProc()

LRESULT CThreadMgr::_ThreadFocusHookProc ( INT  nCode, WPARAM  wParam, LPARAM  lParam  )

protected

Definition at line 500 of file threadmgr.cpp.

{
    if (!m_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, &m_AssociatedFocusWindows)
        {
            AssociatedWindow *wnd = LIST_ENTRY(cursor, AssociatedWindow, entry);
            if (wnd->hwnd == (HWND)wParam)
            {
                TRACE("Triggering Associated window focus\n");
                if (m_focus != wnd->docmgr)
                    SetFocus(wnd->docmgr);
                break;
            }
        }
    }
 
    return CallNextHookEx(m_focusHook, nCode, wParam, lParam);
}

Activate()

STDMETHODIMP CThreadMgr::Activate ( _Out_ TfClientId *  ptid )

override

Definition at line 398 of file threadmgr.cpp.

{
    TRACE("(%p) %p\n", this, ptid);
    return ActivateEx(ptid, 0);
}

ActivateEx()

STDMETHODIMP CThreadMgr::ActivateEx ( _Out_ TfClientId *  id, _In_ DWORD  flags  )

override

Definition at line 642 of file threadmgr.cpp.

{
    TRACE("(%p) %p, %#x\n", this, id, flags);
 
    if (!id)
        return E_INVALIDARG;
 
    if (flags)
        FIXME("Unimplemented flags %#x\n", flags);
 
    if (!g_processId)
    {
        GUID guid;
        CoCreateGuid(&guid);
        GetClientId(guid, &g_processId);
    }
 
    activate_textservices(this);
    ++m_activationCount;
    *id = g_processId;
    return S_OK;
}

Referenced by Activate().

AdviseKeyEventSink()

STDMETHODIMP CThreadMgr::AdviseKeyEventSink ( _In_ TfClientId  tid, _In_ ITfKeyEventSink *  pSink, _In_ BOOL  fForeground  )

override

Definition at line 743 of file threadmgr.cpp.

{
    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 (GUID_NULL == textservice)
        return E_INVALIDARG;
 
    get_textservice_sink(tid, IID_ITfKeyEventSink, (IUnknown **)&check);
    if (check)
        return CONNECT_E_ADVISELIMIT;
 
    if (FAILED(pSink->QueryInterface(IID_ITfKeyEventSink, (LPVOID*)&check)))
        return E_INVALIDARG;
 
    set_textservice_sink(tid, IID_ITfKeyEventSink, check);
 
    if (fForeground)
    {
        if (m_foregroundKeyEventSink)
        {
            m_foregroundKeyEventSink->OnSetFocus(FALSE);
            m_foregroundKeyEventSink->Release();
        }
        check->AddRef();
        check->OnSetFocus(TRUE);
        m_foregroundKeyEventSink = check;
        m_foregroundTextService = textservice;
    }
    return S_OK;
}

AdviseSingleSink()

STDMETHODIMP CThreadMgr::AdviseSingleSink ( _In_ TfClientId  tid, _In_ REFIID  riid, _In_ IUnknown *  punk  )

override

Definition at line 1195 of file threadmgr.cpp.

{
    FIXME("STUB:(%p) %i %s %p\n", this, tid, debugstr_guid(&riid), punk);
    return E_NOTIMPL;
}

AdviseSink()

STDMETHODIMP CThreadMgr::AdviseSink ( _In_ REFIID  riid, _In_ IUnknown *  punk, _Out_ DWORD *  pdwCookie  )

override

Definition at line 673 of file threadmgr.cpp.

{
    TRACE("(%p) %s %p %p\n", this, debugstr_guid(&riid), punk, pdwCookie);
 
    if (cicIsNullPtr(&riid) || !punk || !pdwCookie)
        return E_INVALIDARG;
 
    if (riid == IID_ITfThreadMgrEventSink)
        return advise_sink(&m_ThreadMgrEventSink, IID_ITfThreadMgrEventSink, COOKIE_MAGIC_TMSINK, punk, pdwCookie);
 
    if (riid == IID_ITfThreadFocusSink)
    {
        WARN("semi-stub for ITfThreadFocusSink: sink won't be used.\n");
        return advise_sink(&m_ThreadFocusSink, IID_ITfThreadFocusSink, COOKIE_MAGIC_THREADFOCUSSINK, punk, pdwCookie);
    }
 
    if (riid == IID_ITfActiveLanguageProfileNotifySink)
    {
        WARN("semi-stub for ITfActiveLanguageProfileNotifySink: sink won't be used.\n");
        return advise_sink(&m_ActiveLanguageProfileNotifySink, IID_ITfActiveLanguageProfileNotifySink,
                           COOKIE_MAGIC_ACTIVELANGSINK, punk, pdwCookie);
    }
 
    if (riid == IID_ITfKeyTraceEventSink)
    {
        WARN("semi-stub for ITfKeyTraceEventSink: sink won't be used.\n");
        return advise_sink(&m_KeyTraceEventSink, IID_ITfKeyTraceEventSink,
                           COOKIE_MAGIC_KEYTRACESINK, punk, pdwCookie);
    }
 
    if (riid == IID_ITfUIElementSink)
    {
        WARN("semi-stub for ITfUIElementSink: sink won't be used.\n");
        return advise_sink(&m_UIElementSink, IID_ITfUIElementSink,
                           COOKIE_MAGIC_UIELEMENTSINK, punk, pdwCookie);
    }
 
    if (riid == IID_ITfInputProcessorProfileActivationSink)
    {
        WARN("semi-stub for ITfInputProcessorProfileActivationSink: sink won't be used.\n");
        return advise_sink(&m_InputProcessorProfileActivationSink, IID_ITfInputProcessorProfileActivationSink,
                           COOKIE_MAGIC_INPUTPROCESSORPROFILEACTIVATIONSINK, punk, pdwCookie);
    }
 
    FIXME("(%p) Unhandled Sink: %s\n", this, debugstr_guid(&riid));
    return E_NOTIMPL;
}

AssociateFocus()

STDMETHODIMP CThreadMgr::AssociateFocus ( _In_ HWND  hwnd, _In_ ITfDocumentMgr *  pdimNew, _Out_ ITfDocumentMgr **  ppdimPrev  )

override

Definition at line 554 of file threadmgr.cpp.

{
    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, &m_AssociatedFocusWindows)
    {
        wnd = LIST_ENTRY(cursor, AssociatedWindow, entry);
        if (wnd->hwnd == hwnd)
        {
            if (wnd->docmgr)
                wnd->docmgr->AddRef();
            *ppdimPrev = wnd->docmgr;
            wnd->docmgr = pdimNew;
            if (::GetFocus() == hwnd)
                SetFocus(pdimNew);
            return S_OK;
        }
    }
 
    wnd = (AssociatedWindow *)cicMemAlloc(sizeof(AssociatedWindow));
    wnd->hwnd = hwnd;
    wnd->docmgr = pdimNew;
    list_add_head(&m_AssociatedFocusWindows, &wnd->entry);
 
    if (::GetFocus() == hwnd)
        SetFocus(pdimNew);
 
    this->SetupWindowsHook();
    return S_OK;
}

BeginUIElement()

STDMETHODIMP CThreadMgr::BeginUIElement ( _In_ ITfUIElement *  element, _Inout_ BOOL *  show, _Out_ DWORD *  id  )

override

Definition at line 1160 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

CreateDocumentMgr()

STDMETHODIMP CThreadMgr::CreateDocumentMgr ( _Out_ ITfDocumentMgr **  ppdim )

override

Definition at line 427 of file threadmgr.cpp.

{
    TRACE("(%p)\n", this);
 
    if (!ppdim)
        return E_INVALIDARG;
 
    DocumentMgrEntry *mgrentry = (DocumentMgrEntry *)cicMemAlloc(sizeof(DocumentMgrEntry));
    if (!mgrentry)
        return E_OUTOFMEMORY;
 
    HRESULT hr = DocumentMgr_Constructor(this, ppdim);
    if (SUCCEEDED(hr))
    {
        mgrentry->docmgr = *ppdim;
        list_add_head(&m_CreatedDocumentMgrs, &mgrentry->entry);
    }
    else
    {
        cicMemFree(mgrentry);
    }
 
    return hr;
}

CreateInstance()

HRESULT CThreadMgr::CreateInstance ( IUnknown *  pUnkOuter, CThreadMgr **  ppOut  )

static

Definition at line 1212 of file threadmgr.cpp.

{
    if (pUnkOuter)
        return CLASS_E_NOAGGREGATION;
 
    /* Only 1 ThreadMgr is created per thread */
    CThreadMgr *This = (CThreadMgr *)TlsGetValue(g_dwTLSIndex);
    if (This)
    {
        This->AddRef();
        *ppOut = This;
        return S_OK;
    }
 
    This = new(cicNoThrow) CThreadMgr();
    if (!This)
        return E_OUTOFMEMORY;
 
    TlsSetValue(g_dwTLSIndex, This);
 
    ITfCompartmentMgr *pCompMgr = NULL;
    CompartmentMgr_Constructor(static_cast<ITfThreadMgrEx *>(This), IID_IUnknown, (IUnknown **)&pCompMgr);
    This->m_CompartmentMgr = pCompMgr;
 
    TRACE("returning %p\n", This);
    *ppOut = This;
    return S_OK;
}

Referenced by ThreadMgr_Constructor().

Deactivate()

STDMETHODIMP CThreadMgr::Deactivate ( )

override

Implements ITfThreadMgr.

Definition at line 404 of file threadmgr.cpp.

{
    TRACE("(%p)\n", this);
 
    if (m_activationCount == 0)
        return E_UNEXPECTED;
 
    --m_activationCount;
 
    if (m_activationCount == 0)
    {
        if (m_focus)
        {
            OnSetFocus(NULL, m_focus);
            m_focus->Release();
            m_focus = NULL;
        }
    }
 
    deactivate_textservices();
    return S_OK;
}

EndUIElement()

STDMETHODIMP CThreadMgr::EndUIElement ( _In_ DWORD  id )

override

Definition at line 1175 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

EnumDocumentMgrs()

STDMETHODIMP CThreadMgr::EnumDocumentMgrs ( _Out_ IEnumTfDocumentMgrs **  ppEnum )

override

Definition at line 452 of file threadmgr.cpp.

{
    TRACE("(%p) %p\n", this, ppEnum);
 
    if (!ppEnum)
        return E_INVALIDARG;
 
    return CEnumTfDocumentMgr::CreateInstance(&m_CreatedDocumentMgrs, (CEnumTfDocumentMgr **)ppEnum);
}

EnumFunctionProviders()

STDMETHODIMP CThreadMgr::EnumFunctionProviders ( _Out_ IEnumTfFunctionProviders **  ppEnum )

override

Definition at line 616 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

EnumUIElements()

STDMETHODIMP CThreadMgr::EnumUIElements ( _Out_ IEnumTfUIElements **  enum_elements )

override

Definition at line 1189 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

GetActiveFlags()

STDMETHODIMP CThreadMgr::GetActiveFlags ( _Out_ DWORD *  flags )

override

Definition at line 667 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

GetClientId()

STDMETHODIMP CThreadMgr::GetClientId ( _In_ REFCLSID  rclsid, _Out_ TfClientId *  ptid  )

override

Definition at line 1067 of file threadmgr.cpp.

{
    HRESULT hr;
    ITfCategoryMgr *catmgr;
 
    TRACE("(%p) %s\n", this, debugstr_guid(&rclsid));
 
    CategoryMgr_Constructor(NULL, (IUnknown **)&catmgr);
    hr = catmgr->RegisterGUID(rclsid, ptid);
    catmgr->Release();
 
    return hr;
}

Referenced by ActivateEx().

GetFocus()

STDMETHODIMP CThreadMgr::GetFocus ( _Out_ ITfDocumentMgr **  ppdimFocus )

override

Definition at line 462 of file threadmgr.cpp.

{
    TRACE("(%p)\n", this);
 
    if (!ppdimFocus)
        return E_INVALIDARG;
 
    *ppdimFocus = m_focus;
 
    TRACE("->%p\n", m_focus);
 
    if (!m_focus)
        return S_FALSE;
 
    m_focus->AddRef();
    return S_OK;
}

GetForeground()

STDMETHODIMP CThreadMgr::GetForeground ( _Out_ CLSID *  pclsid )

override

Definition at line 814 of file threadmgr.cpp.

{
    TRACE("(%p) %p\n", this, pclsid);
    if (!pclsid)
        return E_INVALIDARG;
 
    if (m_foregroundTextService == GUID_NULL)
        return S_FALSE;
 
    *pclsid = m_foregroundTextService;
    return S_OK;
}

GetFunctionProvider()

STDMETHODIMP CThreadMgr::GetFunctionProvider ( _In_ REFCLSID  clsid, _Out_ ITfFunctionProvider **  ppFuncProv  )

override

Definition at line 608 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

GetGlobalCompartment()

STDMETHODIMP CThreadMgr::GetGlobalCompartment ( _Out_ ITfCompartmentMgr **  ppCompMgr )

override

Definition at line 622 of file threadmgr.cpp.

{
    HRESULT hr;
    TRACE("(%p) %p\n", this, ppCompMgr);
 
    if (!ppCompMgr)
        return E_INVALIDARG;
 
    if (!g_globalCompartmentMgr)
    {
        hr = CompartmentMgr_Constructor(NULL, IID_ITfCompartmentMgr, (IUnknown **)&g_globalCompartmentMgr);
        if (FAILED(hr))
            return hr;
    }
 
    g_globalCompartmentMgr->AddRef();
    *ppCompMgr = g_globalCompartmentMgr;
    return S_OK;
}

GetMessageA()

STDMETHODIMP CThreadMgr::GetMessageA ( _Out_ LPMSG  pMsg, _In_ HWND  hwnd, _In_ UINT  wMsgFilterMin, _In_ UINT  wMsgFilterMax, _Out_ BOOL *  pfResult  )

override

Definition at line 1027 of file threadmgr.cpp.

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

Referenced by GetMessageA().

GetMessageW()

STDMETHODIMP CThreadMgr::GetMessageW ( _Out_ LPMSG  pMsg, _In_ HWND  hwnd, _In_ UINT  wMsgFilterMin, _In_ UINT  wMsgFilterMax, _Out_ BOOL *  pfResult  )

override

Definition at line 1054 of file threadmgr.cpp.

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

Referenced by GetMessageW().

GetPreservedKey()

STDMETHODIMP CThreadMgr::GetPreservedKey ( _In_ ITfContext *  pic, _In_ const TF_PRESERVEDKEY *  pprekey, _Out_ GUID *  pguid  )

override

Definition at line 875 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

GetPreservedKeyDescription()

STDMETHODIMP CThreadMgr::GetPreservedKeyDescription ( _In_ REFGUID  rguid, _Out_ BSTR *  pbstrDesc  )

override

Definition at line 993 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

GetUIElement()

STDMETHODIMP CThreadMgr::GetUIElement ( _In_ DWORD  id, _Out_ ITfUIElement **  element  )

override

Definition at line 1181 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

IsPreservedKey()

STDMETHODIMP CThreadMgr::IsPreservedKey ( _In_ REFGUID  rguid, _In_ const TF_PRESERVEDKEY *  pprekey, _Out_ BOOL *  pfRegistered  )

override

Definition at line 884 of file threadmgr.cpp.

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

IsThreadFocus()

STDMETHODIMP CThreadMgr::IsThreadFocus ( _Out_ BOOL *  pfThreadFocus )

override

Definition at line 596 of file threadmgr.cpp.

{
    TRACE("(%p) %p\n", this, pfThreadFocus);
 
    if (!pfThreadFocus)
        return E_INVALIDARG;
 
    HWND focus = ::GetFocus();
    *pfThreadFocus = !focus;
    return S_OK;
}

KeyDown()

STDMETHODIMP CThreadMgr::KeyDown ( _In_ WPARAM  wParam, _In_ LPARAM  lParam, _Out_ BOOL *  pfEaten  )

override

Definition at line 851 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    if (!pfEaten)
        return E_INVALIDARG;
    *pfEaten = FALSE;
    return E_NOTIMPL;
}

KeyUp()

STDMETHODIMP CThreadMgr::KeyUp ( _In_ WPARAM  wParam, _In_ LPARAM  lParam, _Out_ BOOL *  pfEaten  )

override

Definition at line 863 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    if (!pfEaten)
        return E_INVALIDARG;
    *pfEaten = FALSE;
    return E_NOTIMPL;
}

OnDocumentMgrDestruction()

void CThreadMgr::OnDocumentMgrDestruction

(

ITfDocumentMgr *

mgr

)

Definition at line 1241 of file threadmgr.cpp.

{
    struct list *cursor;
    LIST_FOR_EACH(cursor, &m_CreatedDocumentMgrs)
    {
        DocumentMgrEntry *mgrentry = LIST_ENTRY(cursor, DocumentMgrEntry, entry);
        if (mgrentry->docmgr == mgr)
        {
            list_remove(cursor);
            cicMemFree(mgrentry);
            return;
        }
    }
    FIXME("ITfDocumentMgr %p not found in this thread\n", mgr);
}

OnInitDocumentMgr()

STDMETHODIMP CThreadMgr::OnInitDocumentMgr ( _In_ ITfDocumentMgr *  pdim )

override

Definition at line 1083 of file threadmgr.cpp.

{
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p\n", this, pdim);
 
    SINK_FOR_EACH(cursor, &m_ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        sink->OnInitDocumentMgr(pdim);
    }
 
    return S_OK;
}

OnPopContext()

STDMETHODIMP CThreadMgr::OnPopContext ( _In_ ITfContext *  pic )

override

Definition at line 1145 of file threadmgr.cpp.

{
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p\n", this, pic);
 
    SINK_FOR_EACH(cursor, &m_ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        sink->OnPopContext(pic);
    }
 
    return S_OK;
}

OnPushContext()

STDMETHODIMP CThreadMgr::OnPushContext ( _In_ ITfContext *  pic )

override

Definition at line 1130 of file threadmgr.cpp.

{
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p\n", this, pic);
 
    SINK_FOR_EACH(cursor, &m_ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        sink->OnPushContext(pic);
    }
 
    return S_OK;
}

OnSetFocus()

STDMETHODIMP CThreadMgr::OnSetFocus ( _In_ ITfDocumentMgr *  pdimFocus, _In_ ITfDocumentMgr *  pdimPrevFocus  )

override

Definition at line 1113 of file threadmgr.cpp.

{
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p %p\n", this, pdimFocus, pdimPrevFocus);
 
    SINK_FOR_EACH(cursor, &m_ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        sink->OnSetFocus(pdimFocus, pdimPrevFocus);
    }
 
    return S_OK;
}

Referenced by Deactivate(), and SetFocus().

OnUninitDocumentMgr()

STDMETHODIMP CThreadMgr::OnUninitDocumentMgr ( _In_ ITfDocumentMgr *  pdim )

override

Definition at line 1098 of file threadmgr.cpp.

{
    ITfThreadMgrEventSink *sink;
    struct list *cursor;
 
    TRACE("(%p) %p\n", this, pdim);
 
    SINK_FOR_EACH(cursor, &m_ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
    {
        sink->OnUninitDocumentMgr(pdim);
    }
 
    return S_OK;
}

PeekMessageA()

STDMETHODIMP CThreadMgr::PeekMessageA ( _Out_ LPMSG  pMsg, _In_ HWND  hwnd, _In_ UINT  wMsgFilterMin, _In_ UINT  wMsgFilterMax, _In_ UINT  wRemoveMsg, _Out_ BOOL *  pfResult  )

override

Definition at line 1013 of file threadmgr.cpp.

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

Referenced by PeekMessageA().

PeekMessageW()

STDMETHODIMP CThreadMgr::PeekMessageW ( _Out_ LPMSG  pMsg, _In_ HWND  hwnd, _In_ UINT  wMsgFilterMin, _In_ UINT  wMsgFilterMax, _In_ UINT  wRemoveMsg, _Out_ BOOL *  pfResult  )

override

Definition at line 1040 of file threadmgr.cpp.

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

Referenced by PeekMessageW().

PreserveKey()

STDMETHODIMP CThreadMgr::PreserveKey ( _In_ TfClientId  tid, _In_ REFGUID  rguid, _In_ const TF_PRESERVEDKEY *  prekey, _In_ const WCHAR *  pchDesc, _In_ ULONG  cchDesc  )

override

Definition at line 910 of file threadmgr.cpp.

{
    struct list *cursor;
 
    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 || cicIsNullPtr(&rguid) || !prekey || (cchDesc && !pchDesc))
        return E_INVALIDARG;
 
    LIST_FOR_EACH(cursor, &m_CurrentPreservedKeys)
    {
        PreservedKey* key = LIST_ENTRY(cursor, PreservedKey, entry);
        if (rguid == key->guid && prekey->uVKey == key->prekey.uVKey && prekey->uModifiers == key->prekey.uModifiers)
            return TF_E_ALREADY_EXISTS;
    }
 
    PreservedKey *newkey = (PreservedKey *)cicMemAlloc(sizeof(PreservedKey));
    if (!newkey)
        return E_OUTOFMEMORY;
 
    newkey->guid  = rguid;
    newkey->prekey = *prekey;
    newkey->tid = tid;
    newkey->description = NULL;
    if (cchDesc)
    {
        newkey->description = (LPWSTR)cicMemAlloc((cchDesc + 1) * sizeof(WCHAR));
        if (!newkey->description)
        {
            cicMemFree(newkey);
            return E_OUTOFMEMORY;
        }
        CopyMemory(newkey->description, pchDesc, cchDesc * sizeof(WCHAR));
        newkey->description[cchDesc] = UNICODE_NULL;
    }
 
    list_add_head(&m_CurrentPreservedKeys, &newkey->entry);
    return S_OK;
}

QueryInterface()

STDMETHODIMP CThreadMgr::QueryInterface ( REFIID  iid, LPVOID *  ppvObject  )

override

Definition at line 352 of file threadmgr.cpp.

{
    *ppvObject = NULL;
 
    IUnknown *pUnk = NULL;
    if (iid == IID_IUnknown || iid == IID_ITfThreadMgr || iid == IID_ITfThreadMgrEx)
        pUnk = static_cast<ITfThreadMgrEx *>(this);
    else if (iid == IID_ITfSource)
        pUnk = static_cast<ITfSource *>(this);
    else if (iid == IID_ITfKeystrokeMgr)
        pUnk = static_cast<ITfKeystrokeMgr *>(this);
    else if (iid == IID_ITfMessagePump)
        pUnk = static_cast<ITfMessagePump *>(this);
    else if (iid == IID_ITfClientId)
        pUnk = static_cast<ITfClientId *>(this);
    else if (iid == IID_ITfCompartmentMgr)
        pUnk = m_CompartmentMgr;
    else if (iid == IID_ITfUIElementMgr)
        pUnk = static_cast<ITfUIElementMgr *>(this);
    else if (iid == IID_ITfSourceSingle)
        pUnk = static_cast<ITfSourceSingle *>(this);
 
    if (pUnk)
    {
        *ppvObject = pUnk;
        pUnk->AddRef();
        return S_OK;
    }
 
    WARN("unsupported interface: %s\n", debugstr_guid(&iid));
    return E_NOINTERFACE;
}

SetFocus()

STDMETHODIMP CThreadMgr::SetFocus ( _In_ ITfDocumentMgr *  pdimFocus )

override

Definition at line 480 of file threadmgr.cpp.

{
    ITfDocumentMgr *check;
 
    TRACE("(%p) %p\n", this, pdimFocus);
 
    if (!pdimFocus)
        check = NULL;
    else if (FAILED(pdimFocus->QueryInterface(IID_ITfDocumentMgr, (LPVOID*)&check)))
        return E_INVALIDARG;
 
    OnSetFocus(check, m_focus);
 
    if (m_focus)
        m_focus->Release();
 
    m_focus = check;
    return S_OK;
}

Referenced by _ThreadFocusHookProc(), and AssociateFocus().

SetPreservedKeyDescription()

STDMETHODIMP CThreadMgr::SetPreservedKeyDescription ( _In_ REFGUID  rguid, _In_ const WCHAR *  pchDesc, _In_ ULONG  cchDesc  )

override

Definition at line 984 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

SetupWindowsHook()

HRESULT CThreadMgr::SetupWindowsHook ( )

protected

Definition at line 539 of file threadmgr.cpp.

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

Referenced by AssociateFocus().

SimulatePreservedKey()

STDMETHODIMP CThreadMgr::SimulatePreservedKey ( _In_ ITfContext *  pic, _In_ REFGUID  rguid, _Out_ BOOL *  pfEaten  )

override

Definition at line 1001 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    if (!pfEaten)
        return E_INVALIDARG;
    *pfEaten = FALSE;
    return E_NOTIMPL;
}

STDMETHODIMP_() [1/2]

CThreadMgr::STDMETHODIMP_ ( ULONG  )

override

STDMETHODIMP_() [2/2]

CThreadMgr::STDMETHODIMP_ ( ULONG  )

override

TestKeyDown()

STDMETHODIMP CThreadMgr::TestKeyDown ( _In_ WPARAM  wParam, _In_ LPARAM  lParam, _Out_ BOOL *  pfEaten  )

override

Definition at line 827 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    if (!pfEaten)
        return E_INVALIDARG;
    *pfEaten = FALSE;
    return S_OK;
}

TestKeyUp()

STDMETHODIMP CThreadMgr::TestKeyUp ( _In_ WPARAM  wParam, _In_ LPARAM  lParam, _Out_ BOOL *  pfEaten  )

override

Definition at line 839 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    if (!pfEaten)
        return E_INVALIDARG;
    *pfEaten = FALSE;
    return S_OK;
}

ThreadFocusHookProc()

LRESULT CALLBACK CThreadMgr::ThreadFocusHookProc ( INT  nCode, WPARAM  wParam, LPARAM  lParam  )

staticprotected

Definition at line 528 of file threadmgr.cpp.

{
    CThreadMgr *This = (CThreadMgr *)TlsGetValue(g_dwTLSIndex);
    if (!This)
    {
        ERR("Hook proc but no ThreadMgr for this thread. Serious Error\n");
        return 0;
    }
    return This->_ThreadFocusHookProc(nCode, wParam, lParam);
}

Referenced by SetupWindowsHook().

UnadviseKeyEventSink()

STDMETHODIMP CThreadMgr::UnadviseKeyEventSink ( _In_ TfClientId  tid )

override

Definition at line 784 of file threadmgr.cpp.

{
    CLSID textservice;
    ITfKeyEventSink *check = NULL;
    TRACE("(%p) %x\n", this, tid);
 
    if (!tid)
        return E_INVALIDARG;
 
    textservice = get_textservice_clsid(tid);
    if (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);
    check->Release();
 
    if (m_foregroundKeyEventSink == check)
    {
        m_foregroundKeyEventSink->Release();
        m_foregroundKeyEventSink = NULL;
        m_foregroundTextService = GUID_NULL;
    }
    return S_OK;
}

UnadviseSingleSink()

STDMETHODIMP CThreadMgr::UnadviseSingleSink ( _In_ TfClientId  tid, _In_ REFIID  riid  )

override

Definition at line 1204 of file threadmgr.cpp.

{
    FIXME("STUB:(%p) %i %s\n", this, tid, debugstr_guid(&riid));
    return E_NOTIMPL;
}

UnadviseSink()

STDMETHODIMP CThreadMgr::UnadviseSink ( _In_ DWORD  dwCookie )

override

Definition at line 724 of file threadmgr.cpp.

{
    DWORD magic;
 
    TRACE("(%p) %x\n", this, dwCookie);
 
    magic = get_Cookie_magic(dwCookie);
    if (magic != COOKIE_MAGIC_TMSINK &&
        magic != COOKIE_MAGIC_THREADFOCUSSINK &&
        magic != COOKIE_MAGIC_KEYTRACESINK &&
        magic != COOKIE_MAGIC_UIELEMENTSINK &&
        magic != COOKIE_MAGIC_INPUTPROCESSORPROFILEACTIVATIONSINK)
    {
        return E_INVALIDARG;
    }
 
    return unadvise_sink(dwCookie);
}

UnpreserveKey()

STDMETHODIMP CThreadMgr::UnpreserveKey ( _In_ REFGUID  rguid, _In_ const TF_PRESERVEDKEY *  pprekey  )

override

Definition at line 955 of file threadmgr.cpp.

{
    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 || cicIsNullPtr(&rguid))
        return E_INVALIDARG;
 
    LIST_FOR_EACH(cursor, &m_CurrentPreservedKeys)
    {
        key = LIST_ENTRY(cursor, PreservedKey, entry);
        if (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);
    cicMemFree(key->description);
    cicMemFree(key);
 
    return S_OK;
}

UpdateUIElement()

STDMETHODIMP CThreadMgr::UpdateUIElement ( _In_ DWORD  id )

override

Definition at line 1169 of file threadmgr.cpp.

{
    FIXME("STUB:(%p)\n", this);
    return E_NOTIMPL;
}

Member Data Documentation

m_activationCount

LONG CThreadMgr::m_activationCount

protected

Definition at line 217 of file threadmgr.cpp.

Referenced by ActivateEx(), and Deactivate().

m_ActiveLanguageProfileNotifySink

struct list CThreadMgr::m_ActiveLanguageProfileNotifySink

protected

Definition at line 229 of file threadmgr.cpp.

Referenced by AdviseSink(), CThreadMgr(), and ~CThreadMgr().

m_AssociatedFocusWindows

struct list CThreadMgr::m_AssociatedFocusWindows

protected

Definition at line 225 of file threadmgr.cpp.

Referenced by _ThreadFocusHookProc(), AssociateFocus(), CThreadMgr(), and ~CThreadMgr().

m_CompartmentMgr

ITfCompartmentMgr* CThreadMgr::m_CompartmentMgr

protected

Definition at line 214 of file threadmgr.cpp.

Referenced by QueryInterface(), and ~CThreadMgr().

m_CreatedDocumentMgrs

struct list CThreadMgr::m_CreatedDocumentMgrs

protected

Definition at line 223 of file threadmgr.cpp.

Referenced by CreateDocumentMgr(), CThreadMgr(), EnumDocumentMgrs(), OnDocumentMgrDestruction(), and ~CThreadMgr().

m_cRefs

LONG CThreadMgr::m_cRefs

protected

Definition at line 211 of file threadmgr.cpp.

Referenced by STDMETHODIMP_().

m_CurrentPreservedKeys

struct list CThreadMgr::m_CurrentPreservedKeys

protected

Definition at line 222 of file threadmgr.cpp.

Referenced by CThreadMgr(), IsPreservedKey(), PreserveKey(), UnpreserveKey(), and ~CThreadMgr().

m_DisplayAttributeNotifySink

struct list CThreadMgr::m_DisplayAttributeNotifySink

protected

Definition at line 230 of file threadmgr.cpp.

Referenced by CThreadMgr(), and ~CThreadMgr().

m_focus

ITfDocumentMgr* CThreadMgr::m_focus

protected

Definition at line 216 of file threadmgr.cpp.

Referenced by _ThreadFocusHookProc(), Deactivate(), GetFocus(), SetFocus(), and ~CThreadMgr().

m_focusHook

HHOOK CThreadMgr::m_focusHook

protected

Definition at line 226 of file threadmgr.cpp.

Referenced by _ThreadFocusHookProc(), CThreadMgr(), SetupWindowsHook(), and ~CThreadMgr().

m_foregroundKeyEventSink

ITfKeyEventSink* CThreadMgr::m_foregroundKeyEventSink

protected

Definition at line 219 of file threadmgr.cpp.

Referenced by AdviseKeyEventSink(), and UnadviseKeyEventSink().

m_foregroundTextService

CLSID CThreadMgr::m_foregroundTextService

protected

Definition at line 220 of file threadmgr.cpp.

Referenced by AdviseKeyEventSink(), CThreadMgr(), GetForeground(), and UnadviseKeyEventSink().

m_InputProcessorProfileActivationSink

struct list CThreadMgr::m_InputProcessorProfileActivationSink

protected

Definition at line 236 of file threadmgr.cpp.

Referenced by AdviseSink(), CThreadMgr(), and ~CThreadMgr().

m_KeyTraceEventSink

struct list CThreadMgr::m_KeyTraceEventSink

protected

Definition at line 231 of file threadmgr.cpp.

Referenced by AdviseSink(), CThreadMgr(), and ~CThreadMgr().

m_PreservedKeyNotifySink

struct list CThreadMgr::m_PreservedKeyNotifySink

protected

Definition at line 232 of file threadmgr.cpp.

Referenced by CThreadMgr(), and ~CThreadMgr().

m_ThreadFocusSink

struct list CThreadMgr::m_ThreadFocusSink

protected

Definition at line 233 of file threadmgr.cpp.

Referenced by AdviseSink(), CThreadMgr(), and ~CThreadMgr().

m_ThreadMgrEventSink

struct list CThreadMgr::m_ThreadMgrEventSink

protected

Definition at line 234 of file threadmgr.cpp.

Referenced by AdviseSink(), CThreadMgr(), OnInitDocumentMgr(), OnPopContext(), OnPushContext(), OnSetFocus(), OnUninitDocumentMgr(), and ~CThreadMgr().

m_UIElementSink

struct list CThreadMgr::m_UIElementSink

protected

Definition at line 235 of file threadmgr.cpp.

Referenced by AdviseSink(), CThreadMgr(), and ~CThreadMgr().

---

The documentation for this class was generated from the following file:

• base/ctf/msctf/threadmgr.cpp