dlls/riched20/richole.c

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