ReactOS 0.4.15-dev-7788-g1ad9096
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
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
56
57enum tid_t {
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};
77
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
90 ITypeLib_Release(tl);
91 return hr;
92}
93
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
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
129 ITypeInfo_Release(ti);
130 }
131
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
142
171
172static const DWORD textfont_prop_masks[][2] = {
174 { CFM_ANIMATION },
176 { CFM_BOLD, CFE_BOLD },
182 { CFM_KERNING },
183 { CFM_LCID },
184 { CFM_FACE },
186 { CFM_OFFSET },
189 { CFM_SIZE },
191 { CFM_SPACING },
196 { CFM_WEIGHT }
197};
198
199typedef union {
204
208
209typedef struct IRichEditOleImpl {
215
218
222
224 struct list entry;
226};
227
233};
234
238
240};
241
242typedef struct ITextFontImpl {
245
251
252typedef struct ITextParaImpl {
255
258
264};
265
267{
268 return CONTAINING_RECORD(iface, IRichEditOleImpl, IRichEditOle_iface);
269}
270
272{
273 return CONTAINING_RECORD(iface, IRichEditOleImpl, ITextDocument2Old_iface);
274}
275
277{
278 return CONTAINING_RECORD(iface, IRichEditOleImpl, IUnknown_inner);
279}
280
282{
283 return CONTAINING_RECORD(iface, IOleClientSiteImpl, IOleInPlaceSite_iface);
284}
285
287{
288 return CONTAINING_RECORD(iface, ITextRangeImpl, ITextRange_iface);
289}
290
292{
293 return CONTAINING_RECORD(iface, ITextSelectionImpl, ITextSelection_iface);
294}
295
297{
298 return CONTAINING_RECORD(iface, ITextFontImpl, ITextFont_iface);
299}
300
302{
303 return CONTAINING_RECORD(iface, ITextParaImpl, ITextPara_iface);
304}
305
309
311{
312 if (!length)
313 return E_INVALIDARG;
314
315 *length = ME_GetTextLength(editor) + 1;
316 return S_OK;
317}
318
320{
322
324 switch (op)
325 {
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
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:
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
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:
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
428{
429 return value * 72.0 / 1440;
430}
431
433{
434 return value * 1440 / 72.0;
435}
436
439{
440 ME_Cursor from, to;
442
443 memset(&fmt, 0, sizeof(fmt));
444 fmt.cbSize = sizeof(fmt);
445 fmt.dwMask = textfont_prop_masks[propid][0];
446
448 to = from;
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:
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
512{
514 ITextRange_QueryInterface(range, &IID_Igetrichole, (void**)&reole);
515 return reole;
516}
517
519{
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
537 hr = ITextFont_GetAllCaps(font, &value);
539
541 hr = ITextFont_GetBold(font, &value);
543
545 hr = ITextFont_GetEmboss(font, &value);
547
549 hr = ITextFont_GetHidden(font, &value);
551
553 hr = ITextFont_GetEngrave(font, &value);
555
557 hr = ITextFont_GetItalic(font, &value);
559
561 hr = ITextFont_GetOutline(font, &value);
563
565 hr = ITextFont_GetProtected(font, &value);
566 CHARFORMAT_SET_B_FIELD(PROTECTED, value);
567
569 hr = ITextFont_GetShadow(font, &value);
571
573 hr = ITextFont_GetSmallCaps(font, &value);
574 CHARFORMAT_SET_B_FIELD(SMALLCAPS, value);
575
577 hr = ITextFont_GetStrikeThrough(font, &value);
578 CHARFORMAT_SET_B_FIELD(STRIKEOUT, value);
579
581 hr = ITextFont_GetSubscript(font, &value);
583
585 hr = ITextFont_GetSuperscript(font, &value);
586 CHARFORMAT_SET_B_FIELD(SUPERSCRIPT, value);
587
589 hr = ITextFont_GetUnderline(font, &value);
590 CHARFORMAT_SET_B_FIELD(UNDERLINE, value);
591
592#undef CHARFORMAT_SET_B_FIELD
593
595 hr = ITextFont_GetAnimation(font, &value);
596 if (hr == S_OK && value != tomUndefined) {
597 fmt.dwMask |= CFM_ANIMATION;
598 fmt.bAnimation = value;
599 }
600
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
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
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
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));
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) {
667 ME_Cursor from, to;
668 LONG start, end;
669
670 ITextRange_GetStart(range, &start);
671 ITextRange_GetEnd(range, &end);
672
676 }
677}
678
680{
681 const IRichEditOleImpl *reole;
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
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 */
702 if (FAILED(hr))
703 return hr;
704
705 for (i = start + 1; i < end; i++) {
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
721{
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
734{
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 */
748{
749 const IRichEditOleImpl *reole;
750 ME_Cursor from, to;
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:
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
834
835 return S_OK;
836}
837
839{
841 v.l = value;
842 return set_textfont_prop(font, propid, &v);
843}
844
846{
848 v.f = value;
849 return set_textfont_prop(font, propid, &v);
850}
851
853{
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
881{
882 const IRichEditOleImpl *reole;
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);
892 *ret = v.str;
893 return hr;
894}
895
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
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
937{
939
940 TRACE("%p %s\n", This, debugstr_guid(riid));
941
942 *ppvObj = NULL;
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
968{
971
972 TRACE("%p ref = %u\n", This, ref);
973
974 return ref;
975}
976
978{
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{
1011};
1012
1013static HRESULT WINAPI
1015{
1017 return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
1018}
1019
1020static ULONG WINAPI
1022{
1024 return IUnknown_AddRef(This->outer_unk);
1025}
1026
1027static ULONG WINAPI
1029{
1031 return IUnknown_Release(This->outer_unk);
1032}
1033
1034static HRESULT WINAPI
1036{
1038 FIXME("stub %p\n",This);
1039 return E_NOTIMPL;
1040}
1041
1042static HRESULT WINAPI
1044{
1046 FIXME("stub %p\n",This);
1047 return E_NOTIMPL;
1048}
1049
1050static HRESULT WINAPI
1052 REFCLSID rclsidNew, LPCSTR lpstrUserTypeNew)
1053{
1055 FIXME("stub %p\n",This);
1056 return E_NOTIMPL;
1057}
1058
1060{
1061 return CONTAINING_RECORD(iface, IOleClientSiteImpl, IOleClientSite_iface);
1062}
1063
1064static HRESULT WINAPI
1066{
1068 TRACE("%p %s\n", me, debugstr_guid(riid) );
1069
1070 *ppvObj = NULL;
1071 if (IsEqualGUID(riid, &IID_IUnknown) ||
1073 *ppvObj = me;
1074 else if (IsEqualGUID(riid, &IID_IOleWindow) ||
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
1088{
1091 TRACE("(%p)->(%u)\n", This, ref);
1092 return ref;
1093}
1094
1096{
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
1113{
1115 if (!This->child.reole)
1116 return CO_E_RELEASED;
1117
1118 FIXME("stub %p\n", iface);
1119 return E_NOTIMPL;
1120}
1121
1123 DWORD dwWhichMoniker, IMoniker **ppmk)
1124{
1126 if (!This->child.reole)
1127 return CO_E_RELEASED;
1128
1129 FIXME("stub %p\n", iface);
1130 return E_NOTIMPL;
1131}
1132
1134 IOleContainer **ppContainer)
1135{
1137 if (!This->child.reole)
1138 return CO_E_RELEASED;
1139
1140 FIXME("stub %p\n", iface);
1141 return E_NOTIMPL;
1142}
1143
1145{
1147 if (!This->child.reole)
1148 return CO_E_RELEASED;
1149
1150 FIXME("stub %p\n", iface);
1151 return E_NOTIMPL;
1152}
1153
1155{
1157 if (!This->child.reole)
1158 return CO_E_RELEASED;
1159
1160 FIXME("stub %p\n", iface);
1161 return E_NOTIMPL;
1162}
1163
1165{
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 = {
1184};
1185
1186/* IOleInPlaceSite interface */
1188{
1190 return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppvObj);
1191}
1192
1194{
1196 return IOleClientSite_AddRef(&This->IOleClientSite_iface);
1197}
1198
1200{
1202 return IOleClientSite_Release(&This->IOleClientSite_iface);
1203}
1204
1206{
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
1222{
1224 FIXME("not implemented: (%p)->(%d)\n", This, fEnterMode);
1225 return E_NOTIMPL;
1226}
1227
1229{
1231 FIXME("not implemented: (%p)\n", This);
1232 return E_NOTIMPL;
1233}
1234
1236{
1238 FIXME("not implemented: (%p)\n", This);
1239 return E_NOTIMPL;
1240}
1241
1243{
1245 FIXME("not implemented: (%p)\n", This);
1246 return E_NOTIMPL;
1247}
1248
1250 IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1251 LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1252{
1254 FIXME("not implemented: (%p)->(%p %p %p %p %p)\n", This, ppFrame, ppDoc, lprcPosRect, lprcClipRect, lpFrameInfo);
1255 return E_NOTIMPL;
1256}
1257
1259{
1261 FIXME("not implemented: (%p)\n", This);
1262 return E_NOTIMPL;
1263}
1264
1266{
1268 FIXME("not implemented: (%p)->(%d)\n", This, fUndoable);
1269 return E_NOTIMPL;
1270}
1271
1273{
1275 FIXME("not implemented: (%p)\n", This);
1276 return E_NOTIMPL;
1277}
1278
1280{
1282 FIXME("not implemented: (%p)\n", This);
1283 return E_NOTIMPL;
1284}
1285
1287{
1289 FIXME("not implemented: (%p)\n", This);
1290 return E_NOTIMPL;
1291}
1292
1294{
1296 FIXME("not implemented: (%p)->(%p)\n", This, lprcPosRect);
1297 return E_NOTIMPL;
1298}
1299
1300static const IOleInPlaceSiteVtbl olestvt =
1301{
1317};
1318
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
1338{
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
1351 DWORD reco, LPDATAOBJECT *lplpdataobj)
1352{
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
1372{
1374 FIXME("stub %p\n",This);
1375 return E_NOTIMPL;
1376}
1377
1378static HRESULT WINAPI
1380 REOBJECT *lpreobject, DWORD dwFlags)
1381{
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 {
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
1429{
1431 TRACE("(%p)\n",This);
1432 return list_count(&This->editor->reobj_list);
1433}
1434
1435static HRESULT WINAPI
1437{
1439 FIXME("stub %p\n",This);
1440 return E_NOTIMPL;
1441}
1442
1443static HRESULT WINAPI
1445 CLIPFORMAT cf, HGLOBAL hMetaPict)
1446{
1448 FIXME("stub %p\n",This);
1449 return E_NOTIMPL;
1450}
1451
1452static HRESULT WINAPI
1454{
1456 FIXME("stub %p\n",This);
1457 return E_NOTIMPL;
1458}
1459
1460static HRESULT WINAPI
1462{
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
1479 LPSTORAGE lpstg)
1480{
1482 FIXME("stub %p\n",This);
1483 return E_NOTIMPL;
1484}
1485
1486static HRESULT WINAPI
1488{
1490 FIXME("stub %p\n",This);
1491 return E_NOTIMPL;
1492}
1493
1495 LPCSTR lpstrContainerApp, LPCSTR lpstrContainerObj)
1496{
1498 FIXME("stub %p %s %s\n",This, lpstrContainerApp, lpstrContainerObj);
1499 return E_NOTIMPL;
1500}
1501
1502static HRESULT WINAPI
1504{
1506 FIXME("stub %p\n",This);
1507 return E_NOTIMPL;
1508}
1509
1510static const IRichEditOleVtbl revt = {
1530};
1531
1532/* ITextRange interface */
1534{
1536
1537 *ppvObj = NULL;
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
1556{
1558 return InterlockedIncrement(&This->ref);
1559}
1560
1562{
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
1580{
1582 TRACE("(%p)->(%p)\n", This, pctinfo);
1583 *pctinfo = 1;
1584 return S_OK;
1585}
1586
1588 ITypeInfo **ppTInfo)
1589{
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
1602 UINT cNames, LCID lcid, DISPID *rgDispId)
1603{
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
1612 if (SUCCEEDED(hr))
1613 hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
1614 return hr;
1615}
1616
1618 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1619 VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
1620 UINT *puArgErr)
1621{
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
1630 if (SUCCEEDED(hr))
1631 hr = ITypeInfo_Invoke(ti, me, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1632 return hr;
1633}
1634
1636{
1638 ME_TextEditor *editor;
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;
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
1672{
1674 ME_TextEditor *editor;
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);
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
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
1726{
1728 ME_TextEditor *editor;
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
1745{
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
1757
1759{
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
1774{
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
1786{
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
1798{
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
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
1834{
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
1846{
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
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
1879{
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
1891{
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
1906{
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
1918 return S_OK;
1919}
1920
1922{
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
1937{
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
1949{
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
1961{
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
1973 return S_OK;
1974}
1975
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
1989{
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
2001{
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
2013{
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
2025 LONG extend)
2026{
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
2056{
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
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
2089{
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
2107{
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
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
2134{
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
2152{
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
2165 LONG *delta)
2166{
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
2178 LONG *delta)
2179{
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
2191{
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
2203 LONG *delta)
2204{
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
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
2262 LONG *delta)
2263{
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
2275 LONG *delta)
2276{
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
2288 LONG *delta)
2289{
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
2301 LONG *delta)
2302{
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
2314 LONG *delta)
2315{
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
2327 LONG *delta)
2328{
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
2340 LONG *delta)
2341{
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
2353 LONG *length)
2354{
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
2367{
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
2380{
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
2392{
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
2404{
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
2416{
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
2428{
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
2440{
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
2452{
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
2464{
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
2476{
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
2488 LONG extend)
2489{
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
2501{
2503 ME_TextEditor *editor;
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
2533{
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 = {
2603};
2604
2605/* ITextFont */
2607{
2609
2610 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
2611
2612 if (IsEqualIID(riid, &IID_ITextFont) ||
2615 {
2616 *ppv = iface;
2617 ITextFont_AddRef(iface);
2618 return S_OK;
2619 }
2620
2621 *ppv = NULL;
2622 return E_NOINTERFACE;
2623}
2624
2626{
2629 TRACE("(%p)->(%u)\n", This, ref);
2630 return ref;
2631}
2632
2634{
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
2652{
2654 TRACE("(%p)->(%p)\n", This, pctinfo);
2655 *pctinfo = 1;
2656 return S_OK;
2657}
2658
2660 ITypeInfo **ppTInfo)
2661{
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
2674 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2675{
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
2684 if (SUCCEEDED(hr))
2685 hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
2686 return hr;
2687}
2688
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{
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
2708 if (SUCCEEDED(hr))
2709 hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2710 return hr;
2711}
2712
2714{
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
2730{
2732 FIXME("(%p)->(%p): stub\n", This, pFont);
2733 return E_NOTIMPL;
2734}
2735
2737{
2739 FIXME("(%p)->(%p): stub\n", This, ret);
2740 return E_NOTIMPL;
2741}
2742
2744{
2746 FIXME("(%p)->(%p %p): stub\n", This, font, ret);
2747 return E_NOTIMPL;
2748}
2749
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
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
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
2852{
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:
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;
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:
2896 return S_OK;
2897 /* all properties are set to tomUndefined, font name is retained */
2898 case tomUndefined:
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
2917{
2919 FIXME("(%p)->(%p): stub\n", This, value);
2920 return E_NOTIMPL;
2921}
2922
2924{
2926 FIXME("(%p)->(%d): stub\n", This, value);
2927 return E_NOTIMPL;
2928}
2929
2931{
2933 TRACE("(%p)->(%p)\n", This, value);
2935}
2936
2938{
2940 TRACE("(%p)->(%d)\n", This, value);
2942}
2943
2945{
2947 TRACE("(%p)->(%p)\n", This, value);
2949}
2950
2952{
2954
2955 TRACE("(%p)->(%d)\n", This, value);
2956
2957 if (value < tomNoAnimation || value > tomAnimationMax)
2958 return E_INVALIDARG;
2959
2961}
2962
2964{
2966 TRACE("(%p)->(%p)\n", This, value);
2968}
2969
2971{
2973 TRACE("(%p)->(%d)\n", This, value);
2975}
2976
2978{
2980 TRACE("(%p)->(%p)\n", This, value);
2982}
2983
2985{
2987 TRACE("(%p)->(%d)\n", This, value);
2989}
2990
2992{
2994 TRACE("(%p)->(%p)\n", This, value);
2996}
2997
2999{
3001 TRACE("(%p)->(%d)\n", This, value);
3003}
3004
3006{
3008 TRACE("(%p)->(%p)\n", This, value);
3010}
3011
3013{
3015 TRACE("(%p)->(%d)\n", This, value);
3017}
3018
3020{
3022 TRACE("(%p)->(%p)\n", This, value);
3024}
3025
3027{
3029 TRACE("(%p)->(%d)\n", This, value);
3031}
3032
3034{
3036 TRACE("(%p)->(%p)\n", This, value);
3038}
3039
3041{
3043 TRACE("(%p)->(%d)\n", This, value);
3045}
3046
3048{
3050 TRACE("(%p)->(%p)\n", This, value);
3052}
3053
3055{
3057 TRACE("(%p)->(%d)\n", This, value);
3059}
3060
3062{
3064 TRACE("(%p)->(%p)\n", This, value);
3066}
3067
3069{
3071 TRACE("(%p)->(%.2f)\n", This, value);
3073}
3074
3076{
3078 TRACE("(%p)->(%p)\n", This, value);
3080}
3081
3083{
3085 TRACE("(%p)->(%d)\n", This, value);
3087}
3088
3090{
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
3105 return *value ? S_OK : E_OUTOFMEMORY;
3106 }
3107
3108 return textfont_getname_from_range(This->range, value);
3109}
3110
3112{
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
3123{
3125 TRACE("(%p)->(%p)\n", This, value);
3127}
3128
3130{
3132 TRACE("(%p)->(%d)\n", This, value);
3134}
3135
3137{
3139 TRACE("(%p)->(%p)\n", This, value);
3141}
3142
3144{
3146 TRACE("(%p)->(%.2f)\n", This, value);
3148}
3149
3151{
3153 TRACE("(%p)->(%p)\n", This, value);
3155}
3156
3158{
3160 TRACE("(%p)->(%d)\n", This, value);
3162}
3163
3165{
3167 TRACE("(%p)->(%p)\n", This, value);
3169}
3170
3172{
3174 TRACE("(%p)->(%d)\n", This, value);
3176}
3177
3179{
3181 TRACE("(%p)->(%p)\n", This, value);
3183}
3184
3186{
3188 TRACE("(%p)->(%.2f)\n", This, value);
3190}
3191
3193{
3195 TRACE("(%p)->(%p)\n", This, value);
3197}
3198
3200{
3202 TRACE("(%p)->(%d)\n", This, value);
3204}
3205
3207{
3209 TRACE("(%p)->(%p)\n", This, value);
3211}
3212
3214{
3216 TRACE("(%p)->(%.2f)\n", This, value);
3218}
3219
3221{
3223 TRACE("(%p)->(%p)\n", This, value);
3225}
3226
3228{
3230 TRACE("(%p)->(%d)\n", This, value);
3232}
3233
3235{
3237 TRACE("(%p)->(%p)\n", This, value);
3239}
3240
3242{
3244 TRACE("(%p)->(%d)\n", This, value);
3246}
3247
3249{
3251 TRACE("(%p)->(%p)\n", This, value);
3253}
3254
3256{
3258 TRACE("(%p)->(%d)\n", This, value);
3260}
3261
3263{
3265 TRACE("(%p)->(%p)\n", This, value);
3267}
3268
3270{
3272 TRACE("(%p)->(%d)\n", This, value);
3274}
3275
3277{
3279 TRACE("(%p)->(%p)\n", This, value);
3281}
3282
3284{
3286 TRACE("(%p)->(%d)\n", This, value);
3288}
3289
3290static ITextFontVtbl textfontvtbl = {
3353};
3354
3356{
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;
3383 }
3384
3385 *ret = &font->ITextFont_iface;
3386 return S_OK;
3387}
3388
3389/* ITextPara */
3391{
3393
3394 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
3395
3396 if (IsEqualIID(riid, &IID_ITextPara) ||
3399 {
3400 *ppv = iface;
3401 ITextPara_AddRef(iface);
3402 return S_OK;
3403 }
3404
3405 *ppv = NULL;
3406 return E_NOINTERFACE;
3407}
3408
3410{
3413 TRACE("(%p)->(%u)\n", This, ref);
3414 return ref;
3415}
3416
3418{
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
3434{
3435 if (This->range)
3436 {
3438 return rng->child.reole;
3439 }
3440 return NULL;
3441}
3442
3444{
3446 TRACE("(%p)->(%p)\n", This, pctinfo);
3447 *pctinfo = 1;
3448 return S_OK;
3449}
3450
3452 ITypeInfo **ppTInfo)
3453{
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
3466 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3467{
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
3476 if (SUCCEEDED(hr))
3477 hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
3478 return hr;
3479}
3480
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{
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
3501 if (SUCCEEDED(hr))
3502 hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3503 return hr;
3504}
3505
3507{
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
3518{
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
3529{
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
3540{
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
3551{
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
3562{
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
3573{
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
3584{
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
3597{
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
3608{
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
3619{
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
3630{
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
3641{
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
3652{
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
3663{
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
3674{
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
3685{
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
3696{
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
3707{
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
3718{
3720 FIXME("(%p)->(%p)\n", This, value);
3721
3722 if (!para_get_reole(This))
3723 return CO_E_RELEASED;
3724
3725 return E_NOTIMPL;
3726}
3727
3729{
3731 FIXME("(%p)->(%d)\n", This, value);
3732
3733 if (!para_get_reole(This))
3734 return CO_E_RELEASED;
3735
3736 return E_NOTIMPL;
3737}
3738
3740{
3742 FIXME("(%p)->(%p)\n", This, value);
3743
3744 if (!para_get_reole(This))
3745 return CO_E_RELEASED;
3746
3747 return E_NOTIMPL;
3748}
3749
3751{
3753 FIXME("(%p)->(%d)\n", This, value);
3754
3755 if (!para_get_reole(This))
3756 return CO_E_RELEASED;
3757
3758 return E_NOTIMPL;
3759}
3760
3762{
3764 FIXME("(%p)->(%p)\n", This, value);
3765
3766 if (!para_get_reole(This))
3767 return CO_E_RELEASED;
3768
3769 return E_NOTIMPL;
3770}
3771
3773{
3775 FIXME("(%p)->(%d)\n", This, value);
3776
3777 if (!para_get_reole(This))
3778 return CO_E_RELEASED;
3779
3780 return E_NOTIMPL;
3781}
3782
3784{
3786 FIXME("(%p)->(%p)\n", This, value);
3787
3788 if (!para_get_reole(This))
3789 return CO_E_RELEASED;
3790
3791 return E_NOTIMPL;
3792}
3793
3795{
3797 FIXME("(%p)->(%.2f)\n", This, value);
3798
3799 if (!para_get_reole(This))
3800 return CO_E_RELEASED;
3801
3802 return E_NOTIMPL;
3803}
3804
3806{
3808 FIXME("(%p)->(%p)\n", This, value);
3809
3810 if (!para_get_reole(This))
3811 return CO_E_RELEASED;
3812
3813 return E_NOTIMPL;
3814}
3815
3817{
3819 FIXME("(%p)->(%d)\n", This, value);
3820
3821 if (!para_get_reole(This))
3822 return CO_E_RELEASED;
3823
3824 return E_NOTIMPL;
3825}
3826
3828{
3830 FIXME("(%p)->(%p)\n", This, value);
3831
3832 if (!para_get_reole(This))
3833 return CO_E_RELEASED;
3834
3835 return E_NOTIMPL;
3836}
3837
3839{
3841 FIXME("(%p)->(%d)\n", This, value);
3842
3843 if (!para_get_reole(This))
3844 return CO_E_RELEASED;
3845
3846 return E_NOTIMPL;
3847}
3848
3850{
3852 FIXME("(%p)->(%p)\n", This, value);
3853
3854 if (!para_get_reole(This))
3855 return CO_E_RELEASED;
3856
3857 return E_NOTIMPL;
3858}
3859
3861{
3863 FIXME("(%p)->(%d)\n", This, value);
3864
3865 if (!para_get_reole(This))
3866 return CO_E_RELEASED;
3867
3868 return E_NOTIMPL;
3869}
3870
3872{
3874 FIXME("(%p)->(%p)\n", This, value);
3875
3876 if (!para_get_reole(This))
3877 return CO_E_RELEASED;
3878
3879 return E_NOTIMPL;
3880}
3881
3883{
3885 FIXME("(%p)->(%.2f)\n", This, value);
3886
3887 if (!para_get_reole(This))
3888 return CO_E_RELEASED;
3889
3890 return E_NOTIMPL;
3891}
3892
3893static HRESULT WINAPI TextPara_SetIndents(ITextPara *iface, FLOAT StartIndent, FLOAT LeftIndent, FLOAT RightIndent)
3894{
3896 FIXME("(%p)->(%.2f %.2f %.2f)\n", This, StartIndent, LeftIndent, RightIndent);
3897
3898 if (!para_get_reole(This))
3899 return CO_E_RELEASED;
3900
3901 return E_NOTIMPL;
3902}
3903
3904static HRESULT WINAPI TextPara_SetLineSpacing(ITextPara *iface, LONG LineSpacingRule, FLOAT LineSpacing)
3905{
3907 FIXME("(%p)->(%d %.2f)\n", This, LineSpacingRule, LineSpacing);
3908
3909 if (!para_get_reole(This))
3910 return CO_E_RELEASED;
3911
3912 return E_NOTIMPL;
3913}
3914
3916{
3918 FIXME("(%p)->(%p)\n", This, value);
3919
3920 if (!para_get_reole(This))
3921 return CO_E_RELEASED;
3922
3923 return E_NOTIMPL;
3924}
3925
3927{
3929 FIXME("(%p)->(%.2f)\n", This, value);
3930
3931 if (!para_get_reole(This))
3932 return CO_E_RELEASED;
3933
3934 return E_NOTIMPL;
3935}
3936
3938{
3940 FIXME("(%p)->(%p)\n", This, value);
3941
3942 if (!para_get_reole(This))
3943 return CO_E_RELEASED;
3944
3945 return E_NOTIMPL;
3946}
3947
3949{
3951 FIXME("(%p)->(%.2f)\n", This, value);
3952
3953 if (!para_get_reole(This))
3954 return CO_E_RELEASED;
3955
3956 return E_NOTIMPL;
3957}
3958
3960{
3962 FIXME("(%p)->(%p)\n", This, value);
3963
3964 if (!para_get_reole(This))
3965 return CO_E_RELEASED;
3966
3967 return E_NOTIMPL;
3968}
3969
3971{
3973 FIXME("(%p)->(%d)\n", This, value);
3974
3975 if (!para_get_reole(This))
3976 return CO_E_RELEASED;
3977
3978 return E_NOTIMPL;
3979}
3980
3982{
3984 FIXME("(%p)->(%p)\n", This, value);
3985
3986 if (!para_get_reole(This))
3987 return CO_E_RELEASED;
3988
3989 return E_NOTIMPL;
3990}
3991
3992static HRESULT WINAPI TextPara_AddTab(ITextPara *iface, FLOAT tbPos, LONG tbAlign, LONG tbLeader)
3993{
3995 FIXME("(%p)->(%.2f %d %d)\n", This, tbPos, tbAlign, tbLeader);
3996
3997 if (!para_get_reole(This))
3998 return CO_E_RELEASED;
3999
4000 return E_NOTIMPL;
4001}
4002
4004{
4006 FIXME("(%p)\n", This);
4007
4008 if (!para_get_reole(This))
4009 return CO_E_RELEASED;
4010
4011 return E_NOTIMPL;
4012}
4013
4015{
4017 FIXME("(%p)->(%.2f)\n", This, pos);
4018
4019 if (!para_get_reole(This))
4020 return CO_E_RELEASED;
4021
4022 return E_NOTIMPL;
4023}
4024
4025static HRESULT WINAPI TextPara_GetTab(ITextPara *iface, LONG iTab, FLOAT *ptbPos, LONG *ptbAlign, LONG *ptbLeader)
4026{
4028 FIXME("(%p)->(%d %p %p %p)\n", This, iTab, ptbPos, ptbAlign, ptbLeader);
4029
4030 if (!para_get_reole(This))
4031 return CO_E_RELEASED;
4032
4033 return E_NOTIMPL;
4034}
4035
4036static ITextParaVtbl textparavtbl = {
4092};
4093
4095{
4096 ITextParaImpl *para;
4097
4098 *ret = NULL;
4099 para = heap_alloc(sizeof(*para));
4100 if (!para)
4101 return E_OUTOFMEMORY;
4102
4103 para->ITextPara_iface.lpVtbl = &textparavtbl;
4104 para->ref = 1;
4105 para->range = range;
4106 ITextRange_AddRef(range);
4107
4108 *ret = &para->ITextPara_iface;
4109 return S_OK;
4110}
4111
4112/* ITextDocument */
4114 void **ppvObject)
4115{
4117 return IRichEditOle_QueryInterface(&This->IRichEditOle_iface, riid, ppvObject);
4118}
4119
4121{
4123 return IRichEditOle_AddRef(&This->IRichEditOle_iface);
4124}
4125
4127{
4129 return IRichEditOle_Release(&This->IRichEditOle_iface);
4130}
4131
4133 UINT *pctinfo)
4134{
4136 TRACE("(%p)->(%p)\n", This, pctinfo);
4137 *pctinfo = 1;
4138 return S_OK;
4139}
4140
4142 ITypeInfo **ppTInfo)
4143{
4145 HRESULT hr;
4146
4147 TRACE("(%p)->(%u,%d,%p)\n", This, iTInfo, lcid, ppTInfo);
4148
4149 hr = get_typeinfo(ITextDocument_tid, ppTInfo);
4150 if (SUCCEEDED(hr))
4151 ITypeInfo_AddRef(*ppTInfo);
4152 return hr;
4153}
4154
4156 LPOLESTR *rgszNames, UINT cNames,
4157 LCID lcid, DISPID *rgDispId)
4158{
4160 ITypeInfo *ti;
4161 HRESULT hr;
4162
4163 TRACE("(%p)->(%s, %p, %u, %d, %p)\n", This, debugstr_guid(riid),
4164 rgszNames, cNames, lcid, rgDispId);
4165
4167 if (SUCCEEDED(hr))
4168 hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
4169 return hr;
4170}
4171
4173 REFIID riid, LCID lcid, WORD wFlags,
4174 DISPPARAMS *pDispParams, VARIANT *pVarResult,
4175 EXCEPINFO *pExcepInfo, UINT *puArgErr)
4176{
4178 ITypeInfo *ti;
4179 HRESULT hr;
4180
4181 TRACE("(%p)->(%d, %s, %d, %u, %p, %p, %p, %p)\n", This, dispIdMember,
4182 debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult,
4183 pExcepInfo, puArgErr);
4184
4186 if (SUCCEEDED(hr))
4187 hr = ITypeInfo_Invoke(ti, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4188 return hr;
4189}
4190
4192{
4194 FIXME("stub %p\n",This);
4195 return E_NOTIMPL;
4196}
4197
4199{
4201
4202 TRACE("(%p)->(%p)\n", iface, selection);
4203
4204 if (!selection)
4205 return E_INVALIDARG;
4206
4207 if (!This->txtSel) {
4208 This->txtSel = CreateTextSelection(This);
4209 if (!This->txtSel) {
4210 *selection = NULL;
4211 return E_OUTOFMEMORY;
4212 }
4213 }
4214
4215 *selection = &This->txtSel->ITextSelection_iface;
4216 ITextSelection_AddRef(*selection);
4217 return S_OK;
4218}
4219
4221{
4223 FIXME("stub %p\n",This);
4224 return E_NOTIMPL;
4225}
4226
4228 ITextStoryRanges **ppStories)
4229{
4231 FIXME("stub %p\n",This);
4232 return E_NOTIMPL;
4233}
4234
4236{
4238 FIXME("stub %p\n",This);
4239 return E_NOTIMPL;
4240}
4241
4243{
4245 FIXME("stub %p\n",This);
4246 return E_NOTIMPL;
4247}
4248
4250{
4252 FIXME("stub %p\n",This);
4253 return E_NOTIMPL;
4254}
4255
4257{
4259 FIXME("stub %p\n",This);
4260 return E_NOTIMPL;
4261}
4262
4264{
4266 FIXME("stub %p\n",This);
4267 return E_NOTIMPL;
4268}
4269
4271 LONG Flags, LONG CodePage)
4272{
4274 FIXME("stub %p\n",This);
4275 return E_NOTIMPL;
4276}
4277
4279 LONG Flags, LONG CodePage)
4280{
4282 FIXME("stub %p\n",This);
4283 return E_NOTIMPL;
4284}
4285
4287{
4289 FIXME("stub %p\n",This);
4290 return E_NOTIMPL;
4291}
4292
4294{
4296 FIXME("stub %p\n",This);
4297 return E_NOTIMPL;
4298}
4299
4301{
4303 FIXME("stub %p\n",This);
4304 return E_NOTIMPL;
4305}
4306
4308{
4310 FIXME("stub %p\n",This);
4311 return E_NOTIMPL;
4312}
4313
4315{
4317 FIXME("stub %p\n",This);
4318 return E_NOTIMPL;
4319}
4320
4322{
4324 FIXME("stub %p\n",This);
4325 return E_NOTIMPL;
4326}
4327
4329{
4330 ITextRangeImpl *txtRge = heap_alloc(sizeof(ITextRangeImpl));
4331
4332 if (!txtRge)
4333 return E_OUTOFMEMORY;
4334 txtRge->ITextRange_iface.lpVtbl = &trvt;
4335 txtRge->ref = 1;
4336 txtRge->child.reole = reOle;
4337 txtRge->start = start;
4338 txtRge->end = end;
4339 list_add_head(&reOle->rangelist, &txtRge->child.entry);
4340 *ppRange = &txtRge->ITextRange_iface;
4341 return S_OK;
4342}
4343
4345 ITextRange **ppRange)
4346{
4348
4349 TRACE("%p %p %d %d\n", This, ppRange, cp1, cp2);
4350 if (!ppRange)
4351 return E_INVALIDARG;
4352
4353 cp2range(This->editor, &cp1, &cp2);
4354 return CreateITextRange(This, cp1, cp2, ppRange);
4355}
4356
4358 ITextRange **ppRange)
4359{
4361 FIXME("stub %p\n",This);
4362 return E_NOTIMPL;
4363}
4364
4365/* ITextDocument2Old methods */
4367{
4369
4370 FIXME("(%p)->(%p): stub\n", This, filter);
4371
4372 return E_NOTIMPL;
4373}
4374
4376{
4378
4379 FIXME("(%p)->(%d, 0x%x): stub\n", This, index, cr);
4380
4381 return E_NOTIMPL;
4382}
4383
4385{
4387
4388 FIXME("(%p)->(%d, %p): stub\n", This, index, cr);
4389
4390 return E_NOTIMPL;
4391}
4392
4394{
4396
4397 FIXME("(%p)->(%p): stub\n", This, type);
4398
4399 return E_NOTIMPL;
4400}
4401
4403{
4405
4406 FIXME("(%p)->(%d): stub\n", This, type);
4407
4408 return E_NOTIMPL;
4409}
4410
4412{
4414
4415 FIXME("(%p)->(%p): stub\n", This, context);
4416
4417 return E_NOTIMPL;
4418}
4419
4421{
4423
4424 FIXME("(%p)->(%d): stub\n", This, context);
4425
4426 return E_NOTIMPL;
4427}
4428
4430 LONG options, LONG current_charrep, LONG current_fontsize,
4431 BSTR *bstr, LONG *pitch_family, LONG *new_fontsize)
4432{
4434
4435 FIXME("(%p)->(%d, %d, %d, %d, %d, %p, %p, %p): stub\n", This, cp, charrep, options, current_charrep,
4436 current_fontsize, bstr, pitch_family, new_fontsize);
4437
4438 return E_NOTIMPL;
4439}
4440
4442{
4444
4445 FIXME("(%p)->(%p): stub\n", This, mode);
4446
4447 return E_NOTIMPL;
4448}
4449
4451{
4453
4454 FIXME("(%p)->(0x%x): stub\n", This, mode);
4455
4456 return E_NOTIMPL;
4457}
4458
4460 LONG *right, LONG *bottom)
4461{
4463
4464 FIXME("(%p)->(%d, %p, %p, %p, %p): stub\n", This, type, left, top, right, bottom);
4465
4466 return E_NOTIMPL;
4467}
4468
4470{
4472
4473 FIXME("(%p)->(%p): stub\n", This, selection);
4474
4475 return E_NOTIMPL;
4476}
4477
4479{
4481
4482 FIXME("(%p)->(%p): stub\n", This, hwnd);
4483
4484 return E_NOTIMPL;
4485}
4486
4488{
4490
4491 FIXME("(%p)->(%p): stub\n", This, flags);
4492
4493 return E_NOTIMPL;
4494}
4495
4497{
4499
4500 FIXME("(%p): stub\n", This);
4501
4502 return E_NOTIMPL;
4503}
4504
4506{
4508
4509 FIXME("(%p)->(%d, %p): stub\n", This, cch, exceed);
4510
4511 return E_NOTIMPL;
4512}
4513
4515{
4517
4518 FIXME("(%p)->(0x%x): stub\n", This, mode);
4519
4520 return E_NOTIMPL;
4521}
4522
4524{
4526
4527 FIXME("(%p): stub\n", This);
4528
4529 return E_NOTIMPL;
4530}
4531
4533{
4535
4536 FIXME("(%p)->(0x%x): stub\n", This, mode);
4537
4538 return E_NOTIMPL;
4539}
4540
4542{
4544
4545 FIXME("(%p)->(%d): stub\n", This, notify);
4546
4547 return E_NOTIMPL;
4548}
4549
4550static const ITextDocument2OldVtbl tdvt = {
4577 /* ITextDocument2Old methods */
4598};
4599
4600/* ITextSelection */
4602 ITextSelection *me,
4603 REFIID riid,
4604 void **ppvObj)
4605{
4607
4608 *ppvObj = NULL;
4611 || IsEqualGUID(riid, &IID_ITextRange)
4612 || IsEqualGUID(riid, &IID_ITextSelection))
4613 {
4614 *ppvObj = me;
4615 ITextSelection_AddRef(me);
4616 return S_OK;
4617 }
4618 else if (IsEqualGUID(riid, &IID_Igetrichole))
4619 {
4620 *ppvObj = This->reOle;
4621 return S_OK;
4622 }
4623
4624 return E_NOINTERFACE;
4625}
4626
4628{
4630 return InterlockedIncrement(&This->ref);
4631}
4632
4634{
4637 if (ref == 0)
4638 heap_free(This);
4639 return ref;
4640}
4641
4643{
4645 TRACE("(%p)->(%p)\n", This, pctinfo);
4646 *pctinfo = 1;
4647 return S_OK;
4648}
4649
4651 ITypeInfo **ppTInfo)
4652{
4654 HRESULT hr;
4655
4656 TRACE("(%p)->(%u,%d,%p)\n", This, iTInfo, lcid, ppTInfo);
4657
4659 if (SUCCEEDED(hr))
4660 ITypeInfo_AddRef(*ppTInfo);
4661 return hr;
4662}
4663
4665 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4666{
4668 ITypeInfo *ti;
4669 HRESULT hr;
4670
4671 TRACE("(%p)->(%s, %p, %u, %d, %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid,
4672 rgDispId);
4673
4675 if (SUCCEEDED(hr))
4676 hr = ITypeInfo_GetIDsOfNames(ti, rgszNames, cNames, rgDispId);
4677 return hr;
4678}
4679
4681 ITextSelection *me,
4682 DISPID dispIdMember,
4683 REFIID riid,
4684 LCID lcid,
4685 WORD wFlags,
4686 DISPPARAMS *pDispParams,
4687 VARIANT *pVarResult,
4688 EXCEPINFO *pExcepInfo,
4689 UINT *puArgErr)
4690{
4692 ITypeInfo *ti;
4693 HRESULT hr;
4694
4695 TRACE("(%p)->(%d, %s, %d, %u, %p, %p, %p, %p)\n", This, dispIdMember, debugstr_guid(riid), lcid,
4696 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4697
4699 if (SUCCEEDED(hr))
4700 hr = ITypeInfo_Invoke(ti, me, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4701 return hr;
4702}
4703
4704/*** ITextRange methods ***/
4706{
4708 ME_Cursor *start = NULL, *end = NULL;
4709 int nChars, endOfs;
4710 BOOL bEOP;
4711
4712 TRACE("(%p)->(%p)\n", This, pbstr);
4713
4714 if (!This->reOle)
4715 return CO_E_RELEASED;
4716
4717 if (!pbstr)
4718 return E_INVALIDARG;
4719
4720 ME_GetSelection(This->reOle->editor, &start, &end);
4721 endOfs = ME_GetCursorOfs(end);
4722 nChars = endOfs - ME_GetCursorOfs(start);
4723 if (!nChars)
4724 {
4725 *pbstr = NULL;
4726 return S_OK;
4727 }
4728
4729 *pbstr = SysAllocStringLen(NULL, nChars);
4730 if (!*pbstr)
4731 return E_OUTOFMEMORY;
4732
4733 bEOP = (end->pRun->next->type == diTextEnd && endOfs > ME_GetTextLength(This->reOle->editor));
4734 ME_GetTextW(This->reOle->editor, *pbstr, nChars, start, nChars, FALSE, bEOP);
4735 TRACE("%s\n", wine_dbgstr_w(*pbstr));
4736
4737 return S_OK;
4738}
4739
4741{
4743 ME_TextEditor *editor;
4744 int len, to, from;
4745
4746 TRACE("(%p)->(%s)\n", This, debugstr_w(str));
4747
4748 if (!This->reOle)
4749 return CO_E_RELEASED;
4750
4751 editor = This->reOle->editor;
4752 len = lstrlenW(str);
4753 ME_GetSelectionOfs(editor, &from, &to);
4754 ME_ReplaceSel(editor, FALSE, str, len);
4755
4756 if (len < to - from)
4758
4759 return S_OK;
4760}
4761
4763{
4765 ME_Cursor *start = NULL, *end = NULL;
4766
4767 TRACE("(%p)->(%p)\n", This, pch);
4768
4769 if (!This->reOle)
4770 return CO_E_RELEASED;
4771
4772 if (!pch)
4773 return E_INVALIDARG;
4774
4775 ME_GetSelection(This->reOle->editor, &start, &end);
4776 return range_GetChar(This->reOle->editor, start, pch);
4777}
4778
4780{
4782
4783 FIXME("(%p)->(%x): stub\n", This, ch);
4784
4785 if (!This->reOle)
4786 return CO_E_RELEASED;
4787
4788 return E_NOTIMPL;
4789}
4790
4792{
4794 LONG start, end;
4795
4796 TRACE("(%p)->(%p)\n", This, range);
4797
4798 if (!This->reOle)
4799 return CO_E_RELEASED;
4800
4801 if (!range)
4802 return E_INVALIDARG;
4803
4804 ITextSelection_GetStart(me, &start);
4805 ITextSelection_GetEnd(me, &end);
4806 return CreateITextRange(This->reOle, start, end, range);
4807}
4808
4810{
4812
4813 FIXME("(%p)->(%p): stub\n", This, range);
4814
4815 if (!This->reOle)
4816 return CO_E_RELEASED;
4817
4818 return E_NOTIMPL;
4819}
4820
4822{
4824
4825 FIXME("(%p)->(%p): stub\n", This, range);
4826
4827 if (!This->reOle)
4828 return CO_E_RELEASED;
4829
4830 FIXME("not implemented\n");
4831 return E_NOTIMPL;
4832}
4833
4835{
4837 LONG lim;
4838
4839 TRACE("(%p)->(%p)\n", This, pcpFirst);
4840
4841 if (!This->reOle)
4842 return CO_E_RELEASED;
4843
4844 if (!pcpFirst)
4845 return E_INVALIDARG;
4846 ME_GetSelectionOfs(This->reOle->editor, pcpFirst, &lim);
4847 return S_OK;
4848}
4849
4851{
4853 LONG start, end;
4854 HRESULT hr;
4855
4856 TRACE("(%p)->(%d)\n", This, value);
4857
4858 if (!This->reOle)
4859 return CO_E_RELEASED;
4860
4861 ME_GetSelectionOfs(This->reOle->editor, &start, &end);
4862 hr = textrange_setstart(This->reOle, value, &start, &end);
4863 if (hr == S_OK)
4864 set_selection(This->reOle->editor, start, end);
4865
4866 return hr;
4867}
4868
4870{
4872 LONG first;
4873
4874 TRACE("(%p)->(%p)\n", This, pcpLim);
4875
4876 if (!This->reOle)
4877 return CO_E_RELEASED;
4878
4879 if (!pcpLim)
4880 return E_INVALIDARG;
4881 ME_GetSelectionOfs(This->reOle->editor, &first, pcpLim);
4882 return S_OK;
4883}
4884
4886{
4888 LONG start, end;
4889 HRESULT hr;
4890
4891 TRACE("(%p)->(%d)\n", This, value);
4892
4893 if (!This->reOle)
4894 return CO_E_RELEASED;
4895
4896 ME_GetSelectionOfs(This->reOle->editor, &start, &end);
4897 hr = textrange_setend(This->reOle, value, &start, &end);
4898 if (hr == S_OK)
4899 set_selection(This->reOle->editor, start, end);
4900
4901 return hr;
4902}
4903
4905{
4908 HRESULT hr;
4909
4910 TRACE("(%p)->(%p)\n", This, font);
4911
4912 if (!This->reOle)
4913 return CO_E_RELEASED;
4914
4915 if (!font)
4916 return E_INVALIDARG;
4917
4918 ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
4920 ITextRange_Release(range);
4921 return hr;
4922}
4923
4925{
4928
4929 TRACE("(%p)->(%p)\n", This, font);
4930
4931 if (!font)
4932 return E_INVALIDARG;
4933
4934 if (!This->reOle)
4935 return CO_E_RELEASED;
4936
4937 ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
4939 ITextRange_Release(range);
4940 return S_OK;
4941}
4942
4944{
4947 HRESULT hr;
4948
4949 TRACE("(%p)->(%p)\n", This, para);
4950
4951 if (!This->reOle)
4952 return CO_E_RELEASED;
4953
4954 if (!para)
4955 return E_INVALIDARG;
4956
4957 ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
4958 hr = create_textpara(range, para);
4959 ITextRange_Release(range);
4960 return hr;
4961}
4962
4964{
4966
4967 FIXME("(%p)->(%p): stub\n", This, para);
4968
4969 if (!This->reOle)
4970 return CO_E_RELEASED;
4971
4972 FIXME("not implemented\n");
4973 return E_NOTIMPL;
4974}
4975
4977{
4979
4980 TRACE("(%p)->(%p)\n", This, length);
4981
4982 if (!This->reOle)
4983 return CO_E_RELEASED;
4984
4985 return textrange_get_storylength(This->reOle->editor, length);
4986}
4987
4989{
4991
4992 TRACE("(%p)->(%p)\n", This, value);
4993
4994 if (!This->reOle)
4995 return CO_E_RELEASED;
4996
4997 if (!value)
4998 return E_INVALIDARG;
4999
5001 return S_OK;
5002}
5003
5005{
5007 LONG start, end;
5008 HRESULT hres;
5009
5010 TRACE("(%p)->(%d)\n", This, bStart);
5011
5012 if (!This->reOle)
5013 return CO_E_RELEASED;
5014
5015 ME_GetSelectionOfs(This->reOle->editor, &start, &end);
5016 hres = range_Collapse(bStart, &start, &end);
5017 if (SUCCEEDED(hres))
5018 set_selection(This->reOle->editor, start, end);
5019 return hres;
5020}
5021
5023{
5026 HRESULT hr;
5027
5028 TRACE("(%p)->(%d %p)\n", This, unit, delta);
5029
5030 if (!This->reOle)
5031 return CO_E_RELEASED;
5032
5033 ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
5034 hr = textrange_expand(range, unit, delta);
5035 ITextRange_Release(range);
5036 return hr;
5037}
5038
5040{
5042
5043 FIXME("(%p)->(%d %p): stub\n", This, unit, index);
5044
5045 if (!This->reOle)
5046 return CO_E_RELEASED;
5047
5048 return E_NOTIMPL;
5049}
5050
5052 LONG extend)
5053{
5055
5056 FIXME("(%p)->(%d %d %d): stub\n", This, unit, index, extend);
5057
5058 if (!This->reOle)
5059 return CO_E_RELEASED;
5060
5061 return E_NOTIMPL;
5062}
5063
5065{
5067
5068 FIXME("(%p)->(%d %d): stub\n", This, anchor, active);
5069
5070 if (!This->reOle)
5071 return CO_E_RELEASED;
5072
5073 return E_NOTIMPL;
5074}
5075
5077{
5080 LONG start, end;
5081
5082 TRACE("(%p)->(%p %p)\n", This, range, ret);
5083
5084 if (ret)
5085 *ret = tomFalse;
5086
5087 if (!This->reOle)
5088 return CO_E_RELEASED;
5089
5090 if (!range)
5091 return S_FALSE;
5092
5093 ITextRange_QueryInterface(range, &IID_ITextSelection, (void**)&selection);
5094 if (!selection)
5095 return S_FALSE;
5096 ITextSelection_Release(selection);
5097
5098 ITextSelection_GetStart(me, &start);
5099 ITextSelection_GetEnd(me, &end);
5100 return textrange_inrange(start, end, range, ret);
5101}
5102
5104{
5106
5107 FIXME("(%p)->(%p %p): stub\n", This, range, ret);
5108
5109 if (!This->reOle)
5110 return CO_E_RELEASED;
5111
5112 return E_NOTIMPL;
5113}
5114
5116{
5119 LONG start, end;
5120
5121 TRACE("(%p)->(%p %p)\n", This, range, ret);
5122
5123 if (ret)
5124 *ret = tomFalse;
5125
5126 if (!This->reOle)
5127 return CO_E_RELEASED;
5128
5129 if (!range)
5130 return S_FALSE;
5131
5132 ITextRange_QueryInterface(range, &IID_ITextSelection, (void**)&selection);
5133 if (!selection)
5134 return S_FALSE;
5135 ITextSelection_Release(selection);
5136
5137 ITextSelection_GetStart(me, &start);
5138 ITextSelection_GetEnd(me, &end);
5139 return textrange_isequal(start, end, range, ret);
5140}
5141
5143{
5145
5146 TRACE("(%p)\n", This);
5147
5148 if (!This->reOle)
5149 return CO_E_RELEASED;
5150
5151 /* nothing to do */
5152 return S_OK;
5153}
5154
5156 LONG *delta)
5157{
5159
5160 FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
5161
5162 if (!This->reOle)
5163 return CO_E_RELEASED;
5164
5165 return E_NOTIMPL;
5166}
5167
5169 LONG *delta)
5170{
5172
5173 FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
5174
5175 if (!This->reOle)
5176 return CO_E_RELEASED;
5177
5178 return E_NOTIMPL;
5179}
5180
5182{
5184
5185 FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
5186
5187 if (!This->reOle)
5188 return CO_E_RELEASED;
5189
5190 return E_NOTIMPL;
5191}
5192
5194 LONG *delta)
5195{
5197
5198 FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
5199
5200 if (!This->reOle)
5201 return CO_E_RELEASED;
5202
5203 return E_NOTIMPL;
5204}
5205
5207 LONG *delta)
5208{
5211 HRESULT hr;
5212
5213 TRACE("(%p)->(%d %d %p)\n", This, unit, count, delta);
5214
5215 if (!This->reOle)
5216 return CO_E_RELEASED;
5217
5218 ITextSelection_QueryInterface(me, &IID_ITextRange, (void**)&range);
5219 hr = textrange_moveend(range, unit, count, delta);
5220 ITextRange_Release(range);
5221 return hr;
5222}
5223
5225 LONG *delta)
5226{
5228
5229 FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5230
5231 if (!This->reOle)
5232 return CO_E_RELEASED;
5233
5234 return E_NOTIMPL;
5235}
5236
5238 LONG *delta)
5239{
5241
5242 FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5243
5244 if (!This->reOle)
5245 return CO_E_RELEASED;
5246
5247 return E_NOTIMPL;
5248}
5249
5251 LONG *delta)
5252{
5254
5255 FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5256
5257 if (!This->reOle)
5258 return CO_E_RELEASED;
5259
5260 return E_NOTIMPL;
5261}
5262
5264 LONG *delta)
5265{
5267
5268 FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5269
5270 if (!This->reOle)
5271 return CO_E_RELEASED;
5272
5273 return E_NOTIMPL;
5274}
5275
5277 LONG *delta)
5278{
5280
5281 FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5282
5283 if (!This->reOle)
5284 return CO_E_RELEASED;
5285
5286 return E_NOTIMPL;
5287}
5288
5290 LONG *delta)
5291{
5293
5294 FIXME("(%p)->(%s %d %p): stub\n", This, debugstr_variant(charset), count, delta);
5295
5296 if (!This->reOle)
5297 return CO_E_RELEASED;
5298
5299 return E_NOTIMPL;
5300}
5301
5303 LONG *length)
5304{
5306
5307 FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
5308
5309 if (!This->reOle)
5310 return CO_E_RELEASED;
5311
5312 FIXME("not implemented\n");
5313 return E_NOTIMPL;
5314}
5315
5318{
5320
5321 FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
5322
5323 if (!This->reOle)
5324 return CO_E_RELEASED;
5325
5326 return E_NOTIMPL;
5327}
5328
5331{
5333
5334 FIXME("(%p)->(%s %d %x %p): stub\n", This, debugstr_w(text), count, flags, length);
5335
5336 if (!This->reOle)
5337 return CO_E_RELEASED;
5338
5339 return E_NOTIMPL;
5340}
5341
5343 LONG *delta)
5344{
5346
5347 FIXME("(%p)->(%d %d %p): stub\n", This, unit, count, delta);
5348
5349 if (!This->reOle)
5350 return CO_E_RELEASED;
5351
5352 return E_NOTIMPL;
5353}
5354
5356{
5358
5359 FIXME("(%p)->(%p): stub\n", This, v);
5360
5361 if (!This->reOle)
5362 return CO_E_RELEASED;
5363
5364 return E_NOTIMPL;
5365}
5366
5368{
5370
5371 FIXME("(%p)->(%p): stub\n", This, v);
5372
5373 if (!This->reOle)
5374 return CO_E_RELEASED;
5375
5376 return E_NOTIMPL;
5377}
5378
5380{
5382
5383 FIXME("(%p)->(%s %x): stub\n", This, debugstr_variant(v), format);
5384
5385 if (!This->reOle)
5386 return CO_E_RELEASED;
5387
5388 return E_NOTIMPL;
5389}
5390
5392 LONG *ret)
5393{
5395
5396 FIXME("(%p)->(%s %x %p): stub\n", This, debugstr_variant(v), format, ret);
5397
5398 if (!This->reOle)
5399 return CO_E_RELEASED;
5400
5401 return E_NOTIMPL;
5402}
5403
5405{
5407
5408 FIXME("(%p)->(%p): stub\n", This, ret);
5409
5410 if (!This->reOle)
5411 return CO_E_RELEASED;
5412
5413 return E_NOTIMPL;
5414}
5415
5417{
5419
5420 FIXME("(%p)->(%d): stub\n", This, type);
5421
5422 if (!This->reOle)
5423 return CO_E_RELEASED;
5424
5425 return E_NOTIMPL;
5426}
5427
5429{
5431
5432 FIXME("(%p)->(%d %p %p): stub\n", This, type, cx, cy);
5433
5434 if (!This->reOle)
5435 return CO_E_RELEASED;
5436
5437 return E_NOTIMPL;
5438}
5439
5441 LONG extend)
5442{
5444
5445 FIXME("(%p)->(%d %d %d %d): stub\n", This, x, y, type, extend);
5446
5447 if (!This->reOle)
5448 return CO_E_RELEASED;
5449
5450 return E_NOTIMPL;
5451}
5452
5454{
5456
5457 FIXME("(%p)->(%d): stub\n", This, value);
5458
5459 if (!This->reOle)
5460 return CO_E_RELEASED;
5461
5462 return E_NOTIMPL;
5463}
5464
5466{
5468
5469 FIXME("(%p)->(%p): stub\n", This, ppv);
5470
5471 if (!This->reOle)
5472 return CO_E_RELEASED;
5473
5474 return E_NOTIMPL;
5475}
5476
5477/*** ITextSelection methods ***/
5479{
5481
5482 FIXME("(%p)->(%p): stub\n", This, flags);
5483
5484 if (!This->reOle)
5485 return CO_E_RELEASED;
5486
5487 return E_NOTIMPL;
5488}
5489
5491{
5493
5494 FIXME("(%p)->(%x): stub\n", This, flags);
5495
5496 if (!This->reOle)
5497 return CO_E_RELEASED;
5498
5499 return E_NOTIMPL;
5500}
5501
5503{
5505
5506 FIXME("(%p)->(%p): stub\n", This, type);
5507
5508 if (!This->reOle)
5509 return CO_E_RELEASED;
5510
5511 return E_NOTIMPL;
5512}
5513
5515 LONG extend, LONG *delta)
5516{
5518
5519 FIXME("(%p)->(%d %d %d %p): stub\n", This, unit, count, extend, delta);
5520
5521 if (!This->reOle)
5522 return CO_E_RELEASED;
5523
5524 return E_NOTIMPL;
5525}
5526
5528 LONG extend, LONG *delta)
5529{
5531
5532 FIXME("(%p)->(%d %d %d %p): stub\n", This, unit, count, extend, delta);
5533
5534 if (!This->reOle)
5535 return CO_E_RELEASED;
5536
5537 return E_NOTIMPL;
5538}
5539
5541 LONG extend, LONG *delta)
5542{
5544
5545 FIXME("(%p)->(%d %d %d %p): stub\n", This, unit, count, extend, delta);
5546
5547 if (!This->reOle)
5548 return CO_E_RELEASED;
5549
5550 return E_NOTIMPL;
5551}
5552
5554 LONG extend, LONG *delta)
5555{
5557
5558 FIXME("(%p)->(%d %d %d %p): stub\n", This, unit, count, extend, delta);
5559
5560 if (!This->reOle)
5561 return CO_E_RELEASED;
5562
5563 return E_NOTIMPL;
5564}
5565
5567 LONG *delta)
5568{
5570
5571 FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
5572
5573 if (!This->reOle)
5574 return CO_E_RELEASED;
5575
5576 return E_NOTIMPL;
5577}
5578
5580 LONG *delta)
5581{
5583
5584 FIXME("(%p)->(%d %d %p): stub\n", This, unit, extend, delta);
5585
5586 if (!This->reOle)
5587 return CO_E_RELEASED;
5588
5589 return E_NOTIMPL;
5590}
5591
5593{
5595
5596 FIXME("(%p)->(%s): stub\n", This, debugstr_w(text));
5597
5598 if (!This->reOle)
5599 return CO_E_RELEASED;
5600
5601 return E_NOTIMPL;
5602}
5603
5604static const ITextSelectionVtbl tsvt = {
5673};
5674
5675static ITextSelectionImpl *
5677{
5678 ITextSelectionImpl *txtSel = heap_alloc(sizeof *txtSel);
5679 if (!txtSel)
5680 return NULL;
5681
5682 txtSel->ITextSelection_iface.lpVtbl = &tsvt;
5683 txtSel->ref = 1;
5684 txtSel->reOle = reOle;
5685 return txtSel;
5686}
5687
5689{
5690 IRichEditOleImpl *reo;
5691
5692 reo = heap_alloc(sizeof(IRichEditOleImpl));
5693 if (!reo)
5694 return 0;
5695
5696 reo->IUnknown_inner.lpVtbl = &reo_unk_vtbl;
5697 reo->IRichEditOle_iface.lpVtbl = &revt;
5698 reo->ITextDocument2Old_iface.lpVtbl = &tdvt;
5699 reo->ref = 1;
5700 reo->editor = editor;
5701 reo->txtSel = NULL;
5702
5703 TRACE("Created %p\n",reo);
5704 list_init(&reo->rangelist);
5705 list_init(&reo->clientsites);
5706 if (outer_unk)
5707 reo->outer_unk = outer_unk;
5708 else
5709 reo->outer_unk = &reo->IUnknown_inner;
5710 *ppvObj = &reo->IUnknown_inner;
5711
5712 return 1;
5713}
5714
5715static void convert_sizel(const ME_Context *c, const SIZEL* szl, SIZE* sz)
5716{
5717 /* sizel is in .01 millimeters, sz in pixels */
5718 sz->cx = MulDiv(szl->cx, c->dpi.cx, 2540);
5719 sz->cy = MulDiv(szl->cy, c->dpi.cy, 2540);
5720}
5721
5722/******************************************************************************
5723 * ME_GetOLEObjectSize
5724 *
5725 * Sets run extent for OLE objects.
5726 */
5727void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize)
5728{
5729 IDataObject* ido;
5730 FORMATETC fmt;
5731 STGMEDIUM stgm;
5732 DIBSECTION dibsect;
5733 ENHMETAHEADER emh;
5734
5735 assert(run->nFlags & MERF_GRAPHICS);
5736 assert(run->reobj);
5737
5738 if (run->reobj->obj.sizel.cx != 0 || run->reobj->obj.sizel.cy != 0)
5739 {
5740 convert_sizel(c, &run->reobj->obj.sizel, pSize);
5741 if (c->editor->nZoomNumerator != 0)
5742 {
5743 pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5744 pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5745 }
5746 return;
5747 }
5748
5749 if (!run->reobj->obj.poleobj)
5750 {
5751 pSize->cx = pSize->cy = 0;
5752 return;
5753 }
5754
5755 if (IOleObject_QueryInterface(run->reobj->obj.poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
5756 {
5757 FIXME("Query Interface IID_IDataObject failed!\n");
5758 pSize->cx = pSize->cy = 0;
5759 return;
5760 }
5761 fmt.cfFormat = CF_BITMAP;
5762 fmt.ptd = NULL;
5763 fmt.dwAspect = DVASPECT_CONTENT;
5764 fmt.lindex = -1;
5765 fmt.tymed = TYMED_GDI;
5766 if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
5767 {
5768 fmt.cfFormat = CF_ENHMETAFILE;
5769 fmt.tymed = TYMED_ENHMF;
5770 if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
5771 {
5772 FIXME("unsupported format\n");
5773 pSize->cx = pSize->cy = 0;
5774 IDataObject_Release(ido);
5775 return;
5776 }
5777 }
5778 IDataObject_Release(ido);
5779
5780 switch (stgm.tymed)
5781 {
5782 case TYMED_GDI:
5783 GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
5784 pSize->cx = dibsect.dsBm.bmWidth;
5785 pSize->cy = dibsect.dsBm.bmHeight;
5786 break;
5787 case TYMED_ENHMF:
5788 GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
5789 pSize->cx = emh.rclBounds.right - emh.rclBounds.left;
5790 pSize->cy = emh.rclBounds.bottom - emh.rclBounds.top;
5791 break;
5792 default:
5793 FIXME("Unsupported tymed %d\n", stgm.tymed);
5794 break;
5795 }
5796 ReleaseStgMedium(&stgm);
5797 if (c->editor->nZoomNumerator != 0)
5798 {
5799 pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5800 pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5801 }
5802}
5803
5804void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run, BOOL selected)
5805{
5806 IDataObject* ido;
5807 FORMATETC fmt;
5808 STGMEDIUM stgm;
5809 DIBSECTION dibsect;
5810 ENHMETAHEADER emh;
5811 HDC hMemDC;
5812 SIZE sz;
5813 BOOL has_size;
5814 HBITMAP old_bm;
5815 RECT rc;
5816
5817 assert(run->nFlags & MERF_GRAPHICS);
5818 assert(run->reobj);
5819 if (IOleObject_QueryInterface(run->reobj->obj.poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
5820 {
5821 FIXME("Couldn't get interface\n");
5822 return;
5823 }
5824 has_size = run->reobj->obj.sizel.cx != 0 || run->reobj->obj.sizel.cy != 0;
5825 fmt.cfFormat = CF_BITMAP;
5826 fmt.ptd = NULL;
5827 fmt.dwAspect = DVASPECT_CONTENT;
5828 fmt.lindex = -1;
5829 fmt.tymed = TYMED_GDI;
5830 if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
5831 {
5832 fmt.cfFormat = CF_ENHMETAFILE;
5833 fmt.tymed = TYMED_ENHMF;
5834 if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
5835 {
5836 FIXME("Couldn't get storage medium\n");
5837 IDataObject_Release(ido);
5838 return;
5839 }
5840 }
5841 IDataObject_Release(ido);
5842
5843 switch (stgm.tymed)
5844 {
5845 case TYMED_GDI:
5846 GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
5847 hMemDC = CreateCompatibleDC(c->hDC);
5848 old_bm = SelectObject(hMemDC, stgm.u.hBitmap);
5849 if (has_size)
5850 {
5851 convert_sizel(c, &run->reobj->obj.sizel, &sz);
5852 } else {
5853 sz.cx = dibsect.dsBm.bmWidth;
5854 sz.cy = dibsect.dsBm.bmHeight;
5855 }
5856 if (c->editor->nZoomNumerator != 0)
5857 {
5858 sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5859 sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5860 }
5861 StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
5862 hMemDC, 0, 0, dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight, SRCCOPY);
5863
5864 SelectObject(hMemDC, old_bm);
5865 DeleteDC(hMemDC);
5866 break;
5867 case TYMED_ENHMF:
5868 GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
5869 if (has_size)
5870 {
5871 convert_sizel(c, &run->reobj->obj.sizel, &sz);
5872 } else {
5873 sz.cx = emh.rclBounds.right - emh.rclBounds.left;
5874 sz.cy = emh.rclBounds.bottom - emh.rclBounds.top;
5875 }
5876 if (c->editor->nZoomNumerator != 0)
5877 {
5878 sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5879 sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
5880 }
5881
5882 rc.left = x;
5883 rc.top = y - sz.cy;
5884 rc.right = x + sz.cx;
5885 rc.bottom = y;
5886 PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
5887 break;
5888 default:
5889 FIXME("Unsupported tymed %d\n", stgm.tymed);
5890 selected = FALSE;
5891 break;
5892 }
5893 ReleaseStgMedium(&stgm);
5894
5895 if (selected && !c->editor->bHideSelection)
5896 PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
5897}
5898
5899void ME_DeleteReObject(struct re_object *reobj)
5900{
5901 if (reobj->obj.poleobj) IOleObject_Release(reobj->obj.poleobj);
5902 if (reobj->obj.pstg) IStorage_Release(reobj->obj.pstg);
5903 if (reobj->obj.polesite) IOleClientSite_Release(reobj->obj.polesite);
5904 heap_free(reobj);
5905}
5906
5908{
5909 *dst = *src;
5910 dst->poleobj = NULL;
5911 dst->pstg = NULL;
5912 dst->polesite = NULL;
5913
5914 if ((flags & REO_GETOBJ_POLEOBJ) && src->poleobj)
5915 {
5916 dst->poleobj = src->poleobj;
5917 IOleObject_AddRef(dst->poleobj);
5918 }
5919 if ((flags & REO_GETOBJ_PSTG) && src->pstg)
5920 {
5921 dst->pstg = src->pstg;
5922 IStorage_AddRef(dst->pstg);
5923 }
5924 if ((flags & REO_GETOBJ_POLESITE) && src->polesite)
5925 {
5926 dst->polesite = src->polesite;
5927 IOleClientSite_AddRef(dst->polesite);
5928 }
5929}
small capitals from c petite p scientific f SUBSCRIPT
Definition: afcover.h:86
Arabic default style
Definition: afstyles.h:94
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define CF_BITMAP
Definition: constants.h:397
#define CF_ENHMETAFILE
Definition: constants.h:409
#define ARRAY_SIZE(A)
Definition: main.h:33
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static void list_add_head(struct list_entry *head, struct list_entry *entry)
Definition: list.h:76
static void list_init(struct list_entry *head)
Definition: list.h:51
const GUID IID_IUnknown
#define STDMETHODCALLTYPE
Definition: bdasup.h:9
#define FIXME(fmt,...)
Definition: debug.h:111
#define ERR(fmt,...)
Definition: debug.h:110
CFF_Charset charset
Definition: cffcmap.c:138
Definition: list.h:37
int selection
Definition: ctm.c:92
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
static char selected[MAX_PATH+1]
Definition: dirdlg.c:7
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
UINT op
Definition: effect.c:236
OLECHAR * BSTR
Definition: compat.h:2293
#define lstrcpynW
Definition: compat.h:738
#define lstrlenW
Definition: compat.h:750
const WCHAR * text
Definition: package.c:1799
void WINAPI ReleaseStgMedium(STGMEDIUM *pmedium)
Definition: ole2.c:2033
HRESULT WINAPI LoadRegTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid, ITypeLib **ppTLib)
Definition: typelib.c:531
int ME_GetCursorOfs(const ME_Cursor *cursor)
Definition: caret.c:957
void ME_InsertTextFromCursor(ME_TextEditor *editor, int nCursor, const WCHAR *str, int len, ME_Style *style)
Definition: caret.c:595
int ME_MoveCursorChars(ME_TextEditor *editor, ME_Cursor *cursor, int nRelOfs, BOOL final_eop)
Definition: caret.c:720
void ME_InsertOLEFromCursor(ME_TextEditor *editor, const REOBJECT *reo, int nCursor)
Definition: caret.c:546
int ME_GetSelection(ME_TextEditor *editor, ME_Cursor **from, ME_Cursor **to)
Definition: caret.c:57
BOOL ME_InternalDeleteText(ME_TextEditor *editor, ME_Cursor *start, int nChars, BOOL bForce)
Definition: caret.c:360
int ME_GetSelectionOfs(ME_TextEditor *editor, int *from, int *to)
Definition: caret.c:42
int ME_GetTextLength(ME_TextEditor *editor)
Definition: caret.c:83
void ME_GetCursorCoordinates(ME_TextEditor *editor, ME_Cursor *pCursor, int *x, int *y, int *height)
Definition: caret.c:221
HRESULT ME_GetDataObject(ME_TextEditor *editor, const ME_Cursor *start, int nChars, IDataObject **dataobj)
Definition: clipboard.c:405
void ME_ReplaceSel(ME_TextEditor *editor, BOOL can_undo, const WCHAR *str, int len)
Definition: editor.c:3463
int ME_GetTextW(ME_TextEditor *editor, WCHAR *buffer, int buflen, const ME_Cursor *start, int srcChars, BOOL bCRLF, BOOL bEOP)
Definition: editor.c:5192
static HRESULT WINAPI ITextRange_fnMoveStartUntil(ITextRange *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:2326
static ITextParaVtbl textparavtbl
Definition: richole.c:4036
static HRESULT WINAPI ITextSelection_fnGetEnd(ITextSelection *me, LONG *pcpLim)
Definition: richole.c:4869
static HRESULT WINAPI IOleClientSite_fnGetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
Definition: richole.c:1133
static HRESULT WINAPI TextPara_SetRightIndent(ITextPara *iface, FLOAT value)
Definition: richole.c:3882
static HRESULT textrange_get_storylength(ME_TextEditor *editor, LONG *length)
Definition: richole.c:310
static HRESULT WINAPI ITextRange_fnMoveWhile(ITextRange *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:2274
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
Definition: richole.c:1221
static HRESULT WINAPI ITextSelection_fnGetFlags(ITextSelection *me, LONG *flags)
Definition: richole.c:5478
static HRESULT WINAPI TextPara_GetLineSpacingRule(ITextPara *iface, LONG *value)
Definition: richole.c:3706
static HRESULT WINAPI ITextSelection_fnMoveStart(ITextSelection *me, LONG unit, LONG count, LONG *delta)
Definition: richole.c:5193
static HRESULT WINAPI ITextRange_fnCollapse(ITextRange *me, LONG bStart)
Definition: richole.c:1988
static HRESULT WINAPI ITextSelection_fnStartOf(ITextSelection *me, LONG unit, LONG extend, LONG *delta)
Definition: richole.c:5155
static HRESULT WINAPI ITextRange_fnGetStoryLength(ITextRange *me, LONG *length)
Definition: richole.c:1948
static HRESULT WINAPI TextFont_GetIDsOfNames(ITextFont *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: richole.c:2673
static HRESULT WINAPI ITextDocument2Old_fnGetFEFlags(ITextDocument2Old *iface, LONG *flags)
Definition: richole.c:4487
static HRESULT WINAPI ITextSelection_fnMoveDown(ITextSelection *me, LONG unit, LONG count, LONG extend, LONG *delta)
Definition: richole.c:5553
static HRESULT WINAPI ITextSelection_fnDelete(ITextSelection *me, LONG unit, LONG count, LONG *delta)
Definition: richole.c:5342
static HRESULT WINAPI ITextRange_fnGetEmbeddedObject(ITextRange *me, IUnknown **ppv)
Definition: richole.c:2532
static HRESULT WINAPI ITextRange_fnScrollIntoView(ITextRange *me, LONG value)
Definition: richole.c:2500
static HRESULT WINAPI ITextDocument2Old_fnReleaseImmContext(ITextDocument2Old *iface, LONG context)
Definition: richole.c:4420
range_update_op
Definition: richole.c:205
@ RANGE_UPDATE_DELETE
Definition: richole.c:206
static HRESULT WINAPI ITextRange_fnMove(ITextRange *me, LONG unit, LONG count, LONG *delta)
Definition: richole.c:2190
static HRESULT WINAPI IRichEditOle_fnQueryInterface(IRichEditOle *me, REFIID riid, LPVOID *ppvObj)
Definition: richole.c:1014
static HRESULT WINAPI TextPara_SetWidowControl(ITextPara *iface, LONG value)
Definition: richole.c:3970
static IRichEditOleImpl * impl_from_IUnknown(IUnknown *iface)
Definition: richole.c:276
static HRESULT WINAPI ITextRange_fnSetChar(ITextRange *me, LONG ch)
Definition: richole.c:1744
static HRESULT WINAPI ITextSelection_fnSelect(ITextSelection *me)
Definition: richole.c:5142
static HRESULT WINAPI IRichEditOle_fnGetClientSite(IRichEditOle *me, IOleClientSite **clientsite)
Definition: richole.c:1337
static HRESULT CreateITextRange(IRichEditOleImpl *reOle, LONG start, LONG end, ITextRange **ppRange)
Definition: richole.c:4328
static HRESULT WINAPI TextFont_GetDuplicate(ITextFont *iface, ITextFont **ret)
Definition: richole.c:2713
static HRESULT WINAPI TextFont_GetSubscript(ITextFont *iface, LONG *value)
Definition: richole.c:3234
static HRESULT WINAPI ITextSelection_fnGetPara(ITextSelection *me, ITextPara **para)
Definition: richole.c:4943
static HRESULT WINAPI ITextRange_fnInStory(ITextRange *me, ITextRange *pRange, LONG *ret)
Definition: richole.c:2106
static HRESULT WINAPI TextFont_SetBold(ITextFont *iface, LONG value)
Definition: richole.c:2984
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnUIActivate(IOleInPlaceSite *iface)
Definition: richole.c:1242
static HRESULT get_textfont_prop(const ITextFontImpl *font, enum textfont_prop_id propid, textfont_prop_val *value)
Definition: richole.c:679
static HRESULT WINAPI TextFont_SetSuperscript(ITextFont *iface, LONG value)
Definition: richole.c:3255
static HRESULT WINAPI TextPara_GetTypeInfo(ITextPara *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: richole.c:3451
static HRESULT WINAPI TextPara_GetLeftIndent(ITextPara *iface, FLOAT *value)
Definition: richole.c:3684
static const ITextRangeVtbl trvt
Definition: richole.c:2544
static ITextFontVtbl textfontvtbl
Definition: richole.c:3290
static HRESULT WINAPI TextFont_SetShadow(ITextFont *iface, LONG value)
Definition: richole.c:3171
static HRESULT WINAPI ITextSelection_fnInRange(ITextSelection *me, ITextRange *range, LONG *ret)
Definition: richole.c:5076
static HRESULT WINAPI ITextSelection_fnChangeCase(ITextSelection *me, LONG type)
Definition: richole.c:5416
static HRESULT WINAPI ITextSelection_fnFindTextEnd(ITextSelection *me, BSTR text, LONG count, LONG flags, LONG *length)
Definition: richole.c:5329
static HRESULT WINAPI TextPara_SetListLevelIndex(ITextPara *iface, LONG value)
Definition: richole.c:3750
static HRESULT WINAPI TextPara_GetTabCount(ITextPara *iface, LONG *value)
Definition: richole.c:3981
static HRESULT WINAPI ITextSelection_fnEndOf(ITextSelection *me, LONG unit, LONG extend, LONG *delta)
Definition: richole.c:5168
static HRESULT WINAPI ITextRange_fnGetPara(ITextRange *me, ITextPara **para)
Definition: richole.c:1921
static HRESULT WINAPI IRichEditOle_fnGetObject(IRichEditOle *me, LONG iob, REOBJECT *lpreobject, DWORD dwFlags)
Definition: richole.c:1379
static HRESULT WINAPI ITextDocument2Old_fnGetImmContext(ITextDocument2Old *iface, LONG *context)
Definition: richole.c:4411
static const IOleInPlaceSiteVtbl olestvt
Definition: richole.c:1300
static HRESULT WINAPI TextFont_GetAnimation(ITextFont *iface, LONG *value)
Definition: richole.c:2944
static ULONG STDMETHODCALLTYPE IOleInPlaceSite_fnAddRef(IOleInPlaceSite *iface)
Definition: richole.c:1193
static HRESULT WINAPI ITextRange_fnChangeCase(ITextRange *me, LONG type)
Definition: richole.c:2463
static LONG WINAPI IRichEditOle_fnGetObjectCount(IRichEditOle *me)
Definition: richole.c:1428
static const ITextSelectionVtbl tsvt
Definition: richole.c:5604
static HRESULT WINAPI ITextDocument2Old_fnRange(ITextDocument2Old *iface, LONG cp1, LONG cp2, ITextRange **ppRange)
Definition: richole.c:4344
static HRESULT range_Collapse(LONG bStart, LONG *start, LONG *end)
Definition: richole.c:1976
static HRESULT WINAPI TextPara_SetListType(ITextPara *iface, LONG value)
Definition: richole.c:3816
static HRESULT WINAPI TextFont_GetStrikeThrough(ITextFont *iface, LONG *value)
Definition: richole.c:3220
static HRESULT WINAPI ITextDocument2Old_fnGetCaretType(ITextDocument2Old *iface, LONG *type)
Definition: richole.c:4393
static HRESULT WINAPI ITextSelection_fnSetPoint(ITextSelection *me, LONG x, LONG y, LONG type, LONG extend)
Definition: richole.c:5440
static HRESULT WINAPI ITextRange_fnDelete(ITextRange *me, LONG unit, LONG count, LONG *delta)
Definition: richole.c:2391
static HRESULT WINAPI IRichEditOle_fnConvertObject(IRichEditOle *me, LONG iob, REFCLSID rclsidNew, LPCSTR lpstrUserTypeNew)
Definition: richole.c:1051
static HRESULT WINAPI ITextSelection_fnMoveEndWhile(ITextSelection *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:5250
static HRESULT WINAPI ITextRange_fnGetPoint(ITextRange *me, LONG type, LONG *cx, LONG *cy)
Definition: richole.c:2475
static HRESULT WINAPI ITextSelection_fnSetEnd(ITextSelection *me, LONG value)
Definition: richole.c:4885
static HRESULT WINAPI ITextSelection_fnGetStoryType(ITextSelection *me, LONG *value)
Definition: richole.c:4988
static void textfont_reset_to_default(ITextFontImpl *font)
Definition: richole.c:2750
static HRESULT WINAPI TextPara_GetRightIndent(ITextPara *iface, FLOAT *value)
Definition: richole.c:3871
static HRESULT WINAPI ITextSelection_fnCut(ITextSelection *me, VARIANT *v)
Definition: richole.c:5355
static HRESULT WINAPI TextPara_QueryInterface(ITextPara *iface, REFIID riid, void **ppv)
Definition: richole.c:3390
static HRESULT WINAPI ITextDocument2Old_fnIMEInProgress(ITextDocument2Old *iface, LONG mode)
Definition: richole.c:4514
static HRESULT WINAPI ITextSelection_fnMoveStartWhile(ITextSelection *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:5237
static HRESULT WINAPI ITextRange_fnMoveStartWhile(ITextRange *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:2287
static HRESULT WINAPI ITextSelection_fnScrollIntoView(ITextSelection *me, LONG value)
Definition: richole.c:5453
static HRESULT WINAPI ITextRange_fnMoveEnd(ITextRange *me, LONG unit, LONG count, LONG *delta)
Definition: richole.c:2261
static HRESULT WINAPI ITextDocument2Old_fnOpen(ITextDocument2Old *iface, VARIANT *pVar, LONG Flags, LONG CodePage)
Definition: richole.c:4270
static HRESULT WINAPI TextPara_GetPageBreakBefore(ITextPara *iface, LONG *value)
Definition: richole.c:3849
static HRESULT WINAPI ITextSelection_fnGetType(ITextSelection *me, LONG *type)
Definition: richole.c:5502
static const IRichEditOleVtbl revt
Definition: richole.c:1510
static HRESULT WINAPI ITextSelection_fnCollapse(ITextSelection *me, LONG bStart)
Definition: richole.c:5004
static HRESULT WINAPI TextPara_SetListTab(ITextPara *iface, FLOAT value)
Definition: richole.c:3794
static IOleClientSiteImpl * impl_from_IOleInPlaceSite(IOleInPlaceSite *iface)
Definition: richole.c:281
#define CHARFORMAT_SET_B_FIELD(mask, value)
static const DWORD textfont_prop_masks[][2]
Definition: richole.c:172
static IRichEditOleImpl * impl_from_ITextDocument2Old(ITextDocument2Old *iface)
Definition: richole.c:271
static HRESULT WINAPI TextFont_GetLanguageID(ITextFont *iface, LONG *value)
Definition: richole.c:3075
static HRESULT WINAPI IRichEditOle_fnSetDvaspect(IRichEditOle *me, LONG iob, DWORD dvaspect)
Definition: richole.c:1487
static HRESULT WINAPI TextPara_GetListAlignment(ITextPara *iface, LONG *value)
Definition: richole.c:3717
static HRESULT WINAPI TextFont_SetAllCaps(ITextFont *iface, LONG value)
Definition: richole.c:2937
static HRESULT WINAPI TextFont_GetTypeInfo(ITextFont *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: richole.c:2659
static HRESULT WINAPI ITextDocument2Old_fnGetClientRect(ITextDocument2Old *iface, LONG type, LONG *left, LONG *top, LONG *right, LONG *bottom)
Definition: richole.c:4459
static HRESULT WINAPI ITextRange_fnMoveEndWhile(ITextRange *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:2300
static HRESULT WINAPI TextFont_SetSmallCaps(ITextFont *iface, LONG value)
Definition: richole.c:3199
static HRESULT WINAPI ITextDocument2Old_fnSetEffectColor(ITextDocument2Old *iface, LONG index, COLORREF cr)
Definition: richole.c:4375
static HRESULT WINAPI ITextRange_fnFindText(ITextRange *me, BSTR text, LONG count, LONG flags, LONG *length)
Definition: richole.c:2352
static void textrange_set_font(ITextRange *range, ITextFont *font)
Definition: richole.c:518
@ ITextSelection_tid
Definition: richole.c:61
@ LAST_tid
Definition: richole.c:64
@ ITextPara_tid
Definition: richole.c:63
@ NULL_tid
Definition: richole.c:58
@ ITextRange_tid
Definition: richole.c:60
@ ITextDocument_tid
Definition: richole.c:59
@ ITextFont_tid
Definition: richole.c:62
static BOOL is_equal_textfont_prop_value(enum textfont_prop_id propid, textfont_prop_val *left, textfont_prop_val *right)
Definition: richole.c:348
static HRESULT WINAPI ITextSelection_fnMoveEnd(ITextSelection *me, LONG unit, LONG count, LONG *delta)
Definition: richole.c:5206
static HRESULT textrange_inrange(LONG start, LONG end, ITextRange *range, LONG *ret)
Definition: richole.c:2073
static ITypeLib * typelib
Definition: richole.c:55
static HRESULT WINAPI TextPara_SetDuplicate(ITextPara *iface, ITextPara *para)
Definition: richole.c:3517
static void init_textfont_prop_value(enum textfont_prop_id propid, textfont_prop_val *v)
Definition: richole.c:386
static void textranges_update_ranges(IRichEditOleImpl *reole, LONG start, LONG end, enum range_update_op op)
Definition: richole.c:319
static HRESULT WINAPI TextFont_IsEqual(ITextFont *iface, ITextFont *font, LONG *ret)
Definition: richole.c:2743
static HRESULT WINAPI ITextDocument2Old_fnBeginEditCollection(ITextDocument2Old *iface)
Definition: richole.c:4300
static HRESULT WINAPI ITextDocument2Old_fnGetStoryRanges(ITextDocument2Old *iface, ITextStoryRanges **ppStories)
Definition: richole.c:4227
static HRESULT WINAPI IRichEditOle_fnGetClipboardData(IRichEditOle *me, CHARRANGE *lpchrg, DWORD reco, LPDATAOBJECT *lplpdataobj)
Definition: richole.c:1350
static HRESULT WINAPI ITextRange_fnSelect(ITextRange *me)
Definition: richole.c:2151
static HRESULT WINAPI ITextRange_fnIsEqual(ITextRange *me, ITextRange *range, LONG *ret)
Definition: richole.c:2133
static HRESULT WINAPI TextFont_GetName(ITextFont *iface, BSTR *value)
Definition: richole.c:3089
static ULONG WINAPI ITextSelection_fnRelease(ITextSelection *me)
Definition: richole.c:4633
static HRESULT WINAPI ITextRange_fnEndOf(ITextRange *me, LONG unit, LONG extend, LONG *delta)
Definition: richole.c:2177
static HRESULT WINAPI ITextRange_fnGetEnd(ITextRange *me, LONG *end)
Definition: richole.c:1845
static HRESULT WINAPI ITextSelection_fnPaste(ITextSelection *me, VARIANT *v, LONG format)
Definition: richole.c:5379
static HRESULT WINAPI TextFont_GetStyle(ITextFont *iface, LONG *value)
Definition: richole.c:2916
static HRESULT WINAPI TextPara_GetWidowControl(ITextPara *iface, LONG *value)
Definition: richole.c:3959
static ULONG WINAPI TextPara_Release(ITextPara *iface)
Definition: richole.c:3417
static HRESULT WINAPI ITextSelection_fnSetFlags(ITextSelection *me, LONG flags)
Definition: richole.c:5490
static HRESULT WINAPI ITextSelection_fnMoveUp(ITextSelection *me, LONG unit, LONG count, LONG extend, LONG *delta)
Definition: richole.c:5540
static HRESULT WINAPI TextPara_Reset(ITextPara *iface, LONG value)
Definition: richole.c:3550
static HRESULT WINAPI ITextDocument2Old_fnSysBeep(ITextDocument2Old *iface)
Definition: richole.c:4523
static HRESULT set_textfont_propl(ITextFontImpl *font, enum textfont_prop_id propid, LONG value)
Definition: richole.c:838
static ULONG WINAPI ITextRange_fnRelease(ITextRange *me)
Definition: richole.c:1561
static HRESULT WINAPI ITextSelection_fnGetTypeInfoCount(ITextSelection *me, UINT *pctinfo)
Definition: richole.c:4642
static HRESULT WINAPI ITextRange_fnGetFont(ITextRange *me, ITextFont **font)
Definition: richole.c:1890
void ME_CopyReObject(REOBJECT *dst, const REOBJECT *src, DWORD flags)
Definition: richole.c:5907
static FLOAT twips_to_points(LONG value)
Definition: richole.c:427
static HRESULT WINAPI TextFont_GetSmallCaps(ITextFont *iface, LONG *value)
Definition: richole.c:3192
static HRESULT WINAPI ITextDocument2Old_fnCheckTextLimit(ITextDocument2Old *iface, LONG cch, LONG *exceed)
Definition: richole.c:4505
static ULONG WINAPI IOleClientSite_fnAddRef(IOleClientSite *iface)
Definition: richole.c:1087
static HRESULT WINAPI TextPara_GetListTab(ITextPara *iface, FLOAT *value)
Definition: richole.c:3783
static HRESULT get_textfont_propl(const ITextFontImpl *font, enum textfont_prop_id propid, LONG *value)
Definition: richole.c:733
static HRESULT WINAPI ITextSelection_fnCanPaste(ITextSelection *me, VARIANT *v, LONG format, LONG *ret)
Definition: richole.c:5391
static ULONG WINAPI IRichEditOleImpl_inner_fnRelease(IUnknown *iface)
Definition: richole.c:977
static HRESULT textfont_getname_from_range(ITextRange *range, BSTR *ret)
Definition: richole.c:880
static ULONG WINAPI IRichEditOle_fnAddRef(IRichEditOle *me)
Definition: richole.c:1021
static ULONG WINAPI ITextDocument2Old_fnAddRef(ITextDocument2Old *iface)
Definition: richole.c:4120
static HRESULT WINAPI ITextDocument2Old_fnUpdate(ITextDocument2Old *iface, LONG mode)
Definition: richole.c:4532
static HRESULT WINAPI TextPara_GetListLevelIndex(ITextPara *iface, LONG *value)
Definition: richole.c:3739
static HRESULT WINAPI TextFont_Invoke(ITextFont *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: richole.c:2689
static ITextSelectionImpl * impl_from_ITextSelection(ITextSelection *iface)
Definition: richole.c:291
static HRESULT textrange_isequal(LONG start, LONG end, ITextRange *range, LONG *ret)
Definition: richole.c:2118
static HRESULT WINAPI IRichEditOle_fnInsertObject(IRichEditOle *me, REOBJECT *reo)
Definition: richole.c:1461
static HRESULT WINAPI TextFont_Reset(ITextFont *iface, LONG value)
Definition: richole.c:2851
static HRESULT create_textpara(ITextRange *, ITextPara **)
Definition: richole.c:4094
static HRESULT WINAPI ITextDocument2Old_fnGetSelectionEx(ITextDocument2Old *iface, ITextSelection **selection)
Definition: richole.c:4469
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnDeactivateAndUndo(IOleInPlaceSite *iface)
Definition: richole.c:1286
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnGetWindow(IOleInPlaceSite *iface, HWND *phwnd)
Definition: richole.c:1205
static HRESULT get_textfont_propf(const ITextFontImpl *font, enum textfont_prop_id propid, FLOAT *value)
Definition: richole.c:720
static HRESULT WINAPI ITextSelection_fnSetStart(ITextSelection *me, LONG value)
Definition: richole.c:4850
static HRESULT WINAPI IOleClientSite_fnQueryInterface(IOleClientSite *me, REFIID riid, LPVOID *ppvObj)
Definition: richole.c:1065
static HRESULT WINAPI ITextSelection_fnCanEdit(ITextSelection *me, LONG *ret)
Definition: richole.c:5404
void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run, BOOL selected)
Definition: richole.c:5804
static HRESULT WINAPI TextFont_SetLanguageID(ITextFont *iface, LONG value)
Definition: richole.c:3082
static HRESULT WINAPI ITextDocument2Old_fnQueryInterface(ITextDocument2Old *iface, REFIID riid, void **ppvObject)
Definition: richole.c:4113
static HRESULT WINAPI TextPara_GetHyphenation(ITextPara *iface, LONG *value)
Definition: richole.c:3607
static HRESULT WINAPI TextFont_SetUnderline(ITextFont *iface, LONG value)
Definition: richole.c:3269
static HRESULT WINAPI TextFont_SetForeColor(ITextFont *iface, LONG value)
Definition: richole.c:3012
static HRESULT WINAPI TextPara_GetTypeInfoCount(ITextPara *iface, UINT *pctinfo)
Definition: richole.c:3443
static FLOAT points_to_twips(FLOAT value)
Definition: richole.c:432
void ME_DeleteReObject(struct re_object *reobj)
Definition: richole.c:5899
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
Definition: richole.c:1265
static HRESULT WINAPI ITextRange_fnSetStart(ITextRange *me, LONG value)
Definition: richole.c:1833
static HRESULT WINAPI ITextRange_fnCanPaste(ITextRange *me, VARIANT *v, LONG format, LONG *ret)
Definition: richole.c:2439
static HRESULT WINAPI IOleClientSite_fnShowObject(IOleClientSite *iface)
Definition: richole.c:1144
static HRESULT WINAPI TextFont_GetBackColor(ITextFont *iface, LONG *value)
Definition: richole.c:2963
static HRESULT WINAPI ITextDocument2Old_fnNew(ITextDocument2Old *iface)
Definition: richole.c:4263
static HRESULT WINAPI ITextRange_fnInvoke(ITextRange *me, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: richole.c:1617
static HRESULT WINAPI TextPara_SetListStart(ITextPara *iface, LONG value)
Definition: richole.c:3772
static HRESULT WINAPI IOleClientSite_fnSaveObject(IOleClientSite *iface)
Definition: richole.c:1112
static HRESULT WINAPI ITextDocument2Old_fnEndEditCollection(ITextDocument2Old *iface)
Definition: richole.c:4307
static void textfont_apply_range_props(ITextFontImpl *font)
Definition: richole.c:2844
static HRESULT WINAPI ITextRange_fnGetStoryType(ITextRange *me, LONG *value)
Definition: richole.c:1960
static HRESULT range_GetChar(ME_TextEditor *editor, ME_Cursor *cursor, LONG *pch)
Definition: richole.c:1715
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnQueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppvObj)
Definition: richole.c:1187
static HRESULT WINAPI TextPara_GetKeepTogether(ITextPara *iface, LONG *value)
Definition: richole.c:3640
static HRESULT WINAPI TextFont_QueryInterface(ITextFont *iface, REFIID riid, void **ppv)
Definition: richole.c:2606
static HRESULT WINAPI ITextSelection_fnGetChar(ITextSelection *me, LONG *pch)
Definition: richole.c:4762
static HRESULT WINAPI TextFont_SetItalic(ITextFont *iface, LONG value)
Definition: richole.c:3054
static HRESULT WINAPI ITextRange_fnSetText(ITextRange *me, BSTR str)
Definition: richole.c:1671
static HRESULT WINAPI ITextSelection_fnMoveRight(ITextSelection *me, LONG unit, LONG count, LONG extend, LONG *delta)
Definition: richole.c:5527
static HRESULT WINAPI TextPara_SetSpaceBefore(ITextPara *iface, FLOAT value)
Definition: richole.c:3948
static HRESULT WINAPI ITextDocument2Old_fnGetWindow(ITextDocument2Old *iface, LONG *hwnd)
Definition: richole.c:4478
static HRESULT WINAPI TextFont_SetKerning(ITextFont *iface, FLOAT value)
Definition: richole.c:3068
static HRESULT WINAPI ITextDocument2Old_fnUpdateWindow(ITextDocument2Old *iface)
Definition: richole.c:4496
static ULONG STDMETHODCALLTYPE IOleInPlaceSite_fnRelease(IOleInPlaceSite *iface)
Definition: richole.c:1199
static HRESULT WINAPI TextPara_GetSpaceBefore(ITextPara *iface, FLOAT *value)
Definition: richole.c:3937
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnInPlaceDeactivate(IOleInPlaceSite *iface)
Definition: richole.c:1272
static HRESULT WINAPI TextFont_SetEmboss(ITextFont *iface, LONG value)
Definition: richole.c:2998
static HRESULT WINAPI ITextDocument2Old_fnRangeFromPoint(ITextDocument2Old *iface, LONG x, LONG y, ITextRange **ppRange)
Definition: richole.c:4357
static HRESULT WINAPI ITextSelection_fnMoveEndUntil(ITextSelection *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:5289
static HRESULT WINAPI ITextRange_fnGetFormattedText(ITextRange *me, ITextRange **range)
Definition: richole.c:1773
static HRESULT WINAPI ITextDocument2Old_fnGetTypeInfoCount(ITextDocument2Old *iface, UINT *pctinfo)
Definition: richole.c:4132
static HRESULT WINAPI ITextDocument2Old_fnGetStoryCount(ITextDocument2Old *iface, LONG *pCount)
Definition: richole.c:4220
static HRESULT WINAPI TextPara_SetHyphenation(ITextPara *iface, LONG value)
Definition: richole.c:3618
static HRESULT WINAPI ITextDocument2Old_fnSetSaved(ITextDocument2Old *iface, LONG Value)
Definition: richole.c:4242
static HRESULT WINAPI TextPara_GetIDsOfNames(ITextPara *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: richole.c:3465
static HRESULT WINAPI TextPara_IsEqual(ITextPara *iface, ITextPara *para, LONG *ret)
Definition: richole.c:3539
static HRESULT WINAPI ITextRange_fnFindTextEnd(ITextRange *me, BSTR text, LONG count, LONG flags, LONG *length)
Definition: richole.c:2378
static HRESULT WINAPI ITextDocument2Old_fnAttachMsgFilter(ITextDocument2Old *iface, IUnknown *filter)
Definition: richole.c:4366
static HRESULT WINAPI TextPara_ClearAllTabs(ITextPara *iface)
Definition: richole.c:4003
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnDiscardUndoState(IOleInPlaceSite *iface)
Definition: richole.c:1279
static HRESULT WINAPI TextFont_GetSpacing(ITextFont *iface, FLOAT *value)
Definition: richole.c:3206
static HRESULT WINAPI ITextRange_fnExpand(ITextRange *me, LONG unit, LONG *delta)
Definition: richole.c:2000
static HRESULT WINAPI IRichEditOleImpl_inner_fnQueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppvObj)
Definition: richole.c:936
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnGetWindowContext(IOleInPlaceSite *iface, IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
Definition: richole.c:1249
static HRESULT WINAPI ITextSelection_fnHomeKey(ITextSelection *me, LONG unit, LONG extend, LONG *delta)
Definition: richole.c:5566
static HRESULT WINAPI TextPara_GetAlignment(ITextPara *iface, LONG *value)
Definition: richole.c:3583
static HRESULT WINAPI ITextDocument2Old_fnGetPreferredFont(ITextDocument2Old *iface, LONG cp, LONG charrep, LONG options, LONG current_charrep, LONG current_fontsize, BSTR *bstr, LONG *pitch_family, LONG *new_fontsize)
Definition: richole.c:4429
static HRESULT WINAPI TextFont_SetName(ITextFont *iface, BSTR value)
Definition: richole.c:3111
static HRESULT WINAPI ITextRange_fnCanEdit(ITextRange *me, LONG *ret)
Definition: richole.c:2451
static ULONG WINAPI ITextDocument2Old_fnRelease(ITextDocument2Old *iface)
Definition: richole.c:4126
static HRESULT WINAPI ITextRange_fnMoveUntil(ITextRange *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:2313
static HRESULT WINAPI TextFont_SetSpacing(ITextFont *iface, FLOAT value)
Definition: richole.c:3213
static HRESULT WINAPI ITextRange_fnGetText(ITextRange *me, BSTR *str)
Definition: richole.c:1635
textfont_prop_id
Definition: richole.c:143
@ FONT_SPACING
Definition: richole.c:162
@ FONT_UNDERLINE
Definition: richole.c:166
@ FONT_OUTLINE
Definition: richole.c:156
@ FONT_SIZE
Definition: richole.c:160
@ FONT_PROPID_LAST
Definition: richole.c:168
@ FONT_BACKCOLOR
Definition: richole.c:146
@ FONT_HIDDEN
Definition: richole.c:150
@ FONT_STRIKETHROUGH
Definition: richole.c:163
@ FONT_SUPERSCRIPT
Definition: richole.c:165
@ FONT_SMALLCAPS
Definition: richole.c:161
@ FONT_PROTECTED
Definition: richole.c:158
@ FONT_EMBOSS
Definition: richole.c:148
@ FONT_ALLCAPS
Definition: richole.c:144
@ FONT_ENGRAVE
Definition: richole.c:151
@ FONT_SUBSCRIPT
Definition: richole.c:164
@ FONT_BOLD
Definition: richole.c:147
@ FONT_LANGID
Definition: richole.c:154
@ FONT_PROPID_FIRST
Definition: richole.c:169
@ FONT_FORECOLOR
Definition: richole.c:149
@ FONT_POSITION
Definition: richole.c:157
@ FONT_NAME
Definition: richole.c:155
@ FONT_ANIMATION
Definition: richole.c:145
@ FONT_KERNING
Definition: richole.c:153
@ FONT_SHADOW
Definition: richole.c:159
@ FONT_WEIGHT
Definition: richole.c:167
@ FONT_ITALIC
Definition: richole.c:152
static HRESULT WINAPI ITextRange_fnPaste(ITextRange *me, VARIANT *v, LONG format)
Definition: richole.c:2427
static HRESULT WINAPI ITextRange_fnCut(ITextRange *me, VARIANT *v)
Definition: richole.c:2403
static HRESULT WINAPI TextPara_GetStyle(ITextPara *iface, LONG *value)
Definition: richole.c:3561
static HRESULT WINAPI ITextDocument2Old_fnGetSaved(ITextDocument2Old *iface, LONG *pValue)
Definition: richole.c:4235
static HRESULT textrange_moveend(ITextRange *range, LONG unit, LONG count, LONG *delta)
Definition: richole.c:2215
static HRESULT WINAPI ITextSelection_fnGetDuplicate(ITextSelection *me, ITextRange **range)
Definition: richole.c:4791
static HRESULT WINAPI ITextRange_fnStartOf(ITextRange *me, LONG unit, LONG extend, LONG *delta)
Definition: richole.c:2164
static HRESULT WINAPI ITextRange_fnCopy(ITextRange *me, VARIANT *v)
Definition: richole.c:2415
static HRESULT WINAPI TextFont_GetTypeInfoCount(ITextFont *iface, UINT *pctinfo)
Definition: richole.c:2651
static HRESULT WINAPI TextPara_SetPageBreakBefore(ITextPara *iface, LONG value)
Definition: richole.c:3860
static HRESULT WINAPI IOleClientSite_fnRequestNewObjectLayout(IOleClientSite *iface)
Definition: richole.c:1164
static HRESULT WINAPI ITextSelection_fnFindText(ITextSelection *me, BSTR text, LONG count, LONG flags, LONG *length)
Definition: richole.c:5302
static HRESULT WINAPI ITextSelection_fnMoveStartUntil(ITextSelection *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:5276
static HRESULT WINAPI TextFont_GetOutline(ITextFont *iface, LONG *value)
Definition: richole.c:3122
static HRESULT WINAPI TextPara_SetAlignment(ITextPara *iface, LONG value)
Definition: richole.c:3596
static IOleClientSiteImpl * impl_from_IOleClientSite(IOleClientSite *iface)
Definition: richole.c:1059
static HRESULT WINAPI ITextSelection_fnInvoke(ITextSelection *me, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: richole.c:4680
static HRESULT WINAPI ITextSelection_fnSetText(ITextSelection *me, BSTR str)
Definition: richole.c:4740
static HRESULT WINAPI ITextSelection_fnMove(ITextSelection *me, LONG unit, LONG count, LONG *delta)
Definition: richole.c:5181
static HRESULT WINAPI TextPara_GetNoLineNumber(ITextPara *iface, LONG *value)
Definition: richole.c:3827
static HRESULT WINAPI ITextSelection_fnSetChar(ITextSelection *me, LONG ch)
Definition: richole.c:4779
static HRESULT CreateOleClientSite(IRichEditOleImpl *reOle, IOleClientSite **ret)
Definition: richole.c:1319
static HRESULT WINAPI IRichEditOle_fnContextSensitiveHelp(IRichEditOle *me, BOOL fEnterMode)
Definition: richole.c:1043
static HRESULT WINAPI ITextRange_fnGetStart(ITextRange *me, LONG *start)
Definition: richole.c:1797
static HRESULT WINAPI ITextDocument2Old_fnFreeze(ITextDocument2Old *iface, LONG *pCount)
Definition: richole.c:4286
void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize)
Definition: richole.c:5727
static HRESULT WINAPI ITextDocument2Old_fnGetDefaultTabStop(ITextDocument2Old *iface, float *pValue)
Definition: richole.c:4249
static HRESULT WINAPI ITextRange_fnGetTypeInfo(ITextRange *me, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: richole.c:1587
static HRESULT WINAPI ITextRange_fnMoveStart(ITextRange *me, LONG unit, LONG count, LONG *delta)
Definition: richole.c:2202
static HRESULT WINAPI ITextDocument2Old_fnInvoke(ITextDocument2Old *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: richole.c:4172
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnScroll(IOleInPlaceSite *iface, SIZE scrollExtent)
Definition: richole.c:1258
static HRESULT WINAPI ITextSelection_fnSetIndex(ITextSelection *me, LONG unit, LONG index, LONG extend)
Definition: richole.c:5051
static HRESULT WINAPI TextPara_GetListType(ITextPara *iface, LONG *value)
Definition: richole.c:3805
static ULONG WINAPI ITextRange_fnAddRef(ITextRange *me)
Definition: richole.c:1555
static HRESULT WINAPI TextFont_GetEngrave(ITextFont *iface, LONG *value)
Definition: richole.c:3033
static HRESULT WINAPI TextFont_SetAnimation(ITextFont *iface, LONG value)
Definition: richole.c:2951
static IRichEditOleImpl * impl_from_IRichEditOle(IRichEditOle *iface)
Definition: richole.c:266
static HRESULT WINAPI ITextDocument2Old_fnRedo(ITextDocument2Old *iface, LONG Count, LONG *prop)
Definition: richole.c:4321
static HRESULT get_typeinfo(enum tid_t tid, ITypeInfo **typeinfo)
Definition: richole.c:108
static HRESULT WINAPI ITextDocument2Old_fnSave(ITextDocument2Old *iface, VARIANT *pVar, LONG Flags, LONG CodePage)
Definition: richole.c:4278
void release_typelib(void)
Definition: richole.c:94
static HRESULT WINAPI ITextRange_fnInRange(ITextRange *me, ITextRange *range, LONG *ret)
Definition: richole.c:2088
static HRESULT WINAPI ITextDocument2Old_fnGetTypeInfo(ITextDocument2Old *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: richole.c:4141
static HRESULT WINAPI TextFont_GetShadow(ITextFont *iface, LONG *value)
Definition: richole.c:3164
static HRESULT WINAPI ITextDocument2Old_fnGetIDsOfNames(ITextDocument2Old *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: richole.c:4155
static HRESULT WINAPI TextFont_GetAllCaps(ITextFont *iface, LONG *value)
Definition: richole.c:2930
static HRESULT WINAPI TextFont_SetEngrave(ITextFont *iface, LONG value)
Definition: richole.c:3040
static HRESULT WINAPI TextPara_SetStyle(ITextPara *iface, LONG value)
Definition: richole.c:3572
static HRESULT WINAPI IOleClientSite_fnOnShowWindow(IOleClientSite *iface, BOOL fShow)
Definition: richole.c:1154
static HRESULT load_typelib(void)
Definition: richole.c:78
static HRESULT WINAPI ITextDocument2Old_fnSetNotificationMode(ITextDocument2Old *iface, LONG mode)
Definition: richole.c:4450
static HRESULT WINAPI TextFont_SetStyle(ITextFont *iface, LONG value)
Definition: richole.c:2923
static HRESULT WINAPI TextPara_SetSpaceAfter(ITextPara *iface, FLOAT value)
Definition: richole.c:3926
static HRESULT WINAPI ITextSelection_fnInStory(ITextSelection *me, ITextRange *range, LONG *ret)
Definition: richole.c:5103
static HRESULT WINAPI ITextSelection_fnGetStoryLength(ITextSelection *me, LONG *length)
Definition: richole.c:4976
static HRESULT WINAPI TextPara_SetNoLineNumber(ITextPara *iface, LONG value)
Definition: richole.c:3838
static HRESULT WINAPI IRichEditOle_fnHandsOffStorage(IRichEditOle *me, LONG iob)
Definition: richole.c:1436
static HRESULT WINAPI TextFont_GetUnderline(ITextFont *iface, LONG *value)
Definition: richole.c:3262
static IRichEditOleImpl * para_get_reole(ITextParaImpl *This)
Definition: richole.c:3433
static HRESULT WINAPI ITextSelection_fnTypeText(ITextSelection *me, BSTR text)
Definition: richole.c:5592
static HRESULT WINAPI TextPara_SetIndents(ITextPara *iface, FLOAT StartIndent, FLOAT LeftIndent, FLOAT RightIndent)
Definition: richole.c:3893
static HRESULT WINAPI ITextSelection_fnGetText(ITextSelection *me, BSTR *pbstr)
Definition: richole.c:4705
static HRESULT WINAPI ITextSelection_fnGetFormattedText(ITextSelection *me, ITextRange **range)
Definition: richole.c:4809
static HRESULT WINAPI IRichEditOle_fnSetHostNames(IRichEditOle *me, LPCSTR lpstrContainerApp, LPCSTR lpstrContainerObj)
Definition: richole.c:1494
static HRESULT textrange_setend(const IRichEditOleImpl *reole, LONG value, LONG *start, LONG *end)
Definition: richole.c:1861
static HRESULT WINAPI TextPara_CanChange(ITextPara *iface, LONG *ret)
Definition: richole.c:3528
static HRESULT WINAPI TextFont_GetProtected(ITextFont *iface, LONG *value)
Definition: richole.c:3150
static LONG WINAPI IRichEditOle_fnGetLinkCount(IRichEditOle *me)
Definition: richole.c:1371
static HRESULT WINAPI ITextRange_fnSetPara(ITextRange *me, ITextPara *para)
Definition: richole.c:1936
static HRESULT WINAPI ITextSelection_fnSetRange(ITextSelection *me, LONG anchor, LONG active)
Definition: richole.c:5064
static HRESULT WINAPI TextFont_SetSubscript(ITextFont *iface, LONG value)
Definition: richole.c:3241
static HRESULT WINAPI ITextRange_fnSetFont(ITextRange *me, ITextFont *font)
Definition: richole.c:1905
static HRESULT WINAPI ITextSelection_fnQueryInterface(ITextSelection *me, REFIID riid, void **ppvObj)
Definition: richole.c:4601
static HRESULT WINAPI TextFont_GetBold(ITextFont *iface, LONG *value)
Definition: richole.c:2977
static HRESULT WINAPI ITextRange_fnSetRange(ITextRange *me, LONG anchor, LONG active)
Definition: richole.c:2055
static HRESULT WINAPI ITextSelection_fnGetStart(ITextSelection *me, LONG *pcpFirst)
Definition: richole.c:4834
static HRESULT WINAPI ITextDocument2Old_fnUnfreeze(ITextDocument2Old *iface, LONG *pCount)
Definition: richole.c:4293
static HRESULT WINAPI ITextRange_fnSetFormattedText(ITextRange *me, ITextRange *range)
Definition: richole.c:1785
static HRESULT WINAPI IRichEditOle_fnSetLinkAvailable(IRichEditOle *me, LONG iob, BOOL fAvailable)
Definition: richole.c:1503
LRESULT CreateIRichEditOle(IUnknown *outer_unk, ME_TextEditor *editor, LPVOID *ppvObj)
Definition: richole.c:5688
static HRESULT WINAPI ITextSelection_fnGetFont(ITextSelection *me, ITextFont **font)
Definition: richole.c:4904
static HRESULT create_textfont(ITextRange *, const ITextFontImpl *, ITextFont **)
Definition: richole.c:3355
static HRESULT WINAPI ITextSelection_fnGetPoint(ITextSelection *me, LONG type, LONG *cx, LONG *cy)
Definition: richole.c:5428
static HRESULT WINAPI ITextDocument2Old_fnGetNotificationMode(ITextDocument2Old *iface, LONG *mode)
Definition: richole.c:4441
static HRESULT WINAPI TextPara_DeleteTab(ITextPara *iface, FLOAT pos)
Definition: richole.c:4014
static HRESULT WINAPI TextPara_SetKeepWithNext(ITextPara *iface, LONG value)
Definition: richole.c:3673
static ULONG WINAPI IOleClientSite_fnRelease(IOleClientSite *iface)
Definition: richole.c:1095
static HRESULT WINAPI ITextSelection_fnFindTextStart(ITextSelection *me, BSTR text, LONG count, LONG flags, LONG *length)
Definition: richole.c:5316
static HRESULT set_textfont_prop(ITextFontImpl *font, enum textfont_prop_id propid, const textfont_prop_val *value)
Definition: richole.c:747
static ITextFontImpl * impl_from_ITextFont(ITextFont *iface)
Definition: richole.c:296
static HRESULT WINAPI ITextSelection_fnGetTypeInfo(ITextSelection *me, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: richole.c:4650
static HRESULT WINAPI TextPara_GetSpaceAfter(ITextPara *iface, FLOAT *value)
Definition: richole.c:3915
static HRESULT WINAPI TextPara_Invoke(ITextPara *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: richole.c:3481
static const ITextDocument2OldVtbl tdvt
Definition: richole.c:4550
static HRESULT WINAPI TextFont_SetOutline(ITextFont *iface, LONG value)
Definition: richole.c:3129
static HRESULT WINAPI TextFont_SetProtected(ITextFont *iface, LONG value)
Definition: richole.c:3157
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
Definition: richole.c:1293
static HRESULT WINAPI ITextRange_fnGetChar(ITextRange *me, LONG *pch)
Definition: richole.c:1725
static HRESULT WINAPI ITextSelection_fnGetEmbeddedObject(ITextSelection *me, IUnknown **ppv)
Definition: richole.c:5465
static HRESULT WINAPI TextPara_AddTab(ITextPara *iface, FLOAT tbPos, LONG tbAlign, LONG tbLeader)
Definition: richole.c:3992
static HRESULT WINAPI IOleClientSite_fnGetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
Definition: richole.c:1122
static HRESULT WINAPI IRichEditOle_fnSaveCompleted(IRichEditOle *me, LONG iob, LPSTORAGE lpstg)
Definition: richole.c:1478
static HRESULT WINAPI ITextDocument2Old_fnGetEffectColor(ITextDocument2Old *iface, LONG index, COLORREF *cr)
Definition: richole.c:4384
static ULONG WINAPI TextFont_Release(ITextFont *iface)
Definition: richole.c:2633
static HRESULT WINAPI ITextDocument2Old_fnGetName(ITextDocument2Old *iface, BSTR *pName)
Definition: richole.c:4191
static HRESULT WINAPI TextPara_SetListAlignment(ITextPara *iface, LONG value)
Definition: richole.c:3728
static HRESULT WINAPI TextFont_SetPosition(ITextFont *iface, FLOAT value)
Definition: richole.c:3143
static HRESULT WINAPI ITextSelection_fnSetPara(ITextSelection *me, ITextPara *para)
Definition: richole.c:4963
static ULONG WINAPI TextPara_AddRef(ITextPara *iface)
Definition: richole.c:3409
static HRESULT WINAPI TextFont_CanChange(ITextFont *iface, LONG *ret)
Definition: richole.c:2736
static const IUnknownVtbl reo_unk_vtbl
Definition: richole.c:1006
static HRESULT WINAPI IRichEditOle_fnImportDataObject(IRichEditOle *me, LPDATAOBJECT lpdataobj, CLIPFORMAT cf, HGLOBAL hMetaPict)
Definition: richole.c:1444
static HRESULT WINAPI TextFont_GetKerning(ITextFont *iface, FLOAT *value)
Definition: richole.c:3061
static HRESULT WINAPI ITextSelection_fnEndKey(ITextSelection *me, LONG unit, LONG extend, LONG *delta)
Definition: richole.c:5579
static HRESULT WINAPI ITextDocument2Old_fnGetSelection(ITextDocument2Old *iface, ITextSelection **selection)
Definition: richole.c:4198
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnCanInPlaceActivate(IOleInPlaceSite *iface)
Definition: richole.c:1228
static void cp2range(ME_TextEditor *editor, LONG *cp1, LONG *cp2)
Definition: richole.c:2037
static HRESULT get_textfont_prop_for_pos(const IRichEditOleImpl *reole, int pos, enum textfont_prop_id propid, textfont_prop_val *value)
Definition: richole.c:437
static ULONG WINAPI TextFont_AddRef(ITextFont *iface)
Definition: richole.c:2625
static HRESULT WINAPI ITextSelection_fnSetFont(ITextSelection *me, ITextFont *font)
Definition: richole.c:4924
static HRESULT WINAPI ITextRange_fnSetPoint(ITextRange *me, LONG x, LONG y, LONG type, LONG extend)
Definition: richole.c:2487
static void textfont_cache_range_props(ITextFontImpl *font)
Definition: richole.c:896
static HRESULT WINAPI TextFont_GetHidden(ITextFont *iface, LONG *value)
Definition: richole.c:3019
static HRESULT WINAPI TextFont_GetForeColor(ITextFont *iface, LONG *value)
Definition: richole.c:3005
static HRESULT WINAPI TextPara_GetFirstLineIndent(ITextPara *iface, FLOAT *value)
Definition: richole.c:3629
static HRESULT WINAPI IRichEditOle_fnActivateAs(IRichEditOle *me, REFCLSID rclsid, REFCLSID rclsidAs)
Definition: richole.c:1035
static HRESULT WINAPI ITextRange_fnGetIDsOfNames(ITextRange *me, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: richole.c:1601
static HRESULT WINAPI TextPara_GetListStart(ITextPara *iface, LONG *value)
Definition: richole.c:3761
static HRESULT WINAPI TextFont_GetSize(ITextFont *iface, FLOAT *value)
Definition: richole.c:3178
static HRESULT WINAPI ITextDocument2Old_fnUndo(ITextDocument2Old *iface, LONG Count, LONG *prop)
Definition: richole.c:4314
static ITextSelectionImpl * CreateTextSelection(IRichEditOleImpl *)
Definition: richole.c:5676
static void convert_sizel(const ME_Context *c, const SIZEL *szl, SIZE *sz)
Definition: richole.c:5715
static HRESULT WINAPI TextFont_GetSuperscript(ITextFont *iface, LONG *value)
Definition: richole.c:3248
static HRESULT WINAPI ITextSelection_fnSetFormattedText(ITextSelection *me, ITextRange *range)
Definition: richole.c:4821
static HRESULT WINAPI TextFont_SetHidden(ITextFont *iface, LONG value)
Definition: richole.c:3026
static ULONG WINAPI IRichEditOle_fnRelease(IRichEditOle *me)
Definition: richole.c:1028
static HRESULT WINAPI TextFont_GetPosition(ITextFont *iface, FLOAT *value)
Definition: richole.c:3136
static const IID *const tid_ids[]
Definition: richole.c:67
static HRESULT WINAPI TextFont_GetWeight(ITextFont *iface, LONG *value)
Definition: richole.c:3276
static HRESULT WINAPI ITextSelection_fnMoveUntil(ITextSelection *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:5263
static HRESULT WINAPI ITextRange_fnGetTypeInfoCount(ITextRange *me, UINT *pctinfo)
Definition: richole.c:1579
static HRESULT WINAPI TextFont_SetBackColor(ITextFont *iface, LONG value)
Definition: richole.c:2970
static HRESULT WINAPI TextPara_GetLineSpacing(ITextPara *iface, FLOAT *value)
Definition: richole.c:3695
static HRESULT WINAPI ITextSelection_fnExpand(ITextSelection *me, LONG unit, LONG *delta)
Definition: richole.c:5022
static HRESULT WINAPI ITextRange_fnFindTextStart(ITextRange *me, BSTR text, LONG count, LONG flags, LONG *length)
Definition: richole.c:2365
static HRESULT WINAPI TextFont_SetDuplicate(ITextFont *iface, ITextFont *pFont)
Definition: richole.c:2729
static HRESULT WINAPI TextPara_GetKeepWithNext(ITextPara *iface, LONG *value)
Definition: richole.c:3662
static HRESULT WINAPI TextFont_SetSize(ITextFont *iface, FLOAT value)
Definition: richole.c:3185
static HRESULT WINAPI ITextDocument2Old_fnSetCaretType(ITextDocument2Old *iface, LONG type)
Definition: richole.c:4402
static HRESULT set_textfont_propd(ITextFontImpl *font, enum textfont_prop_id propid, LONG value)
Definition: richole.c:852
static HRESULT WINAPI ITextRange_fnMoveEndUntil(ITextRange *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:2339
static HRESULT WINAPI ITextSelection_fnMoveWhile(ITextSelection *me, VARIANT *charset, LONG count, LONG *delta)
Definition: richole.c:5224
static HRESULT WINAPI TextPara_SetKeepTogether(ITextPara *iface, LONG value)
Definition: richole.c:3651
static void textfont_reset_to_undefined(ITextFontImpl *font)
Definition: richole.c:2802
static ULONG WINAPI ITextSelection_fnAddRef(ITextSelection *me)
Definition: richole.c:4627
static HRESULT WINAPI ITextSelection_fnMoveLeft(ITextSelection *me, LONG unit, LONG count, LONG extend, LONG *delta)
Definition: richole.c:5514
static HRESULT WINAPI TextFont_SetWeight(ITextFont *iface, LONG value)
Definition: richole.c:3283
static HRESULT WINAPI ITextSelection_fnGetIndex(ITextSelection *me, LONG unit, LONG *index)
Definition: richole.c:5039
static HRESULT textrange_setstart(const IRichEditOleImpl *reole, LONG value, LONG *start, LONG *end)
Definition: richole.c:1813
static HRESULT WINAPI ITextDocument2Old_fnNotify(ITextDocument2Old *iface, LONG notify)
Definition: richole.c:4541
static const IRichEditOleImpl * get_range_reole(ITextRange *range)
Definition: richole.c:511
static HRESULT set_textfont_propf(ITextFontImpl *font, enum textfont_prop_id propid, FLOAT value)
Definition: richole.c:845
static HRESULT WINAPI ITextSelection_fnCopy(ITextSelection *me, VARIANT *v)
Definition: richole.c:5367
static HRESULT STDMETHODCALLTYPE IOleInPlaceSite_fnOnInPlaceActivate(IOleInPlaceSite *iface)
Definition: richole.c:1235
static HRESULT WINAPI ITextRange_fnSetEnd(ITextRange *me, LONG value)
Definition: richole.c:1878
static HRESULT WINAPI ITextDocument2Old_fnSetDefaultTabStop(ITextDocument2Old *iface, float Value)
Definition: richole.c:4256
static HRESULT WINAPI TextPara_GetTab(ITextPara *iface, LONG iTab, FLOAT *ptbPos, LONG *ptbAlign, LONG *ptbLeader)
Definition: richole.c:4025
static HRESULT WINAPI ITextSelection_fnIsEqual(ITextSelection *me, ITextRange *range, LONG *ret)
Definition: richole.c:5115
static HRESULT textrange_expand(ITextRange *range, LONG unit, LONG *delta)
Definition: richole.c:907
static ITypeInfo * typeinfos[LAST_tid]
Definition: richole.c:76
static HRESULT WINAPI ITextRange_fnGetDuplicate(ITextRange *me, ITextRange **ppRange)
Definition: richole.c:1758
static HRESULT WINAPI ITextRange_fnQueryInterface(ITextRange *me, REFIID riid, void **ppvObj)
Definition: richole.c:1533
static HRESULT WINAPI ITextSelection_fnGetIDsOfNames(ITextSelection *me, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: richole.c:4664
static HRESULT WINAPI TextFont_SetStrikeThrough(ITextFont *iface, LONG value)
Definition: richole.c:3227
static HRESULT WINAPI TextFont_GetEmboss(ITextFont *iface, LONG *value)
Definition: richole.c:2991
static const IOleClientSiteVtbl ocst
Definition: richole.c:1174
static HRESULT WINAPI ITextRange_fnSetIndex(ITextRange *me, LONG unit, LONG index, LONG extend)
Definition: richole.c:2024
static ITextParaImpl * impl_from_ITextPara(ITextPara *iface)
Definition: richole.c:301
static HRESULT WINAPI TextFont_GetItalic(ITextFont *iface, LONG *value)
Definition: richole.c:3047
static ULONG WINAPI IRichEditOleImpl_inner_fnAddRef(IUnknown *iface)
Definition: richole.c:967
static HRESULT WINAPI ITextRange_fnGetIndex(ITextRange *me, LONG unit, LONG *index)
Definition: richole.c:2012
static HRESULT WINAPI TextPara_SetLineSpacing(ITextPara *iface, LONG LineSpacingRule, FLOAT LineSpacing)
Definition: richole.c:3904
static ITextRangeImpl * impl_from_ITextRange(ITextRange *iface)
Definition: richole.c:286
static HRESULT WINAPI IRichEditOle_fnInPlaceDeactivate(IRichEditOle *me)
Definition: richole.c:1453
static HRESULT WINAPI TextPara_GetDuplicate(ITextPara *iface, ITextPara **ret)
Definition: richole.c:3506
#define assert(x)
Definition: debug.h:53
void ME_ReleaseStyle(ME_Style *item) DECLSPEC_HIDDEN
Definition: style.c:462
ME_Style * ME_GetInsertStyle(ME_TextEditor *editor, int nCursor) DECLSPEC_HIDDEN
Definition: style.c:476
void ME_CursorFromCharOfs(ME_TextEditor *editor, int nCharOfs, ME_Cursor *pCursor) DECLSPEC_HIDDEN
Definition: run.c:171
void ME_ScrollAbs(ME_TextEditor *editor, int x, int y) DECLSPEC_HIDDEN
Definition: paint.c:1043
void ME_CommitUndo(ME_TextEditor *editor) DECLSPEC_HIDDEN
Definition: undo.c:227
void ME_UpdateRepaint(ME_TextEditor *editor, BOOL update_now) DECLSPEC_HIDDEN
Definition: paint.c:116
void ME_GetCharFormat(ME_TextEditor *editor, const ME_Cursor *from, const ME_Cursor *to, CHARFORMAT2W *pFmt) DECLSPEC_HIDDEN
Definition: run.c:819
void ME_SetCharFormat(ME_TextEditor *editor, ME_Cursor *start, ME_Cursor *end, CHARFORMAT2W *pFmt) DECLSPEC_HIDDEN
Definition: run.c:725
#define MERF_GRAPHICS
Definition: editstr.h:105
@ diTextEnd
Definition: editstr.h:89
#define HIDDEN
Definition: fatfs.h:184
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
PWCHAR pValue
FxCollectionEntry * cur
GLuint start
Definition: gl.h:1545
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
const GLdouble * v
Definition: gl.h:2040
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLuint GLuint end
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLenum src
Definition: glext.h:6340
const GLubyte * c
Definition: glext.h:8905
GLuint index
Definition: glext.h:6031
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
GLdouble GLdouble right
Definition: glext.h:10859
GLfloat f
Definition: glext.h:7540
GLenum GLint * range
Definition: glext.h:7539
GLenum mode
Definition: glext.h:6217
GLint left
Definition: glext.h:7726
GLenum GLenum dst
Definition: glext.h:6340
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
GLbitfield flags
Definition: glext.h:7161
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLint GLint bottom
Definition: glext.h:7726
const GLint * first
Definition: glext.h:5794
GLenum GLsizei len
Definition: glext.h:6722
GLuint id
Definition: glext.h:5910
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
const char cursor[]
Definition: icontest.c:13
tid_t
Definition: ieframe.h:311
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
uint32_t entry
Definition: isohybrid.c:63
#define f
Definition: ke_i.h:83
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
#define wine_dbgstr_w
Definition: kernel32.h:34
LCID WINAPI GetSystemDefaultLCID(void)
Definition: lang.c:797
POINT cp
Definition: magnifier.c:59
#define pch(ap)
Definition: match.c:418
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static LPSTR pName
Definition: security.c:75
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
static DWORD DWORD void LPSTR DWORD cch
Definition: str.c:202
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46
HRESULT hres
Definition: protocol.c:465
static TfClientId tid
static LPOLESTR
Definition: stg_prop.c:27
static const WCHAR sysW[]
Definition: richole.c:40
static VARIANTARG static DISPID
Definition: ordinal.c:52
static HWND child
Definition: cursoricon.c:298
#define set_selection(hctl, start, end)
#define min(a, b)
Definition: monoChain.cc:55
int notify
Definition: msacm.c:1366
INT WINAPI MulDiv(INT nNumber, INT nNumerator, INT nDenominator)
Definition: muldiv.c:25
Definition: mk_font.cpp:20
unsigned int UINT
Definition: ndis.h:50
int Count
Definition: noreturn.cpp:7
#define LOCALE_SYSTEM_DEFAULT
interface IStorage * LPSTORAGE
Definition: objfwd.h:30
interface IDataObject * LPDATAOBJECT
Definition: objfwd.h:21
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339
const GUID IID_IOleInPlaceSite
const GUID IID_IOleWindow
const GUID IID_IOleClientSite
const GUID IID_IDataObject
const GUID IID_IDispatch
long LONG
Definition: pedump.c:60
png_const_structrp png_const_inforp int * unit
Definition: png.h:2159
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
_Out_opt_ int * cx
Definition: commctrl.h:585
#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)
Definition: guiddef.h:68
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
#define IID_NULL
Definition: guiddef.h:98
#define REFCLSID
Definition: guiddef.h:117
#define CFM_PROTECTED
Definition: richedit.h:336
#define CFE_SMALLCAPS
Definition: richedit.h:416
#define CFM_STRIKEOUT
Definition: richedit.h:335
#define CFM_SMALLCAPS
Definition: richedit.h:338
#define CFE_STRIKEOUT
Definition: richedit.h:409
#define CFE_OUTLINE
Definition: richedit.h:419
#define CFE_HIDDEN
Definition: richedit.h:418
#define CFE_BOLD
Definition: richedit.h:406
#define CFM_SHADOW
Definition: richedit.h:342
#define CFE_AUTOCOLOR
Definition: richedit.h:414
#define CFM_IMPRINT
Definition: richedit.h:344
#define CFM_OFFSET
Definition: richedit.h:359
#define CFE_ALLCAPS
Definition: richedit.h:417
#define CFM_WEIGHT
Definition: richedit.h:354
#define CFE_ITALIC
Definition: richedit.h:407
#define CFM_OUTLINE
Definition: richedit.h:341
#define CFE_SUPERSCRIPT
Definition: richedit.h:413
#define CFM_SPACING
Definition: richedit.h:353
#define CFM_EMBOSS
Definition: richedit.h:343
#define CFM_SUBSCRIPT
Definition: richedit.h:348
#define CFE_IMPRINT
Definition: richedit.h:422
#define CFM_HIDDEN
Definition: richedit.h:340
#define CFE_UNDERLINE
Definition: richedit.h:408
#define CFM_BACKCOLOR
Definition: richedit.h:357
#define CFE_SUBSCRIPT
Definition: richedit.h:412
#define CFM_KERNING
Definition: richedit.h:352
#define CFM_ITALIC
Definition: richedit.h:333
#define CFE_PROTECTED
Definition: richedit.h:410
#define CFM_LCID
Definition: richedit.h:356
#define CFM_SIZE
Definition: richedit.h:362
#define CFE_EMBOSS
Definition: richedit.h:421
#define CFE_AUTOBACKCOLOR
Definition: richedit.h:425
#define CFM_ANIMATION
Definition: richedit.h:350
#define CFM_BOLD
Definition: richedit.h:332
#define CFM_FACE
Definition: richedit.h:360
#define CFE_SHADOW
Definition: richedit.h:420
#define CFM_UNDERLINE
Definition: richedit.h:334
#define CFM_COLOR
Definition: richedit.h:361
#define CFM_ALLCAPS
Definition: richedit.h:339
#define CFM_SUPERSCRIPT
Definition: richedit.h:349
const WCHAR * str
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
DWORD LCID
Definition: nls.h:13
__WINE_SERVER_LIST_INLINE unsigned int list_count(const struct list *list)
Definition: list.h:155
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
#define memset(x, y, z)
Definition: compat.h:39
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
CardRegion * from
Definition: spigame.cpp:19
struct reole_child child
Definition: richole.c:260
IOleClientSite IOleClientSite_iface
Definition: richole.c:261
IOleInPlaceSite IOleInPlaceSite_iface
Definition: richole.c:262
IRichEditOle IRichEditOle_iface
Definition: richole.c:211
ITextSelectionImpl * txtSel
Definition: richole.c:217
ITextDocument2Old ITextDocument2Old_iface
Definition: richole.c:212
IUnknown IUnknown_inner
Definition: richole.c:210
struct list rangelist
Definition: richole.c:219
struct list clientsites
Definition: richole.c:220
IUnknown * outer_unk
Definition: richole.c:213
ME_TextEditor * editor
Definition: richole.c:216
textfont_prop_val props[FONT_PROPID_LAST]
Definition: richole.c:247
ITextFont ITextFont_iface
Definition: richole.c:243
BOOL set_cache_enabled
Definition: richole.c:249
BOOL get_cache_enabled
Definition: richole.c:248
ITextRange * range
Definition: richole.c:246
ITextPara ITextPara_iface
Definition: richole.c:253
ITextRange * range
Definition: richole.c:256
ITextRange ITextRange_iface
Definition: richole.c:230
struct reole_child child
Definition: richole.c:229
IRichEditOleImpl * reOle
Definition: richole.c:239
ITextSelection ITextSelection_iface
Definition: richole.c:236
long bottom
Definition: polytest.cpp:53
long right
Definition: polytest.cpp:53
long top
Definition: polytest.cpp:53
long left
Definition: polytest.cpp:53
LONG cx
Definition: kdterminal.h:27
LONG cy
Definition: kdterminal.h:28
LONG cpMax
Definition: richedit.h:501
LONG cpMin
Definition: richedit.h:500
LPSTORAGE pstg
Definition: richole.idl:62
LPOLEOBJECT poleobj
Definition: richole.idl:61
LPOLECLIENTSITE polesite
Definition: richole.idl:63
DWORD cbStruct
Definition: richole.idl:58
LONG cp
Definition: richole.idl:59
Definition: http.c:7252
Definition: dsound.c:943
REOBJECT obj
Definition: editstr.h:155
Definition: send.c:48
IRichEditOleImpl * reole
Definition: richole.c:225
struct list entry
Definition: richole.c:224
LONG bmHeight
Definition: wingdi.h:1423
LONG bmWidth
Definition: wingdi.h:1422
BITMAP dsBm
Definition: wingdi.h:1669
RECTL rclBounds
Definition: wingdi.h:2322
struct re_object * reobj
Definition: editstr.h:168
int nFlags
Definition: editstr.h:165
ME_Cursor * pCursors
Definition: editstr.h:387
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
#define max(a, b)
Definition: svc.c:63
@ tomUseTwips
Definition: tom.idl:46
@ tomAutoColor
Definition: tom.idl:32
@ tomApplyNow
Definition: tom.idl:38
@ tomAnimationMax
Definition: tom.idl:162
@ tomEnd
Definition: tom.idl:66
@ tomUnknownStory
Definition: tom.idl:139
@ tomStory
Definition: tom.idl:123
@ tomUsePoints
Definition: tom.idl:45
@ tomDefault
Definition: tom.idl:33
@ tomApplyLater
Definition: tom.idl:39
@ tomStart
Definition: tom.idl:67
@ tomCacheParms
Definition: tom.idl:41
@ tomTrue
Definition: tom.idl:29
@ tomToggle
Definition: tom.idl:31
@ tomFalse
Definition: tom.idl:28
@ tomTrackParms
Definition: tom.idl:40
@ tomUndefined
Definition: tom.idl:30
float FLOAT
Definition: typedefs.h:69
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
Definition: pdh_main.c:94
int ret
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
LONG_PTR LRESULT
Definition: windef.h:209
DWORD COLORREF
Definition: windef.h:300
#define WINAPI
Definition: msvc.h:6
#define S_FALSE
Definition: winerror.h:2357
#define E_NOINTERFACE
Definition: winerror.h:2364
#define STG_E_INVALIDPARAMETER
Definition: winerror.h:2580
#define CO_E_RELEASED
Definition: winerror.h:2818
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
BOOL WINAPI StretchBlt(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_opt_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ DWORD)
#define SRCCOPY
Definition: wingdi.h:333
#define DSTINVERT
Definition: wingdi.h:327
BOOL WINAPI PatBlt(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ DWORD)
#define FW_NORMAL
Definition: wingdi.h:373
UINT WINAPI GetEnhMetaFileHeader(_In_ HENHMETAFILE hemf, _In_ UINT nSize, _Out_writes_bytes_opt_(nSize) LPENHMETAHEADER lpEnhMetaHeader)
BOOL WINAPI DeleteDC(_In_ HDC)
BOOL WINAPI PlayEnhMetaFile(_In_ HDC, _In_ HENHMETAFILE, _In_ LPCRECT)
DWORD WINAPI GetSysColor(_In_ int)
#define COLOR_WINDOW
Definition: winuser.h:918
#define COLOR_WINDOWTEXT
Definition: winuser.h:921
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180