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