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