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 COBJMACROS
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "ole2.h"
  32 #include "richole.h"
  33 #include "editor.h"
  34 #include "tom.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
  38
  39 /* there is no way to be consistent across different sets of headers - mingw, Wine, Win32 SDK*/
  40
  41 #include "initguid.h"
  42 DEFINE_GUID(IID_ITextServices, 0x8d33f740, 0xcf58, 0x11ce, 0xa8, 0x9d, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5);
  43 DEFINE_GUID(IID_ITextHost, 0x13e670f4,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1);
  44 DEFINE_GUID(IID_ITextHost2, 0x13e670f5,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1);
  45 DEFINE_GUID(IID_ITextDocument, 0x8cc497c0, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  46 DEFINE_GUID(IID_ITextRange, 0x8cc497c2, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  47 DEFINE_GUID(IID_ITextSelection, 0x8cc497c1, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  48 DEFINE_GUID(IID_ITextFont, 0x8cc497c3, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  49 DEFINE_GUID(IID_ITextPara, 0x8cc497c4, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  50
  51 typedef struct ITextSelectionImpl ITextSelectionImpl;
  52 typedef struct IOleClientSiteImpl IOleClientSiteImpl;
  53 typedef struct ITextRangeImpl ITextRangeImpl;
  54
  55 typedef struct IRichEditOleImpl {
  56     IUnknown IUnknown_inner;
  57     IRichEditOle IRichEditOle_iface;
  58     ITextDocument ITextDocument_iface;
  59     IUnknown *outer_unk;
  60     LONG ref;
  61
  62     ME_TextEditor *editor;
  63     ITextSelectionImpl *txtSel;
  64     IOleClientSiteImpl *clientSite;
  65     struct list rangelist;
  66 } IRichEditOleImpl;
  67
  68 struct ITextRangeImpl {
  69     ITextRange ITextRange_iface;
  70     LONG ref;
  71     LONG start, end;
  72     struct list entry;
  73
  74     IRichEditOleImpl *reOle;
  75 };
  76
  77 struct ITextSelectionImpl {
  78     ITextSelection ITextSelection_iface;
  79     LONG ref;
  80
  81     IRichEditOleImpl *reOle;
  82 };
  83
  84 typedef struct ITextFontImpl {
  85     ITextFont ITextFont_iface;
  86     LONG ref;
  87
  88     ITextRange *range;
  89 } ITextFontImpl;
  90
  91 typedef struct ITextParaImpl {
  92     ITextPara ITextPara_iface;
  93     LONG ref;
  94
  95     ITextRange *range;
  96 } ITextParaImpl;
  97
  98 struct IOleClientSiteImpl {
  99     IOleClientSite IOleClientSite_iface;
 100     IOleWindow IOleWindow_iface;
 101     IOleInPlaceSite IOleInPlaceSite_iface;
 102     LONG ref;
 103
 104     IRichEditOleImpl *reOle;
 105 };
 106
 107 static inline IRichEditOleImpl *impl_from_IRichEditOle(IRichEditOle *iface)
 108 {
 109     return CONTAINING_RECORD(iface, IRichEditOleImpl, IRichEditOle_iface);
 110 }
 111
 112 static inline IRichEditOleImpl *impl_from_ITextDocument(ITextDocument *iface)
 113 {
 114     return CONTAINING_RECORD(iface, IRichEditOleImpl, ITextDocument_iface);
 115 }
 116
 117 static inline IRichEditOleImpl *impl_from_IUnknown(IUnknown *iface)
 118 {
 119     return CONTAINING_RECORD(iface, IRichEditOleImpl, IUnknown_inner);
 120 }
 121
 122 static inline IOleClientSiteImpl *impl_from_IOleWindow(IOleWindow *iface)
 123 {
 124     return CONTAINING_RECORD(iface, IOleClientSiteImpl, IOleWindow_iface);
 125 }
 126
 127 static inline IOleClientSiteImpl *impl_from_IOleInPlaceSite(IOleInPlaceSite *iface)
 128 {
 129     return CONTAINING_RECORD(iface, IOleClientSiteImpl, IOleInPlaceSite_iface);
 130 }
 131
 132 static inline ITextSelectionImpl *impl_from_ITextSelection(ITextSelection *iface)
 133 {
 134     return CONTAINING_RECORD(iface, ITextSelectionImpl, ITextSelection_iface);
 135 }
 136
 137 static inline ITextFontImpl *impl_from_ITextFont(ITextFont *iface)
 138 {
 139     return CONTAINING_RECORD(iface, ITextFontImpl, ITextFont_iface);
 140 }
 141
 142 static inline ITextParaImpl *impl_from_ITextPara(ITextPara *iface)
 143 {
 144     return CONTAINING_RECORD(iface, ITextParaImpl, ITextPara_iface);
 145 }
 146
 147 static HRESULT create_textfont(ITextRange*, ITextFont**);
 148 static HRESULT create_textpara(ITextRange*, ITextPara**);
 149
 150 static HRESULT WINAPI IRichEditOleImpl_inner_fnQueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppvObj)
 151 {
 152     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 153
 154     TRACE("%p %s\n", This, debugstr_guid(riid));
 155
 156     *ppvObj = NULL;
 157     if (IsEqualGUID(riid, &IID_IUnknown))
 158         *ppvObj = &This->IUnknown_inner;
 159     else if (IsEqualGUID(riid, &IID_IRichEditOle))
 160         *ppvObj = &This->IRichEditOle_iface;
 161     else if (IsEqualGUID(riid, &IID_ITextDocument))
 162         *ppvObj = &This->ITextDocument_iface;
 163     if (*ppvObj)
 164     {
 165         IUnknown_AddRef((IUnknown *)*ppvObj);
 166         return S_OK;
 167     }
 168     FIXME("%p: unhandled interface %s\n", This, debugstr_guid(riid));
 169
 170     return E_NOINTERFACE;
 171 }
 172
 173 static ULONG WINAPI IRichEditOleImpl_inner_fnAddRef(IUnknown *iface)
 174 {
 175     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 176     ULONG ref = InterlockedIncrement(&This->ref);
 177
 178     TRACE("%p ref = %u\n", This, ref);
 179
 180     return ref;
 181 }
 182
 183 static ULONG WINAPI IRichEditOleImpl_inner_fnRelease(IUnknown *iface)
 184 {
 185     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 186     ULONG ref = InterlockedDecrement(&This->ref);
 187
 188     TRACE ("%p ref=%u\n", This, ref);
 189
 190     if (!ref)
 191     {
 192         ITextRangeImpl *txtRge;
 193
 194         TRACE("Destroying %p\n", This);
 195         This->txtSel->reOle = NULL;
 196         This->editor->reOle = NULL;
 197         ITextSelection_Release(&This->txtSel->ITextSelection_iface);
 198         IOleClientSite_Release(&This->clientSite->IOleClientSite_iface);
 199         LIST_FOR_EACH_ENTRY(txtRge, &This->rangelist, ITextRangeImpl, entry)
 200             txtRge->reOle = NULL;
 201         heap_free(This);
 202     }
 203     return ref;
 204 }
 205
 206 static const IUnknownVtbl reo_unk_vtbl =
 207 {
 208     IRichEditOleImpl_inner_fnQueryInterface,
 209     IRichEditOleImpl_inner_fnAddRef,
 210     IRichEditOleImpl_inner_fnRelease
 211 };
 212
 213 static HRESULT WINAPI
 214 IRichEditOle_fnQueryInterface(IRichEditOle *me, REFIID riid, LPVOID *ppvObj)
 215 {
 216     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 217     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
 218 }
 219
 220 static ULONG WINAPI
 221 IRichEditOle_fnAddRef(IRichEditOle *me)
 222 {
 223     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 224     return IUnknown_AddRef(This->outer_unk);
 225 }
 226
 227 static ULONG WINAPI
 228 IRichEditOle_fnRelease(IRichEditOle *me)
 229 {
 230     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 231     return IUnknown_Release(This->outer_unk);
 232 }
 233
 234 static HRESULT WINAPI
 235 IRichEditOle_fnActivateAs(IRichEditOle *me, REFCLSID rclsid, REFCLSID rclsidAs)
 236 {
 237     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 238     FIXME("stub %p\n",This);
 239     return E_NOTIMPL;
 240 }
 241
 242 static HRESULT WINAPI
 243 IRichEditOle_fnContextSensitiveHelp(IRichEditOle *me, BOOL fEnterMode)
 244 {
 245     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 246     FIXME("stub %p\n",This);
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI
 251 IRichEditOle_fnConvertObject(IRichEditOle *me, LONG iob,
 252                REFCLSID rclsidNew, LPCSTR lpstrUserTypeNew)
 253 {
 254     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 255     FIXME("stub %p\n",This);
 256     return E_NOTIMPL;
 257 }
 258
 259 static inline IOleClientSiteImpl *impl_from_IOleClientSite(IOleClientSite *iface)
 260 {
 261     return CONTAINING_RECORD(iface, IOleClientSiteImpl, IOleClientSite_iface);
 262 }
 263
 264 static HRESULT WINAPI
 265 IOleClientSite_fnQueryInterface(IOleClientSite *me, REFIID riid, LPVOID *ppvObj)
 266 {
 267     IOleClientSiteImpl *This = impl_from_IOleClientSite(me);
 268     TRACE("%p %s\n", me, debugstr_guid(riid) );
 269
 270     *ppvObj = NULL;
 271     if (IsEqualGUID(riid, &IID_IUnknown) ||
 272         IsEqualGUID(riid, &IID_IOleClientSite))
 273         *ppvObj = me;
 274     else if (IsEqualGUID(riid, &IID_IOleWindow))
 275         *ppvObj = &This->IOleWindow_iface;
 276     else if (IsEqualGUID(riid, &IID_IOleInPlaceSite))
 277         *ppvObj = &This->IOleInPlaceSite_iface;
 278     if (*ppvObj)
 279     {
 280         IOleClientSite_AddRef(me);
 281         return S_OK;
 282     }
 283     FIXME("%p: unhandled interface %s\n", me, debugstr_guid(riid) );
 284
 285     return E_NOINTERFACE;
 286 }
 287
 288 static ULONG WINAPI IOleClientSite_fnAddRef(IOleClientSite *iface)
 289 {
 290     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 291     return InterlockedIncrement(&This->ref);
 292 }
 293
 294 static ULONG WINAPI IOleClientSite_fnRelease(IOleClientSite *iface)
 295 {
 296     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 297     ULONG ref = InterlockedDecrement(&This->ref);
 298     if (ref == 0)
 299         heap_free(This);
 300     return ref;
 301 }
 302
 303 static HRESULT WINAPI IOleClientSite_fnSaveObject(IOleClientSite *iface)
 304 {
 305     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 306     if (!This->reOle)
 307         return CO_E_RELEASED;
 308
 309     FIXME("stub %p\n", iface);
 310     return E_NOTIMPL;
 311 }
 312
 313
 314 static HRESULT WINAPI IOleClientSite_fnGetMoniker(IOleClientSite *iface, DWORD dwAssign,
 315         DWORD dwWhichMoniker, IMoniker **ppmk)
 316 {
 317     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 318     if (!This->reOle)
 319         return CO_E_RELEASED;
 320
 321     FIXME("stub %p\n", iface);
 322     return E_NOTIMPL;
 323 }
 324
 325 static HRESULT WINAPI IOleClientSite_fnGetContainer(IOleClientSite *iface,
 326         IOleContainer **ppContainer)
 327 {
 328     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 329     if (!This->reOle)
 330         return CO_E_RELEASED;
 331
 332     FIXME("stub %p\n", iface);
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT WINAPI IOleClientSite_fnShowObject(IOleClientSite *iface)
 337 {
 338     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 339     if (!This->reOle)
 340         return CO_E_RELEASED;
 341
 342     FIXME("stub %p\n", iface);
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI IOleClientSite_fnOnShowWindow(IOleClientSite *iface, BOOL fShow)
 347 {
 348     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 349     if (!This->reOle)
 350         return CO_E_RELEASED;
 351
 352     FIXME("stub %p\n", iface);
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI IOleClientSite_fnRequestNewObjectLayout(IOleClientSite *iface)
 357 {
 358     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
 359     if (!This->reOle)
 360         return CO_E_RELEASED;
 361
 362     FIXME("stub %p\n", iface);
 363     return E_NOTIMPL;
 364 }
 365
 366 static const IOleClientSiteVtbl ocst = {
 367     IOleClientSite_fnQueryInterface,
 368     IOleClientSite_fnAddRef,
 369     IOleClientSite_fnRelease,
 370     IOleClientSite_fnSaveObject,
 371     IOleClientSite_fnGetMoniker,
 372     IOleClientSite_fnGetContainer,
 373     IOleClientSite_fnShowObject,
 374     IOleClientSite_fnOnShowWindow,
 375     IOleClientSite_fnRequestNewObjectLayout
 376 };
 377
 378 /* IOleWindow interface */
 379 static HRESULT WINAPI IOleWindow_fnQueryInterface(IOleWindow *iface, REFIID riid, void **ppvObj)
 380 {
 381     IOleClientSiteImpl *This = impl_from_IOleWindow(iface);
 382     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppvObj);
 383 }
 384
 385 static ULONG WINAPI IOleWindow_fnAddRef(IOleWindow *iface)
 386 {
 387     IOleClientSiteImpl *This = impl_from_IOleWindow(iface);
 388     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
 389 }
 390
 391 static ULONG WINAPI IOleWindow_fnRelease(IOleWindow *iface)
 392 {
 393     IOleClientSiteImpl *This = impl_from_IOleWindow(iface);
 394     return IOleClientSite_Release(&This->IOleClientSite_iface);
 395 }
 396
 397 static HRESULT WINAPI IOleWindow_fnContextSensitiveHelp(IOleWindow *iface, BOOL fEnterMode)
 398 {
 399     IOleClientSiteImpl *This = impl_from_IOleWindow(iface);
 400     FIXME("not implemented: (%p)->(%d)\n", This, fEnterMode);
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI IOleWindow_fnGetWindow(IOleWindow *iface, HWND *phwnd)
 405 {
 406     IOleClientSiteImpl *This = impl_from_IOleWindow(iface);
 407     TRACE("(%p)->(%p)\n", This, phwnd);
 408
 409     if (!phwnd)
 410         return E_INVALIDARG;
 411
 412     *phwnd = This->reOle->editor->hWnd;
 413     return S_OK;
 414 }
 415
 416 static const IOleWindowVtbl olewinvt = {
 417     IOleWindow_fnQueryInterface,
 418     IOleWindow_fnAddRef,
 419     IOleWindow_fnRelease,
 420     IOleWindow_fnGetWindow,
 421     IOleWindow_fnContextSensitiveHelp
 422 };
 423
 424 /* IOleInPlaceSite interface */
 425 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnQueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppvObj)
 426 {
 427     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 428     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppvObj);
 429 }
 430
 431 static ULONG STDMETHODCALLTYPE IOleInPlaceSite_fnAddRef(IOleInPlaceSite *iface)
 432 {
 433     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 434     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
 435 }
 436
 437 static ULONG STDMETHODCALLTYPE IOleInPlaceSite_fnRelease(IOleInPlaceSite *iface)
 438 {
 439     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 440     return IOleClientSite_Release(&This->IOleClientSite_iface);
 441 }
 442
 443 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnGetWindow(IOleInPlaceSite *iface, HWND *phwnd)
 444 {
 445     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 446     return IOleWindow_GetWindow(&This->IOleWindow_iface, phwnd);
 447 }
 448
 449 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
 450 {
 451     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 452     return IOleWindow_ContextSensitiveHelp(&This->IOleWindow_iface, fEnterMode);
 453 }
 454
 455 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnCanInPlaceActivate(IOleInPlaceSite *iface)
 456 {
 457     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 458     FIXME("not implemented: (%p)\n", This);
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnInPlaceActivate(IOleInPlaceSite *iface)
 463 {
 464     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 465     FIXME("not implemented: (%p)\n", This);
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnUIActivate(IOleInPlaceSite *iface)
 470 {
 471     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 472     FIXME("not implemented: (%p)\n", This);
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnGetWindowContext(IOleInPlaceSite *iface, IOleInPlaceFrame **ppFrame,
 477                                                                     IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
 478                                                                     LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 479 {
 480     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 481     FIXME("not implemented: (%p)->(%p %p %p %p %p)\n", This, ppFrame, ppDoc, lprcPosRect, lprcClipRect, lpFrameInfo);
 482     return E_NOTIMPL;
 483 }
 484
 485 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnScroll(IOleInPlaceSite *iface, SIZE scrollExtent)
 486 {
 487     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 488     FIXME("not implemented: (%p)\n", This);
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
 493 {
 494     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 495     FIXME("not implemented: (%p)->(%d)\n", This, fUndoable);
 496     return E_NOTIMPL;
 497 }
 498
 499 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnInPlaceDeactivate(IOleInPlaceSite *iface)
 500 {
 501     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 502     FIXME("not implemented: (%p)\n", This);
 503     return E_NOTIMPL;
 504 }
 505
 506 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnDiscardUndoState(IOleInPlaceSite *iface)
 507 {
 508     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 509     FIXME("not implemented: (%p)\n", This);
 510     return E_NOTIMPL;
 511 }
 512
 513 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnDeactivateAndUndo(IOleInPlaceSite *iface)
 514 {
 515     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 516     FIXME("not implemented: (%p)\n", This);
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
 521 {
 522     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
 523     FIXME("not implemented: (%p)->(%p)\n", This, lprcPosRect);
 524     return E_NOTIMPL;
 525 }
 526
 527 static const IOleInPlaceSiteVtbl olestvt =
 528 {
 529     IOleInPlaceSite_fnQueryInterface,
 530     IOleInPlaceSite_fnAddRef,
 531     IOleInPlaceSite_fnRelease,
 532     IOleInPlaceSite_fnGetWindow,
 533     IOleInPlaceSite_fnContextSensitiveHelp,
 534     IOleInPlaceSite_fnCanInPlaceActivate,
 535     IOleInPlaceSite_fnOnInPlaceActivate,
 536     IOleInPlaceSite_fnOnUIActivate,
 537     IOleInPlaceSite_fnGetWindowContext,
 538     IOleInPlaceSite_fnScroll,
 539     IOleInPlaceSite_fnOnUIDeactivate,
 540     IOleInPlaceSite_fnOnInPlaceDeactivate,
 541     IOleInPlaceSite_fnDiscardUndoState,
 542     IOleInPlaceSite_fnDeactivateAndUndo,
 543     IOleInPlaceSite_fnOnPosRectChange
 544 };
 545
 546 static IOleClientSiteImpl *
 547 CreateOleClientSite(IRichEditOleImpl *reOle)
 548 {
 549     IOleClientSiteImpl *clientSite = heap_alloc(sizeof *clientSite);
 550     if (!clientSite)
 551         return NULL;
 552
 553     clientSite->IOleClientSite_iface.lpVtbl = &ocst;
 554     clientSite->IOleWindow_iface.lpVtbl = &olewinvt;
 555     clientSite->IOleInPlaceSite_iface.lpVtbl = &olestvt;
 556     clientSite->ref = 1;
 557     clientSite->reOle = reOle;
 558     return clientSite;
 559 }
 560
 561 static HRESULT WINAPI
 562 IRichEditOle_fnGetClientSite(IRichEditOle *me,
 563                LPOLECLIENTSITE *lplpolesite)
 564 {
 565     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 566
 567     TRACE("%p,%p\n",This, lplpolesite);
 568
 569     if(!lplpolesite)
 570         return E_INVALIDARG;
 571     *lplpolesite = &This->clientSite->IOleClientSite_iface;
 572     IOleClientSite_AddRef(*lplpolesite);
 573     return S_OK;
 574 }
 575
 576 static HRESULT WINAPI
 577 IRichEditOle_fnGetClipboardData(IRichEditOle *me, CHARRANGE *lpchrg,
 578                DWORD reco, LPDATAOBJECT *lplpdataobj)
 579 {
 580     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 581     ME_Cursor start;
 582     int nChars;
 583
 584     TRACE("(%p,%p,%d)\n",This, lpchrg, reco);
 585     if(!lplpdataobj)
 586         return E_INVALIDARG;
 587     if(!lpchrg) {
 588         int nFrom, nTo, nStartCur = ME_GetSelectionOfs(This->editor, &nFrom, &nTo);
 589         start = This->editor->pCursors[nStartCur];
 590         nChars = nTo - nFrom;
 591     } else {
 592         ME_CursorFromCharOfs(This->editor, lpchrg->cpMin, &start);
 593         nChars = lpchrg->cpMax - lpchrg->cpMin;
 594     }
 595     return ME_GetDataObject(This->editor, &start, nChars, lplpdataobj);
 596 }
 597
 598 static LONG WINAPI IRichEditOle_fnGetLinkCount(IRichEditOle *me)
 599 {
 600     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 601     FIXME("stub %p\n",This);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI
 606 IRichEditOle_fnGetObject(IRichEditOle *me, LONG iob,
 607                REOBJECT *lpreobject, DWORD dwFlags)
 608 {
 609     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 610     FIXME("stub %p\n",This);
 611     return E_NOTIMPL;
 612 }
 613
 614 static LONG WINAPI
 615 IRichEditOle_fnGetObjectCount(IRichEditOle *me)
 616 {
 617     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 618     FIXME("stub %p\n",This);
 619     return 0;
 620 }
 621
 622 static HRESULT WINAPI
 623 IRichEditOle_fnHandsOffStorage(IRichEditOle *me, LONG iob)
 624 {
 625     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 626     FIXME("stub %p\n",This);
 627     return E_NOTIMPL;
 628 }
 629
 630 static HRESULT WINAPI
 631 IRichEditOle_fnImportDataObject(IRichEditOle *me, LPDATAOBJECT lpdataobj,
 632                CLIPFORMAT cf, HGLOBAL hMetaPict)
 633 {
 634     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 635     FIXME("stub %p\n",This);
 636     return E_NOTIMPL;
 637 }
 638
 639 static HRESULT WINAPI
 640 IRichEditOle_fnInPlaceDeactivate(IRichEditOle *me)
 641 {
 642     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 643     FIXME("stub %p\n",This);
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI
 648 IRichEditOle_fnInsertObject(IRichEditOle *me, REOBJECT *reo)
 649 {
 650     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 651     TRACE("(%p,%p)\n", This, reo);
 652
 653     if (reo->cbStruct < sizeof(*reo)) return STG_E_INVALIDPARAMETER;
 654
 655     ME_InsertOLEFromCursor(This->editor, reo, 0);
 656     ME_CommitUndo(This->editor);
 657     ME_UpdateRepaint(This->editor, FALSE);
 658     return S_OK;
 659 }
 660
 661 static HRESULT WINAPI IRichEditOle_fnSaveCompleted(IRichEditOle *me, LONG iob,
 662                LPSTORAGE lpstg)
 663 {
 664     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 665     FIXME("stub %p\n",This);
 666     return E_NOTIMPL;
 667 }
 668
 669 static HRESULT WINAPI
 670 IRichEditOle_fnSetDvaspect(IRichEditOle *me, LONG iob, DWORD dvaspect)
 671 {
 672     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 673     FIXME("stub %p\n",This);
 674     return E_NOTIMPL;
 675 }
 676
 677 static HRESULT WINAPI IRichEditOle_fnSetHostNames(IRichEditOle *me,
 678                LPCSTR lpstrContainerApp, LPCSTR lpstrContainerObj)
 679 {
 680     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 681     FIXME("stub %p %s %s\n",This, lpstrContainerApp, lpstrContainerObj);
 682     return E_NOTIMPL;
 683 }
 684
 685 static HRESULT WINAPI
 686 IRichEditOle_fnSetLinkAvailable(IRichEditOle *me, LONG iob, BOOL fAvailable)
 687 {
 688     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
 689     FIXME("stub %p\n",This);
 690     return E_NOTIMPL;
 691 }
 692
 693 static const IRichEditOleVtbl revt = {
 694     IRichEditOle_fnQueryInterface,
 695     IRichEditOle_fnAddRef,
 696     IRichEditOle_fnRelease,
 697     IRichEditOle_fnGetClientSite,
 698     IRichEditOle_fnGetObjectCount,
 699     IRichEditOle_fnGetLinkCount,
 700     IRichEditOle_fnGetObject,
 701     IRichEditOle_fnInsertObject,
 702     IRichEditOle_fnConvertObject,
 703     IRichEditOle_fnActivateAs,
 704     IRichEditOle_fnSetHostNames,
 705     IRichEditOle_fnSetLinkAvailable,
 706     IRichEditOle_fnSetDvaspect,
 707     IRichEditOle_fnHandsOffStorage,
 708     IRichEditOle_fnSaveCompleted,
 709     IRichEditOle_fnInPlaceDeactivate,
 710     IRichEditOle_fnContextSensitiveHelp,
 711     IRichEditOle_fnGetClipboardData,
 712     IRichEditOle_fnImportDataObject
 713 };
 714
 715 /* ITextRange interface */
 716 static inline ITextRangeImpl *impl_from_ITextRange(ITextRange *iface)
 717 {
 718     return CONTAINING_RECORD(iface, ITextRangeImpl, ITextRange_iface);
 719 }
 720
 721 static HRESULT WINAPI ITextRange_fnQueryInterface(ITextRange *me, REFIID riid, void **ppvObj)
 722 {
 723     *ppvObj = NULL;
 724     if (IsEqualGUID(riid, &IID_IUnknown)
 725         || IsEqualGUID(riid, &IID_IDispatch)
 726         || IsEqualGUID(riid, &IID_ITextRange))
 727     {
 728         *ppvObj = me;
 729         ITextRange_AddRef(me);
 730         return S_OK;
 731     }
 732
 733     return E_NOINTERFACE;
 734 }
 735
 736 static ULONG WINAPI ITextRange_fnAddRef(ITextRange *me)
 737 {
 738     ITextRangeImpl *This = impl_from_ITextRange(me);
 739     return InterlockedIncrement(&This->ref);
 740 }
 741
 742 static ULONG WINAPI ITextRange_fnRelease(ITextRange *me)
 743 {
 744     ITextRangeImpl *This = impl_from_ITextRange(me);
 745     ULONG ref = InterlockedDecrement(&This->ref);
 746
 747     TRACE ("%p ref=%u\n", This, ref);
 748     if (ref == 0)
 749     {
 750         if (This->reOle)
 751         {
 752             list_remove(&This->entry);
 753             This->reOle = NULL;
 754         }
 755         heap_free(This);
 756     }
 757     return ref;
 758 }
 759
 760 static HRESULT WINAPI ITextRange_fnGetTypeInfoCount(ITextRange *me, UINT *pctinfo)
 761 {
 762     ITextRangeImpl *This = impl_from_ITextRange(me);
 763     if (!This->reOle)
 764         return CO_E_RELEASED;
 765
 766     FIXME("not implemented %p\n", This);
 767     return E_NOTIMPL;
 768 }
 769
 770 static HRESULT WINAPI ITextRange_fnGetTypeInfo(ITextRange *me, UINT iTInfo, LCID lcid,
 771                                                ITypeInfo **ppTInfo)
 772 {
 773     ITextRangeImpl *This = impl_from_ITextRange(me);
 774     if (!This->reOle)
 775         return CO_E_RELEASED;
 776
 777     FIXME("not implemented %p\n", This);
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI ITextRange_fnGetIDsOfNames(ITextRange *me, REFIID riid, LPOLESTR *rgszNames,
 782                                                  UINT cNames, LCID lcid, DISPID *rgDispId)
 783 {
 784     ITextRangeImpl *This = impl_from_ITextRange(me);
 785     if (!This->reOle)
 786         return CO_E_RELEASED;
 787
 788     FIXME("not implemented %p\n", This);
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI ITextRange_fnInvoke(ITextRange *me, DISPID dispIdMember, REFIID riid,
 793                                           LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 794                                           VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 795                                           UINT *puArgErr)
 796 {
 797     ITextRangeImpl *This = impl_from_ITextRange(me);
 798     if (!This->reOle)
 799         return CO_E_RELEASED;
 800
 801     FIXME("not implemented %p\n", This);
 802     return E_NOTIMPL;
 803 }
 804
 805 static HRESULT WINAPI ITextRange_fnGetText(ITextRange *me, BSTR *pbstr)
 806 {
 807     ITextRangeImpl *This = impl_from_ITextRange(me);
 808     if (!This->reOle)
 809         return CO_E_RELEASED;
 810
 811     FIXME("not implemented %p\n", This);
 812     return E_NOTIMPL;
 813 }
 814
 815 static HRESULT WINAPI ITextRange_fnSetText(ITextRange *me, BSTR bstr)
 816 {
 817     ITextRangeImpl *This = impl_from_ITextRange(me);
 818     if (!This->reOle)
 819         return CO_E_RELEASED;
 820
 821     FIXME("not implemented %p\n", This);
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT range_GetChar(ME_TextEditor *editor, ME_Cursor *cursor, LONG *pch)
 826 {
 827     WCHAR wch[2];
 828
 829     ME_GetTextW(editor, wch, 1, cursor, 1, FALSE, cursor->pRun->next->type == diTextEnd);
 830     *pch = wch[0];
 831
 832     return S_OK;
 833 }
 834
 835 static HRESULT WINAPI ITextRange_fnGetChar(ITextRange *me, LONG *pch)
 836 {
 837     ITextRangeImpl *This = impl_from_ITextRange(me);
 838     ME_Cursor cursor;
 839
 840     if (!This->reOle)
 841         return CO_E_RELEASED;
 842     TRACE("%p\n", pch);
 843     if (!pch)
 844         return E_INVALIDARG;
 845
 846     ME_CursorFromCharOfs(This->reOle->editor, This->start, &cursor);
 847     return range_GetChar(This->reOle->editor, &cursor, pch);
 848 }
 849
 850 static HRESULT WINAPI ITextRange_fnSetChar(ITextRange *me, LONG ch)
 851 {
 852     ITextRangeImpl *This = impl_from_ITextRange(me);
 853     if (!This->reOle)
 854         return CO_E_RELEASED;
 855
 856     FIXME("not implemented %p\n", This);
 857     return E_NOTIMPL;
 858 }
 859
 860 static HRESULT CreateITextRange(IRichEditOleImpl *reOle, LONG start, LONG end, ITextRange** ppRange);
 861
 862 static HRESULT WINAPI ITextRange_fnGetDuplicate(ITextRange *me, ITextRange **ppRange)
 863 {
 864     ITextRangeImpl *This = impl_from_ITextRange(me);
 865     if (!This->reOle)
 866         return CO_E_RELEASED;
 867
 868     TRACE("%p %p\n", This, ppRange);
 869     if (!ppRange)
 870         return E_INVALIDARG;
 871
 872     return CreateITextRange(This->reOle, This->start, This->end, ppRange);
 873 }
 874
 875 static HRESULT WINAPI ITextRange_fnGetFormattedText(ITextRange *me, ITextRange **ppRange)
 876 {
 877     ITextRangeImpl *This = impl_from_ITextRange(me);
 878     if (!This->reOle)
 879         return CO_E_RELEASED;
 880
 881     FIXME("not implemented %p\n", This);
 882     return E_NOTIMPL;
 883 }
 884
 885 static HRESULT WINAPI ITextRange_fnSetFormattedText(ITextRange *me, ITextRange *pRange)
 886 {
 887     ITextRangeImpl *This = impl_from_ITextRange(me);
 888     if (!This->reOle)
 889         return CO_E_RELEASED;
 890
 891     FIXME("not implemented %p\n", This);
 892     return E_NOTIMPL;
 893 }
 894
 895 static HRESULT WINAPI ITextRange_fnGetStart(ITextRange *me, LONG *pcpFirst)
 896 {
 897     ITextRangeImpl *This = impl_from_ITextRange(me);
 898     if (!This->reOle)
 899         return CO_E_RELEASED;
 900
 901     if (!pcpFirst)
 902         return E_INVALIDARG;
 903     *pcpFirst = This->start;
 904     TRACE("%d\n", *pcpFirst);
 905     return S_OK;
 906 }
 907
 908 static HRESULT WINAPI ITextRange_fnSetStart(ITextRange *me, LONG start)
 909 {
 910     ITextRangeImpl *This = impl_from_ITextRange(me);
 911     int len;
 912
 913     TRACE("(%p)->(%d)\n", This, start);
 914
 915     if (!This->reOle)
 916         return CO_E_RELEASED;
 917
 918     if (start == This->start)
 919         return S_FALSE;
 920
 921     if (start < 0) {
 922         This->start = 0;
 923         return S_OK;
 924     }
 925
 926     len = ME_GetTextLength(This->reOle->editor);
 927     if (start > This->end)
 928         This->end = len;
 929
 930     if (start > len)
 931         This->start = len;
 932     else
 933         This->start = start;
 934
 935     return S_OK;
 936 }
 937
 938 static HRESULT WINAPI ITextRange_fnGetEnd(ITextRange *me, LONG *pcpLim)
 939 {
 940     ITextRangeImpl *This = impl_from_ITextRange(me);
 941     if (!This->reOle)
 942         return CO_E_RELEASED;
 943
 944     if (!pcpLim)
 945         return E_INVALIDARG;
 946     *pcpLim = This->end;
 947     TRACE("%d\n", *pcpLim);
 948     return S_OK;
 949 }
 950
 951 static HRESULT WINAPI ITextRange_fnSetEnd(ITextRange *me, LONG end)
 952 {
 953     ITextRangeImpl *This = impl_from_ITextRange(me);
 954     int len;
 955
 956     TRACE("(%p)->(%d)\n", This, end);
 957
 958     if (!This->reOle)
 959         return CO_E_RELEASED;
 960
 961     if (end == This->end)
 962         return S_FALSE;
 963
 964     if (end < This->start) {
 965         This->start = This->end = max(0, end);
 966         return S_OK;
 967     }
 968
 969     len = ME_GetTextLength(This->reOle->editor);
 970     if (end > len)
 971         This->end = len + 1;
 972     else
 973         This->end = end;
 974
 975     return S_OK;
 976 }
 977
 978 static HRESULT WINAPI ITextRange_fnGetFont(ITextRange *me, ITextFont **font)
 979 {
 980     ITextRangeImpl *This = impl_from_ITextRange(me);
 981
 982     TRACE("(%p)->(%p)\n", This, font);
 983
 984     if (!This->reOle)
 985         return CO_E_RELEASED;
 986
 987     if (!font)
 988         return E_INVALIDARG;
 989
 990     return create_textfont(me, font);
 991 }
 992
 993 static HRESULT WINAPI ITextRange_fnSetFont(ITextRange *me, ITextFont *pFont)
 994 {
 995     ITextRangeImpl *This = impl_from_ITextRange(me);
 996     if (!This->reOle)
 997         return CO_E_RELEASED;
 998
 999     FIXME("not implemented %p\n", This);
1000     return E_NOTIMPL;
1001 }
1002
1003 static HRESULT WINAPI ITextRange_fnGetPara(ITextRange *me, ITextPara **para)
1004 {
1005     ITextRangeImpl *This = impl_from_ITextRange(me);
1006
1007     TRACE("(%p)->(%p)\n", This, para);
1008
1009     if (!This->reOle)
1010         return CO_E_RELEASED;
1011
1012     if (!para)
1013         return E_INVALIDARG;
1014
1015     return create_textpara(me, para);
1016 }
1017
1018 static HRESULT WINAPI ITextRange_fnSetPara(ITextRange *me, ITextPara *pPara)
1019 {
1020     ITextRangeImpl *This = impl_from_ITextRange(me);
1021     if (!This->reOle)
1022         return CO_E_RELEASED;
1023
1024     FIXME("not implemented %p\n", This);
1025     return E_NOTIMPL;
1026 }
1027
1028 static HRESULT WINAPI ITextRange_fnGetStoryLength(ITextRange *me, LONG *pcch)
1029 {
1030     ITextRangeImpl *This = impl_from_ITextRange(me);
1031     if (!This->reOle)
1032         return CO_E_RELEASED;
1033
1034     FIXME("not implemented %p\n", This);
1035     return E_NOTIMPL;
1036 }
1037
1038 static HRESULT WINAPI ITextRange_fnGetStoryType(ITextRange *me, LONG *pValue)
1039 {
1040     ITextRangeImpl *This = impl_from_ITextRange(me);
1041     if (!This->reOle)
1042         return CO_E_RELEASED;
1043
1044     FIXME("not implemented %p\n", This);
1045     return E_NOTIMPL;
1046 }
1047
1048 static HRESULT range_Collapse(LONG bStart, LONG *start, LONG *end)
1049 {
1050   if (*end == *start)
1051       return S_FALSE;
1052
1053   if (bStart == tomEnd || bStart == tomFalse)
1054       *start = *end;
1055   else
1056       *end = *start;
1057   return S_OK;
1058 }
1059
1060 static HRESULT WINAPI ITextRange_fnCollapse(ITextRange *me, LONG bStart)
1061 {
1062     ITextRangeImpl *This = impl_from_ITextRange(me);
1063     if (!This->reOle)
1064         return CO_E_RELEASED;
1065
1066     return range_Collapse(bStart, &This->start, &This->end);
1067 }
1068
1069 static HRESULT WINAPI ITextRange_fnExpand(ITextRange *me, LONG Unit, LONG *pDelta)
1070 {
1071     ITextRangeImpl *This = impl_from_ITextRange(me);
1072     if (!This->reOle)
1073         return CO_E_RELEASED;
1074
1075     FIXME("not implemented %p\n", This);
1076     return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI ITextRange_fnGetIndex(ITextRange *me, LONG Unit, LONG *pIndex)
1080 {
1081     ITextRangeImpl *This = impl_from_ITextRange(me);
1082     if (!This->reOle)
1083         return CO_E_RELEASED;
1084
1085     FIXME("not implemented %p\n", This);
1086     return E_NOTIMPL;
1087 }
1088
1089 static HRESULT WINAPI ITextRange_fnSetIndex(ITextRange *me, LONG Unit, LONG Index,
1090                                             LONG Extend)
1091 {
1092     ITextRangeImpl *This = impl_from_ITextRange(me);
1093     if (!This->reOle)
1094         return CO_E_RELEASED;
1095
1096     FIXME("not implemented %p\n", This);
1097     return E_NOTIMPL;
1098 }
1099
1100 static HRESULT WINAPI ITextRange_fnSetRange(ITextRange *me, LONG cpActive, LONG cpOther)
1101 {
1102     ITextRangeImpl *This = impl_from_ITextRange(me);
1103     if (!This->reOle)
1104         return CO_E_RELEASED;
1105
1106     FIXME("not implemented %p\n", This);
1107     return E_NOTIMPL;
1108 }
1109
1110 static HRESULT WINAPI ITextRange_fnInRange(ITextRange *me, ITextRange *pRange, LONG *pb)
1111 {
1112     ITextRangeImpl *This = impl_from_ITextRange(me);
1113     if (!This->reOle)
1114         return CO_E_RELEASED;
1115
1116     FIXME("not implemented %p\n", This);
1117     return E_NOTIMPL;
1118 }
1119
1120 static HRESULT WINAPI ITextRange_fnInStory(ITextRange *me, ITextRange *pRange, LONG *pb)
1121 {
1122     ITextRangeImpl *This = impl_from_ITextRange(me);
1123     if (!This->reOle)
1124         return CO_E_RELEASED;
1125
1126     FIXME("not implemented %p\n", This);
1127     return E_NOTIMPL;
1128 }
1129
1130 static HRESULT WINAPI ITextRange_fnIsEqual(ITextRange *me, ITextRange *pRange, LONG *pb)
1131 {
1132     ITextRangeImpl *This = impl_from_ITextRange(me);
1133     if (!This->reOle)
1134         return CO_E_RELEASED;
1135
1136     FIXME("not implemented %p\n", This);
1137     return E_NOTIMPL;
1138 }
1139
1140 static HRESULT WINAPI ITextRange_fnSelect(ITextRange *me)
1141 {
1142     ITextRangeImpl *This = impl_from_ITextRange(me);
1143     if (!This->reOle)
1144         return CO_E_RELEASED;
1145
1146     FIXME("not implemented %p\n", This);
1147     return E_NOTIMPL;
1148 }
1149
1150 static HRESULT WINAPI ITextRange_fnStartOf(ITextRange *me, LONG Unit, LONG Extend,
1151                                            LONG *pDelta)
1152 {
1153     ITextRangeImpl *This = impl_from_ITextRange(me);
1154     if (!This->reOle)
1155         return CO_E_RELEASED;
1156
1157     FIXME("not implemented %p\n", This);
1158     return E_NOTIMPL;
1159 }
1160
1161 static HRESULT WINAPI ITextRange_fnEndOf(ITextRange *me, LONG Unit, LONG Extend,
1162                                          LONG *pDelta)
1163 {
1164     ITextRangeImpl *This = impl_from_ITextRange(me);
1165     if (!This->reOle)
1166         return CO_E_RELEASED;
1167
1168     FIXME("not implemented %p\n", This);
1169     return E_NOTIMPL;
1170 }
1171
1172 static HRESULT WINAPI ITextRange_fnMove(ITextRange *me, LONG Unit, LONG Count, LONG *pDelta)
1173 {
1174     ITextRangeImpl *This = impl_from_ITextRange(me);
1175     if (!This->reOle)
1176         return CO_E_RELEASED;
1177
1178     FIXME("not implemented %p\n", This);
1179     return E_NOTIMPL;
1180 }
1181
1182 static HRESULT WINAPI ITextRange_fnMoveStart(ITextRange *me, LONG Unit, LONG Count,
1183                                              LONG *pDelta)
1184 {
1185     ITextRangeImpl *This = impl_from_ITextRange(me);
1186     if (!This->reOle)
1187         return CO_E_RELEASED;
1188
1189     FIXME("not implemented %p\n", This);
1190     return E_NOTIMPL;
1191 }
1192
1193 static HRESULT WINAPI ITextRange_fnMoveEnd(ITextRange *me, LONG Unit, LONG Count,
1194                                            LONG *pDelta)
1195 {
1196     ITextRangeImpl *This = impl_from_ITextRange(me);
1197     if (!This->reOle)
1198         return CO_E_RELEASED;
1199
1200     FIXME("not implemented %p\n", This);
1201     return E_NOTIMPL;
1202 }
1203
1204 static HRESULT WINAPI ITextRange_fnMoveWhile(ITextRange *me, VARIANT *Cset, LONG Count,
1205                                              LONG *pDelta)
1206 {
1207     ITextRangeImpl *This = impl_from_ITextRange(me);
1208     if (!This->reOle)
1209         return CO_E_RELEASED;
1210
1211     FIXME("not implemented %p\n", This);
1212     return E_NOTIMPL;
1213 }
1214
1215 static HRESULT WINAPI ITextRange_fnMoveStartWhile(ITextRange *me, VARIANT *Cset, LONG Count,
1216                                                   LONG *pDelta)
1217 {
1218     ITextRangeImpl *This = impl_from_ITextRange(me);
1219     if (!This->reOle)
1220         return CO_E_RELEASED;
1221
1222     FIXME("not implemented %p\n", This);
1223     return E_NOTIMPL;
1224 }
1225
1226 static HRESULT WINAPI ITextRange_fnMoveEndWhile(ITextRange *me, VARIANT *Cset, LONG Count,
1227                                                 LONG *pDelta)
1228 {
1229     ITextRangeImpl *This = impl_from_ITextRange(me);
1230     if (!This->reOle)
1231         return CO_E_RELEASED;
1232
1233     FIXME("not implemented %p\n", This);
1234     return E_NOTIMPL;
1235 }
1236
1237 static HRESULT WINAPI ITextRange_fnMoveUntil(ITextRange *me, VARIANT *Cset, LONG Count,
1238                                              LONG *pDelta)
1239 {
1240     ITextRangeImpl *This = impl_from_ITextRange(me);
1241     if (!This->reOle)
1242         return CO_E_RELEASED;
1243
1244     FIXME("not implemented %p\n", This);
1245     return E_NOTIMPL;
1246 }
1247
1248 static HRESULT WINAPI ITextRange_fnMoveStartUntil(ITextRange *me, VARIANT *Cset, LONG Count,
1249                                                   LONG *pDelta)
1250 {
1251     ITextRangeImpl *This = impl_from_ITextRange(me);
1252     if (!This->reOle)
1253         return CO_E_RELEASED;
1254
1255     FIXME("not implemented %p\n", This);
1256     return E_NOTIMPL;
1257 }
1258
1259 static HRESULT WINAPI ITextRange_fnMoveEndUntil(ITextRange *me, VARIANT *Cset, LONG Count,
1260                                                 LONG *pDelta)
1261 {
1262     ITextRangeImpl *This = impl_from_ITextRange(me);
1263     if (!This->reOle)
1264         return CO_E_RELEASED;
1265
1266     FIXME("not implemented %p\n", This);
1267     return E_NOTIMPL;
1268 }
1269
1270 static HRESULT WINAPI ITextRange_fnFindText(ITextRange *me, BSTR bstr, LONG cch, LONG Flags,
1271                                             LONG *pLength)
1272 {
1273     ITextRangeImpl *This = impl_from_ITextRange(me);
1274     if (!This->reOle)
1275         return CO_E_RELEASED;
1276
1277     FIXME("not implemented %p\n", This);
1278     return E_NOTIMPL;
1279 }
1280
1281 static HRESULT WINAPI ITextRange_fnFindTextStart(ITextRange *me, BSTR bstr, LONG cch,
1282                                                  LONG Flags, LONG *pLength)
1283 {
1284     ITextRangeImpl *This = impl_from_ITextRange(me);
1285     if (!This->reOle)
1286         return CO_E_RELEASED;
1287
1288     FIXME("not implemented %p\n", This);
1289     return E_NOTIMPL;
1290 }
1291
1292 static HRESULT WINAPI ITextRange_fnFindTextEnd(ITextRange *me, BSTR bstr, LONG cch,
1293                                                LONG Flags, LONG *pLength)
1294 {
1295     ITextRangeImpl *This = impl_from_ITextRange(me);
1296     if (!This->reOle)
1297         return CO_E_RELEASED;
1298
1299     FIXME("not implemented %p\n", This);
1300     return E_NOTIMPL;
1301 }
1302
1303 static HRESULT WINAPI ITextRange_fnDelete(ITextRange *me, LONG Unit, LONG Count,
1304                                           LONG *pDelta)
1305 {
1306     ITextRangeImpl *This = impl_from_ITextRange(me);
1307     if (!This->reOle)
1308         return CO_E_RELEASED;
1309
1310     FIXME("not implemented %p\n", This);
1311     return E_NOTIMPL;
1312 }
1313
1314 static HRESULT WINAPI ITextRange_fnCut(ITextRange *me, VARIANT *pVar)
1315 {
1316     ITextRangeImpl *This = impl_from_ITextRange(me);
1317     if (!This->reOle)
1318         return CO_E_RELEASED;
1319
1320     FIXME("not implemented %p\n", This);
1321     return E_NOTIMPL;
1322 }
1323
1324 static HRESULT WINAPI ITextRange_fnCopy(ITextRange *me, VARIANT *pVar)
1325 {
1326     ITextRangeImpl *This = impl_from_ITextRange(me);
1327     if (!This->reOle)
1328         return CO_E_RELEASED;
1329
1330     FIXME("not implemented %p\n", This);
1331     return E_NOTIMPL;
1332 }
1333
1334 static HRESULT WINAPI ITextRange_fnPaste(ITextRange *me, VARIANT *pVar, LONG Format)
1335 {
1336     ITextRangeImpl *This = impl_from_ITextRange(me);
1337     if (!This->reOle)
1338         return CO_E_RELEASED;
1339
1340     FIXME("not implemented %p\n", This);
1341     return E_NOTIMPL;
1342 }
1343
1344 static HRESULT WINAPI ITextRange_fnCanPaste(ITextRange *me, VARIANT *pVar, LONG Format,
1345                                             LONG *pb)
1346 {
1347     ITextRangeImpl *This = impl_from_ITextRange(me);
1348     if (!This->reOle)
1349         return CO_E_RELEASED;
1350
1351     FIXME("not implemented %p\n", This);
1352     return E_NOTIMPL;
1353 }
1354
1355 static HRESULT WINAPI ITextRange_fnCanEdit(ITextRange *me, LONG *pb)
1356 {
1357     ITextRangeImpl *This = impl_from_ITextRange(me);
1358     if (!This->reOle)
1359         return CO_E_RELEASED;
1360
1361     FIXME("not implemented %p\n", This);
1362     return E_NOTIMPL;
1363 }
1364
1365 static HRESULT WINAPI ITextRange_fnChangeCase(ITextRange *me, LONG Type)
1366 {
1367     ITextRangeImpl *This = impl_from_ITextRange(me);
1368     if (!This->reOle)
1369         return CO_E_RELEASED;
1370
1371     FIXME("not implemented %p\n", This);
1372     return E_NOTIMPL;
1373 }
1374
1375 static HRESULT WINAPI ITextRange_fnGetPoint(ITextRange *me, LONG Type, LONG *cx, LONG *cy)
1376 {
1377     ITextRangeImpl *This = impl_from_ITextRange(me);
1378     if (!This->reOle)
1379         return CO_E_RELEASED;
1380
1381     FIXME("not implemented %p\n", This);
1382     return E_NOTIMPL;
1383 }
1384
1385 static HRESULT WINAPI ITextRange_fnSetPoint(ITextRange *me, LONG x, LONG y, LONG Type,
1386                                             LONG Extend)
1387 {
1388     ITextRangeImpl *This = impl_from_ITextRange(me);
1389     if (!This->reOle)
1390         return CO_E_RELEASED;
1391
1392     FIXME("not implemented %p\n", This);
1393     return E_NOTIMPL;
1394 }
1395
1396 static HRESULT WINAPI ITextRange_fnScrollIntoView(ITextRange *me, LONG Value)
1397 {
1398     ITextRangeImpl *This = impl_from_ITextRange(me);
1399     if (!This->reOle)
1400         return CO_E_RELEASED;
1401
1402     FIXME("not implemented %p\n", This);
1403     return E_NOTIMPL;
1404 }
1405
1406 static HRESULT WINAPI ITextRange_fnGetEmbeddedObject(ITextRange *me, IUnknown **ppv)
1407 {
1408     ITextRangeImpl *This = impl_from_ITextRange(me);
1409     if (!This->reOle)
1410         return CO_E_RELEASED;
1411
1412     FIXME("not implemented %p\n", This);
1413     return E_NOTIMPL;
1414 }
1415
1416 static const ITextRangeVtbl trvt = {
1417     ITextRange_fnQueryInterface,
1418     ITextRange_fnAddRef,
1419     ITextRange_fnRelease,
1420     ITextRange_fnGetTypeInfoCount,
1421     ITextRange_fnGetTypeInfo,
1422     ITextRange_fnGetIDsOfNames,
1423     ITextRange_fnInvoke,
1424     ITextRange_fnGetText,
1425     ITextRange_fnSetText,
1426     ITextRange_fnGetChar,
1427     ITextRange_fnSetChar,
1428     ITextRange_fnGetDuplicate,
1429     ITextRange_fnGetFormattedText,
1430     ITextRange_fnSetFormattedText,
1431     ITextRange_fnGetStart,
1432     ITextRange_fnSetStart,
1433     ITextRange_fnGetEnd,
1434     ITextRange_fnSetEnd,
1435     ITextRange_fnGetFont,
1436     ITextRange_fnSetFont,
1437     ITextRange_fnGetPara,
1438     ITextRange_fnSetPara,
1439     ITextRange_fnGetStoryLength,
1440     ITextRange_fnGetStoryType,
1441     ITextRange_fnCollapse,
1442     ITextRange_fnExpand,
1443     ITextRange_fnGetIndex,
1444     ITextRange_fnSetIndex,
1445     ITextRange_fnSetRange,
1446     ITextRange_fnInRange,
1447     ITextRange_fnInStory,
1448     ITextRange_fnIsEqual,
1449     ITextRange_fnSelect,
1450     ITextRange_fnStartOf,
1451     ITextRange_fnEndOf,
1452     ITextRange_fnMove,
1453     ITextRange_fnMoveStart,
1454     ITextRange_fnMoveEnd,
1455     ITextRange_fnMoveWhile,
1456     ITextRange_fnMoveStartWhile,
1457     ITextRange_fnMoveEndWhile,
1458     ITextRange_fnMoveUntil,
1459     ITextRange_fnMoveStartUntil,
1460     ITextRange_fnMoveEndUntil,
1461     ITextRange_fnFindText,
1462     ITextRange_fnFindTextStart,
1463     ITextRange_fnFindTextEnd,
1464     ITextRange_fnDelete,
1465     ITextRange_fnCut,
1466     ITextRange_fnCopy,
1467     ITextRange_fnPaste,
1468     ITextRange_fnCanPaste,
1469     ITextRange_fnCanEdit,
1470     ITextRange_fnChangeCase,
1471     ITextRange_fnGetPoint,
1472     ITextRange_fnSetPoint,
1473     ITextRange_fnScrollIntoView,
1474     ITextRange_fnGetEmbeddedObject
1475 };
1476
1477 /* ITextFont */
1478 static HRESULT WINAPI TextFont_QueryInterface(ITextFont *iface, REFIID riid, void **ppv)
1479 {
1480     ITextFontImpl *This = impl_from_ITextFont(iface);
1481
1482     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1483
1484     if (IsEqualIID(riid, &IID_ITextFont) ||
1485         IsEqualIID(riid, &IID_IDispatch) ||
1486         IsEqualIID(riid, &IID_IUnknown))
1487     {
1488         *ppv = iface;
1489         ITextFont_AddRef(iface);
1490         return S_OK;
1491     }
1492
1493     *ppv = NULL;
1494     return E_NOINTERFACE;
1495 }
1496
1497 static ULONG WINAPI TextFont_AddRef(ITextFont *iface)
1498 {
1499     ITextFontImpl *This = impl_from_ITextFont(iface);
1500     ULONG ref = InterlockedIncrement(&This->ref);
1501     TRACE("(%p)->(%u)\n", This, ref);
1502     return ref;
1503 }
1504
1505 static ULONG WINAPI TextFont_Release(ITextFont *iface)
1506 {
1507     ITextFontImpl *This = impl_from_ITextFont(iface);
1508     ULONG ref = InterlockedDecrement(&This->ref);
1509
1510     TRACE("(%p)->(%u)\n", This, ref);
1511
1512     if (!ref)
1513     {
1514         ITextRange_Release(This->range);
1515         heap_free(This);
1516     }
1517
1518     return ref;
1519 }
1520
1521 static HRESULT WINAPI TextFont_GetTypeInfoCount(ITextFont *iface, UINT *pctinfo)
1522 {
1523     FIXME("stub\n");
1524     *pctinfo = 0;
1525     return E_NOTIMPL;
1526 }
1527
1528 static HRESULT WINAPI TextFont_GetTypeInfo(ITextFont *iface, UINT iTInfo, LCID lcid,
1529     ITypeInfo **ppTInfo)
1530 {
1531     FIXME("stub\n");
1532     return E_NOTIMPL;
1533 }
1534
1535 static HRESULT WINAPI TextFont_GetIDsOfNames(ITextFont *iface, REFIID riid,
1536     LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1537 {
1538     FIXME("stub\n");
1539     return E_NOTIMPL;
1540 }
1541
1542 static HRESULT WINAPI TextFont_Invoke(
1543     ITextFont *iface,
1544     DISPID dispIdMember,
1545     REFIID riid,
1546     LCID lcid,
1547     WORD wFlags,
1548     DISPPARAMS *pDispParams,
1549     VARIANT *pVarResult,
1550     EXCEPINFO *pExcepInfo,
1551     UINT *puArgErr)
1552 {
1553     FIXME("stub\n");
1554     return E_NOTIMPL;
1555 }
1556
1557 static HRESULT WINAPI TextFont_GetDuplicate(ITextFont *iface, ITextFont **ret)
1558 {
1559     ITextFontImpl *This = impl_from_ITextFont(iface);
1560     FIXME("(%p)->(%p): stub\n", This, ret);
1561     return E_NOTIMPL;
1562 }
1563
1564 static HRESULT WINAPI TextFont_SetDuplicate(ITextFont *iface, ITextFont *pFont)
1565 {
1566     ITextFontImpl *This = impl_from_ITextFont(iface);
1567     FIXME("(%p)->(%p): stub\n", This, pFont);
1568     return E_NOTIMPL;
1569 }
1570
1571 static HRESULT WINAPI TextFont_CanChange(ITextFont *iface, LONG *ret)
1572 {
1573     ITextFontImpl *This = impl_from_ITextFont(iface);
1574     FIXME("(%p)->(%p): stub\n", This, ret);
1575     return E_NOTIMPL;
1576 }
1577
1578 static HRESULT WINAPI TextFont_IsEqual(ITextFont *iface, ITextFont *font, LONG *ret)
1579 {
1580     ITextFontImpl *This = impl_from_ITextFont(iface);
1581     FIXME("(%p)->(%p): stub\n", This, ret);
1582     return E_NOTIMPL;
1583 }
1584
1585 static HRESULT WINAPI TextFont_Reset(ITextFont *iface, LONG value)
1586 {
1587     ITextFontImpl *This = impl_from_ITextFont(iface);
1588     FIXME("(%p): stub\n", This);
1589     return E_NOTIMPL;
1590 }
1591
1592 static HRESULT WINAPI TextFont_GetStyle(ITextFont *iface, LONG *value)
1593 {
1594     ITextFontImpl *This = impl_from_ITextFont(iface);
1595     FIXME("(%p)->(%p): stub\n", This, value);
1596     return E_NOTIMPL;
1597 }
1598
1599 static HRESULT WINAPI TextFont_SetStyle(ITextFont *iface, LONG value)
1600 {
1601     ITextFontImpl *This = impl_from_ITextFont(iface);
1602     FIXME("(%p)->(%d): stub\n", This, value);
1603     return E_NOTIMPL;
1604 }
1605
1606 static HRESULT WINAPI TextFont_GetAllCaps(ITextFont *iface, LONG *value)
1607 {
1608     ITextFontImpl *This = impl_from_ITextFont(iface);
1609     FIXME("(%p)->(%p): stub\n", This, value);
1610     return E_NOTIMPL;
1611 }
1612
1613 static HRESULT WINAPI TextFont_SetAllCaps(ITextFont *iface, LONG value)
1614 {
1615     ITextFontImpl *This = impl_from_ITextFont(iface);
1616     FIXME("(%p)->(%d): stub\n", This, value);
1617     return E_NOTIMPL;
1618 }
1619
1620 static HRESULT WINAPI TextFont_GetAnimation(ITextFont *iface, LONG *value)
1621 {
1622     ITextFontImpl *This = impl_from_ITextFont(iface);
1623     FIXME("(%p)->(%p): stub\n", This, value);
1624     return E_NOTIMPL;
1625 }
1626
1627 static HRESULT WINAPI TextFont_SetAnimation(ITextFont *iface, LONG value)
1628 {
1629     ITextFontImpl *This = impl_from_ITextFont(iface);
1630     FIXME("(%p)->(%d): stub\n", This, value);
1631     return E_NOTIMPL;
1632 }
1633
1634 static HRESULT WINAPI TextFont_GetBackColor(ITextFont *iface, LONG *value)
1635 {
1636     ITextFontImpl *This = impl_from_ITextFont(iface);
1637     FIXME("(%p)->(%p): stub\n", This, value);
1638     return E_NOTIMPL;
1639 }
1640
1641 static HRESULT WINAPI TextFont_SetBackColor(ITextFont *iface, LONG value)
1642 {
1643     ITextFontImpl *This = impl_from_ITextFont(iface);
1644     FIXME("(%p)->(%d): stub\n", This, value);
1645     return E_NOTIMPL;
1646 }
1647
1648 static HRESULT WINAPI TextFont_GetBold(ITextFont *iface, LONG *value)
1649 {
1650     ITextFontImpl *This = impl_from_ITextFont(iface);
1651     FIXME("(%p)->(%p): stub\n", This, value);
1652     return E_NOTIMPL;
1653 }
1654
1655 static HRESULT WINAPI TextFont_SetBold(ITextFont *iface, LONG value)
1656 {
1657     ITextFontImpl *This = impl_from_ITextFont(iface);
1658     FIXME("(%p)->(%d): stub\n", This, value);
1659     return E_NOTIMPL;
1660 }
1661
1662 static HRESULT WINAPI TextFont_GetEmboss(ITextFont *iface, LONG *value)
1663 {
1664     ITextFontImpl *This = impl_from_ITextFont(iface);
1665     FIXME("(%p)->(%p): stub\n", This, value);
1666     return E_NOTIMPL;
1667 }
1668
1669 static HRESULT WINAPI TextFont_SetEmboss(ITextFont *iface, LONG value)
1670 {
1671     ITextFontImpl *This = impl_from_ITextFont(iface);
1672     FIXME("(%p)->(%d): stub\n", This, value);
1673     return E_NOTIMPL;
1674 }
1675
1676 static HRESULT WINAPI TextFont_GetForeColor(ITextFont *iface, LONG *value)
1677 {
1678     ITextFontImpl *This = impl_from_ITextFont(iface);
1679     FIXME("(%p)->(%p): stub\n", This, value);
1680     return E_NOTIMPL;
1681 }
1682
1683 static HRESULT WINAPI TextFont_SetForeColor(ITextFont *iface, LONG value)
1684 {
1685     ITextFontImpl *This = impl_from_ITextFont(iface);
1686     FIXME("(%p)->(%d): stub\n", This, value);
1687     return E_NOTIMPL;
1688 }
1689
1690 static HRESULT WINAPI TextFont_GetHidden(ITextFont *iface, LONG *value)
1691 {
1692     ITextFontImpl *This = impl_from_ITextFont(iface);
1693     FIXME("(%p)->(%p): stub\n", This, value);
1694     return E_NOTIMPL;
1695 }
1696
1697 static HRESULT WINAPI TextFont_SetHidden(ITextFont *iface, LONG value)
1698 {
1699     ITextFontImpl *This = impl_from_ITextFont(iface);
1700     FIXME("(%p)->(%d): stub\n", This, value);
1701     return E_NOTIMPL;
1702 }
1703
1704 static HRESULT WINAPI TextFont_GetEngrave(ITextFont *iface, LONG *value)
1705 {
1706     ITextFontImpl *This = impl_from_ITextFont(iface);
1707     FIXME("(%p)->(%p): stub\n", This, value);
1708     return E_NOTIMPL;
1709 }
1710
1711 static HRESULT WINAPI TextFont_SetEngrave(ITextFont *iface, LONG value)
1712 {
1713     ITextFontImpl *This = impl_from_ITextFont(iface);
1714     FIXME("(%p)->(%d): stub\n", This, value);
1715     return E_NOTIMPL;
1716 }
1717
1718 static HRESULT WINAPI TextFont_GetItalic(ITextFont *iface, LONG *value)
1719 {
1720     ITextFontImpl *This = impl_from_ITextFont(iface);
1721     FIXME("(%p)->(%p): stub\n", This, value);
1722     return E_NOTIMPL;
1723 }
1724
1725 static HRESULT WINAPI TextFont_SetItalic(ITextFont *iface, LONG value)
1726 {
1727     ITextFontImpl *This = impl_from_ITextFont(iface);
1728     FIXME("(%p)->(%d): stub\n", This, value);
1729     return E_NOTIMPL;
1730 }
1731
1732 static HRESULT WINAPI TextFont_GetKerning(ITextFont *iface, FLOAT *value)
1733 {
1734     ITextFontImpl *This = impl_from_ITextFont(iface);
1735     FIXME("(%p)->(%p): stub\n", This, value);
1736     return E_NOTIMPL;
1737 }
1738
1739 static HRESULT WINAPI TextFont_SetKerning(ITextFont *iface, FLOAT value)
1740 {
1741     ITextFontImpl *This = impl_from_ITextFont(iface);
1742     FIXME("(%p)->(%.2f): stub\n", This, value);
1743     return E_NOTIMPL;
1744 }
1745
1746 static HRESULT WINAPI TextFont_GetLanguageID(ITextFont *iface, LONG *value)
1747 {
1748     ITextFontImpl *This = impl_from_ITextFont(iface);
1749     FIXME("(%p)->(%p): stub\n", This, value);
1750     return E_NOTIMPL;
1751 }
1752
1753 static HRESULT WINAPI TextFont_SetLanguageID(ITextFont *iface, LONG value)
1754 {
1755     ITextFontImpl *This = impl_from_ITextFont(iface);
1756     FIXME("(%p)->(%d): stub\n", This, value);
1757     return E_NOTIMPL;
1758 }
1759
1760 static HRESULT WINAPI TextFont_GetName(ITextFont *iface, BSTR *value)
1761 {
1762     ITextFontImpl *This = impl_from_ITextFont(iface);
1763     FIXME("(%p)->(%p): stub\n", This, value);
1764     return E_NOTIMPL;
1765 }
1766
1767 static HRESULT WINAPI TextFont_SetName(ITextFont *iface, BSTR value)
1768 {
1769     ITextFontImpl *This = impl_from_ITextFont(iface);
1770     FIXME("(%p)->(%s): stub\n", This, debugstr_w(value));
1771     return E_NOTIMPL;
1772 }
1773
1774 static HRESULT WINAPI TextFont_GetOutline(ITextFont *iface, LONG *value)
1775 {
1776     ITextFontImpl *This = impl_from_ITextFont(iface);
1777     FIXME("(%p)->(%p): stub\n", This, value);
1778     return E_NOTIMPL;
1779 }
1780
1781 static HRESULT WINAPI TextFont_SetOutline(ITextFont *iface, LONG value)
1782 {
1783     ITextFontImpl *This = impl_from_ITextFont(iface);
1784     FIXME("(%p)->(%d): stub\n", This, value);
1785     return E_NOTIMPL;
1786 }
1787
1788 static HRESULT WINAPI TextFont_GetPosition(ITextFont *iface, FLOAT *value)
1789 {
1790     ITextFontImpl *This = impl_from_ITextFont(iface);
1791     FIXME("(%p)->(%p): stub\n", This, value);
1792     return E_NOTIMPL;
1793 }
1794
1795 static HRESULT WINAPI TextFont_SetPosition(ITextFont *iface, FLOAT value)
1796 {
1797     ITextFontImpl *This = impl_from_ITextFont(iface);
1798     FIXME("(%p)->(%.2f): stub\n", This, value);
1799     return E_NOTIMPL;
1800 }
1801
1802 static HRESULT WINAPI TextFont_GetProtected(ITextFont *iface, LONG *value)
1803 {
1804     ITextFontImpl *This = impl_from_ITextFont(iface);
1805     FIXME("(%p)->(%p): stub\n", This, value);
1806     return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI TextFont_SetProtected(ITextFont *iface, LONG value)
1810 {
1811     ITextFontImpl *This = impl_from_ITextFont(iface);
1812     FIXME("(%p)->(%d): stub\n", This, value);
1813     return E_NOTIMPL;
1814 }
1815
1816 static HRESULT WINAPI TextFont_GetShadow(ITextFont *iface, LONG *value)
1817 {
1818     ITextFontImpl *This = impl_from_ITextFont(iface);
1819     FIXME("(%p)->(%p): stub\n", This, value);
1820     return E_NOTIMPL;
1821 }
1822
1823 static HRESULT WINAPI TextFont_SetShadow(ITextFont *iface, LONG value)
1824 {
1825     ITextFontImpl *This = impl_from_ITextFont(iface);
1826     FIXME("(%p)->(%d): stub\n", This, value);
1827     return E_NOTIMPL;
1828 }
1829
1830 static HRESULT WINAPI TextFont_GetSize(ITextFont *iface, FLOAT *value)
1831 {
1832     ITextFontImpl *This = impl_from_ITextFont(iface);
1833     FIXME("(%p)->(%p): stub\n", This, value);
1834     return E_NOTIMPL;
1835 }
1836
1837 static HRESULT WINAPI TextFont_SetSize(ITextFont *iface, FLOAT value)
1838 {
1839     ITextFontImpl *This = impl_from_ITextFont(iface);
1840     FIXME("(%p)->(%.2f): stub\n", This, value);
1841     return E_NOTIMPL;
1842 }
1843
1844 static HRESULT WINAPI TextFont_GetSmallCaps(ITextFont *iface, LONG *value)
1845 {
1846     ITextFontImpl *This = impl_from_ITextFont(iface);
1847     FIXME("(%p)->(%p): stub\n", This, value);
1848     return E_NOTIMPL;
1849 }
1850
1851 static HRESULT WINAPI TextFont_SetSmallCaps(ITextFont *iface, LONG value)
1852 {
1853     ITextFontImpl *This = impl_from_ITextFont(iface);
1854     FIXME("(%p)->(%d): stub\n", This, value);
1855     return E_NOTIMPL;
1856 }
1857
1858 static HRESULT WINAPI TextFont_GetSpacing(ITextFont *iface, FLOAT *value)
1859 {
1860     ITextFontImpl *This = impl_from_ITextFont(iface);
1861     FIXME("(%p)->(%p): stub\n", This, value);
1862     return E_NOTIMPL;
1863 }
1864
1865 static HRESULT WINAPI TextFont_SetSpacing(ITextFont *iface, FLOAT value)
1866 {
1867     ITextFontImpl *This = impl_from_ITextFont(iface);
1868     FIXME("(%p)->(%.2f): stub\n", This, value);
1869     return E_NOTIMPL;
1870 }
1871
1872 static HRESULT WINAPI TextFont_GetStrikeThrough(ITextFont *iface, LONG *value)
1873 {
1874     ITextFontImpl *This = impl_from_ITextFont(iface);
1875     FIXME("(%p)->(%p): stub\n", This, value);
1876     return E_NOTIMPL;
1877 }
1878
1879 static HRESULT WINAPI TextFont_SetStrikeThrough(ITextFont *iface, LONG value)
1880 {
1881     ITextFontImpl *This = impl_from_ITextFont(iface);
1882     FIXME("(%p)->(%d): stub\n", This, value);
1883     return E_NOTIMPL;
1884 }
1885
1886 static HRESULT WINAPI TextFont_GetSubscript(ITextFont *iface, LONG *value)
1887 {
1888     ITextFontImpl *This = impl_from_ITextFont(iface);
1889     FIXME("(%p)->(%p): stub\n", This, value);
1890     return E_NOTIMPL;
1891 }
1892
1893 static HRESULT WINAPI TextFont_SetSubscript(ITextFont *iface, LONG value)
1894 {
1895     ITextFontImpl *This = impl_from_ITextFont(iface);
1896     FIXME("(%p)->(%d): stub\n", This, value);
1897     return E_NOTIMPL;
1898 }
1899
1900 static HRESULT WINAPI TextFont_GetSuperscript(ITextFont *iface, LONG *value)
1901 {
1902     ITextFontImpl *This = impl_from_ITextFont(iface);
1903     FIXME("(%p)->(%p): stub\n", This, value);
1904     return E_NOTIMPL;
1905 }
1906
1907 static HRESULT WINAPI TextFont_SetSuperscript(ITextFont *iface, LONG value)
1908 {
1909     ITextFontImpl *This = impl_from_ITextFont(iface);
1910     FIXME("(%p)->(%d): stub\n", This, value);
1911     return E_NOTIMPL;
1912 }
1913
1914 static HRESULT WINAPI TextFont_GetUnderline(ITextFont *iface, LONG *value)
1915 {
1916     ITextFontImpl *This = impl_from_ITextFont(iface);
1917     FIXME("(%p)->(%p): stub\n", This, value);
1918     return E_NOTIMPL;
1919 }
1920
1921 static HRESULT WINAPI TextFont_SetUnderline(ITextFont *iface, LONG value)
1922 {
1923     ITextFontImpl *This = impl_from_ITextFont(iface);
1924     FIXME("(%p)->(%d): stub\n", This, value);
1925     return E_NOTIMPL;
1926 }
1927
1928 static HRESULT WINAPI TextFont_GetWeight(ITextFont *iface, LONG *value)
1929 {
1930     ITextFontImpl *This = impl_from_ITextFont(iface);
1931     FIXME("(%p)->(%p): stub\n", This, value);
1932     return E_NOTIMPL;
1933 }
1934
1935 static HRESULT WINAPI TextFont_SetWeight(ITextFont *iface, LONG value)
1936 {
1937     ITextFontImpl *This = impl_from_ITextFont(iface);
1938     FIXME("(%p)->(%d): stub\n", This, value);
1939     return E_NOTIMPL;
1940 }
1941
1942 static ITextFontVtbl textfontvtbl = {
1943     TextFont_QueryInterface,
1944     TextFont_AddRef,
1945     TextFont_Release,
1946     TextFont_GetTypeInfoCount,
1947     TextFont_GetTypeInfo,
1948     TextFont_GetIDsOfNames,
1949     TextFont_Invoke,
1950     TextFont_GetDuplicate,
1951     TextFont_SetDuplicate,
1952     TextFont_CanChange,
1953     TextFont_IsEqual,
1954     TextFont_Reset,
1955     TextFont_GetStyle,
1956     TextFont_SetStyle,
1957     TextFont_GetAllCaps,
1958     TextFont_SetAllCaps,
1959     TextFont_GetAnimation,
1960     TextFont_SetAnimation,
1961     TextFont_GetBackColor,
1962     TextFont_SetBackColor,
1963     TextFont_GetBold,
1964     TextFont_SetBold,
1965     TextFont_GetEmboss,
1966     TextFont_SetEmboss,
1967     TextFont_GetForeColor,
1968     TextFont_SetForeColor,
1969     TextFont_GetHidden,
1970     TextFont_SetHidden,
1971     TextFont_GetEngrave,
1972     TextFont_SetEngrave,
1973     TextFont_GetItalic,
1974     TextFont_SetItalic,
1975     TextFont_GetKerning,
1976     TextFont_SetKerning,
1977     TextFont_GetLanguageID,
1978     TextFont_SetLanguageID,
1979     TextFont_GetName,
1980     TextFont_SetName,
1981     TextFont_GetOutline,
1982     TextFont_SetOutline,
1983     TextFont_GetPosition,
1984     TextFont_SetPosition,
1985     TextFont_GetProtected,
1986     TextFont_SetProtected,
1987     TextFont_GetShadow,
1988     TextFont_SetShadow,
1989     TextFont_GetSize,
1990     TextFont_SetSize,
1991     TextFont_GetSmallCaps,
1992     TextFont_SetSmallCaps,
1993     TextFont_GetSpacing,
1994     TextFont_SetSpacing,
1995     TextFont_GetStrikeThrough,
1996     TextFont_SetStrikeThrough,
1997     TextFont_GetSubscript,
1998     TextFont_SetSubscript,
1999     TextFont_GetSuperscript,
2000     TextFont_SetSuperscript,
2001     TextFont_GetUnderline,
2002     TextFont_SetUnderline,
2003     TextFont_GetWeight,
2004     TextFont_SetWeight
2005 };
2006
2007 static HRESULT create_textfont(ITextRange *range, ITextFont **ret)
2008 {
2009     ITextFontImpl *font;
2010
2011     *ret = NULL;
2012     font = heap_alloc(sizeof(*font));
2013     if (!font)
2014         return E_OUTOFMEMORY;
2015
2016     font->ITextFont_iface.lpVtbl = &textfontvtbl;
2017     font->ref = 1;
2018     font->range = range;
2019     ITextRange_AddRef(range);
2020
2021     *ret = &font->ITextFont_iface;
2022     return S_OK;
2023 }
2024
2025 /* ITextPara */
2026 static HRESULT WINAPI TextPara_QueryInterface(ITextPara *iface, REFIID riid, void **ppv)
2027 {
2028     ITextParaImpl *This = impl_from_ITextPara(iface);
2029
2030     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
2031
2032     if (IsEqualIID(riid, &IID_ITextPara) ||
2033         IsEqualIID(riid, &IID_IDispatch) ||
2034         IsEqualIID(riid, &IID_IUnknown))
2035     {
2036         *ppv = iface;
2037         ITextPara_AddRef(iface);
2038         return S_OK;
2039     }
2040
2041     *ppv = NULL;
2042     return E_NOINTERFACE;
2043 }
2044
2045 static ULONG WINAPI TextPara_AddRef(ITextPara *iface)
2046 {
2047     ITextParaImpl *This = impl_from_ITextPara(iface);
2048     ULONG ref = InterlockedIncrement(&This->ref);
2049     TRACE("(%p)->(%u)\n", This, ref);
2050     return ref;
2051 }
2052
2053 static ULONG WINAPI TextPara_Release(ITextPara *iface)
2054 {
2055     ITextParaImpl *This = impl_from_ITextPara(iface);
2056     ULONG ref = InterlockedDecrement(&This->ref);
2057
2058     TRACE("(%p)->(%u)\n", This, ref);
2059
2060     if (!ref)
2061     {
2062         ITextRange_Release(This->range);
2063         heap_free(This);
2064     }
2065
2066     return ref;
2067 }
2068
2069 static HRESULT WINAPI TextPara_GetTypeInfoCount(ITextPara *iface, UINT *pctinfo)
2070 {
2071     FIXME("stub\n");
2072     *pctinfo = 0;
2073     return E_NOTIMPL;
2074 }
2075
2076 static HRESULT WINAPI TextPara_GetTypeInfo(ITextPara *iface, UINT iTInfo, LCID lcid,
2077     ITypeInfo **ppTInfo)
2078 {
2079     FIXME("stub\n");
2080     return E_NOTIMPL;
2081 }
2082
2083 static HRESULT WINAPI TextPara_GetIDsOfNames(ITextPara *iface, REFIID riid,
2084     LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2085 {
2086     FIXME("stub\n");
2087     return E_NOTIMPL;
2088 }
2089
2090 static HRESULT WINAPI TextPara_Invoke(
2091     ITextPara *iface,
2092     DISPID dispIdMember,
2093     REFIID riid,
2094     LCID lcid,
2095     WORD wFlags,
2096     DISPPARAMS *pDispParams,
2097     VARIANT *pVarResult,
2098     EXCEPINFO *pExcepInfo,
2099     UINT *puArgErr)
2100 {
2101     FIXME("stub\n");
2102     return E_NOTIMPL;
2103 }
2104
2105 static HRESULT WINAPI TextPara_GetDuplicate(ITextPara *iface, ITextPara **ret)
2106 {
2107     ITextParaImpl *This = impl_from_ITextPara(iface);
2108     FIXME("(%p)->(%p)\n", This, ret);
2109     return E_NOTIMPL;
2110 }
2111
2112 static HRESULT WINAPI TextPara_SetDuplicate(ITextPara *iface, ITextPara *para)
2113 {
2114     ITextParaImpl *This = impl_from_ITextPara(iface);
2115     FIXME("(%p)->(%p)\n", This, para);
2116     return E_NOTIMPL;
2117 }
2118
2119 static HRESULT WINAPI TextPara_CanChange(ITextPara *iface, LONG *ret)
2120 {
2121     ITextParaImpl *This = impl_from_ITextPara(iface);
2122     FIXME("(%p)->(%p)\n", This, ret);
2123     return E_NOTIMPL;
2124 }
2125
2126 static HRESULT WINAPI TextPara_IsEqual(ITextPara *iface, ITextPara *para, LONG *ret)
2127 {
2128     ITextParaImpl *This = impl_from_ITextPara(iface);
2129     FIXME("(%p)->(%p %p)\n", This, para, ret);
2130     return E_NOTIMPL;
2131 }
2132
2133 static HRESULT WINAPI TextPara_Reset(ITextPara *iface, LONG value)
2134 {
2135     ITextParaImpl *This = impl_from_ITextPara(iface);
2136     FIXME("(%p)->(%d)\n", This, value);
2137     return E_NOTIMPL;
2138 }
2139
2140 static HRESULT WINAPI TextPara_GetStyle(ITextPara *iface, LONG *value)
2141 {
2142     ITextParaImpl *This = impl_from_ITextPara(iface);
2143     FIXME("(%p)->(%p)\n", This, value);
2144     return E_NOTIMPL;
2145 }
2146
2147 static HRESULT WINAPI TextPara_SetStyle(ITextPara *iface, LONG value)
2148 {
2149     ITextParaImpl *This = impl_from_ITextPara(iface);
2150     FIXME("(%p)->(%d)\n", This, value);
2151     return E_NOTIMPL;
2152 }
2153
2154 static HRESULT WINAPI TextPara_GetAlignment(ITextPara *iface, LONG *value)
2155 {
2156     ITextParaImpl *This = impl_from_ITextPara(iface);
2157     FIXME("(%p)->(%p)\n", This, value);
2158     return E_NOTIMPL;
2159 }
2160
2161 static HRESULT WINAPI TextPara_SetAlignment(ITextPara *iface, LONG value)
2162 {
2163     ITextParaImpl *This = impl_from_ITextPara(iface);
2164     FIXME("(%p)->(%d)\n", This, value);
2165     return E_NOTIMPL;
2166 }
2167
2168 static HRESULT WINAPI TextPara_GetHyphenation(ITextPara *iface, LONG *value)
2169 {
2170     ITextParaImpl *This = impl_from_ITextPara(iface);
2171     FIXME("(%p)->(%p)\n", This, value);
2172     return E_NOTIMPL;
2173 }
2174
2175 static HRESULT WINAPI TextPara_SetHyphenation(ITextPara *iface, LONG value)
2176 {
2177     ITextParaImpl *This = impl_from_ITextPara(iface);
2178     FIXME("(%p)->(%d)\n", This, value);
2179     return E_NOTIMPL;
2180 }
2181
2182 static HRESULT WINAPI TextPara_GetFirstLineIndent(ITextPara *iface, FLOAT *value)
2183 {
2184     ITextParaImpl *This = impl_from_ITextPara(iface);
2185     FIXME("(%p)->(%p)\n", This, value);
2186     return E_NOTIMPL;
2187 }
2188
2189 static HRESULT WINAPI TextPara_GetKeepTogether(ITextPara *iface, LONG *value)
2190 {
2191     ITextParaImpl *This = impl_from_ITextPara(iface);
2192     FIXME("(%p)->(%p)\n", This, value);
2193     return E_NOTIMPL;
2194 }
2195
2196 static HRESULT WINAPI TextPara_SetKeepTogether(ITextPara *iface, LONG value)
2197 {
2198     ITextParaImpl *This = impl_from_ITextPara(iface);
2199     FIXME("(%p)->(%d)\n", This, value);
2200     return E_NOTIMPL;
2201 }
2202
2203 static HRESULT WINAPI TextPara_GetKeepWithNext(ITextPara *iface, LONG *value)
2204 {
2205     ITextParaImpl *This = impl_from_ITextPara(iface);
2206     FIXME("(%p)->(%p)\n", This, value);
2207     return E_NOTIMPL;
2208 }
2209
2210 static HRESULT WINAPI TextPara_SetKeepWithNext(ITextPara *iface, LONG value)
2211 {
2212     ITextParaImpl *This = impl_from_ITextPara(iface);
2213     FIXME("(%p)->(%d)\n", This, value);
2214     return E_NOTIMPL;
2215 }
2216
2217 static HRESULT WINAPI TextPara_GetLeftIndent(ITextPara *iface, FLOAT *value)
2218 {
2219     ITextParaImpl *This = impl_from_ITextPara(iface);
2220     FIXME("(%p)->(%p)\n", This, value);
2221     return E_NOTIMPL;
2222 }
2223
2224 static HRESULT WINAPI TextPara_GetLineSpacing(ITextPara *iface, FLOAT *value)
2225 {
2226     ITextParaImpl *This = impl_from_ITextPara(iface);
2227     FIXME("(%p)->(%p)\n", This, value);
2228     return E_NOTIMPL;
2229 }
2230
2231 static HRESULT WINAPI TextPara_GetLineSpacingRule(ITextPara *iface, LONG *value)
2232 {
2233     ITextParaImpl *This = impl_from_ITextPara(iface);
2234     FIXME("(%p)->(%p)\n", This, value);
2235     return E_NOTIMPL;
2236 }
2237
2238 static HRESULT WINAPI TextPara_GetListAlignment(ITextPara *iface, LONG *value)
2239 {
2240     ITextParaImpl *This = impl_from_ITextPara(iface);
2241     FIXME("(%p)->(%p)\n", This, value);
2242     return E_NOTIMPL;
2243 }
2244
2245 static HRESULT WINAPI TextPara_SetListAlignment(ITextPara *iface, LONG value)
2246 {
2247     ITextParaImpl *This = impl_from_ITextPara(iface);
2248     FIXME("(%p)->(%d)\n", This, value);
2249     return E_NOTIMPL;
2250 }
2251
2252 static HRESULT WINAPI TextPara_GetListLevelIndex(ITextPara *iface, LONG *value)
2253 {
2254     ITextParaImpl *This = impl_from_ITextPara(iface);
2255     FIXME("(%p)->(%p)\n", This, value);
2256     return E_NOTIMPL;
2257 }
2258
2259 static HRESULT WINAPI TextPara_SetListLevelIndex(ITextPara *iface, LONG value)
2260 {
2261     ITextParaImpl *This = impl_from_ITextPara(iface);
2262     FIXME("(%p)->(%d)\n", This, value);
2263     return E_NOTIMPL;
2264 }
2265
2266 static HRESULT WINAPI TextPara_GetListStart(ITextPara *iface, LONG *value)
2267 {
2268     ITextParaImpl *This = impl_from_ITextPara(iface);
2269     FIXME("(%p)->(%p)\n", This, value);
2270     return E_NOTIMPL;
2271 }
2272
2273 static HRESULT WINAPI TextPara_SetListStart(ITextPara *iface, LONG value)
2274 {
2275     ITextParaImpl *This = impl_from_ITextPara(iface);
2276     FIXME("(%p)->(%d)\n", This, value);
2277     return E_NOTIMPL;
2278 }
2279
2280 static HRESULT WINAPI TextPara_GetListTab(ITextPara *iface, FLOAT *value)
2281 {
2282     ITextParaImpl *This = impl_from_ITextPara(iface);
2283     FIXME("(%p)->(%p)\n", This, value);
2284     return E_NOTIMPL;
2285 }
2286
2287 static HRESULT WINAPI TextPara_SetListTab(ITextPara *iface, FLOAT value)
2288 {
2289     ITextParaImpl *This = impl_from_ITextPara(iface);
2290     FIXME("(%p)->(%.2f)\n", This, value);
2291     return E_NOTIMPL;
2292 }
2293
2294 static HRESULT WINAPI TextPara_GetListType(ITextPara *iface, LONG *value)
2295 {
2296     ITextParaImpl *This = impl_from_ITextPara(iface);
2297     FIXME("(%p)->(%p)\n", This, value);
2298     return E_NOTIMPL;
2299 }
2300
2301 static HRESULT WINAPI TextPara_SetListType(ITextPara *iface, LONG value)
2302 {
2303     ITextParaImpl *This = impl_from_ITextPara(iface);
2304     FIXME("(%p)->(%d)\n", This, value);
2305     return E_NOTIMPL;
2306 }
2307
2308 static HRESULT WINAPI TextPara_GetNoLineNumber(ITextPara *iface, LONG *value)
2309 {
2310     ITextParaImpl *This = impl_from_ITextPara(iface);
2311     FIXME("(%p)->(%p)\n", This, value);
2312     return E_NOTIMPL;
2313 }
2314
2315 static HRESULT WINAPI TextPara_SetNoLineNumber(ITextPara *iface, LONG value)
2316 {
2317     ITextParaImpl *This = impl_from_ITextPara(iface);
2318     FIXME("(%p)->(%d)\n", This, value);
2319     return E_NOTIMPL;
2320 }
2321
2322 static HRESULT WINAPI TextPara_GetPageBreakBefore(ITextPara *iface, LONG *value)
2323 {
2324     ITextParaImpl *This = impl_from_ITextPara(iface);
2325     FIXME("(%p)->(%p)\n", This, value);
2326     return E_NOTIMPL;
2327 }
2328
2329 static HRESULT WINAPI TextPara_SetPageBreakBefore(ITextPara *iface, LONG value)
2330 {
2331     ITextParaImpl *This = impl_from_ITextPara(iface);
2332     FIXME("(%p)->(%d)\n", This, value);
2333     return E_NOTIMPL;
2334 }
2335
2336 static HRESULT WINAPI TextPara_GetRightIndent(ITextPara *iface, FLOAT *value)
2337 {
2338     ITextParaImpl *This = impl_from_ITextPara(iface);
2339     FIXME("(%p)->(%p)\n", This, value);
2340     return E_NOTIMPL;
2341 }
2342
2343 static HRESULT WINAPI TextPara_SetRightIndent(ITextPara *iface, FLOAT value)
2344 {
2345     ITextParaImpl *This = impl_from_ITextPara(iface);
2346     FIXME("(%p)->(%.2f)\n", This, value);
2347     return E_NOTIMPL;
2348 }
2349
2350 static HRESULT WINAPI TextPara_SetIndents(ITextPara *iface, FLOAT StartIndent, FLOAT LeftIndent, FLOAT RightIndent)
2351 {
2352     ITextParaImpl *This = impl_from_ITextPara(iface);
2353     FIXME("(%p)->(%.2f %.2f %.2f)\n", This, StartIndent, LeftIndent, RightIndent);
2354     return E_NOTIMPL;
2355 }
2356
2357 static HRESULT WINAPI TextPara_SetLineSpacing(ITextPara *iface, LONG LineSpacingRule, FLOAT LineSpacing)
2358 {
2359     ITextParaImpl *This = impl_from_ITextPara(iface);
2360     FIXME("(%p)->(%d %.2f)\n", This, LineSpacingRule, LineSpacing);
2361     return E_NOTIMPL;
2362 }
2363
2364 static HRESULT WINAPI TextPara_GetSpaceAfter(ITextPara *iface, FLOAT *value)
2365 {
2366     ITextParaImpl *This = impl_from_ITextPara(iface);
2367     FIXME("(%p)->(%p)\n", This, value);
2368     return E_NOTIMPL;
2369 }
2370
2371 static HRESULT WINAPI TextPara_SetSpaceAfter(ITextPara *iface, FLOAT value)
2372 {
2373     ITextParaImpl *This = impl_from_ITextPara(iface);
2374     FIXME("(%p)->(%.2f)\n", This, value);
2375     return E_NOTIMPL;
2376 }
2377
2378 static HRESULT WINAPI TextPara_GetSpaceBefore(ITextPara *iface, FLOAT *value)
2379 {
2380     ITextParaImpl *This = impl_from_ITextPara(iface);
2381     FIXME("(%p)->(%p)\n", This, value);
2382     return E_NOTIMPL;
2383 }
2384
2385 static HRESULT WINAPI TextPara_SetSpaceBefore(ITextPara *iface, FLOAT value)
2386 {
2387     ITextParaImpl *This = impl_from_ITextPara(iface);
2388     FIXME("(%p)->(%.2f)\n", This, value);
2389     return E_NOTIMPL;
2390 }
2391
2392 static HRESULT WINAPI TextPara_GetWidowControl(ITextPara *iface, LONG *value)
2393 {
2394     ITextParaImpl *This = impl_from_ITextPara(iface);
2395     FIXME("(%p)->(%p)\n", This, value);
2396     return E_NOTIMPL;
2397 }
2398
2399 static HRESULT WINAPI TextPara_SetWidowControl(ITextPara *iface, LONG value)
2400 {
2401     ITextParaImpl *This = impl_from_ITextPara(iface);
2402     FIXME("(%p)->(%d)\n", This, value);
2403     return E_NOTIMPL;
2404 }
2405
2406 static HRESULT WINAPI TextPara_GetTabCount(ITextPara *iface, LONG *value)
2407 {
2408     ITextParaImpl *This = impl_from_ITextPara(iface);
2409     FIXME("(%p)->(%p)\n", This, value);
2410     return E_NOTIMPL;
2411 }
2412
2413 static HRESULT WINAPI TextPara_AddTab(ITextPara *iface, FLOAT tbPos, LONG tbAlign, LONG tbLeader)
2414 {
2415     ITextParaImpl *This = impl_from_ITextPara(iface);
2416     FIXME("(%p)->(%.2f %d %d)\n", This, tbPos, tbAlign, tbLeader);
2417     return E_NOTIMPL;
2418 }
2419
2420 static HRESULT WINAPI TextPara_ClearAllTabs(ITextPara *iface)
2421 {
2422     ITextParaImpl *This = impl_from_ITextPara(iface);
2423     FIXME("(%p)\n", This);
2424     return E_NOTIMPL;
2425 }
2426
2427 static HRESULT WINAPI TextPara_DeleteTab(ITextPara *iface, FLOAT pos)
2428 {
2429     ITextParaImpl *This = impl_from_ITextPara(iface);
2430     FIXME("(%p)->(%.2f)\n", This, pos);
2431     return E_NOTIMPL;
2432 }
2433
2434 static HRESULT WINAPI TextPara_GetTab(ITextPara *iface, LONG iTab, FLOAT *ptbPos, LONG *ptbAlign, LONG *ptbLeader)
2435 {
2436     ITextParaImpl *This = impl_from_ITextPara(iface);
2437     FIXME("(%p)->(%d %p %p %p)\n", This, iTab, ptbPos, ptbAlign, ptbLeader);
2438     return E_NOTIMPL;
2439 }
2440
2441 static ITextParaVtbl textparavtbl = {
2442     TextPara_QueryInterface,
2443     TextPara_AddRef,
2444     TextPara_Release,
2445     TextPara_GetTypeInfoCount,
2446     TextPara_GetTypeInfo,
2447     TextPara_GetIDsOfNames,
2448     TextPara_Invoke,
2449     TextPara_GetDuplicate,
2450     TextPara_SetDuplicate,
2451     TextPara_CanChange,
2452     TextPara_IsEqual,
2453     TextPara_Reset,
2454     TextPara_GetStyle,
2455     TextPara_SetStyle,
2456     TextPara_GetAlignment,
2457     TextPara_SetAlignment,
2458     TextPara_GetHyphenation,
2459     TextPara_SetHyphenation,
2460     TextPara_GetFirstLineIndent,
2461     TextPara_GetKeepTogether,
2462     TextPara_SetKeepTogether,
2463     TextPara_GetKeepWithNext,
2464     TextPara_SetKeepWithNext,
2465     TextPara_GetLeftIndent,
2466     TextPara_GetLineSpacing,
2467     TextPara_GetLineSpacingRule,
2468     TextPara_GetListAlignment,
2469     TextPara_SetListAlignment,
2470     TextPara_GetListLevelIndex,
2471     TextPara_SetListLevelIndex,
2472     TextPara_GetListStart,
2473     TextPara_SetListStart,
2474     TextPara_GetListTab,
2475     TextPara_SetListTab,
2476     TextPara_GetListType,
2477     TextPara_SetListType,
2478     TextPara_GetNoLineNumber,
2479     TextPara_SetNoLineNumber,
2480     TextPara_GetPageBreakBefore,
2481     TextPara_SetPageBreakBefore,
2482     TextPara_GetRightIndent,
2483     TextPara_SetRightIndent,
2484     TextPara_SetIndents,
2485     TextPara_SetLineSpacing,
2486     TextPara_GetSpaceAfter,
2487     TextPara_SetSpaceAfter,
2488     TextPara_GetSpaceBefore,
2489     TextPara_SetSpaceBefore,
2490     TextPara_GetWidowControl,
2491     TextPara_SetWidowControl,
2492     TextPara_GetTabCount,
2493     TextPara_AddTab,
2494     TextPara_ClearAllTabs,
2495     TextPara_DeleteTab,
2496     TextPara_GetTab
2497 };
2498
2499 static HRESULT create_textpara(ITextRange *range, ITextPara **ret)
2500 {
2501     ITextParaImpl *para;
2502
2503     *ret = NULL;
2504     para = heap_alloc(sizeof(*para));
2505     if (!para)
2506         return E_OUTOFMEMORY;
2507
2508     para->ITextPara_iface.lpVtbl = &textparavtbl;
2509     para->ref = 1;
2510     para->range = range;
2511     ITextRange_AddRef(range);
2512
2513     *ret = &para->ITextPara_iface;
2514     return S_OK;
2515 }
2516
2517 /* ITextDocument */
2518 static HRESULT WINAPI
2519 ITextDocument_fnQueryInterface(ITextDocument* me, REFIID riid,
2520     void** ppvObject)
2521 {
2522     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2523     return IRichEditOle_QueryInterface(&This->IRichEditOle_iface, riid, ppvObject);
2524 }
2525
2526 static ULONG WINAPI
2527 ITextDocument_fnAddRef(ITextDocument* me)
2528 {
2529     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2530     return IRichEditOle_AddRef(&This->IRichEditOle_iface);
2531 }
2532
2533 static ULONG WINAPI
2534 ITextDocument_fnRelease(ITextDocument* me)
2535 {
2536     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2537     return IRichEditOle_Release(&This->IRichEditOle_iface);
2538 }
2539
2540 static HRESULT WINAPI
2541 ITextDocument_fnGetTypeInfoCount(ITextDocument* me,
2542     UINT* pctinfo)
2543 {
2544     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2545     FIXME("stub %p\n",This);
2546     return E_NOTIMPL;
2547 }
2548
2549 static HRESULT WINAPI
2550 ITextDocument_fnGetTypeInfo(ITextDocument* me, UINT iTInfo, LCID lcid,
2551     ITypeInfo** ppTInfo)
2552 {
2553     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2554     FIXME("stub %p\n",This);
2555     return E_NOTIMPL;
2556 }
2557
2558 static HRESULT WINAPI
2559 ITextDocument_fnGetIDsOfNames(ITextDocument* me, REFIID riid,
2560     LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
2561 {
2562     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2563     FIXME("stub %p\n",This);
2564     return E_NOTIMPL;
2565 }
2566
2567 static HRESULT WINAPI
2568 ITextDocument_fnInvoke(ITextDocument* me, DISPID dispIdMember,
2569     REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
2570     VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
2571 {
2572     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2573     FIXME("stub %p\n",This);
2574     return E_NOTIMPL;
2575 }
2576
2577 static HRESULT WINAPI
2578 ITextDocument_fnGetName(ITextDocument* me, BSTR* pName)
2579 {
2580     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2581     FIXME("stub %p\n",This);
2582     return E_NOTIMPL;
2583 }
2584
2585 static HRESULT WINAPI
2586 ITextDocument_fnGetSelection(ITextDocument* me, ITextSelection** ppSel)
2587 {
2588     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2589     TRACE("(%p)\n", me);
2590
2591     if(!ppSel)
2592       return E_INVALIDARG;
2593     *ppSel = &This->txtSel->ITextSelection_iface;
2594     ITextSelection_AddRef(*ppSel);
2595     return S_OK;
2596 }
2597
2598 static HRESULT WINAPI
2599 ITextDocument_fnGetStoryCount(ITextDocument* me, LONG* pCount)
2600 {
2601     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2602     FIXME("stub %p\n",This);
2603     return E_NOTIMPL;
2604 }
2605
2606 static HRESULT WINAPI
2607 ITextDocument_fnGetStoryRanges(ITextDocument* me,
2608     ITextStoryRanges** ppStories)
2609 {
2610     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2611     FIXME("stub %p\n",This);
2612     return E_NOTIMPL;
2613 }
2614
2615 static HRESULT WINAPI
2616 ITextDocument_fnGetSaved(ITextDocument* me, LONG* pValue)
2617 {
2618     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2619     FIXME("stub %p\n",This);
2620     return E_NOTIMPL;
2621 }
2622
2623 static HRESULT WINAPI
2624 ITextDocument_fnSetSaved(ITextDocument* me, LONG Value)
2625 {
2626     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2627     FIXME("stub %p\n",This);
2628     return E_NOTIMPL;
2629 }
2630
2631 static HRESULT WINAPI
2632 ITextDocument_fnGetDefaultTabStop(ITextDocument* me, float* pValue)
2633 {
2634     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2635     FIXME("stub %p\n",This);
2636     return E_NOTIMPL;
2637 }
2638
2639 static HRESULT WINAPI
2640 ITextDocument_fnSetDefaultTabStop(ITextDocument* me, float Value)
2641 {
2642     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2643     FIXME("stub %p\n",This);
2644     return E_NOTIMPL;
2645 }
2646
2647 static HRESULT WINAPI
2648 ITextDocument_fnNew(ITextDocument* me)
2649 {
2650     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2651     FIXME("stub %p\n",This);
2652     return E_NOTIMPL;
2653 }
2654
2655 static HRESULT WINAPI
2656 ITextDocument_fnOpen(ITextDocument* me, VARIANT* pVar, LONG Flags,
2657     LONG CodePage)
2658 {
2659     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2660     FIXME("stub %p\n",This);
2661     return E_NOTIMPL;
2662 }
2663
2664 static HRESULT WINAPI
2665 ITextDocument_fnSave(ITextDocument* me, VARIANT* pVar, LONG Flags,
2666     LONG CodePage)
2667 {
2668     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2669     FIXME("stub %p\n",This);
2670     return E_NOTIMPL;
2671 }
2672
2673 static HRESULT WINAPI
2674 ITextDocument_fnFreeze(ITextDocument* me, LONG* pCount)
2675 {
2676     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2677     FIXME("stub %p\n",This);
2678     return E_NOTIMPL;
2679 }
2680
2681 static HRESULT WINAPI
2682 ITextDocument_fnUnfreeze(ITextDocument* me, LONG* pCount)
2683 {
2684     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2685     FIXME("stub %p\n",This);
2686     return E_NOTIMPL;
2687 }
2688
2689 static HRESULT WINAPI
2690 ITextDocument_fnBeginEditCollection(ITextDocument* me)
2691 {
2692     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2693     FIXME("stub %p\n",This);
2694     return E_NOTIMPL;
2695 }
2696
2697 static HRESULT WINAPI
2698 ITextDocument_fnEndEditCollection(ITextDocument* me)
2699 {
2700     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2701     FIXME("stub %p\n",This);
2702     return E_NOTIMPL;
2703 }
2704
2705 static HRESULT WINAPI
2706 ITextDocument_fnUndo(ITextDocument* me, LONG Count, LONG* prop)
2707 {
2708     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2709     FIXME("stub %p\n",This);
2710     return E_NOTIMPL;
2711 }
2712
2713 static HRESULT WINAPI
2714 ITextDocument_fnRedo(ITextDocument* me, LONG Count, LONG* prop)
2715 {
2716     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2717     FIXME("stub %p\n",This);
2718     return E_NOTIMPL;
2719 }
2720
2721 static HRESULT CreateITextRange(IRichEditOleImpl *reOle, LONG start, LONG end, ITextRange** ppRange)
2722 {
2723     ITextRangeImpl *txtRge = heap_alloc(sizeof(ITextRangeImpl));
2724
2725     if (!txtRge)
2726         return E_OUTOFMEMORY;
2727     txtRge->ITextRange_iface.lpVtbl = &trvt;
2728     txtRge->ref = 1;
2729     txtRge->reOle = reOle;
2730     txtRge->start = start;
2731     txtRge->end = end;
2732     list_add_head(&reOle->rangelist, &txtRge->entry);
2733     *ppRange = &txtRge->ITextRange_iface;
2734     return S_OK;
2735 }
2736
2737 static HRESULT WINAPI
2738 ITextDocument_fnRange(ITextDocument* me, LONG cp1, LONG cp2,
2739     ITextRange** ppRange)
2740 {
2741     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2742     const int len = ME_GetTextLength(This->editor) + 1;
2743
2744     TRACE("%p %p %d %d\n", This, ppRange, cp1, cp2);
2745     if (!ppRange)
2746         return E_INVALIDARG;
2747
2748     cp1 = max(cp1, 0);
2749     cp2 = max(cp2, 0);
2750     cp1 = min(cp1, len);
2751     cp2 = min(cp2, len);
2752     if (cp1 > cp2)
2753     {
2754         LONG tmp;
2755         tmp = cp1;
2756         cp1 = cp2;
2757         cp2 = tmp;
2758     }
2759     if (cp1 == len)
2760         cp1 = cp2 = len - 1;
2761
2762     return CreateITextRange(This, cp1, cp2, ppRange);
2763 }
2764
2765 static HRESULT WINAPI
2766 ITextDocument_fnRangeFromPoint(ITextDocument* me, LONG x, LONG y,
2767     ITextRange** ppRange)
2768 {
2769     IRichEditOleImpl *This = impl_from_ITextDocument(me);
2770     FIXME("stub %p\n",This);
2771     return E_NOTIMPL;
2772 }
2773
2774 static const ITextDocumentVtbl tdvt = {
2775     ITextDocument_fnQueryInterface,
2776     ITextDocument_fnAddRef,
2777     ITextDocument_fnRelease,
2778     ITextDocument_fnGetTypeInfoCount,
2779     ITextDocument_fnGetTypeInfo,
2780     ITextDocument_fnGetIDsOfNames,
2781     ITextDocument_fnInvoke,
2782     ITextDocument_fnGetName,
2783     ITextDocument_fnGetSelection,
2784     ITextDocument_fnGetStoryCount,
2785     ITextDocument_fnGetStoryRanges,
2786     ITextDocument_fnGetSaved,
2787     ITextDocument_fnSetSaved,
2788     ITextDocument_fnGetDefaultTabStop,
2789     ITextDocument_fnSetDefaultTabStop,
2790     ITextDocument_fnNew,
2791     ITextDocument_fnOpen,
2792     ITextDocument_fnSave,
2793     ITextDocument_fnFreeze,
2794     ITextDocument_fnUnfreeze,
2795     ITextDocument_fnBeginEditCollection,
2796     ITextDocument_fnEndEditCollection,
2797     ITextDocument_fnUndo,
2798     ITextDocument_fnRedo,
2799     ITextDocument_fnRange,
2800     ITextDocument_fnRangeFromPoint
2801 };
2802
2803 /* ITextSelection */
2804 static HRESULT WINAPI ITextSelection_fnQueryInterface(
2805     ITextSelection *me,
2806     REFIID riid,
2807     void **ppvObj)
2808 {
2809     *ppvObj = NULL;
2810     if (IsEqualGUID(riid, &IID_IUnknown)
2811         || IsEqualGUID(riid, &IID_IDispatch)
2812         || IsEqualGUID(riid, &IID_ITextRange)
2813         || IsEqualGUID(riid, &IID_ITextSelection))
2814     {
2815         *ppvObj = me;
2816         ITextSelection_AddRef(me);
2817         return S_OK;
2818     }
2819
2820     return E_NOINTERFACE;
2821 }
2822
2823 static ULONG WINAPI ITextSelection_fnAddRef(ITextSelection *me)
2824 {
2825     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2826     return InterlockedIncrement(&This->ref);
2827 }
2828
2829 static ULONG WINAPI ITextSelection_fnRelease(ITextSelection *me)
2830 {
2831     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2832     ULONG ref = InterlockedDecrement(&This->ref);
2833     if (ref == 0)
2834         heap_free(This);
2835     return ref;
2836 }
2837
2838 static HRESULT WINAPI ITextSelection_fnGetTypeInfoCount(ITextSelection *me, UINT *pctinfo)
2839 {
2840     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2841     if (!This->reOle)
2842         return CO_E_RELEASED;
2843
2844     FIXME("not implemented\n");
2845     return E_NOTIMPL;
2846 }
2847
2848 static HRESULT WINAPI ITextSelection_fnGetTypeInfo(ITextSelection *me, UINT iTInfo, LCID lcid,
2849     ITypeInfo **ppTInfo)
2850 {
2851     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2852     if (!This->reOle)
2853         return CO_E_RELEASED;
2854
2855     FIXME("not implemented\n");
2856     return E_NOTIMPL;
2857 }
2858
2859 static HRESULT WINAPI ITextSelection_fnGetIDsOfNames(ITextSelection *me, REFIID riid,
2860     LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2861 {
2862     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2863     if (!This->reOle)
2864         return CO_E_RELEASED;
2865
2866     FIXME("not implemented\n");
2867     return E_NOTIMPL;
2868 }
2869
2870 static HRESULT WINAPI ITextSelection_fnInvoke(
2871     ITextSelection *me,
2872     DISPID dispIdMember,
2873     REFIID riid,
2874     LCID lcid,
2875     WORD wFlags,
2876     DISPPARAMS *pDispParams,
2877     VARIANT *pVarResult,
2878     EXCEPINFO *pExcepInfo,
2879     UINT *puArgErr)
2880 {
2881     FIXME("not implemented\n");
2882     return E_NOTIMPL;
2883 }
2884
2885 /*** ITextRange methods ***/
2886 static HRESULT WINAPI ITextSelection_fnGetText(ITextSelection *me, BSTR *pbstr)
2887 {
2888     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2889     ME_Cursor *start = NULL, *end = NULL;
2890     int nChars, endOfs;
2891     BOOL bEOP;
2892
2893     if (!This->reOle)
2894         return CO_E_RELEASED;
2895     TRACE("%p\n", pbstr);
2896     if (!pbstr)
2897         return E_INVALIDARG;
2898
2899     ME_GetSelection(This->reOle->editor, &start, &end);
2900     endOfs = ME_GetCursorOfs(end);
2901     nChars = endOfs - ME_GetCursorOfs(start);
2902     if (!nChars)
2903     {
2904         *pbstr = NULL;
2905         return S_OK;
2906     }
2907
2908     *pbstr = SysAllocStringLen(NULL, nChars);
2909     if (!*pbstr)
2910         return E_OUTOFMEMORY;
2911
2912     bEOP = (end->pRun->next->type == diTextEnd && endOfs > ME_GetTextLength(This->reOle->editor));
2913     ME_GetTextW(This->reOle->editor, *pbstr, nChars, start, nChars, FALSE, bEOP);
2914     TRACE("%s\n", wine_dbgstr_w(*pbstr));
2915
2916     return S_OK;
2917 }
2918
2919 static HRESULT WINAPI ITextSelection_fnSetText(ITextSelection *me, BSTR bstr)
2920 {
2921     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2922     if (!This->reOle)
2923         return CO_E_RELEASED;
2924
2925     FIXME("not implemented\n");
2926     return E_NOTIMPL;
2927 }
2928
2929 static HRESULT WINAPI ITextSelection_fnGetChar(ITextSelection *me, LONG *pch)
2930 {
2931     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2932     ME_Cursor *start = NULL, *end = NULL;
2933
2934     if (!This->reOle)
2935         return CO_E_RELEASED;
2936     TRACE("%p\n", pch);
2937     if (!pch)
2938         return E_INVALIDARG;
2939
2940     ME_GetSelection(This->reOle->editor, &start, &end);
2941     return range_GetChar(This->reOle->editor, start, pch);
2942 }
2943
2944 static HRESULT WINAPI ITextSelection_fnSetChar(ITextSelection *me, LONG ch)
2945 {
2946     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2947     if (!This->reOle)
2948         return CO_E_RELEASED;
2949
2950     FIXME("not implemented\n");
2951     return E_NOTIMPL;
2952 }
2953
2954 static HRESULT WINAPI ITextSelection_fnGetDuplicate(ITextSelection *me, ITextRange **ppRange)
2955 {
2956     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2957     if (!This->reOle)
2958         return CO_E_RELEASED;
2959
2960     FIXME("not implemented\n");
2961     return E_NOTIMPL;
2962 }
2963
2964 static HRESULT WINAPI ITextSelection_fnGetFormattedText(ITextSelection *me, ITextRange **ppRange)
2965 {
2966     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2967     if (!This->reOle)
2968         return CO_E_RELEASED;
2969
2970     FIXME("not implemented\n");
2971     return E_NOTIMPL;
2972 }
2973
2974 static HRESULT WINAPI ITextSelection_fnSetFormattedText(ITextSelection *me, ITextRange *pRange)
2975 {
2976     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2977     if (!This->reOle)
2978         return CO_E_RELEASED;
2979
2980     FIXME("not implemented\n");
2981     return E_NOTIMPL;
2982 }
2983
2984 static HRESULT WINAPI ITextSelection_fnGetStart(ITextSelection *me, LONG *pcpFirst)
2985 {
2986     ITextSelectionImpl *This = impl_from_ITextSelection(me);
2987     LONG lim;
2988     if (!This->reOle)
2989         return CO_E_RELEASED;
2990
2991     if (!pcpFirst)
2992         return E_INVALIDARG;
2993     ME_GetSelectionOfs(This->reOle->editor, pcpFirst, &lim);
2994     TRACE("%d\n", *pcpFirst);
2995     return S_OK;
2996 }
2997
2998 static HRESULT WINAPI ITextSelection_fnSetStart(ITextSelection *me, LONG cpFirst)
2999 {
3000     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3001     if (!This->reOle)
3002         return CO_E_RELEASED;
3003
3004     FIXME("not implemented\n");
3005     return E_NOTIMPL;
3006 }
3007
3008 static HRESULT WINAPI ITextSelection_fnGetEnd(ITextSelection *me, LONG *pcpLim)
3009 {
3010     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3011     LONG first;
3012     if (!This->reOle)
3013         return CO_E_RELEASED;
3014
3015     if (!pcpLim)
3016         return E_INVALIDARG;
3017     ME_GetSelectionOfs(This->reOle->editor, &first, pcpLim);
3018     TRACE("%d\n", *pcpLim);
3019     return S_OK;
3020 }
3021
3022 static HRESULT WINAPI ITextSelection_fnSetEnd(ITextSelection *me, LONG cpLim)
3023 {
3024     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3025     if (!This->reOle)
3026         return CO_E_RELEASED;
3027
3028     FIXME("not implemented\n");
3029     return E_NOTIMPL;
3030 }
3031
3032 static HRESULT WINAPI ITextSelection_fnGetFont(ITextSelection *me, ITextFont **pFont)
3033 {
3034     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3035     if (!This->reOle)
3036         return CO_E_RELEASED;
3037
3038     FIXME("not implemented\n");
3039     return E_NOTIMPL;
3040 }
3041
3042 static HRESULT WINAPI ITextSelection_fnSetFont(ITextSelection *me, ITextFont *pFont)
3043 {
3044     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3045     if (!This->reOle)
3046         return CO_E_RELEASED;
3047
3048     FIXME("not implemented\n");
3049     return E_NOTIMPL;
3050 }
3051
3052 static HRESULT WINAPI ITextSelection_fnGetPara(ITextSelection *me, ITextPara **para)
3053 {
3054     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3055     if (!This->reOle)
3056         return CO_E_RELEASED;
3057
3058     FIXME("not implemented\n");
3059     return E_NOTIMPL;
3060 }
3061
3062 static HRESULT WINAPI ITextSelection_fnSetPara(ITextSelection *me, ITextPara *pPara)
3063 {
3064     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3065     if (!This->reOle)
3066         return CO_E_RELEASED;
3067
3068     FIXME("not implemented\n");
3069     return E_NOTIMPL;
3070 }
3071
3072 static HRESULT WINAPI ITextSelection_fnGetStoryLength(ITextSelection *me, LONG *pcch)
3073 {
3074     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3075     if (!This->reOle)
3076         return CO_E_RELEASED;
3077
3078     FIXME("not implemented\n");
3079     return E_NOTIMPL;
3080 }
3081
3082 static HRESULT WINAPI ITextSelection_fnGetStoryType(ITextSelection *me, LONG *pValue)
3083 {
3084     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3085     if (!This->reOle)
3086         return CO_E_RELEASED;
3087
3088     FIXME("not implemented\n");
3089     return E_NOTIMPL;
3090 }
3091
3092 static HRESULT WINAPI ITextSelection_fnCollapse(ITextSelection *me, LONG bStart)
3093 {
3094     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3095     LONG start, end;
3096     HRESULT hres;
3097     if (!This->reOle)
3098         return CO_E_RELEASED;
3099
3100     ME_GetSelectionOfs(This->reOle->editor, &start, &end);
3101     hres = range_Collapse(bStart, &start, &end);
3102     if (SUCCEEDED(hres))
3103         ME_SetSelection(This->reOle->editor, start, end);
3104     return hres;
3105 }
3106
3107 static HRESULT WINAPI ITextSelection_fnExpand(ITextSelection *me, LONG Unit, LONG *pDelta)
3108 {
3109     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3110     if (!This->reOle)
3111         return CO_E_RELEASED;
3112
3113     FIXME("not implemented\n");
3114     return E_NOTIMPL;
3115 }
3116
3117 static HRESULT WINAPI ITextSelection_fnGetIndex(ITextSelection *me, LONG Unit, LONG *pIndex)
3118 {
3119     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3120     if (!This->reOle)
3121         return CO_E_RELEASED;
3122
3123     FIXME("not implemented\n");
3124     return E_NOTIMPL;
3125 }
3126
3127 static HRESULT WINAPI ITextSelection_fnSetIndex(ITextSelection *me, LONG Unit, LONG Index,
3128     LONG Extend)
3129 {
3130     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3131     if (!This->reOle)
3132         return CO_E_RELEASED;
3133
3134     FIXME("not implemented\n");
3135     return E_NOTIMPL;
3136 }
3137
3138 static HRESULT WINAPI ITextSelection_fnSetRange(ITextSelection *me, LONG cpActive, LONG cpOther)
3139 {
3140     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3141     if (!This->reOle)
3142         return CO_E_RELEASED;
3143
3144     FIXME("not implemented\n");
3145     return E_NOTIMPL;
3146 }
3147
3148 static HRESULT WINAPI ITextSelection_fnInRange(ITextSelection *me, ITextRange *pRange, LONG *pb)
3149 {
3150     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3151     if (!This->reOle)
3152         return CO_E_RELEASED;
3153
3154     FIXME("not implemented\n");
3155     return E_NOTIMPL;
3156 }
3157
3158 static HRESULT WINAPI ITextSelection_fnInStory(ITextSelection *me, ITextRange *pRange, LONG *pb)
3159 {
3160     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3161     if (!This->reOle)
3162         return CO_E_RELEASED;
3163
3164     FIXME("not implemented\n");
3165     return E_NOTIMPL;
3166 }
3167
3168 static HRESULT WINAPI ITextSelection_fnIsEqual(ITextSelection *me, ITextRange *pRange, LONG *pb)
3169 {
3170     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3171     if (!This->reOle)
3172         return CO_E_RELEASED;
3173
3174     FIXME("not implemented\n");
3175     return E_NOTIMPL;
3176 }
3177
3178 static HRESULT WINAPI ITextSelection_fnSelect(ITextSelection *me)
3179 {
3180     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3181     if (!This->reOle)
3182         return CO_E_RELEASED;
3183
3184     FIXME("not implemented\n");
3185     return E_NOTIMPL;
3186 }
3187
3188 static HRESULT WINAPI ITextSelection_fnStartOf(ITextSelection *me, LONG Unit, LONG Extend,
3189     LONG *pDelta)
3190 {
3191     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3192     if (!This->reOle)
3193         return CO_E_RELEASED;
3194
3195     FIXME("not implemented\n");
3196     return E_NOTIMPL;
3197 }
3198
3199 static HRESULT WINAPI ITextSelection_fnEndOf(ITextSelection *me, LONG Unit, LONG Extend,
3200     LONG *pDelta)
3201 {
3202     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3203     if (!This->reOle)
3204         return CO_E_RELEASED;
3205
3206     FIXME("not implemented\n");
3207     return E_NOTIMPL;
3208 }
3209
3210 static HRESULT WINAPI ITextSelection_fnMove(ITextSelection *me, LONG Unit, LONG Count, LONG *pDelta)
3211 {
3212     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3213     if (!This->reOle)
3214         return CO_E_RELEASED;
3215
3216     FIXME("not implemented\n");
3217     return E_NOTIMPL;
3218 }
3219
3220 static HRESULT WINAPI ITextSelection_fnMoveStart(ITextSelection *me, LONG Unit, LONG Count,
3221     LONG *pDelta)
3222 {
3223     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3224     if (!This->reOle)
3225         return CO_E_RELEASED;
3226
3227     FIXME("not implemented\n");
3228     return E_NOTIMPL;
3229 }
3230
3231 static HRESULT WINAPI ITextSelection_fnMoveEnd(ITextSelection *me, LONG Unit, LONG Count,
3232     LONG *pDelta)
3233 {
3234     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3235     if (!This->reOle)
3236         return CO_E_RELEASED;
3237
3238     FIXME("not implemented\n");
3239     return E_NOTIMPL;
3240 }
3241
3242 static HRESULT WINAPI ITextSelection_fnMoveWhile(ITextSelection *me, VARIANT *Cset, LONG Count,
3243     LONG *pDelta)
3244 {
3245     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3246     if (!This->reOle)
3247         return CO_E_RELEASED;
3248
3249     FIXME("not implemented\n");
3250     return E_NOTIMPL;
3251 }
3252
3253 static HRESULT WINAPI ITextSelection_fnMoveStartWhile(ITextSelection *me, VARIANT *Cset, LONG Count,
3254     LONG *pDelta)
3255 {
3256     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3257     if (!This->reOle)
3258         return CO_E_RELEASED;
3259
3260     FIXME("not implemented\n");
3261     return E_NOTIMPL;
3262 }
3263
3264 static HRESULT WINAPI ITextSelection_fnMoveEndWhile(ITextSelection *me, VARIANT *Cset, LONG Count,
3265     LONG *pDelta)
3266 {
3267     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3268     if (!This->reOle)
3269         return CO_E_RELEASED;
3270
3271     FIXME("not implemented\n");
3272     return E_NOTIMPL;
3273 }
3274
3275 static HRESULT WINAPI ITextSelection_fnMoveUntil(ITextSelection *me, VARIANT *Cset, LONG Count,
3276     LONG *pDelta)
3277 {
3278     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3279     if (!This->reOle)
3280         return CO_E_RELEASED;
3281
3282     FIXME("not implemented\n");
3283     return E_NOTIMPL;
3284 }
3285
3286 static HRESULT WINAPI ITextSelection_fnMoveStartUntil(ITextSelection *me, VARIANT *Cset, LONG Count,
3287     LONG *pDelta)
3288 {
3289     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3290     if (!This->reOle)
3291         return CO_E_RELEASED;
3292
3293     FIXME("not implemented\n");
3294     return E_NOTIMPL;
3295 }
3296
3297 static HRESULT WINAPI ITextSelection_fnMoveEndUntil(ITextSelection *me, VARIANT *Cset, LONG Count,
3298     LONG *pDelta)
3299 {
3300     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3301     if (!This->reOle)
3302         return CO_E_RELEASED;
3303
3304     FIXME("not implemented\n");
3305     return E_NOTIMPL;
3306 }
3307
3308 static HRESULT WINAPI ITextSelection_fnFindText(ITextSelection *me, BSTR bstr, LONG cch, LONG Flags,
3309     LONG *pLength)
3310 {
3311     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3312     if (!This->reOle)
3313         return CO_E_RELEASED;
3314
3315     FIXME("not implemented\n");
3316     return E_NOTIMPL;
3317 }
3318
3319 static HRESULT WINAPI ITextSelection_fnFindTextStart(ITextSelection *me, BSTR bstr, LONG cch,
3320     LONG Flags, LONG *pLength)
3321 {
3322     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3323     if (!This->reOle)
3324         return CO_E_RELEASED;
3325
3326     FIXME("not implemented\n");
3327     return E_NOTIMPL;
3328 }
3329
3330 static HRESULT WINAPI ITextSelection_fnFindTextEnd(ITextSelection *me, BSTR bstr, LONG cch,
3331     LONG Flags, LONG *pLength)
3332 {
3333     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3334     if (!This->reOle)
3335         return CO_E_RELEASED;
3336
3337     FIXME("not implemented\n");
3338     return E_NOTIMPL;
3339 }
3340
3341 static HRESULT WINAPI ITextSelection_fnDelete(ITextSelection *me, LONG Unit, LONG Count,
3342     LONG *pDelta)
3343 {
3344     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3345     if (!This->reOle)
3346         return CO_E_RELEASED;
3347
3348     FIXME("not implemented\n");
3349     return E_NOTIMPL;
3350 }
3351
3352 static HRESULT WINAPI ITextSelection_fnCut(ITextSelection *me, VARIANT *pVar)
3353 {
3354     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3355     if (!This->reOle)
3356         return CO_E_RELEASED;
3357
3358     FIXME("not implemented\n");
3359     return E_NOTIMPL;
3360 }
3361
3362 static HRESULT WINAPI ITextSelection_fnCopy(ITextSelection *me, VARIANT *pVar)
3363 {
3364     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3365     if (!This->reOle)
3366         return CO_E_RELEASED;
3367
3368     FIXME("not implemented\n");
3369     return E_NOTIMPL;
3370 }
3371
3372 static HRESULT WINAPI ITextSelection_fnPaste(ITextSelection *me, VARIANT *pVar, LONG Format)
3373 {
3374     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3375     if (!This->reOle)
3376         return CO_E_RELEASED;
3377
3378     FIXME("not implemented\n");
3379     return E_NOTIMPL;
3380 }
3381
3382 static HRESULT WINAPI ITextSelection_fnCanPaste(ITextSelection *me, VARIANT *pVar, LONG Format,
3383     LONG *pb)
3384 {
3385     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3386     if (!This->reOle)
3387         return CO_E_RELEASED;
3388
3389     FIXME("not implemented\n");
3390     return E_NOTIMPL;
3391 }
3392
3393 static HRESULT WINAPI ITextSelection_fnCanEdit(ITextSelection *me, LONG *pb)
3394 {
3395     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3396     if (!This->reOle)
3397         return CO_E_RELEASED;
3398
3399     FIXME("not implemented\n");
3400     return E_NOTIMPL;
3401 }
3402
3403 static HRESULT WINAPI ITextSelection_fnChangeCase(ITextSelection *me, LONG Type)
3404 {
3405     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3406     if (!This->reOle)
3407         return CO_E_RELEASED;
3408
3409     FIXME("not implemented\n");
3410     return E_NOTIMPL;
3411 }
3412
3413 static HRESULT WINAPI ITextSelection_fnGetPoint(ITextSelection *me, LONG Type, LONG *cx, LONG *cy)
3414 {
3415     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3416     if (!This->reOle)
3417         return CO_E_RELEASED;
3418
3419     FIXME("not implemented\n");
3420     return E_NOTIMPL;
3421 }
3422
3423 static HRESULT WINAPI ITextSelection_fnSetPoint(ITextSelection *me, LONG x, LONG y, LONG Type,
3424     LONG Extend)
3425 {
3426     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3427     if (!This->reOle)
3428         return CO_E_RELEASED;
3429
3430     FIXME("not implemented\n");
3431     return E_NOTIMPL;
3432 }
3433
3434 static HRESULT WINAPI ITextSelection_fnScrollIntoView(ITextSelection *me, LONG Value)
3435 {
3436     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3437     if (!This->reOle)
3438         return CO_E_RELEASED;
3439
3440     FIXME("not implemented\n");
3441     return E_NOTIMPL;
3442 }
3443
3444 static HRESULT WINAPI ITextSelection_fnGetEmbeddedObject(ITextSelection *me, IUnknown **ppv)
3445 {
3446     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3447     if (!This->reOle)
3448         return CO_E_RELEASED;
3449
3450     FIXME("not implemented\n");
3451     return E_NOTIMPL;
3452 }
3453
3454 /*** ITextSelection methods ***/
3455 static HRESULT WINAPI ITextSelection_fnGetFlags(ITextSelection *me, LONG *pFlags)
3456 {
3457     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3458     if (!This->reOle)
3459         return CO_E_RELEASED;
3460
3461     FIXME("not implemented\n");
3462     return E_NOTIMPL;
3463 }
3464
3465 static HRESULT WINAPI ITextSelection_fnSetFlags(ITextSelection *me, LONG Flags)
3466 {
3467     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3468     if (!This->reOle)
3469         return CO_E_RELEASED;
3470
3471     FIXME("not implemented\n");
3472     return E_NOTIMPL;
3473 }
3474
3475 static HRESULT WINAPI ITextSelection_fnGetType(ITextSelection *me, LONG *pType)
3476 {
3477     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3478     if (!This->reOle)
3479         return CO_E_RELEASED;
3480
3481     FIXME("not implemented\n");
3482     return E_NOTIMPL;
3483 }
3484
3485 static HRESULT WINAPI ITextSelection_fnMoveLeft(ITextSelection *me, LONG Unit, LONG Count,
3486     LONG Extend, LONG *pDelta)
3487 {
3488     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3489     if (!This->reOle)
3490         return CO_E_RELEASED;
3491
3492     FIXME("not implemented\n");
3493     return E_NOTIMPL;
3494 }
3495
3496 static HRESULT WINAPI ITextSelection_fnMoveRight(ITextSelection *me, LONG Unit, LONG Count,
3497     LONG Extend, LONG *pDelta)
3498 {
3499     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3500     if (!This->reOle)
3501         return CO_E_RELEASED;
3502
3503     FIXME("not implemented\n");
3504     return E_NOTIMPL;
3505 }
3506
3507 static HRESULT WINAPI ITextSelection_fnMoveUp(ITextSelection *me, LONG Unit, LONG Count,
3508     LONG Extend, LONG *pDelta)
3509 {
3510     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3511     if (!This->reOle)
3512         return CO_E_RELEASED;
3513
3514     FIXME("not implemented\n");
3515     return E_NOTIMPL;
3516 }
3517
3518 static HRESULT WINAPI ITextSelection_fnMoveDown(ITextSelection *me, LONG Unit, LONG Count,
3519     LONG Extend, LONG *pDelta)
3520 {
3521     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3522     if (!This->reOle)
3523         return CO_E_RELEASED;
3524
3525     FIXME("not implemented\n");
3526     return E_NOTIMPL;
3527 }
3528
3529 static HRESULT WINAPI ITextSelection_fnHomeKey(ITextSelection *me, LONG Unit, LONG Extend,
3530     LONG *pDelta)
3531 {
3532     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3533     if (!This->reOle)
3534         return CO_E_RELEASED;
3535
3536     FIXME("not implemented\n");
3537     return E_NOTIMPL;
3538 }
3539
3540 static HRESULT WINAPI ITextSelection_fnEndKey(ITextSelection *me, LONG Unit, LONG Extend,
3541     LONG *pDelta)
3542 {
3543     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3544     if (!This->reOle)
3545         return CO_E_RELEASED;
3546
3547     FIXME("not implemented\n");
3548     return E_NOTIMPL;
3549 }
3550
3551 static HRESULT WINAPI ITextSelection_fnTypeText(ITextSelection *me, BSTR bstr)
3552 {
3553     ITextSelectionImpl *This = impl_from_ITextSelection(me);
3554     if (!This->reOle)
3555         return CO_E_RELEASED;
3556
3557     FIXME("not implemented\n");
3558     return E_NOTIMPL;
3559 }
3560
3561 static const ITextSelectionVtbl tsvt = {
3562     ITextSelection_fnQueryInterface,
3563     ITextSelection_fnAddRef,
3564     ITextSelection_fnRelease,
3565     ITextSelection_fnGetTypeInfoCount,
3566     ITextSelection_fnGetTypeInfo,
3567     ITextSelection_fnGetIDsOfNames,
3568     ITextSelection_fnInvoke,
3569     ITextSelection_fnGetText,
3570     ITextSelection_fnSetText,
3571     ITextSelection_fnGetChar,
3572     ITextSelection_fnSetChar,
3573     ITextSelection_fnGetDuplicate,
3574     ITextSelection_fnGetFormattedText,
3575     ITextSelection_fnSetFormattedText,
3576     ITextSelection_fnGetStart,
3577     ITextSelection_fnSetStart,
3578     ITextSelection_fnGetEnd,
3579     ITextSelection_fnSetEnd,
3580     ITextSelection_fnGetFont,
3581     ITextSelection_fnSetFont,
3582     ITextSelection_fnGetPara,
3583     ITextSelection_fnSetPara,
3584     ITextSelection_fnGetStoryLength,
3585     ITextSelection_fnGetStoryType,
3586     ITextSelection_fnCollapse,
3587     ITextSelection_fnExpand,
3588     ITextSelection_fnGetIndex,
3589     ITextSelection_fnSetIndex,
3590     ITextSelection_fnSetRange,
3591     ITextSelection_fnInRange,
3592     ITextSelection_fnInStory,
3593     ITextSelection_fnIsEqual,
3594     ITextSelection_fnSelect,
3595     ITextSelection_fnStartOf,
3596     ITextSelection_fnEndOf,
3597     ITextSelection_fnMove,
3598     ITextSelection_fnMoveStart,
3599     ITextSelection_fnMoveEnd,
3600     ITextSelection_fnMoveWhile,
3601     ITextSelection_fnMoveStartWhile,
3602     ITextSelection_fnMoveEndWhile,
3603     ITextSelection_fnMoveUntil,
3604     ITextSelection_fnMoveStartUntil,
3605     ITextSelection_fnMoveEndUntil,
3606     ITextSelection_fnFindText,
3607     ITextSelection_fnFindTextStart,
3608     ITextSelection_fnFindTextEnd,
3609     ITextSelection_fnDelete,
3610     ITextSelection_fnCut,
3611     ITextSelection_fnCopy,
3612     ITextSelection_fnPaste,
3613     ITextSelection_fnCanPaste,
3614     ITextSelection_fnCanEdit,
3615     ITextSelection_fnChangeCase,
3616     ITextSelection_fnGetPoint,
3617     ITextSelection_fnSetPoint,
3618     ITextSelection_fnScrollIntoView,
3619     ITextSelection_fnGetEmbeddedObject,
3620     ITextSelection_fnGetFlags,
3621     ITextSelection_fnSetFlags,
3622     ITextSelection_fnGetType,
3623     ITextSelection_fnMoveLeft,
3624     ITextSelection_fnMoveRight,
3625     ITextSelection_fnMoveUp,
3626     ITextSelection_fnMoveDown,
3627     ITextSelection_fnHomeKey,
3628     ITextSelection_fnEndKey,
3629     ITextSelection_fnTypeText
3630 };
3631
3632 static ITextSelectionImpl *
3633 CreateTextSelection(IRichEditOleImpl *reOle)
3634 {
3635     ITextSelectionImpl *txtSel = heap_alloc(sizeof *txtSel);
3636     if (!txtSel)
3637         return NULL;
3638
3639     txtSel->ITextSelection_iface.lpVtbl = &tsvt;
3640     txtSel->ref = 1;
3641     txtSel->reOle = reOle;
3642     return txtSel;
3643 }
3644
3645 LRESULT CreateIRichEditOle(IUnknown *outer_unk, ME_TextEditor *editor, LPVOID *ppvObj)
3646 {
3647     IRichEditOleImpl *reo;
3648
3649     reo = heap_alloc(sizeof(IRichEditOleImpl));
3650     if (!reo)
3651         return 0;
3652
3653     reo->IUnknown_inner.lpVtbl = &reo_unk_vtbl;
3654     reo->IRichEditOle_iface.lpVtbl = &revt;
3655     reo->ITextDocument_iface.lpVtbl = &tdvt;
3656     reo->ref = 1;
3657     reo->editor = editor;
3658     reo->txtSel = CreateTextSelection(reo);
3659     if (!reo->txtSel)
3660     {
3661         heap_free(reo);
3662         return 0;
3663     }
3664     reo->clientSite = CreateOleClientSite(reo);
3665     if (!reo->clientSite)
3666     {
3667         ITextSelection_Release(&reo->txtSel->ITextSelection_iface);
3668         heap_free(reo);
3669         return 0;
3670     }
3671     TRACE("Created %p\n",reo);
3672     list_init(&reo->rangelist);
3673     if (outer_unk)
3674         reo->outer_unk = outer_unk;
3675     else
3676         reo->outer_unk = &reo->IUnknown_inner;
3677     *ppvObj = &reo->IRichEditOle_iface;
3678
3679     return 1;
3680 }
3681
3682 static void convert_sizel(const ME_Context *c, const SIZEL* szl, SIZE* sz)
3683 {
3684   /* sizel is in .01 millimeters, sz in pixels */
3685   sz->cx = MulDiv(szl->cx, c->dpi.cx, 2540);
3686   sz->cy = MulDiv(szl->cy, c->dpi.cy, 2540);
3687 }
3688
3689 /******************************************************************************
3690  * ME_GetOLEObjectSize
3691  *
3692  * Sets run extent for OLE objects.
3693  */
3694 void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize)
3695 {
3696   IDataObject*  ido;
3697   FORMATETC     fmt;
3698   STGMEDIUM     stgm;
3699   DIBSECTION    dibsect;
3700   ENHMETAHEADER emh;
3701
3702   assert(run->nFlags & MERF_GRAPHICS);
3703   assert(run->ole_obj);
3704
3705   if (run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0)
3706   {
3707     convert_sizel(c, &run->ole_obj->sizel, pSize);
3708     if (c->editor->nZoomNumerator != 0)
3709     {
3710       pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
3711       pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
3712     }
3713     return;
3714   }
3715
3716   if (IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
3717   {
3718       FIXME("Query Interface IID_IDataObject failed!\n");
3719       pSize->cx = pSize->cy = 0;
3720       return;
3721   }
3722   fmt.cfFormat = CF_BITMAP;
3723   fmt.ptd = NULL;
3724   fmt.dwAspect = DVASPECT_CONTENT;
3725   fmt.lindex = -1;
3726   fmt.tymed = TYMED_GDI;
3727   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
3728   {
3729     fmt.cfFormat = CF_ENHMETAFILE;
3730     fmt.tymed = TYMED_ENHMF;
3731     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
3732     {
3733       FIXME("unsupported format\n");
3734       pSize->cx = pSize->cy = 0;
3735       IDataObject_Release(ido);
3736       return;
3737     }
3738   }
3739
3740   switch (stgm.tymed)
3741   {
3742   case TYMED_GDI:
3743     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
3744     pSize->cx = dibsect.dsBm.bmWidth;
3745     pSize->cy = dibsect.dsBm.bmHeight;
3746     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
3747     break;
3748   case TYMED_ENHMF:
3749     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
3750     pSize->cx = emh.rclBounds.right - emh.rclBounds.left;
3751     pSize->cy = emh.rclBounds.bottom - emh.rclBounds.top;
3752     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
3753     break;
3754   default:
3755     FIXME("Unsupported tymed %d\n", stgm.tymed);
3756     break;
3757   }
3758   IDataObject_Release(ido);
3759   if (c->editor->nZoomNumerator != 0)
3760   {
3761     pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
3762     pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
3763   }
3764 }
3765
3766 void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run,
3767                 ME_Paragraph *para, BOOL selected)
3768 {
3769   IDataObject*  ido;
3770   FORMATETC     fmt;
3771   STGMEDIUM     stgm;
3772   DIBSECTION    dibsect;
3773   ENHMETAHEADER emh;
3774   HDC           hMemDC;
3775   SIZE          sz;
3776   BOOL          has_size;
3777
3778   assert(run->nFlags & MERF_GRAPHICS);
3779   assert(run->ole_obj);
3780   if (IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
3781   {
3782     FIXME("Couldn't get interface\n");
3783     return;
3784   }
3785   has_size = run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0;
3786   fmt.cfFormat = CF_BITMAP;
3787   fmt.ptd = NULL;
3788   fmt.dwAspect = DVASPECT_CONTENT;
3789   fmt.lindex = -1;
3790   fmt.tymed = TYMED_GDI;
3791   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
3792   {
3793     fmt.cfFormat = CF_ENHMETAFILE;
3794     fmt.tymed = TYMED_ENHMF;
3795     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
3796     {
3797       FIXME("Couldn't get storage medium\n");
3798       IDataObject_Release(ido);
3799       return;
3800     }
3801   }
3802   switch (stgm.tymed)
3803   {
3804   case TYMED_GDI:
3805     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
3806     hMemDC = CreateCompatibleDC(c->hDC);
3807     SelectObject(hMemDC, stgm.u.hBitmap);
3808     if (has_size)
3809     {
3810       convert_sizel(c, &run->ole_obj->sizel, &sz);
3811     } else {
3812       sz.cx = MulDiv(dibsect.dsBm.bmWidth, c->dpi.cx, 96);
3813       sz.cy = MulDiv(dibsect.dsBm.bmHeight, c->dpi.cy, 96);
3814     }
3815     if (c->editor->nZoomNumerator != 0)
3816     {
3817       sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
3818       sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
3819     }
3820     if (sz.cx == dibsect.dsBm.bmWidth && sz.cy == dibsect.dsBm.bmHeight)
3821     {
3822       BitBlt(c->hDC, x, y - sz.cy,
3823              dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight,
3824              hMemDC, 0, 0, SRCCOPY);
3825     } else {
3826       StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
3827                  hMemDC, 0, 0, dibsect.dsBm.bmWidth,
3828                  dibsect.dsBm.bmHeight, SRCCOPY);
3829     }
3830     DeleteDC(hMemDC);
3831     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
3832     break;
3833   case TYMED_ENHMF:
3834     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
3835     if (has_size)
3836     {
3837       convert_sizel(c, &run->ole_obj->sizel, &sz);
3838     } else {
3839       sz.cy = MulDiv(emh.rclBounds.bottom - emh.rclBounds.top, c->dpi.cx, 96);
3840       sz.cx = MulDiv(emh.rclBounds.right - emh.rclBounds.left, c->dpi.cy, 96);
3841     }
3842     if (c->editor->nZoomNumerator != 0)
3843     {
3844       sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
3845       sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
3846     }
3847
3848     {
3849       RECT    rc;
3850
3851       rc.left = x;
3852       rc.top = y - sz.cy;
3853       rc.right = x + sz.cx;
3854       rc.bottom = y;
3855       PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
3856     }
3857     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
3858     break;
3859   default:
3860     FIXME("Unsupported tymed %d\n", stgm.tymed);
3861     selected = FALSE;
3862     break;
3863   }
3864   if (selected && !c->editor->bHideSelection)
3865     PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
3866   IDataObject_Release(ido);
3867 }
3868
3869 void ME_DeleteReObject(REOBJECT* reo)
3870 {
3871     if (reo->poleobj)   IOleObject_Release(reo->poleobj);
3872     if (reo->pstg)      IStorage_Release(reo->pstg);
3873     if (reo->polesite)  IOleClientSite_Release(reo->polesite);
3874     FREE_OBJ(reo);
3875 }
3876
3877 void ME_CopyReObject(REOBJECT* dst, const REOBJECT* src)
3878 {
3879     *dst = *src;
3880
3881     if (dst->poleobj)   IOleObject_AddRef(dst->poleobj);
3882     if (dst->pstg)      IStorage_AddRef(dst->pstg);
3883     if (dst->polesite)  IOleClientSite_AddRef(dst->polesite);
3884 }
3885
3886 void ME_GetITextDocumentInterface(IRichEditOle *iface, LPVOID *ppvObj)
3887 {
3888     IRichEditOleImpl *This = impl_from_IRichEditOle(iface);
3889     *ppvObj = &This->ITextDocument_iface;
3890 }