dll/win32/msctf/threadmgr.c

   1 /*
   2  *  ITfThreadMgr implementation
   3  *
   4  *  Copyright 2008 Aric Stewart, CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24
  25 #define COBJMACROS
  26
  27 #include "wine/debug.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winreg.h"
  31 #include "winuser.h"
  32 #include "shlwapi.h"
  33 #include "winerror.h"
  34 #include "objbase.h"
  35 #include "olectl.h"
  36
  37 #include "wine/unicode.h"
  38
  39 #include "msctf.h"
  40 #include "msctf_internal.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msctf);
  43
  44 typedef struct tagPreservedKey
  45 {
  46     struct list     entry;
  47     GUID            guid;
  48     TF_PRESERVEDKEY prekey;
  49     LPWSTR          description;
  50     TfClientId      tid;
  51 } PreservedKey;
  52
  53 typedef struct tagDocumentMgrs
  54 {
  55     struct list     entry;
  56     ITfDocumentMgr  *docmgr;
  57 } DocumentMgrEntry;
  58
  59 typedef struct tagAssociatedWindow
  60 {
  61     struct list     entry;
  62     HWND            hwnd;
  63     ITfDocumentMgr  *docmgr;
  64 } AssociatedWindow;
  65
  66 typedef struct tagACLMulti {
  67     ITfThreadMgrEx ITfThreadMgrEx_iface;
  68     ITfSource ITfSource_iface;
  69     ITfKeystrokeMgr ITfKeystrokeMgr_iface;
  70     ITfMessagePump ITfMessagePump_iface;
  71     ITfClientId ITfClientId_iface;
  72     /* const ITfThreadMgrExVtbl *ThreadMgrExVtbl; */
  73     /* const ITfConfigureSystemKeystrokeFeedVtbl *ConfigureSystemKeystrokeFeedVtbl; */
  74     /* const ITfLangBarItemMgrVtbl *LangBarItemMgrVtbl; */
  75     ITfUIElementMgr ITfUIElementMgr_iface;
  76     ITfSourceSingle ITfSourceSingle_iface;
  77     LONG refCount;
  78
  79     /* Aggregation */
  80     ITfCompartmentMgr  *CompartmentMgr;
  81
  82     ITfThreadMgrEventSink ITfThreadMgrEventSink_iface; /* internal */
  83
  84     ITfDocumentMgr *focus;
  85     LONG activationCount;
  86
  87     ITfKeyEventSink *foregroundKeyEventSink;
  88     CLSID foregroundTextService;
  89
  90     struct list CurrentPreservedKeys;
  91     struct list CreatedDocumentMgrs;
  92
  93     struct list AssociatedFocusWindows;
  94     HHOOK  focusHook;
  95
  96     /* kept as separate lists to reduce unnecessary iterations */
  97     struct list     ActiveLanguageProfileNotifySink;
  98     struct list     DisplayAttributeNotifySink;
  99     struct list     KeyTraceEventSink;
 100     struct list     PreservedKeyNotifySink;
 101     struct list     ThreadFocusSink;
 102     struct list     ThreadMgrEventSink;
 103 } ThreadMgr;
 104
 105 typedef struct tagEnumTfDocumentMgr {
 106     IEnumTfDocumentMgrs IEnumTfDocumentMgrs_iface;
 107     LONG refCount;
 108
 109     struct list *index;
 110     struct list *head;
 111 } EnumTfDocumentMgr;
 112
 113 static HRESULT EnumTfDocumentMgr_Constructor(struct list* head, IEnumTfDocumentMgrs **ppOut);
 114
 115 static inline ThreadMgr *impl_from_ITfThreadMgrEx(ITfThreadMgrEx *iface)
 116 {
 117     return CONTAINING_RECORD(iface, ThreadMgr, ITfThreadMgrEx_iface);
 118 }
 119
 120 static inline ThreadMgr *impl_from_ITfSource(ITfSource *iface)
 121 {
 122     return CONTAINING_RECORD(iface, ThreadMgr, ITfSource_iface);
 123 }
 124
 125 static inline ThreadMgr *impl_from_ITfKeystrokeMgr(ITfKeystrokeMgr *iface)
 126 {
 127     return CONTAINING_RECORD(iface, ThreadMgr, ITfKeystrokeMgr_iface);
 128 }
 129
 130 static inline ThreadMgr *impl_from_ITfMessagePump(ITfMessagePump *iface)
 131 {
 132     return CONTAINING_RECORD(iface, ThreadMgr, ITfMessagePump_iface);
 133 }
 134
 135 static inline ThreadMgr *impl_from_ITfClientId(ITfClientId *iface)
 136 {
 137     return CONTAINING_RECORD(iface, ThreadMgr, ITfClientId_iface);
 138 }
 139
 140 static inline ThreadMgr *impl_from_ITfThreadMgrEventSink(ITfThreadMgrEventSink *iface)
 141 {
 142     return CONTAINING_RECORD(iface, ThreadMgr, ITfThreadMgrEventSink_iface);
 143 }
 144
 145 static inline ThreadMgr *impl_from_ITfUIElementMgr(ITfUIElementMgr *iface)
 146 {
 147     return CONTAINING_RECORD(iface, ThreadMgr, ITfUIElementMgr_iface);
 148 }
 149
 150 static inline ThreadMgr *impl_from_ITfSourceSingle(ITfSourceSingle *iface)
 151 {
 152     return CONTAINING_RECORD(iface, ThreadMgr, ITfSourceSingle_iface);
 153 }
 154
 155 static inline EnumTfDocumentMgr *impl_from_IEnumTfDocumentMgrs(IEnumTfDocumentMgrs *iface)
 156 {
 157     return CONTAINING_RECORD(iface, EnumTfDocumentMgr, IEnumTfDocumentMgrs_iface);
 158 }
 159
 160 static void ThreadMgr_Destructor(ThreadMgr *This)
 161 {
 162     struct list *cursor, *cursor2;
 163
 164     /* unhook right away */
 165     if (This->focusHook)
 166         UnhookWindowsHookEx(This->focusHook);
 167
 168     TlsSetValue(tlsIndex,NULL);
 169     TRACE("destroying %p\n", This);
 170     if (This->focus)
 171         ITfDocumentMgr_Release(This->focus);
 172
 173     free_sinks(&This->ActiveLanguageProfileNotifySink);
 174     free_sinks(&This->DisplayAttributeNotifySink);
 175     free_sinks(&This->KeyTraceEventSink);
 176     free_sinks(&This->PreservedKeyNotifySink);
 177     free_sinks(&This->ThreadFocusSink);
 178     free_sinks(&This->ThreadMgrEventSink);
 179
 180     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->CurrentPreservedKeys)
 181     {
 182         PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
 183         list_remove(cursor);
 184         HeapFree(GetProcessHeap(),0,key->description);
 185         HeapFree(GetProcessHeap(),0,key);
 186     }
 187
 188     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->CreatedDocumentMgrs)
 189     {
 190         DocumentMgrEntry *mgr = LIST_ENTRY(cursor,DocumentMgrEntry,entry);
 191         list_remove(cursor);
 192         FIXME("Left Over ITfDocumentMgr.  Should we do something with it?\n");
 193         HeapFree(GetProcessHeap(),0,mgr);
 194     }
 195
 196     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->AssociatedFocusWindows)
 197     {
 198         AssociatedWindow *wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
 199         list_remove(cursor);
 200         HeapFree(GetProcessHeap(),0,wnd);
 201     }
 202
 203     CompartmentMgr_Destructor(This->CompartmentMgr);
 204
 205     HeapFree(GetProcessHeap(),0,This);
 206 }
 207
 208 static HRESULT WINAPI ThreadMgr_QueryInterface(ITfThreadMgrEx *iface, REFIID iid, LPVOID *ppvOut)
 209 {
 210     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 211     *ppvOut = NULL;
 212
 213     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfThreadMgr)
 214         || IsEqualIID(iid, &IID_ITfThreadMgrEx))
 215     {
 216         *ppvOut = &This->ITfThreadMgrEx_iface;
 217     }
 218     else if (IsEqualIID(iid, &IID_ITfSource))
 219     {
 220         *ppvOut = &This->ITfSource_iface;
 221     }
 222     else if (IsEqualIID(iid, &IID_ITfKeystrokeMgr))
 223     {
 224         *ppvOut = &This->ITfKeystrokeMgr_iface;
 225     }
 226     else if (IsEqualIID(iid, &IID_ITfMessagePump))
 227     {
 228         *ppvOut = &This->ITfMessagePump_iface;
 229     }
 230     else if (IsEqualIID(iid, &IID_ITfClientId))
 231     {
 232         *ppvOut = &This->ITfClientId_iface;
 233     }
 234     else if (IsEqualIID(iid, &IID_ITfCompartmentMgr))
 235     {
 236         *ppvOut = This->CompartmentMgr;
 237     }
 238     else if (IsEqualIID(iid, &IID_ITfUIElementMgr))
 239     {
 240         *ppvOut = &This->ITfUIElementMgr_iface;
 241     }
 242     else if (IsEqualIID(iid, &IID_ITfSourceSingle))
 243     {
 244         *ppvOut = &This->ITfSourceSingle_iface;
 245     }
 246
 247     if (*ppvOut)
 248     {
 249         ITfThreadMgrEx_AddRef(iface);
 250         return S_OK;
 251     }
 252
 253     WARN("unsupported interface: %s\n", debugstr_guid(iid));
 254     return E_NOINTERFACE;
 255 }
 256
 257 static ULONG WINAPI ThreadMgr_AddRef(ITfThreadMgrEx *iface)
 258 {
 259     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 260     return InterlockedIncrement(&This->refCount);
 261 }
 262
 263 static ULONG WINAPI ThreadMgr_Release(ITfThreadMgrEx *iface)
 264 {
 265     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 266     ULONG ret;
 267
 268     ret = InterlockedDecrement(&This->refCount);
 269     if (ret == 0)
 270         ThreadMgr_Destructor(This);
 271     return ret;
 272 }
 273
 274 /*****************************************************
 275  * ITfThreadMgr functions
 276  *****************************************************/
 277
 278 static HRESULT WINAPI ThreadMgr_Activate(ITfThreadMgrEx *iface, TfClientId *id)
 279 {
 280     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 281
 282     TRACE("(%p) %p\n", This, id);
 283     return ITfThreadMgrEx_ActivateEx(iface, id, 0);
 284 }
 285
 286 static HRESULT WINAPI ThreadMgr_Deactivate(ITfThreadMgrEx *iface)
 287 {
 288     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 289     TRACE("(%p)\n",This);
 290
 291     if (This->activationCount == 0)
 292         return E_UNEXPECTED;
 293
 294     This->activationCount --;
 295
 296     if (This->activationCount == 0)
 297     {
 298         if (This->focus)
 299         {
 300             ITfThreadMgrEventSink_OnSetFocus(&This->ITfThreadMgrEventSink_iface, 0, This->focus);
 301             ITfDocumentMgr_Release(This->focus);
 302             This->focus = 0;
 303         }
 304     }
 305
 306     deactivate_textservices();
 307
 308     return S_OK;
 309 }
 310
 311 static HRESULT WINAPI ThreadMgr_CreateDocumentMgr(ITfThreadMgrEx *iface, ITfDocumentMgr **ppdim)
 312 {
 313     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 314     DocumentMgrEntry *mgrentry;
 315     HRESULT hr;
 316
 317     TRACE("(%p)\n",iface);
 318     mgrentry = HeapAlloc(GetProcessHeap(),0,sizeof(DocumentMgrEntry));
 319     if (mgrentry == NULL)
 320         return E_OUTOFMEMORY;
 321
 322     hr = DocumentMgr_Constructor(&This->ITfThreadMgrEventSink_iface, ppdim);
 323
 324     if (SUCCEEDED(hr))
 325     {
 326         mgrentry->docmgr = *ppdim;
 327         list_add_head(&This->CreatedDocumentMgrs,&mgrentry->entry);
 328     }
 329     else
 330         HeapFree(GetProcessHeap(),0,mgrentry);
 331
 332     return hr;
 333 }
 334
 335 static HRESULT WINAPI ThreadMgr_EnumDocumentMgrs(ITfThreadMgrEx *iface, IEnumTfDocumentMgrs **ppEnum)
 336 {
 337     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 338     TRACE("(%p) %p\n",This,ppEnum);
 339
 340     if (!ppEnum)
 341         return E_INVALIDARG;
 342
 343     return EnumTfDocumentMgr_Constructor(&This->CreatedDocumentMgrs, ppEnum);
 344 }
 345
 346 static HRESULT WINAPI ThreadMgr_GetFocus(ITfThreadMgrEx *iface, ITfDocumentMgr **ppdimFocus)
 347 {
 348     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 349     TRACE("(%p)\n",This);
 350
 351     if (!ppdimFocus)
 352         return E_INVALIDARG;
 353
 354     *ppdimFocus = This->focus;
 355
 356     TRACE("->%p\n",This->focus);
 357
 358     if (This->focus == NULL)
 359         return S_FALSE;
 360
 361     ITfDocumentMgr_AddRef(This->focus);
 362
 363     return S_OK;
 364 }
 365
 366 static HRESULT WINAPI ThreadMgr_SetFocus(ITfThreadMgrEx *iface, ITfDocumentMgr *pdimFocus)
 367 {
 368     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 369     ITfDocumentMgr *check;
 370
 371     TRACE("(%p) %p\n",This,pdimFocus);
 372
 373     if (!pdimFocus)
 374         check = NULL;
 375     else if (FAILED(ITfDocumentMgr_QueryInterface(pdimFocus,&IID_ITfDocumentMgr,(LPVOID*) &check)))
 376         return E_INVALIDARG;
 377
 378     ITfThreadMgrEventSink_OnSetFocus(&This->ITfThreadMgrEventSink_iface, check, This->focus);
 379
 380     if (This->focus)
 381         ITfDocumentMgr_Release(This->focus);
 382
 383     This->focus = check;
 384     return S_OK;
 385 }
 386
 387 static LRESULT CALLBACK ThreadFocusHookProc(int nCode, WPARAM wParam, LPARAM lParam)
 388 {
 389     ThreadMgr *This;
 390
 391     This = TlsGetValue(tlsIndex);
 392     if (!This)
 393     {
 394         ERR("Hook proc but no ThreadMgr for this thread. Serious Error\n");
 395         return 0;
 396     }
 397     if (!This->focusHook)
 398     {
 399         ERR("Hook proc but no ThreadMgr focus Hook. Serious Error\n");
 400         return 0;
 401     }
 402
 403     if (nCode == HCBT_SETFOCUS) /* focus change within our thread */
 404     {
 405         struct list *cursor;
 406
 407         LIST_FOR_EACH(cursor, &This->AssociatedFocusWindows)
 408         {
 409             AssociatedWindow *wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
 410             if (wnd->hwnd == (HWND)wParam)
 411             {
 412                 TRACE("Triggering Associated window focus\n");
 413                 if (This->focus != wnd->docmgr)
 414                     ThreadMgr_SetFocus(&This->ITfThreadMgrEx_iface, wnd->docmgr);
 415                 break;
 416             }
 417         }
 418     }
 419
 420     return CallNextHookEx(This->focusHook, nCode, wParam, lParam);
 421 }
 422
 423 static HRESULT SetupWindowsHook(ThreadMgr *This)
 424 {
 425     if (!This->focusHook)
 426     {
 427         This->focusHook = SetWindowsHookExW(WH_CBT, ThreadFocusHookProc, 0,
 428                              GetCurrentThreadId());
 429         if (!This->focusHook)
 430         {
 431             ERR("Unable to set focus hook\n");
 432             return E_FAIL;
 433         }
 434         return S_OK;
 435     }
 436     return S_FALSE;
 437 }
 438
 439 static HRESULT WINAPI ThreadMgr_AssociateFocus(ITfThreadMgrEx *iface, HWND hwnd,
 440 ITfDocumentMgr *pdimNew, ITfDocumentMgr **ppdimPrev)
 441 {
 442     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 443     struct list *cursor, *cursor2;
 444     AssociatedWindow *wnd;
 445
 446     TRACE("(%p) %p %p %p\n",This,hwnd,pdimNew,ppdimPrev);
 447
 448     if (!ppdimPrev)
 449         return E_INVALIDARG;
 450
 451     *ppdimPrev = NULL;
 452
 453     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->AssociatedFocusWindows)
 454     {
 455         wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
 456         if (wnd->hwnd == hwnd)
 457         {
 458             if (wnd->docmgr)
 459                 ITfDocumentMgr_AddRef(wnd->docmgr);
 460             *ppdimPrev = wnd->docmgr;
 461             wnd->docmgr = pdimNew;
 462             if (GetFocus() == hwnd)
 463                 ThreadMgr_SetFocus(iface,pdimNew);
 464             return S_OK;
 465         }
 466     }
 467
 468     wnd = HeapAlloc(GetProcessHeap(),0,sizeof(AssociatedWindow));
 469     wnd->hwnd = hwnd;
 470     wnd->docmgr = pdimNew;
 471     list_add_head(&This->AssociatedFocusWindows,&wnd->entry);
 472
 473     if (GetFocus() == hwnd)
 474         ThreadMgr_SetFocus(iface,pdimNew);
 475
 476     SetupWindowsHook(This);
 477
 478     return S_OK;
 479 }
 480
 481 static HRESULT WINAPI ThreadMgr_IsThreadFocus(ITfThreadMgrEx *iface, BOOL *pfThreadFocus)
 482 {
 483     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 484     HWND focus;
 485
 486     TRACE("(%p) %p\n",This,pfThreadFocus);
 487     focus = GetFocus();
 488     *pfThreadFocus = (focus == NULL);
 489     return S_OK;
 490 }
 491
 492 static HRESULT WINAPI ThreadMgr_GetFunctionProvider(ITfThreadMgrEx *iface, REFCLSID clsid,
 493 ITfFunctionProvider **ppFuncProv)
 494 {
 495     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 496     FIXME("STUB:(%p)\n",This);
 497     return E_NOTIMPL;
 498 }
 499
 500 static HRESULT WINAPI ThreadMgr_EnumFunctionProviders(ITfThreadMgrEx *iface,
 501 IEnumTfFunctionProviders **ppEnum)
 502 {
 503     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 504     FIXME("STUB:(%p)\n",This);
 505     return E_NOTIMPL;
 506 }
 507
 508 static HRESULT WINAPI ThreadMgr_GetGlobalCompartment(ITfThreadMgrEx *iface,
 509 ITfCompartmentMgr **ppCompMgr)
 510 {
 511     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 512     HRESULT hr;
 513     TRACE("(%p) %p\n",This, ppCompMgr);
 514
 515     if (!ppCompMgr)
 516         return E_INVALIDARG;
 517
 518     if (!globalCompartmentMgr)
 519     {
 520         hr = CompartmentMgr_Constructor(NULL,&IID_ITfCompartmentMgr,(IUnknown**)&globalCompartmentMgr);
 521         if (FAILED(hr))
 522             return hr;
 523     }
 524
 525     ITfCompartmentMgr_AddRef(globalCompartmentMgr);
 526     *ppCompMgr = globalCompartmentMgr;
 527     return S_OK;
 528 }
 529
 530 static HRESULT WINAPI ThreadMgr_ActivateEx(ITfThreadMgrEx *iface, TfClientId *id, DWORD flags)
 531 {
 532     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 533
 534     TRACE("(%p) %p, %#x\n", This, id, flags);
 535
 536     if (!id)
 537         return E_INVALIDARG;
 538
 539     if (flags)
 540         FIXME("Unimplemented flags %#x\n", flags);
 541
 542     if (!processId)
 543     {
 544         GUID guid;
 545         CoCreateGuid(&guid);
 546         ITfClientId_GetClientId(&This->ITfClientId_iface, &guid, &processId);
 547     }
 548
 549     activate_textservices(iface);
 550     This->activationCount++;
 551     *id = processId;
 552     return S_OK;
 553 }
 554
 555 static HRESULT WINAPI ThreadMgr_GetActiveFlags(ITfThreadMgrEx *iface, DWORD *flags)
 556 {
 557     ThreadMgr *This = impl_from_ITfThreadMgrEx(iface);
 558
 559     FIXME("STUB:(%p)\n", This);
 560     return E_NOTIMPL;
 561 }
 562
 563 static const ITfThreadMgrExVtbl ThreadMgrExVtbl =
 564 {
 565     ThreadMgr_QueryInterface,
 566     ThreadMgr_AddRef,
 567     ThreadMgr_Release,
 568     ThreadMgr_Activate,
 569     ThreadMgr_Deactivate,
 570     ThreadMgr_CreateDocumentMgr,
 571     ThreadMgr_EnumDocumentMgrs,
 572     ThreadMgr_GetFocus,
 573     ThreadMgr_SetFocus,
 574     ThreadMgr_AssociateFocus,
 575     ThreadMgr_IsThreadFocus,
 576     ThreadMgr_GetFunctionProvider,
 577     ThreadMgr_EnumFunctionProviders,
 578     ThreadMgr_GetGlobalCompartment,
 579
 580     ThreadMgr_ActivateEx,
 581     ThreadMgr_GetActiveFlags
 582 };
 583
 584 static HRESULT WINAPI Source_QueryInterface(ITfSource *iface, REFIID iid, LPVOID *ppvOut)
 585 {
 586     ThreadMgr *This = impl_from_ITfSource(iface);
 587     return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
 588 }
 589
 590 static ULONG WINAPI Source_AddRef(ITfSource *iface)
 591 {
 592     ThreadMgr *This = impl_from_ITfSource(iface);
 593     return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
 594 }
 595
 596 static ULONG WINAPI Source_Release(ITfSource *iface)
 597 {
 598     ThreadMgr *This = impl_from_ITfSource(iface);
 599     return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
 600 }
 601
 602 /*****************************************************
 603  * ITfSource functions
 604  *****************************************************/
 605 static HRESULT WINAPI ThreadMgrSource_AdviseSink(ITfSource *iface,
 606         REFIID riid, IUnknown *punk, DWORD *pdwCookie)
 607 {
 608     ThreadMgr *This = impl_from_ITfSource(iface);
 609
 610     TRACE("(%p) %s %p %p\n",This,debugstr_guid(riid),punk,pdwCookie);
 611
 612     if (!riid || !punk || !pdwCookie)
 613         return E_INVALIDARG;
 614
 615     if (IsEqualIID(riid, &IID_ITfThreadMgrEventSink))
 616         return advise_sink(&This->ThreadMgrEventSink, &IID_ITfThreadMgrEventSink, COOKIE_MAGIC_TMSINK, punk, pdwCookie);
 617
 618     if (IsEqualIID(riid, &IID_ITfThreadFocusSink))
 619     {
 620         WARN("semi-stub for ITfThreadFocusSink: sink won't be used.\n");
 621         return advise_sink(&This->ThreadFocusSink, &IID_ITfThreadFocusSink, COOKIE_MAGIC_THREADFOCUSSINK, punk, pdwCookie);
 622     }
 623
 624     FIXME("(%p) Unhandled Sink: %s\n",This,debugstr_guid(riid));
 625     return E_NOTIMPL;
 626 }
 627
 628 static HRESULT WINAPI ThreadMgrSource_UnadviseSink(ITfSource *iface, DWORD pdwCookie)
 629 {
 630     ThreadMgr *This = impl_from_ITfSource(iface);
 631
 632     TRACE("(%p) %x\n",This,pdwCookie);
 633
 634     if (get_Cookie_magic(pdwCookie) != COOKIE_MAGIC_TMSINK && get_Cookie_magic(pdwCookie) != COOKIE_MAGIC_THREADFOCUSSINK)
 635         return E_INVALIDARG;
 636
 637     return unadvise_sink(pdwCookie);
 638 }
 639
 640 static const ITfSourceVtbl ThreadMgrSourceVtbl =
 641 {
 642     Source_QueryInterface,
 643     Source_AddRef,
 644     Source_Release,
 645     ThreadMgrSource_AdviseSink,
 646     ThreadMgrSource_UnadviseSink,
 647 };
 648
 649 /*****************************************************
 650  * ITfKeystrokeMgr functions
 651  *****************************************************/
 652
 653 static HRESULT WINAPI KeystrokeMgr_QueryInterface(ITfKeystrokeMgr *iface, REFIID iid, LPVOID *ppvOut)
 654 {
 655     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 656     return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
 657 }
 658
 659 static ULONG WINAPI KeystrokeMgr_AddRef(ITfKeystrokeMgr *iface)
 660 {
 661     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 662     return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
 663 }
 664
 665 static ULONG WINAPI KeystrokeMgr_Release(ITfKeystrokeMgr *iface)
 666 {
 667     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 668     return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
 669 }
 670
 671 static HRESULT WINAPI KeystrokeMgr_AdviseKeyEventSink(ITfKeystrokeMgr *iface,
 672         TfClientId tid, ITfKeyEventSink *pSink, BOOL fForeground)
 673 {
 674     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 675     CLSID textservice;
 676     ITfKeyEventSink *check = NULL;
 677
 678     TRACE("(%p) %x %p %i\n",This,tid,pSink,fForeground);
 679
 680     if (!tid || !pSink)
 681         return E_INVALIDARG;
 682
 683     textservice = get_textservice_clsid(tid);
 684     if (IsEqualCLSID(&GUID_NULL,&textservice))
 685         return E_INVALIDARG;
 686
 687     get_textservice_sink(tid, &IID_ITfKeyEventSink, (IUnknown**)&check);
 688     if (check != NULL)
 689         return CONNECT_E_ADVISELIMIT;
 690
 691     if (FAILED(ITfKeyEventSink_QueryInterface(pSink,&IID_ITfKeyEventSink,(LPVOID*) &check)))
 692         return E_INVALIDARG;
 693
 694     set_textservice_sink(tid, &IID_ITfKeyEventSink, (IUnknown*)check);
 695
 696     if (fForeground)
 697     {
 698         if (This->foregroundKeyEventSink)
 699         {
 700             ITfKeyEventSink_OnSetFocus(This->foregroundKeyEventSink, FALSE);
 701             ITfKeyEventSink_Release(This->foregroundKeyEventSink);
 702         }
 703         ITfKeyEventSink_AddRef(check);
 704         ITfKeyEventSink_OnSetFocus(check, TRUE);
 705         This->foregroundKeyEventSink = check;
 706         This->foregroundTextService = textservice;
 707     }
 708     return S_OK;
 709 }
 710
 711 static HRESULT WINAPI KeystrokeMgr_UnadviseKeyEventSink(ITfKeystrokeMgr *iface,
 712         TfClientId tid)
 713 {
 714     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 715     CLSID textservice;
 716     ITfKeyEventSink *check = NULL;
 717     TRACE("(%p) %x\n",This,tid);
 718
 719     if (!tid)
 720         return E_INVALIDARG;
 721
 722     textservice = get_textservice_clsid(tid);
 723     if (IsEqualCLSID(&GUID_NULL,&textservice))
 724         return E_INVALIDARG;
 725
 726     get_textservice_sink(tid, &IID_ITfKeyEventSink, (IUnknown**)&check);
 727
 728     if (!check)
 729         return CONNECT_E_NOCONNECTION;
 730
 731     set_textservice_sink(tid, &IID_ITfKeyEventSink, NULL);
 732     ITfKeyEventSink_Release(check);
 733
 734     if (This->foregroundKeyEventSink == check)
 735     {
 736         ITfKeyEventSink_Release(This->foregroundKeyEventSink);
 737         This->foregroundKeyEventSink = NULL;
 738         This->foregroundTextService = GUID_NULL;
 739     }
 740     return S_OK;
 741 }
 742
 743 static HRESULT WINAPI KeystrokeMgr_GetForeground(ITfKeystrokeMgr *iface,
 744         CLSID *pclsid)
 745 {
 746     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 747     TRACE("(%p) %p\n",This,pclsid);
 748     if (!pclsid)
 749         return E_INVALIDARG;
 750
 751     if (IsEqualCLSID(&This->foregroundTextService,&GUID_NULL))
 752         return S_FALSE;
 753
 754     *pclsid = This->foregroundTextService;
 755     return S_OK;
 756 }
 757
 758 static HRESULT WINAPI KeystrokeMgr_TestKeyDown(ITfKeystrokeMgr *iface,
 759         WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
 760 {
 761     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 762     FIXME("STUB:(%p)\n",This);
 763     *pfEaten = FALSE;
 764     return S_OK;
 765 }
 766
 767 static HRESULT WINAPI KeystrokeMgr_TestKeyUp(ITfKeystrokeMgr *iface,
 768         WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
 769 {
 770     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 771     FIXME("STUB:(%p)\n",This);
 772     *pfEaten = FALSE;
 773     return S_OK;
 774 }
 775
 776 static HRESULT WINAPI KeystrokeMgr_KeyDown(ITfKeystrokeMgr *iface,
 777         WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
 778 {
 779     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 780     FIXME("STUB:(%p)\n",This);
 781     return E_NOTIMPL;
 782 }
 783
 784 static HRESULT WINAPI KeystrokeMgr_KeyUp(ITfKeystrokeMgr *iface,
 785         WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
 786 {
 787     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 788     FIXME("STUB:(%p)\n",This);
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI KeystrokeMgr_GetPreservedKey(ITfKeystrokeMgr *iface,
 793         ITfContext *pic, const TF_PRESERVEDKEY *pprekey, GUID *pguid)
 794 {
 795     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 796     FIXME("STUB:(%p)\n",This);
 797     return E_NOTIMPL;
 798 }
 799
 800 static HRESULT WINAPI KeystrokeMgr_IsPreservedKey(ITfKeystrokeMgr *iface,
 801         REFGUID rguid, const TF_PRESERVEDKEY *pprekey, BOOL *pfRegistered)
 802 {
 803     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 804     struct list *cursor;
 805
 806     TRACE("(%p) %s (%x %x) %p\n",This,debugstr_guid(rguid), (pprekey)?pprekey->uVKey:0, (pprekey)?pprekey->uModifiers:0, pfRegistered);
 807
 808     if (!rguid || !pprekey || !pfRegistered)
 809         return E_INVALIDARG;
 810
 811     LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
 812     {
 813         PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
 814         if (IsEqualGUID(rguid,&key->guid) && pprekey->uVKey == key->prekey.uVKey && pprekey->uModifiers == key->prekey.uModifiers)
 815         {
 816             *pfRegistered = TRUE;
 817             return S_OK;
 818         }
 819     }
 820
 821     *pfRegistered = FALSE;
 822     return S_FALSE;
 823 }
 824
 825 static HRESULT WINAPI KeystrokeMgr_PreserveKey(ITfKeystrokeMgr *iface,
 826         TfClientId tid, REFGUID rguid, const TF_PRESERVEDKEY *prekey,
 827         const WCHAR *pchDesc, ULONG cchDesc)
 828 {
 829     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 830     struct list *cursor;
 831     PreservedKey *newkey;
 832
 833     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));
 834
 835     if (!tid || ! rguid || !prekey || (cchDesc && !pchDesc))
 836         return E_INVALIDARG;
 837
 838     LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
 839     {
 840         PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
 841         if (IsEqualGUID(rguid,&key->guid) && prekey->uVKey == key->prekey.uVKey && prekey->uModifiers == key->prekey.uModifiers)
 842             return TF_E_ALREADY_EXISTS;
 843     }
 844
 845     newkey = HeapAlloc(GetProcessHeap(),0,sizeof(PreservedKey));
 846     if (!newkey)
 847         return E_OUTOFMEMORY;
 848
 849     newkey->guid  = *rguid;
 850     newkey->prekey = *prekey;
 851     newkey->tid = tid;
 852     newkey->description = NULL;
 853     if (cchDesc)
 854     {
 855         newkey->description = HeapAlloc(GetProcessHeap(),0,cchDesc * sizeof(WCHAR));
 856         if (!newkey->description)
 857         {
 858             HeapFree(GetProcessHeap(),0,newkey);
 859             return E_OUTOFMEMORY;
 860         }
 861         memcpy(newkey->description, pchDesc, cchDesc*sizeof(WCHAR));
 862     }
 863
 864     list_add_head(&This->CurrentPreservedKeys,&newkey->entry);
 865
 866     return S_OK;
 867 }
 868
 869 static HRESULT WINAPI KeystrokeMgr_UnpreserveKey(ITfKeystrokeMgr *iface,
 870         REFGUID rguid, const TF_PRESERVEDKEY *pprekey)
 871 {
 872     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 873     PreservedKey* key = NULL;
 874     struct list *cursor;
 875     TRACE("(%p) %s (%x %x)\n",This,debugstr_guid(rguid),(pprekey)?pprekey->uVKey:0, (pprekey)?pprekey->uModifiers:0);
 876
 877     if (!pprekey || !rguid)
 878         return E_INVALIDARG;
 879
 880     LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
 881     {
 882         key = LIST_ENTRY(cursor,PreservedKey,entry);
 883         if (IsEqualGUID(rguid,&key->guid) && pprekey->uVKey == key->prekey.uVKey && pprekey->uModifiers == key->prekey.uModifiers)
 884             break;
 885         key = NULL;
 886     }
 887
 888     if (!key)
 889         return CONNECT_E_NOCONNECTION;
 890
 891     list_remove(&key->entry);
 892     HeapFree(GetProcessHeap(),0,key->description);
 893     HeapFree(GetProcessHeap(),0,key);
 894
 895     return S_OK;
 896 }
 897
 898 static HRESULT WINAPI KeystrokeMgr_SetPreservedKeyDescription(ITfKeystrokeMgr *iface,
 899         REFGUID rguid, const WCHAR *pchDesc, ULONG cchDesc)
 900 {
 901     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 902     FIXME("STUB:(%p)\n",This);
 903     return E_NOTIMPL;
 904 }
 905
 906 static HRESULT WINAPI KeystrokeMgr_GetPreservedKeyDescription(ITfKeystrokeMgr *iface,
 907         REFGUID rguid, BSTR *pbstrDesc)
 908 {
 909     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 910     FIXME("STUB:(%p)\n",This);
 911     return E_NOTIMPL;
 912 }
 913
 914 static HRESULT WINAPI KeystrokeMgr_SimulatePreservedKey(ITfKeystrokeMgr *iface,
 915         ITfContext *pic, REFGUID rguid, BOOL *pfEaten)
 916 {
 917     ThreadMgr *This = impl_from_ITfKeystrokeMgr(iface);
 918     FIXME("STUB:(%p)\n",This);
 919     return E_NOTIMPL;
 920 }
 921
 922 static const ITfKeystrokeMgrVtbl KeystrokeMgrVtbl =
 923 {
 924     KeystrokeMgr_QueryInterface,
 925     KeystrokeMgr_AddRef,
 926     KeystrokeMgr_Release,
 927     KeystrokeMgr_AdviseKeyEventSink,
 928     KeystrokeMgr_UnadviseKeyEventSink,
 929     KeystrokeMgr_GetForeground,
 930     KeystrokeMgr_TestKeyDown,
 931     KeystrokeMgr_TestKeyUp,
 932     KeystrokeMgr_KeyDown,
 933     KeystrokeMgr_KeyUp,
 934     KeystrokeMgr_GetPreservedKey,
 935     KeystrokeMgr_IsPreservedKey,
 936     KeystrokeMgr_PreserveKey,
 937     KeystrokeMgr_UnpreserveKey,
 938     KeystrokeMgr_SetPreservedKeyDescription,
 939     KeystrokeMgr_GetPreservedKeyDescription,
 940     KeystrokeMgr_SimulatePreservedKey
 941 };
 942
 943 /*****************************************************
 944  * ITfMessagePump functions
 945  *****************************************************/
 946
 947 static HRESULT WINAPI MessagePump_QueryInterface(ITfMessagePump *iface, REFIID iid, LPVOID *ppvOut)
 948 {
 949     ThreadMgr *This = impl_from_ITfMessagePump(iface);
 950     return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
 951 }
 952
 953 static ULONG WINAPI MessagePump_AddRef(ITfMessagePump *iface)
 954 {
 955     ThreadMgr *This = impl_from_ITfMessagePump(iface);
 956     return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
 957 }
 958
 959 static ULONG WINAPI MessagePump_Release(ITfMessagePump *iface)
 960 {
 961     ThreadMgr *This = impl_from_ITfMessagePump(iface);
 962     return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
 963 }
 964
 965 static HRESULT WINAPI MessagePump_PeekMessageA(ITfMessagePump *iface,
 966         LPMSG pMsg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax,
 967         UINT wRemoveMsg, BOOL *pfResult)
 968 {
 969     if (!pfResult)
 970         return E_INVALIDARG;
 971     *pfResult = PeekMessageA(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
 972     return S_OK;
 973 }
 974
 975 static HRESULT WINAPI MessagePump_GetMessageA(ITfMessagePump *iface,
 976         LPMSG pMsg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax,
 977         BOOL *pfResult)
 978 {
 979     if (!pfResult)
 980         return E_INVALIDARG;
 981     *pfResult = GetMessageA(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax);
 982     return S_OK;
 983 }
 984
 985 static HRESULT WINAPI MessagePump_PeekMessageW(ITfMessagePump *iface,
 986         LPMSG pMsg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax,
 987         UINT wRemoveMsg, BOOL *pfResult)
 988 {
 989     if (!pfResult)
 990         return E_INVALIDARG;
 991     *pfResult = PeekMessageW(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
 992     return S_OK;
 993 }
 994
 995 static HRESULT WINAPI MessagePump_GetMessageW(ITfMessagePump *iface,
 996         LPMSG pMsg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax,
 997         BOOL *pfResult)
 998 {
 999     if (!pfResult)
1000         return E_INVALIDARG;
1001     *pfResult = GetMessageW(pMsg, hwnd, wMsgFilterMin, wMsgFilterMax);
1002     return S_OK;
1003 }
1004
1005 static const ITfMessagePumpVtbl MessagePumpVtbl =
1006 {
1007     MessagePump_QueryInterface,
1008     MessagePump_AddRef,
1009     MessagePump_Release,
1010     MessagePump_PeekMessageA,
1011     MessagePump_GetMessageA,
1012     MessagePump_PeekMessageW,
1013     MessagePump_GetMessageW
1014 };
1015
1016 /*****************************************************
1017  * ITfClientId functions
1018  *****************************************************/
1019
1020 static HRESULT WINAPI ClientId_QueryInterface(ITfClientId *iface, REFIID iid, LPVOID *ppvOut)
1021 {
1022     ThreadMgr *This = impl_from_ITfClientId(iface);
1023     return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
1024 }
1025
1026 static ULONG WINAPI ClientId_AddRef(ITfClientId *iface)
1027 {
1028     ThreadMgr *This = impl_from_ITfClientId(iface);
1029     return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
1030 }
1031
1032 static ULONG WINAPI ClientId_Release(ITfClientId *iface)
1033 {
1034     ThreadMgr *This = impl_from_ITfClientId(iface);
1035     return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
1036 }
1037
1038 static HRESULT WINAPI ClientId_GetClientId(ITfClientId *iface,
1039     REFCLSID rclsid, TfClientId *ptid)
1040
1041 {
1042     ThreadMgr *This = impl_from_ITfClientId(iface);
1043     HRESULT hr;
1044     ITfCategoryMgr *catmgr;
1045
1046     TRACE("(%p) %s\n",This,debugstr_guid(rclsid));
1047
1048     CategoryMgr_Constructor(NULL,(IUnknown**)&catmgr);
1049     hr = ITfCategoryMgr_RegisterGUID(catmgr,rclsid,ptid);
1050     ITfCategoryMgr_Release(catmgr);
1051
1052     return hr;
1053 }
1054
1055 static const ITfClientIdVtbl ClientIdVtbl =
1056 {
1057     ClientId_QueryInterface,
1058     ClientId_AddRef,
1059     ClientId_Release,
1060     ClientId_GetClientId
1061 };
1062
1063 /*****************************************************
1064  * ITfThreadMgrEventSink functions  (internal)
1065  *****************************************************/
1066 static HRESULT WINAPI ThreadMgrEventSink_QueryInterface(ITfThreadMgrEventSink *iface, REFIID iid, LPVOID *ppvOut)
1067 {
1068     ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
1069     return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
1070 }
1071
1072 static ULONG WINAPI ThreadMgrEventSink_AddRef(ITfThreadMgrEventSink *iface)
1073 {
1074     ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
1075     return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
1076 }
1077
1078 static ULONG WINAPI ThreadMgrEventSink_Release(ITfThreadMgrEventSink *iface)
1079 {
1080     ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
1081     return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
1082 }
1083
1084
1085 static HRESULT WINAPI ThreadMgrEventSink_OnInitDocumentMgr(
1086         ITfThreadMgrEventSink *iface,ITfDocumentMgr *pdim)
1087 {
1088     ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
1089     ITfThreadMgrEventSink *sink;
1090     struct list *cursor;
1091
1092     TRACE("(%p) %p\n",This,pdim);
1093
1094     SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
1095     {
1096         ITfThreadMgrEventSink_OnInitDocumentMgr(sink, pdim);
1097     }
1098
1099     return S_OK;
1100 }
1101
1102 static HRESULT WINAPI ThreadMgrEventSink_OnUninitDocumentMgr(
1103         ITfThreadMgrEventSink *iface, ITfDocumentMgr *pdim)
1104 {
1105     ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
1106     ITfThreadMgrEventSink *sink;
1107     struct list *cursor;
1108
1109     TRACE("(%p) %p\n",This,pdim);
1110
1111     SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
1112     {
1113         ITfThreadMgrEventSink_OnUninitDocumentMgr(sink, pdim);
1114     }
1115
1116     return S_OK;
1117 }
1118
1119 static HRESULT WINAPI ThreadMgrEventSink_OnSetFocus(
1120         ITfThreadMgrEventSink *iface, ITfDocumentMgr *pdimFocus,
1121         ITfDocumentMgr *pdimPrevFocus)
1122 {
1123     ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
1124     ITfThreadMgrEventSink *sink;
1125     struct list *cursor;
1126
1127     TRACE("(%p) %p %p\n",This,pdimFocus, pdimPrevFocus);
1128
1129     SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
1130     {
1131         ITfThreadMgrEventSink_OnSetFocus(sink, pdimFocus, pdimPrevFocus);
1132     }
1133
1134     return S_OK;
1135 }
1136
1137 static HRESULT WINAPI ThreadMgrEventSink_OnPushContext(
1138         ITfThreadMgrEventSink *iface, ITfContext *pic)
1139 {
1140     ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
1141     ITfThreadMgrEventSink *sink;
1142     struct list *cursor;
1143
1144     TRACE("(%p) %p\n",This,pic);
1145
1146     SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
1147     {
1148         ITfThreadMgrEventSink_OnPushContext(sink, pic);
1149     }
1150
1151     return S_OK;
1152 }
1153
1154 static HRESULT WINAPI ThreadMgrEventSink_OnPopContext(
1155         ITfThreadMgrEventSink *iface, ITfContext *pic)
1156 {
1157     ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
1158     ITfThreadMgrEventSink *sink;
1159     struct list *cursor;
1160
1161     TRACE("(%p) %p\n",This,pic);
1162
1163     SINK_FOR_EACH(cursor, &This->ThreadMgrEventSink, ITfThreadMgrEventSink, sink)
1164     {
1165         ITfThreadMgrEventSink_OnPopContext(sink, pic);
1166     }
1167
1168     return S_OK;
1169 }
1170
1171 static const ITfThreadMgrEventSinkVtbl ThreadMgrEventSinkVtbl =
1172 {
1173     ThreadMgrEventSink_QueryInterface,
1174     ThreadMgrEventSink_AddRef,
1175     ThreadMgrEventSink_Release,
1176     ThreadMgrEventSink_OnInitDocumentMgr,
1177     ThreadMgrEventSink_OnUninitDocumentMgr,
1178     ThreadMgrEventSink_OnSetFocus,
1179     ThreadMgrEventSink_OnPushContext,
1180     ThreadMgrEventSink_OnPopContext
1181 };
1182
1183 /*****************************************************
1184  * ITfUIElementMgr functions
1185  *****************************************************/
1186 static HRESULT WINAPI UIElementMgr_QueryInterface(ITfUIElementMgr *iface, REFIID iid, void **ppvOut)
1187 {
1188     ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
1189
1190     return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
1191 }
1192
1193 static ULONG WINAPI UIElementMgr_AddRef(ITfUIElementMgr *iface)
1194 {
1195     ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
1196
1197     return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
1198 }
1199
1200 static ULONG WINAPI UIElementMgr_Release(ITfUIElementMgr *iface)
1201 {
1202     ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
1203
1204     return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
1205 }
1206
1207 static HRESULT WINAPI UIElementMgr_BeginUIElement(ITfUIElementMgr *iface, ITfUIElement *element,
1208                                                   BOOL *show, DWORD *id)
1209 {
1210     ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
1211
1212     FIXME("STUB:(%p)\n", This);
1213     return E_NOTIMPL;
1214 }
1215
1216 static HRESULT WINAPI UIElementMgr_UpdateUIElement(ITfUIElementMgr *iface, DWORD id)
1217 {
1218     ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
1219
1220     FIXME("STUB:(%p)\n", This);
1221     return E_NOTIMPL;
1222 }
1223
1224 static HRESULT WINAPI UIElementMgr_EndUIElement(ITfUIElementMgr *iface, DWORD id)
1225 {
1226     ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
1227
1228     FIXME("STUB:(%p)\n", This);
1229     return E_NOTIMPL;
1230 }
1231
1232 static HRESULT WINAPI UIElementMgr_GetUIElement(ITfUIElementMgr *iface, DWORD id,
1233                                                 ITfUIElement **element)
1234 {
1235     ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
1236
1237     FIXME("STUB:(%p)\n", This);
1238     return E_NOTIMPL;
1239 }
1240
1241 static HRESULT WINAPI UIElementMgr_EnumUIElements(ITfUIElementMgr *iface,
1242                                                   IEnumTfUIElements **enum_elements)
1243 {
1244     ThreadMgr *This = impl_from_ITfUIElementMgr(iface);
1245
1246     FIXME("STUB:(%p)\n", This);
1247     return E_NOTIMPL;
1248 }
1249
1250 static const ITfUIElementMgrVtbl ThreadMgrUIElementMgrVtbl =
1251 {
1252     UIElementMgr_QueryInterface,
1253     UIElementMgr_AddRef,
1254     UIElementMgr_Release,
1255
1256     UIElementMgr_BeginUIElement,
1257     UIElementMgr_UpdateUIElement,
1258     UIElementMgr_EndUIElement,
1259     UIElementMgr_GetUIElement,
1260     UIElementMgr_EnumUIElements
1261 };
1262
1263 /*****************************************************
1264  * ITfSourceSingle functions
1265  *****************************************************/
1266 static HRESULT WINAPI ThreadMgrSourceSingle_QueryInterface(ITfSourceSingle *iface, REFIID iid, LPVOID *ppvOut)
1267 {
1268     ThreadMgr *This = impl_from_ITfSourceSingle(iface);
1269     return ITfThreadMgrEx_QueryInterface(&This->ITfThreadMgrEx_iface, iid, ppvOut);
1270 }
1271
1272 static ULONG WINAPI ThreadMgrSourceSingle_AddRef(ITfSourceSingle *iface)
1273 {
1274     ThreadMgr *This = impl_from_ITfSourceSingle(iface);
1275     return ITfThreadMgrEx_AddRef(&This->ITfThreadMgrEx_iface);
1276 }
1277
1278 static ULONG WINAPI ThreadMgrSourceSingle_Release(ITfSourceSingle *iface)
1279 {
1280     ThreadMgr *This = impl_from_ITfSourceSingle(iface);
1281     return ITfThreadMgrEx_Release(&This->ITfThreadMgrEx_iface);
1282 }
1283
1284 static HRESULT WINAPI ThreadMgrSourceSingle_AdviseSingleSink( ITfSourceSingle *iface,
1285     TfClientId tid, REFIID riid, IUnknown *punk)
1286 {
1287     ThreadMgr *This = impl_from_ITfSourceSingle(iface);
1288     FIXME("STUB:(%p) %i %s %p\n",This, tid, debugstr_guid(riid),punk);
1289     return E_NOTIMPL;
1290 }
1291
1292 static HRESULT WINAPI ThreadMgrSourceSingle_UnadviseSingleSink( ITfSourceSingle *iface,
1293     TfClientId tid, REFIID riid)
1294 {
1295     ThreadMgr *This = impl_from_ITfSourceSingle(iface);
1296     FIXME("STUB:(%p) %i %s\n",This, tid, debugstr_guid(riid));
1297     return E_NOTIMPL;
1298 }
1299
1300 static const ITfSourceSingleVtbl SourceSingleVtbl =
1301 {
1302     ThreadMgrSourceSingle_QueryInterface,
1303     ThreadMgrSourceSingle_AddRef,
1304     ThreadMgrSourceSingle_Release,
1305     ThreadMgrSourceSingle_AdviseSingleSink,
1306     ThreadMgrSourceSingle_UnadviseSingleSink
1307 };
1308
1309 HRESULT ThreadMgr_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
1310 {
1311     ThreadMgr *This;
1312     if (pUnkOuter)
1313         return CLASS_E_NOAGGREGATION;
1314
1315     /* Only 1 ThreadMgr is created per thread */
1316     This = TlsGetValue(tlsIndex);
1317     if (This)
1318     {
1319         ThreadMgr_AddRef(&This->ITfThreadMgrEx_iface);
1320         *ppOut = (IUnknown*)&This->ITfThreadMgrEx_iface;
1321         return S_OK;
1322     }
1323
1324     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ThreadMgr));
1325     if (This == NULL)
1326         return E_OUTOFMEMORY;
1327
1328     This->ITfThreadMgrEx_iface.lpVtbl = &ThreadMgrExVtbl;
1329     This->ITfSource_iface.lpVtbl = &ThreadMgrSourceVtbl;
1330     This->ITfKeystrokeMgr_iface.lpVtbl = &KeystrokeMgrVtbl;
1331     This->ITfMessagePump_iface.lpVtbl = &MessagePumpVtbl;
1332     This->ITfClientId_iface.lpVtbl = &ClientIdVtbl;
1333     This->ITfThreadMgrEventSink_iface.lpVtbl = &ThreadMgrEventSinkVtbl;
1334     This->ITfUIElementMgr_iface.lpVtbl = &ThreadMgrUIElementMgrVtbl;
1335     This->ITfSourceSingle_iface.lpVtbl = &SourceSingleVtbl;
1336     This->refCount = 1;
1337     TlsSetValue(tlsIndex,This);
1338
1339     CompartmentMgr_Constructor((IUnknown*)&This->ITfThreadMgrEx_iface, &IID_IUnknown, (IUnknown**)&This->CompartmentMgr);
1340
1341     list_init(&This->CurrentPreservedKeys);
1342     list_init(&This->CreatedDocumentMgrs);
1343     list_init(&This->AssociatedFocusWindows);
1344
1345     list_init(&This->ActiveLanguageProfileNotifySink);
1346     list_init(&This->DisplayAttributeNotifySink);
1347     list_init(&This->KeyTraceEventSink);
1348     list_init(&This->PreservedKeyNotifySink);
1349     list_init(&This->ThreadFocusSink);
1350     list_init(&This->ThreadMgrEventSink);
1351
1352     TRACE("returning %p\n", This);
1353     *ppOut = (IUnknown *)&This->ITfThreadMgrEx_iface;
1354     return S_OK;
1355 }
1356
1357 /**************************************************
1358  * IEnumTfDocumentMgrs implementation
1359  **************************************************/
1360 static void EnumTfDocumentMgr_Destructor(EnumTfDocumentMgr *This)
1361 {
1362     TRACE("destroying %p\n", This);
1363     HeapFree(GetProcessHeap(),0,This);
1364 }
1365
1366 static HRESULT WINAPI EnumTfDocumentMgr_QueryInterface(IEnumTfDocumentMgrs *iface, REFIID iid, LPVOID *ppvOut)
1367 {
1368     EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
1369     *ppvOut = NULL;
1370
1371     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_IEnumTfDocumentMgrs))
1372     {
1373         *ppvOut = &This->IEnumTfDocumentMgrs_iface;
1374     }
1375
1376     if (*ppvOut)
1377     {
1378         IEnumTfDocumentMgrs_AddRef(iface);
1379         return S_OK;
1380     }
1381
1382     WARN("unsupported interface: %s\n", debugstr_guid(iid));
1383     return E_NOINTERFACE;
1384 }
1385
1386 static ULONG WINAPI EnumTfDocumentMgr_AddRef(IEnumTfDocumentMgrs *iface)
1387 {
1388     EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
1389     return InterlockedIncrement(&This->refCount);
1390 }
1391
1392 static ULONG WINAPI EnumTfDocumentMgr_Release(IEnumTfDocumentMgrs *iface)
1393 {
1394     EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
1395     ULONG ret;
1396
1397     ret = InterlockedDecrement(&This->refCount);
1398     if (ret == 0)
1399         EnumTfDocumentMgr_Destructor(This);
1400     return ret;
1401 }
1402
1403 static HRESULT WINAPI EnumTfDocumentMgr_Next(IEnumTfDocumentMgrs *iface,
1404     ULONG ulCount, ITfDocumentMgr **rgDocumentMgr, ULONG *pcFetched)
1405 {
1406     EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
1407     ULONG fetched = 0;
1408
1409     TRACE("(%p)\n",This);
1410
1411     if (rgDocumentMgr == NULL) return E_POINTER;
1412
1413     while (fetched < ulCount)
1414     {
1415         DocumentMgrEntry *mgrentry;
1416         if (This->index == NULL)
1417             break;
1418
1419         mgrentry = LIST_ENTRY(This->index,DocumentMgrEntry,entry);
1420         if (mgrentry == NULL)
1421             break;
1422
1423         *rgDocumentMgr = mgrentry->docmgr;
1424         ITfDocumentMgr_AddRef(*rgDocumentMgr);
1425
1426         This->index = list_next(This->head, This->index);
1427         ++fetched;
1428         ++rgDocumentMgr;
1429     }
1430
1431     if (pcFetched) *pcFetched = fetched;
1432     return fetched == ulCount ? S_OK : S_FALSE;
1433 }
1434
1435 static HRESULT WINAPI EnumTfDocumentMgr_Skip( IEnumTfDocumentMgrs* iface, ULONG celt)
1436 {
1437     EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
1438     ULONG i;
1439
1440     TRACE("(%p)\n",This);
1441     for(i = 0; i < celt && This->index != NULL; i++)
1442         This->index = list_next(This->head, This->index);
1443     return S_OK;
1444 }
1445
1446 static HRESULT WINAPI EnumTfDocumentMgr_Reset( IEnumTfDocumentMgrs* iface)
1447 {
1448     EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
1449     TRACE("(%p)\n",This);
1450     This->index = list_head(This->head);
1451     return S_OK;
1452 }
1453
1454 static HRESULT WINAPI EnumTfDocumentMgr_Clone( IEnumTfDocumentMgrs *iface,
1455     IEnumTfDocumentMgrs **ppenum)
1456 {
1457     EnumTfDocumentMgr *This = impl_from_IEnumTfDocumentMgrs(iface);
1458     HRESULT res;
1459
1460     TRACE("(%p)\n",This);
1461
1462     if (ppenum == NULL) return E_POINTER;
1463
1464     res = EnumTfDocumentMgr_Constructor(This->head, ppenum);
1465     if (SUCCEEDED(res))
1466     {
1467         EnumTfDocumentMgr *new_This = impl_from_IEnumTfDocumentMgrs(*ppenum);
1468         new_This->index = This->index;
1469     }
1470     return res;
1471 }
1472
1473 static const IEnumTfDocumentMgrsVtbl EnumTfDocumentMgrsVtbl =
1474 {
1475     EnumTfDocumentMgr_QueryInterface,
1476     EnumTfDocumentMgr_AddRef,
1477     EnumTfDocumentMgr_Release,
1478     EnumTfDocumentMgr_Clone,
1479     EnumTfDocumentMgr_Next,
1480     EnumTfDocumentMgr_Reset,
1481     EnumTfDocumentMgr_Skip
1482 };
1483
1484 static HRESULT EnumTfDocumentMgr_Constructor(struct list* head, IEnumTfDocumentMgrs **ppOut)
1485 {
1486     EnumTfDocumentMgr *This;
1487
1488     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(EnumTfDocumentMgr));
1489     if (This == NULL)
1490         return E_OUTOFMEMORY;
1491
1492     This->IEnumTfDocumentMgrs_iface.lpVtbl= &EnumTfDocumentMgrsVtbl;
1493     This->refCount = 1;
1494     This->head = head;
1495     This->index = list_head(This->head);
1496
1497     TRACE("returning %p\n", &This->IEnumTfDocumentMgrs_iface);
1498     *ppOut = &This->IEnumTfDocumentMgrs_iface;
1499     return S_OK;
1500 }
1501
1502 void ThreadMgr_OnDocumentMgrDestruction(ITfThreadMgr *iface, ITfDocumentMgr *mgr)
1503 {
1504     ThreadMgr *This = impl_from_ITfThreadMgrEx((ITfThreadMgrEx *)iface);
1505     struct list *cursor;
1506     LIST_FOR_EACH(cursor, &This->CreatedDocumentMgrs)
1507     {
1508         DocumentMgrEntry *mgrentry = LIST_ENTRY(cursor,DocumentMgrEntry,entry);
1509         if (mgrentry->docmgr == mgr)
1510         {
1511             list_remove(cursor);
1512             HeapFree(GetProcessHeap(),0,mgrentry);
1513             return;
1514         }
1515     }
1516     FIXME("ITfDocumentMgr %p not found in this thread\n",mgr);
1517 }