ReactOS 0.4.16-dev-1541-g7e1d9ef
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
 
ITfCompartmentMgrm_CompartmentMgr
 
ITfDocumentMgrm_focus
 
LONG m_activationCount
 
ITfKeyEventSinkm_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 IUnknownLPUNKNOWN
 

Detailed Description

Definition at line 40 of file threadmgr.cpp.

Constructor & Destructor Documentation

◆ CThreadMgr()

CThreadMgr::CThreadMgr ( )

Definition at line 277 of file threadmgr.cpp.

278 : m_cRefs(1)
280 , m_focus(NULL)
283{
285
288
291
292 /* kept as separate lists to reduce unnecessary iterations */
301}
static void list_init(struct list_entry *head)
Definition: list.h:51
LONG m_cRefs
Definition: threadmgr.cpp:211
LONG m_activationCount
Definition: threadmgr.cpp:217
struct list m_PreservedKeyNotifySink
Definition: threadmgr.cpp:232
struct list m_UIElementSink
Definition: threadmgr.cpp:235
struct list m_AssociatedFocusWindows
Definition: threadmgr.cpp:225
struct list m_DisplayAttributeNotifySink
Definition: threadmgr.cpp:230
ITfKeyEventSink * m_foregroundKeyEventSink
Definition: threadmgr.cpp:219
ITfCompartmentMgr * m_CompartmentMgr
Definition: threadmgr.cpp:214
struct list m_ThreadMgrEventSink
Definition: threadmgr.cpp:234
struct list m_KeyTraceEventSink
Definition: threadmgr.cpp:231
struct list m_CurrentPreservedKeys
Definition: threadmgr.cpp:222
struct list m_ActiveLanguageProfileNotifySink
Definition: threadmgr.cpp:229
struct list m_InputProcessorProfileActivationSink
Definition: threadmgr.cpp:236
struct list m_ThreadFocusSink
Definition: threadmgr.cpp:233
ITfDocumentMgr * m_focus
Definition: threadmgr.cpp:216
struct list m_CreatedDocumentMgrs
Definition: threadmgr.cpp:223
HHOOK m_focusHook
Definition: threadmgr.cpp:226
CLSID m_foregroundTextService
Definition: threadmgr.cpp:220
#define NULL
Definition: types.h:112
#define GUID_NULL
Definition: ks.h:106

Referenced by CreateInstance().

◆ ~CThreadMgr()

CThreadMgr::~CThreadMgr ( )
virtual

Definition at line 303 of file threadmgr.cpp.

304{
305 struct list *cursor, *cursor2;
306
307 /* unhook right away */
308 if (m_focusHook)
310
312 TRACE("destroying %p\n", this);
313
314 if (m_focus)
315 m_focus->Release();
316
325
327 {
330 cicMemFree(key->description);
332 }
333
335 {
338 FIXME("Left Over ITfDocumentMgr. Should we do something with it?\n");
339 cicMemFree(mgr);
340 }
341
343 {
346 cicMemFree(wnd);
347 }
348
350}
DWORD g_dwTLSIndex
Definition: utils.cpp:33
static void list_remove(struct list_entry *entry)
Definition: list.h:90
#define FIXME(fmt,...)
Definition: precomp.h:53
static void cicMemFree(LPVOID ptr)
Definition: cicbase.h:20
Definition: list.h:37
BOOL WINAPI TlsSetValue(IN DWORD Index, IN LPVOID Value)
Definition: thread.c:1276
const char cursor[]
Definition: icontest.c:13
ULONG Release()
uint32_t entry
Definition: isohybrid.c:63
EXTERN_C void free_sinks(struct list *sink_list)
Definition: msctf.cpp:297
#define LIST_FOR_EACH_SAFE(cursor, cursor2, list)
Definition: list.h:192
#define TRACE(s)
Definition: solgame.cpp:4
Definition: copy.c:22
#define LIST_ENTRY(type)
Definition: queue.h:175
BOOL WINAPI UnhookWindowsHookEx(_In_ HHOOK)

Member Function Documentation

◆ _ThreadFocusHookProc()

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

Definition at line 500 of file threadmgr.cpp.

501{
502 if (!m_focusHook)
503 {
504 ERR("Hook proc but no ThreadMgr focus Hook. Serious Error\n");
505 return 0;
506 }
507
508 if (nCode == HCBT_SETFOCUS) /* focus change within our thread */
509 {
510 struct list *cursor;
511
513 {
515 if (wnd->hwnd == (HWND)wParam)
516 {
517 TRACE("Triggering Associated window focus\n");
518 if (m_focus != wnd->docmgr)
519 SetFocus(wnd->docmgr);
520 break;
521 }
522 }
523 }
524
525 return CallNextHookEx(m_focusHook, nCode, wParam, lParam);
526}
#define ERR(fmt,...)
Definition: precomp.h:57
STDMETHODIMP SetFocus(_In_ ITfDocumentMgr *pdimFocus) override
Definition: threadmgr.cpp:480
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
#define LIST_FOR_EACH(cursor, list)
Definition: list.h:188
ITfDocumentMgr * docmgr
Definition: threadmgr.cpp:35
#define HCBT_SETFOCUS
Definition: winuser.h:64
LRESULT WINAPI CallNextHookEx(_In_opt_ HHOOK, _In_ int, _In_ WPARAM, _In_ LPARAM)

◆ Activate()

STDMETHODIMP CThreadMgr::Activate ( _Out_ TfClientId ptid)
override

Definition at line 398 of file threadmgr.cpp.

399{
400 TRACE("(%p) %p\n", this, ptid);
401 return ActivateEx(ptid, 0);
402}
STDMETHODIMP ActivateEx(_Out_ TfClientId *id, _In_ DWORD flags) override
Definition: threadmgr.cpp:642

◆ ActivateEx()

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

Definition at line 642 of file threadmgr.cpp.

645{
646 TRACE("(%p) %p, %#x\n", this, id, flags);
647
648 if (!id)
649 return E_INVALIDARG;
650
651 if (flags)
652 FIXME("Unimplemented flags %#x\n", flags);
653
654 if (!g_processId)
655 {
656 GUID guid;
659 }
660
663 *id = g_processId;
664 return S_OK;
665}
STDMETHODIMP GetClientId(_In_ REFCLSID rclsid, _Out_ TfClientId *ptid) override
Definition: threadmgr.cpp:1067
#define E_INVALIDARG
Definition: ddrawi.h:101
GUID guid
Definition: version.c:147
HRESULT WINAPI CoCreateGuid(GUID *pguid)
Definition: compobj.c:2206
GLbitfield flags
Definition: glext.h:7161
#define S_OK
Definition: intsafe.h:52
TfClientId g_processId
Definition: msctf.cpp:44
EXTERN_C HRESULT activate_textservices(ITfThreadMgrEx *tm)
Definition: msctf.cpp:449

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.

747{
748 CLSID textservice;
750
751 TRACE("(%p) %x %p %i\n", this, tid, pSink, fForeground);
752
753 if (!tid || !pSink)
754 return E_INVALIDARG;
755
756 textservice = get_textservice_clsid(tid);
757 if (GUID_NULL == textservice)
758 return E_INVALIDARG;
759
760 get_textservice_sink(tid, IID_ITfKeyEventSink, (IUnknown **)&check);
761 if (check)
763
764 if (FAILED(pSink->QueryInterface(IID_ITfKeyEventSink, (LPVOID*)&check)))
765 return E_INVALIDARG;
766
767 set_textservice_sink(tid, IID_ITfKeyEventSink, check);
768
769 if (fForeground)
770 {
772 {
775 }
776 check->AddRef();
777 check->OnSetFocus(TRUE);
779 m_foregroundTextService = textservice;
780 }
781 return S_OK;
782}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define check(expected, result)
Definition: dplayx.c:32
static TfClientId tid
HRESULT OnSetFocus([in] BOOL fForeground)
#define FAILED(hr)
Definition: intsafe.h:51
EXTERN_C HRESULT set_textservice_sink(TfClientId tid, REFCLSID iid, IUnknown *sink)
Definition: msctf.cpp:517
EXTERN_C CLSID get_textservice_clsid(TfClientId tid)
Definition: msctf.cpp:484
EXTERN_C HRESULT get_textservice_sink(TfClientId tid, REFCLSID iid, IUnknown **sink)
Definition: msctf.cpp:497
#define CONNECT_E_ADVISELIMIT
Definition: olectl.h:252

◆ AdviseSingleSink()

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

Definition at line 1195 of file threadmgr.cpp.

1199{
1200 FIXME("STUB:(%p) %i %s %p\n", this, tid, debugstr_guid(&riid), punk);
1201 return E_NOTIMPL;
1202}
#define E_NOTIMPL
Definition: ddrawi.h:99
REFIID riid
Definition: atlbase.h:39
#define debugstr_guid
Definition: kernel32.h:35

◆ AdviseSink()

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

Definition at line 673 of file threadmgr.cpp.

677{
678 TRACE("(%p) %s %p %p\n", this, debugstr_guid(&riid), punk, pdwCookie);
679
680 if (cicIsNullPtr(&riid) || !punk || !pdwCookie)
681 return E_INVALIDARG;
682
683 if (riid == IID_ITfThreadMgrEventSink)
684 return advise_sink(&m_ThreadMgrEventSink, IID_ITfThreadMgrEventSink, COOKIE_MAGIC_TMSINK, punk, pdwCookie);
685
686 if (riid == IID_ITfThreadFocusSink)
687 {
688 WARN("semi-stub for ITfThreadFocusSink: sink won't be used.\n");
689 return advise_sink(&m_ThreadFocusSink, IID_ITfThreadFocusSink, COOKIE_MAGIC_THREADFOCUSSINK, punk, pdwCookie);
690 }
691
692 if (riid == IID_ITfActiveLanguageProfileNotifySink)
693 {
694 WARN("semi-stub for ITfActiveLanguageProfileNotifySink: sink won't be used.\n");
695 return advise_sink(&m_ActiveLanguageProfileNotifySink, IID_ITfActiveLanguageProfileNotifySink,
696 COOKIE_MAGIC_ACTIVELANGSINK, punk, pdwCookie);
697 }
698
699 if (riid == IID_ITfKeyTraceEventSink)
700 {
701 WARN("semi-stub for ITfKeyTraceEventSink: sink won't be used.\n");
702 return advise_sink(&m_KeyTraceEventSink, IID_ITfKeyTraceEventSink,
703 COOKIE_MAGIC_KEYTRACESINK, punk, pdwCookie);
704 }
705
706 if (riid == IID_ITfUIElementSink)
707 {
708 WARN("semi-stub for ITfUIElementSink: sink won't be used.\n");
709 return advise_sink(&m_UIElementSink, IID_ITfUIElementSink,
710 COOKIE_MAGIC_UIELEMENTSINK, punk, pdwCookie);
711 }
712
713 if (riid == IID_ITfInputProcessorProfileActivationSink)
714 {
715 WARN("semi-stub for ITfInputProcessorProfileActivationSink: sink won't be used.\n");
716 return advise_sink(&m_InputProcessorProfileActivationSink, IID_ITfInputProcessorProfileActivationSink,
718 }
719
720 FIXME("(%p) Unhandled Sink: %s\n", this, debugstr_guid(&riid));
721 return E_NOTIMPL;
722}
#define COOKIE_MAGIC_INPUTPROCESSORPROFILEACTIVATIONSINK
Definition: precomp.h:43
#define COOKIE_MAGIC_KEYTRACESINK
Definition: precomp.h:41
#define COOKIE_MAGIC_UIELEMENTSINK
Definition: precomp.h:42
#define COOKIE_MAGIC_THREADFOCUSSINK
Definition: precomp.h:40
#define COOKIE_MAGIC_TMSINK
Definition: precomp.h:33
#define COOKIE_MAGIC_ACTIVELANGSINK
Definition: precomp.h:44
#define WARN(fmt,...)
Definition: precomp.h:61
static bool cicIsNullPtr(LPCVOID ptr)
Definition: cicbase.h:40
EXTERN_C HRESULT advise_sink(struct list *sink_list, REFIID riid, DWORD cookie_magic, IUnknown *unk, DWORD *cookie)
Definition: msctf.cpp:259

◆ AssociateFocus()

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

Definition at line 554 of file threadmgr.cpp.

558{
559 struct list *cursor, *cursor2;
560 AssociatedWindow *wnd;
561
562 TRACE("(%p) %p %p %p\n", this, hwnd, pdimNew, ppdimPrev);
563
564 if (!ppdimPrev)
565 return E_INVALIDARG;
566
567 *ppdimPrev = NULL;
568
570 {
572 if (wnd->hwnd == hwnd)
573 {
574 if (wnd->docmgr)
575 wnd->docmgr->AddRef();
576 *ppdimPrev = wnd->docmgr;
577 wnd->docmgr = pdimNew;
578 if (::GetFocus() == hwnd)
579 SetFocus(pdimNew);
580 return S_OK;
581 }
582 }
583
585 wnd->hwnd = hwnd;
586 wnd->docmgr = pdimNew;
588
589 if (::GetFocus() == hwnd)
590 SetFocus(pdimNew);
591
592 this->SetupWindowsHook();
593 return S_OK;
594}
static void list_add_head(struct list_entry *head, struct list_entry *entry)
Definition: list.h:76
static LPVOID cicMemAlloc(SIZE_T size)
Definition: cicbase.h:10
HRESULT SetupWindowsHook()
Definition: threadmgr.cpp:539
ULONG AddRef()
struct list entry
Definition: threadmgr.cpp:33
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
HWND WINAPI GetFocus(void)
Definition: window.c:1863

◆ BeginUIElement()

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

Definition at line 1160 of file threadmgr.cpp.

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

◆ CreateDocumentMgr()

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

Definition at line 427 of file threadmgr.cpp.

428{
429 TRACE("(%p)\n", this);
430
431 if (!ppdim)
432 return E_INVALIDARG;
433
435 if (!mgrentry)
436 return E_OUTOFMEMORY;
437
438 HRESULT hr = DocumentMgr_Constructor(this, ppdim);
439 if (SUCCEEDED(hr))
440 {
441 mgrentry->docmgr = *ppdim;
443 }
444 else
445 {
446 cicMemFree(mgrentry);
447 }
448
449 return hr;
450}
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
EXTERN_C HRESULT DocumentMgr_Constructor(ITfThreadMgrEventSink *pThreadMgrSink, ITfDocumentMgr **ppOut)
#define SUCCEEDED(hr)
Definition: intsafe.h:50
HRESULT hr
Definition: shlfolder.c:183
ITfDocumentMgr * docmgr
Definition: threadmgr.cpp:28
struct list entry
Definition: threadmgr.cpp:27

◆ CreateInstance()

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

Definition at line 1212 of file threadmgr.cpp.

1213{
1214 if (pUnkOuter)
1215 return CLASS_E_NOAGGREGATION;
1216
1217 /* Only 1 ThreadMgr is created per thread */
1219 if (This)
1220 {
1221 This->AddRef();
1222 *ppOut = This;
1223 return S_OK;
1224 }
1225
1226 This = new(cicNoThrow) CThreadMgr();
1227 if (!This)
1228 return E_OUTOFMEMORY;
1229
1231
1234 This->m_CompartmentMgr = pCompMgr;
1235
1236 TRACE("returning %p\n", This);
1237 *ppOut = This;
1238 return S_OK;
1239}
const GUID IID_IUnknown
#define cicNoThrow
Definition: cicbase.h:46
EXTERN_C HRESULT CompartmentMgr_Constructor(IUnknown *pUnkOuter, REFIID riid, IUnknown **ppOut)
LPVOID WINAPI TlsGetValue(IN DWORD Index)
Definition: thread.c:1240
static nsIComponentManager * pCompMgr
Definition: nsembed.c:62
#define CLASS_E_NOAGGREGATION
Definition: winerror.h:3772

Referenced by ThreadMgr_Constructor().

◆ Deactivate()

STDMETHODIMP CThreadMgr::Deactivate ( )
override

Implements ITfThreadMgr.

Definition at line 404 of file threadmgr.cpp.

405{
406 TRACE("(%p)\n", this);
407
408 if (m_activationCount == 0)
409 return E_UNEXPECTED;
410
412
413 if (m_activationCount == 0)
414 {
415 if (m_focus)
416 {
418 m_focus->Release();
419 m_focus = NULL;
420 }
421 }
422
424 return S_OK;
425}
STDMETHODIMP OnSetFocus(_In_ ITfDocumentMgr *pdimFocus, _In_ ITfDocumentMgr *pdimPrevFocus) override
Definition: threadmgr.cpp:1113
EXTERN_C HRESULT deactivate_textservices(void)
Definition: msctf.cpp:468
#define E_UNEXPECTED
Definition: winerror.h:3529

◆ EndUIElement()

STDMETHODIMP CThreadMgr::EndUIElement ( _In_ DWORD  id)
override

Definition at line 1175 of file threadmgr.cpp.

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

◆ EnumDocumentMgrs()

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

Definition at line 452 of file threadmgr.cpp.

453{
454 TRACE("(%p) %p\n", this, ppEnum);
455
456 if (!ppEnum)
457 return E_INVALIDARG;
458
460}
static HRESULT CreateInstance(struct list *head, CEnumTfDocumentMgr **ppOut)
Definition: threadmgr.cpp:1371

◆ EnumFunctionProviders()

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

Definition at line 616 of file threadmgr.cpp.

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

◆ EnumUIElements()

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

Definition at line 1189 of file threadmgr.cpp.

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

◆ GetActiveFlags()

STDMETHODIMP CThreadMgr::GetActiveFlags ( _Out_ DWORD flags)
override

Definition at line 667 of file threadmgr.cpp.

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

◆ GetClientId()

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

Definition at line 1067 of file threadmgr.cpp.

1070{
1071 HRESULT hr;
1072 ITfCategoryMgr *catmgr;
1073
1074 TRACE("(%p) %s\n", this, debugstr_guid(&rclsid));
1075
1077 hr = catmgr->RegisterGUID(rclsid, ptid);
1078 catmgr->Release();
1079
1080 return hr;
1081}
EXTERN_C HRESULT CategoryMgr_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
HRESULT RegisterGUID([in] REFGUID rguid, [out] TfGuidAtom *pguidatom)

Referenced by ActivateEx().

◆ GetFocus()

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

Definition at line 462 of file threadmgr.cpp.

463{
464 TRACE("(%p)\n", this);
465
466 if (!ppdimFocus)
467 return E_INVALIDARG;
468
469 *ppdimFocus = m_focus;
470
471 TRACE("->%p\n", m_focus);
472
473 if (!m_focus)
474 return S_FALSE;
475
476 m_focus->AddRef();
477 return S_OK;
478}
#define S_FALSE
Definition: winerror.h:3452

◆ GetForeground()

STDMETHODIMP CThreadMgr::GetForeground ( _Out_ CLSID pclsid)
override

Definition at line 814 of file threadmgr.cpp.

815{
816 TRACE("(%p) %p\n", this, pclsid);
817 if (!pclsid)
818 return E_INVALIDARG;
819
821 return S_FALSE;
822
823 *pclsid = m_foregroundTextService;
824 return S_OK;
825}

◆ GetFunctionProvider()

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

Definition at line 608 of file threadmgr.cpp.

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

◆ GetGlobalCompartment()

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

Definition at line 622 of file threadmgr.cpp.

623{
624 HRESULT hr;
625 TRACE("(%p) %p\n", this, ppCompMgr);
626
627 if (!ppCompMgr)
628 return E_INVALIDARG;
629
631 {
632 hr = CompartmentMgr_Constructor(NULL, IID_ITfCompartmentMgr, (IUnknown **)&g_globalCompartmentMgr);
633 if (FAILED(hr))
634 return hr;
635 }
636
638 *ppCompMgr = g_globalCompartmentMgr;
639 return S_OK;
640}
ITfCompartmentMgr * g_globalCompartmentMgr
Definition: msctf.cpp:45

◆ 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.

1033{
1034 if (!pfResult)
1035 return E_INVALIDARG;
1036 *pfResult = ::GetMessageA(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax);
1037 return S_OK;
1038}
STDMETHODIMP GetMessageA(_Out_ LPMSG pMsg, _In_ HWND hwnd, _In_ UINT wMsgFilterMin, _In_ UINT wMsgFilterMax, _Out_ BOOL *pfResult) override
Definition: threadmgr.cpp:1027

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.

1060{
1061 if (!pfResult)
1062 return E_INVALIDARG;
1063 *pfResult = ::GetMessageW(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax);
1064 return S_OK;
1065}
STDMETHODIMP GetMessageW(_Out_ LPMSG pMsg, _In_ HWND hwnd, _In_ UINT wMsgFilterMin, _In_ UINT wMsgFilterMax, _Out_ BOOL *pfResult) override
Definition: threadmgr.cpp:1054

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.

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

◆ GetPreservedKeyDescription()

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

Definition at line 993 of file threadmgr.cpp.

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

◆ GetUIElement()

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

Definition at line 1181 of file threadmgr.cpp.

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

◆ IsPreservedKey()

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

Definition at line 884 of file threadmgr.cpp.

888{
889 struct list *cursor;
890
891 TRACE("(%p) %s (%x %x) %p\n", this, debugstr_guid(&rguid), (pprekey ? pprekey->uVKey : 0), (pprekey ? pprekey->uModifiers : 0), pfRegistered);
892
893 if (cicIsNullPtr(&rguid) || !pprekey || !pfRegistered)
894 return E_INVALIDARG;
895
897 {
899 if (rguid == key->guid && pprekey->uVKey == key->prekey.uVKey && pprekey->uModifiers == key->prekey.uModifiers)
900 {
901 *pfRegistered = TRUE;
902 return S_OK;
903 }
904 }
905
906 *pfRegistered = FALSE;
907 return S_FALSE;
908}

◆ IsThreadFocus()

STDMETHODIMP CThreadMgr::IsThreadFocus ( _Out_ BOOL pfThreadFocus)
override

Definition at line 596 of file threadmgr.cpp.

597{
598 TRACE("(%p) %p\n", this, pfThreadFocus);
599
600 if (!pfThreadFocus)
601 return E_INVALIDARG;
602
603 HWND focus = ::GetFocus();
604 *pfThreadFocus = !focus;
605 return S_OK;
606}

◆ KeyDown()

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

Definition at line 851 of file threadmgr.cpp.

855{
856 FIXME("STUB:(%p)\n", this);
857 if (!pfEaten)
858 return E_INVALIDARG;
859 *pfEaten = FALSE;
860 return E_NOTIMPL;
861}

◆ KeyUp()

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

Definition at line 863 of file threadmgr.cpp.

867{
868 FIXME("STUB:(%p)\n", this);
869 if (!pfEaten)
870 return E_INVALIDARG;
871 *pfEaten = FALSE;
872 return E_NOTIMPL;
873}

◆ OnDocumentMgrDestruction()

void CThreadMgr::OnDocumentMgrDestruction ( ITfDocumentMgr mgr)

Definition at line 1241 of file threadmgr.cpp.

1242{
1243 struct list *cursor;
1245 {
1247 if (mgrentry->docmgr == mgr)
1248 {
1250 cicMemFree(mgrentry);
1251 return;
1252 }
1253 }
1254 FIXME("ITfDocumentMgr %p not found in this thread\n", mgr);
1255}

◆ OnInitDocumentMgr()

STDMETHODIMP CThreadMgr::OnInitDocumentMgr ( _In_ ITfDocumentMgr pdim)
override

Definition at line 1083 of file threadmgr.cpp.

1084{
1086 struct list *cursor;
1087
1088 TRACE("(%p) %p\n", this, pdim);
1089
1091 {
1092 sink->OnInitDocumentMgr(pdim);
1093 }
1094
1095 return S_OK;
1096}
#define SINK_FOR_EACH(cursor, list, type, elem)
Definition: precomp.h:96
GLsizei GLenum GLboolean sink
Definition: glext.h:5672

◆ OnPopContext()

STDMETHODIMP CThreadMgr::OnPopContext ( _In_ ITfContext pic)
override

Definition at line 1145 of file threadmgr.cpp.

1146{
1148 struct list *cursor;
1149
1150 TRACE("(%p) %p\n", this, pic);
1151
1153 {
1154 sink->OnPopContext(pic);
1155 }
1156
1157 return S_OK;
1158}

◆ OnPushContext()

STDMETHODIMP CThreadMgr::OnPushContext ( _In_ ITfContext pic)
override

Definition at line 1130 of file threadmgr.cpp.

1131{
1133 struct list *cursor;
1134
1135 TRACE("(%p) %p\n", this, pic);
1136
1138 {
1139 sink->OnPushContext(pic);
1140 }
1141
1142 return S_OK;
1143}

◆ OnSetFocus()

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

Definition at line 1113 of file threadmgr.cpp.

1116{
1118 struct list *cursor;
1119
1120 TRACE("(%p) %p %p\n", this, pdimFocus, pdimPrevFocus);
1121
1123 {
1124 sink->OnSetFocus(pdimFocus, pdimPrevFocus);
1125 }
1126
1127 return S_OK;
1128}

Referenced by Deactivate(), and SetFocus().

◆ OnUninitDocumentMgr()

STDMETHODIMP CThreadMgr::OnUninitDocumentMgr ( _In_ ITfDocumentMgr pdim)
override

Definition at line 1098 of file threadmgr.cpp.

1099{
1101 struct list *cursor;
1102
1103 TRACE("(%p) %p\n", this, pdim);
1104
1106 {
1107 sink->OnUninitDocumentMgr(pdim);
1108 }
1109
1110 return S_OK;
1111}

◆ 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.

1020{
1021 if (!pfResult)
1022 return E_INVALIDARG;
1023 *pfResult = ::PeekMessageA(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
1024 return S_OK;
1025}
STDMETHODIMP PeekMessageA(_Out_ LPMSG pMsg, _In_ HWND hwnd, _In_ UINT wMsgFilterMin, _In_ UINT wMsgFilterMax, _In_ UINT wRemoveMsg, _Out_ BOOL *pfResult) override
Definition: threadmgr.cpp:1013

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.

1047{
1048 if (!pfResult)
1049 return E_INVALIDARG;
1050 *pfResult = ::PeekMessageW(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
1051 return S_OK;
1052}
STDMETHODIMP PeekMessageW(_Out_ LPMSG pMsg, _In_ HWND hwnd, _In_ UINT wMsgFilterMin, _In_ UINT wMsgFilterMax, _In_ UINT wRemoveMsg, _Out_ BOOL *pfResult) override
Definition: threadmgr.cpp:1040

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.

916{
917 struct list *cursor;
918
919 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));
920
921 if (!tid || cicIsNullPtr(&rguid) || !prekey || (cchDesc && !pchDesc))
922 return E_INVALIDARG;
923
925 {
927 if (rguid == key->guid && prekey->uVKey == key->prekey.uVKey && prekey->uModifiers == key->prekey.uModifiers)
928 return TF_E_ALREADY_EXISTS;
929 }
930
932 if (!newkey)
933 return E_OUTOFMEMORY;
934
935 newkey->guid = rguid;
936 newkey->prekey = *prekey;
937 newkey->tid = tid;
938 newkey->description = NULL;
939 if (cchDesc)
940 {
941 newkey->description = (LPWSTR)cicMemAlloc((cchDesc + 1) * sizeof(WCHAR));
942 if (!newkey->description)
943 {
944 cicMemFree(newkey);
945 return E_OUTOFMEMORY;
946 }
947 CopyMemory(newkey->description, pchDesc, cchDesc * sizeof(WCHAR));
948 newkey->description[cchDesc] = UNICODE_NULL;
949 }
950
952 return S_OK;
953}
#define debugstr_wn
Definition: kernel32.h:33
#define UNICODE_NULL
struct list entry
Definition: threadmgr.cpp:18
TF_PRESERVEDKEY prekey
Definition: threadmgr.cpp:20
LPWSTR description
Definition: threadmgr.cpp:21
TfClientId tid
Definition: threadmgr.cpp:22
#define CopyMemory
Definition: winbase.h:1751
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ QueryInterface()

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

Definition at line 352 of file threadmgr.cpp.

353{
354 *ppvObject = NULL;
355
356 IUnknown *pUnk = NULL;
357 if (iid == IID_IUnknown || iid == IID_ITfThreadMgr || iid == IID_ITfThreadMgrEx)
358 pUnk = static_cast<ITfThreadMgrEx *>(this);
359 else if (iid == IID_ITfSource)
360 pUnk = static_cast<ITfSource *>(this);
361 else if (iid == IID_ITfKeystrokeMgr)
362 pUnk = static_cast<ITfKeystrokeMgr *>(this);
363 else if (iid == IID_ITfMessagePump)
364 pUnk = static_cast<ITfMessagePump *>(this);
365 else if (iid == IID_ITfClientId)
366 pUnk = static_cast<ITfClientId *>(this);
367 else if (iid == IID_ITfCompartmentMgr)
369 else if (iid == IID_ITfUIElementMgr)
370 pUnk = static_cast<ITfUIElementMgr *>(this);
371 else if (iid == IID_ITfSourceSingle)
372 pUnk = static_cast<ITfSourceSingle *>(this);
373
374 if (pUnk)
375 {
376 *ppvObject = pUnk;
377 pUnk->AddRef();
378 return S_OK;
379 }
380
381 WARN("unsupported interface: %s\n", debugstr_guid(&iid));
382 return E_NOINTERFACE;
383}
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
nsrefcnt AddRef()
#define E_NOINTERFACE
Definition: winerror.h:3480

◆ SetFocus()

STDMETHODIMP CThreadMgr::SetFocus ( _In_ ITfDocumentMgr pdimFocus)
override

Definition at line 480 of file threadmgr.cpp.

481{
483
484 TRACE("(%p) %p\n", this, pdimFocus);
485
486 if (!pdimFocus)
487 check = NULL;
488 else if (FAILED(pdimFocus->QueryInterface(IID_ITfDocumentMgr, (LPVOID*)&check)))
489 return E_INVALIDARG;
490
492
493 if (m_focus)
494 m_focus->Release();
495
496 m_focus = check;
497 return S_OK;
498}

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.

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

◆ SetupWindowsHook()

HRESULT CThreadMgr::SetupWindowsHook ( )
protected

Definition at line 539 of file threadmgr.cpp.

540{
541 if (!m_focusHook)
542 {
544 if (!m_focusHook)
545 {
546 ERR("Unable to set focus hook\n");
547 return E_FAIL;
548 }
549 return S_OK;
550 }
551 return S_FALSE;
552}
static LRESULT CALLBACK ThreadFocusHookProc(INT nCode, WPARAM wParam, LPARAM lParam)
Definition: threadmgr.cpp:528
#define E_FAIL
Definition: ddrawi.h:102
DWORD WINAPI GetCurrentThreadId(void)
Definition: thread.c:459
HHOOK WINAPI SetWindowsHookExW(_In_ int, _In_ HOOKPROC, _In_opt_ HINSTANCE, _In_ DWORD)
#define WH_CBT
Definition: winuser.h:35

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.

1005{
1006 FIXME("STUB:(%p)\n", this);
1007 if (!pfEaten)
1008 return E_INVALIDARG;
1009 *pfEaten = FALSE;
1010 return E_NOTIMPL;
1011}

◆ 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.

831{
832 FIXME("STUB:(%p)\n", this);
833 if (!pfEaten)
834 return E_INVALIDARG;
835 *pfEaten = FALSE;
836 return S_OK;
837}

◆ TestKeyUp()

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

Definition at line 839 of file threadmgr.cpp.

843{
844 FIXME("STUB:(%p)\n", this);
845 if (!pfEaten)
846 return E_INVALIDARG;
847 *pfEaten = FALSE;
848 return S_OK;
849}

◆ ThreadFocusHookProc()

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

Definition at line 528 of file threadmgr.cpp.

529{
531 if (!This)
532 {
533 ERR("Hook proc but no ThreadMgr for this thread. Serious Error\n");
534 return 0;
535 }
536 return This->_ThreadFocusHookProc(nCode, wParam, lParam);
537}

Referenced by SetupWindowsHook().

◆ UnadviseKeyEventSink()

STDMETHODIMP CThreadMgr::UnadviseKeyEventSink ( _In_ TfClientId  tid)
override

Definition at line 784 of file threadmgr.cpp.

785{
786 CLSID textservice;
788 TRACE("(%p) %x\n", this, tid);
789
790 if (!tid)
791 return E_INVALIDARG;
792
793 textservice = get_textservice_clsid(tid);
794 if (GUID_NULL == textservice)
795 return E_INVALIDARG;
796
797 get_textservice_sink(tid, IID_ITfKeyEventSink, (IUnknown **)&check);
798
799 if (!check)
801
802 set_textservice_sink(tid, IID_ITfKeyEventSink, NULL);
803 check->Release();
804
806 {
810 }
811 return S_OK;
812}
#define CONNECT_E_NOCONNECTION
Definition: olectl.h:251

◆ UnadviseSingleSink()

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

Definition at line 1204 of file threadmgr.cpp.

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

◆ UnadviseSink()

STDMETHODIMP CThreadMgr::UnadviseSink ( _In_ DWORD  dwCookie)
override

Definition at line 724 of file threadmgr.cpp.

725{
726 DWORD magic;
727
728 TRACE("(%p) %x\n", this, dwCookie);
729
730 magic = get_Cookie_magic(dwCookie);
731 if (magic != COOKIE_MAGIC_TMSINK &&
733 magic != COOKIE_MAGIC_KEYTRACESINK &&
736 {
737 return E_INVALIDARG;
738 }
739
740 return unadvise_sink(dwCookie);
741}
unsigned long DWORD
Definition: ntddk_ex.h:95
EXTERN_C DWORD get_Cookie_magic(DWORD id)
Definition: msctf.cpp:203
EXTERN_C HRESULT unadvise_sink(DWORD cookie)
Definition: msctf.cpp:286

◆ UnpreserveKey()

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

Definition at line 955 of file threadmgr.cpp.

958{
960 struct list *cursor;
961 TRACE("(%p) %s (%x %x)\n", this, debugstr_guid(&rguid), (pprekey ? pprekey->uVKey : 0), (pprekey ? pprekey->uModifiers : 0));
962
963 if (!pprekey || cicIsNullPtr(&rguid))
964 return E_INVALIDARG;
965
967 {
969 if (rguid == key->guid && pprekey->uVKey == key->prekey.uVKey && pprekey->uModifiers == key->prekey.uModifiers)
970 break;
971 key = NULL;
972 }
973
974 if (!key)
976
977 list_remove(&key->entry);
978 cicMemFree(key->description);
980
981 return S_OK;
982}

◆ UpdateUIElement()

STDMETHODIMP CThreadMgr::UpdateUIElement ( _In_ DWORD  id)
override

Definition at line 1169 of file threadmgr.cpp.

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

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

◆ 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

◆ 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: