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