dlls/riched20/richole.c

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