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 "richedit.h"
  35 #include "tom.h"
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
  39
  40 /* there is no way to be consistent across different sets of headers - mingw, Wine, Win32 SDK*/
  41
  42 #include "initguid.h"
  43
  44 DEFINE_GUID(LIBID_tom, 0x8cc497c9, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  45 DEFINE_GUID(IID_ITextServices, 0x8d33f740, 0xcf58, 0x11ce, 0xa8, 0x9d, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5);
  46 DEFINE_GUID(IID_ITextHost, 0x13e670f4,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1);
  47 DEFINE_GUID(IID_ITextHost2, 0x13e670f5,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1);
  48 DEFINE_GUID(IID_ITextDocument, 0x8cc497c0, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  49 DEFINE_GUID(IID_ITextDocument2Old, 0x01c25500, 0x4268, 0x11d1, 0x88, 0x3a, 0x3c, 0x8b, 0x00, 0xc1, 0x00, 0x00);
  50 DEFINE_GUID(IID_ITextRange, 0x8cc497c2, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  51 DEFINE_GUID(IID_ITextSelection, 0x8cc497c1, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  52 DEFINE_GUID(IID_ITextFont, 0x8cc497c3, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  53 DEFINE_GUID(IID_ITextPara, 0x8cc497c4, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
  54
  55 static ITypeLib *typelib;
  56
  57 enum tid_t {
  58     NULL_tid,
  59     ITextDocument_tid,
  60     ITextRange_tid,
  61     ITextSelection_tid,
  62     ITextFont_tid,
  63     ITextPara_tid,
  64     LAST_tid
  65 };
  66
  67 static const IID * const tid_ids[] =
  68 {
  69     &IID_NULL,
  70     &IID_ITextDocument,
  71     &IID_ITextRange,
  72     &IID_ITextSelection,
  73     &IID_ITextFont,
  74     &IID_ITextPara,
  75 };
  76 static ITypeInfo *typeinfos[LAST_tid];
  77
  78 static HRESULT load_typelib(void)
  79 {
  80     ITypeLib *tl;
  81     HRESULT hr;
  82
  83     hr = LoadRegTypeLib(&LIBID_tom, 1, 0, LOCALE_SYSTEM_DEFAULT, &tl);
  84     if (FAILED(hr)) {
  85         ERR("LoadRegTypeLib failed: %08x\n", hr);
  86         return hr;
  87     }
  88
  89     if (InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
  90         ITypeLib_Release(tl);
  91     return hr;
  92 }
  93
  94 void release_typelib(void)
  95 {
  96     unsigned i;
  97
  98     if (!typelib)
  99         return;
 100
 101     for (i = 0; i < ARRAY_SIZE(typeinfos); i++)
 102         if (typeinfos[i])
 103             ITypeInfo_Release(typeinfos[i]);
 104
 105     ITypeLib_Release(typelib);
 106 }
 107
 108 static HRESULT get_typeinfo(enum tid_t tid, ITypeInfo **typeinfo)
 109 {
 110     HRESULT hr;
 111
 112     if (!typelib)
 113         hr = load_typelib();
 114     if (!typelib)
 115         return hr;
 116
 117     if (!typeinfos[tid])
 118     {
 119         ITypeInfo *ti;
 120
 121         hr = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
 122         if (FAILED(hr))
 123         {
 124             ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hr);
 125             return hr;
 126         }
 127
 128         if (InterlockedCompareExchangePointer((void**)(typeinfos+tid), ti, NULL))
 129             ITypeInfo_Release(ti);
 130     }
 131
 132     *typeinfo = typeinfos[tid];
 133     return S_OK;
 134 }
 135
 136 /* private IID used to get back IRichEditOleImpl pointer */
 137 DEFINE_GUID(IID_Igetrichole, 0xe3ce5c7a, 0x8247, 0x4622, 0x81, 0xad, 0x11, 0x81, 0x02, 0xaa, 0x01, 0x30);
 138
 139 typedef struct ITextSelectionImpl ITextSelectionImpl;
 140 typedef struct IOleClientSiteImpl IOleClientSiteImpl;
 141 typedef struct ITextRangeImpl ITextRangeImpl;
 142
 143 enum textfont_prop_id {
 144     FONT_ALLCAPS = 0,
 145     FONT_ANIMATION,
 146     FONT_BACKCOLOR,
 147     FONT_BOLD,
 148     FONT_EMBOSS,
 149     FONT_FORECOLOR,
 150     FONT_HIDDEN,
 151     FONT_ENGRAVE,
 152     FONT_ITALIC,
 153     FONT_KERNING,
 154     FONT_LANGID,
 155     FONT_NAME,
 156     FONT_OUTLINE,
 157     FONT_POSITION,
 158     FONT_PROTECTED,
 159     FONT_SHADOW,
 160     FONT_SIZE,
 161     FONT_SMALLCAPS,
 162     FONT_SPACING,
 163     FONT_STRIKETHROUGH,
 164     FONT_SUBSCRIPT,
 165     FONT_SUPERSCRIPT,
 166     FONT_UNDERLINE,
 167     FONT_WEIGHT,
 168     FONT_PROPID_LAST,
 169     FONT_PROPID_FIRST = FONT_ALLCAPS
 170 };
 171
 172 static const DWORD textfont_prop_masks[][2] = {
 173     { CFM_ALLCAPS,     CFE_ALLCAPS },
 174     { CFM_ANIMATION },
 175     { CFM_BACKCOLOR,   CFE_AUTOBACKCOLOR },
 176     { CFM_BOLD,        CFE_BOLD },
 177     { CFM_EMBOSS,      CFE_EMBOSS },
 178     { CFM_COLOR,       CFE_AUTOCOLOR },
 179     { CFM_HIDDEN,      CFE_HIDDEN },
 180     { CFM_IMPRINT,     CFE_IMPRINT },
 181     { CFM_ITALIC,      CFE_ITALIC },
 182     { CFM_KERNING },
 183     { CFM_LCID },
 184     { CFM_FACE },
 185     { CFM_OUTLINE,     CFE_OUTLINE },
 186     { CFM_OFFSET },
 187     { CFM_PROTECTED,   CFE_PROTECTED },
 188     { CFM_SHADOW,      CFE_SHADOW },
 189     { CFM_SIZE },
 190     { CFM_SMALLCAPS,   CFE_SMALLCAPS },
 191     { CFM_SPACING },
 192     { CFM_STRIKEOUT,   CFE_STRIKEOUT },
 193     { CFM_SUBSCRIPT,   CFE_SUBSCRIPT },
 194     { CFM_SUPERSCRIPT, CFE_SUPERSCRIPT },
 195     { CFM_UNDERLINE,   CFE_UNDERLINE },
 196     { CFM_WEIGHT }
 197 };
 198
 199 typedef union {
 200     FLOAT f;
 201     LONG  l;
 202     BSTR  str;
 203 } textfont_prop_val;
 204
 205 enum range_update_op {
 206     RANGE_UPDATE_DELETE
 207 };
 208
 209 typedef struct IRichEditOleImpl {
 210     IUnknown IUnknown_inner;
 211     IRichEditOle IRichEditOle_iface;
 212     ITextDocument2Old ITextDocument2Old_iface;
 213     IUnknown *outer_unk;
 214     LONG ref;
 215
 216     ME_TextEditor *editor;
 217     ITextSelectionImpl *txtSel;
 218
 219     struct list rangelist;
 220     struct list clientsites;
 221 } IRichEditOleImpl;
 222
 223 struct reole_child {
 224     struct list entry;
 225     IRichEditOleImpl *reole;
 226 };
 227
 228 struct ITextRangeImpl {
 229     struct reole_child child;
 230     ITextRange ITextRange_iface;
 231     LONG ref;
 232     LONG start, end;
 233 };
 234
 235 struct ITextSelectionImpl {
 236     ITextSelection ITextSelection_iface;
 237     LONG ref;
 238
 239     IRichEditOleImpl *reOle;
 240 };
 241
 242 typedef struct ITextFontImpl {
 243     ITextFont ITextFont_iface;
 244     LONG ref;
 245
 246     ITextRange *range;
 247     textfont_prop_val props[FONT_PROPID_LAST];
 248     BOOL get_cache_enabled;
 249     BOOL set_cache_enabled;
 250 } ITextFontImpl;
 251
 252 typedef struct ITextParaImpl {
 253     ITextPara ITextPara_iface;
 254     LONG ref;
 255
 256     ITextRange *range;
 257 } ITextParaImpl;
 258
 259 struct IOleClientSiteImpl {
 260     struct reole_child child;
 261     IOleClientSite IOleClientSite_iface;
 262     IOleInPlaceSite IOleInPlaceSite_iface;
 263     LONG ref;
 264 };
 265
 266 static inline IRichEditOleImpl *impl_from_IRichEditOle(IRichEditOle *iface)
 267 {
 268     return CONTAINING_RECORD(iface, IRichEditOleImpl, IRichEditOle_iface);
 269 }
 270
 271 static inline IRichEditOleImpl *impl_from_ITextDocument2Old(ITextDocument2Old *iface)
 272 {
 273     return CONTAINING_RECORD(iface, IRichEditOleImpl, ITextDocument2Old_iface);
 274 }
 275
 276 static inline IRichEditOleImpl *impl_from_IUnknown(IUnknown *iface)
 277 {
 278     return CONTAINING_RECORD(iface, IRichEditOleImpl, IUnknown_inner);
 279 }
 280
 281 static inline IOleClientSiteImpl *impl_from_IOleInPlaceSite(IOleInPlaceSite *iface)
 282 {
 283     return CONTAINING_RECORD(iface, IOleClientSiteImpl, IOleInPlaceSite_iface);
 284 }
 285
 286 static inline ITextRangeImpl *impl_from_ITextRange(ITextRange *iface)
 287 {
 288     return CONTAINING_RECORD(iface, ITextRangeImpl, ITextRange_iface);
 289 }
 290
 291 static inline ITextSelectionImpl *impl_from_ITextSelection(ITextSelection *iface)
 292 {
 293     return CONTAINING_RECORD(iface, ITextSelectionImpl, ITextSelection_iface);
 294 }
 295
 296 static inline ITextFontImpl *impl_from_ITextFont(ITextFont *iface)
 297 {
 298     return CONTAINING_RECORD(iface, ITextFontImpl, ITextFont_iface);
 299 }
 300
 301 static inline ITextParaImpl *impl_from_ITextPara(ITextPara *iface)
 302 {
 303     return CONTAINING_RECORD(iface, ITextParaImpl, ITextPara_iface);
 304 }
 305
 306 static HRESULT create_textfont(ITextRange*, const ITextFontImpl*, ITextFont**);
 307 static HRESULT create_textpara(ITextRange*, ITextPara**);
 308 static ITextSelectionImpl *CreateTextSelection(IRichEditOleImpl*);
 309
 310 static HRESULT textrange_get_storylength(ME_TextEditor *editor, LONG *length)
 311 {
 312     if (!length)
 313         return E_INVALIDARG;
 314
 315     *length = ME_GetTextLength(editor) + 1;
 316     return S_OK;
 317 }
 318
 319 static void textranges_update_ranges(IRichEditOleImpl *reole, LONG start, LONG end, enum range_update_op op)
 320 {
 321     ITextRangeImpl *range;
 322
 323     LIST_FOR_EACH_ENTRY(range, &reole->rangelist, ITextRangeImpl, child.entry) {
 324         switch (op)
 325         {
 326         case RANGE_UPDATE_DELETE:
 327             /* range fully covered by deleted range - collapse to insertion point */
 328             if (range->start >= start && range->end <= end)
 329                 range->start = range->end = start;
 330             /* deleted range cuts from the right */
 331             else if (range->start < start && range->end <= end)
 332                 range->end = start;
 333             /* deleted range cuts from the left */
 334             else if (range->start >= start && range->end > end) {
 335                 range->start = start;
 336                 range->end -= end - start;
 337             }
 338             /* deleted range cuts within */
 339             else
 340                 range->end -= end - start;
 341             break;
 342         default:
 343             FIXME("unknown update op, %d\n", op);
 344         }
 345     }
 346 }
 347
 348 static inline BOOL is_equal_textfont_prop_value(enum textfont_prop_id propid, textfont_prop_val *left,
 349     textfont_prop_val *right)
 350 {
 351     switch (propid)
 352     {
 353     case FONT_ALLCAPS:
 354     case FONT_ANIMATION:
 355     case FONT_BACKCOLOR:
 356     case FONT_BOLD:
 357     case FONT_EMBOSS:
 358     case FONT_FORECOLOR:
 359     case FONT_HIDDEN:
 360     case FONT_ENGRAVE:
 361     case FONT_ITALIC:
 362     case FONT_KERNING:
 363     case FONT_LANGID:
 364     case FONT_OUTLINE:
 365     case FONT_PROTECTED:
 366     case FONT_SHADOW:
 367     case FONT_SMALLCAPS:
 368     case FONT_STRIKETHROUGH:
 369     case FONT_SUBSCRIPT:
 370     case FONT_SUPERSCRIPT:
 371     case FONT_UNDERLINE:
 372     case FONT_WEIGHT:
 373         return left->l == right->l;
 374     case FONT_NAME:
 375         return !wcscmp(left->str, right->str);
 376     case FONT_POSITION:
 377     case FONT_SIZE:
 378     case FONT_SPACING:
 379        return left->f == right->f;
 380     default:
 381         FIXME("unhandled font property %d\n", propid);
 382         return FALSE;
 383     }
 384 }
 385
 386 static inline void init_textfont_prop_value(enum textfont_prop_id propid, textfont_prop_val *v)
 387 {
 388     switch (propid)
 389     {
 390     case FONT_ALLCAPS:
 391     case FONT_ANIMATION:
 392     case FONT_BACKCOLOR:
 393     case FONT_BOLD:
 394     case FONT_EMBOSS:
 395     case FONT_FORECOLOR:
 396     case FONT_HIDDEN:
 397     case FONT_ENGRAVE:
 398     case FONT_ITALIC:
 399     case FONT_KERNING:
 400     case FONT_LANGID:
 401     case FONT_OUTLINE:
 402     case FONT_PROTECTED:
 403     case FONT_SHADOW:
 404     case FONT_SMALLCAPS:
 405     case FONT_STRIKETHROUGH:
 406     case FONT_SUBSCRIPT:
 407     case FONT_SUPERSCRIPT:
 408     case FONT_UNDERLINE:
 409     case FONT_WEIGHT:
 410         v->l = tomUndefined;
 411         return;
 412     case FONT_NAME:
 413         v->str = NULL;
 414         return;
 415     case FONT_POSITION:
 416     case FONT_SIZE:
 417     case FONT_SPACING:
 418         v->f = tomUndefined;
 419         return;
 420     default:
 421         FIXME("unhandled font property %d\n", propid);
 422         v->l = tomUndefined;
 423         return;
 424     }
 425 }
 426
 427 static inline FLOAT twips_to_points(LONG value)
 428 {
 429     return value * 72.0 / 1440;
 430 }
 431
 432 static inline FLOAT points_to_twips(FLOAT value)
 433 {
 434     return value * 1440 / 72.0;
 435 }
 436
 437 static HRESULT get_textfont_prop_for_pos(const IRichEditOleImpl *reole, int pos, enum textfont_prop_id propid,
 438     textfont_prop_val *value)
 439 {
 440     ME_Cursor from, to;
 441     CHARFORMAT2W fmt;
 442
 443     memset(&fmt, 0, sizeof(fmt));
 444     fmt.cbSize = sizeof(fmt);
 445     fmt.dwMask = textfont_prop_masks[propid][0];
 446
 447     ME_CursorFromCharOfs(reole->editor, pos, &from);
 448     to = from;
 449     ME_MoveCursorChars(reole->editor, &to, 1, FALSE);
 450     ME_GetCharFormat(reole->editor, &from, &to, &fmt);
 451
 452     switch (propid)
 453     {
 454     case FONT_ALLCAPS:
 455     case FONT_BOLD:
 456     case FONT_EMBOSS:
 457     case FONT_HIDDEN:
 458     case FONT_ENGRAVE:
 459     case FONT_ITALIC:
 460     case FONT_OUTLINE:
 461     case FONT_PROTECTED:
 462     case FONT_SHADOW:
 463     case FONT_SMALLCAPS:
 464     case FONT_STRIKETHROUGH:
 465     case FONT_SUBSCRIPT:
 466     case FONT_SUPERSCRIPT:
 467     case FONT_UNDERLINE:
 468         value->l = fmt.dwEffects & textfont_prop_masks[propid][1] ? tomTrue : tomFalse;
 469         break;
 470     case FONT_ANIMATION:
 471         value->l = fmt.bAnimation;
 472         break;
 473     case FONT_BACKCOLOR:
 474         value->l = fmt.dwEffects & CFE_AUTOBACKCOLOR ? GetSysColor(COLOR_WINDOW) : fmt.crBackColor;
 475         break;
 476     case FONT_FORECOLOR:
 477         value->l = fmt.dwEffects & CFE_AUTOCOLOR ? GetSysColor(COLOR_WINDOWTEXT) : fmt.crTextColor;
 478         break;
 479     case FONT_KERNING:
 480         value->f = twips_to_points(fmt.wKerning);
 481         break;
 482     case FONT_LANGID:
 483         value->l = fmt.lcid;
 484         break;
 485     case FONT_NAME:
 486         /* this case is used exclusively by GetName() */
 487         value->str = SysAllocString(fmt.szFaceName);
 488         if (!value->str)
 489             return E_OUTOFMEMORY;
 490         break;
 491     case FONT_POSITION:
 492         value->f = twips_to_points(fmt.yOffset);
 493         break;
 494     case FONT_SIZE:
 495         value->f = twips_to_points(fmt.yHeight);
 496         break;
 497     case FONT_SPACING:
 498         value->f = fmt.sSpacing;
 499         break;
 500     case FONT_WEIGHT:
 501         value->l = fmt.wWeight;
 502         break;
 503     default:
 504         FIXME("unhandled font property %d\n", propid);
 505         return E_FAIL;
 506     }
 507
 508     return S_OK;
 509 }
 510
 511 static inline const IRichEditOleImpl *get_range_reole(ITextRange *range)
 512 {
 513     IRichEditOleImpl *reole = NULL;
 514     ITextRange_QueryInterface(range, &IID_Igetrichole, (void**)&reole);
 515     return reole;
 516 }
 517
 518 static void textrange_set_font(ITextRange *range, ITextFont *font)
 519 {
 520     CHARFORMAT2W fmt;
 521     HRESULT hr;
 522     LONG value;
 523     BSTR str;
 524     FLOAT f;
 525
 526 #define CHARFORMAT_SET_B_FIELD(mask, value) \
 527     if (hr == S_OK && value != tomUndefined) { \
 528         fmt.dwMask |= CFM_##mask; \
 529         if (value == tomTrue) fmt.dwEffects |= CFE_##mask; \
 530     } \
 531
 532     /* fill format data from font */
 533     memset(&fmt, 0, sizeof(fmt));
 534     fmt.cbSize = sizeof(fmt);
 535
 536     value = tomUndefined;
 537     hr = ITextFont_GetAllCaps(font, &value);
 538     CHARFORMAT_SET_B_FIELD(ALLCAPS, value);
 539
 540     value = tomUndefined;
 541     hr = ITextFont_GetBold(font, &value);
 542     CHARFORMAT_SET_B_FIELD(BOLD, value);
 543
 544     value = tomUndefined;
 545     hr = ITextFont_GetEmboss(font, &value);
 546     CHARFORMAT_SET_B_FIELD(EMBOSS, value);
 547
 548     value = tomUndefined;
 549     hr = ITextFont_GetHidden(font, &value);
 550     CHARFORMAT_SET_B_FIELD(HIDDEN, value);
 551
 552     value = tomUndefined;
 553     hr = ITextFont_GetEngrave(font, &value);
 554     CHARFORMAT_SET_B_FIELD(IMPRINT, value);
 555
 556     value = tomUndefined;
 557     hr = ITextFont_GetItalic(font, &value);
 558     CHARFORMAT_SET_B_FIELD(ITALIC, value);
 559
 560     value = tomUndefined;
 561     hr = ITextFont_GetOutline(font, &value);
 562     CHARFORMAT_SET_B_FIELD(OUTLINE, value);
 563
 564     value = tomUndefined;
 565     hr = ITextFont_GetProtected(font, &value);
 566     CHARFORMAT_SET_B_FIELD(PROTECTED, value);
 567
 568     value = tomUndefined;
 569     hr = ITextFont_GetShadow(font, &value);
 570     CHARFORMAT_SET_B_FIELD(SHADOW, value);
 571
 572     value = tomUndefined;
 573     hr = ITextFont_GetSmallCaps(font, &value);
 574     CHARFORMAT_SET_B_FIELD(SMALLCAPS, value);
 575
 576     value = tomUndefined;
 577     hr = ITextFont_GetStrikeThrough(font, &value);
 578     CHARFORMAT_SET_B_FIELD(STRIKEOUT, value);
 579
 580     value = tomUndefined;
 581     hr = ITextFont_GetSubscript(font, &value);
 582     CHARFORMAT_SET_B_FIELD(SUBSCRIPT, value);
 583
 584     value = tomUndefined;
 585     hr = ITextFont_GetSuperscript(font, &value);
 586     CHARFORMAT_SET_B_FIELD(SUPERSCRIPT, value);
 587
 588     value = tomUndefined;
 589     hr = ITextFont_GetUnderline(font, &value);
 590     CHARFORMAT_SET_B_FIELD(UNDERLINE, value);
 591
 592 #undef CHARFORMAT_SET_B_FIELD
 593
 594     value = tomUndefined;
 595     hr = ITextFont_GetAnimation(font, &value);
 596     if (hr == S_OK && value != tomUndefined) {
 597         fmt.dwMask |= CFM_ANIMATION;
 598         fmt.bAnimation = value;
 599     }
 600
 601     value = tomUndefined;
 602     hr = ITextFont_GetBackColor(font, &value);
 603     if (hr == S_OK && value != tomUndefined) {
 604         fmt.dwMask |= CFM_BACKCOLOR;
 605         if (value == tomAutoColor)
 606             fmt.dwEffects |= CFE_AUTOBACKCOLOR;
 607         else
 608             fmt.crBackColor = value;
 609     }
 610
 611     value = tomUndefined;
 612     hr = ITextFont_GetForeColor(font, &value);
 613     if (hr == S_OK && value != tomUndefined) {
 614         fmt.dwMask |= CFM_COLOR;
 615         if (value == tomAutoColor)
 616             fmt.dwEffects |= CFE_AUTOCOLOR;
 617         else
 618             fmt.crTextColor = value;
 619     }
 620
 621     value = tomUndefined;
 622     hr = ITextFont_GetKerning(font, &f);
 623     if (hr == S_OK && f != tomUndefined) {
 624         fmt.dwMask |= CFM_KERNING;
 625         fmt.wKerning = points_to_twips(f);
 626     }
 627
 628     value = tomUndefined;
 629     hr = ITextFont_GetLanguageID(font, &value);
 630     if (hr == S_OK && value != tomUndefined) {
 631         fmt.dwMask |= CFM_LCID;
 632         fmt.lcid = value;
 633     }
 634
 635     if (ITextFont_GetName(font, &str) == S_OK) {
 636         fmt.dwMask |= CFM_FACE;
 637         lstrcpynW(fmt.szFaceName, str, ARRAY_SIZE(fmt.szFaceName));
 638         SysFreeString(str);
 639     }
 640
 641     hr = ITextFont_GetPosition(font, &f);
 642     if (hr == S_OK && f != tomUndefined) {
 643         fmt.dwMask |= CFM_OFFSET;
 644         fmt.yOffset = points_to_twips(f);
 645     }
 646
 647     hr = ITextFont_GetSize(font, &f);
 648     if (hr == S_OK && f != tomUndefined) {
 649         fmt.dwMask |= CFM_SIZE;
 650         fmt.yHeight = points_to_twips(f);
 651     }
 652
 653     hr = ITextFont_GetSpacing(font, &f);
 654     if (hr == S_OK && f != tomUndefined) {
 655         fmt.dwMask |= CFM_SPACING;
 656         fmt.sSpacing = f;
 657     }
 658
 659     hr = ITextFont_GetWeight(font, &value);
 660     if (hr == S_OK && value != tomUndefined) {
 661         fmt.dwMask |= CFM_WEIGHT;
 662         fmt.wWeight = value;
 663     }
 664
 665     if (fmt.dwMask) {
 666         const IRichEditOleImpl *reole = get_range_reole(range);
 667         ME_Cursor from, to;
 668         LONG start, end;
 669
 670         ITextRange_GetStart(range, &start);
 671         ITextRange_GetEnd(range, &end);
 672
 673         ME_CursorFromCharOfs(reole->editor, start, &from);
 674         ME_CursorFromCharOfs(reole->editor, end, &to);
 675         ME_SetCharFormat(reole->editor, &from, &to, &fmt);
 676     }
 677 }
 678
 679 static HRESULT get_textfont_prop(const ITextFontImpl *font, enum textfont_prop_id propid, textfont_prop_val *value)
 680 {
 681     const IRichEditOleImpl *reole;
 682     textfont_prop_val v;
 683     LONG start, end, i;
 684     HRESULT hr;
 685
 686     /* when font is not attached to any range use cached values */
 687     if (!font->range || font->get_cache_enabled) {
 688         *value = font->props[propid];
 689         return S_OK;
 690     }
 691
 692     if (!(reole = get_range_reole(font->range)))
 693         return CO_E_RELEASED;
 694
 695     init_textfont_prop_value(propid, value);
 696
 697     ITextRange_GetStart(font->range, &start);
 698     ITextRange_GetEnd(font->range, &end);
 699
 700     /* iterate trough a range to see if property value is consistent */
 701     hr = get_textfont_prop_for_pos(reole, start, propid, &v);
 702     if (FAILED(hr))
 703         return hr;
 704
 705     for (i = start + 1; i < end; i++) {
 706         textfont_prop_val cur;
 707
 708         hr = get_textfont_prop_for_pos(reole, i, propid, &cur);
 709         if (FAILED(hr))
 710             return hr;
 711
 712         if (!is_equal_textfont_prop_value(propid, &v, &cur))
 713             return S_OK;
 714     }
 715
 716     *value = v;
 717     return S_OK;
 718 }
 719
 720 static HRESULT get_textfont_propf(const ITextFontImpl *font, enum textfont_prop_id propid, FLOAT *value)
 721 {
 722     textfont_prop_val v;
 723     HRESULT hr;
 724
 725     if (!value)
 726         return E_INVALIDARG;
 727
 728     hr = get_textfont_prop(font, propid, &v);
 729     *value = v.f;
 730     return hr;
 731 }
 732
 733 static HRESULT get_textfont_propl(const ITextFontImpl *font, enum textfont_prop_id propid, LONG *value)
 734 {
 735     textfont_prop_val v;
 736     HRESULT hr;
 737
 738     if (!value)
 739         return E_INVALIDARG;
 740
 741     hr = get_textfont_prop(font, propid, &v);
 742     *value = v.l;
 743     return hr;
 744 }
 745
 746 /* Value should already have a terminal value, for boolean properties it means tomToggle is not handled */
 747 static HRESULT set_textfont_prop(ITextFontImpl *font, enum textfont_prop_id propid, const textfont_prop_val *value)
 748 {
 749     const IRichEditOleImpl *reole;
 750     ME_Cursor from, to;
 751     CHARFORMAT2W fmt;
 752     LONG start, end;
 753
 754     /* when font is not attached to any range use cache */
 755     if (!font->range || font->set_cache_enabled) {
 756         if (propid == FONT_NAME) {
 757             SysFreeString(font->props[propid].str);
 758             font->props[propid].str = SysAllocString(value->str);
 759         }
 760         else
 761             font->props[propid] = *value;
 762         return S_OK;
 763     }
 764
 765     if (!(reole = get_range_reole(font->range)))
 766         return CO_E_RELEASED;
 767
 768     memset(&fmt, 0, sizeof(fmt));
 769     fmt.cbSize = sizeof(fmt);
 770     fmt.dwMask = textfont_prop_masks[propid][0];
 771
 772     switch (propid)
 773     {
 774     case FONT_ALLCAPS:
 775     case FONT_BOLD:
 776     case FONT_EMBOSS:
 777     case FONT_HIDDEN:
 778     case FONT_ENGRAVE:
 779     case FONT_ITALIC:
 780     case FONT_OUTLINE:
 781     case FONT_PROTECTED:
 782     case FONT_SHADOW:
 783     case FONT_SMALLCAPS:
 784     case FONT_STRIKETHROUGH:
 785     case FONT_SUBSCRIPT:
 786     case FONT_SUPERSCRIPT:
 787     case FONT_UNDERLINE:
 788         fmt.dwEffects = value->l == tomTrue ? textfont_prop_masks[propid][1] : 0;
 789         break;
 790     case FONT_ANIMATION:
 791         fmt.bAnimation = value->l;
 792         break;
 793     case FONT_BACKCOLOR:
 794     case FONT_FORECOLOR:
 795         if (value->l == tomAutoColor)
 796             fmt.dwEffects = textfont_prop_masks[propid][1];
 797         else if (propid == FONT_BACKCOLOR)
 798             fmt.crBackColor = value->l;
 799         else
 800             fmt.crTextColor = value->l;
 801         break;
 802     case FONT_KERNING:
 803         fmt.wKerning = value->f;
 804         break;
 805     case FONT_LANGID:
 806         fmt.lcid = value->l;
 807         break;
 808     case FONT_POSITION:
 809         fmt.yOffset = value->f;
 810         break;
 811     case FONT_SIZE:
 812         fmt.yHeight = value->f;
 813         break;
 814     case FONT_SPACING:
 815         fmt.sSpacing = value->f;
 816         break;
 817     case FONT_WEIGHT:
 818         fmt.wWeight = value->l;
 819         break;
 820     case FONT_NAME:
 821         lstrcpynW(fmt.szFaceName, value->str, ARRAY_SIZE(fmt.szFaceName));
 822         break;
 823     default:
 824         FIXME("unhandled font property %d\n", propid);
 825         return E_FAIL;
 826     }
 827
 828     ITextRange_GetStart(font->range, &start);
 829     ITextRange_GetEnd(font->range, &end);
 830
 831     ME_CursorFromCharOfs(reole->editor, start, &from);
 832     ME_CursorFromCharOfs(reole->editor, end, &to);
 833     ME_SetCharFormat(reole->editor, &from, &to, &fmt);
 834
 835     return S_OK;
 836 }
 837
 838 static inline HRESULT set_textfont_propl(ITextFontImpl *font, enum textfont_prop_id propid, LONG value)
 839 {
 840     textfont_prop_val v;
 841     v.l = value;
 842     return set_textfont_prop(font, propid, &v);
 843 }
 844
 845 static inline HRESULT set_textfont_propf(ITextFontImpl *font, enum textfont_prop_id propid, FLOAT value)
 846 {
 847     textfont_prop_val v;
 848     v.f = value;
 849     return set_textfont_prop(font, propid, &v);
 850 }
 851
 852 static HRESULT set_textfont_propd(ITextFontImpl *font, enum textfont_prop_id propid, LONG value)
 853 {
 854     textfont_prop_val v;
 855
 856     switch (value)
 857     {
 858     case tomUndefined:
 859         return S_OK;
 860     case tomToggle: {
 861         LONG oldvalue;
 862         get_textfont_propl(font, propid, &oldvalue);
 863         if (oldvalue == tomFalse)
 864             value = tomTrue;
 865         else if (oldvalue == tomTrue)
 866             value = tomFalse;
 867         else
 868             return E_INVALIDARG;
 869         /* fallthrough */
 870     }
 871     case tomTrue:
 872     case tomFalse:
 873         v.l = value;
 874         return set_textfont_prop(font, propid, &v);
 875     default:
 876         return E_INVALIDARG;
 877     }
 878 }
 879
 880 static HRESULT textfont_getname_from_range(ITextRange *range, BSTR *ret)
 881 {
 882     const IRichEditOleImpl *reole;
 883     textfont_prop_val v;
 884     HRESULT hr;
 885     LONG start;
 886
 887     if (!(reole = get_range_reole(range)))
 888         return CO_E_RELEASED;
 889
 890     ITextRange_GetStart(range, &start);
 891     hr = get_textfont_prop_for_pos(reole, start, FONT_NAME, &v);
 892     *ret = v.str;
 893     return hr;
 894 }
 895
 896 static void textfont_cache_range_props(ITextFontImpl *font)
 897 {
 898     enum textfont_prop_id propid;
 899     for (propid = FONT_PROPID_FIRST; propid < FONT_PROPID_LAST; propid++) {
 900         if (propid == FONT_NAME)
 901             textfont_getname_from_range(font->range, &font->props[propid].str);
 902         else
 903             get_textfont_prop(font, propid, &font->props[propid]);
 904     }
 905 }
 906
 907 static HRESULT textrange_expand(ITextRange *range, LONG unit, LONG *delta)
 908 {
 909     LONG expand_start, expand_end;
 910
 911     switch (unit)
 912     {
 913     case tomStory:
 914         expand_start = 0;
 915         ITextRange_GetStoryLength(range, &expand_end);
 916         break;
 917     default:
 918         FIXME("unit %d is not supported\n", unit);
 919         return E_NOTIMPL;
 920     }
 921
 922     if (delta) {
 923         LONG start, end;
 924
 925         ITextRange_GetStart(range, &start);
 926         ITextRange_GetEnd(range, &end);
 927         *delta = expand_end - expand_start - (end - start);
 928     }
 929
 930     ITextRange_SetStart(range, expand_start);
 931     ITextRange_SetEnd(range, expand_end);
 932
 933     return S_OK;
 934 }
 935
 936 static HRESULT WINAPI IRichEditOleImpl_inner_fnQueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppvObj)
 937 {
 938     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 939
 940     TRACE("%p %s\n", This, debugstr_guid(riid));
 941
 942     *ppvObj = NULL;
 943     if (IsEqualGUID(riid, &IID_IUnknown))
 944         *ppvObj = &This->IUnknown_inner;
 945     else if (IsEqualGUID(riid, &IID_IRichEditOle))
 946         *ppvObj = &This->IRichEditOle_iface;
 947     else if (IsEqualGUID(riid, &IID_ITextDocument) || IsEqualGUID(riid, &IID_ITextDocument2Old))
 948         *ppvObj = &This->ITextDocument2Old_iface;
 949     if (*ppvObj)
 950     {
 951         IUnknown_AddRef((IUnknown *)*ppvObj);
 952         return S_OK;
 953     }
 954     FIXME("%p: unhandled interface %s\n", This, debugstr_guid(riid));
 955
 956     return E_NOINTERFACE;
 957 }
 958
 959 static ULONG WINAPI IRichEditOleImpl_inner_fnAddRef(IUnknown *iface)
 960 {
 961     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 962     ULONG ref = InterlockedIncrement(&This->ref);
 963
 964     TRACE("%p ref = %u\n", This, ref);
 965
 966     return ref;
 967 }
 968
 969 static ULONG WINAPI IRichEditOleImpl_inner_fnRelease(IUnknown *iface)
 970 {
 971     IRichEditOleImpl *This = impl_from_IUnknown(iface);
 972     ULONG ref = InterlockedDecrement(&This->ref);
 973
 974     TRACE ("%p ref=%u\n", This, ref);
 975
 976     if (!ref)
 977     {
 978         IOleClientSiteImpl *clientsite;
 979         ITextRangeImpl *txtRge;
 980
 981         This->editor->reOle = NULL;
 982         if (This->txtSel) {
 983             This->txtSel->reOle = NULL;
 984             ITextSelection_Release(&This->txtSel->ITextSelection_iface);
 985         }
 986
 987         LIST_FOR_EACH_ENTRY(txtRge, &This->rangelist, ITextRangeImpl, child.entry)
 988             txtRge->child.reole = NULL;
 989
 990         LIST_FOR_EACH_ENTRY(clientsite, &This->clientsites, IOleClientSiteImpl, child.entry)
 991             clientsite->child.reole = NULL;
 992
 993         heap_free(This);
 994     }
 995     return ref;
 996 }
 997
 998 static const IUnknownVtbl reo_unk_vtbl =
 999 {
1000     IRichEditOleImpl_inner_fnQueryInterface,
1001     IRichEditOleImpl_inner_fnAddRef,
1002     IRichEditOleImpl_inner_fnRelease
1003 };
1004
1005 static HRESULT WINAPI
1006 IRichEditOle_fnQueryInterface(IRichEditOle *me, REFIID riid, LPVOID *ppvObj)
1007 {
1008     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1009     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
1010 }
1011
1012 static ULONG WINAPI
1013 IRichEditOle_fnAddRef(IRichEditOle *me)
1014 {
1015     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1016     return IUnknown_AddRef(This->outer_unk);
1017 }
1018
1019 static ULONG WINAPI
1020 IRichEditOle_fnRelease(IRichEditOle *me)
1021 {
1022     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1023     return IUnknown_Release(This->outer_unk);
1024 }
1025
1026 static HRESULT WINAPI
1027 IRichEditOle_fnActivateAs(IRichEditOle *me, REFCLSID rclsid, REFCLSID rclsidAs)
1028 {
1029     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1030     FIXME("stub %p\n",This);
1031     return E_NOTIMPL;
1032 }
1033
1034 static HRESULT WINAPI
1035 IRichEditOle_fnContextSensitiveHelp(IRichEditOle *me, BOOL fEnterMode)
1036 {
1037     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1038     FIXME("stub %p\n",This);
1039     return E_NOTIMPL;
1040 }
1041
1042 static HRESULT WINAPI
1043 IRichEditOle_fnConvertObject(IRichEditOle *me, LONG iob,
1044                REFCLSID rclsidNew, LPCSTR lpstrUserTypeNew)
1045 {
1046     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1047     FIXME("stub %p\n",This);
1048     return E_NOTIMPL;
1049 }
1050
1051 static inline IOleClientSiteImpl *impl_from_IOleClientSite(IOleClientSite *iface)
1052 {
1053     return CONTAINING_RECORD(iface, IOleClientSiteImpl, IOleClientSite_iface);
1054 }
1055
1056 static HRESULT WINAPI
1057 IOleClientSite_fnQueryInterface(IOleClientSite *me, REFIID riid, LPVOID *ppvObj)
1058 {
1059     IOleClientSiteImpl *This = impl_from_IOleClientSite(me);
1060     TRACE("%p %s\n", me, debugstr_guid(riid) );
1061
1062     *ppvObj = NULL;
1063     if (IsEqualGUID(riid, &IID_IUnknown) ||
1064         IsEqualGUID(riid, &IID_IOleClientSite))
1065         *ppvObj = me;
1066     else if (IsEqualGUID(riid, &IID_IOleWindow) ||
1067              IsEqualGUID(riid, &IID_IOleInPlaceSite))
1068         *ppvObj = &This->IOleInPlaceSite_iface;
1069     if (*ppvObj)
1070     {
1071         IOleClientSite_AddRef(me);
1072         return S_OK;
1073     }
1074     FIXME("%p: unhandled interface %s\n", me, debugstr_guid(riid) );
1075
1076     return E_NOINTERFACE;
1077 }
1078
1079 static ULONG WINAPI IOleClientSite_fnAddRef(IOleClientSite *iface)
1080 {
1081     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
1082     ULONG ref = InterlockedIncrement(&This->ref);
1083     TRACE("(%p)->(%u)\n", This, ref);
1084     return ref;
1085 }
1086
1087 static ULONG WINAPI IOleClientSite_fnRelease(IOleClientSite *iface)
1088 {
1089     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
1090     ULONG ref = InterlockedDecrement(&This->ref);
1091
1092     TRACE("(%p)->(%u)\n", This, ref);
1093
1094     if (ref == 0) {
1095         if (This->child.reole) {
1096             list_remove(&This->child.entry);
1097             This->child.reole = NULL;
1098         }
1099         heap_free(This);
1100     }
1101     return ref;
1102 }
1103
1104 static HRESULT WINAPI IOleClientSite_fnSaveObject(IOleClientSite *iface)
1105 {
1106     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
1107     if (!This->child.reole)
1108         return CO_E_RELEASED;
1109
1110     FIXME("stub %p\n", iface);
1111     return E_NOTIMPL;
1112 }
1113
1114 static HRESULT WINAPI IOleClientSite_fnGetMoniker(IOleClientSite *iface, DWORD dwAssign,
1115         DWORD dwWhichMoniker, IMoniker **ppmk)
1116 {
1117     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
1118     if (!This->child.reole)
1119         return CO_E_RELEASED;
1120
1121     FIXME("stub %p\n", iface);
1122     return E_NOTIMPL;
1123 }
1124
1125 static HRESULT WINAPI IOleClientSite_fnGetContainer(IOleClientSite *iface,
1126         IOleContainer **ppContainer)
1127 {
1128     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
1129     if (!This->child.reole)
1130         return CO_E_RELEASED;
1131
1132     FIXME("stub %p\n", iface);
1133     return E_NOTIMPL;
1134 }
1135
1136 static HRESULT WINAPI IOleClientSite_fnShowObject(IOleClientSite *iface)
1137 {
1138     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
1139     if (!This->child.reole)
1140         return CO_E_RELEASED;
1141
1142     FIXME("stub %p\n", iface);
1143     return E_NOTIMPL;
1144 }
1145
1146 static HRESULT WINAPI IOleClientSite_fnOnShowWindow(IOleClientSite *iface, BOOL fShow)
1147 {
1148     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
1149     if (!This->child.reole)
1150         return CO_E_RELEASED;
1151
1152     FIXME("stub %p\n", iface);
1153     return E_NOTIMPL;
1154 }
1155
1156 static HRESULT WINAPI IOleClientSite_fnRequestNewObjectLayout(IOleClientSite *iface)
1157 {
1158     IOleClientSiteImpl *This = impl_from_IOleClientSite(iface);
1159     if (!This->child.reole)
1160         return CO_E_RELEASED;
1161
1162     FIXME("stub %p\n", iface);
1163     return E_NOTIMPL;
1164 }
1165
1166 static const IOleClientSiteVtbl ocst = {
1167     IOleClientSite_fnQueryInterface,
1168     IOleClientSite_fnAddRef,
1169     IOleClientSite_fnRelease,
1170     IOleClientSite_fnSaveObject,
1171     IOleClientSite_fnGetMoniker,
1172     IOleClientSite_fnGetContainer,
1173     IOleClientSite_fnShowObject,
1174     IOleClientSite_fnOnShowWindow,
1175     IOleClientSite_fnRequestNewObjectLayout
1176 };
1177
1178 /* IOleInPlaceSite interface */
1179 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnQueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppvObj)
1180 {
1181     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1182     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppvObj);
1183 }
1184
1185 static ULONG STDMETHODCALLTYPE IOleInPlaceSite_fnAddRef(IOleInPlaceSite *iface)
1186 {
1187     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1188     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
1189 }
1190
1191 static ULONG STDMETHODCALLTYPE IOleInPlaceSite_fnRelease(IOleInPlaceSite *iface)
1192 {
1193     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1194     return IOleClientSite_Release(&This->IOleClientSite_iface);
1195 }
1196
1197 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnGetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1198 {
1199     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1200
1201     TRACE("(%p)->(%p)\n", This, phwnd);
1202
1203     if (!This->child.reole)
1204         return CO_E_RELEASED;
1205
1206     if (!phwnd)
1207         return E_INVALIDARG;
1208
1209     *phwnd = This->child.reole->editor->hWnd;
1210     return S_OK;
1211 }
1212
1213 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1214 {
1215     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1216     FIXME("not implemented: (%p)->(%d)\n", This, fEnterMode);
1217     return E_NOTIMPL;
1218 }
1219
1220 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnCanInPlaceActivate(IOleInPlaceSite *iface)
1221 {
1222     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1223     FIXME("not implemented: (%p)\n", This);
1224     return E_NOTIMPL;
1225 }
1226
1227 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnInPlaceActivate(IOleInPlaceSite *iface)
1228 {
1229     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1230     FIXME("not implemented: (%p)\n", This);
1231     return E_NOTIMPL;
1232 }
1233
1234 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnUIActivate(IOleInPlaceSite *iface)
1235 {
1236     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1237     FIXME("not implemented: (%p)\n", This);
1238     return E_NOTIMPL;
1239 }
1240
1241 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnGetWindowContext(IOleInPlaceSite *iface, IOleInPlaceFrame **ppFrame,
1242                                                                     IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1243                                                                     LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1244 {
1245     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1246     FIXME("not implemented: (%p)->(%p %p %p %p %p)\n", This, ppFrame, ppDoc, lprcPosRect, lprcClipRect, lpFrameInfo);
1247     return E_NOTIMPL;
1248 }
1249
1250 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnScroll(IOleInPlaceSite *iface, SIZE scrollExtent)
1251 {
1252     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1253     FIXME("not implemented: (%p)\n", This);
1254     return E_NOTIMPL;
1255 }
1256
1257 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1258 {
1259     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1260     FIXME("not implemented: (%p)->(%d)\n", This, fUndoable);
1261     return E_NOTIMPL;
1262 }
1263
1264 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnInPlaceDeactivate(IOleInPlaceSite *iface)
1265 {
1266     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1267     FIXME("not implemented: (%p)\n", This);
1268     return E_NOTIMPL;
1269 }
1270
1271 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnDiscardUndoState(IOleInPlaceSite *iface)
1272 {
1273     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1274     FIXME("not implemented: (%p)\n", This);
1275     return E_NOTIMPL;
1276 }
1277
1278 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnDeactivateAndUndo(IOleInPlaceSite *iface)
1279 {
1280     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1281     FIXME("not implemented: (%p)\n", This);
1282     return E_NOTIMPL;
1283 }
1284
1285 static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1286 {
1287     IOleClientSiteImpl *This = impl_from_IOleInPlaceSite(iface);
1288     FIXME("not implemented: (%p)->(%p)\n", This, lprcPosRect);
1289     return E_NOTIMPL;
1290 }
1291
1292 static const IOleInPlaceSiteVtbl olestvt =
1293 {
1294     IOleInPlaceSite_fnQueryInterface,
1295     IOleInPlaceSite_fnAddRef,
1296     IOleInPlaceSite_fnRelease,
1297     IOleInPlaceSite_fnGetWindow,
1298     IOleInPlaceSite_fnContextSensitiveHelp,
1299     IOleInPlaceSite_fnCanInPlaceActivate,
1300     IOleInPlaceSite_fnOnInPlaceActivate,
1301     IOleInPlaceSite_fnOnUIActivate,
1302     IOleInPlaceSite_fnGetWindowContext,
1303     IOleInPlaceSite_fnScroll,
1304     IOleInPlaceSite_fnOnUIDeactivate,
1305     IOleInPlaceSite_fnOnInPlaceDeactivate,
1306     IOleInPlaceSite_fnDiscardUndoState,
1307     IOleInPlaceSite_fnDeactivateAndUndo,
1308     IOleInPlaceSite_fnOnPosRectChange
1309 };
1310
1311 static HRESULT CreateOleClientSite(IRichEditOleImpl *reOle, IOleClientSite **ret)
1312 {
1313     IOleClientSiteImpl *clientSite = heap_alloc(sizeof *clientSite);
1314
1315     if (!clientSite)
1316         return E_OUTOFMEMORY;
1317
1318     clientSite->IOleClientSite_iface.lpVtbl = &ocst;
1319     clientSite->IOleInPlaceSite_iface.lpVtbl = &olestvt;
1320     clientSite->ref = 1;
1321     clientSite->child.reole = reOle;
1322     list_add_head(&reOle->clientsites, &clientSite->child.entry);
1323
1324     *ret = &clientSite->IOleClientSite_iface;
1325     return S_OK;
1326 }
1327
1328 static HRESULT WINAPI
1329 IRichEditOle_fnGetClientSite(IRichEditOle *me, IOleClientSite **clientsite)
1330 {
1331     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1332
1333     TRACE("(%p)->(%p)\n", This, clientsite);
1334
1335     if (!clientsite)
1336         return E_INVALIDARG;
1337
1338     return CreateOleClientSite(This, clientsite);
1339 }
1340
1341 static HRESULT WINAPI
1342 IRichEditOle_fnGetClipboardData(IRichEditOle *me, CHARRANGE *lpchrg,
1343                DWORD reco, LPDATAOBJECT *lplpdataobj)
1344 {
1345     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1346     ME_Cursor start;
1347     int nChars;
1348
1349     TRACE("(%p,%p,%d)\n",This, lpchrg, reco);
1350     if(!lplpdataobj)
1351         return E_INVALIDARG;
1352     if(!lpchrg) {
1353         int nFrom, nTo, nStartCur = ME_GetSelectionOfs(This->editor, &nFrom, &nTo);
1354         start = This->editor->pCursors[nStartCur];
1355         nChars = nTo - nFrom;
1356     } else {
1357         ME_CursorFromCharOfs(This->editor, lpchrg->cpMin, &start);
1358         nChars = lpchrg->cpMax - lpchrg->cpMin;
1359     }
1360     return ME_GetDataObject(This->editor, &start, nChars, lplpdataobj);
1361 }
1362
1363 static LONG WINAPI IRichEditOle_fnGetLinkCount(IRichEditOle *me)
1364 {
1365     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1366     FIXME("stub %p\n",This);
1367     return E_NOTIMPL;
1368 }
1369
1370 static HRESULT WINAPI
1371 IRichEditOle_fnGetObject(IRichEditOle *me, LONG iob,
1372                REOBJECT *lpreobject, DWORD dwFlags)
1373 {
1374     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1375     struct re_object *reobj = NULL;
1376     LONG count = 0;
1377
1378     TRACE("(%p)->(%x, %p, %x)\n", This, iob, lpreobject, dwFlags);
1379
1380     if (!lpreobject || !lpreobject->cbStruct)
1381         return E_INVALIDARG;
1382
1383     if (iob == REO_IOB_USE_CP)
1384     {
1385         ME_Cursor cursor;
1386
1387         TRACE("character offset: %d\n", lpreobject->cp);
1388         ME_CursorFromCharOfs(This->editor, lpreobject->cp, &cursor);
1389         if (!cursor.pRun->member.run.reobj)
1390             return E_INVALIDARG;
1391         else
1392             reobj = cursor.pRun->member.run.reobj;
1393     }
1394     else if (iob == REO_IOB_SELECTION)
1395     {
1396         ME_Cursor *from, *to;
1397
1398         ME_GetSelection(This->editor, &from, &to);
1399         if (!from->pRun->member.run.reobj)
1400             return E_INVALIDARG;
1401         else
1402             reobj = from->pRun->member.run.reobj;
1403     }
1404     else
1405     {
1406         if (iob > IRichEditOle_GetObjectCount(me))
1407             return E_INVALIDARG;
1408         LIST_FOR_EACH_ENTRY(reobj, &This->editor->reobj_list, struct re_object, entry)
1409         {
1410             if (count == iob)
1411                 break;
1412             count++;
1413         }
1414     }
1415     ME_CopyReObject(lpreobject, &reobj->obj, dwFlags);
1416     return S_OK;
1417 }
1418
1419 static LONG WINAPI
1420 IRichEditOle_fnGetObjectCount(IRichEditOle *me)
1421 {
1422     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1423     TRACE("(%p)\n",This);
1424     return list_count(&This->editor->reobj_list);
1425 }
1426
1427 static HRESULT WINAPI
1428 IRichEditOle_fnHandsOffStorage(IRichEditOle *me, LONG iob)
1429 {
1430     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1431     FIXME("stub %p\n",This);
1432     return E_NOTIMPL;
1433 }
1434
1435 static HRESULT WINAPI
1436 IRichEditOle_fnImportDataObject(IRichEditOle *me, LPDATAOBJECT lpdataobj,
1437                CLIPFORMAT cf, HGLOBAL hMetaPict)
1438 {
1439     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1440     FIXME("stub %p\n",This);
1441     return E_NOTIMPL;
1442 }
1443
1444 static HRESULT WINAPI
1445 IRichEditOle_fnInPlaceDeactivate(IRichEditOle *me)
1446 {
1447     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1448     FIXME("stub %p\n",This);
1449     return E_NOTIMPL;
1450 }
1451
1452 static HRESULT WINAPI
1453 IRichEditOle_fnInsertObject(IRichEditOle *me, REOBJECT *reo)
1454 {
1455     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1456
1457     TRACE("(%p,%p)\n", This, reo);
1458
1459     if (!reo)
1460         return E_INVALIDARG;
1461
1462     if (reo->cbStruct < sizeof(*reo)) return STG_E_INVALIDPARAMETER;
1463
1464     ME_InsertOLEFromCursor(This->editor, reo, 0);
1465     ME_CommitUndo(This->editor);
1466     ME_UpdateRepaint(This->editor, FALSE);
1467     return S_OK;
1468 }
1469
1470 static HRESULT WINAPI IRichEditOle_fnSaveCompleted(IRichEditOle *me, LONG iob,
1471                LPSTORAGE lpstg)
1472 {
1473     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1474     FIXME("stub %p\n",This);
1475     return E_NOTIMPL;
1476 }
1477
1478 static HRESULT WINAPI
1479 IRichEditOle_fnSetDvaspect(IRichEditOle *me, LONG iob, DWORD dvaspect)
1480 {
1481     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1482     FIXME("stub %p\n",This);
1483     return E_NOTIMPL;
1484 }
1485
1486 static HRESULT WINAPI IRichEditOle_fnSetHostNames(IRichEditOle *me,
1487                LPCSTR lpstrContainerApp, LPCSTR lpstrContainerObj)
1488 {
1489     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1490     FIXME("stub %p %s %s\n",This, lpstrContainerApp, lpstrContainerObj);
1491     return E_NOTIMPL;
1492 }
1493
1494 static HRESULT WINAPI
1495 IRichEditOle_fnSetLinkAvailable(IRichEditOle *me, LONG iob, BOOL fAvailable)
1496 {
1497     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
1498     FIXME("stub %p\n",This);
1499     return E_NOTIMPL;
1500 }
1501
1502 static const IRichEditOleVtbl revt = {
1503     IRichEditOle_fnQueryInterface,
1504     IRichEditOle_fnAddRef,
1505     IRichEditOle_fnRelease,
1506     IRichEditOle_fnGetClientSite,
1507     IRichEditOle_fnGetObjectCount,
1508     IRichEditOle_fnGetLinkCount,
1509     IRichEditOle_fnGetObject,
1510     IRichEditOle_fnInsertObject,
1511     IRichEditOle_fnConvertObject,
1512     IRichEditOle_fnActivateAs,
1513     IRichEditOle_fnSetHostNames,
1514     IRichEditOle_fnSetLinkAvailable,
1515     IRichEditOle_fnSetDvaspect,
1516     IRichEditOle_fnHandsOffStorage,
1517     IRichEditOle_fnSaveCompleted,
1518     IRichEditOle_fnInPlaceDeactivate,
1519     IRichEditOle_fnContextSensitiveHelp,
1520     IRichEditOle_fnGetClipboardData,
1521     IRichEditOle_fnImportDataObject
1522 };
1523
1524 /* ITextRange interface */
1525 static HRESULT WINAPI ITextRange_fnQueryInterface(ITextRange *me, REFIID riid, void **ppvObj)
1526 {
1527     ITextRangeImpl *This = impl_from_ITextRange(me);
1528
1529     *ppvObj = NULL;
1530     if (IsEqualGUID(riid, &IID_IUnknown)
1531         || IsEqualGUID(riid, &IID_IDispatch)
1532         || IsEqualGUID(riid, &IID_ITextRange))
1533     {
1534         *ppvObj = me;
1535         ITextRange_AddRef(me);
1536         return S_OK;
1537     }
1538     else if (IsEqualGUID(riid, &IID_Igetrichole))
1539     {
1540         *ppvObj = This->child.reole;
1541         return S_OK;
1542     }
1543
1544     return E_NOINTERFACE;
1545 }
1546
1547 static ULONG WINAPI ITextRange_fnAddRef(ITextRange *me)
1548 {
1549     ITextRangeImpl *This = impl_from_ITextRange(me);
1550     return InterlockedIncrement(&This->ref);
1551 }
1552
1553 static ULONG WINAPI ITextRange_fnRelease(ITextRange *me)
1554 {
1555     ITextRangeImpl *This = impl_from_ITextRange(me);
1556     ULONG ref = InterlockedDecrement(&This->ref);
1557
1558     TRACE ("%p ref=%u\n", This, ref);
1559     if (ref == 0)
1560     {
1561         if (This->child.reole)
1562         {
1563             list_remove(&This->child.entry);
1564             This->child.reole = NULL;
1565         }
1566         heap_free(This);
1567     }
1568     return ref;
1569 }
1570
1571 static HRESULT WINAPI ITextRange_fnGetTypeInfoCount(ITextRange *me, UINT *pctinfo)
1572 {
1573     ITextRangeImpl *This = impl_from_ITextRange(me);
1574     TRACE("(%p)->(%p)\n", This, pctinfo);
1575     *pctinfo = 1;
1576     return S_OK;
1577 }
1578
1579 static HRESULT WINAPI ITextRange_fnGetTypeInfo(ITextRange *me, UINT iTInfo, LCID lcid,
1580                                                ITypeInfo **ppTInfo)
1581 {
1582     ITextRangeImpl *This = impl_from_ITextRange(me);
1583     HRESULT hr;
1584
1585     TRACE("(%p)->(%u,%d,%p)\n", This, iTInfo, lcid, ppTInfo);
1586
1587     hr = get_typeinfo(ITextRange_tid, ppTInfo);
1588     if (SUCCEEDED(hr))
1589         ITypeInfo_AddRef(*ppTInfo);
1590     return hr;
1591 }
1592
1593 static HRESULT WINAPI ITextRange_fnGetIDsOfNames(ITextRange *me, REFIID riid, LPOLESTR *rgszNames,
1594                                                  UINT cNames, LCID lcid, DISPID *rgDispId)
1595 {
1596     ITextRangeImpl *This = impl_from_ITextRange(me);
1597     ITypeInfo *ti;
1598     HRESULT hr;
1599
1600     TRACE("(%p)->(%s, %p, %u, %d, %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid,
1601             rgDispId);
1602
1603     hr = get_typeinfo(ITextRange_tid, &ti);
1604     if (SUCCEEDED(hr))
1605         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
1606     return hr;
1607 }
1608
1609 static HRESULT WINAPI ITextRange_fnInvoke(ITextRange *me, DISPID dispIdMember, REFIID riid,
1610                                           LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1611                                           VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
1612                                           UINT *puArgErr)
1613 {
1614     ITextRangeImpl *This = impl_from_ITextRange(me);
1615     ITypeInfo *ti;
1616     HRESULT hr;
1617
1618     TRACE("(%p)->(%d, %s, %d, %u, %p, %p, %p, %p)\n", This, dispIdMember, debugstr_guid(riid),
1619             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1620
1621     hr = get_typeinfo(ITextRange_tid, &ti);
1622     if (SUCCEEDED(hr))
1623         hr = ITypeInfo_Invoke(ti, me, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1624     return hr;
1625 }
1626
1627 static HRESULT WINAPI ITextRange_fnGetText(ITextRange *me, BSTR *str)
1628 {
1629     ITextRangeImpl *This = impl_from_ITextRange(me);
1630     ME_TextEditor *editor;
1631     ME_Cursor start, end;
1632     int length;
1633     BOOL bEOP;
1634
1635     TRACE("(%p)->(%p)\n", This, str);
1636
1637     if (!This->child.reole)
1638         return CO_E_RELEASED;
1639
1640     if (!str)
1641         return E_INVALIDARG;
1642
1643     /* return early for degenerate range */
1644     if (This->start == This->end) {
1645         *str = NULL;
1646         return S_OK;
1647     }
1648
1649     editor = This->child.reole->editor;
1650     ME_CursorFromCharOfs(editor, This->start, &start);
1651     ME_CursorFromCharOfs(editor, This->end, &end);
1652
1653     length = This->end - This->start;
1654     *str = SysAllocStringLen(NULL, length);
1655     if (!*str)
1656         return E_OUTOFMEMORY;
1657
1658     bEOP = (end.pRun->next->type == diTextEnd && This->end > ME_GetTextLength(editor));
1659     ME_GetTextW(editor, *str, length, &start, length, FALSE, bEOP);
1660     return S_OK;
1661 }
1662
1663 static HRESULT WINAPI ITextRange_fnSetText(ITextRange *me, BSTR str)
1664 {
1665     ITextRangeImpl *This = impl_from_ITextRange(me);
1666     ME_TextEditor *editor;
1667     ME_Cursor cursor;
1668     ME_Style *style;
1669     int len;
1670
1671     TRACE("(%p)->(%s)\n", This, debugstr_w(str));
1672
1673     if (!This->child.reole)
1674         return CO_E_RELEASED;
1675
1676     editor = This->child.reole->editor;
1677
1678     /* delete only where's something to delete */
1679     if (This->start != This->end) {
1680         ME_CursorFromCharOfs(editor, This->start, &cursor);
1681         ME_InternalDeleteText(editor, &cursor, This->end - This->start, FALSE);
1682     }
1683
1684     if (!str || !*str) {
1685         /* will update this range as well */
1686         textranges_update_ranges(This->child.reole, This->start, This->end, RANGE_UPDATE_DELETE);
1687         return S_OK;
1688     }
1689
1690     /* it's safer not to rely on stored BSTR length */
1691     len = lstrlenW(str);
1692     cursor = editor->pCursors[0];
1693     ME_CursorFromCharOfs(editor, This->start, &editor->pCursors[0]);
1694     style = ME_GetInsertStyle(editor, 0);
1695     ME_InsertTextFromCursor(editor, 0, str, len, style);
1696     ME_ReleaseStyle(style);
1697     editor->pCursors[0] = cursor;
1698
1699     if (len < This->end - This->start)
1700         textranges_update_ranges(This->child.reole, This->start + len, This->end, RANGE_UPDATE_DELETE);
1701     else
1702         This->end = len - This->start;
1703
1704     return S_OK;
1705 }
1706
1707 static HRESULT range_GetChar(ME_TextEditor *editor, ME_Cursor *cursor, LONG *pch)
1708 {
1709     WCHAR wch[2];
1710
1711     ME_GetTextW(editor, wch, 1, cursor, 1, FALSE, cursor->pRun->next->type == diTextEnd);
1712     *pch = wch[0];
1713
1714     return S_OK;
1715 }
1716
1717 static HRESULT WINAPI ITextRange_fnGetChar(ITextRange *me, LONG *pch)
1718 {
1719     ITextRangeImpl *This = impl_from_ITextRange(me);
1720     ME_TextEditor *editor;
1721     ME_Cursor cursor;
1722
1723     TRACE("(%p)->(%p)\n", This, pch);
1724
1725     if (!This->child.reole)
1726         return CO_E_RELEASED;
1727
1728     if (!pch)
1729         return E_INVALIDARG;
1730
1731     editor = This->child.reole->editor;
1732     ME_CursorFromCharOfs(editor, This->start, &cursor);
1733     return range_GetChar(editor, &cursor, pch);
1734 }
1735
1736 static HRESULT WINAPI ITextRange_fnSetChar(ITextRange *me, LONG ch)
1737 {
1738     ITextRangeImpl *This = impl_from_ITextRange(me);
1739
1740     FIXME("(%p)->(%x): stub\n", This, ch);
1741
1742     if (!This->child.reole)
1743         return CO_E_RELEASED;
1744
1745     return E_NOTIMPL;
1746 }
1747
1748 static HRESULT CreateITextRange(IRichEditOleImpl *reOle, LONG start, LONG end, ITextRange** ppRange);
1749
1750 static HRESULT WINAPI ITextRange_fnGetDuplicate(ITextRange *me, ITextRange **ppRange)
1751 {
1752     ITextRangeImpl *This = impl_from_ITextRange(me);
1753
1754     TRACE("(%p)->(%p)\n", This, ppRange);
1755
1756     if (!This->child.reole)
1757         return CO_E_RELEASED;
1758
1759     if (!ppRange)
1760         return E_INVALIDARG;
1761
1762     return CreateITextRange(This->child.reole, This->start, This->end, ppRange);
1763 }
1764
1765 static HRESULT WINAPI ITextRange_fnGetFormattedText(ITextRange *me, ITextRange **range)
1766 {
1767     ITextRangeImpl *This = impl_from_ITextRange(me);
1768
1769     FIXME("(%p)->(%p): stub\n", This, range);
1770
1771     if (!This->child.reole)
1772         return CO_E_RELEASED;
1773
1774     return E_NOTIMPL;
1775 }
1776
1777 static HRESULT WINAPI ITextRange_fnSetFormattedText(ITextRange *me, ITextRange *range)
1778 {
1779     ITextRangeImpl *This = impl_from_ITextRange(me);
1780
1781     FIXME("(%p)->(%p): stub\n", This, range);
1782
1783     if (!This->child.reole)
1784         return CO_E_RELEASED;
1785
1786     return E_NOTIMPL;
1787 }
1788
1789 static HRESULT WINAPI ITextRange_fnGetStart(ITextRange *me, LONG *start)
1790 {
1791     ITextRangeImpl *This = impl_from_ITextRange(me);
1792
1793     TRACE("(%p)->(%p)\n", This, start);
1794
1795     if (!This->child.reole)
1796         return CO_E_RELEASED;
1797
1798     if (!start)
1799         return E_INVALIDARG;
1800
1801     *start = This->start;
1802     return S_OK;
1803 }
1804
1805 static HRESULT textrange_setstart(const IRichEditOleImpl *reole, LONG value, LONG *start, LONG *end)
1806 {
1807     int len;
1808
1809     if (value < 0)
1810         value = 0;
1811
1812     if (value == *start)
1813         return S_FALSE;
1814
1815     if (value <= *end) {
1816         *start = value;
1817         return S_OK;
1818     }
1819
1820     len = ME_GetTextLength(reole->editor);
1821     *start = *end = value > len ? len : value;
1822     return S_OK;
1823 }
1824
1825 static HRESULT WINAPI ITextRange_fnSetStart(ITextRange *me, LONG value)
1826 {
1827     ITextRangeImpl *This = impl_from_ITextRange(me);
1828
1829     TRACE("(%p)->(%d)\n", This, value);
1830
1831     if (!This->child.reole)
1832         return CO_E_RELEASED;
1833
1834     return textrange_setstart(This->child.reole, value, &This->start, &This->end);
1835 }
1836
1837 static HRESULT WINAPI ITextRange_fnGetEnd(ITextRange *me, LONG *end)
1838 {
1839     ITextRangeImpl *This = impl_from_ITextRange(me);
1840
1841     TRACE("(%p)->(%p)\n", This, end);
1842
1843     if (!This->child.reole)
1844         return CO_E_RELEASED;
1845
1846     if (!end)
1847         return E_INVALIDARG;
1848
1849     *end = This->end;
1850     return S_OK;
1851 }
1852
1853 static HRESULT textrange_setend(const IRichEditOleImpl *reole, LONG value, LONG *start, LONG *end)
1854 {
1855     int len;
1856
1857     if (value == *end)
1858         return S_FALSE;
1859
1860     if (value < *start) {
1861         *start = *end = max(0, value);
1862         return S_OK;
1863     }
1864
1865     len = ME_GetTextLength(reole->editor);
1866     *end = value > len ? len + 1 : value;
1867     return S_OK;
1868 }
1869
1870 static HRESULT WINAPI ITextRange_fnSetEnd(ITextRange *me, LONG value)
1871 {
1872     ITextRangeImpl *This = impl_from_ITextRange(me);
1873
1874     TRACE("(%p)->(%d)\n", This, value);
1875
1876     if (!This->child.reole)
1877         return CO_E_RELEASED;
1878
1879     return textrange_setend(This->child.reole, value, &This->start, &This->end);
1880 }
1881
1882 static HRESULT WINAPI ITextRange_fnGetFont(ITextRange *me, ITextFont **font)
1883 {
1884     ITextRangeImpl *This = impl_from_ITextRange(me);
1885
1886     TRACE("(%p)->(%p)\n", This, font);
1887
1888     if (!This->child.reole)
1889         return CO_E_RELEASED;
1890
1891     if (!font)
1892         return E_INVALIDARG;
1893
1894     return create_textfont(me, NULL, font);
1895 }
1896
1897 static HRESULT WINAPI ITextRange_fnSetFont(ITextRange *me, ITextFont *font)
1898 {
1899     ITextRangeImpl *This = impl_from_ITextRange(me);
1900
1901     TRACE("(%p)->(%p)\n", This, font);
1902
1903     if (!font)
1904         return E_INVALIDARG;
1905
1906     if (!This->child.reole)
1907         return CO_E_RELEASED;
1908
1909     textrange_set_font(me, font);
1910     return S_OK;
1911 }
1912
1913 static HRESULT WINAPI ITextRange_fnGetPara(ITextRange *me, ITextPara **para)
1914 {
1915     ITextRangeImpl *This = impl_from_ITextRange(me);
1916
1917     TRACE("(%p)->(%p)\n", This, para);
1918
1919     if (!This->child.reole)
1920         return CO_E_RELEASED;
1921
1922     if (!para)
1923         return E_INVALIDARG;
1924
1925     return create_textpara(me, para);
1926 }
1927
1928 static HRESULT WINAPI ITextRange_fnSetPara(ITextRange *me, ITextPara *para)
1929 {
1930     ITextRangeImpl *This = impl_from_ITextRange(me);
1931
1932     FIXME("(%p)->(%p): stub\n", This, para);
1933
1934     if (!This->child.reole)
1935         return CO_E_RELEASED;
1936
1937     return E_NOTIMPL;
1938 }
1939
1940 static HRESULT WINAPI ITextRange_fnGetStoryLength(ITextRange *me, LONG *length)
1941 {
1942     ITextRangeImpl *This = impl_from_ITextRange(me);
1943
1944     TRACE("(%p)->(%p)\n", This, length);
1945
1946     if (!This->child.reole)
1947         return CO_E_RELEASED;
1948
1949     return textrange_get_storylength(This->child.reole->editor, length);
1950 }
1951
1952 static HRESULT WINAPI ITextRange_fnGetStoryType(ITextRange *me, LONG *value)
1953 {
1954     ITextRangeImpl *This = impl_from_ITextRange(me);
1955
1956     TRACE("(%p)->(%p)\n", This, value);
1957
1958     if (!This->child.reole)
1959         return CO_E_RELEASED;
1960
1961     if (!value)
1962         return E_INVALIDARG;
1963
1964     *value = tomUnknownStory;
1965     return S_OK;
1966 }
1967
1968 static HRESULT range_Collapse(LONG bStart, LONG *start, LONG *end)
1969 {
1970   if (*end == *start)
1971       return S_FALSE;
1972
1973   if (bStart == tomEnd)
1974       *start = *end;
1975   else
1976       *end = *start;
1977   return S_OK;
1978 }
1979
1980 static HRESULT WINAPI ITextRange_fnCollapse(ITextRange *me, LONG bStart)
1981 {
1982     ITextRangeImpl *This = impl_from_ITextRange(me);
1983
1984     TRACE("(%p)->(%d)\n", This, bStart);
1985
1986     if (!This->child.reole)
1987         return CO_E_RELEASED;
1988
1989     return range_Collapse(bStart, &This->start, &This->end);
1990 }
1991
1992 static HRESULT WINAPI ITextRange_fnExpand(ITextRange *me, LONG unit, LONG *delta)
1993 {
1994     ITextRangeImpl *This = impl_from_ITextRange(me);
1995
1996     TRACE("(%p)->(%d %p)\n", This, unit, delta);
1997
1998     if (!This->child.reole)
1999         return CO_E_RELEASED;
2000
2001     return textrange_expand(me, unit, delta);
2002 }
2003
2004 static HRESULT WINAPI ITextRange_fnGetIndex(ITextRange *me, LONG unit, LONG *index)
2005 {
2006     ITextRangeImpl *This = impl_from_ITextRange(me);
2007
2008     FIXME("(%p)->(%d %p): stub\n", This, unit, index);
2009
2010     if (!This->child.reole)
2011         return CO_E_RELEASED;
2012
2013     return E_NOTIMPL;
2014 }
2015
2016 static HRESULT WINAPI ITextRange_fnSetIndex(ITextRange *me, LONG unit, LONG index,
2017                                             LONG extend)
2018 {
2019     ITextRangeImpl *This = impl_from_ITextRange(me);
2020
2021     FIXME("(%p)->(%d %d %d): stub\n", This, unit, index, extend);
2022
2023     if (!This->child.reole)
2024         return CO_E_RELEASED;
2025
2026     return E_NOTIMPL;
2027 }
2028
2029 static void cp2range(ME_TextEditor *editor, LONG *cp1, LONG *cp2)
2030 {
2031     int len = ME_GetTextLength(editor) + 1;
2032
2033     *cp1 = max(*cp1, 0);
2034     *cp2 = max(*cp2, 0);
2035     *cp1 = min(*cp1, len);
2036     *cp2 = min(*cp2, len);
2037     if (*cp1 > *cp2)
2038     {
2039         int tmp = *cp1;
2040         *cp1 = *cp2;
2041         *cp2 = tmp;
2042     }
2043     if (*cp1 == len)
2044         *cp1 = *cp2 = len - 1;
2045 }
2046
2047 static HRESULT WINAPI ITextRange_fnSetRange(ITextRange *me, LONG anchor, LONG active)
2048 {
2049     ITextRangeImpl *This = impl_from_ITextRange(me);
2050
2051     TRACE("(%p)->(%d %d)\n", This, anchor, active);
2052
2053     if (!This->child.reole)
2054         return CO_E_RELEASED;
2055
2056     cp2range(This->child.reole->editor, &anchor, &active);
2057     if (anchor == This->start && active == This->end)
2058         return S_FALSE;
2059
2060     This->start = anchor;
2061     This->end = active;
2062     return S_OK;
2063 }
2064
2065 static HRESULT textrange_inrange(LONG start, LONG end, ITextRange *range, LONG *ret)
2066 {
2067     LONG from, to, v;
2068
2069     if (!ret)
2070         ret = &v;
2071
2072     if (FAILED(ITextRange_GetStart(range, &from)) || FAILED(ITextRange_GetEnd(range, &to))) {
2073         *ret = tomFalse;
2074     }
2075     else
2076         *ret = (start >= from && end <= to) ? tomTrue : tomFalse;
2077     return *ret == tomTrue ? S_OK : S_FALSE;
2078 }
2079
2080 static HRESULT WINAPI ITextRange_fnInRange(ITextRange *me, ITextRange *range, LONG *ret)
2081 {
2082     ITextRangeImpl *This = impl_from_ITextRange(me);
2083
2084     TRACE("(%p)->(%p %p)\n", This, range, ret);
2085
2086     if (ret)
2087         *ret = tomFalse;
2088
2089     if (!This->child.reole)
2090         return CO_E_RELEASED;
2091
2092     if (!range)
2093         return S_FALSE;
2094
2095     return textrange_inrange(This->start, This->end, range, ret);
2096 }
2097
2098 static HRESULT WINAPI ITextRange_fnInStory(ITextRange *me, ITextRange *pRange, LONG *ret)
2099 {
2100     ITextRangeImpl *This = impl_from_ITextRange(me);
2101
2102     FIXME("(%p)->(%p): stub\n", This, ret);
2103
2104     if (!This->child.reole)
2105         return CO_E_RELEASED;
2106
2107     return E_NOTIMPL;
2108 }
2109
2110 static HRESULT textrange_isequal(LONG start, LONG end, ITextRange *range, LONG *ret)
2111 {
2112     LONG from, to, v;
2113
2114     if (!ret)
2115         ret = &v;
2116
2117     if (FAILED(ITextRange_GetStart(range, &from)) || FAILED(ITextRange_GetEnd(range, &to))) {
2118         *ret = tomFalse;
2119     }
2120     else
2121         *ret = (start == from && end == to) ? tomTrue : tomFalse;
2122     return *ret == tomTrue ? S_OK : S_FALSE;
2123 }
2124
2125 static HRESULT WINAPI ITextRange_fnIsEqual(ITextRange *me, ITextRange *range, LONG *ret)
2126 {
2127     ITextRangeImpl *This = impl_from_ITextRange(me);
2128
2129     TRACE("(%p)->(%p %p)\n", This, range, ret);
2130
2131     if (ret)
2132         *ret = tomFalse;
2133
2134     if (!This->child.reole)
2135         return CO_E_RELEASED;
2136
2137     if (!range)
2138         return S_FALSE;
2139
2140     return textrange_isequal(This->start, This->end, range, ret);
2141 }
2142
2143 static HRESULT WINAPI ITextRange_fnSelect(ITextRange *me)
2144 {
2145     ITextRangeImpl *This = impl_from_ITextRange(me);
2146
2147     TRACE("(%p)\n", This);
2148
2149     if (!This->child.reole)
2150         return CO_E_RELEASED;
2151
2152     set_selection(This->child.reole->editor, This->start, This->end);
2153     return S_OK;
2154 }
2155
2156 static HRESULT WINAPI ITextRange_fnStartOf(ITextRange *me, LONG unit, LONG extend,
2157                                            LONG *delta)
2158 {
2159     ITextRangeImpl *This = impl_from_ITextRange(me);
2160
2161     FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
2162
2163     if (!This->child.reole)
2164         return CO_E_RELEASED;
2165
2166     return E_NOTIMPL;
2167 }
2168
2169 static HRESULT WINAPI ITextRange_fnEndOf(ITextRange *me, LONG unit, LONG extend,
2170                                          LONG *delta)
2171 {
2172     ITextRangeImpl *This = impl_from_ITextRange(me);
2173
2174     FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
2175
2176     if (!This->child.reole)
2177         return CO_E_RELEASED;
2178
2179     return E_NOTIMPL;
2180 }
2181
2182 static HRESULT WINAPI ITextRange_fnMove(ITextRange *me, LONG unit, LONG count, LONG *delta)
2183 {
2184     ITextRangeImpl *This = impl_from_ITextRange(me);
2185
2186     FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
2187
2188     if (!This->child.reole)
2189         return CO_E_RELEASED;
2190
2191     return E_NOTIMPL;
2192 }
2193
2194 static HRESULT WINAPI ITextRange_fnMoveStart(ITextRange *me, LONG unit, LONG count,
2195                                              LONG *delta)
2196 {
2197     ITextRangeImpl *This = impl_from_ITextRange(me);
2198
2199     FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
2200
2201     if (!This->child.reole)
2202         return CO_E_RELEASED;
2203
2204     return E_NOTIMPL;
2205 }
2206
2207 static HRESULT textrange_moveend(ITextRange *range, LONG unit, LONG count, LONG *delta)
2208 {
2209     LONG old_start, old_end, new_start, new_end;
2210     HRESULT hr = S_OK;
2211
2212     if (!count)
2213     {
2214         if (delta)
2215             *delta = 0;
2216         return S_FALSE;
2217     }
2218
2219     ITextRange_GetStart(range, &old_start);
2220     ITextRange_GetEnd(range, &old_end);
2221     switch (unit)
2222     {
2223     case tomStory:
2224         if (count < 0)
2225             new_start = new_end = 0;
2226         else
2227         {
2228             new_start = old_start;
2229             ITextRange_GetStoryLength(range, &new_end);
2230         }
2231         if (delta)
2232         {
2233             if (new_end < old_end)
2234                 *delta = -1;
2235             else if (new_end == old_end)
2236                 *delta = 0;
2237             else
2238                 *delta = 1;
2239         }
2240         break;
2241     default:
2242         FIXME("unit %d is not supported\n", unit);
2243         return E_NOTIMPL;
2244     }
2245     if (new_end == old_end)
2246         hr = S_FALSE;
2247     ITextRange_SetStart(range, new_start);
2248     ITextRange_SetEnd(range, new_end);
2249
2250     return hr;
2251 }
2252
2253 static HRESULT WINAPI ITextRange_fnMoveEnd(ITextRange *me, LONG unit, LONG count,
2254                                            LONG *delta)
2255 {
2256     ITextRangeImpl *This = impl_from_ITextRange(me);
2257
2258     TRACE("(%p)->(%d %d %p)\n", This, unit, count, delta);
2259
2260     if (!This->child.reole)
2261         return CO_E_RELEASED;
2262
2263     return textrange_moveend(me, unit, count, delta);
2264 }
2265
2266 static HRESULT WINAPI ITextRange_fnMoveWhile(ITextRange *me, VARIANT *charset, LONG count,
2267                                              LONG *delta)
2268 {
2269     ITextRangeImpl *This = impl_from_ITextRange(me);
2270
2271     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
2272
2273     if (!This->child.reole)
2274         return CO_E_RELEASED;
2275
2276     return E_NOTIMPL;
2277 }
2278
2279 static HRESULT WINAPI ITextRange_fnMoveStartWhile(ITextRange *me, VARIANT *charset, LONG count,
2280                                                   LONG *delta)
2281 {
2282     ITextRangeImpl *This = impl_from_ITextRange(me);
2283
2284     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
2285
2286     if (!This->child.reole)
2287         return CO_E_RELEASED;
2288
2289     return E_NOTIMPL;
2290 }
2291
2292 static HRESULT WINAPI ITextRange_fnMoveEndWhile(ITextRange *me, VARIANT *charset, LONG count,
2293                                                 LONG *delta)
2294 {
2295     ITextRangeImpl *This = impl_from_ITextRange(me);
2296
2297     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
2298
2299     if (!This->child.reole)
2300         return CO_E_RELEASED;
2301
2302     return E_NOTIMPL;
2303 }
2304
2305 static HRESULT WINAPI ITextRange_fnMoveUntil(ITextRange *me, VARIANT *charset, LONG count,
2306                                              LONG *delta)
2307 {
2308     ITextRangeImpl *This = impl_from_ITextRange(me);
2309
2310     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
2311
2312     if (!This->child.reole)
2313         return CO_E_RELEASED;
2314
2315     return E_NOTIMPL;
2316 }
2317
2318 static HRESULT WINAPI ITextRange_fnMoveStartUntil(ITextRange *me, VARIANT *charset, LONG count,
2319                                                   LONG *delta)
2320 {
2321     ITextRangeImpl *This = impl_from_ITextRange(me);
2322
2323     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
2324
2325     if (!This->child.reole)
2326         return CO_E_RELEASED;
2327
2328     return E_NOTIMPL;
2329 }
2330
2331 static HRESULT WINAPI ITextRange_fnMoveEndUntil(ITextRange *me, VARIANT *charset, LONG count,
2332                                                 LONG *delta)
2333 {
2334     ITextRangeImpl *This = impl_from_ITextRange(me);
2335
2336     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
2337
2338     if (!This->child.reole)
2339         return CO_E_RELEASED;
2340
2341     return E_NOTIMPL;
2342 }
2343
2344 static HRESULT WINAPI ITextRange_fnFindText(ITextRange *me, BSTR text, LONG count, LONG flags,
2345                                             LONG *length)
2346 {
2347     ITextRangeImpl *This = impl_from_ITextRange(me);
2348
2349     FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
2350
2351     if (!This->child.reole)
2352         return CO_E_RELEASED;
2353
2354     return E_NOTIMPL;
2355 }
2356
2357 static HRESULT WINAPI ITextRange_fnFindTextStart(ITextRange *me, BSTR text, LONG count,
2358                                                  LONG flags, LONG *length)
2359 {
2360     ITextRangeImpl *This = impl_from_ITextRange(me);
2361
2362     FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
2363
2364     if (!This->child.reole)
2365         return CO_E_RELEASED;
2366
2367     return E_NOTIMPL;
2368 }
2369
2370 static HRESULT WINAPI ITextRange_fnFindTextEnd(ITextRange *me, BSTR text, LONG count,
2371                                                LONG flags, LONG *length)
2372 {
2373     ITextRangeImpl *This = impl_from_ITextRange(me);
2374
2375     FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
2376
2377     if (!This->child.reole)
2378         return CO_E_RELEASED;
2379
2380     return E_NOTIMPL;
2381 }
2382
2383 static HRESULT WINAPI ITextRange_fnDelete(ITextRange *me, LONG unit, LONG count, LONG *delta)
2384 {
2385     ITextRangeImpl *This = impl_from_ITextRange(me);
2386
2387     FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
2388
2389     if (!This->child.reole)
2390         return CO_E_RELEASED;
2391
2392     return E_NOTIMPL;
2393 }
2394
2395 static HRESULT WINAPI ITextRange_fnCut(ITextRange *me, VARIANT *v)
2396 {
2397     ITextRangeImpl *This = impl_from_ITextRange(me);
2398
2399     FIXME("(%p)->(%p): stub\n", This, v);
2400
2401     if (!This->child.reole)
2402         return CO_E_RELEASED;
2403
2404     return E_NOTIMPL;
2405 }
2406
2407 static HRESULT WINAPI ITextRange_fnCopy(ITextRange *me, VARIANT *v)
2408 {
2409     ITextRangeImpl *This = impl_from_ITextRange(me);
2410
2411     FIXME("(%p)->(%p): stub\n", This, v);
2412
2413     if (!This->child.reole)
2414         return CO_E_RELEASED;
2415
2416     return E_NOTIMPL;
2417 }
2418
2419 static HRESULT WINAPI ITextRange_fnPaste(ITextRange *me, VARIANT *v, LONG format)
2420 {
2421     ITextRangeImpl *This = impl_from_ITextRange(me);
2422
2423     FIXME("(%p)->(%s %x): stub\n", This, debugstr_variant(v), format);
2424
2425     if (!This->child.reole)
2426         return CO_E_RELEASED;
2427
2428     return E_NOTIMPL;
2429 }
2430
2431 static HRESULT WINAPI ITextRange_fnCanPaste(ITextRange *me, VARIANT *v, LONG format, LONG *ret)
2432 {
2433     ITextRangeImpl *This = impl_from_ITextRange(me);
2434
2435     FIXME("(%p)->(%s %x %p): stub\n", This, debugstr_variant(v), format, ret);
2436
2437     if (!This->child.reole)
2438         return CO_E_RELEASED;
2439
2440     return E_NOTIMPL;
2441 }
2442
2443 static HRESULT WINAPI ITextRange_fnCanEdit(ITextRange *me, LONG *ret)
2444 {
2445     ITextRangeImpl *This = impl_from_ITextRange(me);
2446
2447     FIXME("(%p)->(%p): stub\n", This, ret);
2448
2449     if (!This->child.reole)
2450         return CO_E_RELEASED;
2451
2452     return E_NOTIMPL;
2453 }
2454
2455 static HRESULT WINAPI ITextRange_fnChangeCase(ITextRange *me, LONG type)
2456 {
2457     ITextRangeImpl *This = impl_from_ITextRange(me);
2458
2459     FIXME("(%p)->(%d): stub\n", This, type);
2460
2461     if (!This->child.reole)
2462         return CO_E_RELEASED;
2463
2464     return E_NOTIMPL;
2465 }
2466
2467 static HRESULT WINAPI ITextRange_fnGetPoint(ITextRange *me, LONG type, LONG *cx, LONG *cy)
2468 {
2469     ITextRangeImpl *This = impl_from_ITextRange(me);
2470
2471     FIXME("(%p)->(%d %p %p): stub\n", This, type, cx, cy);
2472
2473     if (!This->child.reole)
2474         return CO_E_RELEASED;
2475
2476     return E_NOTIMPL;
2477 }
2478
2479 static HRESULT WINAPI ITextRange_fnSetPoint(ITextRange *me, LONG x, LONG y, LONG type,
2480                                             LONG extend)
2481 {
2482     ITextRangeImpl *This = impl_from_ITextRange(me);
2483
2484     FIXME("(%p)->(%d %d %d %d): stub\n", This, x, y, type, extend);
2485
2486     if (!This->child.reole)
2487         return CO_E_RELEASED;
2488
2489     return E_NOTIMPL;
2490 }
2491
2492 static HRESULT WINAPI ITextRange_fnScrollIntoView(ITextRange *me, LONG value)
2493 {
2494     ITextRangeImpl *This = impl_from_ITextRange(me);
2495     ME_TextEditor *editor;
2496     ME_Cursor cursor;
2497     int x, y, height;
2498
2499     TRACE("(%p)->(%d)\n", This, value);
2500
2501     if (!This->child.reole)
2502         return CO_E_RELEASED;
2503
2504     editor = This->child.reole->editor;
2505
2506     switch (value)
2507     {
2508     case tomStart:
2509         ME_CursorFromCharOfs(editor, This->start, &cursor);
2510         ME_GetCursorCoordinates(editor, &cursor, &x, &y, &height);
2511         break;
2512     case tomEnd:
2513         ME_CursorFromCharOfs(editor, This->end, &cursor);
2514         ME_GetCursorCoordinates(editor, &cursor, &x, &y, &height);
2515         break;
2516     default:
2517         FIXME("bStart value %d not handled\n", value);
2518         return E_NOTIMPL;
2519     }
2520     ME_ScrollAbs(editor, x, y);
2521     return S_OK;
2522 }
2523
2524 static HRESULT WINAPI ITextRange_fnGetEmbeddedObject(ITextRange *me, IUnknown **ppv)
2525 {
2526     ITextRangeImpl *This = impl_from_ITextRange(me);
2527
2528     FIXME("(%p)->(%p): stub\n", This, ppv);
2529
2530     if (!This->child.reole)
2531         return CO_E_RELEASED;
2532
2533     return E_NOTIMPL;
2534 }
2535
2536 static const ITextRangeVtbl trvt = {
2537     ITextRange_fnQueryInterface,
2538     ITextRange_fnAddRef,
2539     ITextRange_fnRelease,
2540     ITextRange_fnGetTypeInfoCount,
2541     ITextRange_fnGetTypeInfo,
2542     ITextRange_fnGetIDsOfNames,
2543     ITextRange_fnInvoke,
2544     ITextRange_fnGetText,
2545     ITextRange_fnSetText,
2546     ITextRange_fnGetChar,
2547     ITextRange_fnSetChar,
2548     ITextRange_fnGetDuplicate,
2549     ITextRange_fnGetFormattedText,
2550     ITextRange_fnSetFormattedText,
2551     ITextRange_fnGetStart,
2552     ITextRange_fnSetStart,
2553     ITextRange_fnGetEnd,
2554     ITextRange_fnSetEnd,
2555     ITextRange_fnGetFont,
2556     ITextRange_fnSetFont,
2557     ITextRange_fnGetPara,
2558     ITextRange_fnSetPara,
2559     ITextRange_fnGetStoryLength,
2560     ITextRange_fnGetStoryType,
2561     ITextRange_fnCollapse,
2562     ITextRange_fnExpand,
2563     ITextRange_fnGetIndex,
2564     ITextRange_fnSetIndex,
2565     ITextRange_fnSetRange,
2566     ITextRange_fnInRange,
2567     ITextRange_fnInStory,
2568     ITextRange_fnIsEqual,
2569     ITextRange_fnSelect,
2570     ITextRange_fnStartOf,
2571     ITextRange_fnEndOf,
2572     ITextRange_fnMove,
2573     ITextRange_fnMoveStart,
2574     ITextRange_fnMoveEnd,
2575     ITextRange_fnMoveWhile,
2576     ITextRange_fnMoveStartWhile,
2577     ITextRange_fnMoveEndWhile,
2578     ITextRange_fnMoveUntil,
2579     ITextRange_fnMoveStartUntil,
2580     ITextRange_fnMoveEndUntil,
2581     ITextRange_fnFindText,
2582     ITextRange_fnFindTextStart,
2583     ITextRange_fnFindTextEnd,
2584     ITextRange_fnDelete,
2585     ITextRange_fnCut,
2586     ITextRange_fnCopy,
2587     ITextRange_fnPaste,
2588     ITextRange_fnCanPaste,
2589     ITextRange_fnCanEdit,
2590     ITextRange_fnChangeCase,
2591     ITextRange_fnGetPoint,
2592     ITextRange_fnSetPoint,
2593     ITextRange_fnScrollIntoView,
2594     ITextRange_fnGetEmbeddedObject
2595 };
2596
2597 /* ITextFont */
2598 static HRESULT WINAPI TextFont_QueryInterface(ITextFont *iface, REFIID riid, void **ppv)
2599 {
2600     ITextFontImpl *This = impl_from_ITextFont(iface);
2601
2602     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
2603
2604     if (IsEqualIID(riid, &IID_ITextFont) ||
2605         IsEqualIID(riid, &IID_IDispatch) ||
2606         IsEqualIID(riid, &IID_IUnknown))
2607     {
2608         *ppv = iface;
2609         ITextFont_AddRef(iface);
2610         return S_OK;
2611     }
2612
2613     *ppv = NULL;
2614     return E_NOINTERFACE;
2615 }
2616
2617 static ULONG WINAPI TextFont_AddRef(ITextFont *iface)
2618 {
2619     ITextFontImpl *This = impl_from_ITextFont(iface);
2620     ULONG ref = InterlockedIncrement(&This->ref);
2621     TRACE("(%p)->(%u)\n", This, ref);
2622     return ref;
2623 }
2624
2625 static ULONG WINAPI TextFont_Release(ITextFont *iface)
2626 {
2627     ITextFontImpl *This = impl_from_ITextFont(iface);
2628     ULONG ref = InterlockedDecrement(&This->ref);
2629
2630     TRACE("(%p)->(%u)\n", This, ref);
2631
2632     if (!ref)
2633     {
2634         if (This->range)
2635             ITextRange_Release(This->range);
2636         SysFreeString(This->props[FONT_NAME].str);
2637         heap_free(This);
2638     }
2639
2640     return ref;
2641 }
2642
2643 static HRESULT WINAPI TextFont_GetTypeInfoCount(ITextFont *iface, UINT *pctinfo)
2644 {
2645     ITextFontImpl *This = impl_from_ITextFont(iface);
2646     TRACE("(%p)->(%p)\n", This, pctinfo);
2647     *pctinfo = 1;
2648     return S_OK;
2649 }
2650
2651 static HRESULT WINAPI TextFont_GetTypeInfo(ITextFont *iface, UINT iTInfo, LCID lcid,
2652     ITypeInfo **ppTInfo)
2653 {
2654     ITextFontImpl *This = impl_from_ITextFont(iface);
2655     HRESULT hr;
2656
2657     TRACE("(%p)->(%u,%d,%p)\n", This, iTInfo, lcid, ppTInfo);
2658
2659     hr = get_typeinfo(ITextFont_tid, ppTInfo);
2660     if (SUCCEEDED(hr))
2661         ITypeInfo_AddRef(*ppTInfo);
2662     return hr;
2663 }
2664
2665 static HRESULT WINAPI TextFont_GetIDsOfNames(ITextFont *iface, REFIID riid,
2666     LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2667 {
2668     ITextFontImpl *This = impl_from_ITextFont(iface);
2669     ITypeInfo *ti;
2670     HRESULT hr;
2671
2672     TRACE("(%p)->(%s, %p, %u, %d, %p)\n", This, debugstr_guid(riid),
2673             rgszNames, cNames, lcid, rgDispId);
2674
2675     hr = get_typeinfo(ITextFont_tid, &ti);
2676     if (SUCCEEDED(hr))
2677         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
2678     return hr;
2679 }
2680
2681 static HRESULT WINAPI TextFont_Invoke(
2682     ITextFont *iface,
2683     DISPID dispIdMember,
2684     REFIID riid,
2685     LCID lcid,
2686     WORD wFlags,
2687     DISPPARAMS *pDispParams,
2688     VARIANT *pVarResult,
2689     EXCEPINFO *pExcepInfo,
2690     UINT *puArgErr)
2691 {
2692     ITextFontImpl *This = impl_from_ITextFont(iface);
2693     ITypeInfo *ti;
2694     HRESULT hr;
2695
2696     TRACE("(%p)->(%d, %s, %d, %u, %p, %p, %p, %p)\n", This, dispIdMember, debugstr_guid(riid),
2697             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2698
2699     hr = get_typeinfo(ITextFont_tid, &ti);
2700     if (SUCCEEDED(hr))
2701         hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2702     return hr;
2703 }
2704
2705 static HRESULT WINAPI TextFont_GetDuplicate(ITextFont *iface, ITextFont **ret)
2706 {
2707     ITextFontImpl *This = impl_from_ITextFont(iface);
2708
2709     TRACE("(%p)->(%p)\n", This, ret);
2710
2711     if (!ret)
2712         return E_INVALIDARG;
2713
2714     *ret = NULL;
2715     if (This->range && !get_range_reole(This->range))
2716         return CO_E_RELEASED;
2717
2718     return create_textfont(NULL, This, ret);
2719 }
2720
2721 static HRESULT WINAPI TextFont_SetDuplicate(ITextFont *iface, ITextFont *pFont)
2722 {
2723     ITextFontImpl *This = impl_from_ITextFont(iface);
2724     FIXME("(%p)->(%p): stub\n", This, pFont);
2725     return E_NOTIMPL;
2726 }
2727
2728 static HRESULT WINAPI TextFont_CanChange(ITextFont *iface, LONG *ret)
2729 {
2730     ITextFontImpl *This = impl_from_ITextFont(iface);
2731     FIXME("(%p)->(%p): stub\n", This, ret);
2732     return E_NOTIMPL;
2733 }
2734
2735 static HRESULT WINAPI TextFont_IsEqual(ITextFont *iface, ITextFont *font, LONG *ret)
2736 {
2737     ITextFontImpl *This = impl_from_ITextFont(iface);
2738     FIXME("(%p)->(%p %p): stub\n", This, font, ret);
2739     return E_NOTIMPL;
2740 }
2741
2742 static void textfont_reset_to_default(ITextFontImpl *font)
2743 {
2744     enum textfont_prop_id id;
2745
2746     for (id = FONT_PROPID_FIRST; id < FONT_PROPID_LAST; id++) {
2747         switch (id)
2748         {
2749         case FONT_ALLCAPS:
2750         case FONT_ANIMATION:
2751         case FONT_BOLD:
2752         case FONT_EMBOSS:
2753         case FONT_HIDDEN:
2754         case FONT_ENGRAVE:
2755         case FONT_ITALIC:
2756         case FONT_OUTLINE:
2757         case FONT_PROTECTED:
2758         case FONT_SHADOW:
2759         case FONT_SMALLCAPS:
2760         case FONT_STRIKETHROUGH:
2761         case FONT_SUBSCRIPT:
2762         case FONT_SUPERSCRIPT:
2763         case FONT_UNDERLINE:
2764             font->props[id].l = tomFalse;
2765             break;
2766         case FONT_BACKCOLOR:
2767         case FONT_FORECOLOR:
2768             font->props[id].l = tomAutoColor;
2769             break;
2770         case FONT_KERNING:
2771         case FONT_POSITION:
2772         case FONT_SIZE:
2773         case FONT_SPACING:
2774             font->props[id].f = 0.0;
2775             break;
2776         case FONT_LANGID:
2777             font->props[id].l = GetSystemDefaultLCID();
2778             break;
2779         case FONT_NAME: {
2780             static const WCHAR sysW[] = {'S','y','s','t','e','m',0};
2781             SysFreeString(font->props[id].str);
2782             font->props[id].str = SysAllocString(sysW);
2783             break;
2784         }
2785         case FONT_WEIGHT:
2786             font->props[id].l = FW_NORMAL;
2787             break;
2788         default:
2789             FIXME("font property %d not handled\n", id);
2790         }
2791     }
2792 }
2793
2794 static void textfont_reset_to_undefined(ITextFontImpl *font)
2795 {
2796     enum textfont_prop_id id;
2797
2798     for (id = FONT_PROPID_FIRST; id < FONT_PROPID_LAST; id++) {
2799         switch (id)
2800         {
2801         case FONT_ALLCAPS:
2802         case FONT_ANIMATION:
2803         case FONT_BOLD:
2804         case FONT_EMBOSS:
2805         case FONT_HIDDEN:
2806         case FONT_ENGRAVE:
2807         case FONT_ITALIC:
2808         case FONT_OUTLINE:
2809         case FONT_PROTECTED:
2810         case FONT_SHADOW:
2811         case FONT_SMALLCAPS:
2812         case FONT_STRIKETHROUGH:
2813         case FONT_SUBSCRIPT:
2814         case FONT_SUPERSCRIPT:
2815         case FONT_UNDERLINE:
2816         case FONT_BACKCOLOR:
2817         case FONT_FORECOLOR:
2818         case FONT_LANGID:
2819         case FONT_WEIGHT:
2820             font->props[id].l = tomUndefined;
2821             break;
2822         case FONT_KERNING:
2823         case FONT_POSITION:
2824         case FONT_SIZE:
2825         case FONT_SPACING:
2826             font->props[id].f = tomUndefined;
2827             break;
2828         case FONT_NAME:
2829             break;
2830         default:
2831             FIXME("font property %d not handled\n", id);
2832         }
2833     }
2834 }
2835
2836 static void textfont_apply_range_props(ITextFontImpl *font)
2837 {
2838     enum textfont_prop_id propid;
2839     for (propid = FONT_PROPID_FIRST; propid < FONT_PROPID_LAST; propid++)
2840         set_textfont_prop(font, propid, &font->props[propid]);
2841 }
2842
2843 static HRESULT WINAPI TextFont_Reset(ITextFont *iface, LONG value)
2844 {
2845     ITextFontImpl *This = impl_from_ITextFont(iface);
2846
2847     TRACE("(%p)->(%d)\n", This, value);
2848
2849     /* If font is attached to a range, released or not, we can't
2850        reset to undefined */
2851     if (This->range) {
2852         if (!get_range_reole(This->range))
2853             return CO_E_RELEASED;
2854
2855         switch (value)
2856         {
2857         case tomUndefined:
2858             return E_INVALIDARG;
2859         case tomCacheParms:
2860             textfont_cache_range_props(This);
2861             This->get_cache_enabled = TRUE;
2862             break;
2863         case tomTrackParms:
2864             This->get_cache_enabled = FALSE;
2865             break;
2866         case tomApplyLater:
2867             This->set_cache_enabled = TRUE;
2868             break;
2869         case tomApplyNow:
2870             This->set_cache_enabled = FALSE;
2871             textfont_apply_range_props(This);
2872             break;
2873         case tomUsePoints:
2874         case tomUseTwips:
2875             return E_INVALIDARG;
2876         default:
2877             FIXME("reset mode %d not supported\n", value);
2878         }
2879
2880         return S_OK;
2881     }
2882     else {
2883         switch (value)
2884         {
2885         /* reset to global defaults */
2886         case tomDefault:
2887             textfont_reset_to_default(This);
2888             return S_OK;
2889         /* all properties are set to tomUndefined, font name is retained */
2890         case tomUndefined:
2891             textfont_reset_to_undefined(This);
2892             return S_OK;
2893         case tomApplyNow:
2894         case tomApplyLater:
2895         case tomTrackParms:
2896         case tomCacheParms:
2897             return S_OK;
2898         case tomUsePoints:
2899         case tomUseTwips:
2900             return E_INVALIDARG;
2901         }
2902     }
2903
2904     FIXME("reset mode %d not supported\n", value);
2905     return E_NOTIMPL;
2906 }
2907
2908 static HRESULT WINAPI TextFont_GetStyle(ITextFont *iface, LONG *value)
2909 {
2910     ITextFontImpl *This = impl_from_ITextFont(iface);
2911     FIXME("(%p)->(%p): stub\n", This, value);
2912     return E_NOTIMPL;
2913 }
2914
2915 static HRESULT WINAPI TextFont_SetStyle(ITextFont *iface, LONG value)
2916 {
2917     ITextFontImpl *This = impl_from_ITextFont(iface);
2918     FIXME("(%p)->(%d): stub\n", This, value);
2919     return E_NOTIMPL;
2920 }
2921
2922 static HRESULT WINAPI TextFont_GetAllCaps(ITextFont *iface, LONG *value)
2923 {
2924     ITextFontImpl *This = impl_from_ITextFont(iface);
2925     TRACE("(%p)->(%p)\n", This, value);
2926     return get_textfont_propl(This, FONT_ALLCAPS, value);
2927 }
2928
2929 static HRESULT WINAPI TextFont_SetAllCaps(ITextFont *iface, LONG value)
2930 {
2931     ITextFontImpl *This = impl_from_ITextFont(iface);
2932     TRACE("(%p)->(%d)\n", This, value);
2933     return set_textfont_propd(This, FONT_ALLCAPS, value);
2934 }
2935
2936 static HRESULT WINAPI TextFont_GetAnimation(ITextFont *iface, LONG *value)
2937 {
2938     ITextFontImpl *This = impl_from_ITextFont(iface);
2939     TRACE("(%p)->(%p)\n", This, value);
2940     return get_textfont_propl(This, FONT_ANIMATION, value);
2941 }
2942
2943 static HRESULT WINAPI TextFont_SetAnimation(ITextFont *iface, LONG value)
2944 {
2945     ITextFontImpl *This = impl_from_ITextFont(iface);
2946
2947     TRACE("(%p)->(%d)\n", This, value);
2948
2949     if (value < tomNoAnimation || value > tomAnimationMax)
2950         return E_INVALIDARG;
2951
2952     return set_textfont_propl(This, FONT_ANIMATION, value);
2953 }
2954
2955 static HRESULT WINAPI TextFont_GetBackColor(ITextFont *iface, LONG *value)
2956 {
2957     ITextFontImpl *This = impl_from_ITextFont(iface);
2958     TRACE("(%p)->(%p)\n", This, value);
2959     return get_textfont_propl(This, FONT_BACKCOLOR, value);
2960 }
2961
2962 static HRESULT WINAPI TextFont_SetBackColor(ITextFont *iface, LONG value)
2963 {
2964     ITextFontImpl *This = impl_from_ITextFont(iface);
2965     TRACE("(%p)->(%d)\n", This, value);
2966     return set_textfont_propl(This, FONT_BACKCOLOR, value);
2967 }
2968
2969 static HRESULT WINAPI TextFont_GetBold(ITextFont *iface, LONG *value)
2970 {
2971     ITextFontImpl *This = impl_from_ITextFont(iface);
2972     TRACE("(%p)->(%p)\n", This, value);
2973     return get_textfont_propl(This, FONT_BOLD, value);
2974 }
2975
2976 static HRESULT WINAPI TextFont_SetBold(ITextFont *iface, LONG value)
2977 {
2978     ITextFontImpl *This = impl_from_ITextFont(iface);
2979     TRACE("(%p)->(%d)\n", This, value);
2980     return set_textfont_propd(This, FONT_BOLD, value);
2981 }
2982
2983 static HRESULT WINAPI TextFont_GetEmboss(ITextFont *iface, LONG *value)
2984 {
2985     ITextFontImpl *This = impl_from_ITextFont(iface);
2986     TRACE("(%p)->(%p)\n", This, value);
2987     return get_textfont_propl(This, FONT_EMBOSS, value);
2988 }
2989
2990 static HRESULT WINAPI TextFont_SetEmboss(ITextFont *iface, LONG value)
2991 {
2992     ITextFontImpl *This = impl_from_ITextFont(iface);
2993     TRACE("(%p)->(%d)\n", This, value);
2994     return set_textfont_propd(This, FONT_EMBOSS, value);
2995 }
2996
2997 static HRESULT WINAPI TextFont_GetForeColor(ITextFont *iface, LONG *value)
2998 {
2999     ITextFontImpl *This = impl_from_ITextFont(iface);
3000     TRACE("(%p)->(%p)\n", This, value);
3001     return get_textfont_propl(This, FONT_FORECOLOR, value);
3002 }
3003
3004 static HRESULT WINAPI TextFont_SetForeColor(ITextFont *iface, LONG value)
3005 {
3006     ITextFontImpl *This = impl_from_ITextFont(iface);
3007     TRACE("(%p)->(%d)\n", This, value);
3008     return set_textfont_propl(This, FONT_FORECOLOR, value);
3009 }
3010
3011 static HRESULT WINAPI TextFont_GetHidden(ITextFont *iface, LONG *value)
3012 {
3013     ITextFontImpl *This = impl_from_ITextFont(iface);
3014     TRACE("(%p)->(%p)\n", This, value);
3015     return get_textfont_propl(This, FONT_HIDDEN, value);
3016 }
3017
3018 static HRESULT WINAPI TextFont_SetHidden(ITextFont *iface, LONG value)
3019 {
3020     ITextFontImpl *This = impl_from_ITextFont(iface);
3021     TRACE("(%p)->(%d)\n", This, value);
3022     return set_textfont_propd(This, FONT_HIDDEN, value);
3023 }
3024
3025 static HRESULT WINAPI TextFont_GetEngrave(ITextFont *iface, LONG *value)
3026 {
3027     ITextFontImpl *This = impl_from_ITextFont(iface);
3028     TRACE("(%p)->(%p)\n", This, value);
3029     return get_textfont_propl(This, FONT_ENGRAVE, value);
3030 }
3031
3032 static HRESULT WINAPI TextFont_SetEngrave(ITextFont *iface, LONG value)
3033 {
3034     ITextFontImpl *This = impl_from_ITextFont(iface);
3035     TRACE("(%p)->(%d)\n", This, value);
3036     return set_textfont_propd(This, FONT_ENGRAVE, value);
3037 }
3038
3039 static HRESULT WINAPI TextFont_GetItalic(ITextFont *iface, LONG *value)
3040 {
3041     ITextFontImpl *This = impl_from_ITextFont(iface);
3042     TRACE("(%p)->(%p)\n", This, value);
3043     return get_textfont_propl(This, FONT_ITALIC, value);
3044 }
3045
3046 static HRESULT WINAPI TextFont_SetItalic(ITextFont *iface, LONG value)
3047 {
3048     ITextFontImpl *This = impl_from_ITextFont(iface);
3049     TRACE("(%p)->(%d)\n", This, value);
3050     return set_textfont_propd(This, FONT_ITALIC, value);
3051 }
3052
3053 static HRESULT WINAPI TextFont_GetKerning(ITextFont *iface, FLOAT *value)
3054 {
3055     ITextFontImpl *This = impl_from_ITextFont(iface);
3056     TRACE("(%p)->(%p)\n", This, value);
3057     return get_textfont_propf(This, FONT_KERNING, value);
3058 }
3059
3060 static HRESULT WINAPI TextFont_SetKerning(ITextFont *iface, FLOAT value)
3061 {
3062     ITextFontImpl *This = impl_from_ITextFont(iface);
3063     TRACE("(%p)->(%.2f)\n", This, value);
3064     return set_textfont_propf(This, FONT_KERNING, value);
3065 }
3066
3067 static HRESULT WINAPI TextFont_GetLanguageID(ITextFont *iface, LONG *value)
3068 {
3069     ITextFontImpl *This = impl_from_ITextFont(iface);
3070     TRACE("(%p)->(%p)\n", This, value);
3071     return get_textfont_propl(This, FONT_LANGID, value);
3072 }
3073
3074 static HRESULT WINAPI TextFont_SetLanguageID(ITextFont *iface, LONG value)
3075 {
3076     ITextFontImpl *This = impl_from_ITextFont(iface);
3077     TRACE("(%p)->(%d)\n", This, value);
3078     return set_textfont_propl(This, FONT_LANGID, value);
3079 }
3080
3081 static HRESULT WINAPI TextFont_GetName(ITextFont *iface, BSTR *value)
3082 {
3083     ITextFontImpl *This = impl_from_ITextFont(iface);
3084
3085     TRACE("(%p)->(%p)\n", This, value);
3086
3087     if (!value)
3088         return E_INVALIDARG;
3089
3090     *value = NULL;
3091
3092     if (!This->range) {
3093         if (This->props[FONT_NAME].str)
3094             *value = SysAllocString(This->props[FONT_NAME].str);
3095         else
3096             *value = SysAllocStringLen(NULL, 0);
3097         return *value ? S_OK : E_OUTOFMEMORY;
3098     }
3099
3100     return textfont_getname_from_range(This->range, value);
3101 }
3102
3103 static HRESULT WINAPI TextFont_SetName(ITextFont *iface, BSTR value)
3104 {
3105     ITextFontImpl *This = impl_from_ITextFont(iface);
3106     textfont_prop_val v;
3107
3108     TRACE("(%p)->(%s)\n", This, debugstr_w(value));
3109
3110     v.str = value;
3111     return set_textfont_prop(This, FONT_NAME, &v);
3112 }
3113
3114 static HRESULT WINAPI TextFont_GetOutline(ITextFont *iface, LONG *value)
3115 {
3116     ITextFontImpl *This = impl_from_ITextFont(iface);
3117     TRACE("(%p)->(%p)\n", This, value);
3118     return get_textfont_propl(This, FONT_OUTLINE, value);
3119 }
3120
3121 static HRESULT WINAPI TextFont_SetOutline(ITextFont *iface, LONG value)
3122 {
3123     ITextFontImpl *This = impl_from_ITextFont(iface);
3124     TRACE("(%p)->(%d)\n", This, value);
3125     return set_textfont_propd(This, FONT_OUTLINE, value);
3126 }
3127
3128 static HRESULT WINAPI TextFont_GetPosition(ITextFont *iface, FLOAT *value)
3129 {
3130     ITextFontImpl *This = impl_from_ITextFont(iface);
3131     TRACE("(%p)->(%p)\n", This, value);
3132     return get_textfont_propf(This, FONT_POSITION, value);
3133 }
3134
3135 static HRESULT WINAPI TextFont_SetPosition(ITextFont *iface, FLOAT value)
3136 {
3137     ITextFontImpl *This = impl_from_ITextFont(iface);
3138     TRACE("(%p)->(%.2f)\n", This, value);
3139     return set_textfont_propf(This, FONT_POSITION, value);
3140 }
3141
3142 static HRESULT WINAPI TextFont_GetProtected(ITextFont *iface, LONG *value)
3143 {
3144     ITextFontImpl *This = impl_from_ITextFont(iface);
3145     TRACE("(%p)->(%p)\n", This, value);
3146     return get_textfont_propl(This, FONT_PROTECTED, value);
3147 }
3148
3149 static HRESULT WINAPI TextFont_SetProtected(ITextFont *iface, LONG value)
3150 {
3151     ITextFontImpl *This = impl_from_ITextFont(iface);
3152     TRACE("(%p)->(%d)\n", This, value);
3153     return set_textfont_propd(This, FONT_PROTECTED, value);
3154 }
3155
3156 static HRESULT WINAPI TextFont_GetShadow(ITextFont *iface, LONG *value)
3157 {
3158     ITextFontImpl *This = impl_from_ITextFont(iface);
3159     TRACE("(%p)->(%p)\n", This, value);
3160     return get_textfont_propl(This, FONT_SHADOW, value);
3161 }
3162
3163 static HRESULT WINAPI TextFont_SetShadow(ITextFont *iface, LONG value)
3164 {
3165     ITextFontImpl *This = impl_from_ITextFont(iface);
3166     TRACE("(%p)->(%d)\n", This, value);
3167     return set_textfont_propd(This, FONT_SHADOW, value);
3168 }
3169
3170 static HRESULT WINAPI TextFont_GetSize(ITextFont *iface, FLOAT *value)
3171 {
3172     ITextFontImpl *This = impl_from_ITextFont(iface);
3173     TRACE("(%p)->(%p)\n", This, value);
3174     return get_textfont_propf(This, FONT_SIZE, value);
3175 }
3176
3177 static HRESULT WINAPI TextFont_SetSize(ITextFont *iface, FLOAT value)
3178 {
3179     ITextFontImpl *This = impl_from_ITextFont(iface);
3180     TRACE("(%p)->(%.2f)\n", This, value);
3181     return set_textfont_propf(This, FONT_SIZE, value);
3182 }
3183
3184 static HRESULT WINAPI TextFont_GetSmallCaps(ITextFont *iface, LONG *value)
3185 {
3186     ITextFontImpl *This = impl_from_ITextFont(iface);
3187     TRACE("(%p)->(%p)\n", This, value);
3188     return get_textfont_propl(This, FONT_SMALLCAPS, value);
3189 }
3190
3191 static HRESULT WINAPI TextFont_SetSmallCaps(ITextFont *iface, LONG value)
3192 {
3193     ITextFontImpl *This = impl_from_ITextFont(iface);
3194     TRACE("(%p)->(%d)\n", This, value);
3195     return set_textfont_propd(This, FONT_SMALLCAPS, value);
3196 }
3197
3198 static HRESULT WINAPI TextFont_GetSpacing(ITextFont *iface, FLOAT *value)
3199 {
3200     ITextFontImpl *This = impl_from_ITextFont(iface);
3201     TRACE("(%p)->(%p)\n", This, value);
3202     return get_textfont_propf(This, FONT_SPACING, value);
3203 }
3204
3205 static HRESULT WINAPI TextFont_SetSpacing(ITextFont *iface, FLOAT value)
3206 {
3207     ITextFontImpl *This = impl_from_ITextFont(iface);
3208     TRACE("(%p)->(%.2f)\n", This, value);
3209     return set_textfont_propf(This, FONT_SPACING, value);
3210 }
3211
3212 static HRESULT WINAPI TextFont_GetStrikeThrough(ITextFont *iface, LONG *value)
3213 {
3214     ITextFontImpl *This = impl_from_ITextFont(iface);
3215     TRACE("(%p)->(%p)\n", This, value);
3216     return get_textfont_propl(This, FONT_STRIKETHROUGH, value);
3217 }
3218
3219 static HRESULT WINAPI TextFont_SetStrikeThrough(ITextFont *iface, LONG value)
3220 {
3221     ITextFontImpl *This = impl_from_ITextFont(iface);
3222     TRACE("(%p)->(%d)\n", This, value);
3223     return set_textfont_propd(This, FONT_STRIKETHROUGH, value);
3224 }
3225
3226 static HRESULT WINAPI TextFont_GetSubscript(ITextFont *iface, LONG *value)
3227 {
3228     ITextFontImpl *This = impl_from_ITextFont(iface);
3229     TRACE("(%p)->(%p)\n", This, value);
3230     return get_textfont_propl(This, FONT_SUBSCRIPT, value);
3231 }
3232
3233 static HRESULT WINAPI TextFont_SetSubscript(ITextFont *iface, LONG value)
3234 {
3235     ITextFontImpl *This = impl_from_ITextFont(iface);
3236     TRACE("(%p)->(%d)\n", This, value);
3237     return set_textfont_propd(This, FONT_SUBSCRIPT, value);
3238 }
3239
3240 static HRESULT WINAPI TextFont_GetSuperscript(ITextFont *iface, LONG *value)
3241 {
3242     ITextFontImpl *This = impl_from_ITextFont(iface);
3243     TRACE("(%p)->(%p)\n", This, value);
3244     return get_textfont_propl(This, FONT_SUPERSCRIPT, value);
3245 }
3246
3247 static HRESULT WINAPI TextFont_SetSuperscript(ITextFont *iface, LONG value)
3248 {
3249     ITextFontImpl *This = impl_from_ITextFont(iface);
3250     TRACE("(%p)->(%d)\n", This, value);
3251     return set_textfont_propd(This, FONT_SUPERSCRIPT, value);
3252 }
3253
3254 static HRESULT WINAPI TextFont_GetUnderline(ITextFont *iface, LONG *value)
3255 {
3256     ITextFontImpl *This = impl_from_ITextFont(iface);
3257     TRACE("(%p)->(%p)\n", This, value);
3258     return get_textfont_propl(This, FONT_UNDERLINE, value);
3259 }
3260
3261 static HRESULT WINAPI TextFont_SetUnderline(ITextFont *iface, LONG value)
3262 {
3263     ITextFontImpl *This = impl_from_ITextFont(iface);
3264     TRACE("(%p)->(%d)\n", This, value);
3265     return set_textfont_propd(This, FONT_UNDERLINE, value);
3266 }
3267
3268 static HRESULT WINAPI TextFont_GetWeight(ITextFont *iface, LONG *value)
3269 {
3270     ITextFontImpl *This = impl_from_ITextFont(iface);
3271     TRACE("(%p)->(%p)\n", This, value);
3272     return get_textfont_propl(This, FONT_WEIGHT, value);
3273 }
3274
3275 static HRESULT WINAPI TextFont_SetWeight(ITextFont *iface, LONG value)
3276 {
3277     ITextFontImpl *This = impl_from_ITextFont(iface);
3278     TRACE("(%p)->(%d)\n", This, value);
3279     return set_textfont_propl(This, FONT_WEIGHT, value);
3280 }
3281
3282 static ITextFontVtbl textfontvtbl = {
3283     TextFont_QueryInterface,
3284     TextFont_AddRef,
3285     TextFont_Release,
3286     TextFont_GetTypeInfoCount,
3287     TextFont_GetTypeInfo,
3288     TextFont_GetIDsOfNames,
3289     TextFont_Invoke,
3290     TextFont_GetDuplicate,
3291     TextFont_SetDuplicate,
3292     TextFont_CanChange,
3293     TextFont_IsEqual,
3294     TextFont_Reset,
3295     TextFont_GetStyle,
3296     TextFont_SetStyle,
3297     TextFont_GetAllCaps,
3298     TextFont_SetAllCaps,
3299     TextFont_GetAnimation,
3300     TextFont_SetAnimation,
3301     TextFont_GetBackColor,
3302     TextFont_SetBackColor,
3303     TextFont_GetBold,
3304     TextFont_SetBold,
3305     TextFont_GetEmboss,
3306     TextFont_SetEmboss,
3307     TextFont_GetForeColor,
3308     TextFont_SetForeColor,
3309     TextFont_GetHidden,
3310     TextFont_SetHidden,
3311     TextFont_GetEngrave,
3312     TextFont_SetEngrave,
3313     TextFont_GetItalic,
3314     TextFont_SetItalic,
3315     TextFont_GetKerning,
3316     TextFont_SetKerning,
3317     TextFont_GetLanguageID,
3318     TextFont_SetLanguageID,
3319     TextFont_GetName,
3320     TextFont_SetName,
3321     TextFont_GetOutline,
3322     TextFont_SetOutline,
3323     TextFont_GetPosition,
3324     TextFont_SetPosition,
3325     TextFont_GetProtected,
3326     TextFont_SetProtected,
3327     TextFont_GetShadow,
3328     TextFont_SetShadow,
3329     TextFont_GetSize,
3330     TextFont_SetSize,
3331     TextFont_GetSmallCaps,
3332     TextFont_SetSmallCaps,
3333     TextFont_GetSpacing,
3334     TextFont_SetSpacing,
3335     TextFont_GetStrikeThrough,
3336     TextFont_SetStrikeThrough,
3337     TextFont_GetSubscript,
3338     TextFont_SetSubscript,
3339     TextFont_GetSuperscript,
3340     TextFont_SetSuperscript,
3341     TextFont_GetUnderline,
3342     TextFont_SetUnderline,
3343     TextFont_GetWeight,
3344     TextFont_SetWeight
3345 };
3346
3347 static HRESULT create_textfont(ITextRange *range, const ITextFontImpl *src, ITextFont **ret)
3348 {
3349     ITextFontImpl *font;
3350
3351     *ret = NULL;
3352     font = heap_alloc(sizeof(*font));
3353     if (!font)
3354         return E_OUTOFMEMORY;
3355
3356     font->ITextFont_iface.lpVtbl = &textfontvtbl;
3357     font->ref = 1;
3358
3359     if (src) {
3360         font->range = NULL;
3361         font->get_cache_enabled = TRUE;
3362         font->set_cache_enabled = TRUE;
3363         memcpy(&font->props, &src->props, sizeof(font->props));
3364         if (font->props[FONT_NAME].str)
3365             font->props[FONT_NAME].str = SysAllocString(font->props[FONT_NAME].str);
3366     }
3367     else {
3368         font->range = range;
3369         ITextRange_AddRef(range);
3370
3371         /* cache current properties */
3372         font->get_cache_enabled = FALSE;
3373         font->set_cache_enabled = FALSE;
3374         textfont_cache_range_props(font);
3375     }
3376
3377     *ret = &font->ITextFont_iface;
3378     return S_OK;
3379 }
3380
3381 /* ITextPara */
3382 static HRESULT WINAPI TextPara_QueryInterface(ITextPara *iface, REFIID riid, void **ppv)
3383 {
3384     ITextParaImpl *This = impl_from_ITextPara(iface);
3385
3386     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
3387
3388     if (IsEqualIID(riid, &IID_ITextPara) ||
3389         IsEqualIID(riid, &IID_IDispatch) ||
3390         IsEqualIID(riid, &IID_IUnknown))
3391     {
3392         *ppv = iface;
3393         ITextPara_AddRef(iface);
3394         return S_OK;
3395     }
3396
3397     *ppv = NULL;
3398     return E_NOINTERFACE;
3399 }
3400
3401 static ULONG WINAPI TextPara_AddRef(ITextPara *iface)
3402 {
3403     ITextParaImpl *This = impl_from_ITextPara(iface);
3404     ULONG ref = InterlockedIncrement(&This->ref);
3405     TRACE("(%p)->(%u)\n", This, ref);
3406     return ref;
3407 }
3408
3409 static ULONG WINAPI TextPara_Release(ITextPara *iface)
3410 {
3411     ITextParaImpl *This = impl_from_ITextPara(iface);
3412     ULONG ref = InterlockedDecrement(&This->ref);
3413
3414     TRACE("(%p)->(%u)\n", This, ref);
3415
3416     if (!ref)
3417     {
3418         ITextRange_Release(This->range);
3419         heap_free(This);
3420     }
3421
3422     return ref;
3423 }
3424
3425 static HRESULT WINAPI TextPara_GetTypeInfoCount(ITextPara *iface, UINT *pctinfo)
3426 {
3427     ITextParaImpl *This = impl_from_ITextPara(iface);
3428     TRACE("(%p)->(%p)\n", This, pctinfo);
3429     *pctinfo = 1;
3430     return S_OK;
3431 }
3432
3433 static HRESULT WINAPI TextPara_GetTypeInfo(ITextPara *iface, UINT iTInfo, LCID lcid,
3434     ITypeInfo **ppTInfo)
3435 {
3436     ITextParaImpl *This = impl_from_ITextPara(iface);
3437     HRESULT hr;
3438
3439     TRACE("(%p)->(%u,%d,%p)\n", This, iTInfo, lcid, ppTInfo);
3440
3441     hr = get_typeinfo(ITextPara_tid, ppTInfo);
3442     if (SUCCEEDED(hr))
3443         ITypeInfo_AddRef(*ppTInfo);
3444     return hr;
3445 }
3446
3447 static HRESULT WINAPI TextPara_GetIDsOfNames(ITextPara *iface, REFIID riid,
3448     LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3449 {
3450     ITextParaImpl *This = impl_from_ITextPara(iface);
3451     ITypeInfo *ti;
3452     HRESULT hr;
3453
3454     TRACE("(%p)->(%s, %p, %u, %d, %p)\n", This, debugstr_guid(riid), rgszNames,
3455             cNames, lcid, rgDispId);
3456
3457     hr = get_typeinfo(ITextPara_tid, &ti);
3458     if (SUCCEEDED(hr))
3459         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
3460     return hr;
3461 }
3462
3463 static HRESULT WINAPI TextPara_Invoke(
3464     ITextPara *iface,
3465     DISPID dispIdMember,
3466     REFIID riid,
3467     LCID lcid,
3468     WORD wFlags,
3469     DISPPARAMS *pDispParams,
3470     VARIANT *pVarResult,
3471     EXCEPINFO *pExcepInfo,
3472     UINT *puArgErr)
3473 {
3474     ITextParaImpl *This = impl_from_ITextPara(iface);
3475     ITypeInfo *ti;
3476     HRESULT hr;
3477
3478     TRACE("(%p)->(%d, %s, %d, %u, %p, %p, %p, %p)\n", This, dispIdMember,
3479             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult,
3480             pExcepInfo, puArgErr);
3481
3482     hr = get_typeinfo(ITextPara_tid, &ti);
3483     if (SUCCEEDED(hr))
3484         hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3485     return hr;
3486 }
3487
3488 static HRESULT WINAPI TextPara_GetDuplicate(ITextPara *iface, ITextPara **ret)
3489 {
3490     ITextParaImpl *This = impl_from_ITextPara(iface);
3491     FIXME("(%p)->(%p)\n", This, ret);
3492     return E_NOTIMPL;
3493 }
3494
3495 static HRESULT WINAPI TextPara_SetDuplicate(ITextPara *iface, ITextPara *para)
3496 {
3497     ITextParaImpl *This = impl_from_ITextPara(iface);
3498     FIXME("(%p)->(%p)\n", This, para);
3499     return E_NOTIMPL;
3500 }
3501
3502 static HRESULT WINAPI TextPara_CanChange(ITextPara *iface, LONG *ret)
3503 {
3504     ITextParaImpl *This = impl_from_ITextPara(iface);
3505     FIXME("(%p)->(%p)\n", This, ret);
3506     return E_NOTIMPL;
3507 }
3508
3509 static HRESULT WINAPI TextPara_IsEqual(ITextPara *iface, ITextPara *para, LONG *ret)
3510 {
3511     ITextParaImpl *This = impl_from_ITextPara(iface);
3512     FIXME("(%p)->(%p %p)\n", This, para, ret);
3513     return E_NOTIMPL;
3514 }
3515
3516 static HRESULT WINAPI TextPara_Reset(ITextPara *iface, LONG value)
3517 {
3518     ITextParaImpl *This = impl_from_ITextPara(iface);
3519     FIXME("(%p)->(%d)\n", This, value);
3520     return E_NOTIMPL;
3521 }
3522
3523 static HRESULT WINAPI TextPara_GetStyle(ITextPara *iface, LONG *value)
3524 {
3525     ITextParaImpl *This = impl_from_ITextPara(iface);
3526     FIXME("(%p)->(%p)\n", This, value);
3527     return E_NOTIMPL;
3528 }
3529
3530 static HRESULT WINAPI TextPara_SetStyle(ITextPara *iface, LONG value)
3531 {
3532     ITextParaImpl *This = impl_from_ITextPara(iface);
3533     FIXME("(%p)->(%d)\n", This, value);
3534     return E_NOTIMPL;
3535 }
3536
3537 static HRESULT WINAPI TextPara_GetAlignment(ITextPara *iface, LONG *value)
3538 {
3539     ITextParaImpl *This = impl_from_ITextPara(iface);
3540     FIXME("(%p)->(%p)\n", This, value);
3541     return E_NOTIMPL;
3542 }
3543
3544 static HRESULT WINAPI TextPara_SetAlignment(ITextPara *iface, LONG value)
3545 {
3546     ITextParaImpl *This = impl_from_ITextPara(iface);
3547     FIXME("(%p)->(%d)\n", This, value);
3548     return E_NOTIMPL;
3549 }
3550
3551 static HRESULT WINAPI TextPara_GetHyphenation(ITextPara *iface, LONG *value)
3552 {
3553     ITextParaImpl *This = impl_from_ITextPara(iface);
3554     FIXME("(%p)->(%p)\n", This, value);
3555     return E_NOTIMPL;
3556 }
3557
3558 static HRESULT WINAPI TextPara_SetHyphenation(ITextPara *iface, LONG value)
3559 {
3560     ITextParaImpl *This = impl_from_ITextPara(iface);
3561     FIXME("(%p)->(%d)\n", This, value);
3562     return E_NOTIMPL;
3563 }
3564
3565 static HRESULT WINAPI TextPara_GetFirstLineIndent(ITextPara *iface, FLOAT *value)
3566 {
3567     ITextParaImpl *This = impl_from_ITextPara(iface);
3568     FIXME("(%p)->(%p)\n", This, value);
3569     return E_NOTIMPL;
3570 }
3571
3572 static HRESULT WINAPI TextPara_GetKeepTogether(ITextPara *iface, LONG *value)
3573 {
3574     ITextParaImpl *This = impl_from_ITextPara(iface);
3575     FIXME("(%p)->(%p)\n", This, value);
3576     return E_NOTIMPL;
3577 }
3578
3579 static HRESULT WINAPI TextPara_SetKeepTogether(ITextPara *iface, LONG value)
3580 {
3581     ITextParaImpl *This = impl_from_ITextPara(iface);
3582     FIXME("(%p)->(%d)\n", This, value);
3583     return E_NOTIMPL;
3584 }
3585
3586 static HRESULT WINAPI TextPara_GetKeepWithNext(ITextPara *iface, LONG *value)
3587 {
3588     ITextParaImpl *This = impl_from_ITextPara(iface);
3589     FIXME("(%p)->(%p)\n", This, value);
3590     return E_NOTIMPL;
3591 }
3592
3593 static HRESULT WINAPI TextPara_SetKeepWithNext(ITextPara *iface, LONG value)
3594 {
3595     ITextParaImpl *This = impl_from_ITextPara(iface);
3596     FIXME("(%p)->(%d)\n", This, value);
3597     return E_NOTIMPL;
3598 }
3599
3600 static HRESULT WINAPI TextPara_GetLeftIndent(ITextPara *iface, FLOAT *value)
3601 {
3602     ITextParaImpl *This = impl_from_ITextPara(iface);
3603     FIXME("(%p)->(%p)\n", This, value);
3604     return E_NOTIMPL;
3605 }
3606
3607 static HRESULT WINAPI TextPara_GetLineSpacing(ITextPara *iface, FLOAT *value)
3608 {
3609     ITextParaImpl *This = impl_from_ITextPara(iface);
3610     FIXME("(%p)->(%p)\n", This, value);
3611     return E_NOTIMPL;
3612 }
3613
3614 static HRESULT WINAPI TextPara_GetLineSpacingRule(ITextPara *iface, LONG *value)
3615 {
3616     ITextParaImpl *This = impl_from_ITextPara(iface);
3617     FIXME("(%p)->(%p)\n", This, value);
3618     return E_NOTIMPL;
3619 }
3620
3621 static HRESULT WINAPI TextPara_GetListAlignment(ITextPara *iface, LONG *value)
3622 {
3623     ITextParaImpl *This = impl_from_ITextPara(iface);
3624     FIXME("(%p)->(%p)\n", This, value);
3625     return E_NOTIMPL;
3626 }
3627
3628 static HRESULT WINAPI TextPara_SetListAlignment(ITextPara *iface, LONG value)
3629 {
3630     ITextParaImpl *This = impl_from_ITextPara(iface);
3631     FIXME("(%p)->(%d)\n", This, value);
3632     return E_NOTIMPL;
3633 }
3634
3635 static HRESULT WINAPI TextPara_GetListLevelIndex(ITextPara *iface, LONG *value)
3636 {
3637     ITextParaImpl *This = impl_from_ITextPara(iface);
3638     FIXME("(%p)->(%p)\n", This, value);
3639     return E_NOTIMPL;
3640 }
3641
3642 static HRESULT WINAPI TextPara_SetListLevelIndex(ITextPara *iface, LONG value)
3643 {
3644     ITextParaImpl *This = impl_from_ITextPara(iface);
3645     FIXME("(%p)->(%d)\n", This, value);
3646     return E_NOTIMPL;
3647 }
3648
3649 static HRESULT WINAPI TextPara_GetListStart(ITextPara *iface, LONG *value)
3650 {
3651     ITextParaImpl *This = impl_from_ITextPara(iface);
3652     FIXME("(%p)->(%p)\n", This, value);
3653     return E_NOTIMPL;
3654 }
3655
3656 static HRESULT WINAPI TextPara_SetListStart(ITextPara *iface, LONG value)
3657 {
3658     ITextParaImpl *This = impl_from_ITextPara(iface);
3659     FIXME("(%p)->(%d)\n", This, value);
3660     return E_NOTIMPL;
3661 }
3662
3663 static HRESULT WINAPI TextPara_GetListTab(ITextPara *iface, FLOAT *value)
3664 {
3665     ITextParaImpl *This = impl_from_ITextPara(iface);
3666     FIXME("(%p)->(%p)\n", This, value);
3667     return E_NOTIMPL;
3668 }
3669
3670 static HRESULT WINAPI TextPara_SetListTab(ITextPara *iface, FLOAT value)
3671 {
3672     ITextParaImpl *This = impl_from_ITextPara(iface);
3673     FIXME("(%p)->(%.2f)\n", This, value);
3674     return E_NOTIMPL;
3675 }
3676
3677 static HRESULT WINAPI TextPara_GetListType(ITextPara *iface, LONG *value)
3678 {
3679     ITextParaImpl *This = impl_from_ITextPara(iface);
3680     FIXME("(%p)->(%p)\n", This, value);
3681     return E_NOTIMPL;
3682 }
3683
3684 static HRESULT WINAPI TextPara_SetListType(ITextPara *iface, LONG value)
3685 {
3686     ITextParaImpl *This = impl_from_ITextPara(iface);
3687     FIXME("(%p)->(%d)\n", This, value);
3688     return E_NOTIMPL;
3689 }
3690
3691 static HRESULT WINAPI TextPara_GetNoLineNumber(ITextPara *iface, LONG *value)
3692 {
3693     ITextParaImpl *This = impl_from_ITextPara(iface);
3694     FIXME("(%p)->(%p)\n", This, value);
3695     return E_NOTIMPL;
3696 }
3697
3698 static HRESULT WINAPI TextPara_SetNoLineNumber(ITextPara *iface, LONG value)
3699 {
3700     ITextParaImpl *This = impl_from_ITextPara(iface);
3701     FIXME("(%p)->(%d)\n", This, value);
3702     return E_NOTIMPL;
3703 }
3704
3705 static HRESULT WINAPI TextPara_GetPageBreakBefore(ITextPara *iface, LONG *value)
3706 {
3707     ITextParaImpl *This = impl_from_ITextPara(iface);
3708     FIXME("(%p)->(%p)\n", This, value);
3709     return E_NOTIMPL;
3710 }
3711
3712 static HRESULT WINAPI TextPara_SetPageBreakBefore(ITextPara *iface, LONG value)
3713 {
3714     ITextParaImpl *This = impl_from_ITextPara(iface);
3715     FIXME("(%p)->(%d)\n", This, value);
3716     return E_NOTIMPL;
3717 }
3718
3719 static HRESULT WINAPI TextPara_GetRightIndent(ITextPara *iface, FLOAT *value)
3720 {
3721     ITextParaImpl *This = impl_from_ITextPara(iface);
3722     FIXME("(%p)->(%p)\n", This, value);
3723     return E_NOTIMPL;
3724 }
3725
3726 static HRESULT WINAPI TextPara_SetRightIndent(ITextPara *iface, FLOAT value)
3727 {
3728     ITextParaImpl *This = impl_from_ITextPara(iface);
3729     FIXME("(%p)->(%.2f)\n", This, value);
3730     return E_NOTIMPL;
3731 }
3732
3733 static HRESULT WINAPI TextPara_SetIndents(ITextPara *iface, FLOAT StartIndent, FLOAT LeftIndent, FLOAT RightIndent)
3734 {
3735     ITextParaImpl *This = impl_from_ITextPara(iface);
3736     FIXME("(%p)->(%.2f %.2f %.2f)\n", This, StartIndent, LeftIndent, RightIndent);
3737     return E_NOTIMPL;
3738 }
3739
3740 static HRESULT WINAPI TextPara_SetLineSpacing(ITextPara *iface, LONG LineSpacingRule, FLOAT LineSpacing)
3741 {
3742     ITextParaImpl *This = impl_from_ITextPara(iface);
3743     FIXME("(%p)->(%d %.2f)\n", This, LineSpacingRule, LineSpacing);
3744     return E_NOTIMPL;
3745 }
3746
3747 static HRESULT WINAPI TextPara_GetSpaceAfter(ITextPara *iface, FLOAT *value)
3748 {
3749     ITextParaImpl *This = impl_from_ITextPara(iface);
3750     FIXME("(%p)->(%p)\n", This, value);
3751     return E_NOTIMPL;
3752 }
3753
3754 static HRESULT WINAPI TextPara_SetSpaceAfter(ITextPara *iface, FLOAT value)
3755 {
3756     ITextParaImpl *This = impl_from_ITextPara(iface);
3757     FIXME("(%p)->(%.2f)\n", This, value);
3758     return E_NOTIMPL;
3759 }
3760
3761 static HRESULT WINAPI TextPara_GetSpaceBefore(ITextPara *iface, FLOAT *value)
3762 {
3763     ITextParaImpl *This = impl_from_ITextPara(iface);
3764     FIXME("(%p)->(%p)\n", This, value);
3765     return E_NOTIMPL;
3766 }
3767
3768 static HRESULT WINAPI TextPara_SetSpaceBefore(ITextPara *iface, FLOAT value)
3769 {
3770     ITextParaImpl *This = impl_from_ITextPara(iface);
3771     FIXME("(%p)->(%.2f)\n", This, value);
3772     return E_NOTIMPL;
3773 }
3774
3775 static HRESULT WINAPI TextPara_GetWidowControl(ITextPara *iface, LONG *value)
3776 {
3777     ITextParaImpl *This = impl_from_ITextPara(iface);
3778     FIXME("(%p)->(%p)\n", This, value);
3779     return E_NOTIMPL;
3780 }
3781
3782 static HRESULT WINAPI TextPara_SetWidowControl(ITextPara *iface, LONG value)
3783 {
3784     ITextParaImpl *This = impl_from_ITextPara(iface);
3785     FIXME("(%p)->(%d)\n", This, value);
3786     return E_NOTIMPL;
3787 }
3788
3789 static HRESULT WINAPI TextPara_GetTabCount(ITextPara *iface, LONG *value)
3790 {
3791     ITextParaImpl *This = impl_from_ITextPara(iface);
3792     FIXME("(%p)->(%p)\n", This, value);
3793     return E_NOTIMPL;
3794 }
3795
3796 static HRESULT WINAPI TextPara_AddTab(ITextPara *iface, FLOAT tbPos, LONG tbAlign, LONG tbLeader)
3797 {
3798     ITextParaImpl *This = impl_from_ITextPara(iface);
3799     FIXME("(%p)->(%.2f %d %d)\n", This, tbPos, tbAlign, tbLeader);
3800     return E_NOTIMPL;
3801 }
3802
3803 static HRESULT WINAPI TextPara_ClearAllTabs(ITextPara *iface)
3804 {
3805     ITextParaImpl *This = impl_from_ITextPara(iface);
3806     FIXME("(%p)\n", This);
3807     return E_NOTIMPL;
3808 }
3809
3810 static HRESULT WINAPI TextPara_DeleteTab(ITextPara *iface, FLOAT pos)
3811 {
3812     ITextParaImpl *This = impl_from_ITextPara(iface);
3813     FIXME("(%p)->(%.2f)\n", This, pos);
3814     return E_NOTIMPL;
3815 }
3816
3817 static HRESULT WINAPI TextPara_GetTab(ITextPara *iface, LONG iTab, FLOAT *ptbPos, LONG *ptbAlign, LONG *ptbLeader)
3818 {
3819     ITextParaImpl *This = impl_from_ITextPara(iface);
3820     FIXME("(%p)->(%d %p %p %p)\n", This, iTab, ptbPos, ptbAlign, ptbLeader);
3821     return E_NOTIMPL;
3822 }
3823
3824 static ITextParaVtbl textparavtbl = {
3825     TextPara_QueryInterface,
3826     TextPara_AddRef,
3827     TextPara_Release,
3828     TextPara_GetTypeInfoCount,
3829     TextPara_GetTypeInfo,
3830     TextPara_GetIDsOfNames,
3831     TextPara_Invoke,
3832     TextPara_GetDuplicate,
3833     TextPara_SetDuplicate,
3834     TextPara_CanChange,
3835     TextPara_IsEqual,
3836     TextPara_Reset,
3837     TextPara_GetStyle,
3838     TextPara_SetStyle,
3839     TextPara_GetAlignment,
3840     TextPara_SetAlignment,
3841     TextPara_GetHyphenation,
3842     TextPara_SetHyphenation,
3843     TextPara_GetFirstLineIndent,
3844     TextPara_GetKeepTogether,
3845     TextPara_SetKeepTogether,
3846     TextPara_GetKeepWithNext,
3847     TextPara_SetKeepWithNext,
3848     TextPara_GetLeftIndent,
3849     TextPara_GetLineSpacing,
3850     TextPara_GetLineSpacingRule,
3851     TextPara_GetListAlignment,
3852     TextPara_SetListAlignment,
3853     TextPara_GetListLevelIndex,
3854     TextPara_SetListLevelIndex,
3855     TextPara_GetListStart,
3856     TextPara_SetListStart,
3857     TextPara_GetListTab,
3858     TextPara_SetListTab,
3859     TextPara_GetListType,
3860     TextPara_SetListType,
3861     TextPara_GetNoLineNumber,
3862     TextPara_SetNoLineNumber,
3863     TextPara_GetPageBreakBefore,
3864     TextPara_SetPageBreakBefore,
3865     TextPara_GetRightIndent,
3866     TextPara_SetRightIndent,
3867     TextPara_SetIndents,
3868     TextPara_SetLineSpacing,
3869     TextPara_GetSpaceAfter,
3870     TextPara_SetSpaceAfter,
3871     TextPara_GetSpaceBefore,
3872     TextPara_SetSpaceBefore,
3873     TextPara_GetWidowControl,
3874     TextPara_SetWidowControl,
3875     TextPara_GetTabCount,
3876     TextPara_AddTab,
3877     TextPara_ClearAllTabs,
3878     TextPara_DeleteTab,
3879     TextPara_GetTab
3880 };
3881
3882 static HRESULT create_textpara(ITextRange *range, ITextPara **ret)
3883 {
3884     ITextParaImpl *para;
3885
3886     *ret = NULL;
3887     para = heap_alloc(sizeof(*para));
3888     if (!para)
3889         return E_OUTOFMEMORY;
3890
3891     para->ITextPara_iface.lpVtbl = &textparavtbl;
3892     para->ref = 1;
3893     para->range = range;
3894     ITextRange_AddRef(range);
3895
3896     *ret = &para->ITextPara_iface;
3897     return S_OK;
3898 }
3899
3900 /* ITextDocument */
3901 static HRESULT WINAPI ITextDocument2Old_fnQueryInterface(ITextDocument2Old* iface, REFIID riid,
3902                                                          void **ppvObject)
3903 {
3904     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3905     return IRichEditOle_QueryInterface(&This->IRichEditOle_iface, riid, ppvObject);
3906 }
3907
3908 static ULONG WINAPI ITextDocument2Old_fnAddRef(ITextDocument2Old *iface)
3909 {
3910     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3911     return IRichEditOle_AddRef(&This->IRichEditOle_iface);
3912 }
3913
3914 static ULONG WINAPI ITextDocument2Old_fnRelease(ITextDocument2Old *iface)
3915 {
3916     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3917     return IRichEditOle_Release(&This->IRichEditOle_iface);
3918 }
3919
3920 static HRESULT WINAPI ITextDocument2Old_fnGetTypeInfoCount(ITextDocument2Old *iface,
3921                                                            UINT *pctinfo)
3922 {
3923     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3924     TRACE("(%p)->(%p)\n", This, pctinfo);
3925     *pctinfo = 1;
3926     return S_OK;
3927 }
3928
3929 static HRESULT WINAPI ITextDocument2Old_fnGetTypeInfo(ITextDocument2Old *iface, UINT iTInfo, LCID lcid,
3930                                                       ITypeInfo **ppTInfo)
3931 {
3932     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3933     HRESULT hr;
3934
3935     TRACE("(%p)->(%u,%d,%p)\n", This, iTInfo, lcid, ppTInfo);
3936
3937     hr = get_typeinfo(ITextDocument_tid, ppTInfo);
3938     if (SUCCEEDED(hr))
3939         ITypeInfo_AddRef(*ppTInfo);
3940     return hr;
3941 }
3942
3943 static HRESULT WINAPI ITextDocument2Old_fnGetIDsOfNames(ITextDocument2Old *iface, REFIID riid,
3944                                                         LPOLESTR *rgszNames, UINT cNames,
3945                                                         LCID lcid, DISPID *rgDispId)
3946 {
3947     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3948     ITypeInfo *ti;
3949     HRESULT hr;
3950
3951     TRACE("(%p)->(%s, %p, %u, %d, %p)\n", This, debugstr_guid(riid),
3952             rgszNames, cNames, lcid, rgDispId);
3953
3954     hr = get_typeinfo(ITextDocument_tid, &ti);
3955     if (SUCCEEDED(hr))
3956         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
3957     return hr;
3958 }
3959
3960 static HRESULT WINAPI ITextDocument2Old_fnInvoke(ITextDocument2Old *iface, DISPID dispIdMember,
3961                                                  REFIID riid, LCID lcid, WORD wFlags,
3962                                                  DISPPARAMS *pDispParams, VARIANT *pVarResult,
3963                                                  EXCEPINFO *pExcepInfo, UINT *puArgErr)
3964 {
3965     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3966     ITypeInfo *ti;
3967     HRESULT hr;
3968
3969     TRACE("(%p)->(%d, %s, %d, %u, %p, %p, %p, %p)\n", This, dispIdMember,
3970             debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult,
3971             pExcepInfo, puArgErr);
3972
3973     hr = get_typeinfo(ITextDocument_tid, &ti);
3974     if (SUCCEEDED(hr))
3975         hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3976     return hr;
3977 }
3978
3979 static HRESULT WINAPI ITextDocument2Old_fnGetName(ITextDocument2Old *iface, BSTR *pName)
3980 {
3981     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3982     FIXME("stub %p\n",This);
3983     return E_NOTIMPL;
3984 }
3985
3986 static HRESULT WINAPI ITextDocument2Old_fnGetSelection(ITextDocument2Old *iface, ITextSelection **selection)
3987 {
3988     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
3989
3990     TRACE("(%p)->(%p)\n", iface, selection);
3991
3992     if (!selection)
3993       return E_INVALIDARG;
3994
3995     if (!This->txtSel) {
3996       This->txtSel = CreateTextSelection(This);
3997       if (!This->txtSel) {
3998         *selection = NULL;
3999         return E_OUTOFMEMORY;
4000       }
4001     }
4002
4003     *selection = &This->txtSel->ITextSelection_iface;
4004     ITextSelection_AddRef(*selection);
4005     return S_OK;
4006 }
4007
4008 static HRESULT WINAPI ITextDocument2Old_fnGetStoryCount(ITextDocument2Old *iface, LONG *pCount)
4009 {
4010     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4011     FIXME("stub %p\n",This);
4012     return E_NOTIMPL;
4013 }
4014
4015 static HRESULT WINAPI ITextDocument2Old_fnGetStoryRanges(ITextDocument2Old *iface,
4016                                                          ITextStoryRanges **ppStories)
4017 {
4018     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4019     FIXME("stub %p\n",This);
4020     return E_NOTIMPL;
4021 }
4022
4023 static HRESULT WINAPI ITextDocument2Old_fnGetSaved(ITextDocument2Old *iface, LONG *pValue)
4024 {
4025     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4026     FIXME("stub %p\n",This);
4027     return E_NOTIMPL;
4028 }
4029
4030 static HRESULT WINAPI ITextDocument2Old_fnSetSaved(ITextDocument2Old *iface, LONG Value)
4031 {
4032     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4033     FIXME("stub %p\n",This);
4034     return E_NOTIMPL;
4035 }
4036
4037 static HRESULT WINAPI ITextDocument2Old_fnGetDefaultTabStop(ITextDocument2Old *iface, float *pValue)
4038 {
4039     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4040     FIXME("stub %p\n",This);
4041     return E_NOTIMPL;
4042 }
4043
4044 static HRESULT WINAPI ITextDocument2Old_fnSetDefaultTabStop(ITextDocument2Old *iface, float Value)
4045 {
4046     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4047     FIXME("stub %p\n",This);
4048     return E_NOTIMPL;
4049 }
4050
4051 static HRESULT WINAPI ITextDocument2Old_fnNew(ITextDocument2Old *iface)
4052 {
4053     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4054     FIXME("stub %p\n",This);
4055     return E_NOTIMPL;
4056 }
4057
4058 static HRESULT WINAPI ITextDocument2Old_fnOpen(ITextDocument2Old *iface, VARIANT *pVar,
4059                                                LONG Flags, LONG CodePage)
4060 {
4061     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4062     FIXME("stub %p\n",This);
4063     return E_NOTIMPL;
4064 }
4065
4066 static HRESULT WINAPI ITextDocument2Old_fnSave(ITextDocument2Old *iface, VARIANT *pVar,
4067                                                LONG Flags, LONG CodePage)
4068 {
4069     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4070     FIXME("stub %p\n",This);
4071     return E_NOTIMPL;
4072 }
4073
4074 static HRESULT WINAPI ITextDocument2Old_fnFreeze(ITextDocument2Old *iface, LONG *pCount)
4075 {
4076     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4077     FIXME("stub %p\n",This);
4078     return E_NOTIMPL;
4079 }
4080
4081 static HRESULT WINAPI ITextDocument2Old_fnUnfreeze(ITextDocument2Old *iface, LONG *pCount)
4082 {
4083     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4084     FIXME("stub %p\n",This);
4085     return E_NOTIMPL;
4086 }
4087
4088 static HRESULT WINAPI ITextDocument2Old_fnBeginEditCollection(ITextDocument2Old *iface)
4089 {
4090     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4091     FIXME("stub %p\n",This);
4092     return E_NOTIMPL;
4093 }
4094
4095 static HRESULT WINAPI ITextDocument2Old_fnEndEditCollection(ITextDocument2Old *iface)
4096 {
4097     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4098     FIXME("stub %p\n",This);
4099     return E_NOTIMPL;
4100 }
4101
4102 static HRESULT WINAPI ITextDocument2Old_fnUndo(ITextDocument2Old *iface, LONG Count, LONG *prop)
4103 {
4104     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4105     FIXME("stub %p\n",This);
4106     return E_NOTIMPL;
4107 }
4108
4109 static HRESULT WINAPI ITextDocument2Old_fnRedo(ITextDocument2Old *iface, LONG Count, LONG *prop)
4110 {
4111     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4112     FIXME("stub %p\n",This);
4113     return E_NOTIMPL;
4114 }
4115
4116 static HRESULT CreateITextRange(IRichEditOleImpl *reOle, LONG start, LONG end, ITextRange** ppRange)
4117 {
4118     ITextRangeImpl *txtRge = heap_alloc(sizeof(ITextRangeImpl));
4119
4120     if (!txtRge)
4121         return E_OUTOFMEMORY;
4122     txtRge->ITextRange_iface.lpVtbl = &trvt;
4123     txtRge->ref = 1;
4124     txtRge->child.reole = reOle;
4125     txtRge->start = start;
4126     txtRge->end = end;
4127     list_add_head(&reOle->rangelist, &txtRge->child.entry);
4128     *ppRange = &txtRge->ITextRange_iface;
4129     return S_OK;
4130 }
4131
4132 static HRESULT WINAPI ITextDocument2Old_fnRange(ITextDocument2Old *iface, LONG cp1, LONG cp2,
4133                                                 ITextRange **ppRange)
4134 {
4135     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4136
4137     TRACE("%p %p %d %d\n", This, ppRange, cp1, cp2);
4138     if (!ppRange)
4139         return E_INVALIDARG;
4140
4141     cp2range(This->editor, &cp1, &cp2);
4142     return CreateITextRange(This, cp1, cp2, ppRange);
4143 }
4144
4145 static HRESULT WINAPI ITextDocument2Old_fnRangeFromPoint(ITextDocument2Old *iface, LONG x, LONG y,
4146                                                          ITextRange **ppRange)
4147 {
4148     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4149     FIXME("stub %p\n",This);
4150     return E_NOTIMPL;
4151 }
4152
4153 /* ITextDocument2Old methods */
4154 static HRESULT WINAPI ITextDocument2Old_fnAttachMsgFilter(ITextDocument2Old *iface, IUnknown *filter)
4155 {
4156     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4157
4158     FIXME("(%p)->(%p): stub\n", This, filter);
4159
4160     return E_NOTIMPL;
4161 }
4162
4163 static HRESULT WINAPI ITextDocument2Old_fnSetEffectColor(ITextDocument2Old *iface, LONG index, COLORREF cr)
4164 {
4165     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4166
4167     FIXME("(%p)->(%d, 0x%x): stub\n", This, index, cr);
4168
4169     return E_NOTIMPL;
4170 }
4171
4172 static HRESULT WINAPI ITextDocument2Old_fnGetEffectColor(ITextDocument2Old *iface, LONG index, COLORREF *cr)
4173 {
4174     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4175
4176     FIXME("(%p)->(%d, %p): stub\n", This, index, cr);
4177
4178     return E_NOTIMPL;
4179 }
4180
4181 static HRESULT WINAPI ITextDocument2Old_fnGetCaretType(ITextDocument2Old *iface, LONG *type)
4182 {
4183     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4184
4185     FIXME("(%p)->(%p): stub\n", This, type);
4186
4187     return E_NOTIMPL;
4188 }
4189
4190 static HRESULT WINAPI ITextDocument2Old_fnSetCaretType(ITextDocument2Old *iface, LONG type)
4191 {
4192     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4193
4194     FIXME("(%p)->(%d): stub\n", This, type);
4195
4196     return E_NOTIMPL;
4197 }
4198
4199 static HRESULT WINAPI ITextDocument2Old_fnGetImmContext(ITextDocument2Old *iface, LONG *context)
4200 {
4201     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4202
4203     FIXME("(%p)->(%p): stub\n", This, context);
4204
4205     return E_NOTIMPL;
4206 }
4207
4208 static HRESULT WINAPI ITextDocument2Old_fnReleaseImmContext(ITextDocument2Old *iface, LONG context)
4209 {
4210     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4211
4212     FIXME("(%p)->(%d): stub\n", This, context);
4213
4214     return E_NOTIMPL;
4215 }
4216
4217 static HRESULT WINAPI ITextDocument2Old_fnGetPreferredFont(ITextDocument2Old *iface, LONG cp, LONG charrep,
4218                                                            LONG options, LONG current_charrep, LONG current_fontsize,
4219                                                            BSTR *bstr, LONG *pitch_family, LONG *new_fontsize)
4220 {
4221     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4222
4223     FIXME("(%p)->(%d, %d, %d, %d, %d, %p, %p, %p): stub\n", This, cp, charrep, options, current_charrep,
4224           current_fontsize, bstr, pitch_family, new_fontsize);
4225
4226     return E_NOTIMPL;
4227 }
4228
4229 static HRESULT WINAPI ITextDocument2Old_fnGetNotificationMode(ITextDocument2Old *iface, LONG *mode)
4230 {
4231     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4232
4233     FIXME("(%p)->(%p): stub\n", This, mode);
4234
4235     return E_NOTIMPL;
4236 }
4237
4238 static HRESULT WINAPI ITextDocument2Old_fnSetNotificationMode(ITextDocument2Old *iface, LONG mode)
4239 {
4240     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4241
4242     FIXME("(%p)->(0x%x): stub\n", This, mode);
4243
4244     return E_NOTIMPL;
4245 }
4246
4247 static HRESULT WINAPI ITextDocument2Old_fnGetClientRect(ITextDocument2Old *iface, LONG type, LONG *left, LONG *top,
4248                                                         LONG *right, LONG *bottom)
4249 {
4250     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4251
4252     FIXME("(%p)->(%d, %p, %p, %p, %p): stub\n", This, type, left, top, right, bottom);
4253
4254     return E_NOTIMPL;
4255 }
4256
4257 static HRESULT WINAPI ITextDocument2Old_fnGetSelectionEx(ITextDocument2Old *iface, ITextSelection **selection)
4258 {
4259     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4260
4261     FIXME("(%p)->(%p): stub\n", This, selection);
4262
4263     return E_NOTIMPL;
4264 }
4265
4266 static HRESULT WINAPI ITextDocument2Old_fnGetWindow(ITextDocument2Old *iface, LONG *hwnd)
4267 {
4268     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4269
4270     FIXME("(%p)->(%p): stub\n", This, hwnd);
4271
4272     return E_NOTIMPL;
4273 }
4274
4275 static HRESULT WINAPI ITextDocument2Old_fnGetFEFlags(ITextDocument2Old *iface, LONG *flags)
4276 {
4277     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4278
4279     FIXME("(%p)->(%p): stub\n", This, flags);
4280
4281     return E_NOTIMPL;
4282 }
4283
4284 static HRESULT WINAPI ITextDocument2Old_fnUpdateWindow(ITextDocument2Old *iface)
4285 {
4286     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4287
4288     FIXME("(%p): stub\n", This);
4289
4290     return E_NOTIMPL;
4291 }
4292
4293 static HRESULT WINAPI ITextDocument2Old_fnCheckTextLimit(ITextDocument2Old *iface, LONG cch, LONG *exceed)
4294 {
4295     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4296
4297     FIXME("(%p)->(%d, %p): stub\n", This, cch, exceed);
4298
4299     return E_NOTIMPL;
4300 }
4301
4302 static HRESULT WINAPI ITextDocument2Old_fnIMEInProgress(ITextDocument2Old *iface, LONG mode)
4303 {
4304     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4305
4306     FIXME("(%p)->(0x%x): stub\n", This, mode);
4307
4308     return E_NOTIMPL;
4309 }
4310
4311 static HRESULT WINAPI ITextDocument2Old_fnSysBeep(ITextDocument2Old *iface)
4312 {
4313     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4314
4315     FIXME("(%p): stub\n", This);
4316
4317     return E_NOTIMPL;
4318 }
4319
4320 static HRESULT WINAPI ITextDocument2Old_fnUpdate(ITextDocument2Old *iface, LONG mode)
4321 {
4322     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4323
4324     FIXME("(%p)->(0x%x): stub\n", This, mode);
4325
4326     return E_NOTIMPL;
4327 }
4328
4329 static HRESULT WINAPI ITextDocument2Old_fnNotify(ITextDocument2Old *iface, LONG notify)
4330 {
4331     IRichEditOleImpl *This = impl_from_ITextDocument2Old(iface);
4332
4333     FIXME("(%p)->(%d): stub\n", This, notify);
4334
4335     return E_NOTIMPL;
4336 }
4337
4338 static const ITextDocument2OldVtbl tdvt = {
4339     ITextDocument2Old_fnQueryInterface,
4340     ITextDocument2Old_fnAddRef,
4341     ITextDocument2Old_fnRelease,
4342     ITextDocument2Old_fnGetTypeInfoCount,
4343     ITextDocument2Old_fnGetTypeInfo,
4344     ITextDocument2Old_fnGetIDsOfNames,
4345     ITextDocument2Old_fnInvoke,
4346     ITextDocument2Old_fnGetName,
4347     ITextDocument2Old_fnGetSelection,
4348     ITextDocument2Old_fnGetStoryCount,
4349     ITextDocument2Old_fnGetStoryRanges,
4350     ITextDocument2Old_fnGetSaved,
4351     ITextDocument2Old_fnSetSaved,
4352     ITextDocument2Old_fnGetDefaultTabStop,
4353     ITextDocument2Old_fnSetDefaultTabStop,
4354     ITextDocument2Old_fnNew,
4355     ITextDocument2Old_fnOpen,
4356     ITextDocument2Old_fnSave,
4357     ITextDocument2Old_fnFreeze,
4358     ITextDocument2Old_fnUnfreeze,
4359     ITextDocument2Old_fnBeginEditCollection,
4360     ITextDocument2Old_fnEndEditCollection,
4361     ITextDocument2Old_fnUndo,
4362     ITextDocument2Old_fnRedo,
4363     ITextDocument2Old_fnRange,
4364     ITextDocument2Old_fnRangeFromPoint,
4365     /* ITextDocument2Old methods */
4366     ITextDocument2Old_fnAttachMsgFilter,
4367     ITextDocument2Old_fnSetEffectColor,
4368     ITextDocument2Old_fnGetEffectColor,
4369     ITextDocument2Old_fnGetCaretType,
4370     ITextDocument2Old_fnSetCaretType,
4371     ITextDocument2Old_fnGetImmContext,
4372     ITextDocument2Old_fnReleaseImmContext,
4373     ITextDocument2Old_fnGetPreferredFont,
4374     ITextDocument2Old_fnGetNotificationMode,
4375     ITextDocument2Old_fnSetNotificationMode,
4376     ITextDocument2Old_fnGetClientRect,
4377     ITextDocument2Old_fnGetSelectionEx,
4378     ITextDocument2Old_fnGetWindow,
4379     ITextDocument2Old_fnGetFEFlags,
4380     ITextDocument2Old_fnUpdateWindow,
4381     ITextDocument2Old_fnCheckTextLimit,
4382     ITextDocument2Old_fnIMEInProgress,
4383     ITextDocument2Old_fnSysBeep,
4384     ITextDocument2Old_fnUpdate,
4385     ITextDocument2Old_fnNotify
4386 };
4387
4388 /* ITextSelection */
4389 static HRESULT WINAPI ITextSelection_fnQueryInterface(
4390     ITextSelection *me,
4391     REFIID riid,
4392     void **ppvObj)
4393 {
4394     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4395
4396     *ppvObj = NULL;
4397     if (IsEqualGUID(riid, &IID_IUnknown)
4398         || IsEqualGUID(riid, &IID_IDispatch)
4399         || IsEqualGUID(riid, &IID_ITextRange)
4400         || IsEqualGUID(riid, &IID_ITextSelection))
4401     {
4402         *ppvObj = me;
4403         ITextSelection_AddRef(me);
4404         return S_OK;
4405     }
4406     else if (IsEqualGUID(riid, &IID_Igetrichole))
4407     {
4408         *ppvObj = This->reOle;
4409         return S_OK;
4410     }
4411
4412     return E_NOINTERFACE;
4413 }
4414
4415 static ULONG WINAPI ITextSelection_fnAddRef(ITextSelection *me)
4416 {
4417     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4418     return InterlockedIncrement(&This->ref);
4419 }
4420
4421 static ULONG WINAPI ITextSelection_fnRelease(ITextSelection *me)
4422 {
4423     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4424     ULONG ref = InterlockedDecrement(&This->ref);
4425     if (ref == 0)
4426         heap_free(This);
4427     return ref;
4428 }
4429
4430 static HRESULT WINAPI ITextSelection_fnGetTypeInfoCount(ITextSelection *me, UINT *pctinfo)
4431 {
4432     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4433     TRACE("(%p)->(%p)\n", This, pctinfo);
4434     *pctinfo = 1;
4435     return S_OK;
4436 }
4437
4438 static HRESULT WINAPI ITextSelection_fnGetTypeInfo(ITextSelection *me, UINT iTInfo, LCID lcid,
4439     ITypeInfo **ppTInfo)
4440 {
4441     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4442     HRESULT hr;
4443
4444     TRACE("(%p)->(%u,%d,%p)\n", This, iTInfo, lcid, ppTInfo);
4445
4446     hr = get_typeinfo(ITextSelection_tid, ppTInfo);
4447     if (SUCCEEDED(hr))
4448         ITypeInfo_AddRef(*ppTInfo);
4449     return hr;
4450 }
4451
4452 static HRESULT WINAPI ITextSelection_fnGetIDsOfNames(ITextSelection *me, REFIID riid,
4453     LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4454 {
4455     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4456     ITypeInfo *ti;
4457     HRESULT hr;
4458
4459     TRACE("(%p)->(%s, %p, %u, %d, %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid,
4460             rgDispId);
4461
4462     hr = get_typeinfo(ITextSelection_tid, &ti);
4463     if (SUCCEEDED(hr))
4464         hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
4465     return hr;
4466 }
4467
4468 static HRESULT WINAPI ITextSelection_fnInvoke(
4469     ITextSelection *me,
4470     DISPID dispIdMember,
4471     REFIID riid,
4472     LCID lcid,
4473     WORD wFlags,
4474     DISPPARAMS *pDispParams,
4475     VARIANT *pVarResult,
4476     EXCEPINFO *pExcepInfo,
4477     UINT *puArgErr)
4478 {
4479     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4480     ITypeInfo *ti;
4481     HRESULT hr;
4482
4483     TRACE("(%p)->(%d, %s, %d, %u, %p, %p, %p, %p)\n", This, dispIdMember, debugstr_guid(riid), lcid,
4484             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4485
4486     hr = get_typeinfo(ITextSelection_tid, &ti);
4487     if (SUCCEEDED(hr))
4488         hr = ITypeInfo_Invoke(ti, me, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4489     return hr;
4490 }
4491
4492 /*** ITextRange methods ***/
4493 static HRESULT WINAPI ITextSelection_fnGetText(ITextSelection *me, BSTR *pbstr)
4494 {
4495     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4496     ME_Cursor *start = NULL, *end = NULL;
4497     int nChars, endOfs;
4498     BOOL bEOP;
4499
4500     TRACE("(%p)->(%p)\n", This, pbstr);
4501
4502     if (!This->reOle)
4503         return CO_E_RELEASED;
4504
4505     if (!pbstr)
4506         return E_INVALIDARG;
4507
4508     ME_GetSelection(This->reOle->editor, &start, &end);
4509     endOfs = ME_GetCursorOfs(end);
4510     nChars = endOfs - ME_GetCursorOfs(start);
4511     if (!nChars)
4512     {
4513         *pbstr = NULL;
4514         return S_OK;
4515     }
4516
4517     *pbstr = SysAllocStringLen(NULL, nChars);
4518     if (!*pbstr)
4519         return E_OUTOFMEMORY;
4520
4521     bEOP = (end->pRun->next->type == diTextEnd && endOfs > ME_GetTextLength(This->reOle->editor));
4522     ME_GetTextW(This->reOle->editor, *pbstr, nChars, start, nChars, FALSE, bEOP);
4523     TRACE("%s\n", wine_dbgstr_w(*pbstr));
4524
4525     return S_OK;
4526 }
4527
4528 static HRESULT WINAPI ITextSelection_fnSetText(ITextSelection *me, BSTR str)
4529 {
4530     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4531     ME_TextEditor *editor;
4532     int len, to, from;
4533
4534     TRACE("(%p)->(%s)\n", This, debugstr_w(str));
4535
4536     if (!This->reOle)
4537         return CO_E_RELEASED;
4538
4539     editor = This->reOle->editor;
4540     len = lstrlenW(str);
4541     ME_GetSelectionOfs(editor, &from, &to);
4542     ME_ReplaceSel(editor, FALSE, str, len);
4543
4544     if (len < to - from)
4545         textranges_update_ranges(This->reOle, from, len, RANGE_UPDATE_DELETE);
4546
4547     return S_OK;
4548 }
4549
4550 static HRESULT WINAPI ITextSelection_fnGetChar(ITextSelection *me, LONG *pch)
4551 {
4552     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4553     ME_Cursor *start = NULL, *end = NULL;
4554
4555     TRACE("(%p)->(%p)\n", This, pch);
4556
4557     if (!This->reOle)
4558         return CO_E_RELEASED;
4559
4560     if (!pch)
4561         return E_INVALIDARG;
4562
4563     ME_GetSelection(This->reOle->editor, &start, &end);
4564     return range_GetChar(This->reOle->editor, start, pch);
4565 }
4566
4567 static HRESULT WINAPI ITextSelection_fnSetChar(ITextSelection *me, LONG ch)
4568 {
4569     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4570
4571     FIXME("(%p)->(%x): stub\n", This, ch);
4572
4573     if (!This->reOle)
4574         return CO_E_RELEASED;
4575
4576     return E_NOTIMPL;
4577 }
4578
4579 static HRESULT WINAPI ITextSelection_fnGetDuplicate(ITextSelection *me, ITextRange **range)
4580 {
4581     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4582     LONG start, end;
4583
4584     TRACE("(%p)->(%p)\n", This, range);
4585
4586     if (!This->reOle)
4587         return CO_E_RELEASED;
4588
4589     if (!range)
4590         return E_INVALIDARG;
4591
4592     ITextSelection_GetStart(me, &start);
4593     ITextSelection_GetEnd(me, &end);
4594     return CreateITextRange(This->reOle, start, end, range);
4595 }
4596
4597 static HRESULT WINAPI ITextSelection_fnGetFormattedText(ITextSelection *me, ITextRange **range)
4598 {
4599     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4600
4601     FIXME("(%p)->(%p): stub\n", This, range);
4602
4603     if (!This->reOle)
4604         return CO_E_RELEASED;
4605
4606     return E_NOTIMPL;
4607 }
4608
4609 static HRESULT WINAPI ITextSelection_fnSetFormattedText(ITextSelection *me, ITextRange *range)
4610 {
4611     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4612
4613     FIXME("(%p)->(%p): stub\n", This, range);
4614
4615     if (!This->reOle)
4616         return CO_E_RELEASED;
4617
4618     FIXME("not implemented\n");
4619     return E_NOTIMPL;
4620 }
4621
4622 static HRESULT WINAPI ITextSelection_fnGetStart(ITextSelection *me, LONG *pcpFirst)
4623 {
4624     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4625     LONG lim;
4626
4627     TRACE("(%p)->(%p)\n", This, pcpFirst);
4628
4629     if (!This->reOle)
4630         return CO_E_RELEASED;
4631
4632     if (!pcpFirst)
4633         return E_INVALIDARG;
4634     ME_GetSelectionOfs(This->reOle->editor, pcpFirst, &lim);
4635     return S_OK;
4636 }
4637
4638 static HRESULT WINAPI ITextSelection_fnSetStart(ITextSelection *me, LONG value)
4639 {
4640     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4641     LONG start, end;
4642     HRESULT hr;
4643
4644     TRACE("(%p)->(%d)\n", This, value);
4645
4646     if (!This->reOle)
4647         return CO_E_RELEASED;
4648
4649     ME_GetSelectionOfs(This->reOle->editor, &start, &end);
4650     hr = textrange_setstart(This->reOle, value, &start, &end);
4651     if (hr == S_OK)
4652         set_selection(This->reOle->editor, start, end);
4653
4654     return hr;
4655 }
4656
4657 static HRESULT WINAPI ITextSelection_fnGetEnd(ITextSelection *me, LONG *pcpLim)
4658 {
4659     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4660     LONG first;
4661
4662     TRACE("(%p)->(%p)\n", This, pcpLim);
4663
4664     if (!This->reOle)
4665         return CO_E_RELEASED;
4666
4667     if (!pcpLim)
4668         return E_INVALIDARG;
4669     ME_GetSelectionOfs(This->reOle->editor, &first, pcpLim);
4670     return S_OK;
4671 }
4672
4673 static HRESULT WINAPI ITextSelection_fnSetEnd(ITextSelection *me, LONG value)
4674 {
4675     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4676     LONG start, end;
4677     HRESULT hr;
4678
4679     TRACE("(%p)->(%d)\n", This, value);
4680
4681     if (!This->reOle)
4682         return CO_E_RELEASED;
4683
4684     ME_GetSelectionOfs(This->reOle->editor, &start, &end);
4685     hr = textrange_setend(This->reOle, value, &start, &end);
4686     if (hr == S_OK)
4687         set_selection(This->reOle->editor, start, end);
4688
4689     return hr;
4690 }
4691
4692 static HRESULT WINAPI ITextSelection_fnGetFont(ITextSelection *me, ITextFont **font)
4693 {
4694     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4695     ITextRange *range = NULL;
4696     HRESULT hr;
4697
4698     TRACE("(%p)->(%p)\n", This, font);
4699
4700     if (!This->reOle)
4701         return CO_E_RELEASED;
4702
4703     if (!font)
4704         return E_INVALIDARG;
4705
4706     ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
4707     hr = create_textfont(range, NULL, font);
4708     ITextRange_Release(range);
4709     return hr;
4710 }
4711
4712 static HRESULT WINAPI ITextSelection_fnSetFont(ITextSelection *me, ITextFont *font)
4713 {
4714     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4715     ITextRange *range = NULL;
4716
4717     TRACE("(%p)->(%p)\n", This, font);
4718
4719     if (!font)
4720         return E_INVALIDARG;
4721
4722     if (!This->reOle)
4723         return CO_E_RELEASED;
4724
4725     ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
4726     textrange_set_font(range, font);
4727     ITextRange_Release(range);
4728     return S_OK;
4729 }
4730
4731 static HRESULT WINAPI ITextSelection_fnGetPara(ITextSelection *me, ITextPara **para)
4732 {
4733     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4734     ITextRange *range = NULL;
4735     HRESULT hr;
4736
4737     TRACE("(%p)->(%p)\n", This, para);
4738
4739     if (!This->reOle)
4740         return CO_E_RELEASED;
4741
4742     if (!para)
4743         return E_INVALIDARG;
4744
4745     ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
4746     hr = create_textpara(range, para);
4747     ITextRange_Release(range);
4748     return hr;
4749 }
4750
4751 static HRESULT WINAPI ITextSelection_fnSetPara(ITextSelection *me, ITextPara *para)
4752 {
4753     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4754
4755     FIXME("(%p)->(%p): stub\n", This, para);
4756
4757     if (!This->reOle)
4758         return CO_E_RELEASED;
4759
4760     FIXME("not implemented\n");
4761     return E_NOTIMPL;
4762 }
4763
4764 static HRESULT WINAPI ITextSelection_fnGetStoryLength(ITextSelection *me, LONG *length)
4765 {
4766     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4767
4768     TRACE("(%p)->(%p)\n", This, length);
4769
4770     if (!This->reOle)
4771         return CO_E_RELEASED;
4772
4773     return textrange_get_storylength(This->reOle->editor, length);
4774 }
4775
4776 static HRESULT WINAPI ITextSelection_fnGetStoryType(ITextSelection *me, LONG *value)
4777 {
4778     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4779
4780     TRACE("(%p)->(%p)\n", This, value);
4781
4782     if (!This->reOle)
4783         return CO_E_RELEASED;
4784
4785     if (!value)
4786         return E_INVALIDARG;
4787
4788     *value = tomUnknownStory;
4789     return S_OK;
4790 }
4791
4792 static HRESULT WINAPI ITextSelection_fnCollapse(ITextSelection *me, LONG bStart)
4793 {
4794     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4795     LONG start, end;
4796     HRESULT hres;
4797
4798     TRACE("(%p)->(%d)\n", This, bStart);
4799
4800     if (!This->reOle)
4801         return CO_E_RELEASED;
4802
4803     ME_GetSelectionOfs(This->reOle->editor, &start, &end);
4804     hres = range_Collapse(bStart, &start, &end);
4805     if (SUCCEEDED(hres))
4806         set_selection(This->reOle->editor, start, end);
4807     return hres;
4808 }
4809
4810 static HRESULT WINAPI ITextSelection_fnExpand(ITextSelection *me, LONG unit, LONG *delta)
4811 {
4812     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4813     ITextRange *range = NULL;
4814     HRESULT hr;
4815
4816     TRACE("(%p)->(%d %p)\n", This, unit, delta);
4817
4818     if (!This->reOle)
4819         return CO_E_RELEASED;
4820
4821     ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
4822     hr = textrange_expand(range, unit, delta);
4823     ITextRange_Release(range);
4824     return hr;
4825 }
4826
4827 static HRESULT WINAPI ITextSelection_fnGetIndex(ITextSelection *me, LONG unit, LONG *index)
4828 {
4829     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4830
4831     FIXME("(%p)->(%d %p): stub\n", This, unit, index);
4832
4833     if (!This->reOle)
4834         return CO_E_RELEASED;
4835
4836     return E_NOTIMPL;
4837 }
4838
4839 static HRESULT WINAPI ITextSelection_fnSetIndex(ITextSelection *me, LONG unit, LONG index,
4840     LONG extend)
4841 {
4842     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4843
4844     FIXME("(%p)->(%d %d %d): stub\n", This, unit, index, extend);
4845
4846     if (!This->reOle)
4847         return CO_E_RELEASED;
4848
4849     return E_NOTIMPL;
4850 }
4851
4852 static HRESULT WINAPI ITextSelection_fnSetRange(ITextSelection *me, LONG anchor, LONG active)
4853 {
4854     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4855
4856     FIXME("(%p)->(%d %d): stub\n", This, anchor, active);
4857
4858     if (!This->reOle)
4859         return CO_E_RELEASED;
4860
4861     return E_NOTIMPL;
4862 }
4863
4864 static HRESULT WINAPI ITextSelection_fnInRange(ITextSelection *me, ITextRange *range, LONG *ret)
4865 {
4866     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4867     ITextSelection *selection = NULL;
4868     LONG start, end;
4869
4870     TRACE("(%p)->(%p %p)\n", This, range, ret);
4871
4872     if (ret)
4873         *ret = tomFalse;
4874
4875     if (!This->reOle)
4876         return CO_E_RELEASED;
4877
4878     if (!range)
4879         return S_FALSE;
4880
4881     ITextRange_QueryInterface(range, &IID_ITextSelection, (void**)&selection);
4882     if (!selection)
4883         return S_FALSE;
4884     ITextSelection_Release(selection);
4885
4886     ITextSelection_GetStart(me, &start);
4887     ITextSelection_GetEnd(me, &end);
4888     return textrange_inrange(start, end, range, ret);
4889 }
4890
4891 static HRESULT WINAPI ITextSelection_fnInStory(ITextSelection *me, ITextRange *range, LONG *ret)
4892 {
4893     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4894
4895     FIXME("(%p)->(%p %p): stub\n", This, range, ret);
4896
4897     if (!This->reOle)
4898         return CO_E_RELEASED;
4899
4900     return E_NOTIMPL;
4901 }
4902
4903 static HRESULT WINAPI ITextSelection_fnIsEqual(ITextSelection *me, ITextRange *range, LONG *ret)
4904 {
4905     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4906     ITextSelection *selection = NULL;
4907     LONG start, end;
4908
4909     TRACE("(%p)->(%p %p)\n", This, range, ret);
4910
4911     if (ret)
4912         *ret = tomFalse;
4913
4914     if (!This->reOle)
4915         return CO_E_RELEASED;
4916
4917     if (!range)
4918         return S_FALSE;
4919
4920     ITextRange_QueryInterface(range, &IID_ITextSelection, (void**)&selection);
4921     if (!selection)
4922         return S_FALSE;
4923     ITextSelection_Release(selection);
4924
4925     ITextSelection_GetStart(me, &start);
4926     ITextSelection_GetEnd(me, &end);
4927     return textrange_isequal(start, end, range, ret);
4928 }
4929
4930 static HRESULT WINAPI ITextSelection_fnSelect(ITextSelection *me)
4931 {
4932     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4933
4934     TRACE("(%p)\n", This);
4935
4936     if (!This->reOle)
4937         return CO_E_RELEASED;
4938
4939     /* nothing to do */
4940     return S_OK;
4941 }
4942
4943 static HRESULT WINAPI ITextSelection_fnStartOf(ITextSelection *me, LONG unit, LONG extend,
4944     LONG *delta)
4945 {
4946     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4947
4948     FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
4949
4950     if (!This->reOle)
4951         return CO_E_RELEASED;
4952
4953     return E_NOTIMPL;
4954 }
4955
4956 static HRESULT WINAPI ITextSelection_fnEndOf(ITextSelection *me, LONG unit, LONG extend,
4957     LONG *delta)
4958 {
4959     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4960
4961     FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
4962
4963     if (!This->reOle)
4964         return CO_E_RELEASED;
4965
4966     return E_NOTIMPL;
4967 }
4968
4969 static HRESULT WINAPI ITextSelection_fnMove(ITextSelection *me, LONG unit, LONG count, LONG *delta)
4970 {
4971     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4972
4973     FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
4974
4975     if (!This->reOle)
4976         return CO_E_RELEASED;
4977
4978     return E_NOTIMPL;
4979 }
4980
4981 static HRESULT WINAPI ITextSelection_fnMoveStart(ITextSelection *me, LONG unit, LONG count,
4982     LONG *delta)
4983 {
4984     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4985
4986     FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
4987
4988     if (!This->reOle)
4989         return CO_E_RELEASED;
4990
4991     return E_NOTIMPL;
4992 }
4993
4994 static HRESULT WINAPI ITextSelection_fnMoveEnd(ITextSelection *me, LONG unit, LONG count,
4995     LONG *delta)
4996 {
4997     ITextSelectionImpl *This = impl_from_ITextSelection(me);
4998     ITextRange *range = NULL;
4999     HRESULT hr;
5000
5001     TRACE("(%p)->(%d %d %p)\n", This, unit, count, delta);
5002
5003     if (!This->reOle)
5004         return CO_E_RELEASED;
5005
5006     ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
5007     hr = textrange_moveend(range, unit, count, delta);
5008     ITextRange_Release(range);
5009     return hr;
5010 }
5011
5012 static HRESULT WINAPI ITextSelection_fnMoveWhile(ITextSelection *me, VARIANT *charset, LONG count,
5013     LONG *delta)
5014 {
5015     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5016
5017     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5018
5019     if (!This->reOle)
5020         return CO_E_RELEASED;
5021
5022     return E_NOTIMPL;
5023 }
5024
5025 static HRESULT WINAPI ITextSelection_fnMoveStartWhile(ITextSelection *me, VARIANT *charset, LONG count,
5026     LONG *delta)
5027 {
5028     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5029
5030     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5031
5032     if (!This->reOle)
5033         return CO_E_RELEASED;
5034
5035     return E_NOTIMPL;
5036 }
5037
5038 static HRESULT WINAPI ITextSelection_fnMoveEndWhile(ITextSelection *me, VARIANT *charset, LONG count,
5039     LONG *delta)
5040 {
5041     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5042
5043     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5044
5045     if (!This->reOle)
5046         return CO_E_RELEASED;
5047
5048     return E_NOTIMPL;
5049 }
5050
5051 static HRESULT WINAPI ITextSelection_fnMoveUntil(ITextSelection *me, VARIANT *charset, LONG count,
5052     LONG *delta)
5053 {
5054     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5055
5056     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5057
5058     if (!This->reOle)
5059         return CO_E_RELEASED;
5060
5061     return E_NOTIMPL;
5062 }
5063
5064 static HRESULT WINAPI ITextSelection_fnMoveStartUntil(ITextSelection *me, VARIANT *charset, LONG count,
5065     LONG *delta)
5066 {
5067     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5068
5069     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5070
5071     if (!This->reOle)
5072         return CO_E_RELEASED;
5073
5074     return E_NOTIMPL;
5075 }
5076
5077 static HRESULT WINAPI ITextSelection_fnMoveEndUntil(ITextSelection *me, VARIANT *charset, LONG count,
5078     LONG *delta)
5079 {
5080     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5081
5082     FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5083
5084     if (!This->reOle)
5085         return CO_E_RELEASED;
5086
5087     return E_NOTIMPL;
5088 }
5089
5090 static HRESULT WINAPI ITextSelection_fnFindText(ITextSelection *me, BSTR text, LONG count, LONG flags,
5091     LONG *length)
5092 {
5093     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5094
5095     FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
5096
5097     if (!This->reOle)
5098         return CO_E_RELEASED;
5099
5100     FIXME("not implemented\n");
5101     return E_NOTIMPL;
5102 }
5103
5104 static HRESULT WINAPI ITextSelection_fnFindTextStart(ITextSelection *me, BSTR text, LONG count,
5105     LONG flags, LONG *length)
5106 {
5107     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5108
5109     FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
5110
5111     if (!This->reOle)
5112         return CO_E_RELEASED;
5113
5114     return E_NOTIMPL;
5115 }
5116
5117 static HRESULT WINAPI ITextSelection_fnFindTextEnd(ITextSelection *me, BSTR text, LONG count,
5118     LONG flags, LONG *length)
5119 {
5120     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5121
5122     FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
5123
5124     if (!This->reOle)
5125         return CO_E_RELEASED;
5126
5127     return E_NOTIMPL;
5128 }
5129
5130 static HRESULT WINAPI ITextSelection_fnDelete(ITextSelection *me, LONG unit, LONG count,
5131     LONG *delta)
5132 {
5133     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5134
5135     FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
5136
5137     if (!This->reOle)
5138         return CO_E_RELEASED;
5139
5140     return E_NOTIMPL;
5141 }
5142
5143 static HRESULT WINAPI ITextSelection_fnCut(ITextSelection *me, VARIANT *v)
5144 {
5145     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5146
5147     FIXME("(%p)->(%p): stub\n", This, v);
5148
5149     if (!This->reOle)
5150         return CO_E_RELEASED;
5151
5152     return E_NOTIMPL;
5153 }
5154
5155 static HRESULT WINAPI ITextSelection_fnCopy(ITextSelection *me, VARIANT *v)
5156 {
5157     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5158
5159     FIXME("(%p)->(%p): stub\n", This, v);
5160
5161     if (!This->reOle)
5162         return CO_E_RELEASED;
5163
5164     return E_NOTIMPL;
5165 }
5166
5167 static HRESULT WINAPI ITextSelection_fnPaste(ITextSelection *me, VARIANT *v, LONG format)
5168 {
5169     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5170
5171     FIXME("(%p)->(%s %x): stub\n", This, debugstr_variant(v), format);
5172
5173     if (!This->reOle)
5174         return CO_E_RELEASED;
5175
5176     return E_NOTIMPL;
5177 }
5178
5179 static HRESULT WINAPI ITextSelection_fnCanPaste(ITextSelection *me, VARIANT *v, LONG format,
5180     LONG *ret)
5181 {
5182     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5183
5184     FIXME("(%p)->(%s %x %p): stub\n", This, debugstr_variant(v), format, ret);
5185
5186     if (!This->reOle)
5187         return CO_E_RELEASED;
5188
5189     return E_NOTIMPL;
5190 }
5191
5192 static HRESULT WINAPI ITextSelection_fnCanEdit(ITextSelection *me, LONG *ret)
5193 {
5194     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5195
5196     FIXME("(%p)->(%p): stub\n", This, ret);
5197
5198     if (!This->reOle)
5199         return CO_E_RELEASED;
5200
5201     return E_NOTIMPL;
5202 }
5203
5204 static HRESULT WINAPI ITextSelection_fnChangeCase(ITextSelection *me, LONG type)
5205 {
5206     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5207
5208     FIXME("(%p)->(%d): stub\n", This, type);
5209
5210     if (!This->reOle)
5211         return CO_E_RELEASED;
5212
5213     return E_NOTIMPL;
5214 }
5215
5216 static HRESULT WINAPI ITextSelection_fnGetPoint(ITextSelection *me, LONG type, LONG *cx, LONG *cy)
5217 {
5218     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5219
5220     FIXME("(%p)->(%d %p %p): stub\n", This, type, cx, cy);
5221
5222     if (!This->reOle)
5223         return CO_E_RELEASED;
5224
5225     return E_NOTIMPL;
5226 }
5227
5228 static HRESULT WINAPI ITextSelection_fnSetPoint(ITextSelection *me, LONG x, LONG y, LONG type,
5229     LONG extend)
5230 {
5231     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5232
5233     FIXME("(%p)->(%d %d %d %d): stub\n", This, x, y, type, extend);
5234
5235     if (!This->reOle)
5236         return CO_E_RELEASED;
5237
5238     return E_NOTIMPL;
5239 }
5240
5241 static HRESULT WINAPI ITextSelection_fnScrollIntoView(ITextSelection *me, LONG value)
5242 {
5243     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5244
5245     FIXME("(%p)->(%d): stub\n", This, value);
5246
5247     if (!This->reOle)
5248         return CO_E_RELEASED;
5249
5250     return E_NOTIMPL;
5251 }
5252
5253 static HRESULT WINAPI ITextSelection_fnGetEmbeddedObject(ITextSelection *me, IUnknown **ppv)
5254 {
5255     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5256
5257     FIXME("(%p)->(%p): stub\n", This, ppv);
5258
5259     if (!This->reOle)
5260         return CO_E_RELEASED;
5261
5262     return E_NOTIMPL;
5263 }
5264
5265 /*** ITextSelection methods ***/
5266 static HRESULT WINAPI ITextSelection_fnGetFlags(ITextSelection *me, LONG *flags)
5267 {
5268     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5269
5270     FIXME("(%p)->(%p): stub\n", This, flags);
5271
5272     if (!This->reOle)
5273         return CO_E_RELEASED;
5274
5275     return E_NOTIMPL;
5276 }
5277
5278 static HRESULT WINAPI ITextSelection_fnSetFlags(ITextSelection *me, LONG flags)
5279 {
5280     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5281
5282     FIXME("(%p)->(%x): stub\n", This, flags);
5283
5284     if (!This->reOle)
5285         return CO_E_RELEASED;
5286
5287     return E_NOTIMPL;
5288 }
5289
5290 static HRESULT WINAPI ITextSelection_fnGetType(ITextSelection *me, LONG *type)
5291 {
5292     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5293
5294     FIXME("(%p)->(%p): stub\n", This, type);
5295
5296     if (!This->reOle)
5297         return CO_E_RELEASED;
5298
5299     return E_NOTIMPL;
5300 }
5301
5302 static HRESULT WINAPI ITextSelection_fnMoveLeft(ITextSelection *me, LONG unit, LONG count,
5303     LONG extend, LONG *delta)
5304 {
5305     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5306
5307     FIXME("(%p)->(%d %d %d %p): stub\n", This, unit, count, extend, delta);
5308
5309     if (!This->reOle)
5310         return CO_E_RELEASED;
5311
5312     return E_NOTIMPL;
5313 }
5314
5315 static HRESULT WINAPI ITextSelection_fnMoveRight(ITextSelection *me, LONG unit, LONG count,
5316     LONG extend, LONG *delta)
5317 {
5318     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5319
5320     FIXME("(%p)->(%d %d %d %p): stub\n", This, unit, count, extend, delta);
5321
5322     if (!This->reOle)
5323         return CO_E_RELEASED;
5324
5325     return E_NOTIMPL;
5326 }
5327
5328 static HRESULT WINAPI ITextSelection_fnMoveUp(ITextSelection *me, LONG unit, LONG count,
5329     LONG extend, LONG *delta)
5330 {
5331     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5332
5333     FIXME("(%p)->(%d %d %d %p): stub\n", This, unit, count, extend, delta);
5334
5335     if (!This->reOle)
5336         return CO_E_RELEASED;
5337
5338     return E_NOTIMPL;
5339 }
5340
5341 static HRESULT WINAPI ITextSelection_fnMoveDown(ITextSelection *me, LONG unit, LONG count,
5342     LONG extend, LONG *delta)
5343 {
5344     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5345
5346     FIXME("(%p)->(%d %d %d %p): stub\n", This, unit, count, extend, delta);
5347
5348     if (!This->reOle)
5349         return CO_E_RELEASED;
5350
5351     return E_NOTIMPL;
5352 }
5353
5354 static HRESULT WINAPI ITextSelection_fnHomeKey(ITextSelection *me, LONG unit, LONG extend,
5355     LONG *delta)
5356 {
5357     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5358
5359     FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
5360
5361     if (!This->reOle)
5362         return CO_E_RELEASED;
5363
5364     return E_NOTIMPL;
5365 }
5366
5367 static HRESULT WINAPI ITextSelection_fnEndKey(ITextSelection *me, LONG unit, LONG extend,
5368     LONG *delta)
5369 {
5370     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5371
5372     FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
5373
5374     if (!This->reOle)
5375         return CO_E_RELEASED;
5376
5377     return E_NOTIMPL;
5378 }
5379
5380 static HRESULT WINAPI ITextSelection_fnTypeText(ITextSelection *me, BSTR text)
5381 {
5382     ITextSelectionImpl *This = impl_from_ITextSelection(me);
5383
5384     FIXME("(%p)->(%s): stub\n", This, debugstr_w(text));
5385
5386     if (!This->reOle)
5387         return CO_E_RELEASED;
5388
5389     return E_NOTIMPL;
5390 }
5391
5392 static const ITextSelectionVtbl tsvt = {
5393     ITextSelection_fnQueryInterface,
5394     ITextSelection_fnAddRef,
5395     ITextSelection_fnRelease,
5396     ITextSelection_fnGetTypeInfoCount,
5397     ITextSelection_fnGetTypeInfo,
5398     ITextSelection_fnGetIDsOfNames,
5399     ITextSelection_fnInvoke,
5400     ITextSelection_fnGetText,
5401     ITextSelection_fnSetText,
5402     ITextSelection_fnGetChar,
5403     ITextSelection_fnSetChar,
5404     ITextSelection_fnGetDuplicate,
5405     ITextSelection_fnGetFormattedText,
5406     ITextSelection_fnSetFormattedText,
5407     ITextSelection_fnGetStart,
5408     ITextSelection_fnSetStart,
5409     ITextSelection_fnGetEnd,
5410     ITextSelection_fnSetEnd,
5411     ITextSelection_fnGetFont,
5412     ITextSelection_fnSetFont,
5413     ITextSelection_fnGetPara,
5414     ITextSelection_fnSetPara,
5415     ITextSelection_fnGetStoryLength,
5416     ITextSelection_fnGetStoryType,
5417     ITextSelection_fnCollapse,
5418     ITextSelection_fnExpand,
5419     ITextSelection_fnGetIndex,
5420     ITextSelection_fnSetIndex,
5421     ITextSelection_fnSetRange,
5422     ITextSelection_fnInRange,
5423     ITextSelection_fnInStory,
5424     ITextSelection_fnIsEqual,
5425     ITextSelection_fnSelect,
5426     ITextSelection_fnStartOf,
5427     ITextSelection_fnEndOf,
5428     ITextSelection_fnMove,
5429     ITextSelection_fnMoveStart,
5430     ITextSelection_fnMoveEnd,
5431     ITextSelection_fnMoveWhile,
5432     ITextSelection_fnMoveStartWhile,
5433     ITextSelection_fnMoveEndWhile,
5434     ITextSelection_fnMoveUntil,
5435     ITextSelection_fnMoveStartUntil,
5436     ITextSelection_fnMoveEndUntil,
5437     ITextSelection_fnFindText,
5438     ITextSelection_fnFindTextStart,
5439     ITextSelection_fnFindTextEnd,
5440     ITextSelection_fnDelete,
5441     ITextSelection_fnCut,
5442     ITextSelection_fnCopy,
5443     ITextSelection_fnPaste,
5444     ITextSelection_fnCanPaste,
5445     ITextSelection_fnCanEdit,
5446     ITextSelection_fnChangeCase,
5447     ITextSelection_fnGetPoint,
5448     ITextSelection_fnSetPoint,
5449     ITextSelection_fnScrollIntoView,
5450     ITextSelection_fnGetEmbeddedObject,
5451     ITextSelection_fnGetFlags,
5452     ITextSelection_fnSetFlags,
5453     ITextSelection_fnGetType,
5454     ITextSelection_fnMoveLeft,
5455     ITextSelection_fnMoveRight,
5456     ITextSelection_fnMoveUp,
5457     ITextSelection_fnMoveDown,
5458     ITextSelection_fnHomeKey,
5459     ITextSelection_fnEndKey,
5460     ITextSelection_fnTypeText
5461 };
5462
5463 static ITextSelectionImpl *
5464 CreateTextSelection(IRichEditOleImpl *reOle)
5465 {
5466     ITextSelectionImpl *txtSel = heap_alloc(sizeof *txtSel);
5467     if (!txtSel)
5468         return NULL;
5469
5470     txtSel->ITextSelection_iface.lpVtbl = &tsvt;
5471     txtSel->ref = 1;
5472     txtSel->reOle = reOle;
5473     return txtSel;
5474 }
5475
5476 LRESULT CreateIRichEditOle(IUnknown *outer_unk, ME_TextEditor *editor, LPVOID *ppvObj)
5477 {
5478     IRichEditOleImpl *reo;
5479
5480     reo = heap_alloc(sizeof(IRichEditOleImpl));
5481     if (!reo)
5482         return 0;
5483
5484     reo->IUnknown_inner.lpVtbl = &reo_unk_vtbl;
5485     reo->IRichEditOle_iface.lpVtbl = &revt;
5486     reo->ITextDocument2Old_iface.lpVtbl = &tdvt;
5487     reo->ref = 1;
5488     reo->editor = editor;
5489     reo->txtSel = NULL;
5490
5491     TRACE("Created %p\n",reo);
5492     list_init(&reo->rangelist);
5493     list_init(&reo->clientsites);
5494     if (outer_unk)
5495         reo->outer_unk = outer_unk;
5496     else
5497         reo->outer_unk = &reo->IUnknown_inner;
5498     *ppvObj = &reo->IUnknown_inner;
5499
5500     return 1;
5501 }
5502
5503 static void convert_sizel(const ME_Context *c, const SIZEL* szl, SIZE* sz)
5504 {
5505   /* sizel is in .01 millimeters, sz in pixels */
5506   sz->cx = MulDiv(szl->cx, c->dpi.cx, 2540);
5507   sz->cy = MulDiv(szl->cy, c->dpi.cy, 2540);
5508 }
5509
5510 /******************************************************************************
5511  * ME_GetOLEObjectSize
5512  *
5513  * Sets run extent for OLE objects.
5514  */
5515 void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize)
5516 {
5517   IDataObject*  ido;
5518   FORMATETC     fmt;
5519   STGMEDIUM     stgm;
5520   DIBSECTION    dibsect;
5521   ENHMETAHEADER emh;
5522
5523   assert(run->nFlags & MERF_GRAPHICS);
5524   assert(run->reobj);
5525
5526   if (run->reobj->obj.sizel.cx != 0 || run->reobj->obj.sizel.cy != 0)
5527   {
5528     convert_sizel(c, &run->reobj->obj.sizel, pSize);
5529     if (c->editor->nZoomNumerator != 0)
5530     {
5531       pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5532       pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5533     }
5534     return;
5535   }
5536
5537   if (!run->reobj->obj.poleobj)
5538   {
5539     pSize->cx = pSize->cy = 0;
5540     return;
5541   }
5542
5543   if (IOleObject_QueryInterface(run->reobj->obj.poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
5544   {
5545       FIXME("Query Interface IID_IDataObject failed!\n");
5546       pSize->cx = pSize->cy = 0;
5547       return;
5548   }
5549   fmt.cfFormat = CF_BITMAP;
5550   fmt.ptd = NULL;
5551   fmt.dwAspect = DVASPECT_CONTENT;
5552   fmt.lindex = -1;
5553   fmt.tymed = TYMED_GDI;
5554   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
5555   {
5556     fmt.cfFormat = CF_ENHMETAFILE;
5557     fmt.tymed = TYMED_ENHMF;
5558     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
5559     {
5560       FIXME("unsupported format\n");
5561       pSize->cx = pSize->cy = 0;
5562       IDataObject_Release(ido);
5563       return;
5564     }
5565   }
5566   IDataObject_Release(ido);
5567
5568   switch (stgm.tymed)
5569   {
5570   case TYMED_GDI:
5571     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
5572     pSize->cx = dibsect.dsBm.bmWidth;
5573     pSize->cy = dibsect.dsBm.bmHeight;
5574     break;
5575   case TYMED_ENHMF:
5576     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
5577     pSize->cx = emh.rclBounds.right - emh.rclBounds.left;
5578     pSize->cy = emh.rclBounds.bottom - emh.rclBounds.top;
5579     break;
5580   default:
5581     FIXME("Unsupported tymed %d\n", stgm.tymed);
5582     break;
5583   }
5584   ReleaseStgMedium(&stgm);
5585   if (c->editor->nZoomNumerator != 0)
5586   {
5587     pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5588     pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5589   }
5590 }
5591
5592 void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run, BOOL selected)
5593 {
5594   IDataObject*  ido;
5595   FORMATETC     fmt;
5596   STGMEDIUM     stgm;
5597   DIBSECTION    dibsect;
5598   ENHMETAHEADER emh;
5599   HDC           hMemDC;
5600   SIZE          sz;
5601   BOOL          has_size;
5602   HBITMAP       old_bm;
5603   RECT          rc;
5604
5605   assert(run->nFlags & MERF_GRAPHICS);
5606   assert(run->reobj);
5607   if (IOleObject_QueryInterface(run->reobj->obj.poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
5608   {
5609     FIXME("Couldn't get interface\n");
5610     return;
5611   }
5612   has_size = run->reobj->obj.sizel.cx != 0 || run->reobj->obj.sizel.cy != 0;
5613   fmt.cfFormat = CF_BITMAP;
5614   fmt.ptd = NULL;
5615   fmt.dwAspect = DVASPECT_CONTENT;
5616   fmt.lindex = -1;
5617   fmt.tymed = TYMED_GDI;
5618   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
5619   {
5620     fmt.cfFormat = CF_ENHMETAFILE;
5621     fmt.tymed = TYMED_ENHMF;
5622     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
5623     {
5624       FIXME("Couldn't get storage medium\n");
5625       IDataObject_Release(ido);
5626       return;
5627     }
5628   }
5629   IDataObject_Release(ido);
5630
5631   switch (stgm.tymed)
5632   {
5633   case TYMED_GDI:
5634     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
5635     hMemDC = CreateCompatibleDC(c->hDC);
5636     old_bm = SelectObject(hMemDC, stgm.u.hBitmap);
5637     if (has_size)
5638     {
5639       convert_sizel(c, &run->reobj->obj.sizel, &sz);
5640     } else {
5641       sz.cx = dibsect.dsBm.bmWidth;
5642       sz.cy = dibsect.dsBm.bmHeight;
5643     }
5644     if (c->editor->nZoomNumerator != 0)
5645     {
5646       sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5647       sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5648     }
5649     StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
5650                hMemDC, 0, 0, dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight, SRCCOPY);
5651
5652     SelectObject(hMemDC, old_bm);
5653     DeleteDC(hMemDC);
5654     break;
5655   case TYMED_ENHMF:
5656     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
5657     if (has_size)
5658     {
5659       convert_sizel(c, &run->reobj->obj.sizel, &sz);
5660     } else {
5661       sz.cx = emh.rclBounds.right - emh.rclBounds.left;
5662       sz.cy = emh.rclBounds.bottom - emh.rclBounds.top;
5663     }
5664     if (c->editor->nZoomNumerator != 0)
5665     {
5666       sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5667       sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5668     }
5669
5670     rc.left = x;
5671     rc.top = y - sz.cy;
5672     rc.right = x + sz.cx;
5673     rc.bottom = y;
5674     PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
5675     break;
5676   default:
5677     FIXME("Unsupported tymed %d\n", stgm.tymed);
5678     selected = FALSE;
5679     break;
5680   }
5681   ReleaseStgMedium(&stgm);
5682
5683   if (selected && !c->editor->bHideSelection)
5684     PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
5685 }
5686
5687 void ME_DeleteReObject(struct re_object *reobj)
5688 {
5689     if (reobj->obj.poleobj)   IOleObject_Release(reobj->obj.poleobj);
5690     if (reobj->obj.pstg)      IStorage_Release(reobj->obj.pstg);
5691     if (reobj->obj.polesite)  IOleClientSite_Release(reobj->obj.polesite);
5692     heap_free(reobj);
5693 }
5694
5695 void ME_CopyReObject(REOBJECT *dst, const REOBJECT *src, DWORD flags)
5696 {
5697     *dst = *src;
5698     dst->poleobj = NULL;
5699     dst->pstg = NULL;
5700     dst->polesite = NULL;
5701
5702     if ((flags & REO_GETOBJ_POLEOBJ) && src->poleobj)
5703     {
5704         dst->poleobj = src->poleobj;
5705         IOleObject_AddRef(dst->poleobj);
5706     }
5707     if ((flags & REO_GETOBJ_PSTG) && src->pstg)
5708     {
5709         dst->pstg = src->pstg;
5710         IStorage_AddRef(dst->pstg);
5711     }
5712     if ((flags & REO_GETOBJ_POLESITE) && src->polesite)
5713     {
5714         dst->polesite = src->polesite;
5715         IOleClientSite_AddRef(dst->polesite);
5716     }
5717 }