git.oblomov.eu Git - wine/blob - dlls/riched20/richole.c

   1 /*
   2  * RichEdit GUIDs and OLE interface
   3  *
   4  * Copyright 2004 by Krzysztof Foltman
   5  * Copyright 2004 Aric Stewart
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #define NONAMELESSUNION
  25 #define NONAMELESSSTRUCT
  26 #define COBJMACROS
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "winuser.h"
  32 #include "ole2.h"
  33 #include "richole.h"
  34 #include "editor.h"
  35 #include "tom.h"
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
  39
  40 /* there is no way to be consistent across different sets of headers - mingw, Wine, Win32 SDK*/
  41
  42 /* FIXME: the next 6 lines should be in textserv.h */
  43 #include "initguid.h"
  44 #define TEXTSERV_GUID(name, l, w1, w2, b1, b2) \
  45     DEFINE_GUID(name, l, w1, w2, b1, b2, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5)
  46
  47 TEXTSERV_GUID(IID_ITextServices, 0x8d33f740, 0xcf58, 0x11ce, 0xa8, 0x9d);
  48 TEXTSERV_GUID(IID_ITextHost, 0xc5bdd8d0, 0xd26e, 0x11ce, 0xa8, 0x9e);
  49 TEXTSERV_GUID(IID_ITextHost2, 0xc5bdd8d0, 0xd26e, 0x11ce, 0xa8, 0x9e);
  50 DEFINE_GUID(IID_ITextDocument, 0x8cc497c0, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  51 DEFINE_GUID(IID_ITextRange, 0x8cc497c2, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  52 DEFINE_GUID(IID_ITextSelection, 0x8cc497c1, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  53
  54 typedef struct ITextSelectionImpl ITextSelectionImpl;
  55 typedef struct IOleClientSiteImpl IOleClientSiteImpl;
  56
  57 typedef struct IRichEditOleImpl {
  58     const IRichEditOleVtbl *lpRichEditOleVtbl;
  59     const ITextDocumentVtbl *lpTextDocumentVtbl;
  60     LONG ref;
  61
  62     ME_TextEditor *editor;
  63     ITextSelectionImpl *txtSel;
  64     IOleClientSiteImpl *clientSite;
  65 } IRichEditOleImpl;
  66
  67 struct ITextSelectionImpl {
  68     const ITextSelectionVtbl *lpVtbl;
  69     LONG ref;
  70
  71     IRichEditOleImpl *reOle;
  72 };
  73
  74 struct IOleClientSiteImpl {
  75     const IOleClientSiteVtbl *lpVtbl;
  76     LONG ref;
  77
  78     IRichEditOleImpl *reOle;
  79 };
  80
  81 static inline IRichEditOleImpl *impl_from_IRichEditOle(IRichEditOle *iface)
  82 {
  83     return (IRichEditOleImpl *)((BYTE*)iface - FIELD_OFFSET(IRichEditOleImpl, lpRichEditOleVtbl));
  84 }
  85
  86 static inline IRichEditOleImpl *impl_from_ITextDocument(ITextDocument *iface)
  87 {
  88     return (IRichEditOleImpl *)((BYTE*)iface - FIELD_OFFSET(IRichEditOleImpl, lpTextDocumentVtbl));
  89 }
  90
  91 static HRESULT WINAPI
  92 IRichEditOle_fnQueryInterface(IRichEditOle *me, REFIID riid, LPVOID *ppvObj)
  93 {
  94     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
  95
  96     TRACE("%p %s\n", This, debugstr_guid(riid) );
  97
  98     *ppvObj = NULL;
  99     if (IsEqualGUID(riid, &IID_IUnknown) ||
 100         IsEqualGUID(riid, &IID_IRichEditOle))
 101         *ppvObj = &This->lpRichEditOleVtbl;
 102     else if (IsEqualGUID(riid, &IID_ITextDocument))
 103         *ppvObj = &This->lpTextDocumentVtbl;
 104     if (*ppvObj)
 105     {
 106         IRichEditOle_AddRef(me);
 107         return S_OK;
 108     }
 109     FIXME("%p: unhandled interface %s\n", This, debugstr_guid(riid) );
 110
 111     return E_NOINTERFACE;
 112 }
 113
 114 static ULONG WINAPI
 115 IRichEditOle_fnAddRef(IRichEditOle *me)
 116 {
 117     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 118     ULONG ref = InterlockedIncrement( &This->ref );
 119
 120     TRACE("%p ref = %u\n", This, ref);
 121
 122     return ref;
 123 }
 124
 125 static ULONG WINAPI
 126 IRichEditOle_fnRelease(IRichEditOle *me)
 127 {
 128     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 129     ULONG ref = InterlockedDecrement(&This->ref);
 130
 131     TRACE ("%p ref=%u\n", This, ref);
 132
 133     if (!ref)
 134     {
 135         TRACE ("Destroying %p\n", This);
 136         This->txtSel->reOle = NULL;
 137         ITextSelection_Release((ITextSelection *) This->txtSel);
 138         IOleClientSite_Release((IOleClientSite *) This->clientSite);
 139         heap_free(This);
 140     }
 141     return ref;
 142 }
 143
 144 static HRESULT WINAPI
 145 IRichEditOle_fnActivateAs(IRichEditOle *me, REFCLSID rclsid, REFCLSID rclsidAs)
 146 {
 147     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 148     FIXME("stub %p\n",This);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI
 153 IRichEditOle_fnContextSensitiveHelp(IRichEditOle *me, BOOL fEnterMode)
 154 {
 155     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 156     FIXME("stub %p\n",This);
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI
 161 IRichEditOle_fnConvertObject(IRichEditOle *me, LONG iob,
 162                REFCLSID rclsidNew, LPCSTR lpstrUserTypeNew)
 163 {
 164     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 165     FIXME("stub %p\n",This);
 166     return E_NOTIMPL;
 167 }
 168
 169 static HRESULT WINAPI
 170 IOleClientSite_fnQueryInterface(IOleClientSite *me, REFIID riid, LPVOID *ppvObj)
 171 {
 172     TRACE("%p %s\n", me, debugstr_guid(riid) );
 173
 174     *ppvObj = NULL;
 175     if (IsEqualGUID(riid, &IID_IUnknown) ||
 176         IsEqualGUID(riid, &IID_IOleClientSite))
 177         *ppvObj = me;
 178     if (*ppvObj)
 179     {
 180         IOleClientSite_AddRef(me);
 181         return S_OK;
 182     }
 183     FIXME("%p: unhandled interface %s\n", me, debugstr_guid(riid) );
 184
 185     return E_NOINTERFACE;
 186 }
 187
 188 static ULONG WINAPI
 189 IOleClientSite_fnAddRef(IOleClientSite *me)
 190 {
 191     IOleClientSiteImpl *This = (IOleClientSiteImpl *) me;
 192     return InterlockedIncrement(&This->ref);
 193 }
 194
 195 static ULONG WINAPI
 196 IOleClientSite_fnRelease(IOleClientSite *me)
 197 {
 198     IOleClientSiteImpl *This = (IOleClientSiteImpl *) me;
 199     ULONG ref = InterlockedDecrement(&This->ref);
 200     if (ref == 0)
 201         heap_free(This);
 202     return ref;
 203 }
 204
 205 static HRESULT WINAPI
 206 IOleClientSite_fnSaveObject(IOleClientSite *me)
 207 {
 208     IOleClientSiteImpl *This = (IOleClientSiteImpl *) me;
 209     if (!This->reOle)
 210         return CO_E_RELEASED;
 211
 212     FIXME("stub %p\n",me);
 213     return E_NOTIMPL;
 214 }
 215
 216
 217 static HRESULT WINAPI
 218 IOleClientSite_fnGetMoniker(IOleClientSite *me, DWORD dwAssign, DWORD dwWhichMoniker,
 219     IMoniker **ppmk)
 220 {
 221     IOleClientSiteImpl *This = (IOleClientSiteImpl *) me;
 222     if (!This->reOle)
 223         return CO_E_RELEASED;
 224
 225     FIXME("stub %p\n",me);
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI
 230 IOleClientSite_fnGetContainer(IOleClientSite *me, IOleContainer **ppContainer)
 231 {
 232     IOleClientSiteImpl *This = (IOleClientSiteImpl *) me;
 233     if (!This->reOle)
 234         return CO_E_RELEASED;
 235
 236     FIXME("stub %p\n",me);
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI
 241 IOleClientSite_fnShowObject(IOleClientSite *me)
 242 {
 243     IOleClientSiteImpl *This = (IOleClientSiteImpl *) me;
 244     if (!This->reOle)
 245         return CO_E_RELEASED;
 246
 247     FIXME("stub %p\n",me);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI
 252 IOleClientSite_fnOnShowWindow(IOleClientSite *me, BOOL fShow)
 253 {
 254     IOleClientSiteImpl *This = (IOleClientSiteImpl *) me;
 255     if (!This->reOle)
 256         return CO_E_RELEASED;
 257
 258     FIXME("stub %p\n",me);
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT WINAPI
 263 IOleClientSite_fnRequestNewObjectLayout(IOleClientSite *me)
 264 {
 265     IOleClientSiteImpl *This = (IOleClientSiteImpl *) me;
 266     if (!This->reOle)
 267         return CO_E_RELEASED;
 268
 269     FIXME("stub %p\n",me);
 270     return E_NOTIMPL;
 271 }
 272
 273 static const IOleClientSiteVtbl ocst = {
 274     IOleClientSite_fnQueryInterface,
 275     IOleClientSite_fnAddRef,
 276     IOleClientSite_fnRelease,
 277     IOleClientSite_fnSaveObject,
 278     IOleClientSite_fnGetMoniker,
 279     IOleClientSite_fnGetContainer,
 280     IOleClientSite_fnShowObject,
 281     IOleClientSite_fnOnShowWindow,
 282     IOleClientSite_fnRequestNewObjectLayout
 283 };
 284
 285 static IOleClientSiteImpl *
 286 CreateOleClientSite(IRichEditOleImpl *reOle)
 287 {
 288     IOleClientSiteImpl *clientSite = heap_alloc(sizeof *clientSite);
 289     if (!clientSite)
 290         return NULL;
 291
 292     clientSite->lpVtbl = &ocst;
 293     clientSite->ref = 1;
 294     clientSite->reOle = reOle;
 295     return clientSite;
 296 }
 297
 298 static HRESULT WINAPI
 299 IRichEditOle_fnGetClientSite(IRichEditOle *me,
 300                LPOLECLIENTSITE *lplpolesite)
 301 {
 302     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 303
 304     TRACE("%p,%p\n",This, lplpolesite);
 305
 306     if(!lplpolesite)
 307         return E_INVALIDARG;
 308     *lplpolesite = (IOleClientSite *) This->clientSite;
 309     IOleClientSite_fnAddRef(*lplpolesite);
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI
 314 IRichEditOle_fnGetClipboardData(IRichEditOle *me, CHARRANGE *lpchrg,
 315                DWORD reco, LPDATAOBJECT *lplpdataobj)
 316 {
 317     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 318     ME_Cursor start;
 319     int nChars;
 320
 321     TRACE("(%p,%p,%d)\n",This, lpchrg, reco);
 322     if(!lplpdataobj)
 323         return E_INVALIDARG;
 324     if(!lpchrg) {
 325         int nFrom, nTo, nStartCur = ME_GetSelectionOfs(This->editor, &nFrom, &nTo);
 326         start = This->editor->pCursors[nStartCur];
 327         nChars = nTo - nFrom;
 328     } else {
 329         ME_CursorFromCharOfs(This->editor, lpchrg->cpMin, &start);
 330         nChars = lpchrg->cpMax - lpchrg->cpMin;
 331     }
 332     return ME_GetDataObject(This->editor, &start, nChars, lplpdataobj);
 333 }
 334
 335 static LONG WINAPI IRichEditOle_fnGetLinkCount(IRichEditOle *me)
 336 {
 337     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 338     FIXME("stub %p\n",This);
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT WINAPI
 343 IRichEditOle_fnGetObject(IRichEditOle *me, LONG iob,
 344                REOBJECT *lpreobject, DWORD dwFlags)
 345 {
 346     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 347     FIXME("stub %p\n",This);
 348     return E_NOTIMPL;
 349 }
 350
 351 static LONG WINAPI
 352 IRichEditOle_fnGetObjectCount(IRichEditOle *me)
 353 {
 354     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 355     FIXME("stub %p\n",This);
 356     return 0;
 357 }
 358
 359 static HRESULT WINAPI
 360 IRichEditOle_fnHandsOffStorage(IRichEditOle *me, LONG iob)
 361 {
 362     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 363     FIXME("stub %p\n",This);
 364     return E_NOTIMPL;
 365 }
 366
 367 static HRESULT WINAPI
 368 IRichEditOle_fnImportDataObject(IRichEditOle *me, LPDATAOBJECT lpdataobj,
 369                CLIPFORMAT cf, HGLOBAL hMetaPict)
 370 {
 371     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 372     FIXME("stub %p\n",This);
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI
 377 IRichEditOle_fnInPlaceDeactivate(IRichEditOle *me)
 378 {
 379     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 380     FIXME("stub %p\n",This);
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT WINAPI
 385 IRichEditOle_fnInsertObject(IRichEditOle *me, REOBJECT *reo)
 386 {
 387     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 388     TRACE("(%p,%p)\n", This, reo);
 389
 390     if (reo->cbStruct < sizeof(*reo)) return STG_E_INVALIDPARAMETER;
 391
 392     ME_InsertOLEFromCursor(This->editor, reo, 0);
 393     ME_CommitUndo(This->editor);
 394     ME_UpdateRepaint(This->editor, FALSE);
 395     return S_OK;
 396 }
 397
 398 static HRESULT WINAPI IRichEditOle_fnSaveCompleted(IRichEditOle *me, LONG iob,
 399                LPSTORAGE lpstg)
 400 {
 401     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 402     FIXME("stub %p\n",This);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI
 407 IRichEditOle_fnSetDvaspect(IRichEditOle *me, LONG iob, DWORD dvaspect)
 408 {
 409     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 410     FIXME("stub %p\n",This);
 411     return E_NOTIMPL;
 412 }
 413
 414 static HRESULT WINAPI IRichEditOle_fnSetHostNames(IRichEditOle *me,
 415                LPCSTR lpstrContainerApp, LPCSTR lpstrContainerObj)
 416 {
 417     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 418     FIXME("stub %p %s %s\n",This, lpstrContainerApp, lpstrContainerObj);
 419     return E_NOTIMPL;
 420 }
 421
 422 static HRESULT WINAPI
 423 IRichEditOle_fnSetLinkAvailable(IRichEditOle *me, LONG iob, BOOL fAvailable)
 424 {
 425     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 426     FIXME("stub %p\n",This);
 427     return E_NOTIMPL;
 428 }
 429
 430 static const IRichEditOleVtbl revt = {
 431     IRichEditOle_fnQueryInterface,
 432     IRichEditOle_fnAddRef,
 433     IRichEditOle_fnRelease,
 434     IRichEditOle_fnGetClientSite,
 435     IRichEditOle_fnGetObjectCount,
 436     IRichEditOle_fnGetLinkCount,
 437     IRichEditOle_fnGetObject,
 438     IRichEditOle_fnInsertObject,
 439     IRichEditOle_fnConvertObject,
 440     IRichEditOle_fnActivateAs,
 441     IRichEditOle_fnSetHostNames,
 442     IRichEditOle_fnSetLinkAvailable,
 443     IRichEditOle_fnSetDvaspect,
 444     IRichEditOle_fnHandsOffStorage,
 445     IRichEditOle_fnSaveCompleted,
 446     IRichEditOle_fnInPlaceDeactivate,
 447     IRichEditOle_fnContextSensitiveHelp,
 448     IRichEditOle_fnGetClipboardData,
 449     IRichEditOle_fnImportDataObject
 450 };
 451
 452 static HRESULT WINAPI
 453 ITextDocument_fnQueryInterface(ITextDocument* me, REFIID riid,
 454     void** ppvObject)
 455 {
 456     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 457     return IRichEditOle_fnQueryInterface((IRichEditOle*)&This->lpRichEditOleVtbl,
 458             riid, ppvObject);
 459 }
 460
 461 static ULONG WINAPI
 462 ITextDocument_fnAddRef(ITextDocument* me)
 463 {
 464     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 465     return IRichEditOle_fnAddRef((IRichEditOle*)&This->lpRichEditOleVtbl);
 466 }
 467
 468 static ULONG WINAPI
 469 ITextDocument_fnRelease(ITextDocument* me)
 470 {
 471     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 472     return IRichEditOle_fnRelease((IRichEditOle*)&This->lpRichEditOleVtbl);
 473 }
 474
 475 static HRESULT WINAPI
 476 ITextDocument_fnGetTypeInfoCount(ITextDocument* me,
 477     UINT* pctinfo)
 478 {
 479     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 480     FIXME("stub %p\n",This);
 481     return E_NOTIMPL;
 482 }
 483
 484 static HRESULT WINAPI
 485 ITextDocument_fnGetTypeInfo(ITextDocument* me, UINT iTInfo, LCID lcid,
 486     ITypeInfo** ppTInfo)
 487 {
 488     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 489     FIXME("stub %p\n",This);
 490     return E_NOTIMPL;
 491 }
 492
 493 static HRESULT WINAPI
 494 ITextDocument_fnGetIDsOfNames(ITextDocument* me, REFIID riid,
 495     LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
 496 {
 497     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 498     FIXME("stub %p\n",This);
 499     return E_NOTIMPL;
 500 }
 501
 502 static HRESULT WINAPI
 503 ITextDocument_fnInvoke(ITextDocument* me, DISPID dispIdMember,
 504     REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
 505     VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 506 {
 507     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 508     FIXME("stub %p\n",This);
 509     return E_NOTIMPL;
 510 }
 511
 512 static HRESULT WINAPI
 513 ITextDocument_fnGetName(ITextDocument* me, BSTR* pName)
 514 {
 515     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 516     FIXME("stub %p\n",This);
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI
 521 ITextDocument_fnGetSelection(ITextDocument* me, ITextSelection** ppSel)
 522 {
 523     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 524     TRACE("(%p)\n", me);
 525     *ppSel = (ITextSelection *) This->txtSel;
 526     ITextSelection_AddRef(*ppSel);
 527     return S_OK;
 528 }
 529
 530 static HRESULT WINAPI
 531 ITextDocument_fnGetStoryCount(ITextDocument* me, LONG* pCount)
 532 {
 533     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 534     FIXME("stub %p\n",This);
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI
 539 ITextDocument_fnGetStoryRanges(ITextDocument* me,
 540     ITextStoryRanges** ppStories)
 541 {
 542     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 543     FIXME("stub %p\n",This);
 544     return E_NOTIMPL;
 545 }
 546
 547 static HRESULT WINAPI
 548 ITextDocument_fnGetSaved(ITextDocument* me, LONG* pValue)
 549 {
 550     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 551     FIXME("stub %p\n",This);
 552     return E_NOTIMPL;
 553 }
 554
 555 static HRESULT WINAPI
 556 ITextDocument_fnSetSaved(ITextDocument* me, LONG Value)
 557 {
 558     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 559     FIXME("stub %p\n",This);
 560     return E_NOTIMPL;
 561 }
 562
 563 static HRESULT WINAPI
 564 ITextDocument_fnGetDefaultTabStop(ITextDocument* me, float* pValue)
 565 {
 566     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 567     FIXME("stub %p\n",This);
 568     return E_NOTIMPL;
 569 }
 570
 571 static HRESULT WINAPI
 572 ITextDocument_fnSetDefaultTabStop(ITextDocument* me, float Value)
 573 {
 574     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 575     FIXME("stub %p\n",This);
 576     return E_NOTIMPL;
 577 }
 578
 579 static HRESULT WINAPI
 580 ITextDocument_fnNew(ITextDocument* me)
 581 {
 582     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 583     FIXME("stub %p\n",This);
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI
 588 ITextDocument_fnOpen(ITextDocument* me, VARIANT* pVar, LONG Flags,
 589     LONG CodePage)
 590 {
 591     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 592     FIXME("stub %p\n",This);
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI
 597 ITextDocument_fnSave(ITextDocument* me, VARIANT* pVar, LONG Flags,
 598     LONG CodePage)
 599 {
 600     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 601     FIXME("stub %p\n",This);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI
 606 ITextDocument_fnFreeze(ITextDocument* me, LONG* pCount)
 607 {
 608     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 609     FIXME("stub %p\n",This);
 610     return E_NOTIMPL;
 611 }
 612
 613 static HRESULT WINAPI
 614 ITextDocument_fnUnfreeze(ITextDocument* me, LONG* pCount)
 615 {
 616     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 617     FIXME("stub %p\n",This);
 618     return E_NOTIMPL;
 619 }
 620
 621 static HRESULT WINAPI
 622 ITextDocument_fnBeginEditCollection(ITextDocument* me)
 623 {
 624     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 625     FIXME("stub %p\n",This);
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI
 630 ITextDocument_fnEndEditCollection(ITextDocument* me)
 631 {
 632     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 633     FIXME("stub %p\n",This);
 634     return E_NOTIMPL;
 635 }
 636
 637 static HRESULT WINAPI
 638 ITextDocument_fnUndo(ITextDocument* me, LONG Count, LONG* prop)
 639 {
 640     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 641     FIXME("stub %p\n",This);
 642     return E_NOTIMPL;
 643 }
 644
 645 static HRESULT WINAPI
 646 ITextDocument_fnRedo(ITextDocument* me, LONG Count, LONG* prop)
 647 {
 648     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 649     FIXME("stub %p\n",This);
 650     return E_NOTIMPL;
 651 }
 652
 653 static HRESULT WINAPI
 654 ITextDocument_fnRange(ITextDocument* me, LONG cp1, LONG cp2,
 655     ITextRange** ppRange)
 656 {
 657     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 658     FIXME("stub %p\n",This);
 659     return E_NOTIMPL;
 660 }
 661
 662 static HRESULT WINAPI
 663 ITextDocument_fnRangeFromPoint(ITextDocument* me, LONG x, LONG y,
 664     ITextRange** ppRange)
 665 {
 666     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 667     FIXME("stub %p\n",This);
 668     return E_NOTIMPL;
 669 }
 670
 671 static const ITextDocumentVtbl tdvt = {
 672     ITextDocument_fnQueryInterface,
 673     ITextDocument_fnAddRef,
 674     ITextDocument_fnRelease,
 675     ITextDocument_fnGetTypeInfoCount,
 676     ITextDocument_fnGetTypeInfo,
 677     ITextDocument_fnGetIDsOfNames,
 678     ITextDocument_fnInvoke,
 679     ITextDocument_fnGetName,
 680     ITextDocument_fnGetSelection,
 681     ITextDocument_fnGetStoryCount,
 682     ITextDocument_fnGetStoryRanges,
 683     ITextDocument_fnGetSaved,
 684     ITextDocument_fnSetSaved,
 685     ITextDocument_fnGetDefaultTabStop,
 686     ITextDocument_fnSetDefaultTabStop,
 687     ITextDocument_fnNew,
 688     ITextDocument_fnOpen,
 689     ITextDocument_fnSave,
 690     ITextDocument_fnFreeze,
 691     ITextDocument_fnUnfreeze,
 692     ITextDocument_fnBeginEditCollection,
 693     ITextDocument_fnEndEditCollection,
 694     ITextDocument_fnUndo,
 695     ITextDocument_fnRedo,
 696     ITextDocument_fnRange,
 697     ITextDocument_fnRangeFromPoint
 698 };
 699
 700 static HRESULT WINAPI ITextSelection_fnQueryInterface(
 701     ITextSelection *me,
 702     REFIID riid,
 703     void **ppvObj)
 704 {
 705     *ppvObj = NULL;
 706     if (IsEqualGUID(riid, &IID_IUnknown)
 707         || IsEqualGUID(riid, &IID_IDispatch)
 708         || IsEqualGUID(riid, &IID_ITextRange)
 709         || IsEqualGUID(riid, &IID_ITextSelection))
 710     {
 711         *ppvObj = me;
 712         ITextSelection_AddRef(me);
 713         return S_OK;
 714     }
 715
 716     return E_NOINTERFACE;
 717 }
 718
 719 static ULONG WINAPI ITextSelection_fnAddRef(
 720     ITextSelection *me)
 721 {
 722     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 723     return InterlockedIncrement(&This->ref);
 724 }
 725
 726 static ULONG WINAPI ITextSelection_fnRelease(
 727     ITextSelection *me)
 728 {
 729     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 730     ULONG ref = InterlockedDecrement(&This->ref);
 731     if (ref == 0)
 732         heap_free(This);
 733     return ref;
 734 }
 735
 736 static HRESULT WINAPI ITextSelection_fnGetTypeInfoCount(
 737     ITextSelection *me,
 738     UINT *pctinfo)
 739 {
 740     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 741     if (!This->reOle)
 742         return CO_E_RELEASED;
 743
 744     FIXME("not implemented\n");
 745     return E_NOTIMPL;
 746 }
 747
 748 static HRESULT WINAPI ITextSelection_fnGetTypeInfo(
 749     ITextSelection *me,
 750     UINT iTInfo,
 751     LCID lcid,
 752     ITypeInfo **ppTInfo)
 753 {
 754     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 755     if (!This->reOle)
 756         return CO_E_RELEASED;
 757
 758     FIXME("not implemented\n");
 759     return E_NOTIMPL;
 760 }
 761
 762 static HRESULT WINAPI ITextSelection_fnGetIDsOfNames(
 763     ITextSelection *me,
 764     REFIID riid,
 765     LPOLESTR *rgszNames,
 766     UINT cNames,
 767     LCID lcid,
 768     DISPID *rgDispId)
 769 {
 770     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 771     if (!This->reOle)
 772         return CO_E_RELEASED;
 773
 774     FIXME("not implemented\n");
 775     return E_NOTIMPL;
 776 }
 777
 778 static HRESULT WINAPI ITextSelection_fnInvoke(
 779     ITextSelection *me,
 780     DISPID dispIdMember,
 781     REFIID riid,
 782     LCID lcid,
 783     WORD wFlags,
 784     DISPPARAMS *pDispParams,
 785     VARIANT *pVarResult,
 786     EXCEPINFO *pExcepInfo,
 787     UINT *puArgErr)
 788 {
 789     FIXME("not implemented\n");
 790     return E_NOTIMPL;
 791 }
 792
 793 /*** ITextRange methods ***/
 794 static HRESULT WINAPI ITextSelection_fnGetText(
 795     ITextSelection *me,
 796     BSTR *pbstr)
 797 {
 798     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 799     if (!This->reOle)
 800         return CO_E_RELEASED;
 801
 802     FIXME("not implemented\n");
 803     return E_NOTIMPL;
 804 }
 805
 806 static HRESULT WINAPI ITextSelection_fnSetText(
 807     ITextSelection *me,
 808     BSTR bstr)
 809 {
 810     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 811     if (!This->reOle)
 812         return CO_E_RELEASED;
 813
 814     FIXME("not implemented\n");
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI ITextSelection_fnGetChar(
 819     ITextSelection *me,
 820     LONG *pch)
 821 {
 822     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 823     if (!This->reOle)
 824         return CO_E_RELEASED;
 825
 826     FIXME("not implemented\n");
 827     return E_NOTIMPL;
 828 }
 829
 830 static HRESULT WINAPI ITextSelection_fnSetChar(
 831     ITextSelection *me,
 832     LONG ch)
 833 {
 834     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 835     if (!This->reOle)
 836         return CO_E_RELEASED;
 837
 838     FIXME("not implemented\n");
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI ITextSelection_fnGetDuplicate(
 843     ITextSelection *me,
 844     ITextRange **ppRange)
 845 {
 846     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 847     if (!This->reOle)
 848         return CO_E_RELEASED;
 849
 850     FIXME("not implemented\n");
 851     return E_NOTIMPL;
 852 }
 853
 854 static HRESULT WINAPI ITextSelection_fnGetFormattedText(
 855     ITextSelection *me,
 856     ITextRange **ppRange)
 857 {
 858     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 859     if (!This->reOle)
 860         return CO_E_RELEASED;
 861
 862     FIXME("not implemented\n");
 863     return E_NOTIMPL;
 864 }
 865
 866 static HRESULT WINAPI ITextSelection_fnSetFormattedText(
 867     ITextSelection *me,
 868     ITextRange *pRange)
 869 {
 870     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 871     if (!This->reOle)
 872         return CO_E_RELEASED;
 873
 874     FIXME("not implemented\n");
 875     return E_NOTIMPL;
 876 }
 877
 878 static HRESULT WINAPI ITextSelection_fnGetStart(
 879     ITextSelection *me,
 880     LONG *pcpFirst)
 881 {
 882     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 883     if (!This->reOle)
 884         return CO_E_RELEASED;
 885
 886     FIXME("not implemented\n");
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT WINAPI ITextSelection_fnSetStart(
 891     ITextSelection *me,
 892     LONG cpFirst)
 893 {
 894     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 895     if (!This->reOle)
 896         return CO_E_RELEASED;
 897
 898     FIXME("not implemented\n");
 899     return E_NOTIMPL;
 900 }
 901
 902 static HRESULT WINAPI ITextSelection_fnGetEnd(
 903     ITextSelection *me,
 904     LONG *pcpLim)
 905 {
 906     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 907     if (!This->reOle)
 908         return CO_E_RELEASED;
 909
 910     FIXME("not implemented\n");
 911     return E_NOTIMPL;
 912 }
 913
 914 static HRESULT WINAPI ITextSelection_fnSetEnd(
 915     ITextSelection *me,
 916     LONG cpLim)
 917 {
 918     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 919     if (!This->reOle)
 920         return CO_E_RELEASED;
 921
 922     FIXME("not implemented\n");
 923     return E_NOTIMPL;
 924 }
 925
 926 static HRESULT WINAPI ITextSelection_fnGetFont(
 927     ITextSelection *me,
 928     ITextFont **pFont)
 929 {
 930     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 931     if (!This->reOle)
 932         return CO_E_RELEASED;
 933
 934     FIXME("not implemented\n");
 935     return E_NOTIMPL;
 936 }
 937
 938 static HRESULT WINAPI ITextSelection_fnSetFont(
 939     ITextSelection *me,
 940     ITextFont *pFont)
 941 {
 942     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 943     if (!This->reOle)
 944         return CO_E_RELEASED;
 945
 946     FIXME("not implemented\n");
 947     return E_NOTIMPL;
 948 }
 949
 950 static HRESULT WINAPI ITextSelection_fnGetPara(
 951     ITextSelection *me,
 952     ITextPara **ppPara)
 953 {
 954     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 955     if (!This->reOle)
 956         return CO_E_RELEASED;
 957
 958     FIXME("not implemented\n");
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI ITextSelection_fnSetPara(
 963     ITextSelection *me,
 964     ITextPara *pPara)
 965 {
 966     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 967     if (!This->reOle)
 968         return CO_E_RELEASED;
 969
 970     FIXME("not implemented\n");
 971     return E_NOTIMPL;
 972 }
 973
 974 static HRESULT WINAPI ITextSelection_fnGetStoryLength(
 975     ITextSelection *me,
 976     LONG *pcch)
 977 {
 978     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 979     if (!This->reOle)
 980         return CO_E_RELEASED;
 981
 982     FIXME("not implemented\n");
 983     return E_NOTIMPL;
 984 }
 985
 986 static HRESULT WINAPI ITextSelection_fnGetStoryType(
 987     ITextSelection *me,
 988     LONG *pValue)
 989 {
 990     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 991     if (!This->reOle)
 992         return CO_E_RELEASED;
 993
 994     FIXME("not implemented\n");
 995     return E_NOTIMPL;
 996 }
 997
 998 static HRESULT WINAPI ITextSelection_fnCollapse(
 999     ITextSelection *me,
1000     LONG bStart)
1001 {
1002     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1003     if (!This->reOle)
1004         return CO_E_RELEASED;
1005
1006     FIXME("not implemented\n");
1007     return E_NOTIMPL;
1008 }
1009
1010 static HRESULT WINAPI ITextSelection_fnExpand(
1011     ITextSelection *me,
1012     LONG Unit,
1013     LONG *pDelta)
1014 {
1015     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1016     if (!This->reOle)
1017         return CO_E_RELEASED;
1018
1019     FIXME("not implemented\n");
1020     return E_NOTIMPL;
1021 }
1022
1023 static HRESULT WINAPI ITextSelection_fnGetIndex(
1024     ITextSelection *me,
1025     LONG Unit,
1026     LONG *pIndex)
1027 {
1028     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1029     if (!This->reOle)
1030         return CO_E_RELEASED;
1031
1032     FIXME("not implemented\n");
1033     return E_NOTIMPL;
1034 }
1035
1036 static HRESULT WINAPI ITextSelection_fnSetIndex(
1037     ITextSelection *me,
1038     LONG Unit,
1039     LONG Index,
1040     LONG Extend)
1041 {
1042     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1043     if (!This->reOle)
1044         return CO_E_RELEASED;
1045
1046     FIXME("not implemented\n");
1047     return E_NOTIMPL;
1048 }
1049
1050 static HRESULT WINAPI ITextSelection_fnSetRange(
1051     ITextSelection *me,
1052     LONG cpActive,
1053     LONG cpOther)
1054 {
1055     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1056     if (!This->reOle)
1057         return CO_E_RELEASED;
1058
1059     FIXME("not implemented\n");
1060     return E_NOTIMPL;
1061 }
1062
1063 static HRESULT WINAPI ITextSelection_fnInRange(
1064     ITextSelection *me,
1065     ITextRange *pRange,
1066     LONG *pb)
1067 {
1068     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1069     if (!This->reOle)
1070         return CO_E_RELEASED;
1071
1072     FIXME("not implemented\n");
1073     return E_NOTIMPL;
1074 }
1075
1076 static HRESULT WINAPI ITextSelection_fnInStory(
1077     ITextSelection *me,
1078     ITextRange *pRange,
1079     LONG *pb)
1080 {
1081     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1082     if (!This->reOle)
1083         return CO_E_RELEASED;
1084
1085     FIXME("not implemented\n");
1086     return E_NOTIMPL;
1087 }
1088
1089 static HRESULT WINAPI ITextSelection_fnIsEqual(
1090     ITextSelection *me,
1091     ITextRange *pRange,
1092     LONG *pb)
1093 {
1094     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1095     if (!This->reOle)
1096         return CO_E_RELEASED;
1097
1098     FIXME("not implemented\n");
1099     return E_NOTIMPL;
1100 }
1101
1102 static HRESULT WINAPI ITextSelection_fnSelect(
1103     ITextSelection *me)
1104 {
1105     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1106     if (!This->reOle)
1107         return CO_E_RELEASED;
1108
1109     FIXME("not implemented\n");
1110     return E_NOTIMPL;
1111 }
1112
1113 static HRESULT WINAPI ITextSelection_fnStartOf(
1114     ITextSelection *me,
1115     LONG Unit,
1116     LONG Extend,
1117     LONG *pDelta)
1118 {
1119     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1120     if (!This->reOle)
1121         return CO_E_RELEASED;
1122
1123     FIXME("not implemented\n");
1124     return E_NOTIMPL;
1125 }
1126
1127 static HRESULT WINAPI ITextSelection_fnEndOf(
1128     ITextSelection *me,
1129     LONG Unit,
1130     LONG Extend,
1131     LONG *pDelta)
1132 {
1133     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1134     if (!This->reOle)
1135         return CO_E_RELEASED;
1136
1137     FIXME("not implemented\n");
1138     return E_NOTIMPL;
1139 }
1140
1141 static HRESULT WINAPI ITextSelection_fnMove(
1142     ITextSelection *me,
1143     LONG Unit,
1144     LONG Count,
1145     LONG *pDelta)
1146 {
1147     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1148     if (!This->reOle)
1149         return CO_E_RELEASED;
1150
1151     FIXME("not implemented\n");
1152     return E_NOTIMPL;
1153 }
1154
1155 static HRESULT WINAPI ITextSelection_fnMoveStart(
1156     ITextSelection *me,
1157     LONG Unit,
1158     LONG Count,
1159     LONG *pDelta)
1160 {
1161     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1162     if (!This->reOle)
1163         return CO_E_RELEASED;
1164
1165     FIXME("not implemented\n");
1166     return E_NOTIMPL;
1167 }
1168
1169 static HRESULT WINAPI ITextSelection_fnMoveEnd(
1170     ITextSelection *me,
1171     LONG Unit,
1172     LONG Count,
1173     LONG *pDelta)
1174 {
1175     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1176     if (!This->reOle)
1177         return CO_E_RELEASED;
1178
1179     FIXME("not implemented\n");
1180     return E_NOTIMPL;
1181 }
1182
1183 static HRESULT WINAPI ITextSelection_fnMoveWhile(
1184     ITextSelection *me,
1185     VARIANT *Cset,
1186     LONG Count,
1187     LONG *pDelta)
1188 {
1189     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1190     if (!This->reOle)
1191         return CO_E_RELEASED;
1192
1193     FIXME("not implemented\n");
1194     return E_NOTIMPL;
1195 }
1196
1197 static HRESULT WINAPI ITextSelection_fnMoveStartWhile(
1198     ITextSelection *me,
1199     VARIANT *Cset,
1200     LONG Count,
1201     LONG *pDelta)
1202 {
1203     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1204     if (!This->reOle)
1205         return CO_E_RELEASED;
1206
1207     FIXME("not implemented\n");
1208     return E_NOTIMPL;
1209 }
1210
1211 static HRESULT WINAPI ITextSelection_fnMoveEndWhile(
1212     ITextSelection *me,
1213     VARIANT *Cset,
1214     LONG Count,
1215     LONG *pDelta)
1216 {
1217     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1218     if (!This->reOle)
1219         return CO_E_RELEASED;
1220
1221     FIXME("not implemented\n");
1222     return E_NOTIMPL;
1223 }
1224
1225 static HRESULT WINAPI ITextSelection_fnMoveUntil(
1226     ITextSelection *me,
1227     VARIANT *Cset,
1228     LONG Count,
1229     LONG *pDelta)
1230 {
1231     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1232     if (!This->reOle)
1233         return CO_E_RELEASED;
1234
1235     FIXME("not implemented\n");
1236     return E_NOTIMPL;
1237 }
1238
1239 static HRESULT WINAPI ITextSelection_fnMoveStartUntil(
1240     ITextSelection *me,
1241     VARIANT *Cset,
1242     LONG Count,
1243     LONG *pDelta)
1244 {
1245     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1246     if (!This->reOle)
1247         return CO_E_RELEASED;
1248
1249     FIXME("not implemented\n");
1250     return E_NOTIMPL;
1251 }
1252
1253 static HRESULT WINAPI ITextSelection_fnMoveEndUntil(
1254     ITextSelection *me,
1255     VARIANT *Cset,
1256     LONG Count,
1257     LONG *pDelta)
1258 {
1259     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1260     if (!This->reOle)
1261         return CO_E_RELEASED;
1262
1263     FIXME("not implemented\n");
1264     return E_NOTIMPL;
1265 }
1266
1267 static HRESULT WINAPI ITextSelection_fnFindText(
1268     ITextSelection *me,
1269     BSTR bstr,
1270     LONG cch,
1271     LONG Flags,
1272     LONG *pLength)
1273 {
1274     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1275     if (!This->reOle)
1276         return CO_E_RELEASED;
1277
1278     FIXME("not implemented\n");
1279     return E_NOTIMPL;
1280 }
1281
1282 static HRESULT WINAPI ITextSelection_fnFindTextStart(
1283     ITextSelection *me,
1284     BSTR bstr,
1285     LONG cch,
1286     LONG Flags,
1287     LONG *pLength)
1288 {
1289     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1290     if (!This->reOle)
1291         return CO_E_RELEASED;
1292
1293     FIXME("not implemented\n");
1294     return E_NOTIMPL;
1295 }
1296
1297 static HRESULT WINAPI ITextSelection_fnFindTextEnd(
1298     ITextSelection *me,
1299     BSTR bstr,
1300     LONG cch,
1301     LONG Flags,
1302     LONG *pLength)
1303 {
1304     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1305     if (!This->reOle)
1306         return CO_E_RELEASED;
1307
1308     FIXME("not implemented\n");
1309     return E_NOTIMPL;
1310 }
1311
1312 static HRESULT WINAPI ITextSelection_fnDelete(
1313     ITextSelection *me,
1314     LONG Unit,
1315     LONG Count,
1316     LONG *pDelta)
1317 {
1318     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1319     if (!This->reOle)
1320         return CO_E_RELEASED;
1321
1322     FIXME("not implemented\n");
1323     return E_NOTIMPL;
1324 }
1325
1326 static HRESULT WINAPI ITextSelection_fnCut(
1327     ITextSelection *me,
1328     VARIANT *pVar)
1329 {
1330     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1331     if (!This->reOle)
1332         return CO_E_RELEASED;
1333
1334     FIXME("not implemented\n");
1335     return E_NOTIMPL;
1336 }
1337
1338 static HRESULT WINAPI ITextSelection_fnCopy(
1339     ITextSelection *me,
1340     VARIANT *pVar)
1341 {
1342     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1343     if (!This->reOle)
1344         return CO_E_RELEASED;
1345
1346     FIXME("not implemented\n");
1347     return E_NOTIMPL;
1348 }
1349
1350 static HRESULT WINAPI ITextSelection_fnPaste(
1351     ITextSelection *me,
1352     VARIANT *pVar,
1353     LONG Format)
1354 {
1355     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1356     if (!This->reOle)
1357         return CO_E_RELEASED;
1358
1359     FIXME("not implemented\n");
1360     return E_NOTIMPL;
1361 }
1362
1363 static HRESULT WINAPI ITextSelection_fnCanPaste(
1364     ITextSelection *me,
1365     VARIANT *pVar,
1366     LONG Format,
1367     LONG *pb)
1368 {
1369     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1370     if (!This->reOle)
1371         return CO_E_RELEASED;
1372
1373     FIXME("not implemented\n");
1374     return E_NOTIMPL;
1375 }
1376
1377 static HRESULT WINAPI ITextSelection_fnCanEdit(
1378     ITextSelection *me,
1379     LONG *pb)
1380 {
1381     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1382     if (!This->reOle)
1383         return CO_E_RELEASED;
1384
1385     FIXME("not implemented\n");
1386     return E_NOTIMPL;
1387 }
1388
1389 static HRESULT WINAPI ITextSelection_fnChangeCase(
1390     ITextSelection *me,
1391     LONG Type)
1392 {
1393     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1394     if (!This->reOle)
1395         return CO_E_RELEASED;
1396
1397     FIXME("not implemented\n");
1398     return E_NOTIMPL;
1399 }
1400
1401 static HRESULT WINAPI ITextSelection_fnGetPoint(
1402     ITextSelection *me,
1403     LONG Type,
1404     LONG *cx,
1405     LONG *cy)
1406 {
1407     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1408     if (!This->reOle)
1409         return CO_E_RELEASED;
1410
1411     FIXME("not implemented\n");
1412     return E_NOTIMPL;
1413 }
1414
1415 static HRESULT WINAPI ITextSelection_fnSetPoint(
1416     ITextSelection *me,
1417     LONG x,
1418     LONG y,
1419     LONG Type,
1420     LONG Extend)
1421 {
1422     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1423     if (!This->reOle)
1424         return CO_E_RELEASED;
1425
1426     FIXME("not implemented\n");
1427     return E_NOTIMPL;
1428 }
1429
1430 static HRESULT WINAPI ITextSelection_fnScrollIntoView(
1431     ITextSelection *me,
1432     LONG Value)
1433 {
1434     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1435     if (!This->reOle)
1436         return CO_E_RELEASED;
1437
1438     FIXME("not implemented\n");
1439     return E_NOTIMPL;
1440 }
1441
1442 static HRESULT WINAPI ITextSelection_fnGetEmbeddedObject(
1443     ITextSelection *me,
1444     IUnknown **ppv)
1445 {
1446     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1447     if (!This->reOle)
1448         return CO_E_RELEASED;
1449
1450     FIXME("not implemented\n");
1451     return E_NOTIMPL;
1452 }
1453
1454 /*** ITextSelection methods ***/
1455 static HRESULT WINAPI ITextSelection_fnGetFlags(
1456     ITextSelection *me,
1457     LONG *pFlags)
1458 {
1459     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1460     if (!This->reOle)
1461         return CO_E_RELEASED;
1462
1463     FIXME("not implemented\n");
1464     return E_NOTIMPL;
1465 }
1466
1467 static HRESULT WINAPI ITextSelection_fnSetFlags(
1468     ITextSelection *me,
1469     LONG Flags)
1470 {
1471     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1472     if (!This->reOle)
1473         return CO_E_RELEASED;
1474
1475     FIXME("not implemented\n");
1476     return E_NOTIMPL;
1477 }
1478
1479 static HRESULT WINAPI ITextSelection_fnGetType(
1480     ITextSelection *me,
1481     LONG *pType)
1482 {
1483     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1484     if (!This->reOle)
1485         return CO_E_RELEASED;
1486
1487     FIXME("not implemented\n");
1488     return E_NOTIMPL;
1489 }
1490
1491 static HRESULT WINAPI ITextSelection_fnMoveLeft(
1492     ITextSelection *me,
1493     LONG Unit,
1494     LONG Count,
1495     LONG Extend,
1496     LONG *pDelta)
1497 {
1498     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1499     if (!This->reOle)
1500         return CO_E_RELEASED;
1501
1502     FIXME("not implemented\n");
1503     return E_NOTIMPL;
1504 }
1505
1506 static HRESULT WINAPI ITextSelection_fnMoveRight(
1507     ITextSelection *me,
1508     LONG Unit,
1509     LONG Count,
1510     LONG Extend,
1511     LONG *pDelta)
1512 {
1513     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1514     if (!This->reOle)
1515         return CO_E_RELEASED;
1516
1517     FIXME("not implemented\n");
1518     return E_NOTIMPL;
1519 }
1520
1521 static HRESULT WINAPI ITextSelection_fnMoveUp(
1522     ITextSelection *me,
1523     LONG Unit,
1524     LONG Count,
1525     LONG Extend,
1526     LONG *pDelta)
1527 {
1528     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1529     if (!This->reOle)
1530         return CO_E_RELEASED;
1531
1532     FIXME("not implemented\n");
1533     return E_NOTIMPL;
1534 }
1535
1536 static HRESULT WINAPI ITextSelection_fnMoveDown(
1537     ITextSelection *me,
1538     LONG Unit,
1539     LONG Count,
1540     LONG Extend,
1541     LONG *pDelta)
1542 {
1543     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1544     if (!This->reOle)
1545         return CO_E_RELEASED;
1546
1547     FIXME("not implemented\n");
1548     return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI ITextSelection_fnHomeKey(
1552     ITextSelection *me,
1553     LONG Unit,
1554     LONG Extend,
1555     LONG *pDelta)
1556 {
1557     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1558     if (!This->reOle)
1559         return CO_E_RELEASED;
1560
1561     FIXME("not implemented\n");
1562     return E_NOTIMPL;
1563 }
1564
1565 static HRESULT WINAPI ITextSelection_fnEndKey(
1566     ITextSelection *me,
1567     LONG Unit,
1568     LONG Extend,
1569     LONG *pDelta)
1570 {
1571     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1572     if (!This->reOle)
1573         return CO_E_RELEASED;
1574
1575     FIXME("not implemented\n");
1576     return E_NOTIMPL;
1577 }
1578
1579 static HRESULT WINAPI ITextSelection_fnTypeText(
1580     ITextSelection *me,
1581     BSTR bstr)
1582 {
1583     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1584     if (!This->reOle)
1585         return CO_E_RELEASED;
1586
1587     FIXME("not implemented\n");
1588     return E_NOTIMPL;
1589 }
1590
1591 static const ITextSelectionVtbl tsvt = {
1592     ITextSelection_fnQueryInterface,
1593     ITextSelection_fnAddRef,
1594     ITextSelection_fnRelease,
1595     ITextSelection_fnGetTypeInfoCount,
1596     ITextSelection_fnGetTypeInfo,
1597     ITextSelection_fnGetIDsOfNames,
1598     ITextSelection_fnInvoke,
1599     ITextSelection_fnGetText,
1600     ITextSelection_fnSetText,
1601     ITextSelection_fnGetChar,
1602     ITextSelection_fnSetChar,
1603     ITextSelection_fnGetDuplicate,
1604     ITextSelection_fnGetFormattedText,
1605     ITextSelection_fnSetFormattedText,
1606     ITextSelection_fnGetStart,
1607     ITextSelection_fnSetStart,
1608     ITextSelection_fnGetEnd,
1609     ITextSelection_fnSetEnd,
1610     ITextSelection_fnGetFont,
1611     ITextSelection_fnSetFont,
1612     ITextSelection_fnGetPara,
1613     ITextSelection_fnSetPara,
1614     ITextSelection_fnGetStoryLength,
1615     ITextSelection_fnGetStoryType,
1616     ITextSelection_fnCollapse,
1617     ITextSelection_fnExpand,
1618     ITextSelection_fnGetIndex,
1619     ITextSelection_fnSetIndex,
1620     ITextSelection_fnSetRange,
1621     ITextSelection_fnInRange,
1622     ITextSelection_fnInStory,
1623     ITextSelection_fnIsEqual,
1624     ITextSelection_fnSelect,
1625     ITextSelection_fnStartOf,
1626     ITextSelection_fnEndOf,
1627     ITextSelection_fnMove,
1628     ITextSelection_fnMoveStart,
1629     ITextSelection_fnMoveEnd,
1630     ITextSelection_fnMoveWhile,
1631     ITextSelection_fnMoveStartWhile,
1632     ITextSelection_fnMoveEndWhile,
1633     ITextSelection_fnMoveUntil,
1634     ITextSelection_fnMoveStartUntil,
1635     ITextSelection_fnMoveEndUntil,
1636     ITextSelection_fnFindText,
1637     ITextSelection_fnFindTextStart,
1638     ITextSelection_fnFindTextEnd,
1639     ITextSelection_fnDelete,
1640     ITextSelection_fnCut,
1641     ITextSelection_fnCopy,
1642     ITextSelection_fnPaste,
1643     ITextSelection_fnCanPaste,
1644     ITextSelection_fnCanEdit,
1645     ITextSelection_fnChangeCase,
1646     ITextSelection_fnGetPoint,
1647     ITextSelection_fnSetPoint,
1648     ITextSelection_fnScrollIntoView,
1649     ITextSelection_fnGetEmbeddedObject,
1650     ITextSelection_fnGetFlags,
1651     ITextSelection_fnSetFlags,
1652     ITextSelection_fnGetType,
1653     ITextSelection_fnMoveLeft,
1654     ITextSelection_fnMoveRight,
1655     ITextSelection_fnMoveUp,
1656     ITextSelection_fnMoveDown,
1657     ITextSelection_fnHomeKey,
1658     ITextSelection_fnEndKey,
1659     ITextSelection_fnTypeText
1660 };
1661
1662 static ITextSelectionImpl *
1663 CreateTextSelection(IRichEditOleImpl *reOle)
1664 {
1665     ITextSelectionImpl *txtSel = heap_alloc(sizeof *txtSel);
1666     if (!txtSel)
1667         return NULL;
1668
1669     txtSel->lpVtbl = &tsvt;
1670     txtSel->ref = 1;
1671     txtSel->reOle = reOle;
1672     return txtSel;
1673 }
1674
1675 LRESULT CreateIRichEditOle(ME_TextEditor *editor, LPVOID *ppObj)
1676 {
1677     IRichEditOleImpl *reo;
1678
1679     reo = heap_alloc(sizeof(IRichEditOleImpl));
1680     if (!reo)
1681         return 0;
1682
1683     reo->lpRichEditOleVtbl = &revt;
1684     reo->lpTextDocumentVtbl = &tdvt;
1685     reo->ref = 1;
1686     reo->editor = editor;
1687     reo->txtSel = CreateTextSelection(reo);
1688     if (!reo->txtSel)
1689     {
1690         heap_free(reo);
1691         return 0;
1692     }
1693     reo->clientSite = CreateOleClientSite(reo);
1694     if (!reo->txtSel)
1695     {
1696         ITextSelection_Release((ITextSelection *) reo->txtSel);
1697         heap_free(reo);
1698         return 0;
1699     }
1700     TRACE("Created %p\n",reo);
1701     *ppObj = reo;
1702
1703     return 1;
1704 }
1705
1706 static void convert_sizel(ME_Context *c, const SIZEL* szl, SIZE* sz)
1707 {
1708   /* sizel is in .01 millimeters, sz in pixels */
1709   sz->cx = MulDiv(szl->cx, c->dpi.cx, 2540);
1710   sz->cy = MulDiv(szl->cy, c->dpi.cy, 2540);
1711 }
1712
1713 /******************************************************************************
1714  * ME_GetOLEObjectSize
1715  *
1716  * Sets run extent for OLE objects.
1717  */
1718 void ME_GetOLEObjectSize(ME_Context *c, ME_Run *run, SIZE *pSize)
1719 {
1720   IDataObject*  ido;
1721   FORMATETC     fmt;
1722   STGMEDIUM     stgm;
1723   DIBSECTION    dibsect;
1724   ENHMETAHEADER emh;
1725
1726   assert(run->nFlags & MERF_GRAPHICS);
1727   assert(run->ole_obj);
1728
1729   if (run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0)
1730   {
1731     convert_sizel(c, &run->ole_obj->sizel, pSize);
1732     if (c->editor->nZoomNumerator != 0)
1733     {
1734       pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1735       pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1736     }
1737     return;
1738   }
1739
1740   IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido);
1741   fmt.cfFormat = CF_BITMAP;
1742   fmt.ptd = NULL;
1743   fmt.dwAspect = DVASPECT_CONTENT;
1744   fmt.lindex = -1;
1745   fmt.tymed = TYMED_GDI;
1746   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
1747   {
1748     fmt.cfFormat = CF_ENHMETAFILE;
1749     fmt.tymed = TYMED_ENHMF;
1750     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
1751     {
1752       FIXME("unsupported format\n");
1753       pSize->cx = pSize->cy = 0;
1754       IDataObject_Release(ido);
1755       return;
1756     }
1757   }
1758
1759   switch (stgm.tymed)
1760   {
1761   case TYMED_GDI:
1762     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
1763     pSize->cx = dibsect.dsBm.bmWidth;
1764     pSize->cy = dibsect.dsBm.bmHeight;
1765     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
1766     break;
1767   case TYMED_ENHMF:
1768     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
1769     pSize->cx = emh.rclBounds.right - emh.rclBounds.left;
1770     pSize->cy = emh.rclBounds.bottom - emh.rclBounds.top;
1771     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
1772     break;
1773   default:
1774     FIXME("Unsupported tymed %d\n", stgm.tymed);
1775     break;
1776   }
1777   IDataObject_Release(ido);
1778   if (c->editor->nZoomNumerator != 0)
1779   {
1780     pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1781     pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1782   }
1783 }
1784
1785 void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run,
1786                 ME_Paragraph *para, BOOL selected)
1787 {
1788   IDataObject*  ido;
1789   FORMATETC     fmt;
1790   STGMEDIUM     stgm;
1791   DIBSECTION    dibsect;
1792   ENHMETAHEADER emh;
1793   HDC           hMemDC;
1794   SIZE          sz;
1795   BOOL          has_size;
1796
1797   assert(run->nFlags & MERF_GRAPHICS);
1798   assert(run->ole_obj);
1799   if (IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
1800   {
1801     FIXME("Couldn't get interface\n");
1802     return;
1803   }
1804   has_size = run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0;
1805   fmt.cfFormat = CF_BITMAP;
1806   fmt.ptd = NULL;
1807   fmt.dwAspect = DVASPECT_CONTENT;
1808   fmt.lindex = -1;
1809   fmt.tymed = TYMED_GDI;
1810   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
1811   {
1812     fmt.cfFormat = CF_ENHMETAFILE;
1813     fmt.tymed = TYMED_ENHMF;
1814     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
1815     {
1816       FIXME("Couldn't get storage medium\n");
1817       IDataObject_Release(ido);
1818       return;
1819     }
1820   }
1821   switch (stgm.tymed)
1822   {
1823   case TYMED_GDI:
1824     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
1825     hMemDC = CreateCompatibleDC(c->hDC);
1826     SelectObject(hMemDC, stgm.u.hBitmap);
1827     if (has_size)
1828     {
1829       convert_sizel(c, &run->ole_obj->sizel, &sz);
1830     } else {
1831       sz.cx = MulDiv(dibsect.dsBm.bmWidth, c->dpi.cx, 96);
1832       sz.cy = MulDiv(dibsect.dsBm.bmHeight, c->dpi.cy, 96);
1833     }
1834     if (c->editor->nZoomNumerator != 0)
1835     {
1836       sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1837       sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1838     }
1839     if (sz.cx == dibsect.dsBm.bmWidth && sz.cy == dibsect.dsBm.bmHeight)
1840     {
1841       BitBlt(c->hDC, x, y - sz.cy,
1842              dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight,
1843              hMemDC, 0, 0, SRCCOPY);
1844     } else {
1845       StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
1846                  hMemDC, 0, 0, dibsect.dsBm.bmWidth,
1847                  dibsect.dsBm.bmHeight, SRCCOPY);
1848     }
1849     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
1850     break;
1851   case TYMED_ENHMF:
1852     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
1853     if (has_size)
1854     {
1855       convert_sizel(c, &run->ole_obj->sizel, &sz);
1856     } else {
1857       sz.cy = MulDiv(emh.rclBounds.bottom - emh.rclBounds.top, c->dpi.cx, 96);
1858       sz.cx = MulDiv(emh.rclBounds.right - emh.rclBounds.left, c->dpi.cy, 96);
1859     }
1860     if (c->editor->nZoomNumerator != 0)
1861     {
1862       sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1863       sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1864     }
1865
1866     {
1867       RECT    rc;
1868
1869       rc.left = x;
1870       rc.top = y - sz.cy;
1871       rc.right = x + sz.cx;
1872       rc.bottom = y;
1873       PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
1874     }
1875     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
1876     break;
1877   default:
1878     FIXME("Unsupported tymed %d\n", stgm.tymed);
1879     selected = FALSE;
1880     break;
1881   }
1882   if (selected && !c->editor->bHideSelection)
1883     PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
1884   IDataObject_Release(ido);
1885 }
1886
1887 void ME_DeleteReObject(REOBJECT* reo)
1888 {
1889     if (reo->poleobj)   IOleObject_Release(reo->poleobj);
1890     if (reo->pstg)      IStorage_Release(reo->pstg);
1891     if (reo->polesite)  IOleClientSite_Release(reo->polesite);
1892     FREE_OBJ(reo);
1893 }
1894
1895 void ME_CopyReObject(REOBJECT* dst, const REOBJECT* src)
1896 {
1897     *dst = *src;
1898
1899     if (dst->poleobj)   IOleObject_AddRef(dst->poleobj);
1900     if (dst->pstg)      IStorage_AddRef(dst->pstg);
1901     if (dst->polesite)  IOleClientSite_AddRef(dst->polesite);
1902 }