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