dlls/msctf/compartmentmgr.c

   1 /*
   2  *  ITfCompartmentMgr implementation
   3  *
   4  *  Copyright 2009 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 "oleauto.h"
  36 #include "olectl.h"
  37
  38 #include "wine/unicode.h"
  39 #include "wine/list.h"
  40
  41 #include "msctf.h"
  42 #include "msctf_internal.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(msctf);
  45
  46 typedef struct tagCompartmentValue {
  47     struct list entry;
  48     GUID guid;
  49     TfClientId owner;
  50     ITfCompartment *compartment;
  51 } CompartmentValue;
  52
  53 typedef struct tagCompartmentMgr {
  54     ITfCompartmentMgr ITfCompartmentMgr_iface;
  55     LONG refCount;
  56
  57     IUnknown *pUnkOuter;
  58
  59     struct list values;
  60 } CompartmentMgr;
  61
  62 typedef struct tagCompartmentEnumGuid {
  63     IEnumGUID IEnumGUID_iface;
  64     LONG refCount;
  65
  66     struct list *values;
  67     struct list *cursor;
  68 } CompartmentEnumGuid;
  69
  70
  71 typedef struct tagCompartmentSink {
  72     struct list         entry;
  73     union {
  74         IUnknown            *pIUnknown;
  75         ITfCompartmentEventSink *pITfCompartmentEventSink;
  76     } interfaces;
  77 } CompartmentSink;
  78
  79 typedef struct tagCompartment {
  80     ITfCompartment ITfCompartment_iface;
  81     ITfSource ITfSource_iface;
  82     LONG refCount;
  83
  84     /* Only VT_I4, VT_UNKNOWN and VT_BSTR data types are allowed */
  85     VARIANT variant;
  86     CompartmentValue *valueData;
  87     struct list CompartmentEventSink;
  88 } Compartment;
  89
  90 static HRESULT CompartmentEnumGuid_Constructor(struct list* values, IEnumGUID **ppOut);
  91 static HRESULT Compartment_Constructor(CompartmentValue *value, ITfCompartment **ppOut);
  92
  93 static inline CompartmentMgr *impl_from_ITfCompartmentMgr(ITfCompartmentMgr *iface)
  94 {
  95     return CONTAINING_RECORD(iface, CompartmentMgr, ITfCompartmentMgr_iface);
  96 }
  97
  98 static inline Compartment *impl_from_ITfCompartment(ITfCompartment *iface)
  99 {
 100     return CONTAINING_RECORD(iface, Compartment, ITfCompartment_iface);
 101 }
 102
 103 static inline Compartment *impl_from_ITfSource(ITfSource *iface)
 104 {
 105     return CONTAINING_RECORD(iface, Compartment, ITfSource_iface);
 106 }
 107
 108 static inline CompartmentEnumGuid *impl_from_IEnumGUID(IEnumGUID *iface)
 109 {
 110     return CONTAINING_RECORD(iface, CompartmentEnumGuid, IEnumGUID_iface);
 111 }
 112
 113 HRESULT CompartmentMgr_Destructor(ITfCompartmentMgr *iface)
 114 {
 115     CompartmentMgr *This = impl_from_ITfCompartmentMgr(iface);
 116     struct list *cursor, *cursor2;
 117
 118     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->values)
 119     {
 120         CompartmentValue* value = LIST_ENTRY(cursor,CompartmentValue,entry);
 121         list_remove(cursor);
 122         ITfCompartment_Release(value->compartment);
 123         HeapFree(GetProcessHeap(),0,value);
 124     }
 125
 126     HeapFree(GetProcessHeap(),0,This);
 127     return S_OK;
 128 }
 129
 130 /*****************************************************
 131  * ITfCompartmentMgr functions
 132  *****************************************************/
 133 static HRESULT WINAPI CompartmentMgr_QueryInterface(ITfCompartmentMgr *iface, REFIID iid, LPVOID *ppvOut)
 134 {
 135     CompartmentMgr *This = impl_from_ITfCompartmentMgr(iface);
 136     if (This->pUnkOuter)
 137         return IUnknown_QueryInterface(This->pUnkOuter, iid, ppvOut);
 138     else
 139     {
 140         *ppvOut = NULL;
 141
 142         if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfCompartmentMgr))
 143         {
 144             *ppvOut = &This->ITfCompartmentMgr_iface;
 145         }
 146
 147         if (*ppvOut)
 148         {
 149             ITfCompartmentMgr_AddRef(iface);
 150             return S_OK;
 151         }
 152
 153         WARN("unsupported interface: %s\n", debugstr_guid(iid));
 154         return E_NOINTERFACE;
 155     }
 156 }
 157
 158 static ULONG WINAPI CompartmentMgr_AddRef(ITfCompartmentMgr *iface)
 159 {
 160     CompartmentMgr *This = impl_from_ITfCompartmentMgr(iface);
 161     if (This->pUnkOuter)
 162         return IUnknown_AddRef(This->pUnkOuter);
 163     else
 164         return InterlockedIncrement(&This->refCount);
 165 }
 166
 167 static ULONG WINAPI CompartmentMgr_Release(ITfCompartmentMgr *iface)
 168 {
 169     CompartmentMgr *This = impl_from_ITfCompartmentMgr(iface);
 170     if (This->pUnkOuter)
 171         return IUnknown_Release(This->pUnkOuter);
 172     else
 173     {
 174         ULONG ret;
 175
 176         ret = InterlockedDecrement(&This->refCount);
 177         if (ret == 0)
 178             CompartmentMgr_Destructor(iface);
 179         return ret;
 180     }
 181 }
 182
 183 static HRESULT WINAPI CompartmentMgr_GetCompartment(ITfCompartmentMgr *iface,
 184         REFGUID rguid, ITfCompartment **ppcomp)
 185 {
 186     CompartmentMgr *This = impl_from_ITfCompartmentMgr(iface);
 187     CompartmentValue* value;
 188     struct list *cursor;
 189     HRESULT hr;
 190
 191     TRACE("(%p) %s  %p\n",This,debugstr_guid(rguid),ppcomp);
 192
 193     LIST_FOR_EACH(cursor, &This->values)
 194     {
 195         value = LIST_ENTRY(cursor,CompartmentValue,entry);
 196         if (IsEqualGUID(rguid,&value->guid))
 197         {
 198             ITfCompartment_AddRef(value->compartment);
 199             *ppcomp = value->compartment;
 200             return S_OK;
 201         }
 202     }
 203
 204     value = HeapAlloc(GetProcessHeap(),0,sizeof(CompartmentValue));
 205     value->guid = *rguid;
 206     value->owner = 0;
 207     hr = Compartment_Constructor(value,&value->compartment);
 208     if (SUCCEEDED(hr))
 209     {
 210         list_add_head(&This->values,&value->entry);
 211         ITfCompartment_AddRef(value->compartment);
 212         *ppcomp = value->compartment;
 213     }
 214     else
 215     {
 216         HeapFree(GetProcessHeap(),0,value);
 217         *ppcomp = NULL;
 218     }
 219     return hr;
 220 }
 221
 222 static HRESULT WINAPI CompartmentMgr_ClearCompartment(ITfCompartmentMgr *iface,
 223     TfClientId tid, REFGUID rguid)
 224 {
 225     CompartmentMgr *This = impl_from_ITfCompartmentMgr(iface);
 226     struct list *cursor;
 227
 228     TRACE("(%p) %i %s\n",This,tid,debugstr_guid(rguid));
 229
 230     LIST_FOR_EACH(cursor, &This->values)
 231     {
 232         CompartmentValue* value = LIST_ENTRY(cursor,CompartmentValue,entry);
 233         if (IsEqualGUID(rguid,&value->guid))
 234         {
 235             if (value->owner && tid != value->owner)
 236                 return E_UNEXPECTED;
 237             list_remove(cursor);
 238             ITfCompartment_Release(value->compartment);
 239             HeapFree(GetProcessHeap(),0,value);
 240             return S_OK;
 241         }
 242     }
 243
 244     return CONNECT_E_NOCONNECTION;
 245 }
 246
 247 static HRESULT WINAPI CompartmentMgr_EnumCompartments(ITfCompartmentMgr *iface,
 248  IEnumGUID **ppEnum)
 249 {
 250     CompartmentMgr *This = impl_from_ITfCompartmentMgr(iface);
 251
 252     TRACE("(%p) %p\n",This,ppEnum);
 253     if (!ppEnum)
 254         return E_INVALIDARG;
 255     return CompartmentEnumGuid_Constructor(&This->values, ppEnum);
 256 }
 257
 258 static const ITfCompartmentMgrVtbl CompartmentMgrVtbl =
 259 {
 260     CompartmentMgr_QueryInterface,
 261     CompartmentMgr_AddRef,
 262     CompartmentMgr_Release,
 263     CompartmentMgr_GetCompartment,
 264     CompartmentMgr_ClearCompartment,
 265     CompartmentMgr_EnumCompartments
 266 };
 267
 268 HRESULT CompartmentMgr_Constructor(IUnknown *pUnkOuter, REFIID riid, IUnknown **ppOut)
 269 {
 270     CompartmentMgr *This;
 271
 272     if (!ppOut)
 273         return E_POINTER;
 274
 275     if (pUnkOuter && !IsEqualIID (riid, &IID_IUnknown))
 276         return CLASS_E_NOAGGREGATION;
 277
 278     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CompartmentMgr));
 279     if (This == NULL)
 280         return E_OUTOFMEMORY;
 281
 282     This->ITfCompartmentMgr_iface.lpVtbl = &CompartmentMgrVtbl;
 283     This->pUnkOuter = pUnkOuter;
 284     list_init(&This->values);
 285
 286     if (pUnkOuter)
 287     {
 288         *ppOut = (IUnknown*)&This->ITfCompartmentMgr_iface;
 289         TRACE("returning %p\n", *ppOut);
 290         return S_OK;
 291     }
 292     else
 293     {
 294         HRESULT hr;
 295         hr = ITfCompartmentMgr_QueryInterface(&This->ITfCompartmentMgr_iface, riid, (void**)ppOut);
 296         if (FAILED(hr))
 297             HeapFree(GetProcessHeap(),0,This);
 298         return hr;
 299     }
 300 }
 301
 302 /**************************************************
 303  * IEnumGUID implementation for ITfCompartmentMgr::EnumCompartments
 304  **************************************************/
 305 static void CompartmentEnumGuid_Destructor(CompartmentEnumGuid *This)
 306 {
 307     TRACE("destroying %p\n", This);
 308     HeapFree(GetProcessHeap(),0,This);
 309 }
 310
 311 static HRESULT WINAPI CompartmentEnumGuid_QueryInterface(IEnumGUID *iface, REFIID iid, LPVOID *ppvOut)
 312 {
 313     CompartmentEnumGuid *This = impl_from_IEnumGUID(iface);
 314     *ppvOut = NULL;
 315
 316     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_IEnumGUID))
 317     {
 318         *ppvOut = &This->IEnumGUID_iface;
 319     }
 320
 321     if (*ppvOut)
 322     {
 323         IEnumGUID_AddRef(iface);
 324         return S_OK;
 325     }
 326
 327     WARN("unsupported interface: %s\n", debugstr_guid(iid));
 328     return E_NOINTERFACE;
 329 }
 330
 331 static ULONG WINAPI CompartmentEnumGuid_AddRef(IEnumGUID *iface)
 332 {
 333     CompartmentEnumGuid *This = impl_from_IEnumGUID(iface);
 334     return InterlockedIncrement(&This->refCount);
 335 }
 336
 337 static ULONG WINAPI CompartmentEnumGuid_Release(IEnumGUID *iface)
 338 {
 339     CompartmentEnumGuid *This = impl_from_IEnumGUID(iface);
 340     ULONG ret;
 341
 342     ret = InterlockedDecrement(&This->refCount);
 343     if (ret == 0)
 344         CompartmentEnumGuid_Destructor(This);
 345     return ret;
 346 }
 347
 348 /*****************************************************
 349  * IEnumGuid functions
 350  *****************************************************/
 351 static HRESULT WINAPI CompartmentEnumGuid_Next(IEnumGUID *iface,
 352     ULONG celt, GUID *rgelt, ULONG *pceltFetched)
 353 {
 354     CompartmentEnumGuid *This = impl_from_IEnumGUID(iface);
 355     ULONG fetched = 0;
 356
 357     TRACE("(%p)\n",This);
 358
 359     if (rgelt == NULL) return E_POINTER;
 360
 361     while (fetched < celt && This->cursor)
 362     {
 363         CompartmentValue* value = LIST_ENTRY(This->cursor,CompartmentValue,entry);
 364         if (!value)
 365             break;
 366
 367         This->cursor = list_next(This->values,This->cursor);
 368         *rgelt = value->guid;
 369
 370         ++fetched;
 371         ++rgelt;
 372     }
 373
 374     if (pceltFetched) *pceltFetched = fetched;
 375     return fetched == celt ? S_OK : S_FALSE;
 376 }
 377
 378 static HRESULT WINAPI CompartmentEnumGuid_Skip(IEnumGUID *iface, ULONG celt)
 379 {
 380     CompartmentEnumGuid *This = impl_from_IEnumGUID(iface);
 381     TRACE("(%p)\n",This);
 382
 383     This->cursor = list_next(This->values,This->cursor);
 384     return S_OK;
 385 }
 386
 387 static HRESULT WINAPI CompartmentEnumGuid_Reset(IEnumGUID *iface)
 388 {
 389     CompartmentEnumGuid *This = impl_from_IEnumGUID(iface);
 390     TRACE("(%p)\n",This);
 391     This->cursor = list_head(This->values);
 392     return S_OK;
 393 }
 394
 395 static HRESULT WINAPI CompartmentEnumGuid_Clone(IEnumGUID *iface,
 396     IEnumGUID **ppenum)
 397 {
 398     CompartmentEnumGuid *This = impl_from_IEnumGUID(iface);
 399     HRESULT res;
 400
 401     TRACE("(%p)\n",This);
 402
 403     if (ppenum == NULL) return E_POINTER;
 404
 405     res = CompartmentEnumGuid_Constructor(This->values, ppenum);
 406     if (SUCCEEDED(res))
 407     {
 408         CompartmentEnumGuid *new_This = impl_from_IEnumGUID(*ppenum);
 409         new_This->cursor = This->cursor;
 410     }
 411     return res;
 412 }
 413
 414 static const IEnumGUIDVtbl EnumGUIDVtbl =
 415 {
 416     CompartmentEnumGuid_QueryInterface,
 417     CompartmentEnumGuid_AddRef,
 418     CompartmentEnumGuid_Release,
 419     CompartmentEnumGuid_Next,
 420     CompartmentEnumGuid_Skip,
 421     CompartmentEnumGuid_Reset,
 422     CompartmentEnumGuid_Clone
 423 };
 424
 425 static HRESULT CompartmentEnumGuid_Constructor(struct list *values, IEnumGUID **ppOut)
 426 {
 427     CompartmentEnumGuid *This;
 428
 429     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CompartmentEnumGuid));
 430     if (This == NULL)
 431         return E_OUTOFMEMORY;
 432
 433     This->IEnumGUID_iface.lpVtbl= &EnumGUIDVtbl;
 434     This->refCount = 1;
 435
 436     This->values = values;
 437     This->cursor = list_head(values);
 438
 439     *ppOut = &This->IEnumGUID_iface;
 440     TRACE("returning %p\n", *ppOut);
 441     return S_OK;
 442 }
 443
 444 /**************************************************
 445  * ITfCompartment
 446  **************************************************/
 447 static void free_sink(CompartmentSink *sink)
 448 {
 449         IUnknown_Release(sink->interfaces.pIUnknown);
 450         HeapFree(GetProcessHeap(),0,sink);
 451 }
 452
 453 static void Compartment_Destructor(Compartment *This)
 454 {
 455     struct list *cursor, *cursor2;
 456     TRACE("destroying %p\n", This);
 457     VariantClear(&This->variant);
 458     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->CompartmentEventSink)
 459     {
 460         CompartmentSink* sink = LIST_ENTRY(cursor,CompartmentSink,entry);
 461         list_remove(cursor);
 462         free_sink(sink);
 463     }
 464     HeapFree(GetProcessHeap(),0,This);
 465 }
 466
 467 static HRESULT WINAPI Compartment_QueryInterface(ITfCompartment *iface, REFIID iid, LPVOID *ppvOut)
 468 {
 469     Compartment *This = impl_from_ITfCompartment(iface);
 470
 471     *ppvOut = NULL;
 472
 473     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfCompartment))
 474     {
 475         *ppvOut = &This->ITfCompartment_iface;
 476     }
 477     else if (IsEqualIID(iid, &IID_ITfSource))
 478     {
 479         *ppvOut = &This->ITfSource_iface;
 480     }
 481
 482     if (*ppvOut)
 483     {
 484         ITfCompartment_AddRef(iface);
 485         return S_OK;
 486     }
 487
 488     WARN("unsupported interface: %s\n", debugstr_guid(iid));
 489     return E_NOINTERFACE;
 490 }
 491
 492 static ULONG WINAPI Compartment_AddRef(ITfCompartment *iface)
 493 {
 494     Compartment *This = impl_from_ITfCompartment(iface);
 495     return InterlockedIncrement(&This->refCount);
 496 }
 497
 498 static ULONG WINAPI Compartment_Release(ITfCompartment *iface)
 499 {
 500     Compartment *This = impl_from_ITfCompartment(iface);
 501     ULONG ret;
 502
 503     ret = InterlockedDecrement(&This->refCount);
 504     if (ret == 0)
 505         Compartment_Destructor(This);
 506     return ret;
 507 }
 508
 509 static HRESULT WINAPI Compartment_SetValue(ITfCompartment *iface,
 510     TfClientId tid, const VARIANT *pvarValue)
 511 {
 512     Compartment *This = impl_from_ITfCompartment(iface);
 513     struct list *cursor;
 514
 515     TRACE("(%p) %i %p\n",This,tid,pvarValue);
 516
 517     if (!pvarValue)
 518         return E_INVALIDARG;
 519
 520     if (!(V_VT(pvarValue) == VT_BSTR || V_VT(pvarValue) == VT_I4 ||
 521           V_VT(pvarValue) == VT_UNKNOWN))
 522         return E_INVALIDARG;
 523
 524     if (!This->valueData->owner)
 525         This->valueData->owner = tid;
 526
 527     VariantClear(&This->variant);
 528
 529     /* Shallow copy of value and type */
 530     This->variant = *pvarValue;
 531
 532     if (V_VT(pvarValue) == VT_BSTR)
 533         V_BSTR(&This->variant) = SysAllocStringByteLen((char*)V_BSTR(pvarValue),
 534                 SysStringByteLen(V_BSTR(pvarValue)));
 535     else if (V_VT(pvarValue) == VT_UNKNOWN)
 536         IUnknown_AddRef(V_UNKNOWN(&This->variant));
 537
 538     LIST_FOR_EACH(cursor, &This->CompartmentEventSink)
 539     {
 540         CompartmentSink* sink = LIST_ENTRY(cursor,CompartmentSink,entry);
 541         ITfCompartmentEventSink_OnChange(sink->interfaces.pITfCompartmentEventSink,&This->valueData->guid);
 542     }
 543
 544     return S_OK;
 545 }
 546
 547 static HRESULT WINAPI Compartment_GetValue(ITfCompartment *iface,
 548     VARIANT *pvarValue)
 549 {
 550     Compartment *This = impl_from_ITfCompartment(iface);
 551     TRACE("(%p) %p\n",This, pvarValue);
 552
 553     if (!pvarValue)
 554         return E_INVALIDARG;
 555
 556     VariantInit(pvarValue);
 557     if (V_VT(&This->variant) == VT_EMPTY) return S_FALSE;
 558     return VariantCopy(pvarValue,&This->variant);
 559 }
 560
 561 static const ITfCompartmentVtbl CompartmentVtbl =
 562 {
 563     Compartment_QueryInterface,
 564     Compartment_AddRef,
 565     Compartment_Release,
 566     Compartment_SetValue,
 567     Compartment_GetValue
 568 };
 569
 570 /*****************************************************
 571  * ITfSource functions
 572  *****************************************************/
 573
 574 static HRESULT WINAPI CompartmentSource_QueryInterface(ITfSource *iface, REFIID iid, LPVOID *ppvOut)
 575 {
 576     Compartment *This = impl_from_ITfSource(iface);
 577     return ITfCompartment_QueryInterface(&This->ITfCompartment_iface, iid, ppvOut);
 578 }
 579
 580 static ULONG WINAPI CompartmentSource_AddRef(ITfSource *iface)
 581 {
 582     Compartment *This = impl_from_ITfSource(iface);
 583     return ITfCompartment_AddRef(&This->ITfCompartment_iface);
 584 }
 585
 586 static ULONG WINAPI CompartmentSource_Release(ITfSource *iface)
 587 {
 588     Compartment *This = impl_from_ITfSource(iface);
 589     return ITfCompartment_Release(&This->ITfCompartment_iface);
 590 }
 591
 592 static HRESULT WINAPI CompartmentSource_AdviseSink(ITfSource *iface,
 593         REFIID riid, IUnknown *punk, DWORD *pdwCookie)
 594 {
 595     Compartment *This = impl_from_ITfSource(iface);
 596     CompartmentSink *cs;
 597
 598     TRACE("(%p) %s %p %p\n",This,debugstr_guid(riid),punk,pdwCookie);
 599
 600     if (!riid || !punk || !pdwCookie)
 601         return E_INVALIDARG;
 602
 603     if (IsEqualIID(riid, &IID_ITfCompartmentEventSink))
 604     {
 605         cs = HeapAlloc(GetProcessHeap(),0,sizeof(CompartmentSink));
 606         if (!cs)
 607             return E_OUTOFMEMORY;
 608         if (FAILED(IUnknown_QueryInterface(punk, riid, (LPVOID *)&cs->interfaces.pITfCompartmentEventSink)))
 609         {
 610             HeapFree(GetProcessHeap(),0,cs);
 611             return CONNECT_E_CANNOTCONNECT;
 612         }
 613         list_add_head(&This->CompartmentEventSink,&cs->entry);
 614         *pdwCookie = generate_Cookie(COOKIE_MAGIC_COMPARTMENTSINK , cs);
 615     }
 616     else
 617     {
 618         FIXME("(%p) Unhandled Sink: %s\n",This,debugstr_guid(riid));
 619         return E_NOTIMPL;
 620     }
 621
 622     TRACE("cookie %x\n",*pdwCookie);
 623
 624     return S_OK;
 625 }
 626
 627 static HRESULT WINAPI CompartmentSource_UnadviseSink(ITfSource *iface, DWORD pdwCookie)
 628 {
 629     Compartment *This = impl_from_ITfSource(iface);
 630     CompartmentSink *sink;
 631
 632     TRACE("(%p) %x\n",This,pdwCookie);
 633
 634     if (get_Cookie_magic(pdwCookie)!=COOKIE_MAGIC_COMPARTMENTSINK)
 635         return E_INVALIDARG;
 636
 637     sink = remove_Cookie(pdwCookie);
 638     if (!sink)
 639         return CONNECT_E_NOCONNECTION;
 640
 641     list_remove(&sink->entry);
 642     free_sink(sink);
 643
 644     return S_OK;
 645 }
 646
 647 static const ITfSourceVtbl CompartmentSourceVtbl =
 648 {
 649     CompartmentSource_QueryInterface,
 650     CompartmentSource_AddRef,
 651     CompartmentSource_Release,
 652     CompartmentSource_AdviseSink,
 653     CompartmentSource_UnadviseSink,
 654 };
 655
 656 static HRESULT Compartment_Constructor(CompartmentValue *valueData, ITfCompartment **ppOut)
 657 {
 658     Compartment *This;
 659
 660     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(Compartment));
 661     if (This == NULL)
 662         return E_OUTOFMEMORY;
 663
 664     This->ITfCompartment_iface.lpVtbl= &CompartmentVtbl;
 665     This->ITfSource_iface.lpVtbl = &CompartmentSourceVtbl;
 666     This->refCount = 1;
 667
 668     This->valueData = valueData;
 669     VariantInit(&This->variant);
 670
 671     list_init(&This->CompartmentEventSink);
 672
 673     *ppOut = &This->ITfCompartment_iface;
 674     TRACE("returning %p\n", *ppOut);
 675     return S_OK;
 676 }