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