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     if (reo->poleobj)   IOleObject_AddRef(reo->poleobj);
 392     if (reo->pstg)      IStorage_AddRef(reo->pstg);
 393     if (reo->polesite)  IOleClientSite_AddRef(reo->polesite);
 394
 395     ME_InsertOLEFromCursor(This->editor, reo, 0);
 396     ME_CommitUndo(This->editor);
 397     ME_UpdateRepaint(This->editor);
 398     return S_OK;
 399 }
 400
 401 static HRESULT WINAPI IRichEditOle_fnSaveCompleted(IRichEditOle *me, LONG iob,
 402                LPSTORAGE lpstg)
 403 {
 404     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 405     FIXME("stub %p\n",This);
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI
 410 IRichEditOle_fnSetDvaspect(IRichEditOle *me, LONG iob, DWORD dvaspect)
 411 {
 412     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 413     FIXME("stub %p\n",This);
 414     return E_NOTIMPL;
 415 }
 416
 417 static HRESULT WINAPI IRichEditOle_fnSetHostNames(IRichEditOle *me,
 418                LPCSTR lpstrContainerApp, LPCSTR lpstrContainerObj)
 419 {
 420     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 421     FIXME("stub %p %s %s\n",This, lpstrContainerApp, lpstrContainerObj);
 422     return E_NOTIMPL;
 423 }
 424
 425 static HRESULT WINAPI
 426 IRichEditOle_fnSetLinkAvailable(IRichEditOle *me, LONG iob, BOOL fAvailable)
 427 {
 428     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 429     FIXME("stub %p\n",This);
 430     return E_NOTIMPL;
 431 }
 432
 433 static const IRichEditOleVtbl revt = {
 434     IRichEditOle_fnQueryInterface,
 435     IRichEditOle_fnAddRef,
 436     IRichEditOle_fnRelease,
 437     IRichEditOle_fnGetClientSite,
 438     IRichEditOle_fnGetObjectCount,
 439     IRichEditOle_fnGetLinkCount,
 440     IRichEditOle_fnGetObject,
 441     IRichEditOle_fnInsertObject,
 442     IRichEditOle_fnConvertObject,
 443     IRichEditOle_fnActivateAs,
 444     IRichEditOle_fnSetHostNames,
 445     IRichEditOle_fnSetLinkAvailable,
 446     IRichEditOle_fnSetDvaspect,
 447     IRichEditOle_fnHandsOffStorage,
 448     IRichEditOle_fnSaveCompleted,
 449     IRichEditOle_fnInPlaceDeactivate,
 450     IRichEditOle_fnContextSensitiveHelp,
 451     IRichEditOle_fnGetClipboardData,
 452     IRichEditOle_fnImportDataObject
 453 };
 454
 455 static HRESULT WINAPI
 456 ITextDocument_fnQueryInterface(ITextDocument* me, REFIID riid,
 457     void** ppvObject)
 458 {
 459     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 460     return IRichEditOle_fnQueryInterface((IRichEditOle*)&This->lpRichEditOleVtbl,
 461             riid, ppvObject);
 462 }
 463
 464 static ULONG WINAPI
 465 ITextDocument_fnAddRef(ITextDocument* me)
 466 {
 467     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 468     return IRichEditOle_fnAddRef((IRichEditOle*)&This->lpRichEditOleVtbl);
 469 }
 470
 471 static ULONG WINAPI
 472 ITextDocument_fnRelease(ITextDocument* me)
 473 {
 474     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 475     return IRichEditOle_fnRelease((IRichEditOle*)&This->lpRichEditOleVtbl);
 476 }
 477
 478 static HRESULT WINAPI
 479 ITextDocument_fnGetTypeInfoCount(ITextDocument* me,
 480     UINT* pctinfo)
 481 {
 482     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 483     FIXME("stub %p\n",This);
 484     return E_NOTIMPL;
 485 }
 486
 487 static HRESULT WINAPI
 488 ITextDocument_fnGetTypeInfo(ITextDocument* me, UINT iTInfo, LCID lcid,
 489     ITypeInfo** ppTInfo)
 490 {
 491     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 492     FIXME("stub %p\n",This);
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI
 497 ITextDocument_fnGetIDsOfNames(ITextDocument* me, REFIID riid,
 498     LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
 499 {
 500     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 501     FIXME("stub %p\n",This);
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI
 506 ITextDocument_fnInvoke(ITextDocument* me, DISPID dispIdMember,
 507     REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
 508     VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 509 {
 510     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 511     FIXME("stub %p\n",This);
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT WINAPI
 516 ITextDocument_fnGetName(ITextDocument* me, BSTR* pName)
 517 {
 518     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 519     FIXME("stub %p\n",This);
 520     return E_NOTIMPL;
 521 }
 522
 523 static HRESULT WINAPI
 524 ITextDocument_fnGetSelection(ITextDocument* me, ITextSelection** ppSel)
 525 {
 526     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 527     TRACE("(%p)\n", me);
 528     *ppSel = (ITextSelection *) This->txtSel;
 529     ITextSelection_AddRef(*ppSel);
 530     return S_OK;
 531 }
 532
 533 static HRESULT WINAPI
 534 ITextDocument_fnGetStoryCount(ITextDocument* me, LONG* pCount)
 535 {
 536     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 537     FIXME("stub %p\n",This);
 538     return E_NOTIMPL;
 539 }
 540
 541 static HRESULT WINAPI
 542 ITextDocument_fnGetStoryRanges(ITextDocument* me,
 543     ITextStoryRanges** ppStories)
 544 {
 545     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 546     FIXME("stub %p\n",This);
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI
 551 ITextDocument_fnGetSaved(ITextDocument* me, LONG* pValue)
 552 {
 553     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 554     FIXME("stub %p\n",This);
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI
 559 ITextDocument_fnSetSaved(ITextDocument* me, LONG Value)
 560 {
 561     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 562     FIXME("stub %p\n",This);
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI
 567 ITextDocument_fnGetDefaultTabStop(ITextDocument* me, float* pValue)
 568 {
 569     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 570     FIXME("stub %p\n",This);
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI
 575 ITextDocument_fnSetDefaultTabStop(ITextDocument* me, float Value)
 576 {
 577     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 578     FIXME("stub %p\n",This);
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI
 583 ITextDocument_fnNew(ITextDocument* me)
 584 {
 585     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 586     FIXME("stub %p\n",This);
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI
 591 ITextDocument_fnOpen(ITextDocument* me, VARIANT* pVar, LONG Flags,
 592     LONG CodePage)
 593 {
 594     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 595     FIXME("stub %p\n",This);
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI
 600 ITextDocument_fnSave(ITextDocument* me, VARIANT* pVar, LONG Flags,
 601     LONG CodePage)
 602 {
 603     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 604     FIXME("stub %p\n",This);
 605     return E_NOTIMPL;
 606 }
 607
 608 static HRESULT WINAPI
 609 ITextDocument_fnFreeze(ITextDocument* me, LONG* pCount)
 610 {
 611     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 612     FIXME("stub %p\n",This);
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI
 617 ITextDocument_fnUnfreeze(ITextDocument* me, LONG* pCount)
 618 {
 619     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 620     FIXME("stub %p\n",This);
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI
 625 ITextDocument_fnBeginEditCollection(ITextDocument* me)
 626 {
 627     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 628     FIXME("stub %p\n",This);
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI
 633 ITextDocument_fnEndEditCollection(ITextDocument* me)
 634 {
 635     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 636     FIXME("stub %p\n",This);
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI
 641 ITextDocument_fnUndo(ITextDocument* me, LONG Count, LONG* prop)
 642 {
 643     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 644     FIXME("stub %p\n",This);
 645     return E_NOTIMPL;
 646 }
 647
 648 static HRESULT WINAPI
 649 ITextDocument_fnRedo(ITextDocument* me, LONG Count, LONG* prop)
 650 {
 651     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 652     FIXME("stub %p\n",This);
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI
 657 ITextDocument_fnRange(ITextDocument* me, LONG cp1, LONG cp2,
 658     ITextRange** ppRange)
 659 {
 660     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 661     FIXME("stub %p\n",This);
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT WINAPI
 666 ITextDocument_fnRangeFromPoint(ITextDocument* me, LONG x, LONG y,
 667     ITextRange** ppRange)
 668 {
 669     IRichEditOleImpl *This = impl_from_ITextDocument(me);
 670     FIXME("stub %p\n",This);
 671     return E_NOTIMPL;
 672 }
 673
 674 static const ITextDocumentVtbl tdvt = {
 675     ITextDocument_fnQueryInterface,
 676     ITextDocument_fnAddRef,
 677     ITextDocument_fnRelease,
 678     ITextDocument_fnGetTypeInfoCount,
 679     ITextDocument_fnGetTypeInfo,
 680     ITextDocument_fnGetIDsOfNames,
 681     ITextDocument_fnInvoke,
 682     ITextDocument_fnGetName,
 683     ITextDocument_fnGetSelection,
 684     ITextDocument_fnGetStoryCount,
 685     ITextDocument_fnGetStoryRanges,
 686     ITextDocument_fnGetSaved,
 687     ITextDocument_fnSetSaved,
 688     ITextDocument_fnGetDefaultTabStop,
 689     ITextDocument_fnSetDefaultTabStop,
 690     ITextDocument_fnNew,
 691     ITextDocument_fnOpen,
 692     ITextDocument_fnSave,
 693     ITextDocument_fnFreeze,
 694     ITextDocument_fnUnfreeze,
 695     ITextDocument_fnBeginEditCollection,
 696     ITextDocument_fnEndEditCollection,
 697     ITextDocument_fnUndo,
 698     ITextDocument_fnRedo,
 699     ITextDocument_fnRange,
 700     ITextDocument_fnRangeFromPoint
 701 };
 702
 703 static HRESULT WINAPI ITextSelection_fnQueryInterface(
 704     ITextSelection *me,
 705     REFIID riid,
 706     void **ppvObj)
 707 {
 708     *ppvObj = NULL;
 709     if (IsEqualGUID(riid, &IID_IUnknown)
 710         || IsEqualGUID(riid, &IID_IDispatch)
 711         || IsEqualGUID(riid, &IID_ITextRange)
 712         || IsEqualGUID(riid, &IID_ITextSelection))
 713     {
 714         *ppvObj = me;
 715         ITextSelection_AddRef(me);
 716         return S_OK;
 717     }
 718
 719     return E_NOINTERFACE;
 720 }
 721
 722 static ULONG WINAPI ITextSelection_fnAddRef(
 723     ITextSelection *me)
 724 {
 725     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 726     return InterlockedIncrement(&This->ref);
 727 }
 728
 729 static ULONG WINAPI ITextSelection_fnRelease(
 730     ITextSelection *me)
 731 {
 732     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 733     ULONG ref = InterlockedDecrement(&This->ref);
 734     if (ref == 0)
 735         heap_free(This);
 736     return ref;
 737 }
 738
 739 static HRESULT WINAPI ITextSelection_fnGetTypeInfoCount(
 740     ITextSelection *me,
 741     UINT *pctinfo)
 742 {
 743     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 744     if (!This->reOle)
 745         return CO_E_RELEASED;
 746
 747     FIXME("not implemented\n");
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI ITextSelection_fnGetTypeInfo(
 752     ITextSelection *me,
 753     UINT iTInfo,
 754     LCID lcid,
 755     ITypeInfo **ppTInfo)
 756 {
 757     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 758     if (!This->reOle)
 759         return CO_E_RELEASED;
 760
 761     FIXME("not implemented\n");
 762     return E_NOTIMPL;
 763 }
 764
 765 static HRESULT WINAPI ITextSelection_fnGetIDsOfNames(
 766     ITextSelection *me,
 767     REFIID riid,
 768     LPOLESTR *rgszNames,
 769     UINT cNames,
 770     LCID lcid,
 771     DISPID *rgDispId)
 772 {
 773     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 774     if (!This->reOle)
 775         return CO_E_RELEASED;
 776
 777     FIXME("not implemented\n");
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI ITextSelection_fnInvoke(
 782     ITextSelection *me,
 783     DISPID dispIdMember,
 784     REFIID riid,
 785     LCID lcid,
 786     WORD wFlags,
 787     DISPPARAMS *pDispParams,
 788     VARIANT *pVarResult,
 789     EXCEPINFO *pExcepInfo,
 790     UINT *puArgErr)
 791 {
 792     FIXME("not implemented\n");
 793     return E_NOTIMPL;
 794 }
 795
 796 /*** ITextRange methods ***/
 797 static HRESULT WINAPI ITextSelection_fnGetText(
 798     ITextSelection *me,
 799     BSTR *pbstr)
 800 {
 801     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 802     if (!This->reOle)
 803         return CO_E_RELEASED;
 804
 805     FIXME("not implemented\n");
 806     return E_NOTIMPL;
 807 }
 808
 809 static HRESULT WINAPI ITextSelection_fnSetText(
 810     ITextSelection *me,
 811     BSTR bstr)
 812 {
 813     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 814     if (!This->reOle)
 815         return CO_E_RELEASED;
 816
 817     FIXME("not implemented\n");
 818     return E_NOTIMPL;
 819 }
 820
 821 static HRESULT WINAPI ITextSelection_fnGetChar(
 822     ITextSelection *me,
 823     LONG *pch)
 824 {
 825     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 826     if (!This->reOle)
 827         return CO_E_RELEASED;
 828
 829     FIXME("not implemented\n");
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI ITextSelection_fnSetChar(
 834     ITextSelection *me,
 835     LONG ch)
 836 {
 837     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 838     if (!This->reOle)
 839         return CO_E_RELEASED;
 840
 841     FIXME("not implemented\n");
 842     return E_NOTIMPL;
 843 }
 844
 845 static HRESULT WINAPI ITextSelection_fnGetDuplicate(
 846     ITextSelection *me,
 847     ITextRange **ppRange)
 848 {
 849     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 850     if (!This->reOle)
 851         return CO_E_RELEASED;
 852
 853     FIXME("not implemented\n");
 854     return E_NOTIMPL;
 855 }
 856
 857 static HRESULT WINAPI ITextSelection_fnGetFormattedText(
 858     ITextSelection *me,
 859     ITextRange **ppRange)
 860 {
 861     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 862     if (!This->reOle)
 863         return CO_E_RELEASED;
 864
 865     FIXME("not implemented\n");
 866     return E_NOTIMPL;
 867 }
 868
 869 static HRESULT WINAPI ITextSelection_fnSetFormattedText(
 870     ITextSelection *me,
 871     ITextRange *pRange)
 872 {
 873     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 874     if (!This->reOle)
 875         return CO_E_RELEASED;
 876
 877     FIXME("not implemented\n");
 878     return E_NOTIMPL;
 879 }
 880
 881 static HRESULT WINAPI ITextSelection_fnGetStart(
 882     ITextSelection *me,
 883     LONG *pcpFirst)
 884 {
 885     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 886     if (!This->reOle)
 887         return CO_E_RELEASED;
 888
 889     FIXME("not implemented\n");
 890     return E_NOTIMPL;
 891 }
 892
 893 static HRESULT WINAPI ITextSelection_fnSetStart(
 894     ITextSelection *me,
 895     LONG cpFirst)
 896 {
 897     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 898     if (!This->reOle)
 899         return CO_E_RELEASED;
 900
 901     FIXME("not implemented\n");
 902     return E_NOTIMPL;
 903 }
 904
 905 static HRESULT WINAPI ITextSelection_fnGetEnd(
 906     ITextSelection *me,
 907     LONG *pcpLim)
 908 {
 909     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 910     if (!This->reOle)
 911         return CO_E_RELEASED;
 912
 913     FIXME("not implemented\n");
 914     return E_NOTIMPL;
 915 }
 916
 917 static HRESULT WINAPI ITextSelection_fnSetEnd(
 918     ITextSelection *me,
 919     LONG cpLim)
 920 {
 921     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 922     if (!This->reOle)
 923         return CO_E_RELEASED;
 924
 925     FIXME("not implemented\n");
 926     return E_NOTIMPL;
 927 }
 928
 929 static HRESULT WINAPI ITextSelection_fnGetFont(
 930     ITextSelection *me,
 931     ITextFont **pFont)
 932 {
 933     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 934     if (!This->reOle)
 935         return CO_E_RELEASED;
 936
 937     FIXME("not implemented\n");
 938     return E_NOTIMPL;
 939 }
 940
 941 static HRESULT WINAPI ITextSelection_fnSetFont(
 942     ITextSelection *me,
 943     ITextFont *pFont)
 944 {
 945     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 946     if (!This->reOle)
 947         return CO_E_RELEASED;
 948
 949     FIXME("not implemented\n");
 950     return E_NOTIMPL;
 951 }
 952
 953 static HRESULT WINAPI ITextSelection_fnGetPara(
 954     ITextSelection *me,
 955     ITextPara **ppPara)
 956 {
 957     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 958     if (!This->reOle)
 959         return CO_E_RELEASED;
 960
 961     FIXME("not implemented\n");
 962     return E_NOTIMPL;
 963 }
 964
 965 static HRESULT WINAPI ITextSelection_fnSetPara(
 966     ITextSelection *me,
 967     ITextPara *pPara)
 968 {
 969     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 970     if (!This->reOle)
 971         return CO_E_RELEASED;
 972
 973     FIXME("not implemented\n");
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI ITextSelection_fnGetStoryLength(
 978     ITextSelection *me,
 979     LONG *pcch)
 980 {
 981     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 982     if (!This->reOle)
 983         return CO_E_RELEASED;
 984
 985     FIXME("not implemented\n");
 986     return E_NOTIMPL;
 987 }
 988
 989 static HRESULT WINAPI ITextSelection_fnGetStoryType(
 990     ITextSelection *me,
 991     LONG *pValue)
 992 {
 993     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
 994     if (!This->reOle)
 995         return CO_E_RELEASED;
 996
 997     FIXME("not implemented\n");
 998     return E_NOTIMPL;
 999 }
1000
1001 static HRESULT WINAPI ITextSelection_fnCollapse(
1002     ITextSelection *me,
1003     LONG bStart)
1004 {
1005     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1006     if (!This->reOle)
1007         return CO_E_RELEASED;
1008
1009     FIXME("not implemented\n");
1010     return E_NOTIMPL;
1011 }
1012
1013 static HRESULT WINAPI ITextSelection_fnExpand(
1014     ITextSelection *me,
1015     LONG Unit,
1016     LONG *pDelta)
1017 {
1018     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1019     if (!This->reOle)
1020         return CO_E_RELEASED;
1021
1022     FIXME("not implemented\n");
1023     return E_NOTIMPL;
1024 }
1025
1026 static HRESULT WINAPI ITextSelection_fnGetIndex(
1027     ITextSelection *me,
1028     LONG Unit,
1029     LONG *pIndex)
1030 {
1031     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1032     if (!This->reOle)
1033         return CO_E_RELEASED;
1034
1035     FIXME("not implemented\n");
1036     return E_NOTIMPL;
1037 }
1038
1039 static HRESULT WINAPI ITextSelection_fnSetIndex(
1040     ITextSelection *me,
1041     LONG Unit,
1042     LONG Index,
1043     LONG Extend)
1044 {
1045     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1046     if (!This->reOle)
1047         return CO_E_RELEASED;
1048
1049     FIXME("not implemented\n");
1050     return E_NOTIMPL;
1051 }
1052
1053 static HRESULT WINAPI ITextSelection_fnSetRange(
1054     ITextSelection *me,
1055     LONG cpActive,
1056     LONG cpOther)
1057 {
1058     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1059     if (!This->reOle)
1060         return CO_E_RELEASED;
1061
1062     FIXME("not implemented\n");
1063     return E_NOTIMPL;
1064 }
1065
1066 static HRESULT WINAPI ITextSelection_fnInRange(
1067     ITextSelection *me,
1068     ITextRange *pRange,
1069     LONG *pb)
1070 {
1071     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1072     if (!This->reOle)
1073         return CO_E_RELEASED;
1074
1075     FIXME("not implemented\n");
1076     return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI ITextSelection_fnInStory(
1080     ITextSelection *me,
1081     ITextRange *pRange,
1082     LONG *pb)
1083 {
1084     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1085     if (!This->reOle)
1086         return CO_E_RELEASED;
1087
1088     FIXME("not implemented\n");
1089     return E_NOTIMPL;
1090 }
1091
1092 static HRESULT WINAPI ITextSelection_fnIsEqual(
1093     ITextSelection *me,
1094     ITextRange *pRange,
1095     LONG *pb)
1096 {
1097     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1098     if (!This->reOle)
1099         return CO_E_RELEASED;
1100
1101     FIXME("not implemented\n");
1102     return E_NOTIMPL;
1103 }
1104
1105 static HRESULT WINAPI ITextSelection_fnSelect(
1106     ITextSelection *me)
1107 {
1108     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1109     if (!This->reOle)
1110         return CO_E_RELEASED;
1111
1112     FIXME("not implemented\n");
1113     return E_NOTIMPL;
1114 }
1115
1116 static HRESULT WINAPI ITextSelection_fnStartOf(
1117     ITextSelection *me,
1118     LONG Unit,
1119     LONG Extend,
1120     LONG *pDelta)
1121 {
1122     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1123     if (!This->reOle)
1124         return CO_E_RELEASED;
1125
1126     FIXME("not implemented\n");
1127     return E_NOTIMPL;
1128 }
1129
1130 static HRESULT WINAPI ITextSelection_fnEndOf(
1131     ITextSelection *me,
1132     LONG Unit,
1133     LONG Extend,
1134     LONG *pDelta)
1135 {
1136     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1137     if (!This->reOle)
1138         return CO_E_RELEASED;
1139
1140     FIXME("not implemented\n");
1141     return E_NOTIMPL;
1142 }
1143
1144 static HRESULT WINAPI ITextSelection_fnMove(
1145     ITextSelection *me,
1146     LONG Unit,
1147     LONG Count,
1148     LONG *pDelta)
1149 {
1150     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1151     if (!This->reOle)
1152         return CO_E_RELEASED;
1153
1154     FIXME("not implemented\n");
1155     return E_NOTIMPL;
1156 }
1157
1158 static HRESULT WINAPI ITextSelection_fnMoveStart(
1159     ITextSelection *me,
1160     LONG Unit,
1161     LONG Count,
1162     LONG *pDelta)
1163 {
1164     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1165     if (!This->reOle)
1166         return CO_E_RELEASED;
1167
1168     FIXME("not implemented\n");
1169     return E_NOTIMPL;
1170 }
1171
1172 static HRESULT WINAPI ITextSelection_fnMoveEnd(
1173     ITextSelection *me,
1174     LONG Unit,
1175     LONG Count,
1176     LONG *pDelta)
1177 {
1178     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1179     if (!This->reOle)
1180         return CO_E_RELEASED;
1181
1182     FIXME("not implemented\n");
1183     return E_NOTIMPL;
1184 }
1185
1186 static HRESULT WINAPI ITextSelection_fnMoveWhile(
1187     ITextSelection *me,
1188     VARIANT *Cset,
1189     LONG Count,
1190     LONG *pDelta)
1191 {
1192     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1193     if (!This->reOle)
1194         return CO_E_RELEASED;
1195
1196     FIXME("not implemented\n");
1197     return E_NOTIMPL;
1198 }
1199
1200 static HRESULT WINAPI ITextSelection_fnMoveStartWhile(
1201     ITextSelection *me,
1202     VARIANT *Cset,
1203     LONG Count,
1204     LONG *pDelta)
1205 {
1206     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1207     if (!This->reOle)
1208         return CO_E_RELEASED;
1209
1210     FIXME("not implemented\n");
1211     return E_NOTIMPL;
1212 }
1213
1214 static HRESULT WINAPI ITextSelection_fnMoveEndWhile(
1215     ITextSelection *me,
1216     VARIANT *Cset,
1217     LONG Count,
1218     LONG *pDelta)
1219 {
1220     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1221     if (!This->reOle)
1222         return CO_E_RELEASED;
1223
1224     FIXME("not implemented\n");
1225     return E_NOTIMPL;
1226 }
1227
1228 static HRESULT WINAPI ITextSelection_fnMoveUntil(
1229     ITextSelection *me,
1230     VARIANT *Cset,
1231     LONG Count,
1232     LONG *pDelta)
1233 {
1234     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1235     if (!This->reOle)
1236         return CO_E_RELEASED;
1237
1238     FIXME("not implemented\n");
1239     return E_NOTIMPL;
1240 }
1241
1242 static HRESULT WINAPI ITextSelection_fnMoveStartUntil(
1243     ITextSelection *me,
1244     VARIANT *Cset,
1245     LONG Count,
1246     LONG *pDelta)
1247 {
1248     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1249     if (!This->reOle)
1250         return CO_E_RELEASED;
1251
1252     FIXME("not implemented\n");
1253     return E_NOTIMPL;
1254 }
1255
1256 static HRESULT WINAPI ITextSelection_fnMoveEndUntil(
1257     ITextSelection *me,
1258     VARIANT *Cset,
1259     LONG Count,
1260     LONG *pDelta)
1261 {
1262     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1263     if (!This->reOle)
1264         return CO_E_RELEASED;
1265
1266     FIXME("not implemented\n");
1267     return E_NOTIMPL;
1268 }
1269
1270 static HRESULT WINAPI ITextSelection_fnFindText(
1271     ITextSelection *me,
1272     BSTR bstr,
1273     LONG cch,
1274     LONG Flags,
1275     LONG *pLength)
1276 {
1277     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1278     if (!This->reOle)
1279         return CO_E_RELEASED;
1280
1281     FIXME("not implemented\n");
1282     return E_NOTIMPL;
1283 }
1284
1285 static HRESULT WINAPI ITextSelection_fnFindTextStart(
1286     ITextSelection *me,
1287     BSTR bstr,
1288     LONG cch,
1289     LONG Flags,
1290     LONG *pLength)
1291 {
1292     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1293     if (!This->reOle)
1294         return CO_E_RELEASED;
1295
1296     FIXME("not implemented\n");
1297     return E_NOTIMPL;
1298 }
1299
1300 static HRESULT WINAPI ITextSelection_fnFindTextEnd(
1301     ITextSelection *me,
1302     BSTR bstr,
1303     LONG cch,
1304     LONG Flags,
1305     LONG *pLength)
1306 {
1307     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1308     if (!This->reOle)
1309         return CO_E_RELEASED;
1310
1311     FIXME("not implemented\n");
1312     return E_NOTIMPL;
1313 }
1314
1315 static HRESULT WINAPI ITextSelection_fnDelete(
1316     ITextSelection *me,
1317     LONG Unit,
1318     LONG Count,
1319     LONG *pDelta)
1320 {
1321     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1322     if (!This->reOle)
1323         return CO_E_RELEASED;
1324
1325     FIXME("not implemented\n");
1326     return E_NOTIMPL;
1327 }
1328
1329 static HRESULT WINAPI ITextSelection_fnCut(
1330     ITextSelection *me,
1331     VARIANT *pVar)
1332 {
1333     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1334     if (!This->reOle)
1335         return CO_E_RELEASED;
1336
1337     FIXME("not implemented\n");
1338     return E_NOTIMPL;
1339 }
1340
1341 static HRESULT WINAPI ITextSelection_fnCopy(
1342     ITextSelection *me,
1343     VARIANT *pVar)
1344 {
1345     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1346     if (!This->reOle)
1347         return CO_E_RELEASED;
1348
1349     FIXME("not implemented\n");
1350     return E_NOTIMPL;
1351 }
1352
1353 static HRESULT WINAPI ITextSelection_fnPaste(
1354     ITextSelection *me,
1355     VARIANT *pVar,
1356     LONG Format)
1357 {
1358     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1359     if (!This->reOle)
1360         return CO_E_RELEASED;
1361
1362     FIXME("not implemented\n");
1363     return E_NOTIMPL;
1364 }
1365
1366 static HRESULT WINAPI ITextSelection_fnCanPaste(
1367     ITextSelection *me,
1368     VARIANT *pVar,
1369     LONG Format,
1370     LONG *pb)
1371 {
1372     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1373     if (!This->reOle)
1374         return CO_E_RELEASED;
1375
1376     FIXME("not implemented\n");
1377     return E_NOTIMPL;
1378 }
1379
1380 static HRESULT WINAPI ITextSelection_fnCanEdit(
1381     ITextSelection *me,
1382     LONG *pb)
1383 {
1384     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1385     if (!This->reOle)
1386         return CO_E_RELEASED;
1387
1388     FIXME("not implemented\n");
1389     return E_NOTIMPL;
1390 }
1391
1392 static HRESULT WINAPI ITextSelection_fnChangeCase(
1393     ITextSelection *me,
1394     LONG Type)
1395 {
1396     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1397     if (!This->reOle)
1398         return CO_E_RELEASED;
1399
1400     FIXME("not implemented\n");
1401     return E_NOTIMPL;
1402 }
1403
1404 static HRESULT WINAPI ITextSelection_fnGetPoint(
1405     ITextSelection *me,
1406     LONG Type,
1407     LONG *cx,
1408     LONG *cy)
1409 {
1410     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1411     if (!This->reOle)
1412         return CO_E_RELEASED;
1413
1414     FIXME("not implemented\n");
1415     return E_NOTIMPL;
1416 }
1417
1418 static HRESULT WINAPI ITextSelection_fnSetPoint(
1419     ITextSelection *me,
1420     LONG x,
1421     LONG y,
1422     LONG Type,
1423     LONG Extend)
1424 {
1425     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1426     if (!This->reOle)
1427         return CO_E_RELEASED;
1428
1429     FIXME("not implemented\n");
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT WINAPI ITextSelection_fnScrollIntoView(
1434     ITextSelection *me,
1435     LONG Value)
1436 {
1437     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1438     if (!This->reOle)
1439         return CO_E_RELEASED;
1440
1441     FIXME("not implemented\n");
1442     return E_NOTIMPL;
1443 }
1444
1445 static HRESULT WINAPI ITextSelection_fnGetEmbeddedObject(
1446     ITextSelection *me,
1447     IUnknown **ppv)
1448 {
1449     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1450     if (!This->reOle)
1451         return CO_E_RELEASED;
1452
1453     FIXME("not implemented\n");
1454     return E_NOTIMPL;
1455 }
1456
1457 /*** ITextSelection methods ***/
1458 static HRESULT WINAPI ITextSelection_fnGetFlags(
1459     ITextSelection *me,
1460     LONG *pFlags)
1461 {
1462     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1463     if (!This->reOle)
1464         return CO_E_RELEASED;
1465
1466     FIXME("not implemented\n");
1467     return E_NOTIMPL;
1468 }
1469
1470 static HRESULT WINAPI ITextSelection_fnSetFlags(
1471     ITextSelection *me,
1472     LONG Flags)
1473 {
1474     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1475     if (!This->reOle)
1476         return CO_E_RELEASED;
1477
1478     FIXME("not implemented\n");
1479     return E_NOTIMPL;
1480 }
1481
1482 static HRESULT WINAPI ITextSelection_fnGetType(
1483     ITextSelection *me,
1484     LONG *pType)
1485 {
1486     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1487     if (!This->reOle)
1488         return CO_E_RELEASED;
1489
1490     FIXME("not implemented\n");
1491     return E_NOTIMPL;
1492 }
1493
1494 static HRESULT WINAPI ITextSelection_fnMoveLeft(
1495     ITextSelection *me,
1496     LONG Unit,
1497     LONG Count,
1498     LONG Extend,
1499     LONG *pDelta)
1500 {
1501     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1502     if (!This->reOle)
1503         return CO_E_RELEASED;
1504
1505     FIXME("not implemented\n");
1506     return E_NOTIMPL;
1507 }
1508
1509 static HRESULT WINAPI ITextSelection_fnMoveRight(
1510     ITextSelection *me,
1511     LONG Unit,
1512     LONG Count,
1513     LONG Extend,
1514     LONG *pDelta)
1515 {
1516     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1517     if (!This->reOle)
1518         return CO_E_RELEASED;
1519
1520     FIXME("not implemented\n");
1521     return E_NOTIMPL;
1522 }
1523
1524 static HRESULT WINAPI ITextSelection_fnMoveUp(
1525     ITextSelection *me,
1526     LONG Unit,
1527     LONG Count,
1528     LONG Extend,
1529     LONG *pDelta)
1530 {
1531     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1532     if (!This->reOle)
1533         return CO_E_RELEASED;
1534
1535     FIXME("not implemented\n");
1536     return E_NOTIMPL;
1537 }
1538
1539 static HRESULT WINAPI ITextSelection_fnMoveDown(
1540     ITextSelection *me,
1541     LONG Unit,
1542     LONG Count,
1543     LONG Extend,
1544     LONG *pDelta)
1545 {
1546     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1547     if (!This->reOle)
1548         return CO_E_RELEASED;
1549
1550     FIXME("not implemented\n");
1551     return E_NOTIMPL;
1552 }
1553
1554 static HRESULT WINAPI ITextSelection_fnHomeKey(
1555     ITextSelection *me,
1556     LONG Unit,
1557     LONG Extend,
1558     LONG *pDelta)
1559 {
1560     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1561     if (!This->reOle)
1562         return CO_E_RELEASED;
1563
1564     FIXME("not implemented\n");
1565     return E_NOTIMPL;
1566 }
1567
1568 static HRESULT WINAPI ITextSelection_fnEndKey(
1569     ITextSelection *me,
1570     LONG Unit,
1571     LONG Extend,
1572     LONG *pDelta)
1573 {
1574     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1575     if (!This->reOle)
1576         return CO_E_RELEASED;
1577
1578     FIXME("not implemented\n");
1579     return E_NOTIMPL;
1580 }
1581
1582 static HRESULT WINAPI ITextSelection_fnTypeText(
1583     ITextSelection *me,
1584     BSTR bstr)
1585 {
1586     ITextSelectionImpl *This = (ITextSelectionImpl *) me;
1587     if (!This->reOle)
1588         return CO_E_RELEASED;
1589
1590     FIXME("not implemented\n");
1591     return E_NOTIMPL;
1592 }
1593
1594 static const ITextSelectionVtbl tsvt = {
1595     ITextSelection_fnQueryInterface,
1596     ITextSelection_fnAddRef,
1597     ITextSelection_fnRelease,
1598     ITextSelection_fnGetTypeInfoCount,
1599     ITextSelection_fnGetTypeInfo,
1600     ITextSelection_fnGetIDsOfNames,
1601     ITextSelection_fnInvoke,
1602     ITextSelection_fnGetText,
1603     ITextSelection_fnSetText,
1604     ITextSelection_fnGetChar,
1605     ITextSelection_fnSetChar,
1606     ITextSelection_fnGetDuplicate,
1607     ITextSelection_fnGetFormattedText,
1608     ITextSelection_fnSetFormattedText,
1609     ITextSelection_fnGetStart,
1610     ITextSelection_fnSetStart,
1611     ITextSelection_fnGetEnd,
1612     ITextSelection_fnSetEnd,
1613     ITextSelection_fnGetFont,
1614     ITextSelection_fnSetFont,
1615     ITextSelection_fnGetPara,
1616     ITextSelection_fnSetPara,
1617     ITextSelection_fnGetStoryLength,
1618     ITextSelection_fnGetStoryType,
1619     ITextSelection_fnCollapse,
1620     ITextSelection_fnExpand,
1621     ITextSelection_fnGetIndex,
1622     ITextSelection_fnSetIndex,
1623     ITextSelection_fnSetRange,
1624     ITextSelection_fnInRange,
1625     ITextSelection_fnInStory,
1626     ITextSelection_fnIsEqual,
1627     ITextSelection_fnSelect,
1628     ITextSelection_fnStartOf,
1629     ITextSelection_fnEndOf,
1630     ITextSelection_fnMove,
1631     ITextSelection_fnMoveStart,
1632     ITextSelection_fnMoveEnd,
1633     ITextSelection_fnMoveWhile,
1634     ITextSelection_fnMoveStartWhile,
1635     ITextSelection_fnMoveEndWhile,
1636     ITextSelection_fnMoveUntil,
1637     ITextSelection_fnMoveStartUntil,
1638     ITextSelection_fnMoveEndUntil,
1639     ITextSelection_fnFindText,
1640     ITextSelection_fnFindTextStart,
1641     ITextSelection_fnFindTextEnd,
1642     ITextSelection_fnDelete,
1643     ITextSelection_fnCut,
1644     ITextSelection_fnCopy,
1645     ITextSelection_fnPaste,
1646     ITextSelection_fnCanPaste,
1647     ITextSelection_fnCanEdit,
1648     ITextSelection_fnChangeCase,
1649     ITextSelection_fnGetPoint,
1650     ITextSelection_fnSetPoint,
1651     ITextSelection_fnScrollIntoView,
1652     ITextSelection_fnGetEmbeddedObject,
1653     ITextSelection_fnGetFlags,
1654     ITextSelection_fnSetFlags,
1655     ITextSelection_fnGetType,
1656     ITextSelection_fnMoveLeft,
1657     ITextSelection_fnMoveRight,
1658     ITextSelection_fnMoveUp,
1659     ITextSelection_fnMoveDown,
1660     ITextSelection_fnHomeKey,
1661     ITextSelection_fnEndKey,
1662     ITextSelection_fnTypeText
1663 };
1664
1665 static ITextSelectionImpl *
1666 CreateTextSelection(IRichEditOleImpl *reOle)
1667 {
1668     ITextSelectionImpl *txtSel = heap_alloc(sizeof *txtSel);
1669     if (!txtSel)
1670         return NULL;
1671
1672     txtSel->lpVtbl = &tsvt;
1673     txtSel->ref = 1;
1674     txtSel->reOle = reOle;
1675     return txtSel;
1676 }
1677
1678 LRESULT CreateIRichEditOle(ME_TextEditor *editor, LPVOID *ppObj)
1679 {
1680     IRichEditOleImpl *reo;
1681
1682     reo = heap_alloc(sizeof(IRichEditOleImpl));
1683     if (!reo)
1684         return 0;
1685
1686     reo->lpRichEditOleVtbl = &revt;
1687     reo->lpTextDocumentVtbl = &tdvt;
1688     reo->ref = 1;
1689     reo->editor = editor;
1690     reo->txtSel = CreateTextSelection(reo);
1691     if (!reo->txtSel)
1692     {
1693         heap_free(reo);
1694         return 0;
1695     }
1696     reo->clientSite = CreateOleClientSite(reo);
1697     if (!reo->txtSel)
1698     {
1699         ITextSelection_Release((ITextSelection *) reo->txtSel);
1700         heap_free(reo);
1701         return 0;
1702     }
1703     TRACE("Created %p\n",reo);
1704     *ppObj = reo;
1705
1706     return 1;
1707 }
1708
1709 static void convert_sizel(ME_Context *c, const SIZEL* szl, SIZE* sz)
1710 {
1711   /* sizel is in .01 millimeters, sz in pixels */
1712   sz->cx = MulDiv(szl->cx, c->dpi.cx, 2540);
1713   sz->cy = MulDiv(szl->cy, c->dpi.cy, 2540);
1714 }
1715
1716 /******************************************************************************
1717  * ME_GetOLEObjectSize
1718  *
1719  * Sets run extent for OLE objects.
1720  */
1721 void ME_GetOLEObjectSize(ME_Context *c, ME_Run *run, SIZE *pSize)
1722 {
1723   IDataObject*  ido;
1724   FORMATETC     fmt;
1725   STGMEDIUM     stgm;
1726   DIBSECTION    dibsect;
1727   ENHMETAHEADER emh;
1728
1729   assert(run->nFlags & MERF_GRAPHICS);
1730   assert(run->ole_obj);
1731
1732   if (run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0)
1733   {
1734     convert_sizel(c, &run->ole_obj->sizel, pSize);
1735     return;
1736   }
1737
1738   IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido);
1739   fmt.cfFormat = CF_BITMAP;
1740   fmt.ptd = NULL;
1741   fmt.dwAspect = DVASPECT_CONTENT;
1742   fmt.lindex = -1;
1743   fmt.tymed = TYMED_GDI;
1744   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
1745   {
1746     fmt.cfFormat = CF_ENHMETAFILE;
1747     fmt.tymed = TYMED_ENHMF;
1748     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
1749     {
1750       FIXME("unsupported format\n");
1751       pSize->cx = pSize->cy = 0;
1752       IDataObject_Release(ido);
1753       return;
1754     }
1755   }
1756
1757   switch (stgm.tymed)
1758   {
1759   case TYMED_GDI:
1760     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
1761     pSize->cx = dibsect.dsBm.bmWidth;
1762     pSize->cy = dibsect.dsBm.bmHeight;
1763     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
1764     break;
1765   case TYMED_ENHMF:
1766     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
1767     pSize->cx = emh.rclBounds.right - emh.rclBounds.left;
1768     pSize->cy = emh.rclBounds.bottom - emh.rclBounds.top;
1769     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
1770     break;
1771   default:
1772     FIXME("Unsupported tymed %d\n", stgm.tymed);
1773     break;
1774   }
1775   IDataObject_Release(ido);
1776   if (c->editor->nZoomNumerator != 0)
1777   {
1778     pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1779     pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1780   }
1781 }
1782
1783 void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run,
1784                 ME_Paragraph *para, BOOL selected)
1785 {
1786   IDataObject*  ido;
1787   FORMATETC     fmt;
1788   STGMEDIUM     stgm;
1789   DIBSECTION    dibsect;
1790   ENHMETAHEADER emh;
1791   HDC           hMemDC;
1792   SIZE          sz;
1793   BOOL          has_size;
1794
1795   assert(run->nFlags & MERF_GRAPHICS);
1796   assert(run->ole_obj);
1797   if (IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
1798   {
1799     FIXME("Couldn't get interface\n");
1800     return;
1801   }
1802   has_size = run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0;
1803   fmt.cfFormat = CF_BITMAP;
1804   fmt.ptd = NULL;
1805   fmt.dwAspect = DVASPECT_CONTENT;
1806   fmt.lindex = -1;
1807   fmt.tymed = TYMED_GDI;
1808   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
1809   {
1810     fmt.cfFormat = CF_ENHMETAFILE;
1811     fmt.tymed = TYMED_ENHMF;
1812     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
1813     {
1814       FIXME("Couldn't get storage medium\n");
1815       IDataObject_Release(ido);
1816       return;
1817     }
1818   }
1819   switch (stgm.tymed)
1820   {
1821   case TYMED_GDI:
1822     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
1823     hMemDC = CreateCompatibleDC(c->hDC);
1824     SelectObject(hMemDC, stgm.u.hBitmap);
1825     if (!has_size && c->editor->nZoomNumerator == 0)
1826     {
1827       sz.cx = dibsect.dsBm.bmWidth;
1828       sz.cy = dibsect.dsBm.bmHeight;
1829       BitBlt(c->hDC, x, y - dibsect.dsBm.bmHeight,
1830              dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight,
1831              hMemDC, 0, 0, SRCCOPY);
1832     }
1833     else
1834     {
1835       if (has_size)
1836       {
1837         convert_sizel(c, &run->ole_obj->sizel, &sz);
1838       }
1839       else
1840       {
1841         sz.cx = MulDiv(dibsect.dsBm.bmWidth,
1842                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1843         sz.cy = MulDiv(dibsect.dsBm.bmHeight,
1844                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1845       }
1846       StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
1847                  hMemDC, 0, 0, dibsect.dsBm.bmWidth, 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 && c->editor->nZoomNumerator == 0)
1854     {
1855       sz.cy = emh.rclBounds.bottom - emh.rclBounds.top;
1856       sz.cx = emh.rclBounds.right - emh.rclBounds.left;
1857     }
1858     else
1859     {
1860       if (has_size)
1861       {
1862         convert_sizel(c, &run->ole_obj->sizel, &sz);
1863       }
1864       else
1865       {
1866         sz.cy = MulDiv(emh.rclBounds.bottom - emh.rclBounds.top,
1867                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1868         sz.cx = MulDiv(emh.rclBounds.right - emh.rclBounds.left,
1869                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
1870       }
1871     }
1872     {
1873       RECT    rc;
1874
1875       rc.left = x;
1876       rc.top = y - sz.cy;
1877       rc.right = x + sz.cx;
1878       rc.bottom = y;
1879       PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
1880     }
1881     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
1882     break;
1883   default:
1884     FIXME("Unsupported tymed %d\n", stgm.tymed);
1885     selected = FALSE;
1886     break;
1887   }
1888   if (selected && !c->editor->bHideSelection)
1889     PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
1890   IDataObject_Release(ido);
1891 }
1892
1893 void ME_DeleteReObject(REOBJECT* reo)
1894 {
1895     if (reo->poleobj)   IOleObject_Release(reo->poleobj);
1896     if (reo->pstg)      IStorage_Release(reo->pstg);
1897     if (reo->polesite)  IOleClientSite_Release(reo->polesite);
1898     FREE_OBJ(reo);
1899 }
1900
1901 void ME_CopyReObject(REOBJECT* dst, const REOBJECT* src)
1902 {
1903     *dst = *src;
1904
1905     if (dst->poleobj)   IOleObject_AddRef(dst->poleobj);
1906     if (dst->pstg)      IStorage_AddRef(dst->pstg);
1907     if (dst->polesite)  IOleClientSite_AddRef(dst->polesite);
1908 }