git.oblomov.eu Git - wine/blob - 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 "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winnls.h"
  30 #include "ole2.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/unicode.h"
  34
  35 #include "mshtml_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  38
  39 static const WCHAR brW[] = {'b','r',0};
  40
  41 typedef struct {
  42     const IHTMLTxtRangeVtbl *lpHTMLTxtRangeVtbl;
  43
  44     LONG ref;
  45
  46     nsIDOMRange *nsrange;
  47     HTMLDocument *doc;
  48
  49     struct list entry;
  50 } HTMLTxtRange;
  51
  52 #define HTMLTXTRANGE(x)  ((IHTMLTxtRange*)  &(x)->lpHTMLTxtRangeVtbl)
  53
  54 typedef struct {
  55     WCHAR *buf;
  56     DWORD len;
  57     DWORD size;
  58 } wstrbuf_t;
  59
  60 typedef struct {
  61     PRUint16 type;
  62     nsIDOMNode *node;
  63     PRUint32 off;
  64     nsAString str;
  65     const PRUnichar *p;
  66 } dompos_t;
  67
  68 typedef enum {
  69     RU_UNKNOWN,
  70     RU_CHAR,
  71     RU_WORD,
  72     RU_SENTENCE,
  73     RU_TEXTEDIT
  74 } range_unit_t;
  75
  76 static HTMLTxtRange *get_range_object(HTMLDocument *doc, IHTMLTxtRange *iface)
  77 {
  78     HTMLTxtRange *iter;
  79
  80     LIST_FOR_EACH_ENTRY(iter, &doc->range_list, HTMLTxtRange, entry) {
  81         if(HTMLTXTRANGE(iter) == iface)
  82             return iter;
  83     }
  84
  85     ERR("Could not find range in document\n");
  86     return NULL;
  87 }
  88
  89 static range_unit_t string_to_unit(LPCWSTR str)
  90 {
  91     static const WCHAR characterW[] =
  92         {'c','h','a','r','a','c','t','e','r',0};
  93     static const WCHAR wordW[] =
  94         {'w','o','r','d',0};
  95     static const WCHAR sentenceW[] =
  96         {'s','e','n','t','e','n','c','e',0};
  97     static const WCHAR texteditW[] =
  98         {'t','e','x','t','e','d','i','t',0};
  99
 100     if(!strcmpiW(str, characterW))  return RU_CHAR;
 101     if(!strcmpiW(str, wordW))       return RU_WORD;
 102     if(!strcmpiW(str, sentenceW))   return RU_SENTENCE;
 103     if(!strcmpiW(str, texteditW))   return RU_TEXTEDIT;
 104
 105     return RU_UNKNOWN;
 106 }
 107
 108 static int string_to_nscmptype(LPCWSTR str)
 109 {
 110     static const WCHAR seW[] = {'S','t','a','r','t','T','o','E','n','d',0};
 111     static const WCHAR ssW[] = {'S','t','a','r','t','T','o','S','t','a','r','t',0};
 112     static const WCHAR esW[] = {'E','n','d','T','o','S','t','a','r','t',0};
 113     static const WCHAR eeW[] = {'E','n','d','T','o','E','n','d',0};
 114
 115     if(!strcmpiW(str, seW))  return NS_START_TO_END;
 116     if(!strcmpiW(str, ssW))  return NS_START_TO_START;
 117     if(!strcmpiW(str, esW))  return NS_END_TO_START;
 118     if(!strcmpiW(str, eeW))  return NS_END_TO_END;
 119
 120     return -1;
 121 }
 122
 123 static PRUint16 get_node_type(nsIDOMNode *node)
 124 {
 125     PRUint16 type = 0xfff;
 126
 127     if(node)
 128         nsIDOMNode_GetNodeType(node, &type);
 129
 130     return type;
 131 }
 132
 133 static BOOL is_br_node(nsIDOMNode *node)
 134 {
 135     nsIDOMElement *elem;
 136     nsAString tag_str;
 137     const PRUnichar *tag;
 138     BOOL ret = FALSE;
 139     nsresult nsres;
 140
 141     nsres = nsIDOMNode_QueryInterface(node, &IID_nsIDOMElement, (void**)&elem);
 142     if(NS_FAILED(nsres))
 143         return FALSE;
 144
 145     nsAString_Init(&tag_str, NULL);
 146     nsIDOMElement_GetTagName(elem, &tag_str);
 147     nsIDOMElement_Release(elem);
 148     nsAString_GetData(&tag_str, &tag, 0);
 149
 150     if(!strcmpiW(tag, brW))
 151         ret = TRUE;
 152
 153     nsAString_Finish(&tag_str);
 154
 155     return ret;
 156 }
 157
 158 static inline void wstrbuf_init(wstrbuf_t *buf)
 159 {
 160     buf->len = 0;
 161     buf->size = 16;
 162     buf->buf = mshtml_alloc(buf->size * sizeof(WCHAR));
 163     *buf->buf = 0;
 164 }
 165
 166 static inline void wstrbuf_finish(wstrbuf_t *buf)
 167 {
 168     mshtml_free(buf->buf);
 169 }
 170
 171 static void wstrbuf_append_len(wstrbuf_t *buf, LPCWSTR str, int len)
 172 {
 173     if(buf->len+len >= buf->size) {
 174         buf->size = 2*buf->len+len;
 175         buf->buf = mshtml_realloc(buf->buf, buf->size * sizeof(WCHAR));
 176     }
 177
 178     memcpy(buf->buf+buf->len, str, len*sizeof(WCHAR));
 179     buf->len += len;
 180     buf->buf[buf->len] = 0;
 181 }
 182
 183 static inline void wstrbuf_append(wstrbuf_t *buf, LPCWSTR str)
 184 {
 185     wstrbuf_append_len(buf, str, strlenW(str));
 186 }
 187
 188 static void wstrbuf_append_node(wstrbuf_t *buf, nsIDOMNode *node)
 189 {
 190
 191     switch(get_node_type(node)) {
 192     case TEXT_NODE: {
 193         nsIDOMText *nstext;
 194         nsAString data_str;
 195         const PRUnichar *data;
 196
 197         nsIDOMNode_QueryInterface(node, &IID_nsIDOMText, (void**)&nstext);
 198
 199         nsAString_Init(&data_str, NULL);
 200         nsIDOMText_GetData(nstext, &data_str);
 201         nsAString_GetData(&data_str, &data, NULL);
 202         wstrbuf_append(buf, data);
 203         nsAString_Finish(&data_str);
 204
 205        nsIDOMText_Release(nstext);
 206
 207         break;
 208     }
 209     case ELEMENT_NODE:
 210         if(is_br_node(node)) {
 211             static const WCHAR endlW[] = {'\r','\n'};
 212             wstrbuf_append_len(buf, endlW, 2);
 213         }
 214     }
 215 }
 216
 217 static BOOL fill_nodestr(dompos_t *pos)
 218 {
 219     nsIDOMText *text;
 220     nsresult nsres;
 221
 222     if(pos->type != TEXT_NODE)
 223         return FALSE;
 224
 225     nsres = nsIDOMNode_QueryInterface(pos->node, &IID_nsIDOMText, (void**)&text);
 226     if(NS_FAILED(nsres))
 227         return FALSE;
 228
 229     nsAString_Init(&pos->str, NULL);
 230     nsIDOMText_GetData(text, &pos->str);
 231     nsIDOMText_Release(text);
 232     nsAString_GetData(&pos->str, &pos->p, NULL);
 233
 234     return TRUE;
 235 }
 236
 237 static nsIDOMNode *next_node(nsIDOMNode *iter)
 238 {
 239     nsIDOMNode *ret, *tmp;
 240     nsresult nsres;
 241
 242     if(!iter)
 243         return NULL;
 244
 245     nsres = nsIDOMNode_GetFirstChild(iter, &ret);
 246     if(NS_SUCCEEDED(nsres) && ret)
 247         return ret;
 248
 249     nsIDOMNode_AddRef(iter);
 250
 251     do {
 252         nsres = nsIDOMNode_GetNextSibling(iter, &ret);
 253         if(NS_SUCCEEDED(nsres) && ret) {
 254             nsIDOMNode_Release(iter);
 255             return ret;
 256         }
 257
 258         nsres = nsIDOMNode_GetParentNode(iter, &tmp);
 259         nsIDOMNode_Release(iter);
 260         iter = tmp;
 261     }while(NS_SUCCEEDED(nsres) && iter);
 262
 263     return NULL;
 264 }
 265
 266 static nsIDOMNode *prev_node(HTMLTxtRange *This, nsIDOMNode *iter)
 267 {
 268     nsIDOMNode *ret, *tmp;
 269     nsresult nsres;
 270
 271     if(!iter) {
 272         nsIDOMHTMLDocument *nshtmldoc;
 273         nsIDOMHTMLElement *nselem;
 274         nsIDOMDocument *nsdoc;
 275
 276         nsIWebNavigation_GetDocument(This->doc->nscontainer->navigation, &nsdoc);
 277         nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
 278         nsIDOMDocument_Release(nsdoc);
 279         nsIDOMHTMLDocument_GetBody(nshtmldoc, &nselem);
 280         nsIDOMHTMLDocument_Release(nshtmldoc);
 281
 282         nsIDOMElement_GetLastChild(nselem, &tmp);
 283         if(!tmp)
 284             return (nsIDOMNode*)nselem;
 285
 286         while(tmp) {
 287             ret = tmp;
 288             nsIDOMNode_GetLastChild(ret, &tmp);
 289         }
 290
 291         nsIDOMElement_Release(nselem);
 292
 293         return ret;
 294     }
 295
 296     nsres = nsIDOMNode_GetLastChild(iter, &ret);
 297     if(NS_SUCCEEDED(nsres) && ret)
 298         return ret;
 299
 300     nsIDOMNode_AddRef(iter);
 301
 302     do {
 303         nsres = nsIDOMNode_GetPreviousSibling(iter, &ret);
 304         if(NS_SUCCEEDED(nsres) && ret) {
 305             nsIDOMNode_Release(iter);
 306             return ret;
 307         }
 308
 309         nsres = nsIDOMNode_GetParentNode(iter, &tmp);
 310         nsIDOMNode_Release(iter);
 311         iter = tmp;
 312     }while(NS_SUCCEEDED(nsres) && iter);
 313
 314     return NULL;
 315 }
 316
 317 static nsIDOMNode *get_child_node(nsIDOMNode *node, PRUint32 off)
 318 {
 319     nsIDOMNodeList *node_list;
 320     nsIDOMNode *ret = NULL;
 321
 322     nsIDOMNode_GetChildNodes(node, &node_list);
 323     nsIDOMNodeList_Item(node_list, off, &ret);
 324     nsIDOMNodeList_Release(node_list);
 325
 326     return ret;
 327 }
 328
 329 static void get_cur_pos(HTMLTxtRange *This, BOOL start, dompos_t *pos)
 330 {
 331     nsIDOMNode *node;
 332     PRInt32 off;
 333
 334     pos->p = NULL;
 335
 336     if(!start) {
 337         PRBool collapsed;
 338         nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
 339         start = collapsed;
 340     }
 341
 342     if(start) {
 343         nsIDOMRange_GetStartContainer(This->nsrange, &node);
 344         nsIDOMRange_GetStartOffset(This->nsrange, &off);
 345     }else {
 346         nsIDOMRange_GetEndContainer(This->nsrange, &node);
 347         nsIDOMRange_GetEndOffset(This->nsrange, &off);
 348     }
 349
 350     pos->type = get_node_type(node);
 351     if(pos->type == ELEMENT_NODE) {
 352         if(start) {
 353             pos->node = get_child_node(node, off);
 354             pos->off = 0;
 355         }else {
 356             pos->node = off ? get_child_node(node, off-1) : prev_node(This, node);
 357             pos->off = -1;
 358         }
 359
 360         pos->type = get_node_type(pos->node);
 361         nsIDOMNode_Release(node);
 362     }else if(start) {
 363         pos->node = node;
 364         pos->off = off;
 365     }else if(off) {
 366         pos->node = node;
 367         pos->off = off-1;
 368     }else {
 369         pos->node = prev_node(This, node);
 370         pos->off = -1;
 371         nsIDOMNode_Release(node);
 372     }
 373
 374     if(pos->type == TEXT_NODE)
 375         fill_nodestr(pos);
 376 }
 377
 378 static void set_range_pos(HTMLTxtRange *This, BOOL start, dompos_t *pos)
 379 {
 380     nsresult nsres;
 381
 382     if(start) {
 383         if(pos->type == TEXT_NODE)
 384             nsres = nsIDOMRange_SetStart(This->nsrange, pos->node, pos->off);
 385         else
 386             nsres = nsIDOMRange_SetStartBefore(This->nsrange, pos->node);
 387     }else {
 388         if(pos->type == TEXT_NODE)
 389             nsres = nsIDOMRange_SetEnd(This->nsrange, pos->node, pos->off+1);
 390         else
 391             nsres = nsIDOMRange_SetEndAfter(This->nsrange, pos->node);
 392     }
 393
 394     if(NS_FAILED(nsres))
 395         ERR("failed: %p %08x\n", pos->node, nsres);
 396 }
 397
 398 static inline void dompos_release(dompos_t *pos)
 399 {
 400     if(pos->node)
 401         nsIDOMNode_Release(pos->node);
 402
 403     if(pos->p)
 404         nsAString_Finish(&pos->str);
 405 }
 406
 407 static inline void dompos_addref(dompos_t *pos)
 408 {
 409     if(pos->node)
 410         nsIDOMNode_AddRef(pos->node);
 411
 412     if(pos->type == TEXT_NODE)
 413         fill_nodestr(pos);
 414 }
 415
 416 static void range_to_string(HTMLTxtRange *This, wstrbuf_t *buf)
 417 {
 418     nsIDOMNode *iter, *tmp;
 419     dompos_t start_pos, end_pos;
 420     PRBool collapsed;
 421
 422     nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
 423     if(collapsed) {
 424         wstrbuf_finish(buf);
 425         buf->buf = NULL;
 426         buf->size = 0;
 427         return;
 428     }
 429
 430     get_cur_pos(This, FALSE, &end_pos);
 431     get_cur_pos(This, TRUE, &start_pos);
 432
 433     if(start_pos.type == TEXT_NODE) {
 434         if(start_pos.node == end_pos.node) {
 435             wstrbuf_append_len(buf, start_pos.p+start_pos.off, end_pos.off-start_pos.off+1);
 436             iter = start_pos.node;
 437             nsIDOMNode_AddRef(iter);
 438         }else {
 439             wstrbuf_append(buf, start_pos.p+start_pos.off);
 440             iter = next_node(start_pos.node);
 441         }
 442     }else {
 443         iter = start_pos.node;
 444         nsIDOMNode_AddRef(iter);
 445     }
 446
 447     while(iter != end_pos.node) {
 448         wstrbuf_append_node(buf, iter);
 449         tmp = next_node(iter);
 450         nsIDOMNode_Release(iter);
 451         iter = tmp;
 452     }
 453
 454     nsIDOMNode_AddRef(end_pos.node);
 455
 456     if(start_pos.node != end_pos.node && !is_br_node(end_pos.node))
 457         wstrbuf_append_len(buf, end_pos.p, end_pos.off+1);
 458
 459     nsIDOMNode_Release(iter);
 460     dompos_release(&start_pos);
 461     dompos_release(&end_pos);
 462 }
 463
 464 static WCHAR get_pos_char(const dompos_t *pos)
 465 {
 466     switch(pos->type) {
 467     case TEXT_NODE:
 468         return pos->p[pos->off];
 469     case ELEMENT_NODE:
 470         if(is_br_node(pos->node))
 471             return '\n';
 472     }
 473
 474     return 0;
 475 }
 476
 477 static WCHAR next_char(const dompos_t *pos, dompos_t *new_pos)
 478 {
 479     nsIDOMNode *iter, *tmp;
 480
 481     if(pos->type == TEXT_NODE && pos->off != -1 && pos->p[pos->off+1]) {
 482         *new_pos = *pos;
 483         new_pos->off++;
 484         dompos_addref(new_pos);
 485         return new_pos->p[new_pos->off];
 486     }
 487
 488     iter = next_node(pos->node);
 489     if(!iter)
 490         return 0;
 491
 492     while(1) {
 493         switch(get_node_type(iter)) {
 494         case TEXT_NODE:
 495             new_pos->node = iter;
 496             new_pos->type = TEXT_NODE;
 497             new_pos->off = 0;
 498             fill_nodestr(new_pos);
 499             return *new_pos->p;
 500
 501         case ELEMENT_NODE:
 502             if(!is_br_node(iter))
 503                 break;
 504
 505             new_pos->node = iter;
 506             new_pos->type = ELEMENT_NODE;
 507             new_pos->off = 0;
 508             new_pos->p = NULL;
 509             return '\n';
 510         }
 511
 512         tmp = iter;
 513         iter = next_node(iter);
 514         nsIDOMNode_Release(tmp);
 515
 516         if(!iter)
 517             break;
 518     }
 519
 520     return 0;
 521 }
 522
 523 static WCHAR prev_char(HTMLTxtRange *This, const dompos_t *pos, dompos_t *new_pos)
 524 {
 525     nsIDOMNode *iter, *tmp;
 526
 527     if(pos->type == TEXT_NODE && pos->off > 0) {
 528         *new_pos = *pos;
 529         new_pos->off--;
 530         dompos_addref(new_pos);
 531         return new_pos->p[new_pos->off];
 532     }
 533
 534     iter = prev_node(This, pos->node);
 535     if(!iter)
 536         return 0;
 537
 538     while(1) {
 539         switch(get_node_type(iter)) {
 540         case TEXT_NODE:
 541             new_pos->node = iter;
 542             new_pos->type = TEXT_NODE;
 543             fill_nodestr(new_pos);
 544             new_pos->off = strlenW(new_pos->p)-1;
 545             return new_pos->p[new_pos->off];
 546
 547         case ELEMENT_NODE:
 548             if(!is_br_node(iter))
 549                 break;
 550
 551             new_pos->node = iter;
 552             new_pos->type = ELEMENT_NODE;
 553             new_pos->off = 0;
 554             new_pos->p = NULL;
 555             return '\n';
 556         }
 557
 558         tmp = iter;
 559         iter = prev_node(This, iter);
 560         nsIDOMNode_Release(tmp);
 561
 562         if(!iter)
 563             break;
 564     }
 565
 566     *new_pos = *pos;
 567     dompos_addref(new_pos);
 568     return 0;
 569 }
 570
 571 static long move_next_chars(long cnt, const dompos_t *pos, BOOL col, dompos_t *new_pos)
 572 {
 573     dompos_t iter, tmp;
 574     long ret = 0;
 575     WCHAR c;
 576
 577     if(col)
 578         ret++;
 579
 580     if(ret >= cnt) {
 581         *new_pos = *pos;
 582         dompos_addref(new_pos);
 583         return ret;
 584     }
 585
 586     c = next_char(pos, &iter);
 587     ret++;
 588
 589     while(ret < cnt) {
 590         tmp = iter;
 591         c = next_char(&tmp, &iter);
 592         if(!c) {
 593             iter = tmp;
 594             break;
 595         }
 596         ret++;
 597         dompos_release(&tmp);
 598     }
 599
 600     *new_pos = iter;
 601     return ret;
 602 }
 603
 604 static long move_prev_chars(HTMLTxtRange *This, long cnt, const dompos_t *pos, BOOL end, dompos_t *new_pos)
 605 {
 606     dompos_t iter, tmp;
 607     long ret = 0;
 608     WCHAR c;
 609
 610     c = prev_char(This, pos, &iter);
 611     if(c)
 612         ret++;
 613
 614     while(c && ret < cnt) {
 615         tmp = iter;
 616         c = prev_char(This, &tmp, &iter);
 617         if(!c) {
 618             iter = tmp;
 619             if(end)
 620                 ret++;
 621             break;
 622         }
 623         ret++;
 624         dompos_release(&tmp);
 625     }
 626
 627     *new_pos = iter;
 628     return ret;
 629 }
 630
 631 static BOOL find_next_space(const dompos_t *pos, BOOL first_space, dompos_t *ret)
 632 {
 633     dompos_t iter, tmp;
 634     WCHAR c;
 635
 636     if(first_space) {
 637         c = get_pos_char(pos);
 638         if(c && isspaceW(c)) {
 639             *ret = *pos;
 640             dompos_addref(ret);
 641             return FALSE;
 642         }
 643     }
 644
 645     c = next_char(pos, &iter);
 646     if(!c) {
 647         *ret = *pos;
 648         dompos_addref(ret);
 649         return FALSE;
 650     }
 651
 652     while(!isspaceW(c)) {
 653         tmp = iter;
 654         c = next_char(&tmp, &iter);
 655         if(!c) {
 656             iter = tmp;
 657             break;
 658         }
 659         dompos_release(&tmp);
 660     }
 661
 662     *ret = iter;
 663     return TRUE;
 664 }
 665
 666 static long find_prev_space(HTMLTxtRange *This, const dompos_t *pos, BOOL first_space, dompos_t *ret)
 667 {
 668     dompos_t iter, tmp;
 669     WCHAR c;
 670
 671     c = prev_char(This, pos, &iter);
 672     if(!c || (first_space && isspaceW(c))) {
 673         *ret = *pos;
 674         dompos_addref(ret);
 675         return FALSE;
 676     }
 677
 678     while(1) {
 679         tmp = iter;
 680         c = prev_char(This, &tmp, &iter);
 681         if(!c || isspaceW(c)) {
 682             dompos_release(&iter);
 683             break;
 684         }
 685         dompos_release(&tmp);
 686     }
 687
 688     *ret = tmp;
 689     return TRUE;
 690 }
 691
 692 static long move_next_words(long cnt, const dompos_t *pos, dompos_t *new_pos)
 693 {
 694     dompos_t iter, tmp;
 695     long ret = 0;
 696
 697     iter = *pos;
 698     dompos_addref(&iter);
 699
 700     while(ret < cnt) {
 701         if(!find_next_space(&iter, FALSE, &tmp))
 702             break;
 703
 704         ret++;
 705         dompos_release(&iter);
 706         iter = tmp;
 707     }
 708
 709     *new_pos = iter;
 710     return ret;
 711 }
 712
 713 static long move_prev_words(HTMLTxtRange *This, long cnt, const dompos_t *pos, dompos_t *new_pos)
 714 {
 715     dompos_t iter, tmp;
 716     long ret = 0;
 717
 718     iter = *pos;
 719     dompos_addref(&iter);
 720
 721     while(ret < cnt) {
 722         if(!find_prev_space(This, &iter, FALSE, &tmp))
 723             break;
 724
 725         dompos_release(&iter);
 726         iter = tmp;
 727         ret++;
 728     }
 729
 730     *new_pos = iter;
 731     return ret;
 732 }
 733
 734 #define HTMLTXTRANGE_THIS(iface) DEFINE_THIS(HTMLTxtRange, HTMLTxtRange, iface)
 735
 736 static HRESULT WINAPI HTMLTxtRange_QueryInterface(IHTMLTxtRange *iface, REFIID riid, void **ppv)
 737 {
 738     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 739
 740     *ppv = NULL;
 741
 742     if(IsEqualGUID(&IID_IUnknown, riid)) {
 743         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 744         *ppv = HTMLTXTRANGE(This);
 745     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 746         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 747         *ppv = HTMLTXTRANGE(This);
 748     }else if(IsEqualGUID(&IID_IHTMLTxtRange, riid)) {
 749         TRACE("(%p)->(IID_IHTMLTxtRange %p)\n", This, ppv);
 750         *ppv = HTMLTXTRANGE(This);
 751     }
 752
 753     if(*ppv) {
 754         IUnknown_AddRef((IUnknown*)*ppv);
 755         return S_OK;
 756     }
 757
 758     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 759     return E_NOINTERFACE;
 760 }
 761
 762 static ULONG WINAPI HTMLTxtRange_AddRef(IHTMLTxtRange *iface)
 763 {
 764     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 765     LONG ref = InterlockedIncrement(&This->ref);
 766
 767     TRACE("(%p) ref=%d\n", This, ref);
 768
 769     return ref;
 770 }
 771
 772 static ULONG WINAPI HTMLTxtRange_Release(IHTMLTxtRange *iface)
 773 {
 774     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 775     LONG ref = InterlockedDecrement(&This->ref);
 776
 777     TRACE("(%p) ref=%d\n", This, ref);
 778
 779     if(!ref) {
 780         if(This->nsrange)
 781             nsISelection_Release(This->nsrange);
 782         if(This->doc)
 783             list_remove(&This->entry);
 784         mshtml_free(This);
 785     }
 786
 787     return ref;
 788 }
 789
 790 static HRESULT WINAPI HTMLTxtRange_GetTypeInfoCount(IHTMLTxtRange *iface, UINT *pctinfo)
 791 {
 792     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 793     FIXME("(%p)->(%p)\n", This, pctinfo);
 794     return E_NOTIMPL;
 795 }
 796
 797 static HRESULT WINAPI HTMLTxtRange_GetTypeInfo(IHTMLTxtRange *iface, UINT iTInfo,
 798                                                LCID lcid, ITypeInfo **ppTInfo)
 799 {
 800     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 801     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 802     return E_NOTIMPL;
 803 }
 804
 805 static HRESULT WINAPI HTMLTxtRange_GetIDsOfNames(IHTMLTxtRange *iface, REFIID riid,
 806                                                  LPOLESTR *rgszNames, UINT cNames,
 807                                                  LCID lcid, DISPID *rgDispId)
 808 {
 809     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 810     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 811           lcid, rgDispId);
 812     return E_NOTIMPL;
 813 }
 814
 815 static HRESULT WINAPI HTMLTxtRange_Invoke(IHTMLTxtRange *iface, DISPID dispIdMember,
 816                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 817                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 818 {
 819     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 820     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 821           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI HTMLTxtRange_get_htmlText(IHTMLTxtRange *iface, BSTR *p)
 826 {
 827     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 828
 829     TRACE("(%p)->(%p)\n", This, p);
 830
 831     *p = NULL;
 832
 833     if(This->nsrange) {
 834         nsIDOMDocumentFragment *fragment;
 835         nsresult nsres;
 836
 837         nsres = nsIDOMRange_CloneContents(This->nsrange, &fragment);
 838         if(NS_SUCCEEDED(nsres)) {
 839             const PRUnichar *nstext;
 840             nsAString nsstr;
 841
 842             nsAString_Init(&nsstr, NULL);
 843             nsnode_to_nsstring((nsIDOMNode*)fragment, &nsstr);
 844             nsIDOMDocumentFragment_Release(fragment);
 845
 846             nsAString_GetData(&nsstr, &nstext, NULL);
 847             *p = SysAllocString(nstext);
 848
 849             nsAString_Finish(&nsstr);
 850         }
 851     }
 852
 853     if(!*p) {
 854         const WCHAR emptyW[] = {0};
 855         *p = SysAllocString(emptyW);
 856     }
 857
 858     TRACE("return %s\n", debugstr_w(*p));
 859     return S_OK;
 860 }
 861
 862 static HRESULT WINAPI HTMLTxtRange_put_text(IHTMLTxtRange *iface, BSTR v)
 863 {
 864     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 865     nsIDOMDocument *nsdoc;
 866     nsIDOMText *text_node;
 867     nsAString text_str;
 868     nsresult nsres;
 869
 870     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 871
 872     if(!This->doc)
 873         return MSHTML_E_NODOC;
 874
 875     nsres = nsIWebNavigation_GetDocument(This->doc->nscontainer->navigation, &nsdoc);
 876     if(NS_FAILED(nsres)) {
 877         ERR("GetDocument failed: %08x\n", nsres);
 878         return S_OK;
 879     }
 880
 881     nsAString_Init(&text_str, v);
 882     nsres = nsIDOMDocument_CreateTextNode(nsdoc, &text_str, &text_node);
 883     nsAString_Finish(&text_str);
 884     if(NS_FAILED(nsres)) {
 885         ERR("CreateTextNode failed: %08x\n", nsres);
 886         return S_OK;
 887     }
 888     nsres = nsIDOMRange_DeleteContents(This->nsrange);
 889     if(NS_FAILED(nsres))
 890         ERR("DeleteContents failed: %08x\n", nsres);
 891
 892     nsres = nsIDOMRange_InsertNode(This->nsrange, (nsIDOMNode*)text_node);
 893     if(NS_FAILED(nsres))
 894         ERR("InsertNode failed: %08x\n", nsres);
 895
 896     return S_OK;
 897 }
 898
 899 static HRESULT WINAPI HTMLTxtRange_get_text(IHTMLTxtRange *iface, BSTR *p)
 900 {
 901     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 902     wstrbuf_t buf;
 903
 904     TRACE("(%p)->(%p)\n", This, p);
 905
 906     wstrbuf_init(&buf);
 907     range_to_string(This, &buf);
 908     if(buf.buf)
 909         *p = SysAllocString(buf.buf);
 910     else
 911         *p = NULL;
 912     wstrbuf_finish(&buf);
 913
 914     TRACE("ret %s\n", debugstr_w(*p));
 915     return S_OK;
 916 }
 917
 918 static HRESULT WINAPI HTMLTxtRange_parentElement(IHTMLTxtRange *iface, IHTMLElement **parent)
 919 {
 920     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 921     nsIDOMNode *nsnode, *tmp;
 922     HTMLDOMNode *node;
 923
 924     TRACE("(%p)->(%p)\n", This, parent);
 925
 926     nsIDOMRange_GetCommonAncestorContainer(This->nsrange, &nsnode);
 927     while(nsnode && get_node_type(nsnode) != ELEMENT_NODE) {
 928         nsIDOMNode_GetParentNode(nsnode, &tmp);
 929         nsIDOMNode_Release(nsnode);
 930         nsnode = tmp;
 931     }
 932
 933     if(!nsnode) {
 934         *parent = NULL;
 935         return S_OK;
 936     }
 937
 938     node = get_node(This->doc, nsnode);
 939     nsIDOMNode_Release(nsnode);
 940
 941     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(node), &IID_IHTMLElement, (void**)parent);
 942 }
 943
 944 static HRESULT WINAPI HTMLTxtRange_duplicate(IHTMLTxtRange *iface, IHTMLTxtRange **Duplicate)
 945 {
 946     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 947     nsIDOMRange *nsrange = NULL;
 948
 949     TRACE("(%p)->(%p)\n", This, Duplicate);
 950
 951     nsIDOMRange_CloneRange(This->nsrange, &nsrange);
 952     *Duplicate = HTMLTxtRange_Create(This->doc, nsrange);
 953     nsIDOMRange_Release(nsrange);
 954
 955     return S_OK;
 956 }
 957
 958 static HRESULT WINAPI HTMLTxtRange_inRange(IHTMLTxtRange *iface, IHTMLTxtRange *Range,
 959         VARIANT_BOOL *InRange)
 960 {
 961     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 962     HTMLTxtRange *src_range;
 963     PRInt16 nsret = 0;
 964     nsresult nsres;
 965
 966     TRACE("(%p)->(%p %p)\n", This, Range, InRange);
 967
 968     *InRange = VARIANT_FALSE;
 969
 970     src_range = get_range_object(This->doc, Range);
 971     if(!src_range)
 972         return E_FAIL;
 973
 974     nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_START_TO_START,
 975             src_range->nsrange, &nsret);
 976     if(NS_SUCCEEDED(nsres) && nsret <= 0) {
 977         nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_END_TO_END,
 978                 src_range->nsrange, &nsret);
 979         if(NS_SUCCEEDED(nsres) && nsret >= 0)
 980             *InRange = VARIANT_TRUE;
 981     }
 982
 983     if(NS_FAILED(nsres))
 984         ERR("CompareBoundaryPoints failed: %08x\n", nsres);
 985
 986     return S_OK;
 987 }
 988
 989 static HRESULT WINAPI HTMLTxtRange_isEqual(IHTMLTxtRange *iface, IHTMLTxtRange *Range,
 990         VARIANT_BOOL *IsEqual)
 991 {
 992     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
 993     HTMLTxtRange *src_range;
 994     PRInt16 nsret = 0;
 995     nsresult nsres;
 996
 997     TRACE("(%p)->(%p %p)\n", This, Range, IsEqual);
 998
 999     *IsEqual = VARIANT_FALSE;
1000
1001     src_range = get_range_object(This->doc, Range);
1002     if(!src_range)
1003         return E_FAIL;
1004
1005     nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_START_TO_START,
1006             src_range->nsrange, &nsret);
1007     if(NS_SUCCEEDED(nsres) && !nsret) {
1008         nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, NS_END_TO_END,
1009                 src_range->nsrange, &nsret);
1010         if(NS_SUCCEEDED(nsres) && !nsret)
1011             *IsEqual = VARIANT_TRUE;
1012     }
1013
1014     if(NS_FAILED(nsres))
1015         ERR("CompareBoundaryPoints failed: %08x\n", nsres);
1016
1017     return S_OK;
1018 }
1019
1020 static HRESULT WINAPI HTMLTxtRange_scrollIntoView(IHTMLTxtRange *iface, VARIANT_BOOL fStart)
1021 {
1022     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1023     FIXME("(%p)->(%x)\n", This, fStart);
1024     return E_NOTIMPL;
1025 }
1026
1027 static HRESULT WINAPI HTMLTxtRange_collapse(IHTMLTxtRange *iface, VARIANT_BOOL Start)
1028 {
1029     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1030
1031     TRACE("(%p)->(%x)\n", This, Start);
1032
1033     nsIDOMRange_Collapse(This->nsrange, Start != VARIANT_FALSE);
1034     return S_OK;
1035 }
1036
1037 static HRESULT WINAPI HTMLTxtRange_expand(IHTMLTxtRange *iface, BSTR Unit, VARIANT_BOOL *Success)
1038 {
1039     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1040     range_unit_t unit;
1041
1042     TRACE("(%p)->(%s %p)\n", This, debugstr_w(Unit), Success);
1043
1044     unit = string_to_unit(Unit);
1045     if(unit == RU_UNKNOWN)
1046         return E_INVALIDARG;
1047
1048     switch(unit) {
1049     case RU_WORD: {
1050         dompos_t end_pos, start_pos, new_pos;
1051
1052         *Success = VARIANT_FALSE;
1053
1054         get_cur_pos(This, TRUE, &start_pos);
1055         get_cur_pos(This, FALSE, &end_pos);
1056         if(find_next_space(&end_pos, TRUE, &new_pos)) {
1057             set_range_pos(This, FALSE, &new_pos);
1058             *Success = VARIANT_TRUE;
1059         }
1060         dompos_release(&new_pos);
1061
1062         if(find_prev_space(This, &start_pos, TRUE, &new_pos)) {
1063             set_range_pos(This, TRUE, &new_pos);
1064             *Success = VARIANT_TRUE;
1065         }
1066
1067         dompos_release(&new_pos);
1068         dompos_release(&end_pos);
1069
1070         break;
1071     }
1072     default:
1073         FIXME("Unimplemented unit %s\n", debugstr_w(Unit));
1074     }
1075
1076     return S_OK;
1077 }
1078
1079 static HRESULT WINAPI HTMLTxtRange_move(IHTMLTxtRange *iface, BSTR Unit,
1080         long Count, long *ActualCount)
1081 {
1082     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1083     range_unit_t unit;
1084
1085     TRACE("(%p)->(%s %ld %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1086
1087     unit = string_to_unit(Unit);
1088     if(unit == RU_UNKNOWN)
1089         return E_INVALIDARG;
1090
1091     IHTMLTxtRange_collapse(HTMLTXTRANGE(This), TRUE);
1092
1093     if(!Count) {
1094         *ActualCount = 0;
1095         return S_OK;
1096     }
1097
1098     switch(unit) {
1099     case RU_CHAR: {
1100         dompos_t cur_pos, new_pos;
1101
1102         get_cur_pos(This, TRUE, &cur_pos);
1103
1104         if(Count > 0) {
1105             *ActualCount = move_next_chars(Count, &cur_pos, TRUE, &new_pos);
1106             set_range_pos(This, FALSE, &new_pos);
1107             IHTMLTxtRange_collapse(HTMLTXTRANGE(This), FALSE);
1108             dompos_release(&new_pos);
1109         }else {
1110             *ActualCount = -move_prev_chars(This, -Count, &cur_pos, FALSE, &new_pos);
1111             set_range_pos(This, TRUE, &new_pos);
1112             IHTMLTxtRange_collapse(HTMLTXTRANGE(This), TRUE);
1113             dompos_release(&new_pos);
1114         }
1115
1116         dompos_release(&cur_pos);
1117         break;
1118     }
1119
1120     case RU_WORD: {
1121         dompos_t cur_pos, new_pos;
1122
1123         get_cur_pos(This, TRUE, &cur_pos);
1124
1125         if(Count > 0) {
1126             *ActualCount = move_next_words(Count, &cur_pos, &new_pos);
1127             set_range_pos(This, FALSE, &new_pos);
1128             IHTMLTxtRange_collapse(HTMLTXTRANGE(This), FALSE);
1129             dompos_release(&new_pos);
1130         }else {
1131             *ActualCount = -move_prev_words(This, -Count, &cur_pos, &new_pos);
1132             set_range_pos(This, TRUE, &new_pos);
1133             IHTMLTxtRange_collapse(HTMLTXTRANGE(This), TRUE);
1134             dompos_release(&new_pos);
1135         }
1136
1137         dompos_release(&cur_pos);
1138         break;
1139     }
1140
1141     default:
1142         FIXME("unimplemented unit %s\n", debugstr_w(Unit));
1143     }
1144
1145     TRACE("ret %ld\n", *ActualCount);
1146     return S_OK;
1147 }
1148
1149 static HRESULT WINAPI HTMLTxtRange_moveStart(IHTMLTxtRange *iface, BSTR Unit,
1150         long Count, long *ActualCount)
1151 {
1152     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1153     FIXME("(%p)->(%s %ld %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1154     return E_NOTIMPL;
1155 }
1156
1157 static HRESULT WINAPI HTMLTxtRange_moveEnd(IHTMLTxtRange *iface, BSTR Unit,
1158         long Count, long *ActualCount)
1159 {
1160     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1161     range_unit_t unit;
1162
1163     TRACE("(%p)->(%s %ld %p)\n", This, debugstr_w(Unit), Count, ActualCount);
1164
1165     unit = string_to_unit(Unit);
1166     if(unit == RU_UNKNOWN)
1167         return E_INVALIDARG;
1168
1169     if(!Count) {
1170         *ActualCount = 0;
1171         return S_OK;
1172     }
1173
1174     switch(unit) {
1175     case RU_CHAR: {
1176         dompos_t cur_pos, new_pos;
1177         PRBool collapsed;
1178
1179         get_cur_pos(This, FALSE, &cur_pos);
1180         nsIDOMRange_GetCollapsed(This->nsrange, &collapsed);
1181
1182         if(Count > 0) {
1183             *ActualCount = move_next_chars(Count, &cur_pos, collapsed, &new_pos);
1184             set_range_pos(This, FALSE, &new_pos);
1185         }else {
1186             *ActualCount = -move_prev_chars(This, -Count, &cur_pos, TRUE,  &new_pos);
1187             if(*ActualCount == Count)
1188                 set_range_pos(This, FALSE, &new_pos);
1189             else
1190                 IHTMLTxtRange_collapse(HTMLTXTRANGE(This), TRUE);
1191         }
1192
1193         dompos_release(&cur_pos);
1194         dompos_release(&new_pos);
1195         break;
1196     }
1197
1198     default:
1199         FIXME("unimplemented unit %s\n", debugstr_w(Unit));
1200     }
1201
1202     return S_OK;
1203 }
1204
1205 static HRESULT WINAPI HTMLTxtRange_select(IHTMLTxtRange *iface)
1206 {
1207     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1208
1209     TRACE("(%p)\n", This);
1210
1211     if(This->doc->nscontainer) {
1212         nsIDOMWindow *dom_window = NULL;
1213         nsISelection *nsselection;
1214
1215         nsIWebBrowser_GetContentDOMWindow(This->doc->nscontainer->webbrowser, &dom_window);
1216         nsIDOMWindow_GetSelection(dom_window, &nsselection);
1217         nsIDOMWindow_Release(dom_window);
1218
1219         nsISelection_RemoveAllRanges(nsselection);
1220         nsISelection_AddRange(nsselection, This->nsrange);
1221
1222         nsISelection_Release(nsselection);
1223     }
1224
1225     return S_OK;
1226 }
1227
1228 static HRESULT WINAPI HTMLTxtRange_pasteHTML(IHTMLTxtRange *iface, BSTR html)
1229 {
1230     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1231     FIXME("(%p)->(%s)\n", This, debugstr_w(html));
1232     return E_NOTIMPL;
1233 }
1234
1235 static HRESULT WINAPI HTMLTxtRange_moveToElementText(IHTMLTxtRange *iface, IHTMLElement *element)
1236 {
1237     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1238     FIXME("(%p)->(%p)\n", This, element);
1239     return E_NOTIMPL;
1240 }
1241
1242 static HRESULT WINAPI HTMLTxtRange_setEndPoint(IHTMLTxtRange *iface, BSTR how,
1243         IHTMLTxtRange *SourceRange)
1244 {
1245     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1246     FIXME("(%p)->(%s %p)\n", This, debugstr_w(how), SourceRange);
1247     return E_NOTIMPL;
1248 }
1249
1250 static HRESULT WINAPI HTMLTxtRange_compareEndPoints(IHTMLTxtRange *iface, BSTR how,
1251         IHTMLTxtRange *SourceRange, long *ret)
1252 {
1253     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1254     HTMLTxtRange *src_range;
1255     PRInt16 nsret = 0;
1256     int nscmpt;
1257     nsresult nsres;
1258
1259     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(how), SourceRange, ret);
1260
1261     nscmpt = string_to_nscmptype(how);
1262     if(nscmpt == -1)
1263         return E_INVALIDARG;
1264
1265     src_range = get_range_object(This->doc, SourceRange);
1266     if(!src_range)
1267         return E_FAIL;
1268
1269     nsres = nsIDOMRange_CompareBoundaryPoints(This->nsrange, nscmpt, src_range->nsrange, &nsret);
1270     if(NS_FAILED(nsres))
1271         ERR("CompareBoundaryPoints failed: %08x\n", nsres);
1272
1273     *ret = nsret;
1274     return S_OK;
1275 }
1276
1277 static HRESULT WINAPI HTMLTxtRange_findText(IHTMLTxtRange *iface, BSTR String,
1278         long count, long Flags, VARIANT_BOOL *Success)
1279 {
1280     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1281     FIXME("(%p)->(%s %ld %08lx %p)\n", This, debugstr_w(String), count, Flags, Success);
1282     return E_NOTIMPL;
1283 }
1284
1285 static HRESULT WINAPI HTMLTxtRange_moveToPoint(IHTMLTxtRange *iface, long x, long y)
1286 {
1287     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1288     FIXME("(%p)->(%ld %ld)\n", This, x, y);
1289     return E_NOTIMPL;
1290 }
1291
1292 static HRESULT WINAPI HTMLTxtRange_getBookmark(IHTMLTxtRange *iface, BSTR *Bookmark)
1293 {
1294     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1295     FIXME("(%p)->(%p)\n", This, Bookmark);
1296     return E_NOTIMPL;
1297 }
1298
1299 static HRESULT WINAPI HTMLTxtRange_moveToBookmark(IHTMLTxtRange *iface, BSTR Bookmark,
1300         VARIANT_BOOL *Success)
1301 {
1302     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1303     FIXME("(%p)->(%s %p)\n", This, debugstr_w(Bookmark), Success);
1304     return E_NOTIMPL;
1305 }
1306
1307 static HRESULT WINAPI HTMLTxtRange_queryCommandSupported(IHTMLTxtRange *iface, BSTR cmdID,
1308         VARIANT_BOOL *pfRet)
1309 {
1310     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1311     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1312     return E_NOTIMPL;
1313 }
1314
1315 static HRESULT WINAPI HTMLTxtRange_queryCommandEnabled(IHTMLTxtRange *iface, BSTR cmdID,
1316         VARIANT_BOOL *pfRet)
1317 {
1318     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1319     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1320     return E_NOTIMPL;
1321 }
1322
1323 static HRESULT WINAPI HTMLTxtRange_queryCommandState(IHTMLTxtRange *iface, BSTR cmdID,
1324         VARIANT_BOOL *pfRet)
1325 {
1326     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1327     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1328     return E_NOTIMPL;
1329 }
1330
1331 static HRESULT WINAPI HTMLTxtRange_queryCommandIndeterm(IHTMLTxtRange *iface, BSTR cmdID,
1332         VARIANT_BOOL *pfRet)
1333 {
1334     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1335     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1336     return E_NOTIMPL;
1337 }
1338
1339 static HRESULT WINAPI HTMLTxtRange_queryCommandText(IHTMLTxtRange *iface, BSTR cmdID,
1340         BSTR *pcmdText)
1341 {
1342     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1343     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pcmdText);
1344     return E_NOTIMPL;
1345 }
1346
1347 static HRESULT WINAPI HTMLTxtRange_queryCommandValue(IHTMLTxtRange *iface, BSTR cmdID,
1348         VARIANT *pcmdValue)
1349 {
1350     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1351     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pcmdValue);
1352     return E_NOTIMPL;
1353 }
1354
1355 static HRESULT WINAPI HTMLTxtRange_execCommand(IHTMLTxtRange *iface, BSTR cmdID,
1356         VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
1357 {
1358     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1359     FIXME("(%p)->(%s %x v %p)\n", This, debugstr_w(cmdID), showUI, pfRet);
1360     return E_NOTIMPL;
1361 }
1362
1363 static HRESULT WINAPI HTMLTxtRange_execCommandShowHelp(IHTMLTxtRange *iface, BSTR cmdID,
1364         VARIANT_BOOL *pfRet)
1365 {
1366     HTMLTxtRange *This = HTMLTXTRANGE_THIS(iface);
1367     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1368     return E_NOTIMPL;
1369 }
1370
1371 #undef HTMLTXTRANGE_THIS
1372
1373 static const IHTMLTxtRangeVtbl HTMLTxtRangeVtbl = {
1374     HTMLTxtRange_QueryInterface,
1375     HTMLTxtRange_AddRef,
1376     HTMLTxtRange_Release,
1377     HTMLTxtRange_GetTypeInfoCount,
1378     HTMLTxtRange_GetTypeInfo,
1379     HTMLTxtRange_GetIDsOfNames,
1380     HTMLTxtRange_Invoke,
1381     HTMLTxtRange_get_htmlText,
1382     HTMLTxtRange_put_text,
1383     HTMLTxtRange_get_text,
1384     HTMLTxtRange_parentElement,
1385     HTMLTxtRange_duplicate,
1386     HTMLTxtRange_inRange,
1387     HTMLTxtRange_isEqual,
1388     HTMLTxtRange_scrollIntoView,
1389     HTMLTxtRange_collapse,
1390     HTMLTxtRange_expand,
1391     HTMLTxtRange_move,
1392     HTMLTxtRange_moveStart,
1393     HTMLTxtRange_moveEnd,
1394     HTMLTxtRange_select,
1395     HTMLTxtRange_pasteHTML,
1396     HTMLTxtRange_moveToElementText,
1397     HTMLTxtRange_setEndPoint,
1398     HTMLTxtRange_compareEndPoints,
1399     HTMLTxtRange_findText,
1400     HTMLTxtRange_moveToPoint,
1401     HTMLTxtRange_getBookmark,
1402     HTMLTxtRange_moveToBookmark,
1403     HTMLTxtRange_queryCommandSupported,
1404     HTMLTxtRange_queryCommandEnabled,
1405     HTMLTxtRange_queryCommandState,
1406     HTMLTxtRange_queryCommandIndeterm,
1407     HTMLTxtRange_queryCommandText,
1408     HTMLTxtRange_queryCommandValue,
1409     HTMLTxtRange_execCommand,
1410     HTMLTxtRange_execCommandShowHelp
1411 };
1412
1413 IHTMLTxtRange *HTMLTxtRange_Create(HTMLDocument *doc, nsIDOMRange *nsrange)
1414 {
1415     HTMLTxtRange *ret = mshtml_alloc(sizeof(HTMLTxtRange));
1416
1417     ret->lpHTMLTxtRangeVtbl = &HTMLTxtRangeVtbl;
1418     ret->ref = 1;
1419
1420     if(nsrange)
1421         nsIDOMRange_AddRef(nsrange);
1422     ret->nsrange = nsrange;
1423
1424     ret->doc = doc;
1425     list_add_head(&doc->range_list, &ret->entry);
1426
1427     return HTMLTXTRANGE(ret);
1428 }
1429
1430 void detach_ranges(HTMLDocument *This)
1431 {
1432     HTMLTxtRange *iter;
1433
1434     LIST_FOR_EACH_ENTRY(iter, &This->range_list, HTMLTxtRange, entry) {
1435         iter->doc = NULL;
1436     }
1437 }