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