2 * Copyright 2006-2007 Jacek Caban for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
33 #include "wine/debug.h"
34 #include "wine/unicode.h"
36 #include "mshtml_private.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
40 static const WCHAR brW[] = {'b','r',0};
41 static const WCHAR hrW[] = {'h','r',0};
44 const IHTMLTxtRangeVtbl *lpHTMLTxtRangeVtbl;
45 const IOleCommandTargetVtbl *lpOleCommandTargetVtbl;
55 #define HTMLTXTRANGE(x) ((IHTMLTxtRange*) &(x)->lpHTMLTxtRangeVtbl)
79 static HTMLTxtRange *get_range_object(HTMLDocument *doc, IHTMLTxtRange *iface)
83 LIST_FOR_EACH_ENTRY(iter, &doc->range_list, HTMLTxtRange, entry) {
84 if(HTMLTXTRANGE(iter) == iface)
88 ERR("Could not find range in document\n");
92 static range_unit_t string_to_unit(LPCWSTR str)
94 static const WCHAR characterW[] =
95 {'c','h','a','r','a','c','t','e','r',0};
96 static const WCHAR wordW[] =
98 static const WCHAR sentenceW[] =
99 {'s','e','n','t','e','n','c','e',0};
100 static const WCHAR texteditW[] =
101 {'t','e','x','t','e','d','i','t',0};
103 if(!strcmpiW(str, characterW)) return RU_CHAR;
104 if(!strcmpiW(str, wordW)) return RU_WORD;
105 if(!strcmpiW(str, sentenceW)) return RU_SENTENCE;
106 if(!strcmpiW(str, texteditW)) return RU_TEXTEDIT;
111 static int string_to_nscmptype(LPCWSTR str)
113 static const WCHAR seW[] = {'S','t','a','r','t','T','o','E','n','d',0};
114 static const WCHAR ssW[] = {'S','t','a','r','t','T','o','S','t','a','r','t',0};
115 static const WCHAR esW[] = {'E','n','d','T','o','S','t','a','r','t',0};
116 static const WCHAR eeW[] = {'E','n','d','T','o','E','n','d',0};
118 if(!strcmpiW(str, seW)) return NS_START_TO_END;
119 if(!strcmpiW(str, ssW)) return NS_START_TO_START;
120 if(!strcmpiW(str, esW)) return NS_END_TO_START;
121 if(!strcmpiW(str, eeW)) return NS_END_TO_END;
126 static PRUint16 get_node_type(nsIDOMNode *node)
131 nsIDOMNode_GetNodeType(node, &type);
136 static BOOL is_elem_tag(nsIDOMNode *node, LPCWSTR istag)
140 const PRUnichar *tag;
144 nsres = nsIDOMNode_QueryInterface(node, &IID_nsIDOMElement, (void**)&elem);
148 nsAString_Init(&tag_str, NULL);
149 nsIDOMElement_GetTagName(elem, &tag_str);
150 nsIDOMElement_Release(elem);
151 nsAString_GetData(&tag_str, &tag);
153 ret = !strcmpiW(tag, istag);
155 nsAString_Finish(&tag_str);
160 static BOOL is_space_elem(nsIDOMNode *node)
164 const PRUnichar *tag;
168 nsres = nsIDOMNode_QueryInterface(node, &IID_nsIDOMElement, (void**)&elem);
172 nsAString_Init(&tag_str, NULL);
173 nsIDOMElement_GetTagName(elem, &tag_str);
174 nsIDOMElement_Release(elem);
175 nsAString_GetData(&tag_str, &tag);
177 ret = !strcmpiW(tag, brW) || !strcmpiW(tag, hrW);
179 nsAString_Finish(&tag_str);
184 static inline void wstrbuf_init(wstrbuf_t *buf)
188 buf->buf = heap_alloc(buf->size * sizeof(WCHAR));
192 static inline void wstrbuf_finish(wstrbuf_t *buf)
197 static void wstrbuf_append_len(wstrbuf_t *buf, LPCWSTR str, int len)
199 if(buf->len+len >= buf->size) {
200 buf->size = 2*buf->len+len;
201 buf->buf = heap_realloc(buf->buf, buf->size * sizeof(WCHAR));
204 memcpy(buf->buf+buf->len, str, len*sizeof(WCHAR));
206 buf->buf[buf->len] = 0;
209 static inline void wstrbuf_append(wstrbuf_t *buf, LPCWSTR str)
211 wstrbuf_append_len(buf, str, strlenW(str));
214 static void wstrbuf_append_nodetxt(wstrbuf_t *buf, LPCWSTR str, int len)
216 const WCHAR *s = str;
219 TRACE("%s\n", debugstr_wn(str, len));
221 if(buf->len+len >= buf->size) {
222 buf->size = 2*buf->len+len;
223 buf->buf = heap_realloc(buf->buf, buf->size * sizeof(WCHAR));
226 if(buf->len && isspaceW(buf->buf[buf->len-1])) {
227 while(s < str+len && isspaceW(*s))
231 d = buf->buf+buf->len;
236 while(s < str+len && isspaceW(*s))
243 buf->len = d - buf->buf;
247 static void wstrbuf_append_node(wstrbuf_t *buf, nsIDOMNode *node)
250 switch(get_node_type(node)) {
254 const PRUnichar *data;
256 nsIDOMNode_QueryInterface(node, &IID_nsIDOMText, (void**)&nstext);
258 nsAString_Init(&data_str, NULL);
259 nsIDOMText_GetData(nstext, &data_str);
260 nsAString_GetData(&data_str, &data);
261 wstrbuf_append_nodetxt(buf, data, strlenW(data));
262 nsAString_Finish(&data_str);
264 nsIDOMText_Release(nstext);
269 if(is_elem_tag(node, brW)) {
270 static const WCHAR endlW[] = {'\r','\n'};
271 wstrbuf_append_len(buf, endlW, 2);
272 }else if(is_elem_tag(node, hrW)) {
273 static const WCHAR endl2W[] = {'\r','\n','\r','\n'};
274 wstrbuf_append_len(buf, endl2W, 4);
279 static BOOL fill_nodestr(dompos_t *pos)
284 if(pos->type != TEXT_NODE)
287 nsres = nsIDOMNode_QueryInterface(pos->node, &IID_nsIDOMText, (void**)&text);
291 nsAString_Init(&pos->str, NULL);
292 nsIDOMText_GetData(text, &pos->str);
293 nsIDOMText_Release(text);
294 nsAString_GetData(&pos->str, &pos->p);
297 pos->off = *pos->p ? strlenW(pos->p)-1 : 0;
302 static nsIDOMNode *next_node(nsIDOMNode *iter)
304 nsIDOMNode *ret, *tmp;
310 nsres = nsIDOMNode_GetFirstChild(iter, &ret);
311 if(NS_SUCCEEDED(nsres) && ret)
314 nsIDOMNode_AddRef(iter);
317 nsres = nsIDOMNode_GetNextSibling(iter, &ret);
318 if(NS_SUCCEEDED(nsres) && ret) {
319 nsIDOMNode_Release(iter);
323 nsres = nsIDOMNode_GetParentNode(iter, &tmp);
324 nsIDOMNode_Release(iter);
326 }while(NS_SUCCEEDED(nsres) && iter);
331 static nsIDOMNode *prev_node(HTMLTxtRange *This, nsIDOMNode *iter)
333 nsIDOMNode *ret, *tmp;
337 nsIDOMHTMLDocument *nshtmldoc;
338 nsIDOMHTMLElement *nselem;
339 nsIDOMDocument *nsdoc;
341 nsIWebNavigation_GetDocument(This->doc->nscontainer->navigation, &nsdoc);
342 nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
343 nsIDOMDocument_Release(nsdoc);
344 nsIDOMHTMLDocument_GetBody(nshtmldoc, &nselem);
345 nsIDOMHTMLDocument_Release(nshtmldoc);
347 nsIDOMElement_GetLastChild(nselem, &tmp);
349 return (nsIDOMNode*)nselem;
353 nsIDOMNode_GetLastChild(ret, &tmp);
356 nsIDOMElement_Release(nselem);
361 nsres = nsIDOMNode_GetLastChild(iter, &ret);
362 if(NS_SUCCEEDED(nsres) && ret)
365 nsIDOMNode_AddRef(iter);
368 nsres = nsIDOMNode_GetPreviousSibling(iter, &ret);
369 if(NS_SUCCEEDED(nsres) && ret) {
370 nsIDOMNode_Release(iter);
374 nsres = nsIDOMNode_GetParentNode(iter, &tmp);
375 nsIDOMNode_Release(iter);
377 }while(NS_SUCCEEDED(nsres) && iter);
382 static nsIDOMNode *get_child_node(nsIDOMNode *node, PRUint32 off)
384 nsIDOMNodeList *node_list;
385 nsIDOMNode *ret = NULL;
387 nsIDOMNode_GetChildNodes(node, &node_list);
388 nsIDOMNodeList_Item(node_list, off, &ret);
389 nsIDOMNodeList_Release(node_list);
394 static void get_cur_pos(HTMLTxtRange *This, BOOL start, dompos_t *pos)
403 nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
408 nsIDOMRange_GetStartContainer(This->nsrange, &node);
409 nsIDOMRange_GetStartOffset(This->nsrange, &off);
411 nsIDOMRange_GetEndContainer(This->nsrange, &node);
412 nsIDOMRange_GetEndOffset(This->nsrange, &off);
415 pos->type = get_node_type(node);
416 if(pos->type == ELEMENT_NODE) {
418 pos->node = get_child_node(node, off);
421 pos->node = off ? get_child_node(node, off-1) : prev_node(This, node);
425 pos->type = get_node_type(pos->node);
426 nsIDOMNode_Release(node);
434 pos->node = prev_node(This, node);
436 nsIDOMNode_Release(node);
439 if(pos->type == TEXT_NODE)
443 static void set_range_pos(HTMLTxtRange *This, BOOL start, dompos_t *pos)
448 if(pos->type == TEXT_NODE)
449 nsres = nsIDOMRange_SetStart(This->nsrange, pos->node, pos->off);
451 nsres = nsIDOMRange_SetStartBefore(This->nsrange, pos->node);
453 if(pos->type == TEXT_NODE && pos->p[pos->off+1])
454 nsres = nsIDOMRange_SetEnd(This->nsrange, pos->node, pos->off+1);
456 nsres = nsIDOMRange_SetEndAfter(This->nsrange, pos->node);
460 ERR("failed: %p %08x\n", pos->node, nsres);
463 static inline void dompos_release(dompos_t *pos)
466 nsIDOMNode_Release(pos->node);
469 nsAString_Finish(&pos->str);
472 static inline void dompos_addref(dompos_t *pos)
475 nsIDOMNode_AddRef(pos->node);
477 if(pos->type == TEXT_NODE)
481 static inline BOOL dompos_cmp(const dompos_t *pos1, const dompos_t *pos2)
483 return pos1->node == pos2->node && pos1->off == pos2->off;
486 static void range_to_string(HTMLTxtRange *This, wstrbuf_t *buf)
488 nsIDOMNode *iter, *tmp;
489 dompos_t start_pos, end_pos;
492 nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
500 get_cur_pos(This, FALSE, &end_pos);
501 get_cur_pos(This, TRUE, &start_pos);
503 if(start_pos.type == TEXT_NODE) {
504 if(start_pos.node == end_pos.node) {
505 wstrbuf_append_nodetxt(buf, start_pos.p+start_pos.off, end_pos.off-start_pos.off+1);
506 iter = start_pos.node;
507 nsIDOMNode_AddRef(iter);
509 wstrbuf_append_nodetxt(buf, start_pos.p+start_pos.off, strlenW(start_pos.p+start_pos.off));
510 iter = next_node(start_pos.node);
513 iter = start_pos.node;
514 nsIDOMNode_AddRef(iter);
517 while(iter != end_pos.node) {
518 wstrbuf_append_node(buf, iter);
519 tmp = next_node(iter);
520 nsIDOMNode_Release(iter);
524 nsIDOMNode_AddRef(end_pos.node);
526 if(start_pos.node != end_pos.node) {
527 if(end_pos.type == TEXT_NODE)
528 wstrbuf_append_nodetxt(buf, end_pos.p, end_pos.off+1);
530 wstrbuf_append_node(buf, end_pos.node);
533 nsIDOMNode_Release(iter);
534 dompos_release(&start_pos);
535 dompos_release(&end_pos);
540 for(p = buf->buf+buf->len-1; p >= buf->buf && isspaceW(*p); p--);
542 p = strchrW(p, '\r');
548 static WCHAR get_pos_char(const dompos_t *pos)
552 return pos->p[pos->off];
554 if(is_space_elem(pos->node))
561 static void end_space(const dompos_t *pos, dompos_t *new_pos)
566 dompos_addref(new_pos);
568 if(pos->type != TEXT_NODE)
571 p = new_pos->p+new_pos->off;
573 if(!*p || !isspace(*p))
576 while(p[1] && isspace(p[1]))
579 new_pos->off = p - new_pos->p;
582 static WCHAR next_char(const dompos_t *pos, dompos_t *new_pos)
584 nsIDOMNode *iter, *tmp;
585 dompos_t last_space, tmp_pos;
589 if(pos->type == TEXT_NODE && pos->off != -1 && pos->p[pos->off]) {
593 while(isspaceW(*++p));
597 if(*p && isspaceW(*p)) {
599 while(p[1] && isspaceW(p[1]))
605 new_pos->off = p - pos->p;
606 dompos_addref(new_pos);
608 return cspace ? cspace : *p;
611 last_space.off = p - pos->p;
612 dompos_addref(&last_space);
616 iter = next_node(pos->node);
619 switch(get_node_type(iter)) {
622 tmp_pos.type = TEXT_NODE;
623 dompos_addref(&tmp_pos);
628 dompos_release(&tmp_pos);
630 }else if(isspaceW(*p)) {
632 dompos_release(&last_space);
636 while(p[1] && isspaceW(p[1]))
639 tmp_pos.off = p-tmp_pos.p;
642 last_space = tmp_pos;
647 nsIDOMNode_Release(iter);
650 *new_pos = last_space;
651 dompos_release(&tmp_pos);
652 nsIDOMNode_Release(iter);
660 nsIDOMNode_Release(iter);
664 if(is_elem_tag(iter, brW)) {
666 dompos_release(&last_space);
669 nsIDOMNode_AddRef(iter);
670 last_space.node = iter;
671 last_space.type = ELEMENT_NODE;
674 }else if(is_elem_tag(iter, hrW)) {
676 *new_pos = last_space;
677 nsIDOMNode_Release(iter);
681 new_pos->node = iter;
682 new_pos->type = ELEMENT_NODE;
690 iter = next_node(iter);
691 nsIDOMNode_Release(tmp);
695 *new_pos = last_space;
698 dompos_addref(new_pos);
704 static WCHAR prev_char(HTMLTxtRange *This, const dompos_t *pos, dompos_t *new_pos)
706 nsIDOMNode *iter, *tmp;
708 BOOL skip_space = FALSE;
710 if(pos->type == TEXT_NODE && isspaceW(pos->p[pos->off]))
713 if(pos->type == TEXT_NODE && pos->off) {
714 p = pos->p+pos->off-1;
717 while(p >= pos->p && isspace(*p))
723 new_pos->off = p-pos->p;
724 dompos_addref(new_pos);
725 return new_pos->p[new_pos->off];
729 iter = prev_node(This, pos->node);
732 switch(get_node_type(iter)) {
737 tmp_pos.type = TEXT_NODE;
738 dompos_addref(&tmp_pos);
740 p = tmp_pos.p + strlenW(tmp_pos.p)-1;
743 while(p >= tmp_pos.p && isspaceW(*p))
748 dompos_release(&tmp_pos);
752 tmp_pos.off = p-tmp_pos.p;
754 nsIDOMNode_Release(iter);
759 if(is_elem_tag(iter, brW)) {
764 }else if(!is_elem_tag(iter, hrW)) {
768 new_pos->node = iter;
769 new_pos->type = ELEMENT_NODE;
776 iter = prev_node(This, iter);
777 nsIDOMNode_Release(tmp);
781 dompos_addref(new_pos);
785 static long move_next_chars(long cnt, const dompos_t *pos, BOOL col, const dompos_t *bound_pos,
786 BOOL *bounded, dompos_t *new_pos)
799 end_space(pos, new_pos);
803 c = next_char(pos, &iter);
808 c = next_char(&tmp, &iter);
809 dompos_release(&tmp);
814 if(bound_pos && dompos_cmp(&tmp, bound_pos)) {
824 static long move_prev_chars(HTMLTxtRange *This, long cnt, const dompos_t *pos, BOOL end,
825 const dompos_t *bound_pos, BOOL *bounded, dompos_t *new_pos)
829 BOOL prev_eq = FALSE;
835 c = prev_char(This, pos, &iter);
839 while(c && ret < cnt) {
841 c = prev_char(This, &tmp, &iter);
842 dompos_release(&tmp);
856 prev_eq = bound_pos && dompos_cmp(&iter, bound_pos);
863 static long find_prev_space(HTMLTxtRange *This, const dompos_t *pos, BOOL first_space, dompos_t *ret)
868 c = prev_char(This, pos, &iter);
869 if(!c || (first_space && isspaceW(c))) {
876 c = prev_char(This, &tmp, &iter);
877 if(!c || isspaceW(c)) {
878 dompos_release(&iter);
881 dompos_release(&tmp);
888 static int find_word_end(const dompos_t *pos, dompos_t *ret)
893 c = get_pos_char(pos);
900 c = next_char(pos, &iter);
911 while(c && !isspaceW(c)) {
913 c = next_char(&tmp, &iter);
915 dompos_release(&iter);
919 dompos_release(&tmp);
927 static long move_next_words(long cnt, const dompos_t *pos, dompos_t *new_pos)
933 c = get_pos_char(pos);
935 end_space(pos, &iter);
938 c = next_char(pos, &iter);
943 while(c && ret < cnt) {
945 c = next_char(&tmp, &iter);
946 dompos_release(&tmp);
955 static long move_prev_words(HTMLTxtRange *This, long cnt, const dompos_t *pos, dompos_t *new_pos)
961 dompos_addref(&iter);
964 if(!find_prev_space(This, &iter, FALSE, &tmp))
967 dompos_release(&iter);
976 #define HTMLTXTRANGE_THIS(iface) DEFINE_THIS(HTMLTxtRange, HTMLTxtRange, iface)
978 static HRESULT WINAPI HTMLTxtRange_QueryInterface(IHTMLTxtRange *iface, REFIID riid, void **ppv)
980 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
984 if(IsEqualGUID(&IID_IUnknown, riid)) {
985 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
986 *ppv = HTMLTXTRANGE(This);
987 }else if(IsEqualGUID(&IID_IDispatch, riid)) {
988 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
989 *ppv = HTMLTXTRANGE(This);
990 }else if(IsEqualGUID(&IID_IHTMLTxtRange, riid)) {
991 TRACE("(%p)->(IID_IHTMLTxtRange %p)\n", This, ppv);
992 *ppv = HTMLTXTRANGE(This);
993 }else if(IsEqualGUID(&IID_IOleCommandTarget, riid)) {
994 TRACE("(%p)->(IID_IOleCommandTarget %p)\n", This, ppv);
995 *ppv = CMDTARGET(This);
999 IUnknown_AddRef((IUnknown*)*ppv);
1003 WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1004 return E_NOINTERFACE;
1007 static ULONG WINAPI HTMLTxtRange_AddRef(IHTMLTxtRange *iface)
1009 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1010 LONG ref = InterlockedIncrement(&This->ref);
1012 TRACE("(%p) ref=%d\n", This, ref);
1017 static ULONG WINAPI HTMLTxtRange_Release(IHTMLTxtRange *iface)
1019 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1020 LONG ref = InterlockedDecrement(&This->ref);
1022 TRACE("(%p) ref=%d\n", This, ref);
1026 nsISelection_Release(This->nsrange);
1028 list_remove(&This->entry);
1035 static HRESULT WINAPI HTMLTxtRange_GetTypeInfoCount(IHTMLTxtRange *iface, UINT *pctinfo)
1037 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1038 FIXME("(%p)->(%p)\n", This, pctinfo);
1042 static HRESULT WINAPI HTMLTxtRange_GetTypeInfo(IHTMLTxtRange *iface, UINT iTInfo,
1043 LCID lcid, ITypeInfo **ppTInfo)
1045 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1046 FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1050 static HRESULT WINAPI HTMLTxtRange_GetIDsOfNames(IHTMLTxtRange *iface, REFIID riid,
1051 LPOLESTR *rgszNames, UINT cNames,
1052 LCID lcid, DISPID *rgDispId)
1054 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1055 FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1060 static HRESULT WINAPI HTMLTxtRange_Invoke(IHTMLTxtRange *iface, DISPID dispIdMember,
1061 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1062 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1064 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1065 FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1066 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1070 static HRESULT WINAPI HTMLTxtRange_get_htmlText(IHTMLTxtRange *iface, BSTR *p)
1072 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1074 TRACE("(%p)->(%p)\n", This, p);
1079 nsIDOMDocumentFragment *fragment;
1082 nsres = nsIDOMRange_CloneContents(This->nsrange, &fragment);
1083 if(NS_SUCCEEDED(nsres)) {
1084 const PRUnichar *nstext;
1087 nsAString_Init(&nsstr, NULL);
1088 nsnode_to_nsstring((nsIDOMNode*)fragment, &nsstr);
1089 nsIDOMDocumentFragment_Release(fragment);
1091 nsAString_GetData(&nsstr, &nstext);
1092 *p = SysAllocString(nstext);
1094 nsAString_Finish(&nsstr);
1099 const WCHAR emptyW[] = {0};
1100 *p = SysAllocString(emptyW);
1103 TRACE("return %s\n", debugstr_w(*p));
1107 static HRESULT WINAPI HTMLTxtRange_put_text(IHTMLTxtRange *iface, BSTR v)
1109 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1110 nsIDOMDocument *nsdoc;
1111 nsIDOMText *text_node;
1115 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1118 return MSHTML_E_NODOC;
1120 nsres = nsIWebNavigation_GetDocument(This->doc->nscontainer->navigation, &nsdoc);
1121 if(NS_FAILED(nsres)) {
1122 ERR("GetDocument failed: %08x\n", nsres);
1126 nsAString_Init(&text_str, v);
1127 nsres = nsIDOMDocument_CreateTextNode(nsdoc, &text_str, &text_node);
1128 nsIDOMDocument_Release(nsdoc);
1129 nsAString_Finish(&text_str);
1130 if(NS_FAILED(nsres)) {
1131 ERR("CreateTextNode failed: %08x\n", nsres);
1134 nsres = nsIDOMRange_DeleteContents(This->nsrange);
1135 if(NS_FAILED(nsres))
1136 ERR("DeleteContents failed: %08x\n", nsres);
1138 nsres = nsIDOMRange_InsertNode(This->nsrange, (nsIDOMNode*)text_node);
1139 if(NS_FAILED(nsres))
1140 ERR("InsertNode failed: %08x\n", nsres);
1142 nsres = nsIDOMRange_SetEndAfter(This->nsrange, (nsIDOMNode*)text_node);
1143 if(NS_FAILED(nsres))
1144 ERR("SetEndAfter failed: %08x\n", nsres);
1146 return IHTMLTxtRange_collapse(HTMLTXTRANGE(This), VARIANT_FALSE);
1149 static HRESULT WINAPI HTMLTxtRange_get_text(IHTMLTxtRange *iface, BSTR *p)
1151 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1154 TRACE("(%p)->(%p)\n", This, p);
1161 range_to_string(This, &buf);
1163 *p = SysAllocString(buf.buf);
1164 wstrbuf_finish(&buf);
1166 TRACE("ret %s\n", debugstr_w(*p));
1170 static HRESULT WINAPI HTMLTxtRange_parentElement(IHTMLTxtRange *iface, IHTMLElement **parent)
1172 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1173 nsIDOMNode *nsnode, *tmp;
1176 TRACE("(%p)->(%p)\n", This, parent);
1178 nsIDOMRange_GetCommonAncestorContainer(This->nsrange, &nsnode);
1179 while(nsnode && get_node_type(nsnode) != ELEMENT_NODE) {
1180 nsIDOMNode_GetParentNode(nsnode, &tmp);
1181 nsIDOMNode_Release(nsnode);
1190 node = get_node(This->doc, nsnode);
1191 nsIDOMNode_Release(nsnode);
1193 return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(node), &IID_IHTMLElement, (void**)parent);
1196 static HRESULT WINAPI HTMLTxtRange_duplicate(IHTMLTxtRange *iface, IHTMLTxtRange **Duplicate)
1198 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1199 nsIDOMRange *nsrange = NULL;
1201 TRACE("(%p)->(%p)\n", This, Duplicate);
1203 nsIDOMRange_CloneRange(This->nsrange, &nsrange);
1204 *Duplicate = HTMLTxtRange_Create(This->doc, nsrange);
1205 nsIDOMRange_Release(nsrange);
1210 static HRESULT WINAPI HTMLTxtRange_inRange(IHTMLTxtRange *iface, IHTMLTxtRange *Range,
1211 VARIANT_BOOL *InRange)
1213 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1214 HTMLTxtRange *src_range;
1218 TRACE("(%p)->(%p %p)\n", This, Range, InRange);
1220 *InRange = VARIANT_FALSE;
1222 src_range = get_range_object(This->doc, Range);
1226 nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_START_TO_START,
1227 src_range->nsrange, &nsret);
1228 if(NS_SUCCEEDED(nsres) && nsret <= 0) {
1229 nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_END_TO_END,
1230 src_range->nsrange, &nsret);
1231 if(NS_SUCCEEDED(nsres) && nsret >= 0)
1232 *InRange = VARIANT_TRUE;
1235 if(NS_FAILED(nsres))
1236 ERR("CompareBoundaryPoints failed: %08x\n", nsres);
1241 static HRESULT WINAPI HTMLTxtRange_isEqual(IHTMLTxtRange *iface, IHTMLTxtRange *Range,
1242 VARIANT_BOOL *IsEqual)
1244 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1245 HTMLTxtRange *src_range;
1249 TRACE("(%p)->(%p %p)\n", This, Range, IsEqual);
1251 *IsEqual = VARIANT_FALSE;
1253 src_range = get_range_object(This->doc, Range);
1257 nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_START_TO_START,
1258 src_range->nsrange, &nsret);
1259 if(NS_SUCCEEDED(nsres) && !nsret) {
1260 nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_END_TO_END,
1261 src_range->nsrange, &nsret);
1262 if(NS_SUCCEEDED(nsres) && !nsret)
1263 *IsEqual = VARIANT_TRUE;
1266 if(NS_FAILED(nsres))
1267 ERR("CompareBoundaryPoints failed: %08x\n", nsres);
1272 static HRESULT WINAPI HTMLTxtRange_scrollIntoView(IHTMLTxtRange *iface, VARIANT_BOOL fStart)
1274 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1275 FIXME("(%p)->(%x)\n", This, fStart);
1279 static HRESULT WINAPI HTMLTxtRange_collapse(IHTMLTxtRange *iface, VARIANT_BOOL Start)
1281 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1283 TRACE("(%p)->(%x)\n", This, Start);
1285 nsIDOMRange_Collapse(This->nsrange, Start != VARIANT_FALSE);
1289 static HRESULT WINAPI HTMLTxtRange_expand(IHTMLTxtRange *iface, BSTR Unit, VARIANT_BOOL *Success)
1291 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1294 TRACE("(%p)->(%s %p)\n", This, debugstr_w(Unit), Success);
1296 unit = string_to_unit(Unit);
1297 if(unit == RU_UNKNOWN)
1298 return E_INVALIDARG;
1300 *Success = VARIANT_FALSE;
1304 dompos_t end_pos, start_pos, new_start_pos, new_end_pos;
1307 nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
1309 get_cur_pos(This, TRUE, &start_pos);
1310 get_cur_pos(This, FALSE, &end_pos);
1312 if(find_word_end(&end_pos, &new_end_pos) || collapsed) {
1313 set_range_pos(This, FALSE, &new_end_pos);
1314 *Success = VARIANT_TRUE;
1317 if(start_pos.type && (get_pos_char(&end_pos) || !dompos_cmp(&new_end_pos, &end_pos))) {
1318 if(find_prev_space(This, &start_pos, TRUE, &new_start_pos)) {
1319 set_range_pos(This, TRUE, &new_start_pos);
1320 *Success = VARIANT_TRUE;
1322 dompos_release(&new_start_pos);
1325 dompos_release(&new_end_pos);
1326 dompos_release(&end_pos);
1327 dompos_release(&start_pos);
1333 nsIDOMDocument *nsdoc;
1334 nsIDOMHTMLDocument *nshtmldoc;
1335 nsIDOMHTMLElement *nsbody = NULL;
1338 nsres = nsIWebNavigation_GetDocument(This->doc->nscontainer->navigation, &nsdoc);
1339 if(NS_FAILED(nsres) || !nsdoc) {
1340 ERR("GetDocument failed: %08x\n", nsres);
1344 nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
1345 nsIDOMDocument_Release(nsdoc);
1347 nsres = nsIDOMHTMLDocument_GetBody(nshtmldoc, &nsbody);
1348 nsIDOMHTMLDocument_Release(nshtmldoc);
1349 if(NS_FAILED(nsres) || !nsbody) {
1350 ERR("Could not get body: %08x\n", nsres);
1354 nsres = nsIDOMRange_SelectNodeContents(This->nsrange, (nsIDOMNode*)nsbody);
1355 nsIDOMHTMLElement_Release(nsbody);
1356 if(NS_FAILED(nsres)) {
1357 ERR("Collapse failed: %08x\n", nsres);
1361 *Success = VARIANT_TRUE;
1366 FIXME("Unimplemented unit %s\n", debugstr_w(Unit));
1372 static HRESULT WINAPI HTMLTxtRange_move(IHTMLTxtRange *iface, BSTR Unit,
1373 long Count, long *ActualCount)
1375 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1378 TRACE("(%p)->(%s %ld %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1380 unit = string_to_unit(Unit);
1381 if(unit == RU_UNKNOWN)
1382 return E_INVALIDARG;
1386 return IHTMLTxtRange_collapse(HTMLTXTRANGE(This), TRUE);
1391 dompos_t cur_pos, new_pos;
1393 get_cur_pos(This, TRUE, &cur_pos);
1396 *ActualCount = move_next_chars(Count, &cur_pos, TRUE, NULL, NULL, &new_pos);
1397 set_range_pos(This, FALSE, &new_pos);
1398 dompos_release(&new_pos);
1400 IHTMLTxtRange_collapse(HTMLTXTRANGE(This), FALSE);
1402 *ActualCount = -move_prev_chars(This, -Count, &cur_pos, FALSE, NULL, NULL, &new_pos);
1403 set_range_pos(This, TRUE, &new_pos);
1404 IHTMLTxtRange_collapse(HTMLTXTRANGE(This), TRUE);
1405 dompos_release(&new_pos);
1408 dompos_release(&cur_pos);
1413 dompos_t cur_pos, new_pos;
1415 get_cur_pos(This, TRUE, &cur_pos);
1418 *ActualCount = move_next_words(Count, &cur_pos, &new_pos);
1419 set_range_pos(This, FALSE, &new_pos);
1420 dompos_release(&new_pos);
1421 IHTMLTxtRange_collapse(HTMLTXTRANGE(This), FALSE);
1423 *ActualCount = -move_prev_words(This, -Count, &cur_pos, &new_pos);
1424 set_range_pos(This, TRUE, &new_pos);
1425 IHTMLTxtRange_collapse(HTMLTXTRANGE(This), TRUE);
1426 dompos_release(&new_pos);
1429 dompos_release(&cur_pos);
1434 FIXME("unimplemented unit %s\n", debugstr_w(Unit));
1437 TRACE("ret %ld\n", *ActualCount);
1441 static HRESULT WINAPI HTMLTxtRange_moveStart(IHTMLTxtRange *iface, BSTR Unit,
1442 long Count, long *ActualCount)
1444 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1447 TRACE("(%p)->(%s %ld %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1449 unit = string_to_unit(Unit);
1450 if(unit == RU_UNKNOWN)
1451 return E_INVALIDARG;
1460 dompos_t start_pos, end_pos, new_pos;
1463 get_cur_pos(This, TRUE, &start_pos);
1464 get_cur_pos(This, FALSE, &end_pos);
1465 nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
1470 *ActualCount = move_next_chars(Count, &start_pos, collapsed, &end_pos, &bounded, &new_pos);
1471 set_range_pos(This, !bounded, &new_pos);
1473 IHTMLTxtRange_collapse(HTMLTXTRANGE(This), FALSE);
1475 *ActualCount = -move_prev_chars(This, -Count, &start_pos, FALSE, NULL, NULL, &new_pos);
1476 set_range_pos(This, TRUE, &new_pos);
1479 dompos_release(&start_pos);
1480 dompos_release(&end_pos);
1481 dompos_release(&new_pos);
1486 FIXME("unimplemented unit %s\n", debugstr_w(Unit));
1492 static HRESULT WINAPI HTMLTxtRange_moveEnd(IHTMLTxtRange *iface, BSTR Unit,
1493 long Count, long *ActualCount)
1495 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1498 TRACE("(%p)->(%s %ld %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1500 unit = string_to_unit(Unit);
1501 if(unit == RU_UNKNOWN)
1502 return E_INVALIDARG;
1511 dompos_t start_pos, end_pos, new_pos;
1514 get_cur_pos(This, TRUE, &start_pos);
1515 get_cur_pos(This, FALSE, &end_pos);
1516 nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
1519 *ActualCount = move_next_chars(Count, &end_pos, collapsed, NULL, NULL, &new_pos);
1520 set_range_pos(This, FALSE, &new_pos);
1524 *ActualCount = -move_prev_chars(This, -Count, &end_pos, TRUE, &start_pos, &bounded, &new_pos);
1525 set_range_pos(This, bounded, &new_pos);
1527 IHTMLTxtRange_collapse(HTMLTXTRANGE(This), TRUE);
1530 dompos_release(&start_pos);
1531 dompos_release(&end_pos);
1532 dompos_release(&new_pos);
1537 FIXME("unimplemented unit %s\n", debugstr_w(Unit));
1543 static HRESULT WINAPI HTMLTxtRange_select(IHTMLTxtRange *iface)
1545 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1547 TRACE("(%p)\n", This);
1549 if(This->doc->nscontainer) {
1550 nsIDOMWindow *dom_window = NULL;
1551 nsISelection *nsselection;
1553 nsIWebBrowser_GetContentDOMWindow(This->doc->nscontainer->webbrowser, &dom_window);
1554 nsIDOMWindow_GetSelection(dom_window, &nsselection);
1555 nsIDOMWindow_Release(dom_window);
1557 nsISelection_RemoveAllRanges(nsselection);
1558 nsISelection_AddRange(nsselection, This->nsrange);
1560 nsISelection_Release(nsselection);
1566 static HRESULT WINAPI HTMLTxtRange_pasteHTML(IHTMLTxtRange *iface, BSTR html)
1568 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1569 FIXME("(%p)->(%s)\n", This, debugstr_w(html));
1573 static HRESULT WINAPI HTMLTxtRange_moveToElementText(IHTMLTxtRange *iface, IHTMLElement *element)
1575 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1576 FIXME("(%p)->(%p)\n", This, element);
1580 static HRESULT WINAPI HTMLTxtRange_setEndPoint(IHTMLTxtRange *iface, BSTR how,
1581 IHTMLTxtRange *SourceRange)
1583 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1584 FIXME("(%p)->(%s %p)\n", This, debugstr_w(how), SourceRange);
1588 static HRESULT WINAPI HTMLTxtRange_compareEndPoints(IHTMLTxtRange *iface, BSTR how,
1589 IHTMLTxtRange *SourceRange, long *ret)
1591 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1592 HTMLTxtRange *src_range;
1597 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(how), SourceRange, ret);
1599 nscmpt = string_to_nscmptype(how);
1601 return E_INVALIDARG;
1603 src_range = get_range_object(This->doc, SourceRange);
1607 nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, nscmpt, src_range->nsrange, &nsret);
1608 if(NS_FAILED(nsres))
1609 ERR("CompareBoundaryPoints failed: %08x\n", nsres);
1615 static HRESULT WINAPI HTMLTxtRange_findText(IHTMLTxtRange *iface, BSTR String,
1616 long count, long Flags, VARIANT_BOOL *Success)
1618 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1619 FIXME("(%p)->(%s %ld %08lx %p)\n", This, debugstr_w(String), count, Flags, Success);
1623 static HRESULT WINAPI HTMLTxtRange_moveToPoint(IHTMLTxtRange *iface, long x, long y)
1625 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1626 FIXME("(%p)->(%ld %ld)\n", This, x, y);
1630 static HRESULT WINAPI HTMLTxtRange_getBookmark(IHTMLTxtRange *iface, BSTR *Bookmark)
1632 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1633 FIXME("(%p)->(%p)\n", This, Bookmark);
1637 static HRESULT WINAPI HTMLTxtRange_moveToBookmark(IHTMLTxtRange *iface, BSTR Bookmark,
1638 VARIANT_BOOL *Success)
1640 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1641 FIXME("(%p)->(%s %p)\n", This, debugstr_w(Bookmark), Success);
1645 static HRESULT WINAPI HTMLTxtRange_queryCommandSupported(IHTMLTxtRange *iface, BSTR cmdID,
1646 VARIANT_BOOL *pfRet)
1648 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1649 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1653 static HRESULT WINAPI HTMLTxtRange_queryCommandEnabled(IHTMLTxtRange *iface, BSTR cmdID,
1654 VARIANT_BOOL *pfRet)
1656 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1657 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1661 static HRESULT WINAPI HTMLTxtRange_queryCommandState(IHTMLTxtRange *iface, BSTR cmdID,
1662 VARIANT_BOOL *pfRet)
1664 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1665 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1669 static HRESULT WINAPI HTMLTxtRange_queryCommandIndeterm(IHTMLTxtRange *iface, BSTR cmdID,
1670 VARIANT_BOOL *pfRet)
1672 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1673 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1677 static HRESULT WINAPI HTMLTxtRange_queryCommandText(IHTMLTxtRange *iface, BSTR cmdID,
1680 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1681 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pcmdText);
1685 static HRESULT WINAPI HTMLTxtRange_queryCommandValue(IHTMLTxtRange *iface, BSTR cmdID,
1688 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1689 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pcmdValue);
1693 static HRESULT WINAPI HTMLTxtRange_execCommand(IHTMLTxtRange *iface, BSTR cmdID,
1694 VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
1696 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1697 FIXME("(%p)->(%s %x v %p)\n", This, debugstr_w(cmdID), showUI, pfRet);
1701 static HRESULT WINAPI HTMLTxtRange_execCommandShowHelp(IHTMLTxtRange *iface, BSTR cmdID,
1702 VARIANT_BOOL *pfRet)
1704 HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1705 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1709 #undef HTMLTXTRANGE_THIS
1711 static const IHTMLTxtRangeVtbl HTMLTxtRangeVtbl = {
1712 HTMLTxtRange_QueryInterface,
1713 HTMLTxtRange_AddRef,
1714 HTMLTxtRange_Release,
1715 HTMLTxtRange_GetTypeInfoCount,
1716 HTMLTxtRange_GetTypeInfo,
1717 HTMLTxtRange_GetIDsOfNames,
1718 HTMLTxtRange_Invoke,
1719 HTMLTxtRange_get_htmlText,
1720 HTMLTxtRange_put_text,
1721 HTMLTxtRange_get_text,
1722 HTMLTxtRange_parentElement,
1723 HTMLTxtRange_duplicate,
1724 HTMLTxtRange_inRange,
1725 HTMLTxtRange_isEqual,
1726 HTMLTxtRange_scrollIntoView,
1727 HTMLTxtRange_collapse,
1728 HTMLTxtRange_expand,
1730 HTMLTxtRange_moveStart,
1731 HTMLTxtRange_moveEnd,
1732 HTMLTxtRange_select,
1733 HTMLTxtRange_pasteHTML,
1734 HTMLTxtRange_moveToElementText,
1735 HTMLTxtRange_setEndPoint,
1736 HTMLTxtRange_compareEndPoints,
1737 HTMLTxtRange_findText,
1738 HTMLTxtRange_moveToPoint,
1739 HTMLTxtRange_getBookmark,
1740 HTMLTxtRange_moveToBookmark,
1741 HTMLTxtRange_queryCommandSupported,
1742 HTMLTxtRange_queryCommandEnabled,
1743 HTMLTxtRange_queryCommandState,
1744 HTMLTxtRange_queryCommandIndeterm,
1745 HTMLTxtRange_queryCommandText,
1746 HTMLTxtRange_queryCommandValue,
1747 HTMLTxtRange_execCommand,
1748 HTMLTxtRange_execCommandShowHelp
1751 #define OLECMDTRG_THIS(iface) DEFINE_THIS(HTMLTxtRange, OleCommandTarget, iface)
1753 static HRESULT WINAPI RangeCommandTarget_QueryInterface(IOleCommandTarget *iface, REFIID riid, void **ppv)
1755 HTMLTxtRange *This = OLECMDTRG_THIS(iface);
1756 return IHTMLTxtRange_QueryInterface(HTMLTXTRANGE(This), riid, ppv);
1759 static ULONG WINAPI RangeCommandTarget_AddRef(IOleCommandTarget *iface)
1761 HTMLTxtRange *This = OLECMDTRG_THIS(iface);
1762 return IHTMLTxtRange_AddRef(HTMLTXTRANGE(This));
1765 static ULONG WINAPI RangeCommandTarget_Release(IOleCommandTarget *iface)
1767 HTMLTxtRange *This = OLECMDTRG_THIS(iface);
1768 return IHTMLTxtRange_Release(HTMLTXTRANGE(This));
1771 static HRESULT WINAPI RangeCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
1772 ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
1774 HTMLTxtRange *This = OLECMDTRG_THIS(iface);
1775 FIXME("(%p)->(%s %d %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
1779 static HRESULT exec_indent(HTMLTxtRange *This, VARIANT *in, VARIANT *out)
1781 nsIDOMDocumentFragment *fragment;
1782 nsIDOMElement *blockquote_elem, *p_elem;
1783 nsIDOMDocument *nsdoc;
1787 static const PRUnichar blockquoteW[] = {'B','L','O','C','K','Q','U','O','T','E',0};
1788 static const PRUnichar pW[] = {'P',0};
1790 TRACE("(%p)->(%p %p)\n", This, in, out);
1792 nsIWebNavigation_GetDocument(This->doc->nscontainer->navigation, &nsdoc);
1794 nsAString_Init(&tag_str, blockquoteW);
1795 nsIDOMDocument_CreateElement(nsdoc, &tag_str, &blockquote_elem);
1796 nsAString_Finish(&tag_str);
1798 nsAString_Init(&tag_str, pW);
1799 nsIDOMDocument_CreateElement(nsdoc, &tag_str, &p_elem);
1800 nsAString_Finish(&tag_str);
1802 nsIDOMDocument_Release(nsdoc);
1804 nsIDOMRange_ExtractContents(This->nsrange, &fragment);
1805 nsIDOMElement_AppendChild(p_elem, (nsIDOMNode*)fragment, &tmp);
1806 nsIDOMDocumentFragment_Release(fragment);
1807 nsIDOMNode_Release(tmp);
1809 nsIDOMElement_AppendChild(blockquote_elem, (nsIDOMNode*)p_elem, &tmp);
1810 nsIDOMElement_Release(p_elem);
1811 nsIDOMNode_Release(tmp);
1813 nsIDOMRange_InsertNode(This->nsrange, (nsIDOMNode*)blockquote_elem);
1814 nsIDOMElement_Release(blockquote_elem);
1819 static HRESULT WINAPI RangeCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
1820 DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1822 HTMLTxtRange *This = OLECMDTRG_THIS(iface);
1824 TRACE("(%p)->(%s %d %x %p %p)\n", This, debugstr_guid(pguidCmdGroup), nCmdID,
1825 nCmdexecopt, pvaIn, pvaOut);
1827 if(pguidCmdGroup && IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
1830 return exec_indent(This, pvaIn, pvaOut);
1832 FIXME("Unsupported cmdid %d of CGID_MSHTML\n", nCmdID);
1835 FIXME("Unsupported cmd %d of group %s\n", nCmdID, debugstr_guid(pguidCmdGroup));
1841 #undef OLECMDTRG_THIS
1843 static const IOleCommandTargetVtbl OleCommandTargetVtbl = {
1844 RangeCommandTarget_QueryInterface,
1845 RangeCommandTarget_AddRef,
1846 RangeCommandTarget_Release,
1847 RangeCommandTarget_QueryStatus,
1848 RangeCommandTarget_Exec
1851 IHTMLTxtRange *HTMLTxtRange_Create(HTMLDocument *doc, nsIDOMRange *nsrange)
1853 HTMLTxtRange *ret = heap_alloc(sizeof(HTMLTxtRange));
1855 ret->lpHTMLTxtRangeVtbl = &HTMLTxtRangeVtbl;
1856 ret->lpOleCommandTargetVtbl = &OleCommandTargetVtbl;
1860 nsIDOMRange_AddRef(nsrange);
1861 ret->nsrange = nsrange;
1864 list_add_head(&doc->range_list, &ret->entry);
1866 return HTMLTXTRANGE(ret);
1869 void detach_ranges(HTMLDocument *This)
1873 LIST_FOR_EACH_ENTRY(iter, &This->range_list, HTMLTxtRange, entry) {