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 #include "initguid.h"
  43 DEFINE_GUID(IID_ITextServices, 0x8d33f740, 0xcf58, 0x11ce, 0xa8, 0x9d, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5);
  44 DEFINE_GUID(IID_ITextHost, 0x13e670f4,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1);
  45 DEFINE_GUID(IID_ITextHost2, 0x13e670f5,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1);
  46 DEFINE_GUID(IID_ITextDocument, 0x8cc497c0, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  47 DEFINE_GUID(IID_ITextRange, 0x8cc497c2, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  48 DEFINE_GUID(IID_ITextSelection, 0x8cc497c1, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  49
  50 typedef struct ITextSelectionImpl ITextSelectionImpl;
  51 typedef struct IOleClientSiteImpl IOleClientSiteImpl;
  52 typedef struct ITextRangeImpl ITextRangeImpl;
  53
  54 typedef struct IRichEditOleImpl {
  55     IUnknown IUnknown_inner;
  56     IRichEditOle IRichEditOle_iface;
  57     ITextDocument ITextDocument_iface;
  58     IUnknown *outer_unk;
  59     LONG ref;
  60
  61     ME_TextEditor *editor;
  62     ITextSelectionImpl *txtSel;
  63     IOleClientSiteImpl *clientSite;
  64     struct list rangelist;
  65 } IRichEditOleImpl;
  66
  67 struct ITextRangeImpl {
  68     ITextRange ITextRange_iface;
  69     LONG ref;
  70     LONG start, end;
  71     struct list entry;
  72
  73     IRichEditOleImpl *reOle;
  74 };
  75
  76 struct ITextSelectionImpl {
  77     ITextSelection ITextSelection_iface;
  78     LONG ref;
  79
  80     IRichEditOleImpl *reOle;
  81 };
  82
  83 struct IOleClientSiteImpl {
  84     IOleClientSite IOleClientSite_iface;
  85     LONG ref;
  86
  87     IRichEditOleImpl *reOle;
  88 };
  89
  90 static inline IRichEditOleImpl *impl_from_IRichEditOle(IRichEditOle *iface)
  91 {
  92     return CONTAINING_RECORD(iface, IRichEditOleImpl, IRichEditOle_iface);
  93 }
  94
  95 static inline IRichEditOleImpl *impl_from_ITextDocument(ITextDocument *iface)
  96 {
  97     return CONTAINING_RECORD(iface, IRichEditOleImpl, ITextDocument_iface);
  98 }
  99
 100 static inline IRichEditOleImpl *impl_from_IUnknown(IUnknown *iface)
 101 {
 102     return CONTAINING_RECORD(iface, IRichEditOleImpl, IUnknown_inner);
 103 }
 104
 105 static HRESULT WINAPI IRichEditOleImpl_inner_fnQueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppvObj)
 106 {
 107     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 108
 109     TRACE("%p %s\n", This, debugstr_guid(riid));
 110
 111     *ppvObj = NULL;
 112     if (IsEqualGUID(riid, &IID_IUnknown))
 113         *ppvObj = &This->IUnknown_inner;
 114     else if (IsEqualGUID(riid, &IID_IRichEditOle))
 115         *ppvObj = &This->IRichEditOle_iface;
 116     else if (IsEqualGUID(riid, &IID_ITextDocument))
 117         *ppvObj = &This->ITextDocument_iface;
 118     if (*ppvObj)
 119     {
 120         IUnknown_AddRef((IUnknown *)*ppvObj);
 121         return S_OK;
 122     }
 123     FIXME("%p: unhandled interface %s\n", This, debugstr_guid(riid));
 124
 125     return E_NOINTERFACE;
 126 }
 127
 128 static ULONG WINAPI IRichEditOleImpl_inner_fnAddRef(IUnknown *iface)
 129 {
 130     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 131     ULONG ref = InterlockedIncrement(&This->ref);
 132
 133     TRACE("%p ref = %u\n", This, ref);
 134
 135     return ref;
 136 }
 137
 138 static ULONG WINAPI IRichEditOleImpl_inner_fnRelease(IUnknown *iface)
 139 {
 140     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 141     ULONG ref = InterlockedDecrement(&This->ref);
 142
 143     TRACE ("%p ref=%u\n", This, ref);
 144
 145     if (!ref)
 146     {
 147         ITextRangeImpl *txtRge;
 148
 149         TRACE("Destroying %p\n", This);
 150         This->txtSel->reOle = NULL;
 151         This->editor->reOle = NULL;
 152         ITextSelection_Release(&This->txtSel->ITextSelection_iface);
 153         IOleClientSite_Release(&This->clientSite->IOleClientSite_iface);
 154         LIST_FOR_EACH_ENTRY(txtRge, &This->rangelist, ITextRangeImpl, entry)
 155             txtRge->reOle = NULL;
 156         heap_free(This);
 157     }
 158     return ref;
 159 }
 160
 161 static const IUnknownVtbl reo_unk_vtbl =
 162 {
 163     IRichEditOleImpl_inner_fnQueryInterface,
 164     IRichEditOleImpl_inner_fnAddRef,
 165     IRichEditOleImpl_inner_fnRelease
 166 };
 167
 168 static HRESULT WINAPI
 169 IRichEditOle_fnQueryInterface(IRichEditOle *me, REFIID riid, LPVOID *ppvObj)
 170 {
 171     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 172     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
 173 }
 174
 175 static ULONG WINAPI
 176 IRichEditOle_fnAddRef(IRichEditOle *me)
 177 {
 178     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 179     return IUnknown_AddRef(This->outer_unk);
 180 }
 181
 182 static ULONG WINAPI
 183 IRichEditOle_fnRelease(IRichEditOle *me)
 184 {
 185     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 186     return IUnknown_Release(This->outer_unk);
 187 }
 188
 189 static HRESULT WINAPI
 190 IRichEditOle_fnActivateAs(IRichEditOle *me, REFCLSID rclsid, REFCLSID rclsidAs)
 191 {
 192     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 193     FIXME("stub %p\n",This);
 194     return E_NOTIMPL;
 195 }
 196
 197 static HRESULT WINAPI
 198 IRichEditOle_fnContextSensitiveHelp(IRichEditOle *me, BOOL fEnterMode)
 199 {
 200     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 201     FIXME("stub %p\n",This);
 202     return E_NOTIMPL;
 203 }
 204
 205 static HRESULT WINAPI
 206 IRichEditOle_fnConvertObject(IRichEditOle *me, LONG iob,
 207                REFCLSID rclsidNew, LPCSTR lpstrUserTypeNew)
 208 {
 209     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 210     FIXME("stub %p\n",This);
 211     return E_NOTIMPL;
 212 }
 213
 214 static inline IOleClientSiteImpl *impl_from_IOleClientSite(IOleClientSite *iface)
 215 {
 216     return CONTAINING_RECORD(iface, IOleClientSiteImpl, IOleClientSite_iface);
 217 }
 218
 219 static HRESULT WINAPI
 220 IOleClientSite_fnQueryInterface(IOleClientSite *me, REFIID riid, LPVOID *ppvObj)
 221 {
 222     TRACE("%p %s\n", me, debugstr_guid(riid) );
 223
 224     *ppvObj = NULL;
 225     if (IsEqualGUID(riid, &IID_IUnknown) ||
 226         IsEqualGUID(riid, &IID_IOleClientSite))
 227         *ppvObj = me;
 228     if (*ppvObj)
 229     {
 230         IOleClientSite_AddRef(me);
 231         return S_OK;
 232     }
 233     FIXME("%p: unhandled interface %s\n", me, debugstr_guid(riid) );
 234
 235     return E_NOINTERFACE;
 236 }
 237
 238 static ULONG WINAPI IOleClientSite_fnAddRef(IOleClientSite *iface)
 239 {
 240     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 241     return InterlockedIncrement(&This->ref);
 242 }
 243
 244 static ULONG WINAPI IOleClientSite_fnRelease(IOleClientSite *iface)
 245 {
 246     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 247     ULONG ref = InterlockedDecrement(&This->ref);
 248     if (ref == 0)
 249         heap_free(This);
 250     return ref;
 251 }
 252
 253 static HRESULT WINAPI IOleClientSite_fnSaveObject(IOleClientSite *iface)
 254 {
 255     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 256     if (!This->reOle)
 257         return CO_E_RELEASED;
 258
 259     FIXME("stub %p\n", iface);
 260     return E_NOTIMPL;
 261 }
 262
 263
 264 static HRESULT WINAPI IOleClientSite_fnGetMoniker(IOleClientSite *iface, DWORD dwAssign,
 265         DWORD dwWhichMoniker, IMoniker **ppmk)
 266 {
 267     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 268     if (!This->reOle)
 269         return CO_E_RELEASED;
 270
 271     FIXME("stub %p\n", iface);
 272     return E_NOTIMPL;
 273 }
 274
 275 static HRESULT WINAPI IOleClientSite_fnGetContainer(IOleClientSite *iface,
 276         IOleContainer **ppContainer)
 277 {
 278     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 279     if (!This->reOle)
 280         return CO_E_RELEASED;
 281
 282     FIXME("stub %p\n", iface);
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT WINAPI IOleClientSite_fnShowObject(IOleClientSite *iface)
 287 {
 288     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 289     if (!This->reOle)
 290         return CO_E_RELEASED;
 291
 292     FIXME("stub %p\n", iface);
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI IOleClientSite_fnOnShowWindow(IOleClientSite *iface, BOOL fShow)
 297 {
 298     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 299     if (!This->reOle)
 300         return CO_E_RELEASED;
 301
 302     FIXME("stub %p\n", iface);
 303     return E_NOTIMPL;
 304 }
 305
 306 static HRESULT WINAPI IOleClientSite_fnRequestNewObjectLayout(IOleClientSite *iface)
 307 {
 308     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 309     if (!This->reOle)
 310         return CO_E_RELEASED;
 311
 312     FIXME("stub %p\n", iface);
 313     return E_NOTIMPL;
 314 }
 315
 316 static const IOleClientSiteVtbl ocst = {
 317     IOleClientSite_fnQueryInterface,
 318     IOleClientSite_fnAddRef,
 319     IOleClientSite_fnRelease,
 320     IOleClientSite_fnSaveObject,
 321     IOleClientSite_fnGetMoniker,
 322     IOleClientSite_fnGetContainer,
 323     IOleClientSite_fnShowObject,
 324     IOleClientSite_fnOnShowWindow,
 325     IOleClientSite_fnRequestNewObjectLayout
 326 };
 327
 328 static IOleClientSiteImpl *
 329 CreateOleClientSite(IRichEditOleImpl *reOle)
 330 {
 331     IOleClientSiteImpl *clientSite = heap_alloc(sizeof *clientSite);
 332     if (!clientSite)
 333         return NULL;
 334
 335     clientSite->IOleClientSite_iface.lpVtbl = &ocst;
 336     clientSite->ref = 1;
 337     clientSite->reOle = reOle;
 338     return clientSite;
 339 }
 340
 341 static HRESULT WINAPI
 342 IRichEditOle_fnGetClientSite(IRichEditOle *me,
 343                LPOLECLIENTSITE *lplpolesite)
 344 {
 345     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 346
 347     TRACE("%p,%p\n",This, lplpolesite);
 348
 349     if(!lplpolesite)
 350         return E_INVALIDARG;
 351     *lplpolesite = &This->clientSite->IOleClientSite_iface;
 352     IOleClientSite_AddRef(*lplpolesite);
 353     return S_OK;
 354 }
 355
 356 static HRESULT WINAPI
 357 IRichEditOle_fnGetClipboardData(IRichEditOle *me, CHARRANGE *lpchrg,
 358                DWORD reco, LPDATAOBJECT *lplpdataobj)
 359 {
 360     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 361     ME_Cursor start;
 362     int nChars;
 363
 364     TRACE("(%p,%p,%d)\n",This, lpchrg, reco);
 365     if(!lplpdataobj)
 366         return E_INVALIDARG;
 367     if(!lpchrg) {
 368         int nFrom, nTo, nStartCur = ME_GetSelectionOfs(This->editor, &nFrom, &nTo);
 369         start = This->editor->pCursors[nStartCur];
 370         nChars = nTo - nFrom;
 371     } else {
 372         ME_CursorFromCharOfs(This->editor, lpchrg->cpMin, &start);
 373         nChars = lpchrg->cpMax - lpchrg->cpMin;
 374     }
 375     return ME_GetDataObject(This->editor, &start, nChars, lplpdataobj);
 376 }
 377
 378 static LONG WINAPI IRichEditOle_fnGetLinkCount(IRichEditOle *me)
 379 {
 380     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 381     FIXME("stub %p\n",This);
 382     return E_NOTIMPL;
 383 }
 384
 385 static HRESULT WINAPI
 386 IRichEditOle_fnGetObject(IRichEditOle *me, LONG iob,
 387                REOBJECT *lpreobject, DWORD dwFlags)
 388 {
 389     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 390     FIXME("stub %p\n",This);
 391     return E_NOTIMPL;
 392 }
 393
 394 static LONG WINAPI
 395 IRichEditOle_fnGetObjectCount(IRichEditOle *me)
 396 {
 397     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 398     FIXME("stub %p\n",This);
 399     return 0;
 400 }
 401
 402 static HRESULT WINAPI
 403 IRichEditOle_fnHandsOffStorage(IRichEditOle *me, LONG iob)
 404 {
 405     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 406     FIXME("stub %p\n",This);
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT WINAPI
 411 IRichEditOle_fnImportDataObject(IRichEditOle *me, LPDATAOBJECT lpdataobj,
 412                CLIPFORMAT cf, HGLOBAL hMetaPict)
 413 {
 414     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 415     FIXME("stub %p\n",This);
 416     return E_NOTIMPL;
 417 }
 418
 419 static HRESULT WINAPI
 420 IRichEditOle_fnInPlaceDeactivate(IRichEditOle *me)
 421 {
 422     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 423     FIXME("stub %p\n",This);
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI
 428 IRichEditOle_fnInsertObject(IRichEditOle *me, REOBJECT *reo)
 429 {
 430     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 431     TRACE("(%p,%p)\n", This, reo);
 432
 433     if (reo->cbStruct < sizeof(*reo)) return STG_E_INVALIDPARAMETER;
 434
 435     ME_InsertOLEFromCursor(This->editor, reo, 0);
 436     ME_CommitUndo(This->editor);
 437     ME_UpdateRepaint(This->editor, FALSE);
 438     return S_OK;
 439 }
 440
 441 static HRESULT WINAPI IRichEditOle_fnSaveCompleted(IRichEditOle *me, LONG iob,
 442                LPSTORAGE lpstg)
 443 {
 444     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 445     FIXME("stub %p\n",This);
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI
 450 IRichEditOle_fnSetDvaspect(IRichEditOle *me, LONG iob, DWORD dvaspect)
 451 {
 452     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 453     FIXME("stub %p\n",This);
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI IRichEditOle_fnSetHostNames(IRichEditOle *me,
 458                LPCSTR lpstrContainerApp, LPCSTR lpstrContainerObj)
 459 {
 460     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 461     FIXME("stub %p %s %s\n",This, lpstrContainerApp, lpstrContainerObj);
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT WINAPI
 466 IRichEditOle_fnSetLinkAvailable(IRichEditOle *me, LONG iob, BOOL fAvailable)
 467 {
 468     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 469     FIXME("stub %p\n",This);
 470     return E_NOTIMPL;
 471 }
 472
 473 static const IRichEditOleVtbl revt = {
 474     IRichEditOle_fnQueryInterface,
 475     IRichEditOle_fnAddRef,
 476     IRichEditOle_fnRelease,
 477     IRichEditOle_fnGetClientSite,
 478     IRichEditOle_fnGetObjectCount,
 479     IRichEditOle_fnGetLinkCount,
 480     IRichEditOle_fnGetObject,
 481     IRichEditOle_fnInsertObject,
 482     IRichEditOle_fnConvertObject,
 483     IRichEditOle_fnActivateAs,
 484     IRichEditOle_fnSetHostNames,
 485     IRichEditOle_fnSetLinkAvailable,
 486     IRichEditOle_fnSetDvaspect,
 487     IRichEditOle_fnHandsOffStorage,
 488     IRichEditOle_fnSaveCompleted,
 489     IRichEditOle_fnInPlaceDeactivate,
 490     IRichEditOle_fnContextSensitiveHelp,
 491     IRichEditOle_fnGetClipboardData,
 492     IRichEditOle_fnImportDataObject
 493 };
 494
 495 /* ITextRange interface */
 496 static inline ITextRangeImpl *impl_from_ITextRange(ITextRange *iface)
 497 {
 498     return CONTAINING_RECORD(iface, ITextRangeImpl, ITextRange_iface);
 499 }
 500
 501 static HRESULT WINAPI ITextRange_fnQueryInterface(ITextRange *me, REFIID riid, void **ppvObj)
 502 {
 503     *ppvObj = NULL;
 504     if (IsEqualGUID(riid, &IID_IUnknown)
 505         || IsEqualGUID(riid, &IID_IDispatch)
 506         || IsEqualGUID(riid, &IID_ITextRange))
 507     {
 508         *ppvObj = me;
 509         ITextRange_AddRef(me);
 510         return S_OK;
 511     }
 512
 513     return E_NOINTERFACE;
 514 }
 515
 516 static ULONG WINAPI ITextRange_fnAddRef(ITextRange *me)
 517 {
 518     ITextRangeImpl *This = impl_from_ITextRange(me);
 519     return InterlockedIncrement(&This->ref);
 520 }
 521
 522 static ULONG WINAPI ITextRange_fnRelease(ITextRange *me)
 523 {
 524     ITextRangeImpl *This = impl_from_ITextRange(me);
 525     ULONG ref = InterlockedDecrement(&This->ref);
 526
 527     TRACE ("%p ref=%u\n", This, ref);
 528     if (ref == 0)
 529     {
 530         if (This->reOle)
 531         {
 532             list_remove(&This->entry);
 533             This->reOle = NULL;
 534         }
 535         heap_free(This);
 536     }
 537     return ref;
 538 }
 539
 540 static HRESULT WINAPI ITextRange_fnGetTypeInfoCount(ITextRange *me, UINT *pctinfo)
 541 {
 542     ITextRangeImpl *This = impl_from_ITextRange(me);
 543     if (!This->reOle)
 544         return CO_E_RELEASED;
 545
 546     FIXME("not implemented %p\n", This);
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI ITextRange_fnGetTypeInfo(ITextRange *me, UINT iTInfo, LCID lcid,
 551                                                ITypeInfo **ppTInfo)
 552 {
 553     ITextRangeImpl *This = impl_from_ITextRange(me);
 554     if (!This->reOle)
 555         return CO_E_RELEASED;
 556
 557     FIXME("not implemented %p\n", This);
 558     return E_NOTIMPL;
 559 }
 560
 561 static HRESULT WINAPI ITextRange_fnGetIDsOfNames(ITextRange *me, REFIID riid, LPOLESTR *rgszNames,
 562                                                  UINT cNames, LCID lcid, DISPID *rgDispId)
 563 {
 564     ITextRangeImpl *This = impl_from_ITextRange(me);
 565     if (!This->reOle)
 566         return CO_E_RELEASED;
 567
 568     FIXME("not implemented %p\n", This);
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI ITextRange_fnInvoke(ITextRange *me, DISPID dispIdMember, REFIID riid,
 573                                           LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 574                                           VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 575                                           UINT *puArgErr)
 576 {
 577     ITextRangeImpl *This = impl_from_ITextRange(me);
 578     if (!This->reOle)
 579         return CO_E_RELEASED;
 580
 581     FIXME("not implemented %p\n", This);
 582     return E_NOTIMPL;
 583 }
 584
 585 static HRESULT WINAPI ITextRange_fnGetText(ITextRange *me, BSTR *pbstr)
 586 {
 587     ITextRangeImpl *This = impl_from_ITextRange(me);
 588     if (!This->reOle)
 589         return CO_E_RELEASED;
 590
 591     FIXME("not implemented %p\n", This);
 592     return E_NOTIMPL;
 593 }
 594
 595 static HRESULT WINAPI ITextRange_fnSetText(ITextRange *me, BSTR bstr)
 596 {
 597     ITextRangeImpl *This = impl_from_ITextRange(me);
 598     if (!This->reOle)
 599         return CO_E_RELEASED;
 600
 601     FIXME("not implemented %p\n", This);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT range_GetChar(ME_TextEditor *editor, ME_Cursor *cursor, LONG *pch)
 606 {
 607     WCHAR wch[2];
 608
 609     ME_GetTextW(editor, wch, 1, cursor, 1, FALSE, cursor->pRun->next->type == diTextEnd);
 610     *pch = wch[0];
 611
 612     return S_OK;
 613 }
 614
 615 static HRESULT WINAPI ITextRange_fnGetChar(ITextRange *me, LONG *pch)
 616 {
 617     ITextRangeImpl *This = impl_from_ITextRange(me);
 618     ME_Cursor cursor;
 619
 620     if (!This->reOle)
 621         return CO_E_RELEASED;
 622     TRACE("%p\n", pch);
 623     if (!pch)
 624         return E_INVALIDARG;
 625
 626     ME_CursorFromCharOfs(This->reOle->editor, This->start, &cursor);
 627     return range_GetChar(This->reOle->editor, &cursor, pch);
 628 }
 629
 630 static HRESULT WINAPI ITextRange_fnSetChar(ITextRange *me, LONG ch)
 631 {
 632     ITextRangeImpl *This = impl_from_ITextRange(me);
 633     if (!This->reOle)
 634         return CO_E_RELEASED;
 635
 636     FIXME("not implemented %p\n", This);
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT CreateITextRange(IRichEditOleImpl *reOle, LONG start, LONG end, ITextRange** ppRange);
 641
 642 static HRESULT WINAPI ITextRange_fnGetDuplicate(ITextRange *me, ITextRange **ppRange)
 643 {
 644     ITextRangeImpl *This = impl_from_ITextRange(me);
 645     if (!This->reOle)
 646         return CO_E_RELEASED;
 647
 648     TRACE("%p %p\n", This, ppRange);
 649     if (!ppRange)
 650         return E_INVALIDARG;
 651
 652     return CreateITextRange(This->reOle, This->start, This->end, ppRange);
 653 }
 654
 655 static HRESULT WINAPI ITextRange_fnGetFormattedText(ITextRange *me, ITextRange **ppRange)
 656 {
 657     ITextRangeImpl *This = impl_from_ITextRange(me);
 658     if (!This->reOle)
 659         return CO_E_RELEASED;
 660
 661     FIXME("not implemented %p\n", This);
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT WINAPI ITextRange_fnSetFormattedText(ITextRange *me, ITextRange *pRange)
 666 {
 667     ITextRangeImpl *This = impl_from_ITextRange(me);
 668     if (!This->reOle)
 669         return CO_E_RELEASED;
 670
 671     FIXME("not implemented %p\n", This);
 672     return E_NOTIMPL;
 673 }
 674
 675 static HRESULT WINAPI ITextRange_fnGetStart(ITextRange *me, LONG *pcpFirst)
 676 {
 677     ITextRangeImpl *This = impl_from_ITextRange(me);
 678     if (!This->reOle)
 679         return CO_E_RELEASED;
 680
 681     if (!pcpFirst)
 682         return E_INVALIDARG;
 683     *pcpFirst = This->start;
 684     TRACE("%d\n", *pcpFirst);
 685     return S_OK;
 686 }
 687
 688 static HRESULT WINAPI ITextRange_fnSetStart(ITextRange *me, LONG cpFirst)
 689 {
 690     ITextRangeImpl *This = impl_from_ITextRange(me);
 691     if (!This->reOle)
 692         return CO_E_RELEASED;
 693
 694     FIXME("not implemented %p\n", This);
 695     return E_NOTIMPL;
 696 }
 697
 698 static HRESULT WINAPI ITextRange_fnGetEnd(ITextRange *me, LONG *pcpLim)
 699 {
 700     ITextRangeImpl *This = impl_from_ITextRange(me);
 701     if (!This->reOle)
 702         return CO_E_RELEASED;
 703
 704     if (!pcpLim)
 705         return E_INVALIDARG;
 706     *pcpLim = This->end;
 707     TRACE("%d\n", *pcpLim);
 708     return S_OK;
 709 }
 710
 711 static HRESULT WINAPI ITextRange_fnSetEnd(ITextRange *me, LONG cpLim)
 712 {
 713     ITextRangeImpl *This = impl_from_ITextRange(me);
 714     if (!This->reOle)
 715         return CO_E_RELEASED;
 716
 717     FIXME("not implemented %p\n", This);
 718     return E_NOTIMPL;
 719 }
 720
 721 static HRESULT WINAPI ITextRange_fnGetFont(ITextRange *me, ITextFont **pFont)
 722 {
 723     ITextRangeImpl *This = impl_from_ITextRange(me);
 724     if (!This->reOle)
 725         return CO_E_RELEASED;
 726
 727     FIXME("not implemented %p\n", This);
 728     return E_NOTIMPL;
 729 }
 730
 731 static HRESULT WINAPI ITextRange_fnSetFont(ITextRange *me, ITextFont *pFont)
 732 {
 733     ITextRangeImpl *This = impl_from_ITextRange(me);
 734     if (!This->reOle)
 735         return CO_E_RELEASED;
 736
 737     FIXME("not implemented %p\n", This);
 738     return E_NOTIMPL;
 739 }
 740
 741 static HRESULT WINAPI ITextRange_fnGetPara(ITextRange *me, ITextPara **ppPara)
 742 {
 743     ITextRangeImpl *This = impl_from_ITextRange(me);
 744     if (!This->reOle)
 745         return CO_E_RELEASED;
 746
 747     FIXME("not implemented %p\n", This);
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI ITextRange_fnSetPara(ITextRange *me, ITextPara *pPara)
 752 {
 753     ITextRangeImpl *This = impl_from_ITextRange(me);
 754     if (!This->reOle)
 755         return CO_E_RELEASED;
 756
 757     FIXME("not implemented %p\n", This);
 758     return E_NOTIMPL;
 759 }
 760
 761 static HRESULT WINAPI ITextRange_fnGetStoryLength(ITextRange *me, LONG *pcch)
 762 {
 763     ITextRangeImpl *This = impl_from_ITextRange(me);
 764     if (!This->reOle)
 765         return CO_E_RELEASED;
 766
 767     FIXME("not implemented %p\n", This);
 768     return E_NOTIMPL;
 769 }
 770
 771 static HRESULT WINAPI ITextRange_fnGetStoryType(ITextRange *me, LONG *pValue)
 772 {
 773     ITextRangeImpl *This = impl_from_ITextRange(me);
 774     if (!This->reOle)
 775         return CO_E_RELEASED;
 776
 777     FIXME("not implemented %p\n", This);
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT range_Collapse(LONG bStart, LONG *start, LONG *end)
 782 {
 783   if (*end == *start)
 784       return S_FALSE;
 785
 786   if (bStart == tomEnd || bStart == tomFalse)
 787       *start = *end;
 788   else
 789       *end = *start;
 790   return S_OK;
 791 }
 792
 793 static HRESULT WINAPI ITextRange_fnCollapse(ITextRange *me, LONG bStart)
 794 {
 795     ITextRangeImpl *This = impl_from_ITextRange(me);
 796     if (!This->reOle)
 797         return CO_E_RELEASED;
 798
 799     return range_Collapse(bStart, &This->start, &This->end);
 800 }
 801
 802 static HRESULT WINAPI ITextRange_fnExpand(ITextRange *me, LONG Unit, LONG *pDelta)
 803 {
 804     ITextRangeImpl *This = impl_from_ITextRange(me);
 805     if (!This->reOle)
 806         return CO_E_RELEASED;
 807
 808     FIXME("not implemented %p\n", This);
 809     return E_NOTIMPL;
 810 }
 811
 812 static HRESULT WINAPI ITextRange_fnGetIndex(ITextRange *me, LONG Unit, LONG *pIndex)
 813 {
 814     ITextRangeImpl *This = impl_from_ITextRange(me);
 815     if (!This->reOle)
 816         return CO_E_RELEASED;
 817
 818     FIXME("not implemented %p\n", This);
 819     return E_NOTIMPL;
 820 }
 821
 822 static HRESULT WINAPI ITextRange_fnSetIndex(ITextRange *me, LONG Unit, LONG Index,
 823                                             LONG Extend)
 824 {
 825     ITextRangeImpl *This = impl_from_ITextRange(me);
 826     if (!This->reOle)
 827         return CO_E_RELEASED;
 828
 829     FIXME("not implemented %p\n", This);
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI ITextRange_fnSetRange(ITextRange *me, LONG cpActive, LONG cpOther)
 834 {
 835     ITextRangeImpl *This = impl_from_ITextRange(me);
 836     if (!This->reOle)
 837         return CO_E_RELEASED;
 838
 839     FIXME("not implemented %p\n", This);
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI ITextRange_fnInRange(ITextRange *me, ITextRange *pRange, LONG *pb)
 844 {
 845     ITextRangeImpl *This = impl_from_ITextRange(me);
 846     if (!This->reOle)
 847         return CO_E_RELEASED;
 848
 849     FIXME("not implemented %p\n", This);
 850     return E_NOTIMPL;
 851 }
 852
 853 static HRESULT WINAPI ITextRange_fnInStory(ITextRange *me, ITextRange *pRange, LONG *pb)
 854 {
 855     ITextRangeImpl *This = impl_from_ITextRange(me);
 856     if (!This->reOle)
 857         return CO_E_RELEASED;
 858
 859     FIXME("not implemented %p\n", This);
 860     return E_NOTIMPL;
 861 }
 862
 863 static HRESULT WINAPI ITextRange_fnIsEqual(ITextRange *me, ITextRange *pRange, LONG *pb)
 864 {
 865     ITextRangeImpl *This = impl_from_ITextRange(me);
 866     if (!This->reOle)
 867         return CO_E_RELEASED;
 868
 869     FIXME("not implemented %p\n", This);
 870     return E_NOTIMPL;
 871 }
 872
 873 static HRESULT WINAPI ITextRange_fnSelect(ITextRange *me)
 874 {
 875     ITextRangeImpl *This = impl_from_ITextRange(me);
 876     if (!This->reOle)
 877         return CO_E_RELEASED;
 878
 879     FIXME("not implemented %p\n", This);
 880     return E_NOTIMPL;
 881 }
 882
 883 static HRESULT WINAPI ITextRange_fnStartOf(ITextRange *me, LONG Unit, LONG Extend,
 884                                            LONG *pDelta)
 885 {
 886     ITextRangeImpl *This = impl_from_ITextRange(me);
 887     if (!This->reOle)
 888         return CO_E_RELEASED;
 889
 890     FIXME("not implemented %p\n", This);
 891     return E_NOTIMPL;
 892 }
 893
 894 static HRESULT WINAPI ITextRange_fnEndOf(ITextRange *me, LONG Unit, LONG Extend,
 895                                          LONG *pDelta)
 896 {
 897     ITextRangeImpl *This = impl_from_ITextRange(me);
 898     if (!This->reOle)
 899         return CO_E_RELEASED;
 900
 901     FIXME("not implemented %p\n", This);
 902     return E_NOTIMPL;
 903 }
 904
 905 static HRESULT WINAPI ITextRange_fnMove(ITextRange *me, LONG Unit, LONG Count, LONG *pDelta)
 906 {
 907     ITextRangeImpl *This = impl_from_ITextRange(me);
 908     if (!This->reOle)
 909         return CO_E_RELEASED;
 910
 911     FIXME("not implemented %p\n", This);
 912     return E_NOTIMPL;
 913 }
 914
 915 static HRESULT WINAPI ITextRange_fnMoveStart(ITextRange *me, LONG Unit, LONG Count,
 916                                              LONG *pDelta)
 917 {
 918     ITextRangeImpl *This = impl_from_ITextRange(me);
 919     if (!This->reOle)
 920         return CO_E_RELEASED;
 921
 922     FIXME("not implemented %p\n", This);
 923     return E_NOTIMPL;
 924 }
 925
 926 static HRESULT WINAPI ITextRange_fnMoveEnd(ITextRange *me, LONG Unit, LONG Count,
 927                                            LONG *pDelta)
 928 {
 929     ITextRangeImpl *This = impl_from_ITextRange(me);
 930     if (!This->reOle)
 931         return CO_E_RELEASED;
 932
 933     FIXME("not implemented %p\n", This);
 934     return E_NOTIMPL;
 935 }
 936
 937 static HRESULT WINAPI ITextRange_fnMoveWhile(ITextRange *me, VARIANT *Cset, LONG Count,
 938                                              LONG *pDelta)
 939 {
 940     ITextRangeImpl *This = impl_from_ITextRange(me);
 941     if (!This->reOle)
 942         return CO_E_RELEASED;
 943
 944     FIXME("not implemented %p\n", This);
 945     return E_NOTIMPL;
 946 }
 947
 948 static HRESULT WINAPI ITextRange_fnMoveStartWhile(ITextRange *me, VARIANT *Cset, LONG Count,
 949                                                   LONG *pDelta)
 950 {
 951     ITextRangeImpl *This = impl_from_ITextRange(me);
 952     if (!This->reOle)
 953         return CO_E_RELEASED;
 954
 955     FIXME("not implemented %p\n", This);
 956     return E_NOTIMPL;
 957 }
 958
 959 static HRESULT WINAPI ITextRange_fnMoveEndWhile(ITextRange *me, VARIANT *Cset, LONG Count,
 960                                                 LONG *pDelta)
 961 {
 962     ITextRangeImpl *This = impl_from_ITextRange(me);
 963     if (!This->reOle)
 964         return CO_E_RELEASED;
 965
 966     FIXME("not implemented %p\n", This);
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI ITextRange_fnMoveUntil(ITextRange *me, VARIANT *Cset, LONG Count,
 971                                              LONG *pDelta)
 972 {
 973     ITextRangeImpl *This = impl_from_ITextRange(me);
 974     if (!This->reOle)
 975         return CO_E_RELEASED;
 976
 977     FIXME("not implemented %p\n", This);
 978     return E_NOTIMPL;
 979 }
 980
 981 static HRESULT WINAPI ITextRange_fnMoveStartUntil(ITextRange *me, VARIANT *Cset, LONG Count,
 982                                                   LONG *pDelta)
 983 {
 984     ITextRangeImpl *This = impl_from_ITextRange(me);
 985     if (!This->reOle)
 986         return CO_E_RELEASED;
 987
 988     FIXME("not implemented %p\n", This);
 989     return E_NOTIMPL;
 990 }
 991
 992 static HRESULT WINAPI ITextRange_fnMoveEndUntil(ITextRange *me, VARIANT *Cset, LONG Count,
 993                                                 LONG *pDelta)
 994 {
 995     ITextRangeImpl *This = impl_from_ITextRange(me);
 996     if (!This->reOle)
 997         return CO_E_RELEASED;
 998
 999     FIXME("not implemented %p\n", This);
1000     return E_NOTIMPL;
1001 }
1002
1003 static HRESULT WINAPI ITextRange_fnFindText(ITextRange *me, BSTR bstr, LONG cch, LONG Flags,
1004                                             LONG *pLength)
1005 {
1006     ITextRangeImpl *This = impl_from_ITextRange(me);
1007     if (!This->reOle)
1008         return CO_E_RELEASED;
1009
1010     FIXME("not implemented %p\n", This);
1011     return E_NOTIMPL;
1012 }
1013
1014 static HRESULT WINAPI ITextRange_fnFindTextStart(ITextRange *me, BSTR bstr, LONG cch,
1015                                                  LONG Flags, LONG *pLength)
1016 {
1017     ITextRangeImpl *This = impl_from_ITextRange(me);
1018     if (!This->reOle)
1019         return CO_E_RELEASED;
1020
1021     FIXME("not implemented %p\n", This);
1022     return E_NOTIMPL;
1023 }
1024
1025 static HRESULT WINAPI ITextRange_fnFindTextEnd(ITextRange *me, BSTR bstr, LONG cch,
1026                                                LONG Flags, LONG *pLength)
1027 {
1028     ITextRangeImpl *This = impl_from_ITextRange(me);
1029     if (!This->reOle)
1030         return CO_E_RELEASED;
1031
1032     FIXME("not implemented %p\n", This);
1033     return E_NOTIMPL;
1034 }
1035
1036 static HRESULT WINAPI ITextRange_fnDelete(ITextRange *me, LONG Unit, LONG Count,
1037                                           LONG *pDelta)
1038 {
1039     ITextRangeImpl *This = impl_from_ITextRange(me);
1040     if (!This->reOle)
1041         return CO_E_RELEASED;
1042
1043     FIXME("not implemented %p\n", This);
1044     return E_NOTIMPL;
1045 }
1046
1047 static HRESULT WINAPI ITextRange_fnCut(ITextRange *me, VARIANT *pVar)
1048 {
1049     ITextRangeImpl *This = impl_from_ITextRange(me);
1050     if (!This->reOle)
1051         return CO_E_RELEASED;
1052
1053     FIXME("not implemented %p\n", This);
1054     return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI ITextRange_fnCopy(ITextRange *me, VARIANT *pVar)
1058 {
1059     ITextRangeImpl *This = impl_from_ITextRange(me);
1060     if (!This->reOle)
1061         return CO_E_RELEASED;
1062
1063     FIXME("not implemented %p\n", This);
1064     return E_NOTIMPL;
1065 }
1066
1067 static HRESULT WINAPI ITextRange_fnPaste(ITextRange *me, VARIANT *pVar, LONG Format)
1068 {
1069     ITextRangeImpl *This = impl_from_ITextRange(me);
1070     if (!This->reOle)
1071         return CO_E_RELEASED;
1072
1073     FIXME("not implemented %p\n", This);
1074     return E_NOTIMPL;
1075 }
1076
1077 static HRESULT WINAPI ITextRange_fnCanPaste(ITextRange *me, VARIANT *pVar, LONG Format,
1078                                             LONG *pb)
1079 {
1080     ITextRangeImpl *This = impl_from_ITextRange(me);
1081     if (!This->reOle)
1082         return CO_E_RELEASED;
1083
1084     FIXME("not implemented %p\n", This);
1085     return E_NOTIMPL;
1086 }
1087
1088 static HRESULT WINAPI ITextRange_fnCanEdit(ITextRange *me, LONG *pb)
1089 {
1090     ITextRangeImpl *This = impl_from_ITextRange(me);
1091     if (!This->reOle)
1092         return CO_E_RELEASED;
1093
1094     FIXME("not implemented %p\n", This);
1095     return E_NOTIMPL;
1096 }
1097
1098 static HRESULT WINAPI ITextRange_fnChangeCase(ITextRange *me, LONG Type)
1099 {
1100     ITextRangeImpl *This = impl_from_ITextRange(me);
1101     if (!This->reOle)
1102         return CO_E_RELEASED;
1103
1104     FIXME("not implemented %p\n", This);
1105     return E_NOTIMPL;
1106 }
1107
1108 static HRESULT WINAPI ITextRange_fnGetPoint(ITextRange *me, LONG Type, LONG *cx, LONG *cy)
1109 {
1110     ITextRangeImpl *This = impl_from_ITextRange(me);
1111     if (!This->reOle)
1112         return CO_E_RELEASED;
1113
1114     FIXME("not implemented %p\n", This);
1115     return E_NOTIMPL;
1116 }
1117
1118 static HRESULT WINAPI ITextRange_fnSetPoint(ITextRange *me, LONG x, LONG y, LONG Type,
1119                                             LONG Extend)
1120 {
1121     ITextRangeImpl *This = impl_from_ITextRange(me);
1122     if (!This->reOle)
1123         return CO_E_RELEASED;
1124
1125     FIXME("not implemented %p\n", This);
1126     return E_NOTIMPL;
1127 }
1128
1129 static HRESULT WINAPI ITextRange_fnScrollIntoView(ITextRange *me, LONG Value)
1130 {
1131     ITextRangeImpl *This = impl_from_ITextRange(me);
1132     if (!This->reOle)
1133         return CO_E_RELEASED;
1134
1135     FIXME("not implemented %p\n", This);
1136     return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI ITextRange_fnGetEmbeddedObject(ITextRange *me, IUnknown **ppv)
1140 {
1141     ITextRangeImpl *This = impl_from_ITextRange(me);
1142     if (!This->reOle)
1143         return CO_E_RELEASED;
1144
1145     FIXME("not implemented %p\n", This);
1146     return E_NOTIMPL;
1147 }
1148
1149 static const ITextRangeVtbl trvt = {
1150     ITextRange_fnQueryInterface,
1151     ITextRange_fnAddRef,
1152     ITextRange_fnRelease,
1153     ITextRange_fnGetTypeInfoCount,
1154     ITextRange_fnGetTypeInfo,
1155     ITextRange_fnGetIDsOfNames,
1156     ITextRange_fnInvoke,
1157     ITextRange_fnGetText,
1158     ITextRange_fnSetText,
1159     ITextRange_fnGetChar,
1160     ITextRange_fnSetChar,
1161     ITextRange_fnGetDuplicate,
1162     ITextRange_fnGetFormattedText,
1163     ITextRange_fnSetFormattedText,
1164     ITextRange_fnGetStart,
1165     ITextRange_fnSetStart,
1166     ITextRange_fnGetEnd,
1167     ITextRange_fnSetEnd,
1168     ITextRange_fnGetFont,
1169     ITextRange_fnSetFont,
1170     ITextRange_fnGetPara,
1171     ITextRange_fnSetPara,
1172     ITextRange_fnGetStoryLength,
1173     ITextRange_fnGetStoryType,
1174     ITextRange_fnCollapse,
1175     ITextRange_fnExpand,
1176     ITextRange_fnGetIndex,
1177     ITextRange_fnSetIndex,
1178     ITextRange_fnSetRange,
1179     ITextRange_fnInRange,
1180     ITextRange_fnInStory,
1181     ITextRange_fnIsEqual,
1182     ITextRange_fnSelect,
1183     ITextRange_fnStartOf,
1184     ITextRange_fnEndOf,
1185     ITextRange_fnMove,
1186     ITextRange_fnMoveStart,
1187     ITextRange_fnMoveEnd,
1188     ITextRange_fnMoveWhile,
1189     ITextRange_fnMoveStartWhile,
1190     ITextRange_fnMoveEndWhile,
1191     ITextRange_fnMoveUntil,
1192     ITextRange_fnMoveStartUntil,
1193     ITextRange_fnMoveEndUntil,
1194     ITextRange_fnFindText,
1195     ITextRange_fnFindTextStart,
1196     ITextRange_fnFindTextEnd,
1197     ITextRange_fnDelete,
1198     ITextRange_fnCut,
1199     ITextRange_fnCopy,
1200     ITextRange_fnPaste,
1201     ITextRange_fnCanPaste,
1202     ITextRange_fnCanEdit,
1203     ITextRange_fnChangeCase,
1204     ITextRange_fnGetPoint,
1205     ITextRange_fnSetPoint,
1206     ITextRange_fnScrollIntoView,
1207     ITextRange_fnGetEmbeddedObject
1208 };
1209 /* ITextRange interface */
1210
1211 static HRESULT WINAPI
1212 ITextDocument_fnQueryInterface(ITextDocument* me, REFIID riid,
1213     void** ppvObject)
1214 {
1215     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1216     return IRichEditOle_QueryInterface(&This->IRichEditOle_iface, riid, ppvObject);
1217 }
1218
1219 static ULONG WINAPI
1220 ITextDocument_fnAddRef(ITextDocument* me)
1221 {
1222     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1223     return IRichEditOle_AddRef(&This->IRichEditOle_iface);
1224 }
1225
1226 static ULONG WINAPI
1227 ITextDocument_fnRelease(ITextDocument* me)
1228 {
1229     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1230     return IRichEditOle_Release(&This->IRichEditOle_iface);
1231 }
1232
1233 static HRESULT WINAPI
1234 ITextDocument_fnGetTypeInfoCount(ITextDocument* me,
1235     UINT* pctinfo)
1236 {
1237     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1238     FIXME("stub %p\n",This);
1239     return E_NOTIMPL;
1240 }
1241
1242 static HRESULT WINAPI
1243 ITextDocument_fnGetTypeInfo(ITextDocument* me, UINT iTInfo, LCID lcid,
1244     ITypeInfo** ppTInfo)
1245 {
1246     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1247     FIXME("stub %p\n",This);
1248     return E_NOTIMPL;
1249 }
1250
1251 static HRESULT WINAPI
1252 ITextDocument_fnGetIDsOfNames(ITextDocument* me, REFIID riid,
1253     LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
1254 {
1255     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1256     FIXME("stub %p\n",This);
1257     return E_NOTIMPL;
1258 }
1259
1260 static HRESULT WINAPI
1261 ITextDocument_fnInvoke(ITextDocument* me, DISPID dispIdMember,
1262     REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
1263     VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
1264 {
1265     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1266     FIXME("stub %p\n",This);
1267     return E_NOTIMPL;
1268 }
1269
1270 static HRESULT WINAPI
1271 ITextDocument_fnGetName(ITextDocument* me, BSTR* pName)
1272 {
1273     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1274     FIXME("stub %p\n",This);
1275     return E_NOTIMPL;
1276 }
1277
1278 static HRESULT WINAPI
1279 ITextDocument_fnGetSelection(ITextDocument* me, ITextSelection** ppSel)
1280 {
1281     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1282     TRACE("(%p)\n", me);
1283
1284     if(!ppSel)
1285       return E_INVALIDARG;
1286     *ppSel = &This->txtSel->ITextSelection_iface;
1287     ITextSelection_AddRef(*ppSel);
1288     return S_OK;
1289 }
1290
1291 static HRESULT WINAPI
1292 ITextDocument_fnGetStoryCount(ITextDocument* me, LONG* pCount)
1293 {
1294     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1295     FIXME("stub %p\n",This);
1296     return E_NOTIMPL;
1297 }
1298
1299 static HRESULT WINAPI
1300 ITextDocument_fnGetStoryRanges(ITextDocument* me,
1301     ITextStoryRanges** ppStories)
1302 {
1303     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1304     FIXME("stub %p\n",This);
1305     return E_NOTIMPL;
1306 }
1307
1308 static HRESULT WINAPI
1309 ITextDocument_fnGetSaved(ITextDocument* me, LONG* pValue)
1310 {
1311     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1312     FIXME("stub %p\n",This);
1313     return E_NOTIMPL;
1314 }
1315
1316 static HRESULT WINAPI
1317 ITextDocument_fnSetSaved(ITextDocument* me, LONG Value)
1318 {
1319     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1320     FIXME("stub %p\n",This);
1321     return E_NOTIMPL;
1322 }
1323
1324 static HRESULT WINAPI
1325 ITextDocument_fnGetDefaultTabStop(ITextDocument* me, float* pValue)
1326 {
1327     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1328     FIXME("stub %p\n",This);
1329     return E_NOTIMPL;
1330 }
1331
1332 static HRESULT WINAPI
1333 ITextDocument_fnSetDefaultTabStop(ITextDocument* me, float Value)
1334 {
1335     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1336     FIXME("stub %p\n",This);
1337     return E_NOTIMPL;
1338 }
1339
1340 static HRESULT WINAPI
1341 ITextDocument_fnNew(ITextDocument* me)
1342 {
1343     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1344     FIXME("stub %p\n",This);
1345     return E_NOTIMPL;
1346 }
1347
1348 static HRESULT WINAPI
1349 ITextDocument_fnOpen(ITextDocument* me, VARIANT* pVar, LONG Flags,
1350     LONG CodePage)
1351 {
1352     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1353     FIXME("stub %p\n",This);
1354     return E_NOTIMPL;
1355 }
1356
1357 static HRESULT WINAPI
1358 ITextDocument_fnSave(ITextDocument* me, VARIANT* pVar, LONG Flags,
1359     LONG CodePage)
1360 {
1361     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1362     FIXME("stub %p\n",This);
1363     return E_NOTIMPL;
1364 }
1365
1366 static HRESULT WINAPI
1367 ITextDocument_fnFreeze(ITextDocument* me, LONG* pCount)
1368 {
1369     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1370     FIXME("stub %p\n",This);
1371     return E_NOTIMPL;
1372 }
1373
1374 static HRESULT WINAPI
1375 ITextDocument_fnUnfreeze(ITextDocument* me, LONG* pCount)
1376 {
1377     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1378     FIXME("stub %p\n",This);
1379     return E_NOTIMPL;
1380 }
1381
1382 static HRESULT WINAPI
1383 ITextDocument_fnBeginEditCollection(ITextDocument* me)
1384 {
1385     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1386     FIXME("stub %p\n",This);
1387     return E_NOTIMPL;
1388 }
1389
1390 static HRESULT WINAPI
1391 ITextDocument_fnEndEditCollection(ITextDocument* me)
1392 {
1393     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1394     FIXME("stub %p\n",This);
1395     return E_NOTIMPL;
1396 }
1397
1398 static HRESULT WINAPI
1399 ITextDocument_fnUndo(ITextDocument* me, LONG Count, LONG* prop)
1400 {
1401     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1402     FIXME("stub %p\n",This);
1403     return E_NOTIMPL;
1404 }
1405
1406 static HRESULT WINAPI
1407 ITextDocument_fnRedo(ITextDocument* me, LONG Count, LONG* prop)
1408 {
1409     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1410     FIXME("stub %p\n",This);
1411     return E_NOTIMPL;
1412 }
1413
1414 static HRESULT CreateITextRange(IRichEditOleImpl *reOle, LONG start, LONG end, ITextRange** ppRange)
1415 {
1416     ITextRangeImpl *txtRge = heap_alloc(sizeof(ITextRangeImpl));
1417
1418     if (!txtRge)
1419         return E_OUTOFMEMORY;
1420     txtRge->ITextRange_iface.lpVtbl = &trvt;
1421     txtRge->ref = 1;
1422     txtRge->reOle = reOle;
1423     txtRge->start = start;
1424     txtRge->end = end;
1425     list_add_head(&reOle->rangelist, &txtRge->entry);
1426     *ppRange = &txtRge->ITextRange_iface;
1427     return S_OK;
1428 }
1429
1430 static HRESULT WINAPI
1431 ITextDocument_fnRange(ITextDocument* me, LONG cp1, LONG cp2,
1432     ITextRange** ppRange)
1433 {
1434     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1435     const int len = ME_GetTextLength(This->editor) + 1;
1436
1437     TRACE("%p %p %d %d\n", This, ppRange, cp1, cp2);
1438     if (!ppRange)
1439         return E_INVALIDARG;
1440
1441     cp1 = max(cp1, 0);
1442     cp2 = max(cp2, 0);
1443     cp1 = min(cp1, len);
1444     cp2 = min(cp2, len);
1445     if (cp1 > cp2)
1446     {
1447         LONG tmp;
1448         tmp = cp1;
1449         cp1 = cp2;
1450         cp2 = tmp;
1451     }
1452     if (cp1 == len)
1453         cp1 = cp2 = len - 1;
1454
1455     return CreateITextRange(This, cp1, cp2, ppRange);
1456 }
1457
1458 static HRESULT WINAPI
1459 ITextDocument_fnRangeFromPoint(ITextDocument* me, LONG x, LONG y,
1460     ITextRange** ppRange)
1461 {
1462     IRichEditOleImpl *This = impl_from_ITextDocument(me);
1463     FIXME("stub %p\n",This);
1464     return E_NOTIMPL;
1465 }
1466
1467 static const ITextDocumentVtbl tdvt = {
1468     ITextDocument_fnQueryInterface,
1469     ITextDocument_fnAddRef,
1470     ITextDocument_fnRelease,
1471     ITextDocument_fnGetTypeInfoCount,
1472     ITextDocument_fnGetTypeInfo,
1473     ITextDocument_fnGetIDsOfNames,
1474     ITextDocument_fnInvoke,
1475     ITextDocument_fnGetName,
1476     ITextDocument_fnGetSelection,
1477     ITextDocument_fnGetStoryCount,
1478     ITextDocument_fnGetStoryRanges,
1479     ITextDocument_fnGetSaved,
1480     ITextDocument_fnSetSaved,
1481     ITextDocument_fnGetDefaultTabStop,
1482     ITextDocument_fnSetDefaultTabStop,
1483     ITextDocument_fnNew,
1484     ITextDocument_fnOpen,
1485     ITextDocument_fnSave,
1486     ITextDocument_fnFreeze,
1487     ITextDocument_fnUnfreeze,
1488     ITextDocument_fnBeginEditCollection,
1489     ITextDocument_fnEndEditCollection,
1490     ITextDocument_fnUndo,
1491     ITextDocument_fnRedo,
1492     ITextDocument_fnRange,
1493     ITextDocument_fnRangeFromPoint
1494 };
1495
1496 static inline ITextSelectionImpl *impl_from_ITextSelection(ITextSelection *iface)
1497 {
1498     return CONTAINING_RECORD(iface, ITextSelectionImpl, ITextSelection_iface);
1499 }
1500
1501 static HRESULT WINAPI ITextSelection_fnQueryInterface(
1502     ITextSelection *me,
1503     REFIID riid,
1504     void **ppvObj)
1505 {
1506     *ppvObj = NULL;
1507     if (IsEqualGUID(riid, &IID_IUnknown)
1508         || IsEqualGUID(riid, &IID_IDispatch)
1509         || IsEqualGUID(riid, &IID_ITextRange)
1510         || IsEqualGUID(riid, &IID_ITextSelection))
1511     {
1512         *ppvObj = me;
1513         ITextSelection_AddRef(me);
1514         return S_OK;
1515     }
1516
1517     return E_NOINTERFACE;
1518 }
1519
1520 static ULONG WINAPI ITextSelection_fnAddRef(ITextSelection *me)
1521 {
1522     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1523     return InterlockedIncrement(&This->ref);
1524 }
1525
1526 static ULONG WINAPI ITextSelection_fnRelease(ITextSelection *me)
1527 {
1528     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1529     ULONG ref = InterlockedDecrement(&This->ref);
1530     if (ref == 0)
1531         heap_free(This);
1532     return ref;
1533 }
1534
1535 static HRESULT WINAPI ITextSelection_fnGetTypeInfoCount(ITextSelection *me, UINT *pctinfo)
1536 {
1537     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1538     if (!This->reOle)
1539         return CO_E_RELEASED;
1540
1541     FIXME("not implemented\n");
1542     return E_NOTIMPL;
1543 }
1544
1545 static HRESULT WINAPI ITextSelection_fnGetTypeInfo(ITextSelection *me, UINT iTInfo, LCID lcid,
1546     ITypeInfo **ppTInfo)
1547 {
1548     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1549     if (!This->reOle)
1550         return CO_E_RELEASED;
1551
1552     FIXME("not implemented\n");
1553     return E_NOTIMPL;
1554 }
1555
1556 static HRESULT WINAPI ITextSelection_fnGetIDsOfNames(ITextSelection *me, REFIID riid,
1557     LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1558 {
1559     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1560     if (!This->reOle)
1561         return CO_E_RELEASED;
1562
1563     FIXME("not implemented\n");
1564     return E_NOTIMPL;
1565 }
1566
1567 static HRESULT WINAPI ITextSelection_fnInvoke(
1568     ITextSelection *me,
1569     DISPID dispIdMember,
1570     REFIID riid,
1571     LCID lcid,
1572     WORD wFlags,
1573     DISPPARAMS *pDispParams,
1574     VARIANT *pVarResult,
1575     EXCEPINFO *pExcepInfo,
1576     UINT *puArgErr)
1577 {
1578     FIXME("not implemented\n");
1579     return E_NOTIMPL;
1580 }
1581
1582 /*** ITextRange methods ***/
1583 static HRESULT WINAPI ITextSelection_fnGetText(ITextSelection *me, BSTR *pbstr)
1584 {
1585     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1586     ME_Cursor *start = NULL, *end = NULL;
1587     int nChars, endOfs;
1588     BOOL bEOP;
1589
1590     if (!This->reOle)
1591         return CO_E_RELEASED;
1592     TRACE("%p\n", pbstr);
1593     if (!pbstr)
1594         return E_INVALIDARG;
1595
1596     ME_GetSelection(This->reOle->editor, &start, &end);
1597     endOfs = ME_GetCursorOfs(end);
1598     nChars = endOfs - ME_GetCursorOfs(start);
1599     if (!nChars)
1600     {
1601         *pbstr = NULL;
1602         return S_OK;
1603     }
1604
1605     *pbstr = SysAllocStringLen(NULL, nChars);
1606     if (!*pbstr)
1607         return E_OUTOFMEMORY;
1608
1609     bEOP = (end->pRun->next->type == diTextEnd && endOfs > ME_GetTextLength(This->reOle->editor));
1610     ME_GetTextW(This->reOle->editor, *pbstr, nChars, start, nChars, FALSE, bEOP);
1611     TRACE("%s\n", wine_dbgstr_w(*pbstr));
1612
1613     return S_OK;
1614 }
1615
1616 static HRESULT WINAPI ITextSelection_fnSetText(ITextSelection *me, BSTR bstr)
1617 {
1618     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1619     if (!This->reOle)
1620         return CO_E_RELEASED;
1621
1622     FIXME("not implemented\n");
1623     return E_NOTIMPL;
1624 }
1625
1626 static HRESULT WINAPI ITextSelection_fnGetChar(ITextSelection *me, LONG *pch)
1627 {
1628     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1629     ME_Cursor *start = NULL, *end = NULL;
1630
1631     if (!This->reOle)
1632         return CO_E_RELEASED;
1633     TRACE("%p\n", pch);
1634     if (!pch)
1635         return E_INVALIDARG;
1636
1637     ME_GetSelection(This->reOle->editor, &start, &end);
1638     return range_GetChar(This->reOle->editor, start, pch);
1639 }
1640
1641 static HRESULT WINAPI ITextSelection_fnSetChar(ITextSelection *me, LONG ch)
1642 {
1643     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1644     if (!This->reOle)
1645         return CO_E_RELEASED;
1646
1647     FIXME("not implemented\n");
1648     return E_NOTIMPL;
1649 }
1650
1651 static HRESULT WINAPI ITextSelection_fnGetDuplicate(ITextSelection *me, ITextRange **ppRange)
1652 {
1653     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1654     if (!This->reOle)
1655         return CO_E_RELEASED;
1656
1657     FIXME("not implemented\n");
1658     return E_NOTIMPL;
1659 }
1660
1661 static HRESULT WINAPI ITextSelection_fnGetFormattedText(ITextSelection *me, ITextRange **ppRange)
1662 {
1663     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1664     if (!This->reOle)
1665         return CO_E_RELEASED;
1666
1667     FIXME("not implemented\n");
1668     return E_NOTIMPL;
1669 }
1670
1671 static HRESULT WINAPI ITextSelection_fnSetFormattedText(ITextSelection *me, ITextRange *pRange)
1672 {
1673     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1674     if (!This->reOle)
1675         return CO_E_RELEASED;
1676
1677     FIXME("not implemented\n");
1678     return E_NOTIMPL;
1679 }
1680
1681 static HRESULT WINAPI ITextSelection_fnGetStart(ITextSelection *me, LONG *pcpFirst)
1682 {
1683     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1684     LONG lim;
1685     if (!This->reOle)
1686         return CO_E_RELEASED;
1687
1688     if (!pcpFirst)
1689         return E_INVALIDARG;
1690     ME_GetSelectionOfs(This->reOle->editor, pcpFirst, &lim);
1691     TRACE("%d\n", *pcpFirst);
1692     return S_OK;
1693 }
1694
1695 static HRESULT WINAPI ITextSelection_fnSetStart(ITextSelection *me, LONG cpFirst)
1696 {
1697     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1698     if (!This->reOle)
1699         return CO_E_RELEASED;
1700
1701     FIXME("not implemented\n");
1702     return E_NOTIMPL;
1703 }
1704
1705 static HRESULT WINAPI ITextSelection_fnGetEnd(ITextSelection *me, LONG *pcpLim)
1706 {
1707     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1708     LONG first;
1709     if (!This->reOle)
1710         return CO_E_RELEASED;
1711
1712     if (!pcpLim)
1713         return E_INVALIDARG;
1714     ME_GetSelectionOfs(This->reOle->editor, &first, pcpLim);
1715     TRACE("%d\n", *pcpLim);
1716     return S_OK;
1717 }
1718
1719 static HRESULT WINAPI ITextSelection_fnSetEnd(ITextSelection *me, LONG cpLim)
1720 {
1721     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1722     if (!This->reOle)
1723         return CO_E_RELEASED;
1724
1725     FIXME("not implemented\n");
1726     return E_NOTIMPL;
1727 }
1728
1729 static HRESULT WINAPI ITextSelection_fnGetFont(ITextSelection *me, ITextFont **pFont)
1730 {
1731     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1732     if (!This->reOle)
1733         return CO_E_RELEASED;
1734
1735     FIXME("not implemented\n");
1736     return E_NOTIMPL;
1737 }
1738
1739 static HRESULT WINAPI ITextSelection_fnSetFont(ITextSelection *me, ITextFont *pFont)
1740 {
1741     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1742     if (!This->reOle)
1743         return CO_E_RELEASED;
1744
1745     FIXME("not implemented\n");
1746     return E_NOTIMPL;
1747 }
1748
1749 static HRESULT WINAPI ITextSelection_fnGetPara(ITextSelection *me, ITextPara **ppPara)
1750 {
1751     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1752     if (!This->reOle)
1753         return CO_E_RELEASED;
1754
1755     FIXME("not implemented\n");
1756     return E_NOTIMPL;
1757 }
1758
1759 static HRESULT WINAPI ITextSelection_fnSetPara(ITextSelection *me, ITextPara *pPara)
1760 {
1761     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1762     if (!This->reOle)
1763         return CO_E_RELEASED;
1764
1765     FIXME("not implemented\n");
1766     return E_NOTIMPL;
1767 }
1768
1769 static HRESULT WINAPI ITextSelection_fnGetStoryLength(ITextSelection *me, LONG *pcch)
1770 {
1771     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1772     if (!This->reOle)
1773         return CO_E_RELEASED;
1774
1775     FIXME("not implemented\n");
1776     return E_NOTIMPL;
1777 }
1778
1779 static HRESULT WINAPI ITextSelection_fnGetStoryType(ITextSelection *me, LONG *pValue)
1780 {
1781     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1782     if (!This->reOle)
1783         return CO_E_RELEASED;
1784
1785     FIXME("not implemented\n");
1786     return E_NOTIMPL;
1787 }
1788
1789 static HRESULT WINAPI ITextSelection_fnCollapse(ITextSelection *me, LONG bStart)
1790 {
1791     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1792     LONG start, end;
1793     HRESULT hres;
1794     if (!This->reOle)
1795         return CO_E_RELEASED;
1796
1797     ME_GetSelectionOfs(This->reOle->editor, &start, &end);
1798     hres = range_Collapse(bStart, &start, &end);
1799     if (SUCCEEDED(hres))
1800         ME_SetSelection(This->reOle->editor, start, end);
1801     return hres;
1802 }
1803
1804 static HRESULT WINAPI ITextSelection_fnExpand(ITextSelection *me, LONG Unit, LONG *pDelta)
1805 {
1806     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1807     if (!This->reOle)
1808         return CO_E_RELEASED;
1809
1810     FIXME("not implemented\n");
1811     return E_NOTIMPL;
1812 }
1813
1814 static HRESULT WINAPI ITextSelection_fnGetIndex(ITextSelection *me, LONG Unit, LONG *pIndex)
1815 {
1816     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1817     if (!This->reOle)
1818         return CO_E_RELEASED;
1819
1820     FIXME("not implemented\n");
1821     return E_NOTIMPL;
1822 }
1823
1824 static HRESULT WINAPI ITextSelection_fnSetIndex(ITextSelection *me, LONG Unit, LONG Index,
1825     LONG Extend)
1826 {
1827     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1828     if (!This->reOle)
1829         return CO_E_RELEASED;
1830
1831     FIXME("not implemented\n");
1832     return E_NOTIMPL;
1833 }
1834
1835 static HRESULT WINAPI ITextSelection_fnSetRange(ITextSelection *me, LONG cpActive, LONG cpOther)
1836 {
1837     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1838     if (!This->reOle)
1839         return CO_E_RELEASED;
1840
1841     FIXME("not implemented\n");
1842     return E_NOTIMPL;
1843 }
1844
1845 static HRESULT WINAPI ITextSelection_fnInRange(ITextSelection *me, ITextRange *pRange, LONG *pb)
1846 {
1847     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1848     if (!This->reOle)
1849         return CO_E_RELEASED;
1850
1851     FIXME("not implemented\n");
1852     return E_NOTIMPL;
1853 }
1854
1855 static HRESULT WINAPI ITextSelection_fnInStory(ITextSelection *me, ITextRange *pRange, LONG *pb)
1856 {
1857     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1858     if (!This->reOle)
1859         return CO_E_RELEASED;
1860
1861     FIXME("not implemented\n");
1862     return E_NOTIMPL;
1863 }
1864
1865 static HRESULT WINAPI ITextSelection_fnIsEqual(ITextSelection *me, ITextRange *pRange, LONG *pb)
1866 {
1867     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1868     if (!This->reOle)
1869         return CO_E_RELEASED;
1870
1871     FIXME("not implemented\n");
1872     return E_NOTIMPL;
1873 }
1874
1875 static HRESULT WINAPI ITextSelection_fnSelect(ITextSelection *me)
1876 {
1877     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1878     if (!This->reOle)
1879         return CO_E_RELEASED;
1880
1881     FIXME("not implemented\n");
1882     return E_NOTIMPL;
1883 }
1884
1885 static HRESULT WINAPI ITextSelection_fnStartOf(ITextSelection *me, LONG Unit, LONG Extend,
1886     LONG *pDelta)
1887 {
1888     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1889     if (!This->reOle)
1890         return CO_E_RELEASED;
1891
1892     FIXME("not implemented\n");
1893     return E_NOTIMPL;
1894 }
1895
1896 static HRESULT WINAPI ITextSelection_fnEndOf(ITextSelection *me, LONG Unit, LONG Extend,
1897     LONG *pDelta)
1898 {
1899     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1900     if (!This->reOle)
1901         return CO_E_RELEASED;
1902
1903     FIXME("not implemented\n");
1904     return E_NOTIMPL;
1905 }
1906
1907 static HRESULT WINAPI ITextSelection_fnMove(ITextSelection *me, LONG Unit, LONG Count, LONG *pDelta)
1908 {
1909     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1910     if (!This->reOle)
1911         return CO_E_RELEASED;
1912
1913     FIXME("not implemented\n");
1914     return E_NOTIMPL;
1915 }
1916
1917 static HRESULT WINAPI ITextSelection_fnMoveStart(ITextSelection *me, LONG Unit, LONG Count,
1918     LONG *pDelta)
1919 {
1920     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1921     if (!This->reOle)
1922         return CO_E_RELEASED;
1923
1924     FIXME("not implemented\n");
1925     return E_NOTIMPL;
1926 }
1927
1928 static HRESULT WINAPI ITextSelection_fnMoveEnd(ITextSelection *me, LONG Unit, LONG Count,
1929     LONG *pDelta)
1930 {
1931     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1932     if (!This->reOle)
1933         return CO_E_RELEASED;
1934
1935     FIXME("not implemented\n");
1936     return E_NOTIMPL;
1937 }
1938
1939 static HRESULT WINAPI ITextSelection_fnMoveWhile(ITextSelection *me, VARIANT *Cset, LONG Count,
1940     LONG *pDelta)
1941 {
1942     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1943     if (!This->reOle)
1944         return CO_E_RELEASED;
1945
1946     FIXME("not implemented\n");
1947     return E_NOTIMPL;
1948 }
1949
1950 static HRESULT WINAPI ITextSelection_fnMoveStartWhile(ITextSelection *me, VARIANT *Cset, LONG Count,
1951     LONG *pDelta)
1952 {
1953     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1954     if (!This->reOle)
1955         return CO_E_RELEASED;
1956
1957     FIXME("not implemented\n");
1958     return E_NOTIMPL;
1959 }
1960
1961 static HRESULT WINAPI ITextSelection_fnMoveEndWhile(ITextSelection *me, VARIANT *Cset, LONG Count,
1962     LONG *pDelta)
1963 {
1964     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1965     if (!This->reOle)
1966         return CO_E_RELEASED;
1967
1968     FIXME("not implemented\n");
1969     return E_NOTIMPL;
1970 }
1971
1972 static HRESULT WINAPI ITextSelection_fnMoveUntil(ITextSelection *me, VARIANT *Cset, LONG Count,
1973     LONG *pDelta)
1974 {
1975     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1976     if (!This->reOle)
1977         return CO_E_RELEASED;
1978
1979     FIXME("not implemented\n");
1980     return E_NOTIMPL;
1981 }
1982
1983 static HRESULT WINAPI ITextSelection_fnMoveStartUntil(ITextSelection *me, VARIANT *Cset, LONG Count,
1984     LONG *pDelta)
1985 {
1986     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1987     if (!This->reOle)
1988         return CO_E_RELEASED;
1989
1990     FIXME("not implemented\n");
1991     return E_NOTIMPL;
1992 }
1993
1994 static HRESULT WINAPI ITextSelection_fnMoveEndUntil(ITextSelection *me, VARIANT *Cset, LONG Count,
1995     LONG *pDelta)
1996 {
1997     ITextSelectionImpl *This = impl_from_ITextSelection(me);
1998     if (!This->reOle)
1999         return CO_E_RELEASED;
2000
2001     FIXME("not implemented\n");
2002     return E_NOTIMPL;
2003 }
2004
2005 static HRESULT WINAPI ITextSelection_fnFindText(ITextSelection *me, BSTR bstr, LONG cch, LONG Flags,
2006     LONG *pLength)
2007 {
2008     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2009     if (!This->reOle)
2010         return CO_E_RELEASED;
2011
2012     FIXME("not implemented\n");
2013     return E_NOTIMPL;
2014 }
2015
2016 static HRESULT WINAPI ITextSelection_fnFindTextStart(ITextSelection *me, BSTR bstr, LONG cch,
2017     LONG Flags, LONG *pLength)
2018 {
2019     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2020     if (!This->reOle)
2021         return CO_E_RELEASED;
2022
2023     FIXME("not implemented\n");
2024     return E_NOTIMPL;
2025 }
2026
2027 static HRESULT WINAPI ITextSelection_fnFindTextEnd(ITextSelection *me, BSTR bstr, LONG cch,
2028     LONG Flags, LONG *pLength)
2029 {
2030     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2031     if (!This->reOle)
2032         return CO_E_RELEASED;
2033
2034     FIXME("not implemented\n");
2035     return E_NOTIMPL;
2036 }
2037
2038 static HRESULT WINAPI ITextSelection_fnDelete(ITextSelection *me, LONG Unit, LONG Count,
2039     LONG *pDelta)
2040 {
2041     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2042     if (!This->reOle)
2043         return CO_E_RELEASED;
2044
2045     FIXME("not implemented\n");
2046     return E_NOTIMPL;
2047 }
2048
2049 static HRESULT WINAPI ITextSelection_fnCut(ITextSelection *me, VARIANT *pVar)
2050 {
2051     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2052     if (!This->reOle)
2053         return CO_E_RELEASED;
2054
2055     FIXME("not implemented\n");
2056     return E_NOTIMPL;
2057 }
2058
2059 static HRESULT WINAPI ITextSelection_fnCopy(ITextSelection *me, VARIANT *pVar)
2060 {
2061     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2062     if (!This->reOle)
2063         return CO_E_RELEASED;
2064
2065     FIXME("not implemented\n");
2066     return E_NOTIMPL;
2067 }
2068
2069 static HRESULT WINAPI ITextSelection_fnPaste(ITextSelection *me, VARIANT *pVar, LONG Format)
2070 {
2071     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2072     if (!This->reOle)
2073         return CO_E_RELEASED;
2074
2075     FIXME("not implemented\n");
2076     return E_NOTIMPL;
2077 }
2078
2079 static HRESULT WINAPI ITextSelection_fnCanPaste(ITextSelection *me, VARIANT *pVar, LONG Format,
2080     LONG *pb)
2081 {
2082     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2083     if (!This->reOle)
2084         return CO_E_RELEASED;
2085
2086     FIXME("not implemented\n");
2087     return E_NOTIMPL;
2088 }
2089
2090 static HRESULT WINAPI ITextSelection_fnCanEdit(ITextSelection *me, LONG *pb)
2091 {
2092     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2093     if (!This->reOle)
2094         return CO_E_RELEASED;
2095
2096     FIXME("not implemented\n");
2097     return E_NOTIMPL;
2098 }
2099
2100 static HRESULT WINAPI ITextSelection_fnChangeCase(ITextSelection *me, LONG Type)
2101 {
2102     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2103     if (!This->reOle)
2104         return CO_E_RELEASED;
2105
2106     FIXME("not implemented\n");
2107     return E_NOTIMPL;
2108 }
2109
2110 static HRESULT WINAPI ITextSelection_fnGetPoint(ITextSelection *me, LONG Type, LONG *cx, LONG *cy)
2111 {
2112     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2113     if (!This->reOle)
2114         return CO_E_RELEASED;
2115
2116     FIXME("not implemented\n");
2117     return E_NOTIMPL;
2118 }
2119
2120 static HRESULT WINAPI ITextSelection_fnSetPoint(ITextSelection *me, LONG x, LONG y, LONG Type,
2121     LONG Extend)
2122 {
2123     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2124     if (!This->reOle)
2125         return CO_E_RELEASED;
2126
2127     FIXME("not implemented\n");
2128     return E_NOTIMPL;
2129 }
2130
2131 static HRESULT WINAPI ITextSelection_fnScrollIntoView(ITextSelection *me, LONG Value)
2132 {
2133     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2134     if (!This->reOle)
2135         return CO_E_RELEASED;
2136
2137     FIXME("not implemented\n");
2138     return E_NOTIMPL;
2139 }
2140
2141 static HRESULT WINAPI ITextSelection_fnGetEmbeddedObject(ITextSelection *me, IUnknown **ppv)
2142 {
2143     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2144     if (!This->reOle)
2145         return CO_E_RELEASED;
2146
2147     FIXME("not implemented\n");
2148     return E_NOTIMPL;
2149 }
2150
2151 /*** ITextSelection methods ***/
2152 static HRESULT WINAPI ITextSelection_fnGetFlags(ITextSelection *me, LONG *pFlags)
2153 {
2154     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2155     if (!This->reOle)
2156         return CO_E_RELEASED;
2157
2158     FIXME("not implemented\n");
2159     return E_NOTIMPL;
2160 }
2161
2162 static HRESULT WINAPI ITextSelection_fnSetFlags(ITextSelection *me, LONG Flags)
2163 {
2164     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2165     if (!This->reOle)
2166         return CO_E_RELEASED;
2167
2168     FIXME("not implemented\n");
2169     return E_NOTIMPL;
2170 }
2171
2172 static HRESULT WINAPI ITextSelection_fnGetType(ITextSelection *me, LONG *pType)
2173 {
2174     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2175     if (!This->reOle)
2176         return CO_E_RELEASED;
2177
2178     FIXME("not implemented\n");
2179     return E_NOTIMPL;
2180 }
2181
2182 static HRESULT WINAPI ITextSelection_fnMoveLeft(ITextSelection *me, LONG Unit, LONG Count,
2183     LONG Extend, LONG *pDelta)
2184 {
2185     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2186     if (!This->reOle)
2187         return CO_E_RELEASED;
2188
2189     FIXME("not implemented\n");
2190     return E_NOTIMPL;
2191 }
2192
2193 static HRESULT WINAPI ITextSelection_fnMoveRight(ITextSelection *me, LONG Unit, LONG Count,
2194     LONG Extend, LONG *pDelta)
2195 {
2196     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2197     if (!This->reOle)
2198         return CO_E_RELEASED;
2199
2200     FIXME("not implemented\n");
2201     return E_NOTIMPL;
2202 }
2203
2204 static HRESULT WINAPI ITextSelection_fnMoveUp(ITextSelection *me, LONG Unit, LONG Count,
2205     LONG Extend, LONG *pDelta)
2206 {
2207     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2208     if (!This->reOle)
2209         return CO_E_RELEASED;
2210
2211     FIXME("not implemented\n");
2212     return E_NOTIMPL;
2213 }
2214
2215 static HRESULT WINAPI ITextSelection_fnMoveDown(ITextSelection *me, LONG Unit, LONG Count,
2216     LONG Extend, LONG *pDelta)
2217 {
2218     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2219     if (!This->reOle)
2220         return CO_E_RELEASED;
2221
2222     FIXME("not implemented\n");
2223     return E_NOTIMPL;
2224 }
2225
2226 static HRESULT WINAPI ITextSelection_fnHomeKey(ITextSelection *me, LONG Unit, LONG Extend,
2227     LONG *pDelta)
2228 {
2229     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2230     if (!This->reOle)
2231         return CO_E_RELEASED;
2232
2233     FIXME("not implemented\n");
2234     return E_NOTIMPL;
2235 }
2236
2237 static HRESULT WINAPI ITextSelection_fnEndKey(ITextSelection *me, LONG Unit, LONG Extend,
2238     LONG *pDelta)
2239 {
2240     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2241     if (!This->reOle)
2242         return CO_E_RELEASED;
2243
2244     FIXME("not implemented\n");
2245     return E_NOTIMPL;
2246 }
2247
2248 static HRESULT WINAPI ITextSelection_fnTypeText(ITextSelection *me, BSTR bstr)
2249 {
2250     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2251     if (!This->reOle)
2252         return CO_E_RELEASED;
2253
2254     FIXME("not implemented\n");
2255     return E_NOTIMPL;
2256 }
2257
2258 static const ITextSelectionVtbl tsvt = {
2259     ITextSelection_fnQueryInterface,
2260     ITextSelection_fnAddRef,
2261     ITextSelection_fnRelease,
2262     ITextSelection_fnGetTypeInfoCount,
2263     ITextSelection_fnGetTypeInfo,
2264     ITextSelection_fnGetIDsOfNames,
2265     ITextSelection_fnInvoke,
2266     ITextSelection_fnGetText,
2267     ITextSelection_fnSetText,
2268     ITextSelection_fnGetChar,
2269     ITextSelection_fnSetChar,
2270     ITextSelection_fnGetDuplicate,
2271     ITextSelection_fnGetFormattedText,
2272     ITextSelection_fnSetFormattedText,
2273     ITextSelection_fnGetStart,
2274     ITextSelection_fnSetStart,
2275     ITextSelection_fnGetEnd,
2276     ITextSelection_fnSetEnd,
2277     ITextSelection_fnGetFont,
2278     ITextSelection_fnSetFont,
2279     ITextSelection_fnGetPara,
2280     ITextSelection_fnSetPara,
2281     ITextSelection_fnGetStoryLength,
2282     ITextSelection_fnGetStoryType,
2283     ITextSelection_fnCollapse,
2284     ITextSelection_fnExpand,
2285     ITextSelection_fnGetIndex,
2286     ITextSelection_fnSetIndex,
2287     ITextSelection_fnSetRange,
2288     ITextSelection_fnInRange,
2289     ITextSelection_fnInStory,
2290     ITextSelection_fnIsEqual,
2291     ITextSelection_fnSelect,
2292     ITextSelection_fnStartOf,
2293     ITextSelection_fnEndOf,
2294     ITextSelection_fnMove,
2295     ITextSelection_fnMoveStart,
2296     ITextSelection_fnMoveEnd,
2297     ITextSelection_fnMoveWhile,
2298     ITextSelection_fnMoveStartWhile,
2299     ITextSelection_fnMoveEndWhile,
2300     ITextSelection_fnMoveUntil,
2301     ITextSelection_fnMoveStartUntil,
2302     ITextSelection_fnMoveEndUntil,
2303     ITextSelection_fnFindText,
2304     ITextSelection_fnFindTextStart,
2305     ITextSelection_fnFindTextEnd,
2306     ITextSelection_fnDelete,
2307     ITextSelection_fnCut,
2308     ITextSelection_fnCopy,
2309     ITextSelection_fnPaste,
2310     ITextSelection_fnCanPaste,
2311     ITextSelection_fnCanEdit,
2312     ITextSelection_fnChangeCase,
2313     ITextSelection_fnGetPoint,
2314     ITextSelection_fnSetPoint,
2315     ITextSelection_fnScrollIntoView,
2316     ITextSelection_fnGetEmbeddedObject,
2317     ITextSelection_fnGetFlags,
2318     ITextSelection_fnSetFlags,
2319     ITextSelection_fnGetType,
2320     ITextSelection_fnMoveLeft,
2321     ITextSelection_fnMoveRight,
2322     ITextSelection_fnMoveUp,
2323     ITextSelection_fnMoveDown,
2324     ITextSelection_fnHomeKey,
2325     ITextSelection_fnEndKey,
2326     ITextSelection_fnTypeText
2327 };
2328
2329 static ITextSelectionImpl *
2330 CreateTextSelection(IRichEditOleImpl *reOle)
2331 {
2332     ITextSelectionImpl *txtSel = heap_alloc(sizeof *txtSel);
2333     if (!txtSel)
2334         return NULL;
2335
2336     txtSel->ITextSelection_iface.lpVtbl = &tsvt;
2337     txtSel->ref = 1;
2338     txtSel->reOle = reOle;
2339     return txtSel;
2340 }
2341
2342 LRESULT CreateIRichEditOle(IUnknown *outer_unk, ME_TextEditor *editor, LPVOID *ppvObj)
2343 {
2344     IRichEditOleImpl *reo;
2345
2346     reo = heap_alloc(sizeof(IRichEditOleImpl));
2347     if (!reo)
2348         return 0;
2349
2350     reo->IUnknown_inner.lpVtbl = &reo_unk_vtbl;
2351     reo->IRichEditOle_iface.lpVtbl = &revt;
2352     reo->ITextDocument_iface.lpVtbl = &tdvt;
2353     reo->ref = 1;
2354     reo->editor = editor;
2355     reo->txtSel = CreateTextSelection(reo);
2356     if (!reo->txtSel)
2357     {
2358         heap_free(reo);
2359         return 0;
2360     }
2361     reo->clientSite = CreateOleClientSite(reo);
2362     if (!reo->clientSite)
2363     {
2364         ITextSelection_Release(&reo->txtSel->ITextSelection_iface);
2365         heap_free(reo);
2366         return 0;
2367     }
2368     TRACE("Created %p\n",reo);
2369     list_init(&reo->rangelist);
2370     if (outer_unk)
2371         reo->outer_unk = outer_unk;
2372     else
2373         reo->outer_unk = &reo->IUnknown_inner;
2374     *ppvObj = &reo->IRichEditOle_iface;
2375
2376     return 1;
2377 }
2378
2379 static void convert_sizel(const ME_Context *c, const SIZEL* szl, SIZE* sz)
2380 {
2381   /* sizel is in .01 millimeters, sz in pixels */
2382   sz->cx = MulDiv(szl->cx, c->dpi.cx, 2540);
2383   sz->cy = MulDiv(szl->cy, c->dpi.cy, 2540);
2384 }
2385
2386 /******************************************************************************
2387  * ME_GetOLEObjectSize
2388  *
2389  * Sets run extent for OLE objects.
2390  */
2391 void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize)
2392 {
2393   IDataObject*  ido;
2394   FORMATETC     fmt;
2395   STGMEDIUM     stgm;
2396   DIBSECTION    dibsect;
2397   ENHMETAHEADER emh;
2398
2399   assert(run->nFlags & MERF_GRAPHICS);
2400   assert(run->ole_obj);
2401
2402   if (run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0)
2403   {
2404     convert_sizel(c, &run->ole_obj->sizel, pSize);
2405     if (c->editor->nZoomNumerator != 0)
2406     {
2407       pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
2408       pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
2409     }
2410     return;
2411   }
2412
2413   if (IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
2414   {
2415       FIXME("Query Interface IID_IDataObject failed!\n");
2416       pSize->cx = pSize->cy = 0;
2417       return;
2418   }
2419   fmt.cfFormat = CF_BITMAP;
2420   fmt.ptd = NULL;
2421   fmt.dwAspect = DVASPECT_CONTENT;
2422   fmt.lindex = -1;
2423   fmt.tymed = TYMED_GDI;
2424   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
2425   {
2426     fmt.cfFormat = CF_ENHMETAFILE;
2427     fmt.tymed = TYMED_ENHMF;
2428     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
2429     {
2430       FIXME("unsupported format\n");
2431       pSize->cx = pSize->cy = 0;
2432       IDataObject_Release(ido);
2433       return;
2434     }
2435   }
2436
2437   switch (stgm.tymed)
2438   {
2439   case TYMED_GDI:
2440     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
2441     pSize->cx = dibsect.dsBm.bmWidth;
2442     pSize->cy = dibsect.dsBm.bmHeight;
2443     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
2444     break;
2445   case TYMED_ENHMF:
2446     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
2447     pSize->cx = emh.rclBounds.right - emh.rclBounds.left;
2448     pSize->cy = emh.rclBounds.bottom - emh.rclBounds.top;
2449     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
2450     break;
2451   default:
2452     FIXME("Unsupported tymed %d\n", stgm.tymed);
2453     break;
2454   }
2455   IDataObject_Release(ido);
2456   if (c->editor->nZoomNumerator != 0)
2457   {
2458     pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
2459     pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
2460   }
2461 }
2462
2463 void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run,
2464                 ME_Paragraph *para, BOOL selected)
2465 {
2466   IDataObject*  ido;
2467   FORMATETC     fmt;
2468   STGMEDIUM     stgm;
2469   DIBSECTION    dibsect;
2470   ENHMETAHEADER emh;
2471   HDC           hMemDC;
2472   SIZE          sz;
2473   BOOL          has_size;
2474
2475   assert(run->nFlags & MERF_GRAPHICS);
2476   assert(run->ole_obj);
2477   if (IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
2478   {
2479     FIXME("Couldn't get interface\n");
2480     return;
2481   }
2482   has_size = run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0;
2483   fmt.cfFormat = CF_BITMAP;
2484   fmt.ptd = NULL;
2485   fmt.dwAspect = DVASPECT_CONTENT;
2486   fmt.lindex = -1;
2487   fmt.tymed = TYMED_GDI;
2488   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
2489   {
2490     fmt.cfFormat = CF_ENHMETAFILE;
2491     fmt.tymed = TYMED_ENHMF;
2492     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
2493     {
2494       FIXME("Couldn't get storage medium\n");
2495       IDataObject_Release(ido);
2496       return;
2497     }
2498   }
2499   switch (stgm.tymed)
2500   {
2501   case TYMED_GDI:
2502     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
2503     hMemDC = CreateCompatibleDC(c->hDC);
2504     SelectObject(hMemDC, stgm.u.hBitmap);
2505     if (has_size)
2506     {
2507       convert_sizel(c, &run->ole_obj->sizel, &sz);
2508     } else {
2509       sz.cx = MulDiv(dibsect.dsBm.bmWidth, c->dpi.cx, 96);
2510       sz.cy = MulDiv(dibsect.dsBm.bmHeight, c->dpi.cy, 96);
2511     }
2512     if (c->editor->nZoomNumerator != 0)
2513     {
2514       sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
2515       sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
2516     }
2517     if (sz.cx == dibsect.dsBm.bmWidth && sz.cy == dibsect.dsBm.bmHeight)
2518     {
2519       BitBlt(c->hDC, x, y - sz.cy,
2520              dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight,
2521              hMemDC, 0, 0, SRCCOPY);
2522     } else {
2523       StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
2524                  hMemDC, 0, 0, dibsect.dsBm.bmWidth,
2525                  dibsect.dsBm.bmHeight, SRCCOPY);
2526     }
2527     DeleteDC(hMemDC);
2528     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
2529     break;
2530   case TYMED_ENHMF:
2531     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
2532     if (has_size)
2533     {
2534       convert_sizel(c, &run->ole_obj->sizel, &sz);
2535     } else {
2536       sz.cy = MulDiv(emh.rclBounds.bottom - emh.rclBounds.top, c->dpi.cx, 96);
2537       sz.cx = MulDiv(emh.rclBounds.right - emh.rclBounds.left, c->dpi.cy, 96);
2538     }
2539     if (c->editor->nZoomNumerator != 0)
2540     {
2541       sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
2542       sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
2543     }
2544
2545     {
2546       RECT    rc;
2547
2548       rc.left = x;
2549       rc.top = y - sz.cy;
2550       rc.right = x + sz.cx;
2551       rc.bottom = y;
2552       PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
2553     }
2554     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
2555     break;
2556   default:
2557     FIXME("Unsupported tymed %d\n", stgm.tymed);
2558     selected = FALSE;
2559     break;
2560   }
2561   if (selected && !c->editor->bHideSelection)
2562     PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
2563   IDataObject_Release(ido);
2564 }
2565
2566 void ME_DeleteReObject(REOBJECT* reo)
2567 {
2568     if (reo->poleobj)   IOleObject_Release(reo->poleobj);
2569     if (reo->pstg)      IStorage_Release(reo->pstg);
2570     if (reo->polesite)  IOleClientSite_Release(reo->polesite);
2571     FREE_OBJ(reo);
2572 }
2573
2574 void ME_CopyReObject(REOBJECT* dst, const REOBJECT* src)
2575 {
2576     *dst = *src;
2577
2578     if (dst->poleobj)   IOleObject_AddRef(dst->poleobj);
2579     if (dst->pstg)      IStorage_AddRef(dst->pstg);
2580     if (dst->polesite)  IOleClientSite_AddRef(dst->polesite);
2581 }
2582
2583 void ME_GetITextDocumentInterface(IRichEditOle *iface, LPVOID *ppvObj)
2584 {
2585     IRichEditOleImpl *This = impl_from_IRichEditOle(iface);
2586     *ppvObj = &This->ITextDocument_iface;
2587 }