dlls/msctf/context.c

   1 /*
   2  *  ITfContext 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 "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 tagContextSink {
  46     struct list         entry;
  47     union {
  48         /* Context Sinks */
  49         IUnknown            *pIUnknown;
  50         /* ITfContextKeyEventSink  *pITfContextKeyEventSink; */
  51         /* ITfEditTransactionSink  *pITfEditTransactionSink; */
  52         /* ITfStatusSink           *pITfStatusSink; */
  53         ITfTextEditSink     *pITfTextEditSink;
  54         /* ITfTextLayoutSink       *pITfTextLayoutSink; */
  55     } interfaces;
  56 } ContextSink;
  57
  58 typedef struct tagContext {
  59     ITfContext ITfContext_iface;
  60     ITfSource ITfSource_iface;
  61     /* const ITfContextCompositionVtbl *ContextCompositionVtbl; */
  62     /* const ITfContextOwnerCompositionServicesVtbl *ContextOwnerCompositionServicesVtbl; */
  63     /* const ITfContextOwnerServicesVtbl *ContextOwnerServicesVtbl; */
  64     ITfInsertAtSelection ITfInsertAtSelection_iface;
  65     /* const ITfMouseTrackerVtbl *MouseTrackerVtbl; */
  66     /* const ITfQueryEmbeddedVtbl *QueryEmbeddedVtbl; */
  67     ITfSourceSingle ITfSourceSingle_iface;
  68     ITextStoreACPSink ITextStoreACPSink_iface;
  69     ITextStoreACPServices ITextStoreACPServices_iface;
  70     LONG refCount;
  71     BOOL connected;
  72
  73     /* Aggregation */
  74     ITfCompartmentMgr  *CompartmentMgr;
  75
  76     TfClientId tidOwner;
  77     TfEditCookie defaultCookie;
  78     TS_STATUS documentStatus;
  79     ITfDocumentMgr *manager;
  80
  81     ITextStoreACP   *pITextStoreACP;
  82     ITfContextOwnerCompositionSink *pITfContextOwnerCompositionSink;
  83
  84     ITfEditSession* currentEditSession;
  85
  86     /* kept as separate lists to reduce unnecessary iterations */
  87     struct list     pContextKeyEventSink;
  88     struct list     pEditTransactionSink;
  89     struct list     pStatusSink;
  90     struct list     pTextEditSink;
  91     struct list     pTextLayoutSink;
  92
  93 } Context;
  94
  95 typedef struct tagEditCookie {
  96     DWORD lockType;
  97     Context *pOwningContext;
  98 } EditCookie;
  99
 100 static inline Context *impl_from_ITfContext(ITfContext *iface)
 101 {
 102     return CONTAINING_RECORD(iface, Context, ITfContext_iface);
 103 }
 104
 105 static inline Context *impl_from_ITfSource(ITfSource *iface)
 106 {
 107     return CONTAINING_RECORD(iface, Context, ITfSource_iface);
 108 }
 109
 110 static inline Context *impl_from_ITfInsertAtSelection(ITfInsertAtSelection *iface)
 111 {
 112     return CONTAINING_RECORD(iface, Context, ITfInsertAtSelection_iface);
 113 }
 114
 115 static inline Context *impl_from_ITfSourceSingle(ITfSourceSingle* iface)
 116 {
 117     return CONTAINING_RECORD(iface, Context, ITfSourceSingle_iface);
 118 }
 119
 120 static inline Context *impl_from_ITextStoreACPSink(ITextStoreACPSink *iface)
 121 {
 122     return CONTAINING_RECORD(iface, Context, ITextStoreACPSink_iface);
 123 }
 124
 125 static inline Context *impl_from_ITextStoreACPServices(ITextStoreACPServices *iface)
 126 {
 127     return CONTAINING_RECORD(iface, Context, ITextStoreACPServices_iface);
 128 }
 129
 130 static void free_sink(ContextSink *sink)
 131 {
 132         IUnknown_Release(sink->interfaces.pIUnknown);
 133         HeapFree(GetProcessHeap(),0,sink);
 134 }
 135
 136 static void Context_Destructor(Context *This)
 137 {
 138     struct list *cursor, *cursor2;
 139     EditCookie *cookie;
 140     TRACE("destroying %p\n", This);
 141
 142     if (This->pITextStoreACP)
 143     {
 144         ITextStoreACP_UnadviseSink(This->pITextStoreACP, (IUnknown*)&This->ITextStoreACPSink_iface);
 145         ITextStoreACP_Release(This->pITextStoreACP);
 146     }
 147
 148     if (This->pITfContextOwnerCompositionSink)
 149         ITfContextOwnerCompositionSink_Release(This->pITfContextOwnerCompositionSink);
 150
 151     if (This->defaultCookie)
 152     {
 153         cookie = remove_Cookie(This->defaultCookie);
 154         HeapFree(GetProcessHeap(),0,cookie);
 155         This->defaultCookie = 0;
 156     }
 157
 158     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pContextKeyEventSink)
 159     {
 160         ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
 161         list_remove(cursor);
 162         free_sink(sink);
 163     }
 164     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pEditTransactionSink)
 165     {
 166         ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
 167         list_remove(cursor);
 168         free_sink(sink);
 169     }
 170     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pStatusSink)
 171     {
 172         ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
 173         list_remove(cursor);
 174         free_sink(sink);
 175     }
 176     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pTextEditSink)
 177     {
 178         ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
 179         list_remove(cursor);
 180         free_sink(sink);
 181     }
 182     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pTextLayoutSink)
 183     {
 184         ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
 185         list_remove(cursor);
 186         free_sink(sink);
 187     }
 188
 189     CompartmentMgr_Destructor(This->CompartmentMgr);
 190     HeapFree(GetProcessHeap(),0,This);
 191 }
 192
 193 static HRESULT WINAPI Context_QueryInterface(ITfContext *iface, REFIID iid, LPVOID *ppvOut)
 194 {
 195     Context *This = impl_from_ITfContext(iface);
 196     *ppvOut = NULL;
 197
 198     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfContext))
 199     {
 200         *ppvOut = &This->ITfContext_iface;
 201     }
 202     else if (IsEqualIID(iid, &IID_ITfSource))
 203     {
 204         *ppvOut = &This->ITfSource_iface;
 205     }
 206     else if (IsEqualIID(iid, &IID_ITfInsertAtSelection))
 207     {
 208         *ppvOut = &This->ITfInsertAtSelection_iface;
 209     }
 210     else if (IsEqualIID(iid, &IID_ITfCompartmentMgr))
 211     {
 212         *ppvOut = This->CompartmentMgr;
 213     }
 214     else if (IsEqualIID(iid, &IID_ITfSourceSingle))
 215     {
 216         *ppvOut = &This->ITfSourceSingle_iface;
 217     }
 218
 219     if (*ppvOut)
 220     {
 221         ITfContext_AddRef(iface);
 222         return S_OK;
 223     }
 224
 225     WARN("unsupported interface: %s\n", debugstr_guid(iid));
 226     return E_NOINTERFACE;
 227 }
 228
 229 static ULONG WINAPI Context_AddRef(ITfContext *iface)
 230 {
 231     Context *This = impl_from_ITfContext(iface);
 232     return InterlockedIncrement(&This->refCount);
 233 }
 234
 235 static ULONG WINAPI Context_Release(ITfContext *iface)
 236 {
 237     Context *This = impl_from_ITfContext(iface);
 238     ULONG ret;
 239
 240     ret = InterlockedDecrement(&This->refCount);
 241     if (ret == 0)
 242         Context_Destructor(This);
 243     return ret;
 244 }
 245
 246 /*****************************************************
 247  * ITfContext functions
 248  *****************************************************/
 249 static HRESULT WINAPI Context_RequestEditSession (ITfContext *iface,
 250         TfClientId tid, ITfEditSession *pes, DWORD dwFlags,
 251         HRESULT *phrSession)
 252 {
 253     Context *This = impl_from_ITfContext(iface);
 254     HRESULT hr;
 255     DWORD  dwLockFlags = 0x0;
 256
 257     TRACE("(%p) %i %p %x %p\n",This, tid, pes, dwFlags, phrSession);
 258
 259     if (!(dwFlags & TF_ES_READ) && !(dwFlags & TF_ES_READWRITE))
 260     {
 261         *phrSession = E_FAIL;
 262         return E_INVALIDARG;
 263     }
 264
 265     if (!This->pITextStoreACP)
 266     {
 267         FIXME("No ITextStoreACP available\n");
 268         *phrSession = E_FAIL;
 269         return E_FAIL;
 270     }
 271
 272     if (!(dwFlags & TF_ES_ASYNC))
 273         dwLockFlags |= TS_LF_SYNC;
 274
 275     if ((dwFlags & TF_ES_READWRITE) == TF_ES_READWRITE)
 276         dwLockFlags |= TS_LF_READWRITE;
 277     else if (dwFlags & TF_ES_READ)
 278         dwLockFlags |= TS_LF_READ;
 279
 280     if (!This->documentStatus.dwDynamicFlags)
 281         ITextStoreACP_GetStatus(This->pITextStoreACP, &This->documentStatus);
 282
 283     if (((dwFlags & TF_ES_READWRITE) == TF_ES_READWRITE) && (This->documentStatus.dwDynamicFlags & TS_SD_READONLY))
 284     {
 285         *phrSession = TS_E_READONLY;
 286         return S_OK;
 287     }
 288
 289     if (FAILED (ITfEditSession_QueryInterface(pes, &IID_ITfEditSession, (LPVOID*)&This->currentEditSession)))
 290     {
 291         *phrSession = E_FAIL;
 292         return E_INVALIDARG;
 293     }
 294
 295     hr = ITextStoreACP_RequestLock(This->pITextStoreACP, dwLockFlags, phrSession);
 296
 297     return hr;
 298 }
 299
 300 static HRESULT WINAPI Context_InWriteSession (ITfContext *iface,
 301          TfClientId tid,
 302          BOOL *pfWriteSession)
 303 {
 304     Context *This = impl_from_ITfContext(iface);
 305     FIXME("STUB:(%p)\n",This);
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI Context_GetSelection (ITfContext *iface,
 310         TfEditCookie ec, ULONG ulIndex, ULONG ulCount,
 311         TF_SELECTION *pSelection, ULONG *pcFetched)
 312 {
 313     Context *This = impl_from_ITfContext(iface);
 314     EditCookie *cookie;
 315     ULONG count, i;
 316     ULONG totalFetched = 0;
 317     HRESULT hr = S_OK;
 318
 319     if (!pSelection || !pcFetched)
 320         return E_INVALIDARG;
 321
 322     *pcFetched = 0;
 323
 324     if (!This->connected)
 325         return TF_E_DISCONNECTED;
 326
 327     if (get_Cookie_magic(ec)!=COOKIE_MAGIC_EDITCOOKIE)
 328         return TF_E_NOLOCK;
 329
 330     if (!This->pITextStoreACP)
 331     {
 332         FIXME("Context does not have a ITextStoreACP\n");
 333         return E_NOTIMPL;
 334     }
 335
 336     cookie = get_Cookie_data(ec);
 337
 338     if (ulIndex == TF_DEFAULT_SELECTION)
 339         count = 1;
 340     else
 341         count = ulCount;
 342
 343     for (i = 0; i < count; i++)
 344     {
 345         DWORD fetched;
 346         TS_SELECTION_ACP acps;
 347
 348         hr = ITextStoreACP_GetSelection(This->pITextStoreACP, ulIndex + i,
 349                 1, &acps, &fetched);
 350
 351         if (hr == TS_E_NOLOCK)
 352             return TF_E_NOLOCK;
 353         else if (SUCCEEDED(hr))
 354         {
 355             pSelection[totalFetched].style.ase = acps.style.ase;
 356             pSelection[totalFetched].style.fInterimChar = acps.style.fInterimChar;
 357             Range_Constructor(iface, This->pITextStoreACP, cookie->lockType, acps.acpStart, acps.acpEnd, &pSelection[totalFetched].range);
 358             totalFetched ++;
 359         }
 360         else
 361             break;
 362     }
 363
 364     *pcFetched = totalFetched;
 365
 366     return hr;
 367 }
 368
 369 static HRESULT WINAPI Context_SetSelection (ITfContext *iface,
 370         TfEditCookie ec, ULONG ulCount, const TF_SELECTION *pSelection)
 371 {
 372     Context *This = impl_from_ITfContext(iface);
 373     TS_SELECTION_ACP *acp;
 374     ULONG i;
 375     HRESULT hr;
 376
 377     TRACE("(%p) %i %i %p\n",This,ec,ulCount,pSelection);
 378
 379     if (!This->pITextStoreACP)
 380     {
 381         FIXME("Context does not have a ITextStoreACP\n");
 382         return E_NOTIMPL;
 383     }
 384
 385     if (get_Cookie_magic(ec)!=COOKIE_MAGIC_EDITCOOKIE)
 386         return TF_E_NOLOCK;
 387
 388     acp = HeapAlloc(GetProcessHeap(), 0, sizeof(TS_SELECTION_ACP) * ulCount);
 389     if (!acp)
 390         return E_OUTOFMEMORY;
 391
 392     for (i = 0; i < ulCount; i++)
 393         if (FAILED(TF_SELECTION_to_TS_SELECTION_ACP(&pSelection[i], &acp[i])))
 394         {
 395             TRACE("Selection Conversion Failed\n");
 396             HeapFree(GetProcessHeap(), 0 , acp);
 397             return E_FAIL;
 398         }
 399
 400     hr = ITextStoreACP_SetSelection(This->pITextStoreACP, ulCount, acp);
 401
 402     HeapFree(GetProcessHeap(), 0, acp);
 403
 404     return hr;
 405 }
 406
 407 static HRESULT WINAPI Context_GetStart (ITfContext *iface,
 408         TfEditCookie ec, ITfRange **ppStart)
 409 {
 410     Context *This = impl_from_ITfContext(iface);
 411     EditCookie *cookie;
 412     TRACE("(%p) %i %p\n",This,ec,ppStart);
 413
 414     if (!ppStart)
 415         return E_INVALIDARG;
 416
 417     *ppStart = NULL;
 418
 419     if (!This->connected)
 420         return TF_E_DISCONNECTED;
 421
 422     if (get_Cookie_magic(ec)!=COOKIE_MAGIC_EDITCOOKIE)
 423         return TF_E_NOLOCK;
 424
 425     cookie = get_Cookie_data(ec);
 426     return Range_Constructor(iface, This->pITextStoreACP, cookie->lockType, 0, 0, ppStart);
 427 }
 428
 429 static HRESULT WINAPI Context_GetEnd (ITfContext *iface,
 430         TfEditCookie ec, ITfRange **ppEnd)
 431 {
 432     Context *This = impl_from_ITfContext(iface);
 433     EditCookie *cookie;
 434     LONG end;
 435     TRACE("(%p) %i %p\n",This,ec,ppEnd);
 436
 437     if (!ppEnd)
 438         return E_INVALIDARG;
 439
 440     *ppEnd = NULL;
 441
 442     if (!This->connected)
 443         return TF_E_DISCONNECTED;
 444
 445     if (get_Cookie_magic(ec)!=COOKIE_MAGIC_EDITCOOKIE)
 446         return TF_E_NOLOCK;
 447
 448     if (!This->pITextStoreACP)
 449     {
 450         FIXME("Context does not have a ITextStoreACP\n");
 451         return E_NOTIMPL;
 452     }
 453
 454     cookie = get_Cookie_data(ec);
 455     ITextStoreACP_GetEndACP(This->pITextStoreACP,&end);
 456
 457     return Range_Constructor(iface, This->pITextStoreACP, cookie->lockType, end, end, ppEnd);
 458 }
 459
 460 static HRESULT WINAPI Context_GetActiveView (ITfContext *iface,
 461   ITfContextView **ppView)
 462 {
 463     Context *This = impl_from_ITfContext(iface);
 464     FIXME("STUB:(%p)\n",This);
 465     return E_NOTIMPL;
 466 }
 467
 468 static HRESULT WINAPI Context_EnumViews (ITfContext *iface,
 469         IEnumTfContextViews **ppEnum)
 470 {
 471     Context *This = impl_from_ITfContext(iface);
 472     FIXME("STUB:(%p)\n",This);
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI Context_GetStatus (ITfContext *iface,
 477         TF_STATUS *pdcs)
 478 {
 479     Context *This = impl_from_ITfContext(iface);
 480     TRACE("(%p) %p\n",This,pdcs);
 481
 482     if (!This->connected)
 483         return TF_E_DISCONNECTED;
 484
 485     if (!pdcs)
 486         return E_INVALIDARG;
 487
 488     if (!This->pITextStoreACP)
 489     {
 490         FIXME("Context does not have a ITextStoreACP\n");
 491         return E_NOTIMPL;
 492     }
 493
 494     ITextStoreACP_GetStatus(This->pITextStoreACP, &This->documentStatus);
 495
 496     *pdcs = This->documentStatus;
 497
 498     return S_OK;
 499 }
 500
 501 static HRESULT WINAPI Context_GetProperty (ITfContext *iface,
 502         REFGUID guidProp, ITfProperty **ppProp)
 503 {
 504     Context *This = impl_from_ITfContext(iface);
 505     FIXME("STUB:(%p)\n",This);
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT WINAPI Context_GetAppProperty (ITfContext *iface,
 510         REFGUID guidProp, ITfReadOnlyProperty **ppProp)
 511 {
 512     Context *This = impl_from_ITfContext(iface);
 513     FIXME("STUB:(%p)\n",This);
 514     return E_NOTIMPL;
 515 }
 516
 517 static HRESULT WINAPI Context_TrackProperties (ITfContext *iface,
 518         const GUID **prgProp, ULONG cProp, const GUID **prgAppProp,
 519         ULONG cAppProp, ITfReadOnlyProperty **ppProperty)
 520 {
 521     Context *This = impl_from_ITfContext(iface);
 522     FIXME("STUB:(%p)\n",This);
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI Context_EnumProperties (ITfContext *iface,
 527         IEnumTfProperties **ppEnum)
 528 {
 529     Context *This = impl_from_ITfContext(iface);
 530     FIXME("STUB:(%p)\n",This);
 531     return E_NOTIMPL;
 532 }
 533
 534 static HRESULT WINAPI Context_GetDocumentMgr (ITfContext *iface,
 535         ITfDocumentMgr **ppDm)
 536 {
 537     Context *This = impl_from_ITfContext(iface);
 538     TRACE("(%p) %p\n",This,ppDm);
 539
 540     if (!ppDm)
 541         return E_INVALIDARG;
 542
 543     *ppDm = This->manager;
 544     if (!This->manager)
 545         return S_FALSE;
 546
 547     ITfDocumentMgr_AddRef(This->manager);
 548
 549     return S_OK;
 550 }
 551
 552 static HRESULT WINAPI Context_CreateRangeBackup (ITfContext *iface,
 553         TfEditCookie ec, ITfRange *pRange, ITfRangeBackup **ppBackup)
 554 {
 555     Context *This = impl_from_ITfContext(iface);
 556     FIXME("STUB:(%p)\n",This);
 557     return E_NOTIMPL;
 558 }
 559
 560 static const ITfContextVtbl ContextVtbl =
 561 {
 562     Context_QueryInterface,
 563     Context_AddRef,
 564     Context_Release,
 565     Context_RequestEditSession,
 566     Context_InWriteSession,
 567     Context_GetSelection,
 568     Context_SetSelection,
 569     Context_GetStart,
 570     Context_GetEnd,
 571     Context_GetActiveView,
 572     Context_EnumViews,
 573     Context_GetStatus,
 574     Context_GetProperty,
 575     Context_GetAppProperty,
 576     Context_TrackProperties,
 577     Context_EnumProperties,
 578     Context_GetDocumentMgr,
 579     Context_CreateRangeBackup
 580 };
 581
 582 static HRESULT WINAPI ContextSource_QueryInterface(ITfSource *iface, REFIID iid, LPVOID *ppvOut)
 583 {
 584     Context *This = impl_from_ITfSource(iface);
 585     return ITfContext_QueryInterface(&This->ITfContext_iface, iid, ppvOut);
 586 }
 587
 588 static ULONG WINAPI ContextSource_AddRef(ITfSource *iface)
 589 {
 590     Context *This = impl_from_ITfSource(iface);
 591     return ITfContext_AddRef(&This->ITfContext_iface);
 592 }
 593
 594 static ULONG WINAPI ContextSource_Release(ITfSource *iface)
 595 {
 596     Context *This = impl_from_ITfSource(iface);
 597     return ITfContext_Release(&This->ITfContext_iface);
 598 }
 599
 600 /*****************************************************
 601  * ITfSource functions
 602  *****************************************************/
 603 static HRESULT WINAPI ContextSource_AdviseSink(ITfSource *iface,
 604         REFIID riid, IUnknown *punk, DWORD *pdwCookie)
 605 {
 606     Context *This = impl_from_ITfSource(iface);
 607     ContextSink *es;
 608     TRACE("(%p) %s %p %p\n",This,debugstr_guid(riid),punk,pdwCookie);
 609
 610     if (!riid || !punk || !pdwCookie)
 611         return E_INVALIDARG;
 612
 613     if (IsEqualIID(riid, &IID_ITfTextEditSink))
 614     {
 615         es = HeapAlloc(GetProcessHeap(),0,sizeof(ContextSink));
 616         if (!es)
 617             return E_OUTOFMEMORY;
 618         if (FAILED(IUnknown_QueryInterface(punk, riid, (LPVOID *)&es->interfaces.pITfTextEditSink)))
 619         {
 620             HeapFree(GetProcessHeap(),0,es);
 621             return CONNECT_E_CANNOTCONNECT;
 622         }
 623         list_add_head(&This->pTextEditSink ,&es->entry);
 624         *pdwCookie = generate_Cookie(COOKIE_MAGIC_CONTEXTSINK, es);
 625     }
 626     else
 627     {
 628         FIXME("(%p) Unhandled Sink: %s\n",This,debugstr_guid(riid));
 629         return E_NOTIMPL;
 630     }
 631
 632     TRACE("cookie %x\n",*pdwCookie);
 633     return S_OK;
 634 }
 635
 636 static HRESULT WINAPI ContextSource_UnadviseSink(ITfSource *iface, DWORD pdwCookie)
 637 {
 638     Context *This = impl_from_ITfSource(iface);
 639     ContextSink *sink;
 640
 641     TRACE("(%p) %x\n",This,pdwCookie);
 642
 643     if (get_Cookie_magic(pdwCookie)!=COOKIE_MAGIC_CONTEXTSINK)
 644         return E_INVALIDARG;
 645
 646     sink = remove_Cookie(pdwCookie);
 647     if (!sink)
 648         return CONNECT_E_NOCONNECTION;
 649
 650     list_remove(&sink->entry);
 651     free_sink(sink);
 652
 653     return S_OK;
 654 }
 655
 656 static const ITfSourceVtbl ContextSourceVtbl =
 657 {
 658     ContextSource_QueryInterface,
 659     ContextSource_AddRef,
 660     ContextSource_Release,
 661     ContextSource_AdviseSink,
 662     ContextSource_UnadviseSink
 663 };
 664
 665 /*****************************************************
 666  * ITfInsertAtSelection functions
 667  *****************************************************/
 668 static HRESULT WINAPI InsertAtSelection_QueryInterface(ITfInsertAtSelection *iface, REFIID iid, LPVOID *ppvOut)
 669 {
 670     Context *This = impl_from_ITfInsertAtSelection(iface);
 671     return ITfContext_QueryInterface(&This->ITfContext_iface, iid, ppvOut);
 672 }
 673
 674 static ULONG WINAPI InsertAtSelection_AddRef(ITfInsertAtSelection *iface)
 675 {
 676     Context *This = impl_from_ITfInsertAtSelection(iface);
 677     return ITfContext_AddRef(&This->ITfContext_iface);
 678 }
 679
 680 static ULONG WINAPI InsertAtSelection_Release(ITfInsertAtSelection *iface)
 681 {
 682     Context *This = impl_from_ITfInsertAtSelection(iface);
 683     return ITfContext_Release(&This->ITfContext_iface);
 684 }
 685
 686 static HRESULT WINAPI InsertAtSelection_InsertTextAtSelection(
 687         ITfInsertAtSelection *iface, TfEditCookie ec, DWORD dwFlags,
 688         const WCHAR *pchText, LONG cch, ITfRange **ppRange)
 689 {
 690     Context *This = impl_from_ITfInsertAtSelection(iface);
 691     EditCookie *cookie;
 692     LONG acpStart, acpEnd;
 693     TS_TEXTCHANGE change;
 694     HRESULT hr;
 695
 696     TRACE("(%p) %i %x %s %p\n",This, ec, dwFlags, debugstr_wn(pchText,cch), ppRange);
 697
 698     if (!This->connected)
 699         return TF_E_DISCONNECTED;
 700
 701     if (get_Cookie_magic(ec)!=COOKIE_MAGIC_EDITCOOKIE)
 702         return TF_E_NOLOCK;
 703
 704     cookie = get_Cookie_data(ec);
 705
 706     if ((cookie->lockType & TS_LF_READWRITE) != TS_LF_READWRITE )
 707         return TS_E_READONLY;
 708
 709     if (!This->pITextStoreACP)
 710     {
 711         FIXME("Context does not have a ITextStoreACP\n");
 712         return E_NOTIMPL;
 713     }
 714
 715     hr = ITextStoreACP_InsertTextAtSelection(This->pITextStoreACP, dwFlags, pchText, cch, &acpStart, &acpEnd, &change);
 716     if (SUCCEEDED(hr))
 717         Range_Constructor(&This->ITfContext_iface, This->pITextStoreACP, cookie->lockType, change.acpStart, change.acpNewEnd, ppRange);
 718
 719     return hr;
 720 }
 721
 722 static HRESULT WINAPI InsertAtSelection_InsertEmbeddedAtSelection(
 723         ITfInsertAtSelection *iface, TfEditCookie ec, DWORD dwFlags,
 724         IDataObject *pDataObject, ITfRange **ppRange)
 725 {
 726     Context *This = impl_from_ITfInsertAtSelection(iface);
 727     FIXME("STUB:(%p)\n",This);
 728     return E_NOTIMPL;
 729 }
 730
 731 static const ITfInsertAtSelectionVtbl InsertAtSelectionVtbl =
 732 {
 733     InsertAtSelection_QueryInterface,
 734     InsertAtSelection_AddRef,
 735     InsertAtSelection_Release,
 736     InsertAtSelection_InsertTextAtSelection,
 737     InsertAtSelection_InsertEmbeddedAtSelection,
 738 };
 739
 740 /*****************************************************
 741  * ITfSourceSingle functions
 742  *****************************************************/
 743 static HRESULT WINAPI SourceSingle_QueryInterface(ITfSourceSingle *iface, REFIID iid, LPVOID *ppvOut)
 744 {
 745     Context *This = impl_from_ITfSourceSingle(iface);
 746     return ITfContext_QueryInterface(&This->ITfContext_iface, iid, ppvOut);
 747 }
 748
 749 static ULONG WINAPI SourceSingle_AddRef(ITfSourceSingle *iface)
 750 {
 751     Context *This = impl_from_ITfSourceSingle(iface);
 752     return ITfContext_AddRef(&This->ITfContext_iface);
 753 }
 754
 755 static ULONG WINAPI SourceSingle_Release(ITfSourceSingle *iface)
 756 {
 757     Context *This = impl_from_ITfSourceSingle(iface);
 758     return ITfContext_Release(&This->ITfContext_iface);
 759 }
 760
 761 static HRESULT WINAPI SourceSingle_AdviseSingleSink( ITfSourceSingle *iface,
 762     TfClientId tid, REFIID riid, IUnknown *punk)
 763 {
 764     Context *This = impl_from_ITfSourceSingle(iface);
 765     FIXME("STUB:(%p) %i %s %p\n",This, tid, debugstr_guid(riid),punk);
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI SourceSingle_UnadviseSingleSink( ITfSourceSingle *iface,
 770     TfClientId tid, REFIID riid)
 771 {
 772     Context *This = impl_from_ITfSourceSingle(iface);
 773     FIXME("STUB:(%p) %i %s\n",This, tid, debugstr_guid(riid));
 774     return E_NOTIMPL;
 775 }
 776
 777 static const ITfSourceSingleVtbl ContextSourceSingleVtbl =
 778 {
 779     SourceSingle_QueryInterface,
 780     SourceSingle_AddRef,
 781     SourceSingle_Release,
 782     SourceSingle_AdviseSingleSink,
 783     SourceSingle_UnadviseSingleSink,
 784 };
 785
 786 /**************************************************************************
 787  *  ITextStoreACPSink
 788  **************************************************************************/
 789
 790 static HRESULT WINAPI TextStoreACPSink_QueryInterface(ITextStoreACPSink *iface, REFIID iid, LPVOID *ppvOut)
 791 {
 792     Context *This = impl_from_ITextStoreACPSink(iface);
 793
 794     *ppvOut = NULL;
 795
 796     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITextStoreACPSink))
 797     {
 798         *ppvOut = &This->ITextStoreACPSink_iface;
 799     }
 800     else if (IsEqualIID(iid, &IID_ITextStoreACPServices))
 801         *ppvOut = &This->ITextStoreACPServices_iface;
 802
 803     if (*ppvOut)
 804     {
 805         ITextStoreACPSink_AddRef(iface);
 806         return S_OK;
 807     }
 808
 809     WARN("unsupported interface: %s\n", debugstr_guid(iid));
 810     return E_NOINTERFACE;
 811 }
 812
 813 static ULONG WINAPI TextStoreACPSink_AddRef(ITextStoreACPSink *iface)
 814 {
 815     Context *This = impl_from_ITextStoreACPSink(iface);
 816     return ITfContext_AddRef(&This->ITfContext_iface);
 817 }
 818
 819 static ULONG WINAPI TextStoreACPSink_Release(ITextStoreACPSink *iface)
 820 {
 821     Context *This = impl_from_ITextStoreACPSink(iface);
 822     return ITfContext_Release(&This->ITfContext_iface);
 823 }
 824
 825 /*****************************************************
 826  * ITextStoreACPSink functions
 827  *****************************************************/
 828
 829 static HRESULT WINAPI TextStoreACPSink_OnTextChange(ITextStoreACPSink *iface,
 830         DWORD dwFlags, const TS_TEXTCHANGE *pChange)
 831 {
 832     Context *This = impl_from_ITextStoreACPSink(iface);
 833     FIXME("STUB:(%p)\n",This);
 834     return E_NOTIMPL;
 835 }
 836
 837 static HRESULT WINAPI TextStoreACPSink_OnSelectionChange(ITextStoreACPSink *iface)
 838 {
 839     Context *This = impl_from_ITextStoreACPSink(iface);
 840     FIXME("STUB:(%p)\n",This);
 841     return E_NOTIMPL;
 842 }
 843
 844 static HRESULT WINAPI TextStoreACPSink_OnLayoutChange(ITextStoreACPSink *iface,
 845     TsLayoutCode lcode, TsViewCookie vcView)
 846 {
 847     Context *This = impl_from_ITextStoreACPSink(iface);
 848     FIXME("STUB:(%p)\n",This);
 849     return E_NOTIMPL;
 850 }
 851
 852 static HRESULT WINAPI TextStoreACPSink_OnStatusChange(ITextStoreACPSink *iface,
 853         DWORD dwFlags)
 854 {
 855     Context *This = impl_from_ITextStoreACPSink(iface);
 856     HRESULT hr, hrSession;
 857
 858     TRACE("(%p) %x\n",This, dwFlags);
 859
 860     if (!This->pITextStoreACP)
 861     {
 862         FIXME("Context does not have a ITextStoreACP\n");
 863         return E_NOTIMPL;
 864     }
 865
 866     hr = ITextStoreACP_RequestLock(This->pITextStoreACP, TS_LF_READ, &hrSession);
 867
 868     if(SUCCEEDED(hr) && SUCCEEDED(hrSession))
 869         This->documentStatus.dwDynamicFlags = dwFlags;
 870
 871     return S_OK;
 872 }
 873
 874 static HRESULT WINAPI TextStoreACPSink_OnAttrsChange(ITextStoreACPSink *iface,
 875         LONG acpStart, LONG acpEnd, ULONG cAttrs, const TS_ATTRID *paAttrs)
 876 {
 877     Context *This = impl_from_ITextStoreACPSink(iface);
 878     FIXME("STUB:(%p)\n",This);
 879     return E_NOTIMPL;
 880 }
 881
 882 static HRESULT WINAPI TextStoreACPSink_OnLockGranted(ITextStoreACPSink *iface,
 883         DWORD dwLockFlags)
 884 {
 885     Context *This = impl_from_ITextStoreACPSink(iface);
 886     HRESULT hr;
 887     EditCookie *cookie,*sinkcookie;
 888     TfEditCookie ec;
 889     struct list *cursor;
 890
 891     TRACE("(%p) %x\n",This, dwLockFlags);
 892
 893     if (!This->currentEditSession)
 894     {
 895         FIXME("OnLockGranted called for something other than an EditSession\n");
 896         return S_OK;
 897     }
 898
 899     cookie = HeapAlloc(GetProcessHeap(),0,sizeof(EditCookie));
 900     if (!cookie)
 901         return E_OUTOFMEMORY;
 902
 903     sinkcookie = HeapAlloc(GetProcessHeap(),0,sizeof(EditCookie));
 904     if (!sinkcookie)
 905     {
 906         HeapFree(GetProcessHeap(), 0, cookie);
 907         return E_OUTOFMEMORY;
 908     }
 909
 910     cookie->lockType = dwLockFlags;
 911     cookie->pOwningContext = This;
 912     ec = generate_Cookie(COOKIE_MAGIC_EDITCOOKIE, cookie);
 913
 914     hr = ITfEditSession_DoEditSession(This->currentEditSession, ec);
 915
 916     if ((dwLockFlags&TS_LF_READWRITE) == TS_LF_READWRITE)
 917     {
 918         TfEditCookie sc;
 919
 920         sinkcookie->lockType = TS_LF_READ;
 921         sinkcookie->pOwningContext = This;
 922         sc = generate_Cookie(COOKIE_MAGIC_EDITCOOKIE, sinkcookie);
 923
 924         /*TODO: implement ITfEditRecord */
 925         LIST_FOR_EACH(cursor, &This->pTextEditSink)
 926         {
 927             ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
 928             ITfTextEditSink_OnEndEdit(sink->interfaces.pITfTextEditSink,
 929                                       (ITfContext*) &This->ITfContext_iface, sc, NULL);
 930         }
 931         sinkcookie = remove_Cookie(sc);
 932     }
 933     HeapFree(GetProcessHeap(),0,sinkcookie);
 934
 935     ITfEditSession_Release(This->currentEditSession);
 936     This->currentEditSession = NULL;
 937
 938     /* Edit Cookie is only valid during the edit session */
 939     cookie = remove_Cookie(ec);
 940     HeapFree(GetProcessHeap(),0,cookie);
 941
 942     return hr;
 943 }
 944
 945 static HRESULT WINAPI TextStoreACPSink_OnStartEditTransaction(ITextStoreACPSink *iface)
 946 {
 947     Context *This = impl_from_ITextStoreACPSink(iface);
 948     FIXME("STUB:(%p)\n",This);
 949     return E_NOTIMPL;
 950 }
 951
 952 static HRESULT WINAPI TextStoreACPSink_OnEndEditTransaction(ITextStoreACPSink *iface)
 953 {
 954     Context *This = impl_from_ITextStoreACPSink(iface);
 955     FIXME("STUB:(%p)\n",This);
 956     return E_NOTIMPL;
 957 }
 958
 959 static const ITextStoreACPSinkVtbl TextStoreACPSinkVtbl =
 960 {
 961     TextStoreACPSink_QueryInterface,
 962     TextStoreACPSink_AddRef,
 963     TextStoreACPSink_Release,
 964     TextStoreACPSink_OnTextChange,
 965     TextStoreACPSink_OnSelectionChange,
 966     TextStoreACPSink_OnLayoutChange,
 967     TextStoreACPSink_OnStatusChange,
 968     TextStoreACPSink_OnAttrsChange,
 969     TextStoreACPSink_OnLockGranted,
 970     TextStoreACPSink_OnStartEditTransaction,
 971     TextStoreACPSink_OnEndEditTransaction
 972 };
 973
 974 static HRESULT WINAPI TextStoreACPServices_QueryInterface(ITextStoreACPServices *iface, REFIID riid, void **obj)
 975 {
 976     Context *This = impl_from_ITextStoreACPServices(iface);
 977     return ITextStoreACPSink_QueryInterface(&This->ITextStoreACPSink_iface, riid, obj);
 978 }
 979
 980 static ULONG WINAPI TextStoreACPServices_AddRef(ITextStoreACPServices *iface)
 981 {
 982     Context *This = impl_from_ITextStoreACPServices(iface);
 983     return ITextStoreACPSink_AddRef(&This->ITextStoreACPSink_iface);
 984 }
 985
 986 static ULONG WINAPI TextStoreACPServices_Release(ITextStoreACPServices *iface)
 987 {
 988     Context *This = impl_from_ITextStoreACPServices(iface);
 989     return ITextStoreACPSink_Release(&This->ITextStoreACPSink_iface);
 990 }
 991
 992 static HRESULT WINAPI TextStoreACPServices_Serialize(ITextStoreACPServices *iface, ITfProperty *prop, ITfRange *range,
 993     TF_PERSISTENT_PROPERTY_HEADER_ACP *header, IStream *stream)
 994 {
 995     Context *This = impl_from_ITextStoreACPServices(iface);
 996
 997     FIXME("stub: %p %p %p %p %p\n", This, prop, range, header, stream);
 998
 999     return E_NOTIMPL;
1000 }
1001
1002 static HRESULT WINAPI TextStoreACPServices_Unserialize(ITextStoreACPServices *iface, ITfProperty *prop,
1003     const TF_PERSISTENT_PROPERTY_HEADER_ACP *header, IStream *stream, ITfPersistentPropertyLoaderACP *loader)
1004 {
1005     Context *This = impl_from_ITextStoreACPServices(iface);
1006
1007     FIXME("stub: %p %p %p %p %p\n", This, prop, header, stream, loader);
1008
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI TextStoreACPServices_ForceLoadProperty(ITextStoreACPServices *iface, ITfProperty *prop)
1013 {
1014     Context *This = impl_from_ITextStoreACPServices(iface);
1015
1016     FIXME("stub: %p %p\n", This, prop);
1017
1018     return E_NOTIMPL;
1019 }
1020
1021 static HRESULT WINAPI TextStoreACPServices_CreateRange(ITextStoreACPServices *iface,
1022     LONG start, LONG end, ITfRangeACP **range)
1023 {
1024     Context *This = impl_from_ITextStoreACPServices(iface);
1025
1026     FIXME("stub: %p %d %d %p\n", This, start, end, range);
1027
1028     return S_OK;
1029 }
1030
1031 static const ITextStoreACPServicesVtbl TextStoreACPServicesVtbl =
1032 {
1033     TextStoreACPServices_QueryInterface,
1034     TextStoreACPServices_AddRef,
1035     TextStoreACPServices_Release,
1036     TextStoreACPServices_Serialize,
1037     TextStoreACPServices_Unserialize,
1038     TextStoreACPServices_ForceLoadProperty,
1039     TextStoreACPServices_CreateRange
1040 };
1041
1042 HRESULT Context_Constructor(TfClientId tidOwner, IUnknown *punk, ITfDocumentMgr *mgr, ITfContext **ppOut, TfEditCookie *pecTextStore)
1043 {
1044     Context *This;
1045     EditCookie *cookie;
1046
1047     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(Context));
1048     if (This == NULL)
1049         return E_OUTOFMEMORY;
1050
1051     cookie = HeapAlloc(GetProcessHeap(),0,sizeof(EditCookie));
1052     if (cookie == NULL)
1053     {
1054         HeapFree(GetProcessHeap(),0,This);
1055         return E_OUTOFMEMORY;
1056     }
1057
1058     TRACE("(%p) %x %p %p %p\n",This, tidOwner, punk, ppOut, pecTextStore);
1059
1060     This->ITfContext_iface.lpVtbl= &ContextVtbl;
1061     This->ITfSource_iface.lpVtbl = &ContextSourceVtbl;
1062     This->ITfInsertAtSelection_iface.lpVtbl = &InsertAtSelectionVtbl;
1063     This->ITfSourceSingle_iface.lpVtbl = &ContextSourceSingleVtbl;
1064     This->ITextStoreACPSink_iface.lpVtbl = &TextStoreACPSinkVtbl;
1065     This->ITextStoreACPServices_iface.lpVtbl = &TextStoreACPServicesVtbl;
1066     This->refCount = 1;
1067     This->tidOwner = tidOwner;
1068     This->connected = FALSE;
1069     This->manager = mgr;
1070
1071     CompartmentMgr_Constructor((IUnknown*)&This->ITfContext_iface, &IID_IUnknown, (IUnknown**)&This->CompartmentMgr);
1072
1073     cookie->lockType = TF_ES_READ;
1074     cookie->pOwningContext = This;
1075
1076     if (punk)
1077     {
1078         IUnknown_QueryInterface(punk, &IID_ITextStoreACP,
1079                           (LPVOID*)&This->pITextStoreACP);
1080
1081         IUnknown_QueryInterface(punk, &IID_ITfContextOwnerCompositionSink,
1082                                 (LPVOID*)&This->pITfContextOwnerCompositionSink);
1083
1084         if (!This->pITextStoreACP && !This->pITfContextOwnerCompositionSink)
1085             FIXME("Unhandled pUnk\n");
1086     }
1087
1088     This->defaultCookie = generate_Cookie(COOKIE_MAGIC_EDITCOOKIE,cookie);
1089     *pecTextStore = This->defaultCookie;
1090
1091     list_init(&This->pContextKeyEventSink);
1092     list_init(&This->pEditTransactionSink);
1093     list_init(&This->pStatusSink);
1094     list_init(&This->pTextEditSink);
1095     list_init(&This->pTextLayoutSink);
1096
1097     *ppOut = &This->ITfContext_iface;
1098     TRACE("returning %p\n", *ppOut);
1099
1100     return S_OK;
1101 }
1102
1103 HRESULT Context_Initialize(ITfContext *iface, ITfDocumentMgr *manager)
1104 {
1105     Context *This = impl_from_ITfContext(iface);
1106
1107     if (This->pITextStoreACP)
1108         ITextStoreACP_AdviseSink(This->pITextStoreACP, &IID_ITextStoreACPSink,
1109             (IUnknown*)&This->ITextStoreACPSink_iface, TS_AS_ALL_SINKS);
1110     This->connected = TRUE;
1111     This->manager = manager;
1112     return S_OK;
1113 }
1114
1115 HRESULT Context_Uninitialize(ITfContext *iface)
1116 {
1117     Context *This = impl_from_ITfContext(iface);
1118
1119     if (This->pITextStoreACP)
1120         ITextStoreACP_UnadviseSink(This->pITextStoreACP, (IUnknown*)&This->ITextStoreACPSink_iface);
1121     This->connected = FALSE;
1122     This->manager = NULL;
1123     return S_OK;
1124 }