mshtml: Properly remove event listeners.
[wine] / dlls / mshtml / txtrange.c
1 /*
2  * Copyright 2006-2007 Jacek Caban for CodeWeavers
3  *
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.
8  *
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.
13  *
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
17  */
18
19 #include <stdarg.h>
20
21 #define COBJMACROS
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "ole2.h"
27 #include "mshtmcid.h"
28
29 #include "wine/debug.h"
30
31 #include "mshtml_private.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
34
35 static const WCHAR brW[] = {'b','r',0};
36 static const WCHAR hrW[] = {'h','r',0};
37
38 typedef struct {
39     IHTMLTxtRange     IHTMLTxtRange_iface;
40     IOleCommandTarget IOleCommandTarget_iface;
41
42     LONG ref;
43
44     nsIDOMRange *nsrange;
45     HTMLDocumentNode *doc;
46
47     struct list entry;
48 } HTMLTxtRange;
49
50 typedef struct {
51     WCHAR *buf;
52     DWORD len;
53     DWORD size;
54 } wstrbuf_t;
55
56 typedef struct {
57     PRUint16 type;
58     nsIDOMNode *node;
59     PRUint32 off;
60     nsAString str;
61     const PRUnichar *p;
62 } dompos_t;
63
64 typedef enum {
65     RU_UNKNOWN,
66     RU_CHAR,
67     RU_WORD,
68     RU_SENTENCE,
69     RU_TEXTEDIT
70 } range_unit_t;
71
72 static HTMLTxtRange *get_range_object(HTMLDocumentNode *doc, IHTMLTxtRange *iface)
73 {
74     HTMLTxtRange *iter;
75
76     LIST_FOR_EACH_ENTRY(iter, &doc->range_list, HTMLTxtRange, entry) {
77         if(&iter->IHTMLTxtRange_iface == iface)
78             return iter;
79     }
80
81     ERR("Could not find range in document\n");
82     return NULL;
83 }
84
85 static range_unit_t string_to_unit(LPCWSTR str)
86 {
87     static const WCHAR characterW[] =
88         {'c','h','a','r','a','c','t','e','r',0};
89     static const WCHAR wordW[] =
90         {'w','o','r','d',0};
91     static const WCHAR sentenceW[] =
92         {'s','e','n','t','e','n','c','e',0};
93     static const WCHAR texteditW[] =
94         {'t','e','x','t','e','d','i','t',0};
95
96     if(!strcmpiW(str, characterW))  return RU_CHAR;
97     if(!strcmpiW(str, wordW))       return RU_WORD;
98     if(!strcmpiW(str, sentenceW))   return RU_SENTENCE;
99     if(!strcmpiW(str, texteditW))   return RU_TEXTEDIT;
100
101     return RU_UNKNOWN;
102 }
103
104 static int string_to_nscmptype(LPCWSTR str)
105 {
106     static const WCHAR seW[] = {'S','t','a','r','t','T','o','E','n','d',0};
107     static const WCHAR ssW[] = {'S','t','a','r','t','T','o','S','t','a','r','t',0};
108     static const WCHAR esW[] = {'E','n','d','T','o','S','t','a','r','t',0};
109     static const WCHAR eeW[] = {'E','n','d','T','o','E','n','d',0};
110
111     if(!strcmpiW(str, seW))  return NS_START_TO_END;
112     if(!strcmpiW(str, ssW))  return NS_START_TO_START;
113     if(!strcmpiW(str, esW))  return NS_END_TO_START;
114     if(!strcmpiW(str, eeW))  return NS_END_TO_END;
115
116     return -1;
117 }
118
119 static PRUint16 get_node_type(nsIDOMNode *node)
120 {
121     PRUint16 type = 0;
122
123     if(node)
124         nsIDOMNode_GetNodeType(node, &type);
125
126     return type;
127 }
128
129 static BOOL is_elem_tag(nsIDOMNode *node, LPCWSTR istag)
130 {
131     nsIDOMElement *elem;
132     nsAString tag_str;
133     const PRUnichar *tag;
134     BOOL ret = FALSE;
135     nsresult nsres;
136
137     nsres = nsIDOMNode_QueryInterface(node, &IID_nsIDOMElement, (void**)&elem);
138     if(NS_FAILED(nsres))
139         return FALSE;
140
141     nsAString_Init(&tag_str, NULL);
142     nsIDOMElement_GetTagName(elem, &tag_str);
143     nsIDOMElement_Release(elem);
144     nsAString_GetData(&tag_str, &tag);
145
146     ret = !strcmpiW(tag, istag);
147
148     nsAString_Finish(&tag_str);
149
150     return ret;
151 }
152
153 static BOOL is_space_elem(nsIDOMNode *node)
154 {
155     nsIDOMElement *elem;
156     nsAString tag_str;
157     const PRUnichar *tag;
158     BOOL ret = FALSE;
159     nsresult nsres;
160
161     nsres = nsIDOMNode_QueryInterface(node, &IID_nsIDOMElement, (void**)&elem);
162     if(NS_FAILED(nsres))
163         return FALSE;
164
165     nsAString_Init(&tag_str, NULL);
166     nsIDOMElement_GetTagName(elem, &tag_str);
167     nsIDOMElement_Release(elem);
168     nsAString_GetData(&tag_str, &tag);
169
170     ret = !strcmpiW(tag, brW) || !strcmpiW(tag, hrW);
171
172     nsAString_Finish(&tag_str);
173
174     return ret;
175 }
176
177 static inline BOOL wstrbuf_init(wstrbuf_t *buf)
178 {
179     buf->len = 0;
180     buf->size = 16;
181     buf->buf = heap_alloc(buf->size * sizeof(WCHAR));
182     if (!buf->buf) return FALSE;
183     *buf->buf = 0;
184     return TRUE;
185 }
186
187 static inline void wstrbuf_finish(wstrbuf_t *buf)
188 {
189     heap_free(buf->buf);
190 }
191
192 static void wstrbuf_append_len(wstrbuf_t *buf, LPCWSTR str, int len)
193 {
194     if(buf->len+len >= buf->size) {
195         buf->size = 2*buf->size+len;
196         buf->buf = heap_realloc(buf->buf, buf->size * sizeof(WCHAR));
197     }
198
199     memcpy(buf->buf+buf->len, str, len*sizeof(WCHAR));
200     buf->len += len;
201     buf->buf[buf->len] = 0;
202 }
203
204 static void wstrbuf_append_nodetxt(wstrbuf_t *buf, LPCWSTR str, int len)
205 {
206     const WCHAR *s = str;
207     WCHAR *d;
208
209     TRACE("%s\n", debugstr_wn(str, len));
210
211     if(buf->len+len >= buf->size) {
212         buf->size = 2*buf->size+len;
213         buf->buf = heap_realloc(buf->buf, buf->size * sizeof(WCHAR));
214     }
215
216     if(buf->len && isspaceW(buf->buf[buf->len-1])) {
217         while(s < str+len && isspaceW(*s))
218             s++;
219     }
220
221     d = buf->buf+buf->len;
222     while(s < str+len) {
223         if(isspaceW(*s)) {
224             *d++ = ' ';
225             s++;
226             while(s < str+len && isspaceW(*s))
227                 s++;
228         }else {
229             *d++ = *s++;
230         }
231     }
232
233     buf->len = d - buf->buf;
234     *d = 0;
235 }
236
237 static void wstrbuf_append_node(wstrbuf_t *buf, nsIDOMNode *node)
238 {
239
240     switch(get_node_type(node)) {
241     case TEXT_NODE: {
242         nsIDOMText *nstext;
243         nsAString data_str;
244         const PRUnichar *data;
245
246         nsIDOMNode_QueryInterface(node, &IID_nsIDOMText, (void**)&nstext);
247
248         nsAString_Init(&data_str, NULL);
249         nsIDOMText_GetData(nstext, &data_str);
250         nsAString_GetData(&data_str, &data);
251         wstrbuf_append_nodetxt(buf, data, strlenW(data));
252         nsAString_Finish(&data_str);
253
254         nsIDOMText_Release(nstext);
255
256         break;
257     }
258     case ELEMENT_NODE:
259         if(is_elem_tag(node, brW)) {
260             static const WCHAR endlW[] = {'\r','\n'};
261             wstrbuf_append_len(buf, endlW, 2);
262         }else if(is_elem_tag(node, hrW)) {
263             static const WCHAR endl2W[] = {'\r','\n','\r','\n'};
264             wstrbuf_append_len(buf, endl2W, 4);
265         }
266     }
267 }
268
269 static void wstrbuf_append_node_rec(wstrbuf_t *buf, nsIDOMNode *node)
270 {
271     nsIDOMNode *iter, *tmp;
272
273     wstrbuf_append_node(buf, node);
274
275     nsIDOMNode_GetFirstChild(node, &iter);
276     while(iter) {
277         wstrbuf_append_node_rec(buf, iter);
278         nsIDOMNode_GetNextSibling(iter, &tmp);
279         nsIDOMNode_Release(iter);
280         iter = tmp;
281     }
282 }
283
284 static BOOL fill_nodestr(dompos_t *pos)
285 {
286     nsIDOMText *text;
287     nsresult nsres;
288
289     if(pos->type != TEXT_NODE)
290         return FALSE;
291
292     nsres = nsIDOMNode_QueryInterface(pos->node, &IID_nsIDOMText, (void**)&text);
293     if(NS_FAILED(nsres))
294         return FALSE;
295
296     nsAString_Init(&pos->str, NULL);
297     nsIDOMText_GetData(text, &pos->str);
298     nsIDOMText_Release(text);
299     nsAString_GetData(&pos->str, &pos->p);
300
301     if(pos->off == -1)
302         pos->off = *pos->p ? strlenW(pos->p)-1 : 0;
303
304     return TRUE;
305 }
306
307 static nsIDOMNode *next_node(nsIDOMNode *iter)
308 {
309     nsIDOMNode *ret, *tmp;
310     nsresult nsres;
311
312     if(!iter)
313         return NULL;
314
315     nsres = nsIDOMNode_GetFirstChild(iter, &ret);
316     if(NS_SUCCEEDED(nsres) && ret)
317         return ret;
318
319     nsIDOMNode_AddRef(iter);
320
321     do {
322         nsres = nsIDOMNode_GetNextSibling(iter, &ret);
323         if(NS_SUCCEEDED(nsres) && ret) {
324             nsIDOMNode_Release(iter);
325             return ret;
326         }
327
328         nsres = nsIDOMNode_GetParentNode(iter, &tmp);
329         nsIDOMNode_Release(iter);
330         iter = tmp;
331     }while(NS_SUCCEEDED(nsres) && iter);
332
333     return NULL;
334 }
335
336 static nsIDOMNode *prev_node(HTMLTxtRange *This, nsIDOMNode *iter)
337 {
338     nsIDOMNode *ret, *tmp;
339     nsresult nsres;
340
341     if(!iter) {
342         nsIDOMHTMLElement *nselem;
343
344         nsIDOMHTMLDocument_GetBody(This->doc->nsdoc, &nselem);
345         nsIDOMElement_GetLastChild(nselem, &tmp);
346         if(!tmp)
347             return (nsIDOMNode*)nselem;
348
349         while(tmp) {
350             ret = tmp;
351             nsIDOMNode_GetLastChild(ret, &tmp);
352         }
353
354         nsIDOMElement_Release(nselem);
355
356         return ret;
357     }
358
359     nsres = nsIDOMNode_GetLastChild(iter, &ret);
360     if(NS_SUCCEEDED(nsres) && ret)
361         return ret;
362
363     nsIDOMNode_AddRef(iter);
364
365     do {
366         nsres = nsIDOMNode_GetPreviousSibling(iter, &ret);
367         if(NS_SUCCEEDED(nsres) && ret) {
368             nsIDOMNode_Release(iter);
369             return ret;
370         }
371
372         nsres = nsIDOMNode_GetParentNode(iter, &tmp);
373         nsIDOMNode_Release(iter);
374         iter = tmp;
375     }while(NS_SUCCEEDED(nsres) && iter);
376
377     return NULL;
378 }
379
380 static nsIDOMNode *get_child_node(nsIDOMNode *node, PRUint32 off)
381 {
382     nsIDOMNodeList *node_list;
383     nsIDOMNode *ret = NULL;
384
385     nsIDOMNode_GetChildNodes(node, &node_list);
386     nsIDOMNodeList_Item(node_list, off, &ret);
387     nsIDOMNodeList_Release(node_list);
388
389     return ret;
390 }
391
392 static void get_cur_pos(HTMLTxtRange *This, BOOL start, dompos_t *pos)
393 {
394     nsIDOMNode *node;
395     PRInt32 off;
396
397     pos->p = NULL;
398
399     if(!start) {
400         PRBool collapsed;
401         nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
402         start = collapsed;
403     }
404
405     if(start) {
406         nsIDOMRange_GetStartContainer(This->nsrange, &node);
407         nsIDOMRange_GetStartOffset(This->nsrange, &off);
408     }else {
409         nsIDOMRange_GetEndContainer(This->nsrange, &node);
410         nsIDOMRange_GetEndOffset(This->nsrange, &off);
411     }
412
413     pos->type = get_node_type(node);
414     if(pos->type == ELEMENT_NODE) {
415         if(start) {
416             pos->node = get_child_node(node, off);
417             pos->off = 0;
418         }else {
419             pos->node = off ? get_child_node(node, off-1) : prev_node(This, node);
420             pos->off = -1;
421         }
422
423         pos->type = get_node_type(pos->node);
424         nsIDOMNode_Release(node);
425     }else if(start) {
426         pos->node = node;
427         pos->off = off;
428     }else if(off) {
429         pos->node = node;
430         pos->off = off-1;
431     }else {
432         pos->node = prev_node(This, node);
433         pos->off = -1;
434         nsIDOMNode_Release(node);
435     }
436
437     if(pos->type == TEXT_NODE)
438         fill_nodestr(pos);
439 }
440
441 static void set_range_pos(HTMLTxtRange *This, BOOL start, dompos_t *pos)
442 {
443     nsresult nsres;
444
445     if(start) {
446         if(pos->type == TEXT_NODE)
447             nsres = nsIDOMRange_SetStart(This->nsrange, pos->node, pos->off);
448         else
449             nsres = nsIDOMRange_SetStartBefore(This->nsrange, pos->node);
450     }else {
451         if(pos->type == TEXT_NODE && pos->p[pos->off+1])
452             nsres = nsIDOMRange_SetEnd(This->nsrange, pos->node, pos->off+1);
453         else
454             nsres = nsIDOMRange_SetEndAfter(This->nsrange, pos->node);
455     }
456
457     if(NS_FAILED(nsres))
458         ERR("failed: %p %08x\n", pos->node, nsres);
459 }
460
461 static inline void dompos_release(dompos_t *pos)
462 {
463     if(pos->node)
464         nsIDOMNode_Release(pos->node);
465
466     if(pos->p)
467         nsAString_Finish(&pos->str);
468 }
469
470 static inline void dompos_addref(dompos_t *pos)
471 {
472     if(pos->node)
473         nsIDOMNode_AddRef(pos->node);
474
475     if(pos->type == TEXT_NODE)
476         fill_nodestr(pos);
477 }
478
479 static inline BOOL dompos_cmp(const dompos_t *pos1, const dompos_t *pos2)
480 {
481     return pos1->node == pos2->node && pos1->off == pos2->off;
482 }
483
484 static void range_to_string(HTMLTxtRange *This, wstrbuf_t *buf)
485 {
486     nsIDOMNode *iter, *tmp;
487     dompos_t start_pos, end_pos;
488     PRBool collapsed;
489
490     nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
491     if(collapsed) {
492         wstrbuf_finish(buf);
493         buf->buf = NULL;
494         buf->size = 0;
495         return;
496     }
497
498     get_cur_pos(This, FALSE, &end_pos);
499     get_cur_pos(This, TRUE, &start_pos);
500
501     if(start_pos.type == TEXT_NODE) {
502         if(start_pos.node == end_pos.node) {
503             wstrbuf_append_nodetxt(buf, start_pos.p+start_pos.off, end_pos.off-start_pos.off+1);
504             iter = start_pos.node;
505             nsIDOMNode_AddRef(iter);
506         }else {
507             wstrbuf_append_nodetxt(buf, start_pos.p+start_pos.off, strlenW(start_pos.p+start_pos.off));
508             iter = next_node(start_pos.node);
509         }
510     }else {
511         iter = start_pos.node;
512         nsIDOMNode_AddRef(iter);
513     }
514
515     while(iter != end_pos.node) {
516         wstrbuf_append_node(buf, iter);
517         tmp = next_node(iter);
518         nsIDOMNode_Release(iter);
519         iter = tmp;
520     }
521
522     nsIDOMNode_AddRef(end_pos.node);
523
524     if(start_pos.node != end_pos.node) {
525         if(end_pos.type == TEXT_NODE)
526             wstrbuf_append_nodetxt(buf, end_pos.p, end_pos.off+1);
527         else
528             wstrbuf_append_node(buf, end_pos.node);
529     }
530
531     nsIDOMNode_Release(iter);
532     dompos_release(&start_pos);
533     dompos_release(&end_pos);
534
535     if(buf->len) {
536         WCHAR *p;
537
538         for(p = buf->buf+buf->len-1; p >= buf->buf && isspaceW(*p); p--);
539
540         p = strchrW(p, '\r');
541         if(p)
542             *p = 0;
543     }
544 }
545
546 HRESULT get_node_text(HTMLDOMNode *node, BSTR *ret)
547 {
548     wstrbuf_t buf;
549     HRESULT hres = S_OK;
550
551     if (!wstrbuf_init(&buf))
552         return E_OUTOFMEMORY;
553     wstrbuf_append_node_rec(&buf, node->nsnode);
554     if(buf.buf) {
555         *ret = SysAllocString(buf.buf);
556         if(!*ret)
557             hres = E_OUTOFMEMORY;
558     } else {
559         *ret = NULL;
560     }
561     wstrbuf_finish(&buf);
562
563     if(SUCCEEDED(hres))
564         TRACE("ret %s\n", debugstr_w(*ret));
565     return hres;
566 }
567
568 static WCHAR get_pos_char(const dompos_t *pos)
569 {
570     switch(pos->type) {
571     case TEXT_NODE:
572         return pos->p[pos->off];
573     case ELEMENT_NODE:
574         if(is_space_elem(pos->node))
575             return '\n';
576     }
577
578     return 0;
579 }
580
581 static void end_space(const dompos_t *pos, dompos_t *new_pos)
582 {
583     const WCHAR *p;
584
585     *new_pos = *pos;
586     dompos_addref(new_pos);
587
588     if(pos->type != TEXT_NODE)
589         return;
590
591     p = new_pos->p+new_pos->off;
592
593     if(!*p || !isspace(*p))
594         return;
595
596     while(p[1] && isspace(p[1]))
597         p++;
598
599     new_pos->off = p - new_pos->p;
600 }
601
602 static WCHAR next_char(const dompos_t *pos, dompos_t *new_pos)
603 {
604     nsIDOMNode *iter, *tmp;
605     dompos_t last_space, tmp_pos;
606     const WCHAR *p;
607     WCHAR cspace = 0;
608
609     if(pos->type == TEXT_NODE && pos->off != -1 && pos->p[pos->off]) {
610         p = pos->p+pos->off;
611
612         if(isspace(*p))
613             while(isspaceW(*++p));
614         else
615             p++;
616
617         if(*p && isspaceW(*p)) {
618             cspace = ' ';
619             while(p[1] && isspaceW(p[1]))
620                 p++;
621         }
622
623         if(*p) {
624             *new_pos = *pos;
625             new_pos->off = p - pos->p;
626             dompos_addref(new_pos);
627
628             return cspace ? cspace : *p;
629         }else {
630             last_space = *pos;
631             last_space.off = p - pos->p;
632             dompos_addref(&last_space);
633         }
634     }
635
636     iter = next_node(pos->node);
637
638     while(iter) {
639         switch(get_node_type(iter)) {
640         case TEXT_NODE:
641             tmp_pos.node = iter;
642             tmp_pos.type = TEXT_NODE;
643             tmp_pos.off = 0;
644             dompos_addref(&tmp_pos);
645
646             p = tmp_pos.p;
647
648             if(!*p) {
649                 dompos_release(&tmp_pos);
650                 break;
651             }else if(isspaceW(*p)) {
652                 if(cspace)
653                     dompos_release(&last_space);
654                 else
655                     cspace = ' ';
656
657                 while(p[1] && isspaceW(p[1]))
658                       p++;
659
660                 tmp_pos.off = p-tmp_pos.p;
661
662                 if(!p[1]) {
663                     last_space = tmp_pos;
664                     break;
665                 }
666
667                 *new_pos = tmp_pos;
668                 nsIDOMNode_Release(iter);
669                 return cspace;
670             }else if(cspace) {
671                 *new_pos = last_space;
672                 dompos_release(&tmp_pos);
673                 nsIDOMNode_Release(iter);
674
675                 return cspace;
676             }else if(*p) {
677                 tmp_pos.off = 0;
678                 *new_pos = tmp_pos;
679             }
680
681             nsIDOMNode_Release(iter);
682             return *p;
683
684         case ELEMENT_NODE:
685             if(is_elem_tag(iter, brW)) {
686                 if(cspace)
687                     dompos_release(&last_space);
688                 cspace = '\n';
689
690                 nsIDOMNode_AddRef(iter);
691                 last_space.node = iter;
692                 last_space.type = ELEMENT_NODE;
693                 last_space.off = 0;
694                 last_space.p = NULL;
695             }else if(is_elem_tag(iter, hrW)) {
696                 if(cspace) {
697                     *new_pos = last_space;
698                     nsIDOMNode_Release(iter);
699                     return cspace;
700                 }
701
702                 new_pos->node = iter;
703                 new_pos->type = ELEMENT_NODE;
704                 new_pos->off = 0;
705                 new_pos->p = NULL;
706                 return '\n';
707             }
708         }
709
710         tmp = iter;
711         iter = next_node(iter);
712         nsIDOMNode_Release(tmp);
713     }
714
715     if(cspace) {
716         *new_pos = last_space;
717     }else {
718         *new_pos = *pos;
719         dompos_addref(new_pos);
720     }
721
722     return cspace;
723 }
724
725 static WCHAR prev_char(HTMLTxtRange *This, const dompos_t *pos, dompos_t *new_pos)
726 {
727     nsIDOMNode *iter, *tmp;
728     const WCHAR *p;
729     BOOL skip_space = FALSE;
730
731     if(pos->type == TEXT_NODE && isspaceW(pos->p[pos->off]))
732         skip_space = TRUE;
733
734     if(pos->type == TEXT_NODE && pos->off) {
735         p = pos->p+pos->off-1;
736
737         if(skip_space) {
738             while(p >= pos->p && isspace(*p))
739                 p--;
740         }
741
742         if(p >= pos->p) {
743             *new_pos = *pos;
744             new_pos->off = p-pos->p;
745             dompos_addref(new_pos);
746             return new_pos->p[new_pos->off];
747         }
748     }
749
750     iter = prev_node(This, pos->node);
751
752     while(iter) {
753         switch(get_node_type(iter)) {
754         case TEXT_NODE: {
755             dompos_t tmp_pos;
756
757             tmp_pos.node = iter;
758             tmp_pos.type = TEXT_NODE;
759             tmp_pos.off = 0;
760             dompos_addref(&tmp_pos);
761
762             p = tmp_pos.p + strlenW(tmp_pos.p)-1;
763
764             if(skip_space) {
765                 while(p >= tmp_pos.p && isspaceW(*p))
766                     p--;
767             }
768
769             if(p < tmp_pos.p) {
770                 dompos_release(&tmp_pos);
771                 break;
772             }
773
774             tmp_pos.off = p-tmp_pos.p;
775             *new_pos = tmp_pos;
776             nsIDOMNode_Release(iter);
777             return *p;
778         }
779
780         case ELEMENT_NODE:
781             if(is_elem_tag(iter, brW)) {
782                 if(skip_space) {
783                     skip_space = FALSE;
784                     break;
785                 }
786             }else if(!is_elem_tag(iter, hrW)) {
787                 break;
788             }
789
790             new_pos->node = iter;
791             new_pos->type = ELEMENT_NODE;
792             new_pos->off = 0;
793             new_pos->p = NULL;
794             return '\n';
795         }
796
797         tmp = iter;
798         iter = prev_node(This, iter);
799         nsIDOMNode_Release(tmp);
800     }
801
802     *new_pos = *pos;
803     dompos_addref(new_pos);
804     return 0;
805 }
806
807 static LONG move_next_chars(LONG cnt, const dompos_t *pos, BOOL col, const dompos_t *bound_pos,
808         BOOL *bounded, dompos_t *new_pos)
809 {
810     dompos_t iter, tmp;
811     LONG ret = 0;
812     WCHAR c;
813
814     if(bounded)
815         *bounded = FALSE;
816
817     if(col)
818         ret++;
819
820     if(ret >= cnt) {
821         end_space(pos, new_pos);
822         return ret;
823     }
824
825     c = next_char(pos, &iter);
826     ret++;
827
828     while(ret < cnt) {
829         tmp = iter;
830         c = next_char(&tmp, &iter);
831         dompos_release(&tmp);
832         if(!c)
833             break;
834
835         ret++;
836         if(bound_pos && dompos_cmp(&tmp, bound_pos)) {
837             *bounded = TRUE;
838             ret++;
839         }
840     }
841
842     *new_pos = iter;
843     return ret;
844 }
845
846 static LONG move_prev_chars(HTMLTxtRange *This, LONG cnt, const dompos_t *pos, BOOL end,
847         const dompos_t *bound_pos, BOOL *bounded, dompos_t *new_pos)
848 {
849     dompos_t iter, tmp;
850     LONG ret = 0;
851     BOOL prev_eq = FALSE;
852     WCHAR c;
853
854     if(bounded)
855         *bounded = FALSE;
856
857     c = prev_char(This, pos, &iter);
858     if(c)
859         ret++;
860
861     while(c && ret < cnt) {
862         tmp = iter;
863         c = prev_char(This, &tmp, &iter);
864         dompos_release(&tmp);
865         if(!c) {
866             if(end)
867                 ret++;
868             break;
869         }
870
871         ret++;
872
873         if(prev_eq) {
874             *bounded = TRUE;
875             ret++;
876         }
877
878         prev_eq = bound_pos && dompos_cmp(&iter, bound_pos);
879     }
880
881     *new_pos = iter;
882     return ret;
883 }
884
885 static LONG find_prev_space(HTMLTxtRange *This, const dompos_t *pos, BOOL first_space, dompos_t *ret)
886 {
887     dompos_t iter, tmp;
888     WCHAR c;
889
890     c = prev_char(This, pos, &iter);
891     if(!c || (first_space && isspaceW(c))) {
892         *ret = iter;
893         return FALSE;
894     }
895
896     while(1) {
897         tmp = iter;
898         c = prev_char(This, &tmp, &iter);
899         if(!c || isspaceW(c)) {
900             dompos_release(&iter);
901             break;
902         }
903         dompos_release(&tmp);
904     }
905
906     *ret = tmp;
907     return TRUE;
908 }
909
910 static int find_word_end(const dompos_t *pos, dompos_t *ret)
911 {
912     dompos_t iter, tmp;
913     int cnt = 1;
914     WCHAR c;
915     c = get_pos_char(pos);
916     if(isspaceW(c)) {
917         *ret = *pos;
918         dompos_addref(ret);
919         return 0;
920     }
921
922     c = next_char(pos, &iter);
923     if(!c) {
924         *ret = iter;
925         return 0;
926     }
927     if(c == '\n') {
928         *ret = *pos;
929         dompos_addref(ret);
930         return 0;
931     }
932
933     while(c && !isspaceW(c)) {
934         tmp = iter;
935         c = next_char(&tmp, &iter);
936         if(c == '\n') {
937             dompos_release(&iter);
938             iter = tmp;
939         }else {
940             cnt++;
941             dompos_release(&tmp);
942         }
943     }
944
945     *ret = iter;
946     return cnt;
947 }
948
949 static LONG move_next_words(LONG cnt, const dompos_t *pos, dompos_t *new_pos)
950 {
951     dompos_t iter, tmp;
952     LONG ret = 0;
953     WCHAR c;
954
955     c = get_pos_char(pos);
956     if(isspaceW(c)) {
957         end_space(pos, &iter);
958         ret++;
959     }else {
960         c = next_char(pos, &iter);
961         if(c && isspaceW(c))
962             ret++;
963     }
964
965     while(c && ret < cnt) {
966         tmp = iter;
967         c = next_char(&tmp, &iter);
968         dompos_release(&tmp);
969         if(isspaceW(c))
970             ret++;
971     }
972
973     *new_pos = iter;
974     return ret;
975 }
976
977 static LONG move_prev_words(HTMLTxtRange *This, LONG cnt, const dompos_t *pos, dompos_t *new_pos)
978 {
979     dompos_t iter, tmp;
980     LONG ret = 0;
981
982     iter = *pos;
983     dompos_addref(&iter);
984
985     while(ret < cnt) {
986         if(!find_prev_space(This, &iter, FALSE, &tmp))
987             break;
988
989         dompos_release(&iter);
990         iter = tmp;
991         ret++;
992     }
993
994     *new_pos = iter;
995     return ret;
996 }
997
998 static inline HTMLTxtRange *impl_from_IHTMLTxtRange(IHTMLTxtRange *iface)
999 {
1000     return CONTAINING_RECORD(iface, HTMLTxtRange, IHTMLTxtRange_iface);
1001 }
1002
1003 static HRESULT WINAPI HTMLTxtRange_QueryInterface(IHTMLTxtRange *iface, REFIID riid, void **ppv)
1004 {
1005     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1006
1007     *ppv = NULL;
1008
1009     if(IsEqualGUID(&IID_IUnknown, riid)) {
1010         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1011         *ppv = &This->IHTMLTxtRange_iface;
1012     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1013         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1014         *ppv = &This->IHTMLTxtRange_iface;
1015     }else if(IsEqualGUID(&IID_IHTMLTxtRange, riid)) {
1016         TRACE("(%p)->(IID_IHTMLTxtRange %p)\n", This, ppv);
1017         *ppv = &This->IHTMLTxtRange_iface;
1018     }else if(IsEqualGUID(&IID_IOleCommandTarget, riid)) {
1019         TRACE("(%p)->(IID_IOleCommandTarget %p)\n", This, ppv);
1020         *ppv = &This->IOleCommandTarget_iface;
1021     }
1022
1023     if(*ppv) {
1024         IUnknown_AddRef((IUnknown*)*ppv);
1025         return S_OK;
1026     }
1027
1028     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1029     return E_NOINTERFACE;
1030 }
1031
1032 static ULONG WINAPI HTMLTxtRange_AddRef(IHTMLTxtRange *iface)
1033 {
1034     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1035     LONG ref = InterlockedIncrement(&This->ref);
1036
1037     TRACE("(%p) ref=%d\n", This, ref);
1038
1039     return ref;
1040 }
1041
1042 static ULONG WINAPI HTMLTxtRange_Release(IHTMLTxtRange *iface)
1043 {
1044     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1045     LONG ref = InterlockedDecrement(&This->ref);
1046
1047     TRACE("(%p) ref=%d\n", This, ref);
1048
1049     if(!ref) {
1050         if(This->nsrange)
1051             nsISelection_Release(This->nsrange);
1052         if(This->doc)
1053             list_remove(&This->entry);
1054         heap_free(This);
1055     }
1056
1057     return ref;
1058 }
1059
1060 static HRESULT WINAPI HTMLTxtRange_GetTypeInfoCount(IHTMLTxtRange *iface, UINT *pctinfo)
1061 {
1062     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1063     FIXME("(%p)->(%p)\n", This, pctinfo);
1064     return E_NOTIMPL;
1065 }
1066
1067 static HRESULT WINAPI HTMLTxtRange_GetTypeInfo(IHTMLTxtRange *iface, UINT iTInfo,
1068                                                LCID lcid, ITypeInfo **ppTInfo)
1069 {
1070     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1071     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1072     return E_NOTIMPL;
1073 }
1074
1075 static HRESULT WINAPI HTMLTxtRange_GetIDsOfNames(IHTMLTxtRange *iface, REFIID riid,
1076                                                  LPOLESTR *rgszNames, UINT cNames,
1077                                                  LCID lcid, DISPID *rgDispId)
1078 {
1079     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1080     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1081           lcid, rgDispId);
1082     return E_NOTIMPL;
1083 }
1084
1085 static HRESULT WINAPI HTMLTxtRange_Invoke(IHTMLTxtRange *iface, DISPID dispIdMember,
1086                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1087                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1088 {
1089     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1090     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1091           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1092     return E_NOTIMPL;
1093 }
1094
1095 static HRESULT WINAPI HTMLTxtRange_get_htmlText(IHTMLTxtRange *iface, BSTR *p)
1096 {
1097     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1098
1099     TRACE("(%p)->(%p)\n", This, p);
1100
1101     *p = NULL;
1102
1103     if(This->nsrange) {
1104         nsIDOMDocumentFragment *fragment;
1105         nsresult nsres;
1106
1107         nsres = nsIDOMRange_CloneContents(This->nsrange, &fragment);
1108         if(NS_SUCCEEDED(nsres)) {
1109             const PRUnichar *nstext;
1110             nsAString nsstr;
1111
1112             nsAString_Init(&nsstr, NULL);
1113             nsnode_to_nsstring((nsIDOMNode*)fragment, &nsstr);
1114             nsIDOMDocumentFragment_Release(fragment);
1115
1116             nsAString_GetData(&nsstr, &nstext);
1117             *p = SysAllocString(nstext);
1118
1119             nsAString_Finish(&nsstr);
1120         }
1121     }
1122
1123     if(!*p) {
1124         const WCHAR emptyW[] = {0};
1125         *p = SysAllocString(emptyW);
1126     }
1127
1128     TRACE("return %s\n", debugstr_w(*p));
1129     return S_OK;
1130 }
1131
1132 static HRESULT WINAPI HTMLTxtRange_put_text(IHTMLTxtRange *iface, BSTR v)
1133 {
1134     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1135     nsIDOMText *text_node;
1136     nsAString text_str;
1137     nsresult nsres;
1138
1139     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1140
1141     if(!This->doc)
1142         return MSHTML_E_NODOC;
1143
1144     nsAString_InitDepend(&text_str, v);
1145     nsres = nsIDOMHTMLDocument_CreateTextNode(This->doc->nsdoc, &text_str, &text_node);
1146     nsAString_Finish(&text_str);
1147     if(NS_FAILED(nsres)) {
1148         ERR("CreateTextNode failed: %08x\n", nsres);
1149         return S_OK;
1150     }
1151     nsres = nsIDOMRange_DeleteContents(This->nsrange);
1152     if(NS_FAILED(nsres))
1153         ERR("DeleteContents failed: %08x\n", nsres);
1154
1155     nsres = nsIDOMRange_InsertNode(This->nsrange, (nsIDOMNode*)text_node);
1156     if(NS_FAILED(nsres))
1157         ERR("InsertNode failed: %08x\n", nsres);
1158
1159     nsres = nsIDOMRange_SetEndAfter(This->nsrange, (nsIDOMNode*)text_node);
1160     if(NS_FAILED(nsres))
1161         ERR("SetEndAfter failed: %08x\n", nsres);
1162
1163     return IHTMLTxtRange_collapse(&This->IHTMLTxtRange_iface, VARIANT_FALSE);
1164 }
1165
1166 static HRESULT WINAPI HTMLTxtRange_get_text(IHTMLTxtRange *iface, BSTR *p)
1167 {
1168     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1169     wstrbuf_t buf;
1170
1171     TRACE("(%p)->(%p)\n", This, p);
1172
1173     *p = NULL;
1174     if(!This->nsrange)
1175         return S_OK;
1176
1177     if (!wstrbuf_init(&buf))
1178         return E_OUTOFMEMORY;
1179     range_to_string(This, &buf);
1180     if (buf.buf)
1181         *p = SysAllocString(buf.buf);
1182     wstrbuf_finish(&buf);
1183
1184     TRACE("ret %s\n", debugstr_w(*p));
1185     return S_OK;
1186 }
1187
1188 static HRESULT WINAPI HTMLTxtRange_parentElement(IHTMLTxtRange *iface, IHTMLElement **parent)
1189 {
1190     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1191     nsIDOMNode *nsnode, *tmp;
1192     HTMLDOMNode *node;
1193     HRESULT hres;
1194
1195     TRACE("(%p)->(%p)\n", This, parent);
1196
1197     nsIDOMRange_GetCommonAncestorContainer(This->nsrange, &nsnode);
1198     while(nsnode && get_node_type(nsnode) != ELEMENT_NODE) {
1199         nsIDOMNode_GetParentNode(nsnode, &tmp);
1200         nsIDOMNode_Release(nsnode);
1201         nsnode = tmp;
1202     }
1203
1204     if(!nsnode) {
1205         *parent = NULL;
1206         return S_OK;
1207     }
1208
1209     hres = get_node(This->doc, nsnode, TRUE, &node);
1210     nsIDOMNode_Release(nsnode);
1211     if(FAILED(hres))
1212         return hres;
1213
1214     return IHTMLDOMNode_QueryInterface(&node->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)parent);
1215 }
1216
1217 static HRESULT WINAPI HTMLTxtRange_duplicate(IHTMLTxtRange *iface, IHTMLTxtRange **Duplicate)
1218 {
1219     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1220     nsIDOMRange *nsrange = NULL;
1221     HRESULT hres;
1222
1223     TRACE("(%p)->(%p)\n", This, Duplicate);
1224
1225     nsIDOMRange_CloneRange(This->nsrange, &nsrange);
1226     hres = HTMLTxtRange_Create(This->doc, nsrange, Duplicate);
1227     nsIDOMRange_Release(nsrange);
1228
1229     return hres;
1230 }
1231
1232 static HRESULT WINAPI HTMLTxtRange_inRange(IHTMLTxtRange *iface, IHTMLTxtRange *Range,
1233         VARIANT_BOOL *InRange)
1234 {
1235     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1236     HTMLTxtRange *src_range;
1237     PRInt16 nsret = 0;
1238     nsresult nsres;
1239
1240     TRACE("(%p)->(%p %p)\n", This, Range, InRange);
1241
1242     *InRange = VARIANT_FALSE;
1243
1244     src_range = get_range_object(This->doc, Range);
1245     if(!src_range)
1246         return E_FAIL;
1247
1248     nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_START_TO_START,
1249             src_range->nsrange, &nsret);
1250     if(NS_SUCCEEDED(nsres) && nsret <= 0) {
1251         nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_END_TO_END,
1252                 src_range->nsrange, &nsret);
1253         if(NS_SUCCEEDED(nsres) && nsret >= 0)
1254             *InRange = VARIANT_TRUE;
1255     }
1256
1257     if(NS_FAILED(nsres))
1258         ERR("CompareBoundaryPoints failed: %08x\n", nsres);
1259
1260     return S_OK;
1261 }
1262
1263 static HRESULT WINAPI HTMLTxtRange_isEqual(IHTMLTxtRange *iface, IHTMLTxtRange *Range,
1264         VARIANT_BOOL *IsEqual)
1265 {
1266     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1267     HTMLTxtRange *src_range;
1268     PRInt16 nsret = 0;
1269     nsresult nsres;
1270
1271     TRACE("(%p)->(%p %p)\n", This, Range, IsEqual);
1272
1273     *IsEqual = VARIANT_FALSE;
1274
1275     src_range = get_range_object(This->doc, Range);
1276     if(!src_range)
1277         return E_FAIL;
1278
1279     nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_START_TO_START,
1280             src_range->nsrange, &nsret);
1281     if(NS_SUCCEEDED(nsres) && !nsret) {
1282         nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_END_TO_END,
1283                 src_range->nsrange, &nsret);
1284         if(NS_SUCCEEDED(nsres) && !nsret)
1285             *IsEqual = VARIANT_TRUE;
1286     }
1287
1288     if(NS_FAILED(nsres))
1289         ERR("CompareBoundaryPoints failed: %08x\n", nsres);
1290
1291     return S_OK;
1292 }
1293
1294 static HRESULT WINAPI HTMLTxtRange_scrollIntoView(IHTMLTxtRange *iface, VARIANT_BOOL fStart)
1295 {
1296     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1297     FIXME("(%p)->(%x)\n", This, fStart);
1298     return E_NOTIMPL;
1299 }
1300
1301 static HRESULT WINAPI HTMLTxtRange_collapse(IHTMLTxtRange *iface, VARIANT_BOOL Start)
1302 {
1303     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1304
1305     TRACE("(%p)->(%x)\n", This, Start);
1306
1307     nsIDOMRange_Collapse(This->nsrange, Start != VARIANT_FALSE);
1308     return S_OK;
1309 }
1310
1311 static HRESULT WINAPI HTMLTxtRange_expand(IHTMLTxtRange *iface, BSTR Unit, VARIANT_BOOL *Success)
1312 {
1313     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1314     range_unit_t unit;
1315
1316     TRACE("(%p)->(%s %p)\n", This, debugstr_w(Unit), Success);
1317
1318     unit = string_to_unit(Unit);
1319     if(unit == RU_UNKNOWN)
1320         return E_INVALIDARG;
1321
1322     *Success = VARIANT_FALSE;
1323
1324     switch(unit) {
1325     case RU_WORD: {
1326         dompos_t end_pos, start_pos, new_start_pos, new_end_pos;
1327         PRBool collapsed;
1328
1329         nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
1330
1331         get_cur_pos(This, TRUE, &start_pos);
1332         get_cur_pos(This, FALSE, &end_pos);
1333
1334         if(find_word_end(&end_pos, &new_end_pos) || collapsed) {
1335             set_range_pos(This, FALSE, &new_end_pos);
1336             *Success = VARIANT_TRUE;
1337         }
1338
1339         if(start_pos.type && (get_pos_char(&end_pos) || !dompos_cmp(&new_end_pos, &end_pos))) {
1340             if(find_prev_space(This, &start_pos, TRUE, &new_start_pos)) {
1341                 set_range_pos(This, TRUE, &new_start_pos);
1342                 *Success = VARIANT_TRUE;
1343             }
1344             dompos_release(&new_start_pos);
1345         }
1346
1347         dompos_release(&new_end_pos);
1348         dompos_release(&end_pos);
1349         dompos_release(&start_pos);
1350
1351         break;
1352     }
1353
1354     case RU_TEXTEDIT: {
1355         nsIDOMHTMLElement *nsbody = NULL;
1356         nsresult nsres;
1357
1358         nsres = nsIDOMHTMLDocument_GetBody(This->doc->nsdoc, &nsbody);
1359         if(NS_FAILED(nsres) || !nsbody) {
1360             ERR("Could not get body: %08x\n", nsres);
1361             break;
1362         }
1363
1364         nsres = nsIDOMRange_SelectNodeContents(This->nsrange, (nsIDOMNode*)nsbody);
1365         nsIDOMHTMLElement_Release(nsbody);
1366         if(NS_FAILED(nsres)) {
1367             ERR("Collapse failed: %08x\n", nsres);
1368             break;
1369         }
1370
1371         *Success = VARIANT_TRUE;
1372         break;
1373     }
1374
1375     default:
1376         FIXME("Unimplemented unit %s\n", debugstr_w(Unit));
1377     }
1378
1379     return S_OK;
1380 }
1381
1382 static HRESULT WINAPI HTMLTxtRange_move(IHTMLTxtRange *iface, BSTR Unit,
1383         LONG Count, LONG *ActualCount)
1384 {
1385     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1386     range_unit_t unit;
1387
1388     TRACE("(%p)->(%s %d %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1389
1390     unit = string_to_unit(Unit);
1391     if(unit == RU_UNKNOWN)
1392         return E_INVALIDARG;
1393
1394     if(!Count) {
1395         *ActualCount = 0;
1396         return IHTMLTxtRange_collapse(&This->IHTMLTxtRange_iface, TRUE);
1397     }
1398
1399     switch(unit) {
1400     case RU_CHAR: {
1401         dompos_t cur_pos, new_pos;
1402
1403         get_cur_pos(This, TRUE, &cur_pos);
1404
1405         if(Count > 0) {
1406             *ActualCount = move_next_chars(Count, &cur_pos, TRUE, NULL, NULL, &new_pos);
1407             set_range_pos(This, FALSE, &new_pos);
1408             dompos_release(&new_pos);
1409
1410             IHTMLTxtRange_collapse(&This->IHTMLTxtRange_iface, FALSE);
1411         }else {
1412             *ActualCount = -move_prev_chars(This, -Count, &cur_pos, FALSE, NULL, NULL, &new_pos);
1413             set_range_pos(This, TRUE, &new_pos);
1414             IHTMLTxtRange_collapse(&This->IHTMLTxtRange_iface, TRUE);
1415             dompos_release(&new_pos);
1416         }
1417
1418         dompos_release(&cur_pos);
1419         break;
1420     }
1421
1422     case RU_WORD: {
1423         dompos_t cur_pos, new_pos;
1424
1425         get_cur_pos(This, TRUE, &cur_pos);
1426
1427         if(Count > 0) {
1428             *ActualCount = move_next_words(Count, &cur_pos, &new_pos);
1429             set_range_pos(This, FALSE, &new_pos);
1430             dompos_release(&new_pos);
1431             IHTMLTxtRange_collapse(&This->IHTMLTxtRange_iface, FALSE);
1432         }else {
1433             *ActualCount = -move_prev_words(This, -Count, &cur_pos, &new_pos);
1434             set_range_pos(This, TRUE, &new_pos);
1435             IHTMLTxtRange_collapse(&This->IHTMLTxtRange_iface, TRUE);
1436             dompos_release(&new_pos);
1437         }
1438
1439         dompos_release(&cur_pos);
1440         break;
1441     }
1442
1443     default:
1444         FIXME("unimplemented unit %s\n", debugstr_w(Unit));
1445     }
1446
1447     TRACE("ret %d\n", *ActualCount);
1448     return S_OK;
1449 }
1450
1451 static HRESULT WINAPI HTMLTxtRange_moveStart(IHTMLTxtRange *iface, BSTR Unit,
1452         LONG Count, LONG *ActualCount)
1453 {
1454     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1455     range_unit_t unit;
1456
1457     TRACE("(%p)->(%s %d %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1458
1459     unit = string_to_unit(Unit);
1460     if(unit == RU_UNKNOWN)
1461         return E_INVALIDARG;
1462
1463     if(!Count) {
1464         *ActualCount = 0;
1465         return S_OK;
1466     }
1467
1468     switch(unit) {
1469     case RU_CHAR: {
1470         dompos_t start_pos, end_pos, new_pos;
1471         PRBool collapsed;
1472
1473         get_cur_pos(This, TRUE, &start_pos);
1474         get_cur_pos(This, FALSE, &end_pos);
1475         nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
1476
1477         if(Count > 0) {
1478             BOOL bounded;
1479
1480             *ActualCount = move_next_chars(Count, &start_pos, collapsed, &end_pos, &bounded, &new_pos);
1481             set_range_pos(This, !bounded, &new_pos);
1482             if(bounded)
1483                 IHTMLTxtRange_collapse(&This->IHTMLTxtRange_iface, FALSE);
1484         }else {
1485             *ActualCount = -move_prev_chars(This, -Count, &start_pos, FALSE, NULL, NULL, &new_pos);
1486             set_range_pos(This, TRUE, &new_pos);
1487         }
1488
1489         dompos_release(&start_pos);
1490         dompos_release(&end_pos);
1491         dompos_release(&new_pos);
1492         break;
1493     }
1494
1495     default:
1496         FIXME("unimplemented unit %s\n", debugstr_w(Unit));
1497     }
1498
1499     return S_OK;
1500 }
1501
1502 static HRESULT WINAPI HTMLTxtRange_moveEnd(IHTMLTxtRange *iface, BSTR Unit,
1503         LONG Count, LONG *ActualCount)
1504 {
1505     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1506     range_unit_t unit;
1507
1508     TRACE("(%p)->(%s %d %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1509
1510     unit = string_to_unit(Unit);
1511     if(unit == RU_UNKNOWN)
1512         return E_INVALIDARG;
1513
1514     if(!Count) {
1515         *ActualCount = 0;
1516         return S_OK;
1517     }
1518
1519     switch(unit) {
1520     case RU_CHAR: {
1521         dompos_t start_pos, end_pos, new_pos;
1522         PRBool collapsed;
1523
1524         get_cur_pos(This, TRUE, &start_pos);
1525         get_cur_pos(This, FALSE, &end_pos);
1526         nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
1527
1528         if(Count > 0) {
1529             *ActualCount = move_next_chars(Count, &end_pos, collapsed, NULL, NULL, &new_pos);
1530             set_range_pos(This, FALSE, &new_pos);
1531         }else {
1532             BOOL bounded;
1533
1534             *ActualCount = -move_prev_chars(This, -Count, &end_pos, TRUE, &start_pos, &bounded, &new_pos);
1535             set_range_pos(This, bounded, &new_pos);
1536             if(bounded)
1537                 IHTMLTxtRange_collapse(&This->IHTMLTxtRange_iface, TRUE);
1538         }
1539
1540         dompos_release(&start_pos);
1541         dompos_release(&end_pos);
1542         dompos_release(&new_pos);
1543         break;
1544     }
1545
1546     default:
1547         FIXME("unimplemented unit %s\n", debugstr_w(Unit));
1548     }
1549
1550     return S_OK;
1551 }
1552
1553 static HRESULT WINAPI HTMLTxtRange_select(IHTMLTxtRange *iface)
1554 {
1555     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1556     nsISelection *nsselection;
1557     nsresult nsres;
1558
1559     TRACE("(%p)\n", This);
1560
1561     nsres = nsIDOMWindow_GetSelection(This->doc->basedoc.window->nswindow, &nsselection);
1562     if(NS_FAILED(nsres)) {
1563         ERR("GetSelection failed: %08x\n", nsres);
1564         return E_FAIL;
1565     }
1566
1567     nsISelection_RemoveAllRanges(nsselection);
1568     nsISelection_AddRange(nsselection, This->nsrange);
1569     nsISelection_Release(nsselection);
1570     return S_OK;
1571 }
1572
1573 static HRESULT WINAPI HTMLTxtRange_pasteHTML(IHTMLTxtRange *iface, BSTR html)
1574 {
1575     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1576     FIXME("(%p)->(%s)\n", This, debugstr_w(html));
1577     return E_NOTIMPL;
1578 }
1579
1580 static HRESULT WINAPI HTMLTxtRange_moveToElementText(IHTMLTxtRange *iface, IHTMLElement *element)
1581 {
1582     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1583     FIXME("(%p)->(%p)\n", This, element);
1584     return E_NOTIMPL;
1585 }
1586
1587 static HRESULT WINAPI HTMLTxtRange_setEndPoint(IHTMLTxtRange *iface, BSTR how,
1588         IHTMLTxtRange *SourceRange)
1589 {
1590     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1591     FIXME("(%p)->(%s %p)\n", This, debugstr_w(how), SourceRange);
1592     return E_NOTIMPL;
1593 }
1594
1595 static HRESULT WINAPI HTMLTxtRange_compareEndPoints(IHTMLTxtRange *iface, BSTR how,
1596         IHTMLTxtRange *SourceRange, LONG *ret)
1597 {
1598     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1599     HTMLTxtRange *src_range;
1600     PRInt16 nsret = 0;
1601     int nscmpt;
1602     nsresult nsres;
1603
1604     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(how), SourceRange, ret);
1605
1606     nscmpt = string_to_nscmptype(how);
1607     if(nscmpt == -1)
1608         return E_INVALIDARG;
1609
1610     src_range = get_range_object(This->doc, SourceRange);
1611     if(!src_range)
1612         return E_FAIL;
1613
1614     nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, nscmpt, src_range->nsrange, &nsret);
1615     if(NS_FAILED(nsres))
1616         ERR("CompareBoundaryPoints failed: %08x\n", nsres);
1617
1618     *ret = nsret;
1619     return S_OK;
1620 }
1621
1622 static HRESULT WINAPI HTMLTxtRange_findText(IHTMLTxtRange *iface, BSTR String,
1623         LONG count, LONG Flags, VARIANT_BOOL *Success)
1624 {
1625     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1626     FIXME("(%p)->(%s %d %08x %p)\n", This, debugstr_w(String), count, Flags, Success);
1627     return E_NOTIMPL;
1628 }
1629
1630 static HRESULT WINAPI HTMLTxtRange_moveToPoint(IHTMLTxtRange *iface, LONG x, LONG y)
1631 {
1632     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1633     FIXME("(%p)->(%d %d)\n", This, x, y);
1634     return E_NOTIMPL;
1635 }
1636
1637 static HRESULT WINAPI HTMLTxtRange_getBookmark(IHTMLTxtRange *iface, BSTR *Bookmark)
1638 {
1639     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1640     FIXME("(%p)->(%p)\n", This, Bookmark);
1641     return E_NOTIMPL;
1642 }
1643
1644 static HRESULT WINAPI HTMLTxtRange_moveToBookmark(IHTMLTxtRange *iface, BSTR Bookmark,
1645         VARIANT_BOOL *Success)
1646 {
1647     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1648     FIXME("(%p)->(%s %p)\n", This, debugstr_w(Bookmark), Success);
1649     return E_NOTIMPL;
1650 }
1651
1652 static HRESULT WINAPI HTMLTxtRange_queryCommandSupported(IHTMLTxtRange *iface, BSTR cmdID,
1653         VARIANT_BOOL *pfRet)
1654 {
1655     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1656     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1657     return E_NOTIMPL;
1658 }
1659
1660 static HRESULT WINAPI HTMLTxtRange_queryCommandEnabled(IHTMLTxtRange *iface, BSTR cmdID,
1661         VARIANT_BOOL *pfRet)
1662 {
1663     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1664     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1665     return E_NOTIMPL;
1666 }
1667
1668 static HRESULT WINAPI HTMLTxtRange_queryCommandState(IHTMLTxtRange *iface, BSTR cmdID,
1669         VARIANT_BOOL *pfRet)
1670 {
1671     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1672     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1673     return E_NOTIMPL;
1674 }
1675
1676 static HRESULT WINAPI HTMLTxtRange_queryCommandIndeterm(IHTMLTxtRange *iface, BSTR cmdID,
1677         VARIANT_BOOL *pfRet)
1678 {
1679     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1680     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1681     return E_NOTIMPL;
1682 }
1683
1684 static HRESULT WINAPI HTMLTxtRange_queryCommandText(IHTMLTxtRange *iface, BSTR cmdID,
1685         BSTR *pcmdText)
1686 {
1687     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1688     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pcmdText);
1689     return E_NOTIMPL;
1690 }
1691
1692 static HRESULT WINAPI HTMLTxtRange_queryCommandValue(IHTMLTxtRange *iface, BSTR cmdID,
1693         VARIANT *pcmdValue)
1694 {
1695     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1696     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pcmdValue);
1697     return E_NOTIMPL;
1698 }
1699
1700 static HRESULT WINAPI HTMLTxtRange_execCommand(IHTMLTxtRange *iface, BSTR cmdID,
1701         VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
1702 {
1703     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1704     FIXME("(%p)->(%s %x v %p)\n", This, debugstr_w(cmdID), showUI, pfRet);
1705     return E_NOTIMPL;
1706 }
1707
1708 static HRESULT WINAPI HTMLTxtRange_execCommandShowHelp(IHTMLTxtRange *iface, BSTR cmdID,
1709         VARIANT_BOOL *pfRet)
1710 {
1711     HTMLTxtRange *This = impl_from_IHTMLTxtRange(iface);
1712     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1713     return E_NOTIMPL;
1714 }
1715
1716 static const IHTMLTxtRangeVtbl HTMLTxtRangeVtbl = {
1717     HTMLTxtRange_QueryInterface,
1718     HTMLTxtRange_AddRef,
1719     HTMLTxtRange_Release,
1720     HTMLTxtRange_GetTypeInfoCount,
1721     HTMLTxtRange_GetTypeInfo,
1722     HTMLTxtRange_GetIDsOfNames,
1723     HTMLTxtRange_Invoke,
1724     HTMLTxtRange_get_htmlText,
1725     HTMLTxtRange_put_text,
1726     HTMLTxtRange_get_text,
1727     HTMLTxtRange_parentElement,
1728     HTMLTxtRange_duplicate,
1729     HTMLTxtRange_inRange,
1730     HTMLTxtRange_isEqual,
1731     HTMLTxtRange_scrollIntoView,
1732     HTMLTxtRange_collapse,
1733     HTMLTxtRange_expand,
1734     HTMLTxtRange_move,
1735     HTMLTxtRange_moveStart,
1736     HTMLTxtRange_moveEnd,
1737     HTMLTxtRange_select,
1738     HTMLTxtRange_pasteHTML,
1739     HTMLTxtRange_moveToElementText,
1740     HTMLTxtRange_setEndPoint,
1741     HTMLTxtRange_compareEndPoints,
1742     HTMLTxtRange_findText,
1743     HTMLTxtRange_moveToPoint,
1744     HTMLTxtRange_getBookmark,
1745     HTMLTxtRange_moveToBookmark,
1746     HTMLTxtRange_queryCommandSupported,
1747     HTMLTxtRange_queryCommandEnabled,
1748     HTMLTxtRange_queryCommandState,
1749     HTMLTxtRange_queryCommandIndeterm,
1750     HTMLTxtRange_queryCommandText,
1751     HTMLTxtRange_queryCommandValue,
1752     HTMLTxtRange_execCommand,
1753     HTMLTxtRange_execCommandShowHelp
1754 };
1755
1756 static inline HTMLTxtRange *impl_from_IOleCommandTarget(IOleCommandTarget *iface)
1757 {
1758     return CONTAINING_RECORD(iface, HTMLTxtRange, IOleCommandTarget_iface);
1759 }
1760
1761 static HRESULT WINAPI RangeCommandTarget_QueryInterface(IOleCommandTarget *iface, REFIID riid, void **ppv)
1762 {
1763     HTMLTxtRange *This = impl_from_IOleCommandTarget(iface);
1764     return IHTMLTxtRange_QueryInterface(&This->IHTMLTxtRange_iface, riid, ppv);
1765 }
1766
1767 static ULONG WINAPI RangeCommandTarget_AddRef(IOleCommandTarget *iface)
1768 {
1769     HTMLTxtRange *This = impl_from_IOleCommandTarget(iface);
1770     return IHTMLTxtRange_AddRef(&This->IHTMLTxtRange_iface);
1771 }
1772
1773 static ULONG WINAPI RangeCommandTarget_Release(IOleCommandTarget *iface)
1774 {
1775     HTMLTxtRange *This = impl_from_IOleCommandTarget(iface);
1776     return IHTMLTxtRange_Release(&This->IHTMLTxtRange_iface);
1777 }
1778
1779 static HRESULT WINAPI RangeCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
1780         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
1781 {
1782     HTMLTxtRange *This = impl_from_IOleCommandTarget(iface);
1783     FIXME("(%p)->(%s %d %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
1784     return E_NOTIMPL;
1785 }
1786
1787 static HRESULT exec_indent(HTMLTxtRange *This, VARIANT *in, VARIANT *out)
1788 {
1789     nsIDOMHTMLElement *blockquote_elem, *p_elem;
1790     nsIDOMDocumentFragment *fragment;
1791     nsIDOMNode *tmp;
1792
1793     static const PRUnichar blockquoteW[] = {'B','L','O','C','K','Q','U','O','T','E',0};
1794     static const PRUnichar pW[] = {'P',0};
1795
1796     TRACE("(%p)->(%p %p)\n", This, in, out);
1797
1798     if(!This->doc->nsdoc) {
1799         WARN("NULL nsdoc\n");
1800         return E_NOTIMPL;
1801     }
1802
1803     create_nselem(This->doc, blockquoteW, &blockquote_elem);
1804     create_nselem(This->doc, pW, &p_elem);
1805
1806     nsIDOMRange_ExtractContents(This->nsrange, &fragment);
1807     nsIDOMElement_AppendChild(p_elem, (nsIDOMNode*)fragment, &tmp);
1808     nsIDOMDocumentFragment_Release(fragment);
1809     nsIDOMNode_Release(tmp);
1810
1811     nsIDOMElement_AppendChild(blockquote_elem, (nsIDOMNode*)p_elem, &tmp);
1812     nsIDOMElement_Release(p_elem);
1813     nsIDOMNode_Release(tmp);
1814
1815     nsIDOMRange_InsertNode(This->nsrange, (nsIDOMNode*)blockquote_elem);
1816     nsIDOMElement_Release(blockquote_elem);
1817
1818     return S_OK;
1819 }
1820
1821 static HRESULT WINAPI RangeCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
1822         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1823 {
1824     HTMLTxtRange *This = impl_from_IOleCommandTarget(iface);
1825
1826     TRACE("(%p)->(%s %d %x %p %p)\n", This, debugstr_guid(pguidCmdGroup), nCmdID,
1827           nCmdexecopt, pvaIn, pvaOut);
1828
1829     if(pguidCmdGroup && IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
1830         switch(nCmdID) {
1831         case IDM_INDENT:
1832             return exec_indent(This, pvaIn, pvaOut);
1833         default:
1834             FIXME("Unsupported cmdid %d of CGID_MSHTML\n", nCmdID);
1835         }
1836     }else {
1837         FIXME("Unsupported cmd %d of group %s\n", nCmdID, debugstr_guid(pguidCmdGroup));
1838     }
1839
1840     return E_NOTIMPL;
1841 }
1842
1843 static const IOleCommandTargetVtbl OleCommandTargetVtbl = {
1844     RangeCommandTarget_QueryInterface,
1845     RangeCommandTarget_AddRef,
1846     RangeCommandTarget_Release,
1847     RangeCommandTarget_QueryStatus,
1848     RangeCommandTarget_Exec
1849 };
1850
1851 HRESULT HTMLTxtRange_Create(HTMLDocumentNode *doc, nsIDOMRange *nsrange, IHTMLTxtRange **p)
1852 {
1853     HTMLTxtRange *ret;
1854
1855     ret = heap_alloc(sizeof(HTMLTxtRange));
1856     if(!ret)
1857         return E_OUTOFMEMORY;
1858
1859     ret->IHTMLTxtRange_iface.lpVtbl = &HTMLTxtRangeVtbl;
1860     ret->IOleCommandTarget_iface.lpVtbl = &OleCommandTargetVtbl;
1861     ret->ref = 1;
1862
1863     if(nsrange)
1864         nsIDOMRange_AddRef(nsrange);
1865     ret->nsrange = nsrange;
1866
1867     ret->doc = doc;
1868     list_add_head(&doc->range_list, &ret->entry);
1869
1870     *p = &ret->IHTMLTxtRange_iface;
1871     return S_OK;
1872 }
1873
1874 void detach_ranges(HTMLDocumentNode *This)
1875 {
1876     HTMLTxtRange *iter;
1877
1878     LIST_FOR_EACH_ENTRY(iter, &This->range_list, HTMLTxtRange, entry) {
1879         iter->doc = NULL;
1880     }
1881 }