dlls/mshtml/htmldoc.c

   1 /*
   2  * Copyright 2005-2009 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 #include <stdio.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "wininet.h"
  28 #include "ole2.h"
  29 #include "perhist.h"
  30 #include "mshtmdid.h"
  31 #include "mshtmcid.h"
  32
  33 #include "wine/debug.h"
  34
  35 #include "mshtml_private.h"
  36 #include "htmlevent.h"
  37 #include "pluginhost.h"
  38 #include "binding.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  41
  42 static HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret);
  43
  44 HRESULT get_doc_elem_by_id(HTMLDocumentNode *doc, const WCHAR *id, HTMLElement **ret)
  45 {
  46     nsIDOMNodeList *nsnode_list;
  47     nsIDOMNode *nsnode = NULL;
  48     nsIDOMElement *nselem;
  49     nsAString id_str;
  50     nsresult nsres;
  51     HRESULT hres;
  52
  53     if(!doc->dom_document) {
  54         WARN("NULL dom_document\n");
  55         return E_UNEXPECTED;
  56     }
  57
  58     nsAString_InitDepend(&id_str, id);
  59     /* get element by id attribute */
  60     nsres = nsIDOMDocument_GetElementById(doc->dom_document, &id_str, &nselem);
  61     if(FAILED(nsres)) {
  62         ERR("GetElementById failed: %08lx\n", nsres);
  63         nsAString_Finish(&id_str);
  64         return E_FAIL;
  65     }
  66
  67     /* get first element by name attribute */
  68     if(doc->html_document) {
  69         nsres = nsIDOMHTMLDocument_GetElementsByName(doc->html_document, &id_str, &nsnode_list);
  70         nsAString_Finish(&id_str);
  71         if(FAILED(nsres)) {
  72             ERR("getElementsByName failed: %08lx\n", nsres);
  73             if(nselem)
  74                 nsIDOMElement_Release(nselem);
  75             return E_FAIL;
  76         }
  77
  78         nsres = nsIDOMNodeList_Item(nsnode_list, 0, &nsnode);
  79         nsIDOMNodeList_Release(nsnode_list);
  80         assert(nsres == NS_OK);
  81     }
  82
  83     if(nsnode && nselem) {
  84         UINT16 pos;
  85
  86         nsres = nsIDOMNode_CompareDocumentPosition(nsnode, (nsIDOMNode*)nselem, &pos);
  87         if(NS_FAILED(nsres)) {
  88             FIXME("CompareDocumentPosition failed: 0x%08lx\n", nsres);
  89             nsIDOMNode_Release(nsnode);
  90             nsIDOMElement_Release(nselem);
  91             return E_FAIL;
  92         }
  93
  94         TRACE("CompareDocumentPosition gave: 0x%x\n", pos);
  95         if(!(pos & (DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS))) {
  96             nsIDOMElement_Release(nselem);
  97             nselem = NULL;
  98         }
  99     }
 100
 101     if(nsnode) {
 102         if(!nselem) {
 103             nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMElement, (void**)&nselem);
 104             assert(nsres == NS_OK);
 105         }
 106         nsIDOMNode_Release(nsnode);
 107     }
 108
 109     if(!nselem) {
 110         *ret = NULL;
 111         return S_OK;
 112     }
 113
 114     hres = get_element(nselem, ret);
 115     nsIDOMElement_Release(nselem);
 116     return hres;
 117 }
 118
 119 UINT get_document_charset(HTMLDocumentNode *doc)
 120 {
 121     nsAString charset_str;
 122     UINT ret = 0;
 123     nsresult nsres;
 124
 125     if(doc->charset)
 126         return doc->charset;
 127
 128     nsAString_Init(&charset_str, NULL);
 129     nsres = nsIDOMDocument_GetCharacterSet(doc->dom_document, &charset_str);
 130     if(NS_SUCCEEDED(nsres)) {
 131         const PRUnichar *charset;
 132
 133         nsAString_GetData(&charset_str, &charset);
 134
 135         if(*charset) {
 136             BSTR str = SysAllocString(charset);
 137             ret = cp_from_charset_string(str);
 138             SysFreeString(str);
 139         }
 140     }else {
 141         ERR("GetCharset failed: %08lx\n", nsres);
 142     }
 143     nsAString_Finish(&charset_str);
 144
 145     if(!ret)
 146         return CP_UTF8;
 147
 148     return doc->charset = ret;
 149 }
 150
 151 typedef struct {
 152     HTMLDOMNode node;
 153     IDOMDocumentType IDOMDocumentType_iface;
 154 } DocumentType;
 155
 156 static inline DocumentType *impl_from_IDOMDocumentType(IDOMDocumentType *iface)
 157 {
 158     return CONTAINING_RECORD(iface, DocumentType, IDOMDocumentType_iface);
 159 }
 160
 161 static HRESULT WINAPI DocumentType_QueryInterface(IDOMDocumentType *iface, REFIID riid, void **ppv)
 162 {
 163     DocumentType *This = impl_from_IDOMDocumentType(iface);
 164
 165     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
 166 }
 167
 168 static ULONG WINAPI DocumentType_AddRef(IDOMDocumentType *iface)
 169 {
 170     DocumentType *This = impl_from_IDOMDocumentType(iface);
 171
 172     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
 173 }
 174
 175 static ULONG WINAPI DocumentType_Release(IDOMDocumentType *iface)
 176 {
 177     DocumentType *This = impl_from_IDOMDocumentType(iface);
 178
 179     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
 180 }
 181
 182 static HRESULT WINAPI DocumentType_GetTypeInfoCount(IDOMDocumentType *iface, UINT *pctinfo)
 183 {
 184     DocumentType *This = impl_from_IDOMDocumentType(iface);
 185
 186     return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
 187 }
 188
 189 static HRESULT WINAPI DocumentType_GetTypeInfo(IDOMDocumentType *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 190 {
 191     DocumentType *This = impl_from_IDOMDocumentType(iface);
 192
 193     return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 194 }
 195
 196 static HRESULT WINAPI DocumentType_GetIDsOfNames(IDOMDocumentType *iface, REFIID riid, LPOLESTR *rgszNames,
 197         UINT cNames, LCID lcid, DISPID *rgDispId)
 198 {
 199     DocumentType *This = impl_from_IDOMDocumentType(iface);
 200
 201     return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 202                                      cNames, lcid, rgDispId);
 203 }
 204
 205 static HRESULT WINAPI DocumentType_Invoke(IDOMDocumentType *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 206         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 207 {
 208     DocumentType *This = impl_from_IDOMDocumentType(iface);
 209
 210     return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 211                               wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 212 }
 213
 214 static HRESULT WINAPI DocumentType_get_name(IDOMDocumentType *iface, BSTR *p)
 215 {
 216     DocumentType *This = impl_from_IDOMDocumentType(iface);
 217     nsAString nsstr;
 218     nsresult nsres;
 219
 220     TRACE("(%p)->(%p)\n", This, p);
 221
 222     nsAString_Init(&nsstr, NULL);
 223     nsres = nsIDOMDocumentType_GetName((nsIDOMDocumentType*)This->node.nsnode, &nsstr);
 224     return return_nsstr(nsres, &nsstr, p);
 225 }
 226
 227 static HRESULT WINAPI DocumentType_get_entities(IDOMDocumentType *iface, IDispatch **p)
 228 {
 229     DocumentType *This = impl_from_IDOMDocumentType(iface);
 230
 231     FIXME("(%p)->(%p)\n", This, p);
 232
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI DocumentType_get_notations(IDOMDocumentType *iface, IDispatch **p)
 237 {
 238     DocumentType *This = impl_from_IDOMDocumentType(iface);
 239
 240     FIXME("(%p)->(%p)\n", This, p);
 241
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI DocumentType_get_publicId(IDOMDocumentType *iface, VARIANT *p)
 246 {
 247     DocumentType *This = impl_from_IDOMDocumentType(iface);
 248
 249     FIXME("(%p)->(%p)\n", This, p);
 250
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT WINAPI DocumentType_get_systemId(IDOMDocumentType *iface, VARIANT *p)
 255 {
 256     DocumentType *This = impl_from_IDOMDocumentType(iface);
 257
 258     FIXME("(%p)->(%p)\n", This, p);
 259
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI DocumentType_get_internalSubset(IDOMDocumentType *iface, VARIANT *p)
 264 {
 265     DocumentType *This = impl_from_IDOMDocumentType(iface);
 266
 267     FIXME("(%p)->(%p)\n", This, p);
 268
 269     return E_NOTIMPL;
 270 }
 271
 272 static const IDOMDocumentTypeVtbl DocumentTypeVtbl = {
 273     DocumentType_QueryInterface,
 274     DocumentType_AddRef,
 275     DocumentType_Release,
 276     DocumentType_GetTypeInfoCount,
 277     DocumentType_GetTypeInfo,
 278     DocumentType_GetIDsOfNames,
 279     DocumentType_Invoke,
 280     DocumentType_get_name,
 281     DocumentType_get_entities,
 282     DocumentType_get_notations,
 283     DocumentType_get_publicId,
 284     DocumentType_get_systemId,
 285     DocumentType_get_internalSubset
 286 };
 287
 288 static inline DocumentType *DocumentType_from_HTMLDOMNode(HTMLDOMNode *iface)
 289 {
 290     return CONTAINING_RECORD(iface, DocumentType, node);
 291 }
 292
 293 static inline DocumentType *DocumentType_from_DispatchEx(DispatchEx *iface)
 294 {
 295     return CONTAINING_RECORD(iface, DocumentType, node.event_target.dispex);
 296 }
 297
 298 static HRESULT DocumentType_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
 299 {
 300     DocumentType *This = DocumentType_from_HTMLDOMNode(iface);
 301
 302     return create_doctype_node(This->node.doc, nsnode, ret);
 303 }
 304
 305 static const cpc_entry_t DocumentType_cpc[] = {{NULL}};
 306
 307 static const NodeImplVtbl DocumentTypeImplVtbl = {
 308     .cpc_entries           = DocumentType_cpc,
 309     .clone                 = DocumentType_clone
 310 };
 311
 312 static void *DocumentType_query_interface(DispatchEx *dispex, REFIID riid)
 313 {
 314     DocumentType *This = DocumentType_from_DispatchEx(dispex);
 315
 316     if(IsEqualGUID(&IID_IDOMDocumentType, riid))
 317         return &This->IDOMDocumentType_iface;
 318
 319     return HTMLDOMNode_query_interface(&This->node.event_target.dispex, riid);
 320 }
 321
 322 static nsISupports *DocumentType_get_gecko_target(DispatchEx *dispex)
 323 {
 324     DocumentType *This = DocumentType_from_DispatchEx(dispex);
 325     return (nsISupports*)This->node.nsnode;
 326 }
 327
 328 static EventTarget *DocumentType_get_parent_event_target(DispatchEx *dispex)
 329 {
 330     DocumentType *This = DocumentType_from_DispatchEx(dispex);
 331     nsIDOMNode *nsnode;
 332     HTMLDOMNode *node;
 333     nsresult nsres;
 334     HRESULT hres;
 335
 336     nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &nsnode);
 337     assert(nsres == NS_OK);
 338     if(!nsnode)
 339         return NULL;
 340
 341     hres = get_node(nsnode, TRUE, &node);
 342     nsIDOMNode_Release(nsnode);
 343     if(FAILED(hres))
 344         return NULL;
 345
 346     return &node->event_target;
 347 }
 348
 349 static IHTMLEventObj *DocumentType_set_current_event(DispatchEx *dispex, IHTMLEventObj *event)
 350 {
 351     DocumentType *This = DocumentType_from_DispatchEx(dispex);
 352     return default_set_current_event(This->node.doc->window, event);
 353 }
 354
 355 static const event_target_vtbl_t DocumentType_event_target_vtbl = {
 356     {
 357         .query_interface     = DocumentType_query_interface,
 358         .destructor          = HTMLDOMNode_destructor,
 359         .traverse            = HTMLDOMNode_traverse,
 360         .unlink              = HTMLDOMNode_unlink
 361     },
 362     .get_gecko_target        = DocumentType_get_gecko_target,
 363     .get_parent_event_target = DocumentType_get_parent_event_target,
 364     .set_current_event       = DocumentType_set_current_event
 365 };
 366
 367 static const tid_t DocumentType_iface_tids[] = {
 368     IDOMDocumentType_tid,
 369     IHTMLDOMNode_tid,
 370     IHTMLDOMNode2_tid,
 371     IHTMLDOMNode3_tid,
 372     0
 373 };
 374
 375 static dispex_static_data_t DocumentType_dispex = {
 376     "DocumentType",
 377     &DocumentType_event_target_vtbl.dispex_vtbl,
 378     DispDOMDocumentType_tid,
 379     DocumentType_iface_tids
 380 };
 381
 382 HRESULT create_doctype_node(HTMLDocumentNode *doc, nsIDOMNode *nsnode, HTMLDOMNode **ret)
 383 {
 384     nsIDOMDocumentType *nsdoctype;
 385     DocumentType *doctype;
 386     nsresult nsres;
 387
 388     if(!(doctype = calloc(1, sizeof(*doctype))))
 389         return E_OUTOFMEMORY;
 390
 391     nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMDocumentType, (void**)&nsdoctype);
 392     assert(nsres == NS_OK);
 393
 394     doctype->node.vtbl = &DocumentTypeImplVtbl;
 395     doctype->IDOMDocumentType_iface.lpVtbl = &DocumentTypeVtbl;
 396     HTMLDOMNode_Init(doc, &doctype->node, (nsIDOMNode*)nsdoctype, &DocumentType_dispex);
 397     nsIDOMDocumentType_Release(nsdoctype);
 398
 399     *ret = &doctype->node;
 400     return S_OK;
 401 }
 402
 403 static inline HTMLDocumentNode *impl_from_IHTMLDocument2(IHTMLDocument2 *iface)
 404 {
 405     return CONTAINING_RECORD(iface, HTMLDocumentNode, IHTMLDocument2_iface);
 406 }
 407
 408 static HRESULT WINAPI HTMLDocument_QueryInterface(IHTMLDocument2 *iface, REFIID riid, void **ppv)
 409 {
 410     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 411
 412     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
 413 }
 414
 415 static ULONG WINAPI HTMLDocument_AddRef(IHTMLDocument2 *iface)
 416 {
 417     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 418
 419     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
 420 }
 421
 422 static ULONG WINAPI HTMLDocument_Release(IHTMLDocument2 *iface)
 423 {
 424     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 425
 426     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
 427 }
 428
 429 static HRESULT WINAPI HTMLDocument_GetTypeInfoCount(IHTMLDocument2 *iface, UINT *pctinfo)
 430 {
 431     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 432
 433     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
 434 }
 435
 436 static HRESULT WINAPI HTMLDocument_GetTypeInfo(IHTMLDocument2 *iface, UINT iTInfo, LCID lcid,
 437         ITypeInfo **ppTInfo)
 438 {
 439     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 440
 441     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 442 }
 443
 444 static HRESULT WINAPI HTMLDocument_GetIDsOfNames(IHTMLDocument2 *iface, REFIID riid, LPOLESTR *rgszNames,
 445         UINT cNames, LCID lcid, DISPID *rgDispId)
 446 {
 447     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 448
 449     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
 450             rgDispId);
 451 }
 452
 453 static HRESULT WINAPI HTMLDocument_Invoke(IHTMLDocument2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 454         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 455 {
 456     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 457
 458     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 459             pDispParams, pVarResult, pExcepInfo, puArgErr);
 460 }
 461
 462 static HRESULT WINAPI HTMLDocument_get_Script(IHTMLDocument2 *iface, IDispatch **p)
 463 {
 464     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 465     HRESULT hres;
 466
 467     TRACE("(%p)->(%p)\n", This, p);
 468
 469     hres = IHTMLDocument7_get_parentWindow(&This->IHTMLDocument7_iface, (IHTMLWindow2**)p);
 470     return hres == S_OK && !*p ? E_PENDING : hres;
 471 }
 472
 473 static HRESULT WINAPI HTMLDocument_get_all(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 474 {
 475     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 476
 477     TRACE("(%p)->(%p)\n", This, p);
 478     *p = create_all_collection(&This->node, FALSE);
 479
 480     return S_OK;
 481 }
 482
 483 static HRESULT WINAPI HTMLDocument_get_body(IHTMLDocument2 *iface, IHTMLElement **p)
 484 {
 485     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 486     nsIDOMElement *nsbody = NULL;
 487     HTMLElement *element;
 488     nsresult nsres;
 489     HRESULT hres;
 490
 491     TRACE("(%p)->(%p)\n", This, p);
 492
 493     if(This->html_document) {
 494         nsres = nsIDOMHTMLDocument_GetBody(This->html_document, (nsIDOMHTMLElement **)&nsbody);
 495         if(NS_FAILED(nsres)) {
 496             TRACE("Could not get body: %08lx\n", nsres);
 497             return E_UNEXPECTED;
 498         }
 499     }else {
 500         nsAString nsnode_name;
 501         nsIDOMDocumentFragment *frag;
 502
 503         nsres = nsIDOMNode_QueryInterface(This->node.nsnode, &IID_nsIDOMDocumentFragment, (void**)&frag);
 504         if(!NS_FAILED(nsres)) {
 505             nsAString_InitDepend(&nsnode_name, L"BODY");
 506             nsIDOMDocumentFragment_QuerySelector(frag, &nsnode_name, &nsbody);
 507             nsAString_Finish(&nsnode_name);
 508             nsIDOMDocumentFragment_Release(frag);
 509         }
 510     }
 511
 512     if(!nsbody) {
 513         *p = NULL;
 514         return S_OK;
 515     }
 516
 517     hres = get_element(nsbody, &element);
 518     nsIDOMElement_Release(nsbody);
 519     if(FAILED(hres))
 520         return hres;
 521
 522     *p = &element->IHTMLElement_iface;
 523     return S_OK;
 524 }
 525
 526 static HRESULT WINAPI HTMLDocument_get_activeElement(IHTMLDocument2 *iface, IHTMLElement **p)
 527 {
 528     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 529     nsIDOMElement *nselem;
 530     HTMLElement *elem;
 531     nsresult nsres;
 532     HRESULT hres;
 533
 534     TRACE("(%p)->(%p)\n", This, p);
 535
 536     if(!This->dom_document) {
 537         *p = NULL;
 538         return S_OK;
 539     }
 540
 541     /*
 542      * NOTE: Gecko may return an active element even if the document is not visible.
 543      * IE returns NULL in this case.
 544      */
 545     nsres = nsIDOMDocument_GetActiveElement(This->dom_document, &nselem);
 546     if(NS_FAILED(nsres)) {
 547         ERR("GetActiveElement failed: %08lx\n", nsres);
 548         return E_FAIL;
 549     }
 550
 551     if(!nselem) {
 552         *p = NULL;
 553         return S_OK;
 554     }
 555
 556     hres = get_element(nselem, &elem);
 557     nsIDOMElement_Release(nselem);
 558     if(FAILED(hres))
 559         return hres;
 560
 561     *p = &elem->IHTMLElement_iface;
 562     return S_OK;
 563 }
 564
 565 static HRESULT WINAPI HTMLDocument_get_images(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 566 {
 567     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 568     nsIDOMHTMLCollection *nscoll = NULL;
 569     nsresult nsres;
 570
 571     TRACE("(%p)->(%p)\n", This, p);
 572
 573     if(!p)
 574         return E_INVALIDARG;
 575
 576     *p = NULL;
 577
 578     if(!This->dom_document) {
 579         WARN("NULL dom_document\n");
 580         return E_UNEXPECTED;
 581     }
 582
 583     if(!This->html_document) {
 584         FIXME("Not implemented for XML document\n");
 585         return E_NOTIMPL;
 586     }
 587
 588     nsres = nsIDOMHTMLDocument_GetImages(This->html_document, &nscoll);
 589     if(NS_FAILED(nsres)) {
 590         ERR("GetImages failed: %08lx\n", nsres);
 591         return E_FAIL;
 592     }
 593
 594     if(nscoll) {
 595         *p = create_collection_from_htmlcol(nscoll, This->document_mode);
 596         nsIDOMHTMLCollection_Release(nscoll);
 597     }
 598
 599     return S_OK;
 600 }
 601
 602 static HRESULT WINAPI HTMLDocument_get_applets(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 603 {
 604     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 605     nsIDOMHTMLCollection *nscoll = NULL;
 606     nsresult nsres;
 607
 608     TRACE("(%p)->(%p)\n", This, p);
 609
 610     if(!p)
 611         return E_INVALIDARG;
 612
 613     *p = NULL;
 614
 615     if(!This->dom_document) {
 616         WARN("NULL dom_document\n");
 617         return E_UNEXPECTED;
 618     }
 619
 620     if(!This->html_document) {
 621         FIXME("Not implemented for XML document\n");
 622         return E_NOTIMPL;
 623     }
 624
 625     nsres = nsIDOMHTMLDocument_GetApplets(This->html_document, &nscoll);
 626     if(NS_FAILED(nsres)) {
 627         ERR("GetApplets failed: %08lx\n", nsres);
 628         return E_FAIL;
 629     }
 630
 631     if(nscoll) {
 632         *p = create_collection_from_htmlcol(nscoll, This->document_mode);
 633         nsIDOMHTMLCollection_Release(nscoll);
 634     }
 635
 636     return S_OK;
 637 }
 638
 639 static HRESULT WINAPI HTMLDocument_get_links(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 640 {
 641     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 642     nsIDOMHTMLCollection *nscoll = NULL;
 643     nsresult nsres;
 644
 645     TRACE("(%p)->(%p)\n", This, p);
 646
 647     if(!p)
 648         return E_INVALIDARG;
 649
 650     *p = NULL;
 651
 652     if(!This->dom_document) {
 653         WARN("NULL dom_document\n");
 654         return E_UNEXPECTED;
 655     }
 656
 657     if(!This->html_document) {
 658         FIXME("Not implemented for XML document\n");
 659         return E_NOTIMPL;
 660     }
 661
 662     nsres = nsIDOMHTMLDocument_GetLinks(This->html_document, &nscoll);
 663     if(NS_FAILED(nsres)) {
 664         ERR("GetLinks failed: %08lx\n", nsres);
 665         return E_FAIL;
 666     }
 667
 668     if(nscoll) {
 669         *p = create_collection_from_htmlcol(nscoll, This->document_mode);
 670         nsIDOMHTMLCollection_Release(nscoll);
 671     }
 672
 673     return S_OK;
 674 }
 675
 676 static HRESULT WINAPI HTMLDocument_get_forms(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 677 {
 678     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 679     nsIDOMHTMLCollection *nscoll = NULL;
 680     nsresult nsres;
 681
 682     TRACE("(%p)->(%p)\n", This, p);
 683
 684     if(!p)
 685         return E_INVALIDARG;
 686
 687     *p = NULL;
 688
 689     if(!This->dom_document) {
 690         WARN("NULL dom_document\n");
 691         return E_UNEXPECTED;
 692     }
 693
 694     if(!This->html_document) {
 695         FIXME("Not implemented for XML document\n");
 696         return E_NOTIMPL;
 697     }
 698
 699     nsres = nsIDOMHTMLDocument_GetForms(This->html_document, &nscoll);
 700     if(NS_FAILED(nsres)) {
 701         ERR("GetForms failed: %08lx\n", nsres);
 702         return E_FAIL;
 703     }
 704
 705     if(nscoll) {
 706         *p = create_collection_from_htmlcol(nscoll, This->document_mode);
 707         nsIDOMHTMLCollection_Release(nscoll);
 708     }
 709
 710     return S_OK;
 711 }
 712
 713 static HRESULT WINAPI HTMLDocument_get_anchors(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 714 {
 715     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 716     nsIDOMHTMLCollection *nscoll = NULL;
 717     nsresult nsres;
 718
 719     TRACE("(%p)->(%p)\n", This, p);
 720
 721     if(!p)
 722         return E_INVALIDARG;
 723
 724     *p = NULL;
 725
 726     if(!This->dom_document) {
 727         WARN("NULL dom_document\n");
 728         return E_UNEXPECTED;
 729     }
 730
 731     if(!This->html_document) {
 732         FIXME("Not implemented for XML document\n");
 733         return E_NOTIMPL;
 734     }
 735
 736     nsres = nsIDOMHTMLDocument_GetAnchors(This->html_document, &nscoll);
 737     if(NS_FAILED(nsres)) {
 738         ERR("GetAnchors failed: %08lx\n", nsres);
 739         return E_FAIL;
 740     }
 741
 742     if(nscoll) {
 743         *p = create_collection_from_htmlcol(nscoll, This->document_mode);
 744         nsIDOMHTMLCollection_Release(nscoll);
 745     }
 746
 747     return S_OK;
 748 }
 749
 750 static HRESULT WINAPI HTMLDocument_put_title(IHTMLDocument2 *iface, BSTR v)
 751 {
 752     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 753     nsAString nsstr;
 754     nsresult nsres;
 755
 756     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 757
 758     if(!This->dom_document) {
 759         WARN("NULL dom_document\n");
 760         return E_UNEXPECTED;
 761     }
 762
 763     nsAString_InitDepend(&nsstr, v);
 764     nsres = nsIDOMDocument_SetTitle(This->dom_document, &nsstr);
 765     nsAString_Finish(&nsstr);
 766     if(NS_FAILED(nsres))
 767         ERR("SetTitle failed: %08lx\n", nsres);
 768
 769     return S_OK;
 770 }
 771
 772 static HRESULT WINAPI HTMLDocument_get_title(IHTMLDocument2 *iface, BSTR *p)
 773 {
 774     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 775     const PRUnichar *ret;
 776     nsAString nsstr;
 777     nsresult nsres;
 778
 779     TRACE("(%p)->(%p)\n", This, p);
 780
 781     if(!This->dom_document) {
 782         WARN("NULL dom_document\n");
 783         return E_UNEXPECTED;
 784     }
 785
 786
 787     nsAString_Init(&nsstr, NULL);
 788     nsres = nsIDOMDocument_GetTitle(This->dom_document, &nsstr);
 789     if (NS_SUCCEEDED(nsres)) {
 790         nsAString_GetData(&nsstr, &ret);
 791         *p = SysAllocString(ret);
 792     }
 793     nsAString_Finish(&nsstr);
 794
 795     if(NS_FAILED(nsres)) {
 796         ERR("GetTitle failed: %08lx\n", nsres);
 797         return E_FAIL;
 798     }
 799
 800     return S_OK;
 801 }
 802
 803 static HRESULT WINAPI HTMLDocument_get_scripts(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 804 {
 805     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 806     nsIDOMHTMLCollection *nscoll = NULL;
 807     nsresult nsres;
 808
 809     TRACE("(%p)->(%p)\n", This, p);
 810
 811     if(!p)
 812         return E_INVALIDARG;
 813
 814     *p = NULL;
 815
 816     if(!This->dom_document) {
 817         WARN("NULL dom_document\n");
 818         return E_UNEXPECTED;
 819     }
 820
 821     if(!This->html_document) {
 822         FIXME("Not implemented for XML document\n");
 823         return E_NOTIMPL;
 824     }
 825
 826     nsres = nsIDOMHTMLDocument_GetScripts(This->html_document, &nscoll);
 827     if(NS_FAILED(nsres)) {
 828         ERR("GetImages failed: %08lx\n", nsres);
 829         return E_FAIL;
 830     }
 831
 832     if(nscoll) {
 833         *p = create_collection_from_htmlcol(nscoll, This->document_mode);
 834         nsIDOMHTMLCollection_Release(nscoll);
 835     }
 836
 837     return S_OK;
 838 }
 839
 840 static HRESULT WINAPI HTMLDocument_put_designMode(IHTMLDocument2 *iface, BSTR v)
 841 {
 842     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 843     HTMLDocumentObj *doc_obj;
 844     HRESULT hres;
 845
 846     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 847
 848     if(wcsicmp(v, L"on")) {
 849         FIXME("Unsupported arg %s\n", debugstr_w(v));
 850         return E_NOTIMPL;
 851     }
 852
 853     doc_obj = This->doc_obj;
 854     IUnknown_AddRef(doc_obj->outer_unk);
 855     hres = setup_edit_mode(doc_obj);
 856     IUnknown_Release(doc_obj->outer_unk);
 857     if(FAILED(hres))
 858         return hres;
 859
 860     call_property_onchanged(&This->cp_container, DISPID_IHTMLDOCUMENT2_DESIGNMODE);
 861     return S_OK;
 862 }
 863
 864 static HRESULT WINAPI HTMLDocument_get_designMode(IHTMLDocument2 *iface, BSTR *p)
 865 {
 866     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 867     FIXME("(%p)->(%p) always returning Off\n", This, p);
 868
 869     if(!p)
 870         return E_INVALIDARG;
 871
 872     *p = SysAllocString(L"Off");
 873
 874     return S_OK;
 875 }
 876
 877 static HRESULT WINAPI HTMLDocument_get_selection(IHTMLDocument2 *iface, IHTMLSelectionObject **p)
 878 {
 879     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 880     nsISelection *nsselection;
 881     nsresult nsres;
 882
 883     TRACE("(%p)->(%p)\n", This, p);
 884
 885     if(!This->html_document) {
 886         FIXME("Not implemented for XML document\n");
 887         return E_NOTIMPL;
 888     }
 889
 890     nsres = nsIDOMHTMLDocument_GetSelection(This->html_document, &nsselection);
 891     if(NS_FAILED(nsres)) {
 892         ERR("GetSelection failed: %08lx\n", nsres);
 893         return E_FAIL;
 894     }
 895
 896     return HTMLSelectionObject_Create(This, nsselection, p);
 897 }
 898
 899 static HRESULT WINAPI HTMLDocument_get_readyState(IHTMLDocument2 *iface, BSTR *p)
 900 {
 901     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 902
 903     TRACE("(%p)->(%p)\n", iface, p);
 904
 905     if(!p)
 906         return E_POINTER;
 907
 908     return get_readystate_string(This->outer_window ? This->outer_window->readystate : 0, p);
 909 }
 910
 911 static HRESULT WINAPI HTMLDocument_get_frames(IHTMLDocument2 *iface, IHTMLFramesCollection2 **p)
 912 {
 913     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 914
 915     TRACE("(%p)->(%p)\n", This, p);
 916
 917     if(!This->outer_window) {
 918         /* Not implemented by IE */
 919         return E_NOTIMPL;
 920     }
 921     return IHTMLWindow2_get_frames(&This->outer_window->base.IHTMLWindow2_iface, p);
 922 }
 923
 924 static HRESULT WINAPI HTMLDocument_get_embeds(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 925 {
 926     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 927     FIXME("(%p)->(%p)\n", This, p);
 928     return E_NOTIMPL;
 929 }
 930
 931 static HRESULT WINAPI HTMLDocument_get_plugins(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 932 {
 933     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 934     FIXME("(%p)->(%p)\n", This, p);
 935     return E_NOTIMPL;
 936 }
 937
 938 static HRESULT WINAPI HTMLDocument_put_alinkColor(IHTMLDocument2 *iface, VARIANT v)
 939 {
 940     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 941     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 942     return E_NOTIMPL;
 943 }
 944
 945 static HRESULT WINAPI HTMLDocument_get_alinkColor(IHTMLDocument2 *iface, VARIANT *p)
 946 {
 947     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 948     FIXME("(%p)->(%p)\n", This, p);
 949     return E_NOTIMPL;
 950 }
 951
 952 static HRESULT WINAPI HTMLDocument_put_bgColor(IHTMLDocument2 *iface, VARIANT v)
 953 {
 954     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 955     IHTMLElement *element = NULL;
 956     IHTMLBodyElement *body;
 957     HRESULT hr;
 958
 959     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 960
 961     hr = IHTMLDocument2_get_body(iface, &element);
 962     if (FAILED(hr))
 963     {
 964         ERR("Failed to get body (0x%08lx)\n", hr);
 965         return hr;
 966     }
 967
 968     if(!element)
 969     {
 970         FIXME("Empty body element.\n");
 971         return hr;
 972     }
 973
 974     hr = IHTMLElement_QueryInterface(element, &IID_IHTMLBodyElement, (void**)&body);
 975     if (SUCCEEDED(hr))
 976     {
 977         hr = IHTMLBodyElement_put_bgColor(body, v);
 978         IHTMLBodyElement_Release(body);
 979     }
 980     IHTMLElement_Release(element);
 981
 982     return hr;
 983 }
 984
 985 static HRESULT WINAPI HTMLDocument_get_bgColor(IHTMLDocument2 *iface, VARIANT *p)
 986 {
 987     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
 988     nsAString nsstr;
 989     nsresult nsres;
 990     HRESULT hres;
 991
 992     TRACE("(%p)->(%p)\n", This, p);
 993
 994     if(!This->dom_document) {
 995         WARN("NULL dom_document\n");
 996         return E_UNEXPECTED;
 997     }
 998
 999     if(!This->html_document) {
1000         FIXME("Not implemented for XML document\n");
1001         return E_NOTIMPL;
1002     }
1003
1004     nsAString_Init(&nsstr, NULL);
1005     nsres = nsIDOMHTMLDocument_GetBgColor(This->html_document, &nsstr);
1006     hres = return_nsstr_variant(nsres, &nsstr, NSSTR_COLOR, p);
1007     if(hres == S_OK && V_VT(p) == VT_BSTR && !V_BSTR(p)) {
1008         TRACE("default #ffffff\n");
1009         if(!(V_BSTR(p) = SysAllocString(L"#ffffff")))
1010             hres = E_OUTOFMEMORY;
1011     }
1012     return hres;
1013 }
1014
1015 static HRESULT WINAPI HTMLDocument_put_fgColor(IHTMLDocument2 *iface, VARIANT v)
1016 {
1017     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1018     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1019     return E_NOTIMPL;
1020 }
1021
1022 static HRESULT WINAPI HTMLDocument_get_fgColor(IHTMLDocument2 *iface, VARIANT *p)
1023 {
1024     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1025     FIXME("(%p)->(%p)\n", This, p);
1026     return E_NOTIMPL;
1027 }
1028
1029 static HRESULT WINAPI HTMLDocument_put_linkColor(IHTMLDocument2 *iface, VARIANT v)
1030 {
1031     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1032     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1033     return E_NOTIMPL;
1034 }
1035
1036 static HRESULT WINAPI HTMLDocument_get_linkColor(IHTMLDocument2 *iface, VARIANT *p)
1037 {
1038     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1039     FIXME("(%p)->(%p)\n", This, p);
1040     return E_NOTIMPL;
1041 }
1042
1043 static HRESULT WINAPI HTMLDocument_put_vlinkColor(IHTMLDocument2 *iface, VARIANT v)
1044 {
1045     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1046     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1047     return E_NOTIMPL;
1048 }
1049
1050 static HRESULT WINAPI HTMLDocument_get_vlinkColor(IHTMLDocument2 *iface, VARIANT *p)
1051 {
1052     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1053     FIXME("(%p)->(%p)\n", This, p);
1054     return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI HTMLDocument_get_referrer(IHTMLDocument2 *iface, BSTR *p)
1058 {
1059     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1060     nsAString nsstr;
1061     nsresult nsres;
1062
1063     TRACE("(%p)->(%p)\n", This, p);
1064
1065     nsAString_InitDepend(&nsstr, NULL);
1066     nsres = nsIDOMDocument_GetReferrer(This->dom_document, &nsstr);
1067     return return_nsstr(nsres, &nsstr, p);
1068 }
1069
1070 static HRESULT WINAPI HTMLDocument_get_location(IHTMLDocument2 *iface, IHTMLLocation **p)
1071 {
1072     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1073
1074     TRACE("(%p)->(%p)\n", This, p);
1075
1076     if(!This->dom_document || !This->window) {
1077         WARN("NULL window\n");
1078         return E_UNEXPECTED;
1079     }
1080
1081     return IHTMLWindow2_get_location(&This->window->base.IHTMLWindow2_iface, p);
1082 }
1083
1084 static HRESULT WINAPI HTMLDocument_get_lastModified(IHTMLDocument2 *iface, BSTR *p)
1085 {
1086     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1087     FIXME("(%p)->(%p)\n", This, p);
1088     return E_NOTIMPL;
1089 }
1090
1091 static HRESULT WINAPI HTMLDocument_put_URL(IHTMLDocument2 *iface, BSTR v)
1092 {
1093     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1094
1095     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1096
1097     if(!This->outer_window) {
1098         FIXME("No window available\n");
1099         return E_FAIL;
1100     }
1101
1102     return navigate_url(This->outer_window, v, This->outer_window->uri, BINDING_NAVIGATED);
1103 }
1104
1105 static HRESULT WINAPI HTMLDocument_get_URL(IHTMLDocument2 *iface, BSTR *p)
1106 {
1107     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1108
1109     TRACE("(%p)->(%p)\n", iface, p);
1110
1111     *p = SysAllocString(This->outer_window && This->outer_window->url ? This->outer_window->url : L"about:blank");
1112     return *p ? S_OK : E_OUTOFMEMORY;
1113 }
1114
1115 static HRESULT WINAPI HTMLDocument_put_domain(IHTMLDocument2 *iface, BSTR v)
1116 {
1117     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1118     nsAString nsstr;
1119     nsresult nsres;
1120
1121     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1122
1123     if(!This->html_document) {
1124         FIXME("Not implemented for XML document\n");
1125         return E_NOTIMPL;
1126     }
1127
1128     nsAString_InitDepend(&nsstr, v);
1129     nsres = nsIDOMHTMLDocument_SetDomain(This->html_document, &nsstr);
1130     nsAString_Finish(&nsstr);
1131     if(NS_FAILED(nsres)) {
1132         ERR("SetDomain failed: %08lx\n", nsres);
1133         return E_INVALIDARG;
1134     }
1135
1136     return S_OK;
1137 }
1138
1139 static HRESULT WINAPI HTMLDocument_get_domain(IHTMLDocument2 *iface, BSTR *p)
1140 {
1141     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1142     nsAString nsstr;
1143     nsresult nsres;
1144
1145     TRACE("(%p)->(%p)\n", This, p);
1146
1147     if(!This->html_document) {
1148         FIXME("Not implemented for XML document\n");
1149         return E_NOTIMPL;
1150     }
1151
1152     if(This->outer_window && !This->outer_window->uri)
1153         return E_FAIL;
1154
1155     nsAString_Init(&nsstr, NULL);
1156     nsres = nsIDOMHTMLDocument_GetDomain(This->html_document, &nsstr);
1157     if(NS_SUCCEEDED(nsres) && This->outer_window && This->outer_window->uri) {
1158         const PRUnichar *str;
1159         HRESULT hres;
1160
1161         nsAString_GetData(&nsstr, &str);
1162         if(!*str) {
1163             TRACE("Gecko returned empty string, fallback to loaded URL.\n");
1164             nsAString_Finish(&nsstr);
1165             hres = IUri_GetHost(This->outer_window->uri, p);
1166             return FAILED(hres) ? hres : S_OK;
1167         }
1168     }
1169
1170     return return_nsstr(nsres, &nsstr, p);
1171 }
1172
1173 static HRESULT WINAPI HTMLDocument_put_cookie(IHTMLDocument2 *iface, BSTR v)
1174 {
1175     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1176     BOOL bret;
1177
1178     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1179
1180     if(!This->outer_window)
1181         return S_OK;
1182
1183     bret = InternetSetCookieExW(This->outer_window->url, NULL, v, 0, 0);
1184     if(!bret) {
1185         FIXME("InternetSetCookieExW failed: %lu\n", GetLastError());
1186         return HRESULT_FROM_WIN32(GetLastError());
1187     }
1188
1189     return S_OK;
1190 }
1191
1192 static HRESULT WINAPI HTMLDocument_get_cookie(IHTMLDocument2 *iface, BSTR *p)
1193 {
1194     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1195     DWORD size;
1196     BOOL bret;
1197
1198     TRACE("(%p)->(%p)\n", This, p);
1199
1200     if(!This->outer_window) {
1201         *p = NULL;
1202         return S_OK;
1203     }
1204
1205     size = 0;
1206     bret = InternetGetCookieExW(This->outer_window->url, NULL, NULL, &size, 0, NULL);
1207     if(!bret && GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
1208         WARN("InternetGetCookieExW failed: %lu\n", GetLastError());
1209         *p = NULL;
1210         return S_OK;
1211     }
1212
1213     if(!size) {
1214         *p = NULL;
1215         return S_OK;
1216     }
1217
1218     *p = SysAllocStringLen(NULL, size/sizeof(WCHAR)-1);
1219     if(!*p)
1220         return E_OUTOFMEMORY;
1221
1222     bret = InternetGetCookieExW(This->outer_window->url, NULL, *p, &size, 0, NULL);
1223     if(!bret) {
1224         ERR("InternetGetCookieExW failed: %lu\n", GetLastError());
1225         return E_FAIL;
1226     }
1227
1228     return S_OK;
1229 }
1230
1231 static HRESULT WINAPI HTMLDocument_put_expando(IHTMLDocument2 *iface, VARIANT_BOOL v)
1232 {
1233     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1234     FIXME("(%p)->(%x)\n", This, v);
1235     return E_NOTIMPL;
1236 }
1237
1238 static HRESULT WINAPI HTMLDocument_get_expando(IHTMLDocument2 *iface, VARIANT_BOOL *p)
1239 {
1240     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1241     FIXME("(%p)->(%p)\n", This, p);
1242     return E_NOTIMPL;
1243 }
1244
1245 static HRESULT WINAPI HTMLDocument_put_charset(IHTMLDocument2 *iface, BSTR v)
1246 {
1247     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1248     FIXME("(%p)->(%s) returning S_OK\n", This, debugstr_w(v));
1249     return S_OK;
1250 }
1251
1252 static HRESULT WINAPI HTMLDocument_get_charset(IHTMLDocument2 *iface, BSTR *p)
1253 {
1254     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1255
1256     TRACE("(%p)->(%p)\n", This, p);
1257
1258     return IHTMLDocument7_get_characterSet(&This->IHTMLDocument7_iface, p);
1259 }
1260
1261 static HRESULT WINAPI HTMLDocument_put_defaultCharset(IHTMLDocument2 *iface, BSTR v)
1262 {
1263     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1264     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1265     return E_NOTIMPL;
1266 }
1267
1268 static HRESULT WINAPI HTMLDocument_get_defaultCharset(IHTMLDocument2 *iface, BSTR *p)
1269 {
1270     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1271
1272     TRACE("(%p)->(%p)\n", This, p);
1273
1274     *p = charset_string_from_cp(GetACP());
1275     return *p ? S_OK : E_OUTOFMEMORY;
1276 }
1277
1278 static HRESULT WINAPI HTMLDocument_get_mimeType(IHTMLDocument2 *iface, BSTR *p)
1279 {
1280     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1281     const PRUnichar *content_type;
1282     nsAString nsstr;
1283     nsresult nsres;
1284     HRESULT hres;
1285
1286     TRACE("(%p)->(%p)\n", This, p);
1287
1288     *p = NULL;
1289
1290     if(This->window && This->window->base.outer_window->readystate == READYSTATE_UNINITIALIZED)
1291         return (*p = SysAllocString(L"")) ? S_OK : E_FAIL;
1292
1293     nsAString_InitDepend(&nsstr, NULL);
1294     nsres = nsIDOMDocument_GetContentType(This->dom_document, &nsstr);
1295     if(NS_FAILED(nsres))
1296         return map_nsresult(nsres);
1297
1298     nsAString_GetData(&nsstr, &content_type);
1299     hres = get_mime_type_display_name(content_type, p);
1300     nsAString_Finish(&nsstr);
1301     return hres;
1302 }
1303
1304 static HRESULT WINAPI HTMLDocument_get_fileSize(IHTMLDocument2 *iface, BSTR *p)
1305 {
1306     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1307     FIXME("(%p)->(%p)\n", This, p);
1308     return E_NOTIMPL;
1309 }
1310
1311 static HRESULT WINAPI HTMLDocument_get_fileCreatedDate(IHTMLDocument2 *iface, BSTR *p)
1312 {
1313     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1314     FIXME("(%p)->(%p)\n", This, p);
1315     return E_NOTIMPL;
1316 }
1317
1318 static HRESULT WINAPI HTMLDocument_get_fileModifiedDate(IHTMLDocument2 *iface, BSTR *p)
1319 {
1320     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1321     FIXME("(%p)->(%p)\n", This, p);
1322     return E_NOTIMPL;
1323 }
1324
1325 static HRESULT WINAPI HTMLDocument_get_fileUpdatedDate(IHTMLDocument2 *iface, BSTR *p)
1326 {
1327     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1328     FIXME("(%p)->(%p)\n", This, p);
1329     return E_NOTIMPL;
1330 }
1331
1332 static HRESULT WINAPI HTMLDocument_get_security(IHTMLDocument2 *iface, BSTR *p)
1333 {
1334     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1335     FIXME("(%p)->(%p)\n", This, p);
1336     return E_NOTIMPL;
1337 }
1338
1339 static HRESULT WINAPI HTMLDocument_get_protocol(IHTMLDocument2 *iface, BSTR *p)
1340 {
1341     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1342     FIXME("(%p)->(%p)\n", This, p);
1343     return E_NOTIMPL;
1344 }
1345
1346 static HRESULT WINAPI HTMLDocument_get_nameProp(IHTMLDocument2 *iface, BSTR *p)
1347 {
1348     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1349     FIXME("(%p)->(%p)\n", This, p);
1350     return E_NOTIMPL;
1351 }
1352
1353 static HRESULT document_write(HTMLDocumentNode *This, SAFEARRAY *psarray, BOOL ln)
1354 {
1355     VARIANT *var, tmp;
1356     JSContext *jsctx;
1357     nsAString nsstr;
1358     ULONG i, argc;
1359     nsresult nsres;
1360     HRESULT hres;
1361
1362     if(!This->dom_document) {
1363         WARN("NULL dom_document\n");
1364         return E_UNEXPECTED;
1365     }
1366
1367     if(!This->html_document) {
1368         FIXME("Not implemented for XML document\n");
1369         return E_NOTIMPL;
1370     }
1371
1372     if (!psarray)
1373         return S_OK;
1374
1375     if(psarray->cDims != 1) {
1376         FIXME("cDims=%d\n", psarray->cDims);
1377         return E_INVALIDARG;
1378     }
1379
1380     hres = SafeArrayAccessData(psarray, (void**)&var);
1381     if(FAILED(hres)) {
1382         WARN("SafeArrayAccessData failed: %08lx\n", hres);
1383         return hres;
1384     }
1385
1386     V_VT(&tmp) = VT_EMPTY;
1387
1388     jsctx = get_context_from_document(This->dom_document);
1389     argc = psarray->rgsabound[0].cElements;
1390     for(i=0; i < argc; i++) {
1391         if(V_VT(var+i) == VT_BSTR) {
1392             nsAString_InitDepend(&nsstr, V_BSTR(var+i));
1393         }else {
1394             hres = VariantChangeTypeEx(&tmp, var+i, MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, VT_BSTR);
1395             if(FAILED(hres)) {
1396                 WARN("Could not convert %s to string\n", debugstr_variant(var+i));
1397                 break;
1398             }
1399             nsAString_InitDepend(&nsstr, V_BSTR(&tmp));
1400         }
1401
1402         if(!ln || i != argc-1)
1403             nsres = nsIDOMHTMLDocument_Write(This->html_document, &nsstr, jsctx);
1404         else
1405             nsres = nsIDOMHTMLDocument_Writeln(This->html_document, &nsstr, jsctx);
1406         nsAString_Finish(&nsstr);
1407         if(V_VT(var+i) != VT_BSTR)
1408             VariantClear(&tmp);
1409         if(NS_FAILED(nsres)) {
1410             ERR("Write failed: %08lx\n", nsres);
1411             hres = E_FAIL;
1412             break;
1413         }
1414     }
1415
1416     SafeArrayUnaccessData(psarray);
1417
1418     return hres;
1419 }
1420
1421 static HRESULT WINAPI HTMLDocument_write(IHTMLDocument2 *iface, SAFEARRAY *psarray)
1422 {
1423     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1424
1425     TRACE("(%p)->(%p)\n", iface, psarray);
1426
1427     return document_write(This, psarray, FALSE);
1428 }
1429
1430 static HRESULT WINAPI HTMLDocument_writeln(IHTMLDocument2 *iface, SAFEARRAY *psarray)
1431 {
1432     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1433
1434     TRACE("(%p)->(%p)\n", This, psarray);
1435
1436     return document_write(This, psarray, TRUE);
1437 }
1438
1439 static HRESULT WINAPI HTMLDocument_open(IHTMLDocument2 *iface, BSTR url, VARIANT name,
1440         VARIANT features, VARIANT replace, IDispatch **pomWindowResult)
1441 {
1442     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1443     nsISupports *tmp;
1444     nsresult nsres;
1445
1446     TRACE("(%p)->(%s %s %s %s %p)\n", This, debugstr_w(url), debugstr_variant(&name),
1447           debugstr_variant(&features), debugstr_variant(&replace), pomWindowResult);
1448
1449     *pomWindowResult = NULL;
1450
1451     if(!This->outer_window)
1452         return E_FAIL;
1453
1454     if(!This->dom_document) {
1455         ERR("!dom_document\n");
1456         return E_NOTIMPL;
1457     }
1458
1459     if(!This->html_document) {
1460         FIXME("Not implemented for XML document\n");
1461         return E_NOTIMPL;
1462     }
1463
1464     if(!url || wcscmp(url, L"text/html") || V_VT(&name) != VT_ERROR
1465        || V_VT(&features) != VT_ERROR || V_VT(&replace) != VT_ERROR)
1466         FIXME("unsupported args\n");
1467
1468     nsres = nsIDOMHTMLDocument_Open(This->html_document, NULL, NULL, NULL,
1469             get_context_from_document(This->dom_document), 0, &tmp);
1470     if(NS_FAILED(nsres)) {
1471         ERR("Open failed: %08lx\n", nsres);
1472         return E_FAIL;
1473     }
1474
1475     if(tmp)
1476         nsISupports_Release(tmp);
1477
1478     *pomWindowResult = (IDispatch*)&This->outer_window->base.IHTMLWindow2_iface;
1479     IHTMLWindow2_AddRef(&This->outer_window->base.IHTMLWindow2_iface);
1480     return S_OK;
1481 }
1482
1483 static HRESULT WINAPI HTMLDocument_close(IHTMLDocument2 *iface)
1484 {
1485     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1486     nsresult nsres;
1487
1488     TRACE("(%p)\n", This);
1489
1490     if(!This->dom_document) {
1491         ERR("!dom_document\n");
1492         return E_NOTIMPL;
1493     }
1494
1495     if(!This->html_document) {
1496         FIXME("Not implemented for XML document\n");
1497         return E_NOTIMPL;
1498     }
1499
1500     nsres = nsIDOMHTMLDocument_Close(This->html_document);
1501     if(NS_FAILED(nsres)) {
1502         ERR("Close failed: %08lx\n", nsres);
1503         return E_FAIL;
1504     }
1505
1506     return S_OK;
1507 }
1508
1509 static HRESULT WINAPI HTMLDocument_clear(IHTMLDocument2 *iface)
1510 {
1511     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1512     nsresult nsres;
1513
1514     TRACE("(%p)\n", This);
1515
1516     if(!This->html_document) {
1517         FIXME("Not implemented for XML document\n");
1518         return E_NOTIMPL;
1519     }
1520
1521     nsres = nsIDOMHTMLDocument_Clear(This->html_document);
1522     if(NS_FAILED(nsres)) {
1523         ERR("Clear failed: %08lx\n", nsres);
1524         return E_FAIL;
1525     }
1526
1527     return S_OK;
1528 }
1529
1530 static const struct {
1531     const WCHAR *name;
1532     OLECMDID id;
1533 }command_names[] = {
1534     {L"copy", IDM_COPY},
1535     {L"cut", IDM_CUT},
1536     {L"fontname", IDM_FONTNAME},
1537     {L"fontsize", IDM_FONTSIZE},
1538     {L"indent", IDM_INDENT},
1539     {L"insertorderedlist", IDM_ORDERLIST},
1540     {L"insertunorderedlist", IDM_UNORDERLIST},
1541     {L"outdent", IDM_OUTDENT},
1542     {L"paste", IDM_PASTE},
1543     {L"respectvisibilityindesign", IDM_RESPECTVISIBILITY_INDESIGN}
1544 };
1545
1546 static BOOL cmdid_from_string(const WCHAR *str, OLECMDID *cmdid)
1547 {
1548     int i;
1549
1550     for(i = 0; i < ARRAY_SIZE(command_names); i++) {
1551         if(!wcsicmp(command_names[i].name, str)) {
1552             *cmdid = command_names[i].id;
1553             return TRUE;
1554         }
1555     }
1556
1557     FIXME("Unknown command %s\n", debugstr_w(str));
1558     return FALSE;
1559 }
1560
1561 static HRESULT WINAPI HTMLDocument_queryCommandSupported(IHTMLDocument2 *iface, BSTR cmdID,
1562         VARIANT_BOOL *pfRet)
1563 {
1564     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1565     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1566     return E_NOTIMPL;
1567 }
1568
1569 static HRESULT WINAPI HTMLDocument_queryCommandEnabled(IHTMLDocument2 *iface, BSTR cmdID,
1570         VARIANT_BOOL *pfRet)
1571 {
1572     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1573     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1574     return E_NOTIMPL;
1575 }
1576
1577 static HRESULT WINAPI HTMLDocument_queryCommandState(IHTMLDocument2 *iface, BSTR cmdID,
1578         VARIANT_BOOL *pfRet)
1579 {
1580     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1581     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1582     return E_NOTIMPL;
1583 }
1584
1585 static HRESULT WINAPI HTMLDocument_queryCommandIndeterm(IHTMLDocument2 *iface, BSTR cmdID,
1586         VARIANT_BOOL *pfRet)
1587 {
1588     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1589     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1590     return E_NOTIMPL;
1591 }
1592
1593 static HRESULT WINAPI HTMLDocument_queryCommandText(IHTMLDocument2 *iface, BSTR cmdID,
1594         BSTR *pfRet)
1595 {
1596     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1597     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1598     return E_NOTIMPL;
1599 }
1600
1601 static HRESULT WINAPI HTMLDocument_queryCommandValue(IHTMLDocument2 *iface, BSTR cmdID,
1602         VARIANT *pfRet)
1603 {
1604     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1605     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1606     return E_NOTIMPL;
1607 }
1608
1609 static HRESULT WINAPI HTMLDocument_execCommand(IHTMLDocument2 *iface, BSTR cmdID,
1610         VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
1611 {
1612     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1613     OLECMDID cmdid;
1614     VARIANT ret;
1615     HRESULT hres;
1616
1617     TRACE("(%p)->(%s %x %s %p)\n", This, debugstr_w(cmdID), showUI, debugstr_variant(&value), pfRet);
1618
1619     if(!cmdid_from_string(cmdID, &cmdid))
1620         return OLECMDERR_E_NOTSUPPORTED;
1621
1622     V_VT(&ret) = VT_EMPTY;
1623     hres = IOleCommandTarget_Exec(&This->IOleCommandTarget_iface, &CGID_MSHTML, cmdid,
1624             showUI ? 0 : OLECMDEXECOPT_DONTPROMPTUSER, &value, &ret);
1625     if(FAILED(hres))
1626         return hres;
1627
1628     if(V_VT(&ret) != VT_EMPTY) {
1629         FIXME("Handle ret %s\n", debugstr_variant(&ret));
1630         VariantClear(&ret);
1631     }
1632
1633     *pfRet = VARIANT_TRUE;
1634     return S_OK;
1635 }
1636
1637 static HRESULT WINAPI HTMLDocument_execCommandShowHelp(IHTMLDocument2 *iface, BSTR cmdID,
1638         VARIANT_BOOL *pfRet)
1639 {
1640     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1641     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1642     return E_NOTIMPL;
1643 }
1644
1645 static HRESULT WINAPI HTMLDocument_createElement(IHTMLDocument2 *iface, BSTR eTag,
1646         IHTMLElement **newElem)
1647 {
1648     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1649     HTMLElement *elem;
1650     HRESULT hres;
1651
1652     TRACE("(%p)->(%s %p)\n", This, debugstr_w(eTag), newElem);
1653
1654     hres = create_element(This, eTag, &elem);
1655     if(FAILED(hres))
1656         return hres;
1657
1658     *newElem = &elem->IHTMLElement_iface;
1659     return S_OK;
1660 }
1661
1662 static HRESULT WINAPI HTMLDocument_put_onhelp(IHTMLDocument2 *iface, VARIANT v)
1663 {
1664     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1665     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1666     return E_NOTIMPL;
1667 }
1668
1669 static HRESULT WINAPI HTMLDocument_get_onhelp(IHTMLDocument2 *iface, VARIANT *p)
1670 {
1671     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1672     FIXME("(%p)->(%p)\n", This, p);
1673     return E_NOTIMPL;
1674 }
1675
1676 static HRESULT WINAPI HTMLDocument_put_onclick(IHTMLDocument2 *iface, VARIANT v)
1677 {
1678     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1679
1680     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1681
1682     return set_doc_event(This, EVENTID_CLICK, &v);
1683 }
1684
1685 static HRESULT WINAPI HTMLDocument_get_onclick(IHTMLDocument2 *iface, VARIANT *p)
1686 {
1687     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1688
1689     TRACE("(%p)->(%p)\n", This, p);
1690
1691     return get_doc_event(This, EVENTID_CLICK, p);
1692 }
1693
1694 static HRESULT WINAPI HTMLDocument_put_ondblclick(IHTMLDocument2 *iface, VARIANT v)
1695 {
1696     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1697
1698     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1699
1700     return set_doc_event(This, EVENTID_DBLCLICK, &v);
1701 }
1702
1703 static HRESULT WINAPI HTMLDocument_get_ondblclick(IHTMLDocument2 *iface, VARIANT *p)
1704 {
1705     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1706
1707     TRACE("(%p)->(%p)\n", This, p);
1708
1709     return get_doc_event(This, EVENTID_DBLCLICK, p);
1710 }
1711
1712 static HRESULT WINAPI HTMLDocument_put_onkeyup(IHTMLDocument2 *iface, VARIANT v)
1713 {
1714     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1715
1716     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1717
1718     return set_doc_event(This, EVENTID_KEYUP, &v);
1719 }
1720
1721 static HRESULT WINAPI HTMLDocument_get_onkeyup(IHTMLDocument2 *iface, VARIANT *p)
1722 {
1723     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1724
1725     TRACE("(%p)->(%p)\n", This, p);
1726
1727     return get_doc_event(This, EVENTID_KEYUP, p);
1728 }
1729
1730 static HRESULT WINAPI HTMLDocument_put_onkeydown(IHTMLDocument2 *iface, VARIANT v)
1731 {
1732     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1733
1734     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1735
1736     return set_doc_event(This, EVENTID_KEYDOWN, &v);
1737 }
1738
1739 static HRESULT WINAPI HTMLDocument_get_onkeydown(IHTMLDocument2 *iface, VARIANT *p)
1740 {
1741     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1742
1743     TRACE("(%p)->(%p)\n", This, p);
1744
1745     return get_doc_event(This, EVENTID_KEYDOWN, p);
1746 }
1747
1748 static HRESULT WINAPI HTMLDocument_put_onkeypress(IHTMLDocument2 *iface, VARIANT v)
1749 {
1750     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1751
1752     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1753
1754     return set_doc_event(This, EVENTID_KEYPRESS, &v);
1755 }
1756
1757 static HRESULT WINAPI HTMLDocument_get_onkeypress(IHTMLDocument2 *iface, VARIANT *p)
1758 {
1759     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1760
1761     TRACE("(%p)->(%p)\n", This, p);
1762
1763     return get_doc_event(This, EVENTID_KEYPRESS, p);
1764 }
1765
1766 static HRESULT WINAPI HTMLDocument_put_onmouseup(IHTMLDocument2 *iface, VARIANT v)
1767 {
1768     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1769
1770     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1771
1772     return set_doc_event(This, EVENTID_MOUSEUP, &v);
1773 }
1774
1775 static HRESULT WINAPI HTMLDocument_get_onmouseup(IHTMLDocument2 *iface, VARIANT *p)
1776 {
1777     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1778
1779     TRACE("(%p)->(%p)\n", This, p);
1780
1781     return get_doc_event(This, EVENTID_MOUSEUP, p);
1782 }
1783
1784 static HRESULT WINAPI HTMLDocument_put_onmousedown(IHTMLDocument2 *iface, VARIANT v)
1785 {
1786     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1787
1788     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1789
1790     return set_doc_event(This, EVENTID_MOUSEDOWN, &v);
1791 }
1792
1793 static HRESULT WINAPI HTMLDocument_get_onmousedown(IHTMLDocument2 *iface, VARIANT *p)
1794 {
1795     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1796
1797     TRACE("(%p)->(%p)\n", This, p);
1798
1799     return get_doc_event(This, EVENTID_MOUSEDOWN, p);
1800 }
1801
1802 static HRESULT WINAPI HTMLDocument_put_onmousemove(IHTMLDocument2 *iface, VARIANT v)
1803 {
1804     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1805
1806     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1807
1808     return set_doc_event(This, EVENTID_MOUSEMOVE, &v);
1809 }
1810
1811 static HRESULT WINAPI HTMLDocument_get_onmousemove(IHTMLDocument2 *iface, VARIANT *p)
1812 {
1813     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1814
1815     TRACE("(%p)->(%p)\n", This, p);
1816
1817     return get_doc_event(This, EVENTID_MOUSEMOVE, p);
1818 }
1819
1820 static HRESULT WINAPI HTMLDocument_put_onmouseout(IHTMLDocument2 *iface, VARIANT v)
1821 {
1822     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1823
1824     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1825
1826     return set_doc_event(This, EVENTID_MOUSEOUT, &v);
1827 }
1828
1829 static HRESULT WINAPI HTMLDocument_get_onmouseout(IHTMLDocument2 *iface, VARIANT *p)
1830 {
1831     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1832
1833     TRACE("(%p)->(%p)\n", This, p);
1834
1835     return get_doc_event(This, EVENTID_MOUSEOUT, p);
1836 }
1837
1838 static HRESULT WINAPI HTMLDocument_put_onmouseover(IHTMLDocument2 *iface, VARIANT v)
1839 {
1840     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1841
1842     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1843
1844     return set_doc_event(This, EVENTID_MOUSEOVER, &v);
1845 }
1846
1847 static HRESULT WINAPI HTMLDocument_get_onmouseover(IHTMLDocument2 *iface, VARIANT *p)
1848 {
1849     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1850
1851     TRACE("(%p)->(%p)\n", This, p);
1852
1853     return get_doc_event(This, EVENTID_MOUSEOVER, p);
1854 }
1855
1856 static HRESULT WINAPI HTMLDocument_put_onreadystatechange(IHTMLDocument2 *iface, VARIANT v)
1857 {
1858     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1859
1860     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1861
1862     return set_doc_event(This, EVENTID_READYSTATECHANGE, &v);
1863 }
1864
1865 static HRESULT WINAPI HTMLDocument_get_onreadystatechange(IHTMLDocument2 *iface, VARIANT *p)
1866 {
1867     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1868
1869     TRACE("(%p)->(%p)\n", This, p);
1870
1871     return get_doc_event(This, EVENTID_READYSTATECHANGE, p);
1872 }
1873
1874 static HRESULT WINAPI HTMLDocument_put_onafterupdate(IHTMLDocument2 *iface, VARIANT v)
1875 {
1876     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1877     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1878     return E_NOTIMPL;
1879 }
1880
1881 static HRESULT WINAPI HTMLDocument_get_onafterupdate(IHTMLDocument2 *iface, VARIANT *p)
1882 {
1883     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1884     FIXME("(%p)->(%p)\n", This, p);
1885     return E_NOTIMPL;
1886 }
1887
1888 static HRESULT WINAPI HTMLDocument_put_onrowexit(IHTMLDocument2 *iface, VARIANT v)
1889 {
1890     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1891     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1892     return E_NOTIMPL;
1893 }
1894
1895 static HRESULT WINAPI HTMLDocument_get_onrowexit(IHTMLDocument2 *iface, VARIANT *p)
1896 {
1897     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1898     FIXME("(%p)->(%p)\n", This, p);
1899     return E_NOTIMPL;
1900 }
1901
1902 static HRESULT WINAPI HTMLDocument_put_onrowenter(IHTMLDocument2 *iface, VARIANT v)
1903 {
1904     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1905     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1906     return E_NOTIMPL;
1907 }
1908
1909 static HRESULT WINAPI HTMLDocument_get_onrowenter(IHTMLDocument2 *iface, VARIANT *p)
1910 {
1911     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1912     FIXME("(%p)->(%p)\n", This, p);
1913     return E_NOTIMPL;
1914 }
1915
1916 static HRESULT WINAPI HTMLDocument_put_ondragstart(IHTMLDocument2 *iface, VARIANT v)
1917 {
1918     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1919
1920     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1921
1922     return set_doc_event(This, EVENTID_DRAGSTART, &v);
1923 }
1924
1925 static HRESULT WINAPI HTMLDocument_get_ondragstart(IHTMLDocument2 *iface, VARIANT *p)
1926 {
1927     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1928
1929     TRACE("(%p)->(%p)\n", This, p);
1930
1931     return get_doc_event(This, EVENTID_DRAGSTART, p);
1932 }
1933
1934 static HRESULT WINAPI HTMLDocument_put_onselectstart(IHTMLDocument2 *iface, VARIANT v)
1935 {
1936     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1937
1938     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1939
1940     return set_doc_event(This, EVENTID_SELECTSTART, &v);
1941 }
1942
1943 static HRESULT WINAPI HTMLDocument_get_onselectstart(IHTMLDocument2 *iface, VARIANT *p)
1944 {
1945     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1946
1947     TRACE("(%p)->(%p)\n", This, p);
1948
1949     return get_doc_event(This, EVENTID_SELECTSTART, p);
1950 }
1951
1952 static HRESULT WINAPI HTMLDocument_elementFromPoint(IHTMLDocument2 *iface, LONG x, LONG y,
1953         IHTMLElement **elementHit)
1954 {
1955     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1956     nsIDOMElement *nselem;
1957     HTMLElement *element;
1958     nsresult nsres;
1959     HRESULT hres;
1960
1961     TRACE("(%p)->(%ld %ld %p)\n", This, x, y, elementHit);
1962
1963     nsres = nsIDOMDocument_ElementFromPoint(This->dom_document, x, y, &nselem);
1964     if(NS_FAILED(nsres)) {
1965         ERR("ElementFromPoint failed: %08lx\n", nsres);
1966         return E_FAIL;
1967     }
1968
1969     if(!nselem) {
1970         *elementHit = NULL;
1971         return S_OK;
1972     }
1973
1974     hres = get_element(nselem, &element);
1975     nsIDOMElement_Release(nselem);
1976     if(FAILED(hres))
1977         return hres;
1978
1979     *elementHit = &element->IHTMLElement_iface;
1980     return S_OK;
1981 }
1982
1983 static HRESULT WINAPI HTMLDocument_get_parentWindow(IHTMLDocument2 *iface, IHTMLWindow2 **p)
1984 {
1985     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1986     HRESULT hres;
1987
1988     TRACE("(%p)->(%p)\n", This, p);
1989
1990     hres = IHTMLDocument7_get_defaultView(&This->IHTMLDocument7_iface, p);
1991     return hres == S_OK && !*p ? E_FAIL : hres;
1992 }
1993
1994 static HRESULT WINAPI HTMLDocument_get_styleSheets(IHTMLDocument2 *iface,
1995         IHTMLStyleSheetsCollection **p)
1996 {
1997     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
1998     nsIDOMStyleSheetList *nsstylelist;
1999     nsresult nsres;
2000     HRESULT hres;
2001
2002     TRACE("(%p)->(%p)\n", This, p);
2003
2004     *p = NULL;
2005
2006     if(!This->dom_document) {
2007         WARN("NULL dom_document\n");
2008         return E_UNEXPECTED;
2009     }
2010
2011     nsres = nsIDOMDocument_GetStyleSheets(This->dom_document, &nsstylelist);
2012     if(NS_FAILED(nsres)) {
2013         ERR("GetStyleSheets failed: %08lx\n", nsres);
2014         return map_nsresult(nsres);
2015     }
2016
2017     hres = create_style_sheet_collection(nsstylelist,
2018                                          dispex_compat_mode(&This->node.event_target.dispex), p);
2019     nsIDOMStyleSheetList_Release(nsstylelist);
2020     return hres;
2021 }
2022
2023 static HRESULT WINAPI HTMLDocument_put_onbeforeupdate(IHTMLDocument2 *iface, VARIANT v)
2024 {
2025     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
2026     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2027     return E_NOTIMPL;
2028 }
2029
2030 static HRESULT WINAPI HTMLDocument_get_onbeforeupdate(IHTMLDocument2 *iface, VARIANT *p)
2031 {
2032     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
2033     FIXME("(%p)->(%p)\n", This, p);
2034     return E_NOTIMPL;
2035 }
2036
2037 static HRESULT WINAPI HTMLDocument_put_onerrorupdate(IHTMLDocument2 *iface, VARIANT v)
2038 {
2039     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
2040     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2041     return E_NOTIMPL;
2042 }
2043
2044 static HRESULT WINAPI HTMLDocument_get_onerrorupdate(IHTMLDocument2 *iface, VARIANT *p)
2045 {
2046     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
2047     FIXME("(%p)->(%p)\n", This, p);
2048     return E_NOTIMPL;
2049 }
2050
2051 static HRESULT WINAPI HTMLDocument_toString(IHTMLDocument2 *iface, BSTR *String)
2052 {
2053     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
2054
2055     TRACE("(%p)->(%p)\n", This, String);
2056
2057     return dispex_to_string(&This->node.event_target.dispex, String);
2058 }
2059
2060 static HRESULT WINAPI HTMLDocument_createStyleSheet(IHTMLDocument2 *iface, BSTR bstrHref,
2061         LONG lIndex, IHTMLStyleSheet **ppnewStyleSheet)
2062 {
2063     HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface);
2064     nsIDOMHTMLHeadElement *head_elem;
2065     IHTMLStyleElement *style_elem;
2066     HTMLElement *elem;
2067     nsresult nsres;
2068     HRESULT hres;
2069
2070     TRACE("(%p)->(%s %ld %p)\n", This, debugstr_w(bstrHref), lIndex, ppnewStyleSheet);
2071
2072     if(!This->dom_document) {
2073         FIXME("not a real doc object\n");
2074         return E_NOTIMPL;
2075     }
2076
2077     if(!This->html_document) {
2078         FIXME("Not implemented for XML document\n");
2079         return E_NOTIMPL;
2080     }
2081
2082     if(lIndex != -1)
2083         FIXME("Unsupported lIndex %ld\n", lIndex);
2084
2085     if(bstrHref && *bstrHref) {
2086         FIXME("semi-stub for href %s\n", debugstr_w(bstrHref));
2087         return create_style_sheet(NULL, dispex_compat_mode(&This->node.event_target.dispex),
2088                                   ppnewStyleSheet);
2089     }
2090
2091     hres = create_element(This, L"style", &elem);
2092     if(FAILED(hres))
2093         return hres;
2094
2095     nsres = nsIDOMHTMLDocument_GetHead(This->html_document, &head_elem);
2096     if(NS_SUCCEEDED(nsres)) {
2097         nsIDOMNode *head_node, *tmp_node;
2098
2099         nsres = nsIDOMHTMLHeadElement_QueryInterface(head_elem, &IID_nsIDOMNode, (void**)&head_node);
2100         nsIDOMHTMLHeadElement_Release(head_elem);
2101         assert(nsres == NS_OK);
2102
2103         nsres = nsIDOMNode_AppendChild(head_node, elem->node.nsnode, &tmp_node);
2104         nsIDOMNode_Release(head_node);
2105         if(NS_SUCCEEDED(nsres) && tmp_node)
2106             nsIDOMNode_Release(tmp_node);
2107     }
2108     if(NS_FAILED(nsres)) {
2109         IHTMLElement_Release(&elem->IHTMLElement_iface);
2110         return E_FAIL;
2111     }
2112
2113     hres = IHTMLElement_QueryInterface(&elem->IHTMLElement_iface, &IID_IHTMLStyleElement, (void**)&style_elem);
2114     assert(hres == S_OK);
2115     IHTMLElement_Release(&elem->IHTMLElement_iface);
2116
2117     hres = IHTMLStyleElement_get_styleSheet(style_elem, ppnewStyleSheet);
2118     IHTMLStyleElement_Release(style_elem);
2119     return hres;
2120 }
2121
2122 static const IHTMLDocument2Vtbl HTMLDocumentVtbl = {
2123     HTMLDocument_QueryInterface,
2124     HTMLDocument_AddRef,
2125     HTMLDocument_Release,
2126     HTMLDocument_GetTypeInfoCount,
2127     HTMLDocument_GetTypeInfo,
2128     HTMLDocument_GetIDsOfNames,
2129     HTMLDocument_Invoke,
2130     HTMLDocument_get_Script,
2131     HTMLDocument_get_all,
2132     HTMLDocument_get_body,
2133     HTMLDocument_get_activeElement,
2134     HTMLDocument_get_images,
2135     HTMLDocument_get_applets,
2136     HTMLDocument_get_links,
2137     HTMLDocument_get_forms,
2138     HTMLDocument_get_anchors,
2139     HTMLDocument_put_title,
2140     HTMLDocument_get_title,
2141     HTMLDocument_get_scripts,
2142     HTMLDocument_put_designMode,
2143     HTMLDocument_get_designMode,
2144     HTMLDocument_get_selection,
2145     HTMLDocument_get_readyState,
2146     HTMLDocument_get_frames,
2147     HTMLDocument_get_embeds,
2148     HTMLDocument_get_plugins,
2149     HTMLDocument_put_alinkColor,
2150     HTMLDocument_get_alinkColor,
2151     HTMLDocument_put_bgColor,
2152     HTMLDocument_get_bgColor,
2153     HTMLDocument_put_fgColor,
2154     HTMLDocument_get_fgColor,
2155     HTMLDocument_put_linkColor,
2156     HTMLDocument_get_linkColor,
2157     HTMLDocument_put_vlinkColor,
2158     HTMLDocument_get_vlinkColor,
2159     HTMLDocument_get_referrer,
2160     HTMLDocument_get_location,
2161     HTMLDocument_get_lastModified,
2162     HTMLDocument_put_URL,
2163     HTMLDocument_get_URL,
2164     HTMLDocument_put_domain,
2165     HTMLDocument_get_domain,
2166     HTMLDocument_put_cookie,
2167     HTMLDocument_get_cookie,
2168     HTMLDocument_put_expando,
2169     HTMLDocument_get_expando,
2170     HTMLDocument_put_charset,
2171     HTMLDocument_get_charset,
2172     HTMLDocument_put_defaultCharset,
2173     HTMLDocument_get_defaultCharset,
2174     HTMLDocument_get_mimeType,
2175     HTMLDocument_get_fileSize,
2176     HTMLDocument_get_fileCreatedDate,
2177     HTMLDocument_get_fileModifiedDate,
2178     HTMLDocument_get_fileUpdatedDate,
2179     HTMLDocument_get_security,
2180     HTMLDocument_get_protocol,
2181     HTMLDocument_get_nameProp,
2182     HTMLDocument_write,
2183     HTMLDocument_writeln,
2184     HTMLDocument_open,
2185     HTMLDocument_close,
2186     HTMLDocument_clear,
2187     HTMLDocument_queryCommandSupported,
2188     HTMLDocument_queryCommandEnabled,
2189     HTMLDocument_queryCommandState,
2190     HTMLDocument_queryCommandIndeterm,
2191     HTMLDocument_queryCommandText,
2192     HTMLDocument_queryCommandValue,
2193     HTMLDocument_execCommand,
2194     HTMLDocument_execCommandShowHelp,
2195     HTMLDocument_createElement,
2196     HTMLDocument_put_onhelp,
2197     HTMLDocument_get_onhelp,
2198     HTMLDocument_put_onclick,
2199     HTMLDocument_get_onclick,
2200     HTMLDocument_put_ondblclick,
2201     HTMLDocument_get_ondblclick,
2202     HTMLDocument_put_onkeyup,
2203     HTMLDocument_get_onkeyup,
2204     HTMLDocument_put_onkeydown,
2205     HTMLDocument_get_onkeydown,
2206     HTMLDocument_put_onkeypress,
2207     HTMLDocument_get_onkeypress,
2208     HTMLDocument_put_onmouseup,
2209     HTMLDocument_get_onmouseup,
2210     HTMLDocument_put_onmousedown,
2211     HTMLDocument_get_onmousedown,
2212     HTMLDocument_put_onmousemove,
2213     HTMLDocument_get_onmousemove,
2214     HTMLDocument_put_onmouseout,
2215     HTMLDocument_get_onmouseout,
2216     HTMLDocument_put_onmouseover,
2217     HTMLDocument_get_onmouseover,
2218     HTMLDocument_put_onreadystatechange,
2219     HTMLDocument_get_onreadystatechange,
2220     HTMLDocument_put_onafterupdate,
2221     HTMLDocument_get_onafterupdate,
2222     HTMLDocument_put_onrowexit,
2223     HTMLDocument_get_onrowexit,
2224     HTMLDocument_put_onrowenter,
2225     HTMLDocument_get_onrowenter,
2226     HTMLDocument_put_ondragstart,
2227     HTMLDocument_get_ondragstart,
2228     HTMLDocument_put_onselectstart,
2229     HTMLDocument_get_onselectstart,
2230     HTMLDocument_elementFromPoint,
2231     HTMLDocument_get_parentWindow,
2232     HTMLDocument_get_styleSheets,
2233     HTMLDocument_put_onbeforeupdate,
2234     HTMLDocument_get_onbeforeupdate,
2235     HTMLDocument_put_onerrorupdate,
2236     HTMLDocument_get_onerrorupdate,
2237     HTMLDocument_toString,
2238     HTMLDocument_createStyleSheet
2239 };
2240
2241 static inline HTMLDocumentNode *impl_from_IHTMLDocument3(IHTMLDocument3 *iface)
2242 {
2243     return CONTAINING_RECORD(iface, HTMLDocumentNode, IHTMLDocument3_iface);
2244 }
2245
2246 static HRESULT WINAPI HTMLDocument3_QueryInterface(IHTMLDocument3 *iface, REFIID riid, void **ppv)
2247 {
2248     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2249     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
2250 }
2251
2252 static ULONG WINAPI HTMLDocument3_AddRef(IHTMLDocument3 *iface)
2253 {
2254     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2255     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
2256 }
2257
2258 static ULONG WINAPI HTMLDocument3_Release(IHTMLDocument3 *iface)
2259 {
2260     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2261     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
2262 }
2263
2264 static HRESULT WINAPI HTMLDocument3_GetTypeInfoCount(IHTMLDocument3 *iface, UINT *pctinfo)
2265 {
2266     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2267     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
2268 }
2269
2270 static HRESULT WINAPI HTMLDocument3_GetTypeInfo(IHTMLDocument3 *iface, UINT iTInfo, LCID lcid,
2271         ITypeInfo **ppTInfo)
2272 {
2273     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2274     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2275 }
2276
2277 static HRESULT WINAPI HTMLDocument3_GetIDsOfNames(IHTMLDocument3 *iface, REFIID riid, LPOLESTR *rgszNames,
2278         UINT cNames, LCID lcid, DISPID *rgDispId)
2279 {
2280     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2281     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId);
2282 }
2283
2284 static HRESULT WINAPI HTMLDocument3_Invoke(IHTMLDocument3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
2285         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2286 {
2287     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2288     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2289             pDispParams, pVarResult, pExcepInfo, puArgErr);
2290 }
2291
2292 static HRESULT WINAPI HTMLDocument3_releaseCapture(IHTMLDocument3 *iface)
2293 {
2294     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2295     FIXME("(%p)\n", This);
2296     return E_NOTIMPL;
2297 }
2298
2299 static HRESULT WINAPI HTMLDocument3_recalc(IHTMLDocument3 *iface, VARIANT_BOOL fForce)
2300 {
2301     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2302
2303     WARN("(%p)->(%x)\n", This, fForce);
2304
2305     /* Doing nothing here should be fine for us. */
2306     return S_OK;
2307 }
2308
2309 static HRESULT WINAPI HTMLDocument3_createTextNode(IHTMLDocument3 *iface, BSTR text, IHTMLDOMNode **newTextNode)
2310 {
2311     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2312     nsIDOMText *nstext;
2313     HTMLDOMNode *node;
2314     nsAString text_str;
2315     nsresult nsres;
2316     HRESULT hres;
2317
2318     TRACE("(%p)->(%s %p)\n", This, debugstr_w(text), newTextNode);
2319
2320     if(!This->dom_document) {
2321         WARN("NULL dom_document\n");
2322         return E_UNEXPECTED;
2323     }
2324
2325     nsAString_InitDepend(&text_str, text);
2326     nsres = nsIDOMDocument_CreateTextNode(This->dom_document, &text_str, &nstext);
2327     nsAString_Finish(&text_str);
2328     if(NS_FAILED(nsres)) {
2329         ERR("CreateTextNode failed: %08lx\n", nsres);
2330         return E_FAIL;
2331     }
2332
2333     hres = HTMLDOMTextNode_Create(This, (nsIDOMNode*)nstext, &node);
2334     nsIDOMText_Release(nstext);
2335     if(FAILED(hres))
2336         return hres;
2337
2338     *newTextNode = &node->IHTMLDOMNode_iface;
2339     return S_OK;
2340 }
2341
2342 static HRESULT WINAPI HTMLDocument3_get_documentElement(IHTMLDocument3 *iface, IHTMLElement **p)
2343 {
2344     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2345     nsIDOMElement *nselem = NULL;
2346     HTMLElement *element;
2347     nsresult nsres;
2348     HRESULT hres;
2349
2350     TRACE("(%p)->(%p)\n", This, p);
2351
2352     if(This->outer_window && This->outer_window->readystate == READYSTATE_UNINITIALIZED) {
2353         *p = NULL;
2354         return S_OK;
2355     }
2356
2357     if(!This->dom_document) {
2358         WARN("NULL dom_document\n");
2359         return E_UNEXPECTED;
2360     }
2361
2362     nsres = nsIDOMDocument_GetDocumentElement(This->dom_document, &nselem);
2363     if(NS_FAILED(nsres)) {
2364         ERR("GetDocumentElement failed: %08lx\n", nsres);
2365         return E_FAIL;
2366     }
2367
2368     if(!nselem) {
2369         *p = NULL;
2370         return S_OK;
2371     }
2372
2373     hres = get_element(nselem, &element);
2374     nsIDOMElement_Release(nselem);
2375     if(FAILED(hres))
2376         return hres;
2377
2378     *p = &element->IHTMLElement_iface;
2379     return hres;
2380 }
2381
2382 static HRESULT WINAPI HTMLDocument3_get_uniqueID(IHTMLDocument3 *iface, BSTR *p)
2383 {
2384     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2385
2386     TRACE("(%p)->(%p)\n", This, p);
2387
2388     return elem_unique_id(++This->unique_id, p);
2389 }
2390
2391 static HRESULT WINAPI HTMLDocument3_attachEvent(IHTMLDocument3 *iface, BSTR event, IDispatch* pDisp,
2392         VARIANT_BOOL *pfResult)
2393 {
2394     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2395
2396     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
2397
2398     return attach_event(&This->node.event_target, event, pDisp, pfResult);
2399 }
2400
2401 static HRESULT WINAPI HTMLDocument3_detachEvent(IHTMLDocument3 *iface, BSTR event, IDispatch *pDisp)
2402 {
2403     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2404
2405     TRACE("(%p)->(%s %p)\n", This, debugstr_w(event), pDisp);
2406
2407     return detach_event(&This->node.event_target, event, pDisp);
2408 }
2409
2410 static HRESULT WINAPI HTMLDocument3_put_onrowsdelete(IHTMLDocument3 *iface, VARIANT v)
2411 {
2412     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2413     FIXME("(%p)->()\n", This);
2414     return E_NOTIMPL;
2415 }
2416
2417 static HRESULT WINAPI HTMLDocument3_get_onrowsdelete(IHTMLDocument3 *iface, VARIANT *p)
2418 {
2419     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2420     FIXME("(%p)->(%p)\n", This, p);
2421     return E_NOTIMPL;
2422 }
2423
2424 static HRESULT WINAPI HTMLDocument3_put_onrowsinserted(IHTMLDocument3 *iface, VARIANT v)
2425 {
2426     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2427     FIXME("(%p)->()\n", This);
2428     return E_NOTIMPL;
2429 }
2430
2431 static HRESULT WINAPI HTMLDocument3_get_onrowsinserted(IHTMLDocument3 *iface, VARIANT *p)
2432 {
2433     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2434     FIXME("(%p)->(%p)\n", This, p);
2435     return E_NOTIMPL;
2436 }
2437
2438 static HRESULT WINAPI HTMLDocument3_put_oncellchange(IHTMLDocument3 *iface, VARIANT v)
2439 {
2440     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2441     FIXME("(%p)->()\n", This);
2442     return E_NOTIMPL;
2443 }
2444
2445 static HRESULT WINAPI HTMLDocument3_get_oncellchange(IHTMLDocument3 *iface, VARIANT *p)
2446 {
2447     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2448     FIXME("(%p)->(%p)\n", This, p);
2449     return E_NOTIMPL;
2450 }
2451
2452 static HRESULT WINAPI HTMLDocument3_put_ondatasetchanged(IHTMLDocument3 *iface, VARIANT v)
2453 {
2454     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2455     FIXME("(%p)->()\n", This);
2456     return E_NOTIMPL;
2457 }
2458
2459 static HRESULT WINAPI HTMLDocument3_get_ondatasetchanged(IHTMLDocument3 *iface, VARIANT *p)
2460 {
2461     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2462     FIXME("(%p)->(%p)\n", This, p);
2463     return E_NOTIMPL;
2464 }
2465
2466 static HRESULT WINAPI HTMLDocument3_put_ondataavailable(IHTMLDocument3 *iface, VARIANT v)
2467 {
2468     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2469     FIXME("(%p)->()\n", This);
2470     return E_NOTIMPL;
2471 }
2472
2473 static HRESULT WINAPI HTMLDocument3_get_ondataavailable(IHTMLDocument3 *iface, VARIANT *p)
2474 {
2475     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2476     FIXME("(%p)->(%p)\n", This, p);
2477     return E_NOTIMPL;
2478 }
2479
2480 static HRESULT WINAPI HTMLDocument3_put_ondatasetcomplete(IHTMLDocument3 *iface, VARIANT v)
2481 {
2482     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2483     FIXME("(%p)->()\n", This);
2484     return E_NOTIMPL;
2485 }
2486
2487 static HRESULT WINAPI HTMLDocument3_get_ondatasetcomplete(IHTMLDocument3 *iface, VARIANT *p)
2488 {
2489     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2490     FIXME("(%p)->(%p)\n", This, p);
2491     return E_NOTIMPL;
2492 }
2493
2494 static HRESULT WINAPI HTMLDocument3_put_onpropertychange(IHTMLDocument3 *iface, VARIANT v)
2495 {
2496     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2497     FIXME("(%p)->()\n", This);
2498     return E_NOTIMPL;
2499 }
2500
2501 static HRESULT WINAPI HTMLDocument3_get_onpropertychange(IHTMLDocument3 *iface, VARIANT *p)
2502 {
2503     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2504     FIXME("(%p)->(%p)\n", This, p);
2505     return E_NOTIMPL;
2506 }
2507
2508 static HRESULT WINAPI HTMLDocument3_put_dir(IHTMLDocument3 *iface, BSTR v)
2509 {
2510     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2511     nsAString dir_str;
2512     nsresult nsres;
2513
2514     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2515
2516     if(!This->dom_document) {
2517         FIXME("NULL dom_document\n");
2518         return E_UNEXPECTED;
2519     }
2520
2521     nsAString_InitDepend(&dir_str, v);
2522     nsres = nsIDOMDocument_SetDir(This->dom_document, &dir_str);
2523     nsAString_Finish(&dir_str);
2524     if(NS_FAILED(nsres)) {
2525         ERR("SetDir failed: %08lx\n", nsres);
2526         return E_FAIL;
2527     }
2528
2529     return S_OK;
2530 }
2531
2532 static HRESULT WINAPI HTMLDocument3_get_dir(IHTMLDocument3 *iface, BSTR *p)
2533 {
2534     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2535     nsAString dir_str;
2536     nsresult nsres;
2537
2538     TRACE("(%p)->(%p)\n", This, p);
2539
2540     if(!This->dom_document) {
2541         FIXME("NULL dom_document\n");
2542         return E_UNEXPECTED;
2543     }
2544
2545     nsAString_Init(&dir_str, NULL);
2546     nsres = nsIDOMDocument_GetDir(This->dom_document, &dir_str);
2547     return return_nsstr(nsres, &dir_str, p);
2548 }
2549
2550 static HRESULT WINAPI HTMLDocument3_put_oncontextmenu(IHTMLDocument3 *iface, VARIANT v)
2551 {
2552     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2553
2554     TRACE("(%p)->()\n", This);
2555
2556     return set_doc_event(This, EVENTID_CONTEXTMENU, &v);
2557 }
2558
2559 static HRESULT WINAPI HTMLDocument3_get_oncontextmenu(IHTMLDocument3 *iface, VARIANT *p)
2560 {
2561     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2562
2563     TRACE("(%p)->(%p)\n", This, p);
2564
2565     return get_doc_event(This, EVENTID_CONTEXTMENU, p);
2566 }
2567
2568 static HRESULT WINAPI HTMLDocument3_put_onstop(IHTMLDocument3 *iface, VARIANT v)
2569 {
2570     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2571     FIXME("(%p)->()\n", This);
2572     return E_NOTIMPL;
2573 }
2574
2575 static HRESULT WINAPI HTMLDocument3_get_onstop(IHTMLDocument3 *iface, VARIANT *p)
2576 {
2577     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2578     FIXME("(%p)->(%p)\n", This, p);
2579     return E_NOTIMPL;
2580 }
2581
2582 static HRESULT WINAPI HTMLDocument3_createDocumentFragment(IHTMLDocument3 *iface, IHTMLDocument2 **ppNewDoc)
2583 {
2584     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2585     nsIDOMDocumentFragment *doc_frag;
2586     HTMLDocumentNode *docnode;
2587     nsresult nsres;
2588     HRESULT hres;
2589
2590     TRACE("(%p)->(%p)\n", This, ppNewDoc);
2591
2592     if(!This->dom_document) {
2593         FIXME("NULL dom_document\n");
2594         return E_NOTIMPL;
2595     }
2596
2597     nsres = nsIDOMDocument_CreateDocumentFragment(This->dom_document, &doc_frag);
2598     if(NS_FAILED(nsres)) {
2599         ERR("CreateDocumentFragment failed: %08lx\n", nsres);
2600         return E_FAIL;
2601     }
2602
2603     hres = create_document_fragment((nsIDOMNode*)doc_frag, This, &docnode);
2604     nsIDOMDocumentFragment_Release(doc_frag);
2605     if(FAILED(hres))
2606         return hres;
2607
2608     *ppNewDoc = &docnode->IHTMLDocument2_iface;
2609     return S_OK;
2610 }
2611
2612 static HRESULT WINAPI HTMLDocument3_get_parentDocument(IHTMLDocument3 *iface, IHTMLDocument2 **p)
2613 {
2614     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2615     FIXME("(%p)->(%p)\n", This, p);
2616     return E_NOTIMPL;
2617 }
2618
2619 static HRESULT WINAPI HTMLDocument3_put_enableDownload(IHTMLDocument3 *iface, VARIANT_BOOL v)
2620 {
2621     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2622     FIXME("(%p)->(%x)\n", This, v);
2623     return E_NOTIMPL;
2624 }
2625
2626 static HRESULT WINAPI HTMLDocument3_get_enableDownload(IHTMLDocument3 *iface, VARIANT_BOOL *p)
2627 {
2628     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2629     FIXME("(%p)->(%p)\n", This, p);
2630     return E_NOTIMPL;
2631 }
2632
2633 static HRESULT WINAPI HTMLDocument3_put_baseUrl(IHTMLDocument3 *iface, BSTR v)
2634 {
2635     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2636     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2637     return E_NOTIMPL;
2638 }
2639
2640 static HRESULT WINAPI HTMLDocument3_get_baseUrl(IHTMLDocument3 *iface, BSTR *p)
2641 {
2642     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2643     FIXME("(%p)->(%p)\n", This, p);
2644     return E_NOTIMPL;
2645 }
2646
2647 static HRESULT WINAPI HTMLDocument3_get_childNodes(IHTMLDocument3 *iface, IDispatch **p)
2648 {
2649     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2650
2651     TRACE("(%p)->(%p)\n", This, p);
2652
2653     return IHTMLDOMNode_get_childNodes(&This->node.IHTMLDOMNode_iface, p);
2654 }
2655
2656 static HRESULT WINAPI HTMLDocument3_put_inheritStyleSheets(IHTMLDocument3 *iface, VARIANT_BOOL v)
2657 {
2658     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2659     FIXME("(%p)->()\n", This);
2660     return E_NOTIMPL;
2661 }
2662
2663 static HRESULT WINAPI HTMLDocument3_get_inheritStyleSheets(IHTMLDocument3 *iface, VARIANT_BOOL *p)
2664 {
2665     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2666     FIXME("(%p)->(%p)\n", This, p);
2667     return E_NOTIMPL;
2668 }
2669
2670 static HRESULT WINAPI HTMLDocument3_put_onbeforeeditfocus(IHTMLDocument3 *iface, VARIANT v)
2671 {
2672     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2673     FIXME("(%p)->()\n", This);
2674     return E_NOTIMPL;
2675 }
2676
2677 static HRESULT WINAPI HTMLDocument3_get_onbeforeeditfocus(IHTMLDocument3 *iface, VARIANT *p)
2678 {
2679     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2680     FIXME("(%p)->(%p)\n", This, p);
2681     return E_NOTIMPL;
2682 }
2683
2684 static HRESULT WINAPI HTMLDocument3_getElementsByName(IHTMLDocument3 *iface, BSTR v,
2685         IHTMLElementCollection **ppelColl)
2686 {
2687     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2688     nsIDOMNodeList *node_list = NULL;
2689     nsAString selector_str;
2690     WCHAR *selector;
2691     nsresult nsres;
2692     static const WCHAR formatW[] = L"*[id=%s],*[name=%s]";
2693
2694     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), ppelColl);
2695
2696     if(!This->dom_document) {
2697         /* We should probably return an empty collection. */
2698         FIXME("No dom_document\n");
2699         return E_NOTIMPL;
2700     }
2701
2702     selector = malloc(2 * SysStringLen(v) * sizeof(WCHAR) + sizeof(formatW));
2703     if(!selector)
2704         return E_OUTOFMEMORY;
2705     swprintf(selector, 2*SysStringLen(v) + ARRAY_SIZE(formatW), formatW, v, v);
2706
2707     /*
2708      * NOTE: IE getElementsByName implementation differs from Gecko. It searches both name and id attributes.
2709      * That's why we use CSS selector instead. We should also use name only when it applies to given element
2710      * types and search should be case insensitive. Those are currently not supported properly.
2711      */
2712     nsAString_InitDepend(&selector_str, selector);
2713     nsres = nsIDOMDocument_QuerySelectorAll(This->dom_document, &selector_str, &node_list);
2714     nsAString_Finish(&selector_str);
2715     free(selector);
2716     if(NS_FAILED(nsres)) {
2717         ERR("QuerySelectorAll failed: %08lx\n", nsres);
2718         if(node_list)
2719             nsIDOMNodeList_Release(node_list);
2720         return E_FAIL;
2721     }
2722
2723     *ppelColl = create_collection_from_nodelist(node_list, This->document_mode);
2724     nsIDOMNodeList_Release(node_list);
2725     return S_OK;
2726 }
2727
2728
2729 static HRESULT WINAPI HTMLDocument3_getElementById(IHTMLDocument3 *iface, BSTR v, IHTMLElement **pel)
2730 {
2731     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2732     HTMLElement *elem;
2733     HRESULT hres;
2734
2735     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
2736
2737     hres = get_doc_elem_by_id(This, v, &elem);
2738     if(FAILED(hres) || !elem) {
2739         *pel = NULL;
2740         return hres;
2741     }
2742
2743     *pel = &elem->IHTMLElement_iface;
2744     return S_OK;
2745 }
2746
2747
2748 static HRESULT WINAPI HTMLDocument3_getElementsByTagName(IHTMLDocument3 *iface, BSTR v,
2749         IHTMLElementCollection **pelColl)
2750 {
2751     HTMLDocumentNode *This = impl_from_IHTMLDocument3(iface);
2752     nsIDOMNodeList *nslist;
2753     nsAString id_str;
2754     nsresult nsres;
2755
2756     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pelColl);
2757
2758     if(This->dom_document) {
2759         nsAString_InitDepend(&id_str, v);
2760         nsres = nsIDOMDocument_GetElementsByTagName(This->dom_document, &id_str, &nslist);
2761         nsAString_Finish(&id_str);
2762         if(FAILED(nsres)) {
2763             ERR("GetElementByName failed: %08lx\n", nsres);
2764             return E_FAIL;
2765         }
2766     }else {
2767         nsIDOMDocumentFragment *docfrag;
2768         nsAString nsstr;
2769
2770         if(v) {
2771             const WCHAR *ptr;
2772             for(ptr=v; *ptr; ptr++) {
2773                 if(!iswalnum(*ptr)) {
2774                     FIXME("Unsupported invalid tag %s\n", debugstr_w(v));
2775                     return E_NOTIMPL;
2776                 }
2777             }
2778         }
2779
2780         nsres = nsIDOMNode_QueryInterface(This->node.nsnode, &IID_nsIDOMDocumentFragment, (void**)&docfrag);
2781         if(NS_FAILED(nsres)) {
2782             ERR("Could not get nsIDOMDocumentFragment iface: %08lx\n", nsres);
2783             return E_UNEXPECTED;
2784         }
2785
2786         nslist = NULL;
2787         nsAString_InitDepend(&nsstr, v);
2788         nsres = nsIDOMDocumentFragment_QuerySelectorAll(docfrag, &nsstr, &nslist);
2789         nsAString_Finish(&nsstr);
2790         nsIDOMDocumentFragment_Release(docfrag);
2791         if(NS_FAILED(nsres)) {
2792             ERR("QuerySelectorAll failed: %08lx\n", nsres);
2793             if(nslist)
2794                 nsIDOMNodeList_Release(nslist);
2795             return E_FAIL;
2796         }
2797     }
2798
2799
2800     *pelColl = create_collection_from_nodelist(nslist, This->document_mode);
2801     nsIDOMNodeList_Release(nslist);
2802
2803     return S_OK;
2804 }
2805
2806 static const IHTMLDocument3Vtbl HTMLDocument3Vtbl = {
2807     HTMLDocument3_QueryInterface,
2808     HTMLDocument3_AddRef,
2809     HTMLDocument3_Release,
2810     HTMLDocument3_GetTypeInfoCount,
2811     HTMLDocument3_GetTypeInfo,
2812     HTMLDocument3_GetIDsOfNames,
2813     HTMLDocument3_Invoke,
2814     HTMLDocument3_releaseCapture,
2815     HTMLDocument3_recalc,
2816     HTMLDocument3_createTextNode,
2817     HTMLDocument3_get_documentElement,
2818     HTMLDocument3_get_uniqueID,
2819     HTMLDocument3_attachEvent,
2820     HTMLDocument3_detachEvent,
2821     HTMLDocument3_put_onrowsdelete,
2822     HTMLDocument3_get_onrowsdelete,
2823     HTMLDocument3_put_onrowsinserted,
2824     HTMLDocument3_get_onrowsinserted,
2825     HTMLDocument3_put_oncellchange,
2826     HTMLDocument3_get_oncellchange,
2827     HTMLDocument3_put_ondatasetchanged,
2828     HTMLDocument3_get_ondatasetchanged,
2829     HTMLDocument3_put_ondataavailable,
2830     HTMLDocument3_get_ondataavailable,
2831     HTMLDocument3_put_ondatasetcomplete,
2832     HTMLDocument3_get_ondatasetcomplete,
2833     HTMLDocument3_put_onpropertychange,
2834     HTMLDocument3_get_onpropertychange,
2835     HTMLDocument3_put_dir,
2836     HTMLDocument3_get_dir,
2837     HTMLDocument3_put_oncontextmenu,
2838     HTMLDocument3_get_oncontextmenu,
2839     HTMLDocument3_put_onstop,
2840     HTMLDocument3_get_onstop,
2841     HTMLDocument3_createDocumentFragment,
2842     HTMLDocument3_get_parentDocument,
2843     HTMLDocument3_put_enableDownload,
2844     HTMLDocument3_get_enableDownload,
2845     HTMLDocument3_put_baseUrl,
2846     HTMLDocument3_get_baseUrl,
2847     HTMLDocument3_get_childNodes,
2848     HTMLDocument3_put_inheritStyleSheets,
2849     HTMLDocument3_get_inheritStyleSheets,
2850     HTMLDocument3_put_onbeforeeditfocus,
2851     HTMLDocument3_get_onbeforeeditfocus,
2852     HTMLDocument3_getElementsByName,
2853     HTMLDocument3_getElementById,
2854     HTMLDocument3_getElementsByTagName
2855 };
2856
2857 static inline HTMLDocumentNode *impl_from_IHTMLDocument4(IHTMLDocument4 *iface)
2858 {
2859     return CONTAINING_RECORD(iface, HTMLDocumentNode, IHTMLDocument4_iface);
2860 }
2861
2862 static HRESULT WINAPI HTMLDocument4_QueryInterface(IHTMLDocument4 *iface, REFIID riid, void **ppv)
2863 {
2864     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2865     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
2866 }
2867
2868 static ULONG WINAPI HTMLDocument4_AddRef(IHTMLDocument4 *iface)
2869 {
2870     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2871     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
2872 }
2873
2874 static ULONG WINAPI HTMLDocument4_Release(IHTMLDocument4 *iface)
2875 {
2876     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2877     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
2878 }
2879
2880 static HRESULT WINAPI HTMLDocument4_GetTypeInfoCount(IHTMLDocument4 *iface, UINT *pctinfo)
2881 {
2882     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2883     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
2884 }
2885
2886 static HRESULT WINAPI HTMLDocument4_GetTypeInfo(IHTMLDocument4 *iface, UINT iTInfo, LCID lcid,
2887         ITypeInfo **ppTInfo)
2888 {
2889     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2890     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2891 }
2892
2893 static HRESULT WINAPI HTMLDocument4_GetIDsOfNames(IHTMLDocument4 *iface, REFIID riid, LPOLESTR *rgszNames,
2894         UINT cNames, LCID lcid, DISPID *rgDispId)
2895 {
2896     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2897     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId);
2898 }
2899
2900 static HRESULT WINAPI HTMLDocument4_Invoke(IHTMLDocument4 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
2901         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2902 {
2903     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2904     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2905             pDispParams, pVarResult, pExcepInfo, puArgErr);
2906 }
2907
2908 static HRESULT WINAPI HTMLDocument4_focus(IHTMLDocument4 *iface)
2909 {
2910     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2911     nsIDOMHTMLElement *nsbody;
2912     nsresult nsres;
2913
2914     TRACE("(%p)->()\n", This);
2915
2916     if(!This->html_document) {
2917         FIXME("Not implemented for XML document\n");
2918         return E_NOTIMPL;
2919     }
2920
2921     nsres = nsIDOMHTMLDocument_GetBody(This->html_document, &nsbody);
2922     if(NS_FAILED(nsres) || !nsbody) {
2923         ERR("GetBody failed: %08lx\n", nsres);
2924         return E_FAIL;
2925     }
2926
2927     nsres = nsIDOMHTMLElement_Focus(nsbody);
2928     nsIDOMHTMLElement_Release(nsbody);
2929     if(NS_FAILED(nsres)) {
2930         ERR("Focus failed: %08lx\n", nsres);
2931         return E_FAIL;
2932     }
2933
2934     return S_OK;
2935 }
2936
2937 static HRESULT WINAPI HTMLDocument4_hasFocus(IHTMLDocument4 *iface, VARIANT_BOOL *pfFocus)
2938 {
2939     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2940     cpp_bool has_focus;
2941     nsresult nsres;
2942
2943     TRACE("(%p)->(%p)\n", This, pfFocus);
2944
2945     if(!This->dom_document) {
2946         FIXME("Unimplemented for fragments.\n");
2947         return E_NOTIMPL;
2948     }
2949
2950     nsres = nsIDOMDocument_HasFocus(This->dom_document, &has_focus);
2951     assert(nsres == NS_OK);
2952
2953     *pfFocus = variant_bool(has_focus);
2954     return S_OK;
2955 }
2956
2957 static HRESULT WINAPI HTMLDocument4_put_onselectionchange(IHTMLDocument4 *iface, VARIANT v)
2958 {
2959     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2960
2961     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2962
2963     return set_doc_event(This, EVENTID_SELECTIONCHANGE, &v);
2964 }
2965
2966 static HRESULT WINAPI HTMLDocument4_get_onselectionchange(IHTMLDocument4 *iface, VARIANT *p)
2967 {
2968     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2969
2970     TRACE("(%p)->(%p)\n", This, p);
2971
2972     return get_doc_event(This, EVENTID_SELECTIONCHANGE, p);
2973 }
2974
2975 static HRESULT WINAPI HTMLDocument4_get_namespaces(IHTMLDocument4 *iface, IDispatch **p)
2976 {
2977     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2978
2979     TRACE("(%p)->(%p)\n", This, p);
2980
2981     if(!This->namespaces) {
2982         HRESULT hres;
2983
2984         hres = create_namespace_collection(dispex_compat_mode(&This->node.event_target.dispex),
2985                                            &This->namespaces);
2986         if(FAILED(hres))
2987             return hres;
2988     }
2989
2990     IHTMLNamespaceCollection_AddRef(This->namespaces);
2991     *p = (IDispatch*)This->namespaces;
2992     return S_OK;
2993 }
2994
2995 static HRESULT WINAPI HTMLDocument4_createDocumentFromUrl(IHTMLDocument4 *iface, BSTR bstrUrl,
2996         BSTR bstrOptions, IHTMLDocument2 **newDoc)
2997 {
2998     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
2999     FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(bstrUrl), debugstr_w(bstrOptions), newDoc);
3000     return E_NOTIMPL;
3001 }
3002
3003 static HRESULT WINAPI HTMLDocument4_put_media(IHTMLDocument4 *iface, BSTR v)
3004 {
3005     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
3006     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3007     return E_NOTIMPL;
3008 }
3009
3010 static HRESULT WINAPI HTMLDocument4_get_media(IHTMLDocument4 *iface, BSTR *p)
3011 {
3012     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
3013     FIXME("(%p)->(%p)\n", This, p);
3014     return E_NOTIMPL;
3015 }
3016
3017 static HRESULT WINAPI HTMLDocument4_createEventObject(IHTMLDocument4 *iface,
3018         VARIANT *pvarEventObject, IHTMLEventObj **ppEventObj)
3019 {
3020     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
3021
3022     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(pvarEventObject), ppEventObj);
3023
3024     if(pvarEventObject && V_VT(pvarEventObject) != VT_ERROR && V_VT(pvarEventObject) != VT_EMPTY) {
3025         FIXME("unsupported pvarEventObject %s\n", debugstr_variant(pvarEventObject));
3026         return E_NOTIMPL;
3027     }
3028
3029     return create_event_obj(dispex_compat_mode(&This->node.event_target.dispex), ppEventObj);
3030 }
3031
3032 static HRESULT WINAPI HTMLDocument4_fireEvent(IHTMLDocument4 *iface, BSTR bstrEventName,
3033         VARIANT *pvarEventObject, VARIANT_BOOL *pfCanceled)
3034 {
3035     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
3036
3037     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(bstrEventName), pvarEventObject, pfCanceled);
3038
3039     return fire_event(&This->node, bstrEventName, pvarEventObject, pfCanceled);
3040 }
3041
3042 static HRESULT WINAPI HTMLDocument4_createRenderStyle(IHTMLDocument4 *iface, BSTR v,
3043         IHTMLRenderStyle **ppIHTMLRenderStyle)
3044 {
3045     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
3046     FIXME("(%p)->(%s %p)\n", This, debugstr_w(v), ppIHTMLRenderStyle);
3047     return E_NOTIMPL;
3048 }
3049
3050 static HRESULT WINAPI HTMLDocument4_put_oncontrolselect(IHTMLDocument4 *iface, VARIANT v)
3051 {
3052     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
3053     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3054     return E_NOTIMPL;
3055 }
3056
3057 static HRESULT WINAPI HTMLDocument4_get_oncontrolselect(IHTMLDocument4 *iface, VARIANT *p)
3058 {
3059     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
3060     FIXME("(%p)->(%p)\n", This, p);
3061     return E_NOTIMPL;
3062 }
3063
3064 static HRESULT WINAPI HTMLDocument4_get_URLUnencoded(IHTMLDocument4 *iface, BSTR *p)
3065 {
3066     HTMLDocumentNode *This = impl_from_IHTMLDocument4(iface);
3067     FIXME("(%p)->(%p)\n", This, p);
3068     return E_NOTIMPL;
3069 }
3070
3071 static const IHTMLDocument4Vtbl HTMLDocument4Vtbl = {
3072     HTMLDocument4_QueryInterface,
3073     HTMLDocument4_AddRef,
3074     HTMLDocument4_Release,
3075     HTMLDocument4_GetTypeInfoCount,
3076     HTMLDocument4_GetTypeInfo,
3077     HTMLDocument4_GetIDsOfNames,
3078     HTMLDocument4_Invoke,
3079     HTMLDocument4_focus,
3080     HTMLDocument4_hasFocus,
3081     HTMLDocument4_put_onselectionchange,
3082     HTMLDocument4_get_onselectionchange,
3083     HTMLDocument4_get_namespaces,
3084     HTMLDocument4_createDocumentFromUrl,
3085     HTMLDocument4_put_media,
3086     HTMLDocument4_get_media,
3087     HTMLDocument4_createEventObject,
3088     HTMLDocument4_fireEvent,
3089     HTMLDocument4_createRenderStyle,
3090     HTMLDocument4_put_oncontrolselect,
3091     HTMLDocument4_get_oncontrolselect,
3092     HTMLDocument4_get_URLUnencoded
3093 };
3094
3095 static inline HTMLDocumentNode *impl_from_IHTMLDocument5(IHTMLDocument5 *iface)
3096 {
3097     return CONTAINING_RECORD(iface, HTMLDocumentNode, IHTMLDocument5_iface);
3098 }
3099
3100 static HRESULT WINAPI HTMLDocument5_QueryInterface(IHTMLDocument5 *iface, REFIID riid, void **ppv)
3101 {
3102     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3103     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
3104 }
3105
3106 static ULONG WINAPI HTMLDocument5_AddRef(IHTMLDocument5 *iface)
3107 {
3108     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3109     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
3110 }
3111
3112 static ULONG WINAPI HTMLDocument5_Release(IHTMLDocument5 *iface)
3113 {
3114     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3115     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
3116 }
3117
3118 static HRESULT WINAPI HTMLDocument5_GetTypeInfoCount(IHTMLDocument5 *iface, UINT *pctinfo)
3119 {
3120     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3121     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
3122 }
3123
3124 static HRESULT WINAPI HTMLDocument5_GetTypeInfo(IHTMLDocument5 *iface, UINT iTInfo, LCID lcid,
3125         ITypeInfo **ppTInfo)
3126 {
3127     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3128     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3129 }
3130
3131 static HRESULT WINAPI HTMLDocument5_GetIDsOfNames(IHTMLDocument5 *iface, REFIID riid, LPOLESTR *rgszNames,
3132         UINT cNames, LCID lcid, DISPID *rgDispId)
3133 {
3134     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3135     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId);
3136 }
3137
3138 static HRESULT WINAPI HTMLDocument5_Invoke(IHTMLDocument5 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
3139         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3140 {
3141     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3142     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
3143             pDispParams, pVarResult, pExcepInfo, puArgErr);
3144 }
3145
3146 static HRESULT WINAPI HTMLDocument5_put_onmousewheel(IHTMLDocument5 *iface, VARIANT v)
3147 {
3148     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3149
3150     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3151
3152     return set_doc_event(This, EVENTID_MOUSEWHEEL, &v);
3153 }
3154
3155 static HRESULT WINAPI HTMLDocument5_get_onmousewheel(IHTMLDocument5 *iface, VARIANT *p)
3156 {
3157     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3158
3159     TRACE("(%p)->(%p)\n", This, p);
3160
3161     return get_doc_event(This, EVENTID_MOUSEWHEEL, p);
3162 }
3163
3164 static HRESULT WINAPI HTMLDocument5_get_doctype(IHTMLDocument5 *iface, IHTMLDOMNode **p)
3165 {
3166     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3167     nsIDOMDocumentType *nsdoctype;
3168     HTMLDOMNode *doctype_node;
3169     nsresult nsres;
3170     HRESULT hres;
3171
3172     TRACE("(%p)->(%p)\n", This, p);
3173
3174     if(dispex_compat_mode(&This->node.event_target.dispex) < COMPAT_MODE_IE9) {
3175         *p = NULL;
3176         return S_OK;
3177     }
3178
3179     nsres = nsIDOMDocument_GetDoctype(This->dom_document, &nsdoctype);
3180     if(NS_FAILED(nsres))
3181         return map_nsresult(nsres);
3182     if(!nsdoctype) {
3183         *p = NULL;
3184         return S_OK;
3185     }
3186
3187     hres = get_node((nsIDOMNode*)nsdoctype, TRUE, &doctype_node);
3188     nsIDOMDocumentType_Release(nsdoctype);
3189
3190     if(SUCCEEDED(hres))
3191         *p = &doctype_node->IHTMLDOMNode_iface;
3192     return hres;
3193 }
3194
3195 static HRESULT WINAPI HTMLDocument5_get_implementation(IHTMLDocument5 *iface, IHTMLDOMImplementation **p)
3196 {
3197     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3198
3199     TRACE("(%p)->(%p)\n", This, p);
3200
3201     if(!This->dom_implementation) {
3202         HRESULT hres;
3203
3204         hres = create_dom_implementation(This, &This->dom_implementation);
3205         if(FAILED(hres))
3206             return hres;
3207     }
3208
3209     IHTMLDOMImplementation_AddRef(This->dom_implementation);
3210     *p = This->dom_implementation;
3211     return S_OK;
3212 }
3213
3214 static HRESULT WINAPI HTMLDocument5_createAttribute(IHTMLDocument5 *iface, BSTR bstrattrName,
3215         IHTMLDOMAttribute **ppattribute)
3216 {
3217     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3218     HTMLDOMAttribute *attr;
3219     HRESULT hres;
3220
3221     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrattrName), ppattribute);
3222
3223     hres = HTMLDOMAttribute_Create(bstrattrName, NULL, 0, dispex_compat_mode(&This->node.event_target.dispex), &attr);
3224     if(FAILED(hres))
3225         return hres;
3226
3227     *ppattribute = &attr->IHTMLDOMAttribute_iface;
3228     return S_OK;
3229 }
3230
3231 static HRESULT WINAPI HTMLDocument5_createComment(IHTMLDocument5 *iface, BSTR bstrdata,
3232         IHTMLDOMNode **ppRetNode)
3233 {
3234     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3235     nsIDOMComment *nscomment;
3236     HTMLElement *elem;
3237     nsAString str;
3238     nsresult nsres;
3239     HRESULT hres;
3240
3241     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrdata), ppRetNode);
3242
3243     if(!This->dom_document) {
3244         WARN("NULL dom_document\n");
3245         return E_UNEXPECTED;
3246     }
3247
3248     nsAString_InitDepend(&str, bstrdata);
3249     nsres = nsIDOMDocument_CreateComment(This->dom_document, &str, &nscomment);
3250     nsAString_Finish(&str);
3251     if(NS_FAILED(nsres)) {
3252         ERR("CreateTextNode failed: %08lx\n", nsres);
3253         return E_FAIL;
3254     }
3255
3256     hres = HTMLCommentElement_Create(This, (nsIDOMNode*)nscomment, &elem);
3257     nsIDOMComment_Release(nscomment);
3258     if(FAILED(hres))
3259         return hres;
3260
3261     *ppRetNode = &elem->node.IHTMLDOMNode_iface;
3262     return S_OK;
3263 }
3264
3265 static HRESULT WINAPI HTMLDocument5_put_onfocusin(IHTMLDocument5 *iface, VARIANT v)
3266 {
3267     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3268
3269     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3270
3271     return set_doc_event(This, EVENTID_FOCUSIN, &v);
3272 }
3273
3274 static HRESULT WINAPI HTMLDocument5_get_onfocusin(IHTMLDocument5 *iface, VARIANT *p)
3275 {
3276     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3277
3278     TRACE("(%p)->(%p)\n", This, p);
3279
3280     return get_doc_event(This, EVENTID_FOCUSIN, p);
3281 }
3282
3283 static HRESULT WINAPI HTMLDocument5_put_onfocusout(IHTMLDocument5 *iface, VARIANT v)
3284 {
3285     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3286
3287     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3288
3289     return set_doc_event(This, EVENTID_FOCUSOUT, &v);
3290 }
3291
3292 static HRESULT WINAPI HTMLDocument5_get_onfocusout(IHTMLDocument5 *iface, VARIANT *p)
3293 {
3294     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3295
3296     TRACE("(%p)->(%p)\n", This, p);
3297
3298     return get_doc_event(This, EVENTID_FOCUSOUT, p);
3299 }
3300
3301 static HRESULT WINAPI HTMLDocument5_put_onactivate(IHTMLDocument5 *iface, VARIANT v)
3302 {
3303     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3304     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3305     return E_NOTIMPL;
3306 }
3307
3308 static HRESULT WINAPI HTMLDocument5_get_onactivate(IHTMLDocument5 *iface, VARIANT *p)
3309 {
3310     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3311     FIXME("(%p)->(%p)\n", This, p);
3312     return E_NOTIMPL;
3313 }
3314
3315 static HRESULT WINAPI HTMLDocument5_put_ondeactivate(IHTMLDocument5 *iface, VARIANT v)
3316 {
3317     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3318     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3319     return E_NOTIMPL;
3320 }
3321
3322 static HRESULT WINAPI HTMLDocument5_get_ondeactivate(IHTMLDocument5 *iface, VARIANT *p)
3323 {
3324     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3325     FIXME("(%p)->(%p)\n", This, p);
3326     return E_NOTIMPL;
3327 }
3328
3329 static HRESULT WINAPI HTMLDocument5_put_onbeforeactivate(IHTMLDocument5 *iface, VARIANT v)
3330 {
3331     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3332     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3333     return E_NOTIMPL;
3334 }
3335
3336 static HRESULT WINAPI HTMLDocument5_get_onbeforeactivate(IHTMLDocument5 *iface, VARIANT *p)
3337 {
3338     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3339     FIXME("(%p)->(%p)\n", This, p);
3340     return E_NOTIMPL;
3341 }
3342
3343 static HRESULT WINAPI HTMLDocument5_put_onbeforedeactivate(IHTMLDocument5 *iface, VARIANT v)
3344 {
3345     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3346     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3347     return E_NOTIMPL;
3348 }
3349
3350 static HRESULT WINAPI HTMLDocument5_get_onbeforedeactivate(IHTMLDocument5 *iface, VARIANT *p)
3351 {
3352     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3353     FIXME("(%p)->(%p)\n", This, p);
3354     return E_NOTIMPL;
3355 }
3356
3357 static HRESULT WINAPI HTMLDocument5_get_compatMode(IHTMLDocument5 *iface, BSTR *p)
3358 {
3359     HTMLDocumentNode *This = impl_from_IHTMLDocument5(iface);
3360
3361     TRACE("(%p)->(%p)\n", This, p);
3362
3363     *p = SysAllocString(This->document_mode <= COMPAT_MODE_IE5 ? L"BackCompat" : L"CSS1Compat");
3364     return *p ? S_OK : E_OUTOFMEMORY;
3365 }
3366
3367 static const IHTMLDocument5Vtbl HTMLDocument5Vtbl = {
3368     HTMLDocument5_QueryInterface,
3369     HTMLDocument5_AddRef,
3370     HTMLDocument5_Release,
3371     HTMLDocument5_GetTypeInfoCount,
3372     HTMLDocument5_GetTypeInfo,
3373     HTMLDocument5_GetIDsOfNames,
3374     HTMLDocument5_Invoke,
3375     HTMLDocument5_put_onmousewheel,
3376     HTMLDocument5_get_onmousewheel,
3377     HTMLDocument5_get_doctype,
3378     HTMLDocument5_get_implementation,
3379     HTMLDocument5_createAttribute,
3380     HTMLDocument5_createComment,
3381     HTMLDocument5_put_onfocusin,
3382     HTMLDocument5_get_onfocusin,
3383     HTMLDocument5_put_onfocusout,
3384     HTMLDocument5_get_onfocusout,
3385     HTMLDocument5_put_onactivate,
3386     HTMLDocument5_get_onactivate,
3387     HTMLDocument5_put_ondeactivate,
3388     HTMLDocument5_get_ondeactivate,
3389     HTMLDocument5_put_onbeforeactivate,
3390     HTMLDocument5_get_onbeforeactivate,
3391     HTMLDocument5_put_onbeforedeactivate,
3392     HTMLDocument5_get_onbeforedeactivate,
3393     HTMLDocument5_get_compatMode
3394 };
3395
3396 static inline HTMLDocumentNode *impl_from_IHTMLDocument6(IHTMLDocument6 *iface)
3397 {
3398     return CONTAINING_RECORD(iface, HTMLDocumentNode, IHTMLDocument6_iface);
3399 }
3400
3401 static HRESULT WINAPI HTMLDocument6_QueryInterface(IHTMLDocument6 *iface, REFIID riid, void **ppv)
3402 {
3403     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3404     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
3405 }
3406
3407 static ULONG WINAPI HTMLDocument6_AddRef(IHTMLDocument6 *iface)
3408 {
3409     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3410     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
3411 }
3412
3413 static ULONG WINAPI HTMLDocument6_Release(IHTMLDocument6 *iface)
3414 {
3415     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3416     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
3417 }
3418
3419 static HRESULT WINAPI HTMLDocument6_GetTypeInfoCount(IHTMLDocument6 *iface, UINT *pctinfo)
3420 {
3421     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3422     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
3423 }
3424
3425 static HRESULT WINAPI HTMLDocument6_GetTypeInfo(IHTMLDocument6 *iface, UINT iTInfo, LCID lcid,
3426         ITypeInfo **ppTInfo)
3427 {
3428     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3429     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3430 }
3431
3432 static HRESULT WINAPI HTMLDocument6_GetIDsOfNames(IHTMLDocument6 *iface, REFIID riid, LPOLESTR *rgszNames,
3433         UINT cNames, LCID lcid, DISPID *rgDispId)
3434 {
3435     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3436     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId);
3437 }
3438
3439 static HRESULT WINAPI HTMLDocument6_Invoke(IHTMLDocument6 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
3440         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3441 {
3442     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3443     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
3444             pDispParams, pVarResult, pExcepInfo, puArgErr);
3445 }
3446
3447 static HRESULT WINAPI HTMLDocument6_get_compatible(IHTMLDocument6 *iface,
3448         IHTMLDocumentCompatibleInfoCollection **p)
3449 {
3450     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3451     FIXME("(%p)->(%p)\n", This, p);
3452     return E_NOTIMPL;
3453 }
3454
3455 static HRESULT WINAPI HTMLDocument6_get_documentMode(IHTMLDocument6 *iface, VARIANT *p)
3456 {
3457     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3458
3459     TRACE("(%p)->(%p)\n", This, p);
3460
3461     V_VT(p) = VT_R4;
3462     V_R4(p) = compat_mode_info[This->document_mode].document_mode;
3463     return S_OK;
3464 }
3465
3466 static HRESULT WINAPI HTMLDocument6_get_onstorage(IHTMLDocument6 *iface,
3467         VARIANT *p)
3468 {
3469     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3470
3471     TRACE("(%p)->(%p)\n", This, p);
3472
3473     return get_doc_event(This, EVENTID_STORAGE, p);
3474 }
3475
3476 static HRESULT WINAPI HTMLDocument6_put_onstorage(IHTMLDocument6 *iface, VARIANT v)
3477 {
3478     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3479
3480     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3481
3482     return set_doc_event(This, EVENTID_STORAGE, &v);
3483 }
3484
3485 static HRESULT WINAPI HTMLDocument6_get_onstoragecommit(IHTMLDocument6 *iface,
3486         VARIANT *p)
3487 {
3488     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3489
3490     TRACE("(%p)->(%p)\n", This, p);
3491
3492     return get_doc_event(This, EVENTID_STORAGECOMMIT, p);
3493 }
3494
3495 static HRESULT WINAPI HTMLDocument6_put_onstoragecommit(IHTMLDocument6 *iface, VARIANT v)
3496 {
3497     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3498
3499     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3500
3501     return set_doc_event(This, EVENTID_STORAGECOMMIT, &v);
3502 }
3503
3504 static HRESULT WINAPI HTMLDocument6_getElementById(IHTMLDocument6 *iface,
3505         BSTR bstrId, IHTMLElement2 **p)
3506 {
3507     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3508     nsIDOMElement *nselem;
3509     HTMLElement *elem;
3510     nsAString nsstr;
3511     nsresult nsres;
3512     HRESULT hres;
3513
3514     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrId), p);
3515
3516     /*
3517      * Unlike IHTMLDocument3 implementation, this is standard compliant and does
3518      * not search for name attributes, so we may simply let Gecko do the right thing.
3519      */
3520
3521     if(!This->dom_document) {
3522         FIXME("Not a document\n");
3523         return E_FAIL;
3524     }
3525
3526     nsAString_InitDepend(&nsstr, bstrId);
3527     nsres = nsIDOMDocument_GetElementById(This->dom_document, &nsstr, &nselem);
3528     nsAString_Finish(&nsstr);
3529     if(NS_FAILED(nsres)) {
3530         ERR("GetElementById failed: %08lx\n", nsres);
3531         return E_FAIL;
3532     }
3533
3534     if(!nselem) {
3535         *p = NULL;
3536         return S_OK;
3537     }
3538
3539     hres = get_element(nselem, &elem);
3540     nsIDOMElement_Release(nselem);
3541     if(FAILED(hres))
3542         return hres;
3543
3544     *p = &elem->IHTMLElement2_iface;
3545     return S_OK;
3546 }
3547
3548 static HRESULT WINAPI HTMLDocument6_updateSettings(IHTMLDocument6 *iface)
3549 {
3550     HTMLDocumentNode *This = impl_from_IHTMLDocument6(iface);
3551     FIXME("(%p)->()\n", This);
3552     return E_NOTIMPL;
3553 }
3554
3555 static const IHTMLDocument6Vtbl HTMLDocument6Vtbl = {
3556     HTMLDocument6_QueryInterface,
3557     HTMLDocument6_AddRef,
3558     HTMLDocument6_Release,
3559     HTMLDocument6_GetTypeInfoCount,
3560     HTMLDocument6_GetTypeInfo,
3561     HTMLDocument6_GetIDsOfNames,
3562     HTMLDocument6_Invoke,
3563     HTMLDocument6_get_compatible,
3564     HTMLDocument6_get_documentMode,
3565     HTMLDocument6_put_onstorage,
3566     HTMLDocument6_get_onstorage,
3567     HTMLDocument6_put_onstoragecommit,
3568     HTMLDocument6_get_onstoragecommit,
3569     HTMLDocument6_getElementById,
3570     HTMLDocument6_updateSettings
3571 };
3572
3573 static inline HTMLDocumentNode *impl_from_IHTMLDocument7(IHTMLDocument7 *iface)
3574 {
3575     return CONTAINING_RECORD(iface, HTMLDocumentNode, IHTMLDocument7_iface);
3576 }
3577
3578 static HRESULT WINAPI HTMLDocument7_QueryInterface(IHTMLDocument7 *iface, REFIID riid, void **ppv)
3579 {
3580     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3581     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
3582 }
3583
3584 static ULONG WINAPI HTMLDocument7_AddRef(IHTMLDocument7 *iface)
3585 {
3586     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3587     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
3588 }
3589
3590 static ULONG WINAPI HTMLDocument7_Release(IHTMLDocument7 *iface)
3591 {
3592     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3593     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
3594 }
3595
3596 static HRESULT WINAPI HTMLDocument7_GetTypeInfoCount(IHTMLDocument7 *iface, UINT *pctinfo)
3597 {
3598     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3599     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
3600 }
3601
3602 static HRESULT WINAPI HTMLDocument7_GetTypeInfo(IHTMLDocument7 *iface, UINT iTInfo, LCID lcid,
3603         ITypeInfo **ppTInfo)
3604 {
3605     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3606     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3607 }
3608
3609 static HRESULT WINAPI HTMLDocument7_GetIDsOfNames(IHTMLDocument7 *iface, REFIID riid, LPOLESTR *rgszNames,
3610         UINT cNames, LCID lcid, DISPID *rgDispId)
3611 {
3612     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3613     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId);
3614 }
3615
3616 static HRESULT WINAPI HTMLDocument7_Invoke(IHTMLDocument7 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
3617         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3618 {
3619     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3620     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
3621             pDispParams, pVarResult, pExcepInfo, puArgErr);
3622 }
3623
3624 static HRESULT WINAPI HTMLDocument7_get_defaultView(IHTMLDocument7 *iface, IHTMLWindow2 **p)
3625 {
3626     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3627
3628     TRACE("(%p)->(%p)\n", This, p);
3629
3630     if(This->window && This->window->base.outer_window) {
3631         *p = &This->window->base.outer_window->base.IHTMLWindow2_iface;
3632         IHTMLWindow2_AddRef(*p);
3633     }else {
3634         *p = NULL;
3635     }
3636     return S_OK;
3637 }
3638
3639 static HRESULT WINAPI HTMLDocument7_createCDATASection(IHTMLDocument7 *iface, BSTR text, IHTMLDOMNode **newCDATASectionNode)
3640 {
3641     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3642     FIXME("(%p)->(%p)\n", This, newCDATASectionNode);
3643     return E_NOTIMPL;
3644 }
3645
3646 static HRESULT WINAPI HTMLDocument7_getSelection(IHTMLDocument7 *iface, IHTMLSelection **ppIHTMLSelection)
3647 {
3648     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3649     FIXME("(%p)->(%p)\n", This, ppIHTMLSelection);
3650     return E_NOTIMPL;
3651 }
3652
3653 static HRESULT WINAPI HTMLDocument7_getElementsByTagNameNS(IHTMLDocument7 *iface, VARIANT *pvarNS,
3654         BSTR bstrLocalName, IHTMLElementCollection **pelColl)
3655 {
3656     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3657     FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrLocalName), pelColl);
3658     return E_NOTIMPL;
3659 }
3660
3661 static HRESULT WINAPI HTMLDocument7_createElementNS(IHTMLDocument7 *iface, VARIANT *pvarNS, BSTR bstrTag, IHTMLElement **newElem)
3662 {
3663     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3664     nsIDOMElement *dom_element;
3665     HTMLElement *element;
3666     nsAString ns, tag;
3667     nsresult nsres;
3668     HRESULT hres;
3669
3670     TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrTag), newElem);
3671
3672     if(!This->dom_document) {
3673         FIXME("NULL dom_document\n");
3674         return E_FAIL;
3675     }
3676
3677     if(pvarNS && V_VT(pvarNS) != VT_NULL && V_VT(pvarNS) != VT_BSTR)
3678         FIXME("Unsupported namespace %s\n", debugstr_variant(pvarNS));
3679
3680     nsAString_InitDepend(&ns, pvarNS && V_VT(pvarNS) == VT_BSTR ? V_BSTR(pvarNS) : NULL);
3681     nsAString_InitDepend(&tag, bstrTag);
3682     nsres = nsIDOMDocument_CreateElementNS(This->dom_document, &ns, &tag, &dom_element);
3683     nsAString_Finish(&ns);
3684     nsAString_Finish(&tag);
3685     if(NS_FAILED(nsres)) {
3686         WARN("CreateElementNS failed: %08lx\n", nsres);
3687         return map_nsresult(nsres);
3688     }
3689
3690     hres = HTMLElement_Create(This, (nsIDOMNode*)dom_element, FALSE, &element);
3691     nsIDOMElement_Release(dom_element);
3692     if(FAILED(hres))
3693         return hres;
3694
3695     *newElem = &element->IHTMLElement_iface;
3696     return S_OK;
3697 }
3698
3699 static HRESULT WINAPI HTMLDocument7_createAttributeNS(IHTMLDocument7 *iface, VARIANT *pvarNS,
3700         BSTR bstrAttrName, IHTMLDOMAttribute **ppAttribute)
3701 {
3702     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3703     FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrAttrName), ppAttribute);
3704     return E_NOTIMPL;
3705 }
3706
3707 static HRESULT WINAPI HTMLDocument7_put_onmsthumbnailclick(IHTMLDocument7 *iface, VARIANT v)
3708 {
3709     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3710     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3711     return E_NOTIMPL;
3712 }
3713
3714 static HRESULT WINAPI HTMLDocument7_get_onmsthumbnailclick(IHTMLDocument7 *iface, VARIANT *p)
3715 {
3716     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3717
3718     TRACE("(%p)->(%p)\n", This, p);
3719
3720     return get_doc_event(This, EVENTID_MSTHUMBNAILCLICK, p);
3721 }
3722
3723 static HRESULT WINAPI HTMLDocument7_get_characterSet(IHTMLDocument7 *iface, BSTR *p)
3724 {
3725     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3726     nsAString charset_str;
3727     nsresult nsres;
3728
3729     TRACE("(%p)->(%p)\n", This, p);
3730
3731     if(!This->dom_document) {
3732         FIXME("NULL dom_document\n");
3733         return E_FAIL;
3734     }
3735
3736     nsAString_Init(&charset_str, NULL);
3737     nsres = nsIDOMDocument_GetCharacterSet(This->dom_document, &charset_str);
3738     return return_nsstr(nsres, &charset_str, p);
3739 }
3740
3741 static HRESULT WINAPI HTMLDocument7_createElement(IHTMLDocument7 *iface, BSTR bstrTag, IHTMLElement **newElem)
3742 {
3743     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3744
3745     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrTag), newElem);
3746
3747     return IHTMLDocument2_createElement(&This->IHTMLDocument2_iface, bstrTag, newElem);
3748 }
3749
3750 static HRESULT WINAPI HTMLDocument7_createAttribute(IHTMLDocument7 *iface, BSTR bstrAttrName, IHTMLDOMAttribute **ppAttribute)
3751 {
3752     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3753
3754     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrAttrName), ppAttribute);
3755
3756     return IHTMLDocument5_createAttribute(&This->IHTMLDocument5_iface, bstrAttrName, ppAttribute);
3757 }
3758
3759 static HRESULT WINAPI HTMLDocument7_getElementsByClassName(IHTMLDocument7 *iface, BSTR v, IHTMLElementCollection **pel)
3760 {
3761     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3762     nsIDOMNodeList *nslist;
3763     nsAString nsstr;
3764     nsresult nsres;
3765
3766     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
3767
3768     if(!This->dom_document) {
3769         FIXME("NULL dom_document not supported\n");
3770         return E_NOTIMPL;
3771     }
3772
3773     nsAString_InitDepend(&nsstr, v);
3774     nsres = nsIDOMDocument_GetElementsByClassName(This->dom_document, &nsstr, &nslist);
3775     nsAString_Finish(&nsstr);
3776     if(FAILED(nsres)) {
3777         ERR("GetElementByClassName failed: %08lx\n", nsres);
3778         return E_FAIL;
3779     }
3780
3781
3782     *pel = create_collection_from_nodelist(nslist, This->document_mode);
3783     nsIDOMNodeList_Release(nslist);
3784     return S_OK;
3785 }
3786
3787 static HRESULT WINAPI HTMLDocument7_createProcessingInstruction(IHTMLDocument7 *iface, BSTR target,
3788         BSTR data, IDOMProcessingInstruction **newProcessingInstruction)
3789 {
3790     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3791     FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(target), debugstr_w(data), newProcessingInstruction);
3792     return E_NOTIMPL;
3793 }
3794
3795 static HRESULT WINAPI HTMLDocument7_adoptNode(IHTMLDocument7 *iface, IHTMLDOMNode *pNodeSource, IHTMLDOMNode3 **ppNodeDest)
3796 {
3797     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3798     FIXME("(%p)->(%p %p)\n", This, pNodeSource, ppNodeDest);
3799     return E_NOTIMPL;
3800 }
3801
3802 static HRESULT WINAPI HTMLDocument7_put_onmssitemodejumplistitemremoved(IHTMLDocument7 *iface, VARIANT v)
3803 {
3804     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3805     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3806     return E_NOTIMPL;
3807 }
3808
3809 static HRESULT WINAPI HTMLDocument7_get_onmssitemodejumplistitemremoved(IHTMLDocument7 *iface, VARIANT *p)
3810 {
3811     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3812     FIXME("(%p)->(%p)\n", This, p);
3813     return E_NOTIMPL;
3814 }
3815
3816 static HRESULT WINAPI HTMLDocument7_get_all(IHTMLDocument7 *iface, IHTMLElementCollection **p)
3817 {
3818     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3819
3820     TRACE("(%p)->(%p)\n", This, p);
3821
3822     return IHTMLDocument2_get_all(&This->IHTMLDocument2_iface, p);
3823 }
3824
3825 static HRESULT WINAPI HTMLDocument7_get_inputEncoding(IHTMLDocument7 *iface, BSTR *p)
3826 {
3827     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3828     FIXME("(%p)->(%p)\n", This, p);
3829     return E_NOTIMPL;
3830 }
3831
3832 static HRESULT WINAPI HTMLDocument7_get_xmlEncoding(IHTMLDocument7 *iface, BSTR *p)
3833 {
3834     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3835     FIXME("(%p)->(%p)\n", This, p);
3836     return E_NOTIMPL;
3837 }
3838
3839 static HRESULT WINAPI HTMLDocument7_put_xmlStandalone(IHTMLDocument7 *iface, VARIANT_BOOL v)
3840 {
3841     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3842     FIXME("(%p)->(%x)\n", This, v);
3843     return E_NOTIMPL;
3844 }
3845
3846 static HRESULT WINAPI HTMLDocument7_get_xmlStandalone(IHTMLDocument7 *iface, VARIANT_BOOL *p)
3847 {
3848     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3849     FIXME("(%p)->(%p)\n", This, p);
3850     return E_NOTIMPL;
3851 }
3852
3853 static HRESULT WINAPI HTMLDocument7_put_xmlVersion(IHTMLDocument7 *iface, BSTR v)
3854 {
3855     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3856     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3857     return E_NOTIMPL;
3858 }
3859
3860 static HRESULT WINAPI HTMLDocument7_get_xmlVersion(IHTMLDocument7 *iface, BSTR *p)
3861 {
3862     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3863     FIXME("(%p)->(%p)\n", This, p);
3864     return E_NOTIMPL;
3865 }
3866
3867 static HRESULT WINAPI HTMLDocument7_hasAttributes(IHTMLDocument7 *iface, VARIANT_BOOL *pfHasAttributes)
3868 {
3869     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3870     FIXME("(%p)->(%p)\n", This, pfHasAttributes);
3871     return E_NOTIMPL;
3872 }
3873
3874 static HRESULT WINAPI HTMLDocument7_put_onabort(IHTMLDocument7 *iface, VARIANT v)
3875 {
3876     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3877
3878     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3879
3880     return set_doc_event(This, EVENTID_ABORT, &v);
3881 }
3882
3883 static HRESULT WINAPI HTMLDocument7_get_onabort(IHTMLDocument7 *iface, VARIANT *p)
3884 {
3885     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3886
3887     TRACE("(%p)->(%p)\n", This, p);
3888
3889     return get_doc_event(This, EVENTID_ABORT, p);
3890 }
3891
3892 static HRESULT WINAPI HTMLDocument7_put_onblur(IHTMLDocument7 *iface, VARIANT v)
3893 {
3894     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3895
3896     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3897
3898     return set_doc_event(This, EVENTID_BLUR, &v);
3899 }
3900
3901 static HRESULT WINAPI HTMLDocument7_get_onblur(IHTMLDocument7 *iface, VARIANT *p)
3902 {
3903     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3904
3905     TRACE("(%p)->(%p)\n", This, p);
3906
3907     return get_doc_event(This, EVENTID_BLUR, p);
3908 }
3909
3910 static HRESULT WINAPI HTMLDocument7_put_oncanplay(IHTMLDocument7 *iface, VARIANT v)
3911 {
3912     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3913     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3914     return E_NOTIMPL;
3915 }
3916
3917 static HRESULT WINAPI HTMLDocument7_get_oncanplay(IHTMLDocument7 *iface, VARIANT *p)
3918 {
3919     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3920     FIXME("(%p)->(%p)\n", This, p);
3921     return E_NOTIMPL;
3922 }
3923
3924 static HRESULT WINAPI HTMLDocument7_put_oncanplaythrough(IHTMLDocument7 *iface, VARIANT v)
3925 {
3926     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3927     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3928     return E_NOTIMPL;
3929 }
3930
3931 static HRESULT WINAPI HTMLDocument7_get_oncanplaythrough(IHTMLDocument7 *iface, VARIANT *p)
3932 {
3933     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3934     FIXME("(%p)->(%p)\n", This, p);
3935     return E_NOTIMPL;
3936 }
3937
3938 static HRESULT WINAPI HTMLDocument7_put_onchange(IHTMLDocument7 *iface, VARIANT v)
3939 {
3940     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3941
3942     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3943
3944     return set_doc_event(This, EVENTID_CHANGE, &v);
3945 }
3946
3947 static HRESULT WINAPI HTMLDocument7_get_onchange(IHTMLDocument7 *iface, VARIANT *p)
3948 {
3949     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3950
3951     TRACE("(%p)->(%p)\n", This, p);
3952
3953     return get_doc_event(This, EVENTID_CHANGE, p);
3954 }
3955
3956 static HRESULT WINAPI HTMLDocument7_put_ondrag(IHTMLDocument7 *iface, VARIANT v)
3957 {
3958     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3959
3960     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3961
3962     return set_doc_event(This, EVENTID_DRAG, &v);
3963 }
3964
3965 static HRESULT WINAPI HTMLDocument7_get_ondrag(IHTMLDocument7 *iface, VARIANT *p)
3966 {
3967     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3968
3969     TRACE("(%p)->(%p)\n", This, p);
3970
3971     return get_doc_event(This, EVENTID_DRAG, p);
3972 }
3973
3974 static HRESULT WINAPI HTMLDocument7_put_ondragend(IHTMLDocument7 *iface, VARIANT v)
3975 {
3976     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3977     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3978     return E_NOTIMPL;
3979 }
3980
3981 static HRESULT WINAPI HTMLDocument7_get_ondragend(IHTMLDocument7 *iface, VARIANT *p)
3982 {
3983     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3984     FIXME("(%p)->(%p)\n", This, p);
3985     return E_NOTIMPL;
3986 }
3987
3988 static HRESULT WINAPI HTMLDocument7_put_ondragenter(IHTMLDocument7 *iface, VARIANT v)
3989 {
3990     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3991     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3992     return E_NOTIMPL;
3993 }
3994
3995 static HRESULT WINAPI HTMLDocument7_get_ondragenter(IHTMLDocument7 *iface, VARIANT *p)
3996 {
3997     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
3998     FIXME("(%p)->(%p)\n", This, p);
3999     return E_NOTIMPL;
4000 }
4001
4002 static HRESULT WINAPI HTMLDocument7_put_ondragleave(IHTMLDocument7 *iface, VARIANT v)
4003 {
4004     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4005     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4006     return E_NOTIMPL;
4007 }
4008
4009 static HRESULT WINAPI HTMLDocument7_get_ondragleave(IHTMLDocument7 *iface, VARIANT *p)
4010 {
4011     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4012     FIXME("(%p)->(%p)\n", This, p);
4013     return E_NOTIMPL;
4014 }
4015
4016 static HRESULT WINAPI HTMLDocument7_put_ondragover(IHTMLDocument7 *iface, VARIANT v)
4017 {
4018     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4019     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4020     return E_NOTIMPL;
4021 }
4022
4023 static HRESULT WINAPI HTMLDocument7_get_ondragover(IHTMLDocument7 *iface, VARIANT *p)
4024 {
4025     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4026     FIXME("(%p)->(%p)\n", This, p);
4027     return E_NOTIMPL;
4028 }
4029
4030 static HRESULT WINAPI HTMLDocument7_put_ondrop(IHTMLDocument7 *iface, VARIANT v)
4031 {
4032     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4033     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4034     return E_NOTIMPL;
4035 }
4036
4037 static HRESULT WINAPI HTMLDocument7_get_ondrop(IHTMLDocument7 *iface, VARIANT *p)
4038 {
4039     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4040     FIXME("(%p)->(%p)\n", This, p);
4041     return E_NOTIMPL;
4042 }
4043
4044 static HRESULT WINAPI HTMLDocument7_put_ondurationchange(IHTMLDocument7 *iface, VARIANT v)
4045 {
4046     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4047     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4048     return E_NOTIMPL;
4049 }
4050
4051 static HRESULT WINAPI HTMLDocument7_get_ondurationchange(IHTMLDocument7 *iface, VARIANT *p)
4052 {
4053     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4054     FIXME("(%p)->(%p)\n", This, p);
4055     return E_NOTIMPL;
4056 }
4057
4058 static HRESULT WINAPI HTMLDocument7_put_onemptied(IHTMLDocument7 *iface, VARIANT v)
4059 {
4060     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4061     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4062     return E_NOTIMPL;
4063 }
4064
4065 static HRESULT WINAPI HTMLDocument7_get_onemptied(IHTMLDocument7 *iface, VARIANT *p)
4066 {
4067     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4068     FIXME("(%p)->(%p)\n", This, p);
4069     return E_NOTIMPL;
4070 }
4071
4072 static HRESULT WINAPI HTMLDocument7_put_onended(IHTMLDocument7 *iface, VARIANT v)
4073 {
4074     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4075     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4076     return E_NOTIMPL;
4077 }
4078
4079 static HRESULT WINAPI HTMLDocument7_get_onended(IHTMLDocument7 *iface, VARIANT *p)
4080 {
4081     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4082     FIXME("(%p)->(%p)\n", This, p);
4083     return E_NOTIMPL;
4084 }
4085
4086 static HRESULT WINAPI HTMLDocument7_put_onerror(IHTMLDocument7 *iface, VARIANT v)
4087 {
4088     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4089
4090     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4091
4092     return set_doc_event(This, EVENTID_ERROR, &v);
4093 }
4094
4095 static HRESULT WINAPI HTMLDocument7_get_onerror(IHTMLDocument7 *iface, VARIANT *p)
4096 {
4097     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4098
4099     TRACE("(%p)->(%p)\n", This, p);
4100
4101     return get_doc_event(This, EVENTID_ERROR, p);
4102 }
4103
4104 static HRESULT WINAPI HTMLDocument7_put_onfocus(IHTMLDocument7 *iface, VARIANT v)
4105 {
4106     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4107
4108     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4109
4110     return set_doc_event(This, EVENTID_FOCUS, &v);
4111 }
4112
4113 static HRESULT WINAPI HTMLDocument7_get_onfocus(IHTMLDocument7 *iface, VARIANT *p)
4114 {
4115     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4116
4117     TRACE("(%p)->(%p)\n", This, p);
4118
4119     return get_doc_event(This, EVENTID_FOCUS, p);
4120 }
4121
4122 static HRESULT WINAPI HTMLDocument7_put_oninput(IHTMLDocument7 *iface, VARIANT v)
4123 {
4124     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4125
4126     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4127
4128     return set_doc_event(This, EVENTID_INPUT, &v);
4129 }
4130
4131 static HRESULT WINAPI HTMLDocument7_get_oninput(IHTMLDocument7 *iface, VARIANT *p)
4132 {
4133     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4134
4135     TRACE("(%p)->(%p)\n", This, p);
4136
4137     return get_doc_event(This, EVENTID_INPUT, p);
4138 }
4139
4140 static HRESULT WINAPI HTMLDocument7_put_onload(IHTMLDocument7 *iface, VARIANT v)
4141 {
4142     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4143
4144     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4145
4146     return set_doc_event(This, EVENTID_LOAD, &v);
4147 }
4148
4149 static HRESULT WINAPI HTMLDocument7_get_onload(IHTMLDocument7 *iface, VARIANT *p)
4150 {
4151     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4152
4153     TRACE("(%p)->(%p)\n", This, p);
4154
4155     return get_doc_event(This, EVENTID_LOAD, p);
4156 }
4157
4158 static HRESULT WINAPI HTMLDocument7_put_onloadeddata(IHTMLDocument7 *iface, VARIANT v)
4159 {
4160     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4161     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4162     return E_NOTIMPL;
4163 }
4164
4165 static HRESULT WINAPI HTMLDocument7_get_onloadeddata(IHTMLDocument7 *iface, VARIANT *p)
4166 {
4167     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4168     FIXME("(%p)->(%p)\n", This, p);
4169     return E_NOTIMPL;
4170 }
4171
4172 static HRESULT WINAPI HTMLDocument7_put_onloadedmetadata(IHTMLDocument7 *iface, VARIANT v)
4173 {
4174     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4175     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4176     return E_NOTIMPL;
4177 }
4178
4179 static HRESULT WINAPI HTMLDocument7_get_onloadedmetadata(IHTMLDocument7 *iface, VARIANT *p)
4180 {
4181     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4182     FIXME("(%p)->(%p)\n", This, p);
4183     return E_NOTIMPL;
4184 }
4185
4186 static HRESULT WINAPI HTMLDocument7_put_onloadstart(IHTMLDocument7 *iface, VARIANT v)
4187 {
4188     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4189     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4190     return E_NOTIMPL;
4191 }
4192
4193 static HRESULT WINAPI HTMLDocument7_get_onloadstart(IHTMLDocument7 *iface, VARIANT *p)
4194 {
4195     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4196     FIXME("(%p)->(%p)\n", This, p);
4197     return E_NOTIMPL;
4198 }
4199
4200 static HRESULT WINAPI HTMLDocument7_put_onpause(IHTMLDocument7 *iface, VARIANT v)
4201 {
4202     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4203     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4204     return E_NOTIMPL;
4205 }
4206
4207 static HRESULT WINAPI HTMLDocument7_get_onpause(IHTMLDocument7 *iface, VARIANT *p)
4208 {
4209     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4210     FIXME("(%p)->(%p)\n", This, p);
4211     return E_NOTIMPL;
4212 }
4213
4214 static HRESULT WINAPI HTMLDocument7_put_onplay(IHTMLDocument7 *iface, VARIANT v)
4215 {
4216     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4217     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4218     return E_NOTIMPL;
4219 }
4220
4221 static HRESULT WINAPI HTMLDocument7_get_onplay(IHTMLDocument7 *iface, VARIANT *p)
4222 {
4223     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4224     FIXME("(%p)->(%p)\n", This, p);
4225     return E_NOTIMPL;
4226 }
4227
4228 static HRESULT WINAPI HTMLDocument7_put_onplaying(IHTMLDocument7 *iface, VARIANT v)
4229 {
4230     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4231     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4232     return E_NOTIMPL;
4233 }
4234
4235 static HRESULT WINAPI HTMLDocument7_get_onplaying(IHTMLDocument7 *iface, VARIANT *p)
4236 {
4237     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4238     FIXME("(%p)->(%p)\n", This, p);
4239     return E_NOTIMPL;
4240 }
4241
4242 static HRESULT WINAPI HTMLDocument7_put_onprogress(IHTMLDocument7 *iface, VARIANT v)
4243 {
4244     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4245     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4246     return E_NOTIMPL;
4247 }
4248
4249 static HRESULT WINAPI HTMLDocument7_get_onprogress(IHTMLDocument7 *iface, VARIANT *p)
4250 {
4251     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4252     FIXME("(%p)->(%p)\n", This, p);
4253     return E_NOTIMPL;
4254 }
4255
4256 static HRESULT WINAPI HTMLDocument7_put_onratechange(IHTMLDocument7 *iface, VARIANT v)
4257 {
4258     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4259     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4260     return E_NOTIMPL;
4261 }
4262
4263 static HRESULT WINAPI HTMLDocument7_get_onratechange(IHTMLDocument7 *iface, VARIANT *p)
4264 {
4265     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4266     FIXME("(%p)->(%p)\n", This, p);
4267     return E_NOTIMPL;
4268 }
4269
4270 static HRESULT WINAPI HTMLDocument7_put_onreset(IHTMLDocument7 *iface, VARIANT v)
4271 {
4272     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4273     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4274     return E_NOTIMPL;
4275 }
4276
4277 static HRESULT WINAPI HTMLDocument7_get_onreset(IHTMLDocument7 *iface, VARIANT *p)
4278 {
4279     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4280     FIXME("(%p)->(%p)\n", This, p);
4281     return E_NOTIMPL;
4282 }
4283
4284 static HRESULT WINAPI HTMLDocument7_put_onscroll(IHTMLDocument7 *iface, VARIANT v)
4285 {
4286     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4287
4288     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4289
4290     return set_doc_event(This, EVENTID_SCROLL, &v);
4291 }
4292
4293 static HRESULT WINAPI HTMLDocument7_get_onscroll(IHTMLDocument7 *iface, VARIANT *p)
4294 {
4295     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4296
4297     TRACE("(%p)->(%p)\n", This, p);
4298
4299     return get_doc_event(This, EVENTID_SCROLL, p);
4300 }
4301
4302 static HRESULT WINAPI HTMLDocument7_put_onseekend(IHTMLDocument7 *iface, VARIANT v)
4303 {
4304     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4305     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4306     return E_NOTIMPL;
4307 }
4308
4309 static HRESULT WINAPI HTMLDocument7_get_onseekend(IHTMLDocument7 *iface, VARIANT *p)
4310 {
4311     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4312     FIXME("(%p)->(%p)\n", This, p);
4313     return E_NOTIMPL;
4314 }
4315
4316 static HRESULT WINAPI HTMLDocument7_put_onseeking(IHTMLDocument7 *iface, VARIANT v)
4317 {
4318     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4319     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4320     return E_NOTIMPL;
4321 }
4322
4323 static HRESULT WINAPI HTMLDocument7_get_onseeking(IHTMLDocument7 *iface, VARIANT *p)
4324 {
4325     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4326     FIXME("(%p)->(%p)\n", This, p);
4327     return E_NOTIMPL;
4328 }
4329
4330 static HRESULT WINAPI HTMLDocument7_put_onselect(IHTMLDocument7 *iface, VARIANT v)
4331 {
4332     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4333     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4334     return E_NOTIMPL;
4335 }
4336
4337 static HRESULT WINAPI HTMLDocument7_get_onselect(IHTMLDocument7 *iface, VARIANT *p)
4338 {
4339     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4340     FIXME("(%p)->(%p)\n", This, p);
4341     return E_NOTIMPL;
4342 }
4343
4344 static HRESULT WINAPI HTMLDocument7_put_onstalled(IHTMLDocument7 *iface, VARIANT v)
4345 {
4346     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4347     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4348     return E_NOTIMPL;
4349 }
4350
4351 static HRESULT WINAPI HTMLDocument7_get_onstalled(IHTMLDocument7 *iface, VARIANT *p)
4352 {
4353     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4354     FIXME("(%p)->(%p)\n", This, p);
4355     return E_NOTIMPL;
4356 }
4357
4358 static HRESULT WINAPI HTMLDocument7_put_onsubmit(IHTMLDocument7 *iface, VARIANT v)
4359 {
4360     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4361
4362     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4363
4364     return set_doc_event(This, EVENTID_SUBMIT, &v);
4365 }
4366
4367 static HRESULT WINAPI HTMLDocument7_get_onsubmit(IHTMLDocument7 *iface, VARIANT *p)
4368 {
4369     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4370
4371     TRACE("(%p)->(%p)\n", This, p);
4372
4373     return get_doc_event(This, EVENTID_SUBMIT, p);
4374 }
4375
4376 static HRESULT WINAPI HTMLDocument7_put_onsuspend(IHTMLDocument7 *iface, VARIANT v)
4377 {
4378     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4379     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4380     return E_NOTIMPL;
4381 }
4382
4383 static HRESULT WINAPI HTMLDocument7_get_onsuspend(IHTMLDocument7 *iface, VARIANT *p)
4384 {
4385     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4386     FIXME("(%p)->(%p)\n", This, p);
4387     return E_NOTIMPL;
4388 }
4389
4390 static HRESULT WINAPI HTMLDocument7_put_ontimeupdate(IHTMLDocument7 *iface, VARIANT v)
4391 {
4392     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4393     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4394     return E_NOTIMPL;
4395 }
4396
4397 static HRESULT WINAPI HTMLDocument7_get_ontimeupdate(IHTMLDocument7 *iface, VARIANT *p)
4398 {
4399     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4400     FIXME("(%p)->(%p)\n", This, p);
4401     return E_NOTIMPL;
4402 }
4403
4404 static HRESULT WINAPI HTMLDocument7_put_onvolumechange(IHTMLDocument7 *iface, VARIANT v)
4405 {
4406     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4407     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4408     return E_NOTIMPL;
4409 }
4410
4411 static HRESULT WINAPI HTMLDocument7_get_onvolumechange(IHTMLDocument7 *iface, VARIANT *p)
4412 {
4413     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4414     FIXME("(%p)->(%p)\n", This, p);
4415     return E_NOTIMPL;
4416 }
4417
4418 static HRESULT WINAPI HTMLDocument7_put_onwaiting(IHTMLDocument7 *iface, VARIANT v)
4419 {
4420     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4421     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4422     return E_NOTIMPL;
4423 }
4424
4425 static HRESULT WINAPI HTMLDocument7_get_onwaiting(IHTMLDocument7 *iface, VARIANT *p)
4426 {
4427     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4428     FIXME("(%p)->(%p)\n", This, p);
4429     return E_NOTIMPL;
4430 }
4431
4432 static HRESULT WINAPI HTMLDocument7_normalize(IHTMLDocument7 *iface)
4433 {
4434     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4435     FIXME("(%p)\n", This);
4436     return E_NOTIMPL;
4437 }
4438
4439 static HRESULT WINAPI HTMLDocument7_importNode(IHTMLDocument7 *iface, IHTMLDOMNode *pNodeSource,
4440         VARIANT_BOOL fDeep, IHTMLDOMNode3 **ppNodeDest)
4441 {
4442     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4443     nsIDOMNode *nsnode = NULL;
4444     HTMLDOMNode *node;
4445     nsresult nsres;
4446     HRESULT hres;
4447
4448     TRACE("(%p)->(%p %x %p)\n", This, pNodeSource, fDeep, ppNodeDest);
4449
4450     if(!This->dom_document) {
4451         WARN("NULL dom_document\n");
4452         return E_UNEXPECTED;
4453     }
4454
4455     if(!(node = unsafe_impl_from_IHTMLDOMNode(pNodeSource))) {
4456         ERR("not our node\n");
4457         return E_FAIL;
4458     }
4459
4460     nsres = nsIDOMDocument_ImportNode(This->dom_document, node->nsnode, !!fDeep, 1, &nsnode);
4461     if(NS_FAILED(nsres)) {
4462         ERR("ImportNode failed: %08lx\n", nsres);
4463         return map_nsresult(nsres);
4464     }
4465
4466     if(!nsnode) {
4467         *ppNodeDest = NULL;
4468         return S_OK;
4469     }
4470
4471     hres = get_node(nsnode, TRUE, &node);
4472     nsIDOMNode_Release(nsnode);
4473     if(FAILED(hres))
4474         return hres;
4475
4476     *ppNodeDest = &node->IHTMLDOMNode3_iface;
4477     return hres;
4478 }
4479
4480 static HRESULT WINAPI HTMLDocument7_get_parentWindow(IHTMLDocument7 *iface, IHTMLWindow2 **p)
4481 {
4482     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4483
4484     TRACE("(%p)->(%p)\n", This, p);
4485
4486     return IHTMLDocument7_get_defaultView(&This->IHTMLDocument7_iface, p);
4487 }
4488
4489 static HRESULT WINAPI HTMLDocument7_put_body(IHTMLDocument7 *iface, IHTMLElement *v)
4490 {
4491     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4492     FIXME("(%p)->(%p)\n", This, v);
4493     return E_NOTIMPL;
4494 }
4495
4496 static HRESULT WINAPI HTMLDocument7_get_body(IHTMLDocument7 *iface, IHTMLElement **p)
4497 {
4498     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4499
4500     TRACE("(%p)->(%p)\n", This, p);
4501
4502     return IHTMLDocument2_get_body(&This->IHTMLDocument2_iface, p);
4503 }
4504
4505 static HRESULT WINAPI HTMLDocument7_get_head(IHTMLDocument7 *iface, IHTMLElement **p)
4506 {
4507     HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface);
4508     nsIDOMHTMLHeadElement *nshead;
4509     nsIDOMElement *nselem;
4510     HTMLElement *elem;
4511     nsresult nsres;
4512     HRESULT hres;
4513
4514     TRACE("(%p)->(%p)\n", This, p);
4515
4516     if(!This->dom_document) {
4517         FIXME("No document\n");
4518         return E_FAIL;
4519     }
4520
4521     if(!This->html_document) {
4522         FIXME("Not implemented for XML document\n");
4523         return E_NOTIMPL;
4524     }
4525
4526     nsres = nsIDOMHTMLDocument_GetHead(This->html_document, &nshead);
4527     assert(nsres == NS_OK);
4528
4529     if(!nshead) {
4530         *p = NULL;
4531         return S_OK;
4532     }
4533
4534     nsres = nsIDOMHTMLHeadElement_QueryInterface(nshead, &IID_nsIDOMElement, (void**)&nselem);
4535     nsIDOMHTMLHeadElement_Release(nshead);
4536     assert(nsres == NS_OK);
4537
4538     hres = get_element(nselem, &elem);
4539     nsIDOMElement_Release(nselem);
4540     if(FAILED(hres))
4541         return hres;
4542
4543     *p = &elem->IHTMLElement_iface;
4544     return S_OK;
4545 }
4546
4547 static const IHTMLDocument7Vtbl HTMLDocument7Vtbl = {
4548     HTMLDocument7_QueryInterface,
4549     HTMLDocument7_AddRef,
4550     HTMLDocument7_Release,
4551     HTMLDocument7_GetTypeInfoCount,
4552     HTMLDocument7_GetTypeInfo,
4553     HTMLDocument7_GetIDsOfNames,
4554     HTMLDocument7_Invoke,
4555     HTMLDocument7_get_defaultView,
4556     HTMLDocument7_createCDATASection,
4557     HTMLDocument7_getSelection,
4558     HTMLDocument7_getElementsByTagNameNS,
4559     HTMLDocument7_createElementNS,
4560     HTMLDocument7_createAttributeNS,
4561     HTMLDocument7_put_onmsthumbnailclick,
4562     HTMLDocument7_get_onmsthumbnailclick,
4563     HTMLDocument7_get_characterSet,
4564     HTMLDocument7_createElement,
4565     HTMLDocument7_createAttribute,
4566     HTMLDocument7_getElementsByClassName,
4567     HTMLDocument7_createProcessingInstruction,
4568     HTMLDocument7_adoptNode,
4569     HTMLDocument7_put_onmssitemodejumplistitemremoved,
4570     HTMLDocument7_get_onmssitemodejumplistitemremoved,
4571     HTMLDocument7_get_all,
4572     HTMLDocument7_get_inputEncoding,
4573     HTMLDocument7_get_xmlEncoding,
4574     HTMLDocument7_put_xmlStandalone,
4575     HTMLDocument7_get_xmlStandalone,
4576     HTMLDocument7_put_xmlVersion,
4577     HTMLDocument7_get_xmlVersion,
4578     HTMLDocument7_hasAttributes,
4579     HTMLDocument7_put_onabort,
4580     HTMLDocument7_get_onabort,
4581     HTMLDocument7_put_onblur,
4582     HTMLDocument7_get_onblur,
4583     HTMLDocument7_put_oncanplay,
4584     HTMLDocument7_get_oncanplay,
4585     HTMLDocument7_put_oncanplaythrough,
4586     HTMLDocument7_get_oncanplaythrough,
4587     HTMLDocument7_put_onchange,
4588     HTMLDocument7_get_onchange,
4589     HTMLDocument7_put_ondrag,
4590     HTMLDocument7_get_ondrag,
4591     HTMLDocument7_put_ondragend,
4592     HTMLDocument7_get_ondragend,
4593     HTMLDocument7_put_ondragenter,
4594     HTMLDocument7_get_ondragenter,
4595     HTMLDocument7_put_ondragleave,
4596     HTMLDocument7_get_ondragleave,
4597     HTMLDocument7_put_ondragover,
4598     HTMLDocument7_get_ondragover,
4599     HTMLDocument7_put_ondrop,
4600     HTMLDocument7_get_ondrop,
4601     HTMLDocument7_put_ondurationchange,
4602     HTMLDocument7_get_ondurationchange,
4603     HTMLDocument7_put_onemptied,
4604     HTMLDocument7_get_onemptied,
4605     HTMLDocument7_put_onended,
4606     HTMLDocument7_get_onended,
4607     HTMLDocument7_put_onerror,
4608     HTMLDocument7_get_onerror,
4609     HTMLDocument7_put_onfocus,
4610     HTMLDocument7_get_onfocus,
4611     HTMLDocument7_put_oninput,
4612     HTMLDocument7_get_oninput,
4613     HTMLDocument7_put_onload,
4614     HTMLDocument7_get_onload,
4615     HTMLDocument7_put_onloadeddata,
4616     HTMLDocument7_get_onloadeddata,
4617     HTMLDocument7_put_onloadedmetadata,
4618     HTMLDocument7_get_onloadedmetadata,
4619     HTMLDocument7_put_onloadstart,
4620     HTMLDocument7_get_onloadstart,
4621     HTMLDocument7_put_onpause,
4622     HTMLDocument7_get_onpause,
4623     HTMLDocument7_put_onplay,
4624     HTMLDocument7_get_onplay,
4625     HTMLDocument7_put_onplaying,
4626     HTMLDocument7_get_onplaying,
4627     HTMLDocument7_put_onprogress,
4628     HTMLDocument7_get_onprogress,
4629     HTMLDocument7_put_onratechange,
4630     HTMLDocument7_get_onratechange,
4631     HTMLDocument7_put_onreset,
4632     HTMLDocument7_get_onreset,
4633     HTMLDocument7_put_onscroll,
4634     HTMLDocument7_get_onscroll,
4635     HTMLDocument7_put_onseekend,
4636     HTMLDocument7_get_onseekend,
4637     HTMLDocument7_put_onseeking,
4638     HTMLDocument7_get_onseeking,
4639     HTMLDocument7_put_onselect,
4640     HTMLDocument7_get_onselect,
4641     HTMLDocument7_put_onstalled,
4642     HTMLDocument7_get_onstalled,
4643     HTMLDocument7_put_onsubmit,
4644     HTMLDocument7_get_onsubmit,
4645     HTMLDocument7_put_onsuspend,
4646     HTMLDocument7_get_onsuspend,
4647     HTMLDocument7_put_ontimeupdate,
4648     HTMLDocument7_get_ontimeupdate,
4649     HTMLDocument7_put_onvolumechange,
4650     HTMLDocument7_get_onvolumechange,
4651     HTMLDocument7_put_onwaiting,
4652     HTMLDocument7_get_onwaiting,
4653     HTMLDocument7_normalize,
4654     HTMLDocument7_importNode,
4655     HTMLDocument7_get_parentWindow,
4656     HTMLDocument7_put_body,
4657     HTMLDocument7_get_body,
4658     HTMLDocument7_get_head
4659 };
4660
4661 static inline HTMLDocumentNode *impl_from_IDocumentSelector(IDocumentSelector *iface)
4662 {
4663     return CONTAINING_RECORD(iface, HTMLDocumentNode, IDocumentSelector_iface);
4664 }
4665
4666 static HRESULT WINAPI DocumentSelector_QueryInterface(IDocumentSelector *iface, REFIID riid, void **ppv)
4667 {
4668     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4669     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
4670 }
4671
4672 static ULONG WINAPI DocumentSelector_AddRef(IDocumentSelector *iface)
4673 {
4674     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4675     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
4676 }
4677
4678 static ULONG WINAPI DocumentSelector_Release(IDocumentSelector *iface)
4679 {
4680     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4681     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
4682 }
4683
4684 static HRESULT WINAPI DocumentSelector_GetTypeInfoCount(IDocumentSelector *iface, UINT *pctinfo)
4685 {
4686     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4687     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
4688 }
4689
4690 static HRESULT WINAPI DocumentSelector_GetTypeInfo(IDocumentSelector *iface, UINT iTInfo,
4691         LCID lcid, ITypeInfo **ppTInfo)
4692 {
4693     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4694     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4695 }
4696
4697 static HRESULT WINAPI DocumentSelector_GetIDsOfNames(IDocumentSelector *iface, REFIID riid,
4698         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4699 {
4700     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4701     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
4702             rgDispId);
4703 }
4704
4705 static HRESULT WINAPI DocumentSelector_Invoke(IDocumentSelector *iface, DISPID dispIdMember, REFIID riid,
4706         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4707 {
4708     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4709     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
4710             pDispParams, pVarResult, pExcepInfo, puArgErr);
4711 }
4712
4713 static HRESULT WINAPI DocumentSelector_querySelector(IDocumentSelector *iface, BSTR v, IHTMLElement **pel)
4714 {
4715     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4716     nsIDOMElement *nselem;
4717     HTMLElement *elem;
4718     nsAString nsstr;
4719     nsresult nsres;
4720     HRESULT hres;
4721
4722     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
4723
4724     nsAString_InitDepend(&nsstr, v);
4725     if(This->dom_document)
4726         nsres = nsIDOMDocument_QuerySelector(This->dom_document, &nsstr, &nselem);
4727     else {
4728         nsIDOMDocumentFragment *frag;
4729         nsres = nsIDOMNode_QueryInterface(This->node.nsnode, &IID_nsIDOMDocumentFragment, (void**)&frag);
4730         if(NS_SUCCEEDED(nsres)) {
4731             nsres = nsIDOMDocumentFragment_QuerySelector(frag, &nsstr, &nselem);
4732             nsIDOMDocumentFragment_Release(frag);
4733         }
4734     }
4735     nsAString_Finish(&nsstr);
4736
4737     if(NS_FAILED(nsres)) {
4738         WARN("QuerySelector failed: %08lx\n", nsres);
4739         return map_nsresult(nsres);
4740     }
4741
4742     if(!nselem) {
4743         *pel = NULL;
4744         return S_OK;
4745     }
4746
4747     hres = get_element(nselem, &elem);
4748     nsIDOMElement_Release(nselem);
4749     if(FAILED(hres))
4750         return hres;
4751
4752     *pel = &elem->IHTMLElement_iface;
4753     return S_OK;
4754 }
4755
4756 static HRESULT WINAPI DocumentSelector_querySelectorAll(IDocumentSelector *iface, BSTR v, IHTMLDOMChildrenCollection **pel)
4757 {
4758     HTMLDocumentNode *This = impl_from_IDocumentSelector(iface);
4759     nsIDOMNodeList *node_list = NULL;
4760     nsAString nsstr;
4761     nsresult nsres;
4762     HRESULT hres;
4763
4764     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
4765
4766     nsAString_InitDepend(&nsstr, v);
4767     if(This->dom_document)
4768         nsres = nsIDOMDocument_QuerySelectorAll(This->dom_document, &nsstr, &node_list);
4769     else {
4770         nsIDOMDocumentFragment *frag;
4771         nsres = nsIDOMNode_QueryInterface(This->node.nsnode, &IID_nsIDOMDocumentFragment, (void**)&frag);
4772         if(NS_SUCCEEDED(nsres)) {
4773             nsres = nsIDOMDocumentFragment_QuerySelectorAll(frag, &nsstr, &node_list);
4774             nsIDOMDocumentFragment_Release(frag);
4775         }
4776     }
4777     nsAString_Finish(&nsstr);
4778
4779     if(NS_FAILED(nsres)) {
4780         WARN("QuerySelectorAll failed: %08lx\n", nsres);
4781         if(node_list)
4782             nsIDOMNodeList_Release(node_list);
4783         return map_nsresult(nsres);
4784     }
4785
4786     hres = create_child_collection(node_list, dispex_compat_mode(&This->node.event_target.dispex), pel);
4787     nsIDOMNodeList_Release(node_list);
4788     return hres;
4789 }
4790
4791 static const IDocumentSelectorVtbl DocumentSelectorVtbl = {
4792     DocumentSelector_QueryInterface,
4793     DocumentSelector_AddRef,
4794     DocumentSelector_Release,
4795     DocumentSelector_GetTypeInfoCount,
4796     DocumentSelector_GetTypeInfo,
4797     DocumentSelector_GetIDsOfNames,
4798     DocumentSelector_Invoke,
4799     DocumentSelector_querySelector,
4800     DocumentSelector_querySelectorAll
4801 };
4802
4803 static inline HTMLDocumentNode *impl_from_IDocumentEvent(IDocumentEvent *iface)
4804 {
4805     return CONTAINING_RECORD(iface, HTMLDocumentNode, IDocumentEvent_iface);
4806 }
4807
4808 static HRESULT WINAPI DocumentEvent_QueryInterface(IDocumentEvent *iface, REFIID riid, void **ppv)
4809 {
4810     HTMLDocumentNode *This = impl_from_IDocumentEvent(iface);
4811     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
4812 }
4813
4814 static ULONG WINAPI DocumentEvent_AddRef(IDocumentEvent *iface)
4815 {
4816     HTMLDocumentNode *This = impl_from_IDocumentEvent(iface);
4817     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
4818 }
4819
4820 static ULONG WINAPI DocumentEvent_Release(IDocumentEvent *iface)
4821 {
4822     HTMLDocumentNode *This = impl_from_IDocumentEvent(iface);
4823     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
4824 }
4825
4826 static HRESULT WINAPI DocumentEvent_GetTypeInfoCount(IDocumentEvent *iface, UINT *pctinfo)
4827 {
4828     HTMLDocumentNode *This = impl_from_IDocumentEvent(iface);
4829     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
4830 }
4831
4832 static HRESULT WINAPI DocumentEvent_GetTypeInfo(IDocumentEvent *iface, UINT iTInfo,
4833         LCID lcid, ITypeInfo **ppTInfo)
4834 {
4835     HTMLDocumentNode *This = impl_from_IDocumentEvent(iface);
4836     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4837 }
4838
4839 static HRESULT WINAPI DocumentEvent_GetIDsOfNames(IDocumentEvent *iface, REFIID riid,
4840         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4841 {
4842     HTMLDocumentNode *This = impl_from_IDocumentEvent(iface);
4843     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
4844             rgDispId);
4845 }
4846
4847 static HRESULT WINAPI DocumentEvent_Invoke(IDocumentEvent *iface, DISPID dispIdMember, REFIID riid,
4848         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4849 {
4850     HTMLDocumentNode *This = impl_from_IDocumentEvent(iface);
4851     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
4852             pDispParams, pVarResult, pExcepInfo, puArgErr);
4853 }
4854
4855 static HRESULT WINAPI DocumentEvent_createEvent(IDocumentEvent *iface, BSTR eventType, IDOMEvent **p)
4856 {
4857     HTMLDocumentNode *This = impl_from_IDocumentEvent(iface);
4858
4859     TRACE("(%p)->(%s %p)\n", This, debugstr_w(eventType), p);
4860
4861     return create_document_event_str(This, eventType, p);
4862 }
4863
4864 static const IDocumentEventVtbl DocumentEventVtbl = {
4865     DocumentEvent_QueryInterface,
4866     DocumentEvent_AddRef,
4867     DocumentEvent_Release,
4868     DocumentEvent_GetTypeInfoCount,
4869     DocumentEvent_GetTypeInfo,
4870     DocumentEvent_GetIDsOfNames,
4871     DocumentEvent_Invoke,
4872     DocumentEvent_createEvent
4873 };
4874
4875 static void HTMLDocumentNode_on_advise(IUnknown *iface, cp_static_data_t *cp)
4876 {
4877     HTMLDocumentNode *This = CONTAINING_RECORD((IHTMLDocument2*)iface, HTMLDocumentNode, IHTMLDocument2_iface);
4878
4879     if(This->outer_window)
4880         update_doc_cp_events(This, cp);
4881 }
4882
4883 static inline HTMLDocumentNode *impl_from_ISupportErrorInfo(ISupportErrorInfo *iface)
4884 {
4885     return CONTAINING_RECORD(iface, HTMLDocumentNode, ISupportErrorInfo_iface);
4886 }
4887
4888 static HRESULT WINAPI SupportErrorInfo_QueryInterface(ISupportErrorInfo *iface, REFIID riid, void **ppv)
4889 {
4890     HTMLDocumentNode *This = impl_from_ISupportErrorInfo(iface);
4891     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
4892 }
4893
4894 static ULONG WINAPI SupportErrorInfo_AddRef(ISupportErrorInfo *iface)
4895 {
4896     HTMLDocumentNode *This = impl_from_ISupportErrorInfo(iface);
4897     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
4898 }
4899
4900 static ULONG WINAPI SupportErrorInfo_Release(ISupportErrorInfo *iface)
4901 {
4902     HTMLDocumentNode *This = impl_from_ISupportErrorInfo(iface);
4903     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
4904 }
4905
4906 static HRESULT WINAPI SupportErrorInfo_InterfaceSupportsErrorInfo(ISupportErrorInfo *iface, REFIID riid)
4907 {
4908     FIXME("(%p)->(%s)\n", iface, debugstr_mshtml_guid(riid));
4909     return S_FALSE;
4910 }
4911
4912 static const ISupportErrorInfoVtbl SupportErrorInfoVtbl = {
4913     SupportErrorInfo_QueryInterface,
4914     SupportErrorInfo_AddRef,
4915     SupportErrorInfo_Release,
4916     SupportErrorInfo_InterfaceSupportsErrorInfo
4917 };
4918
4919 static inline HTMLDocumentNode *impl_from_IDispatchEx(IDispatchEx *iface)
4920 {
4921     return CONTAINING_RECORD(iface, HTMLDocumentNode, IDispatchEx_iface);
4922 }
4923
4924 static HRESULT has_elem_name(nsIDOMHTMLDocument *html_document, const WCHAR *name)
4925 {
4926     static const WCHAR fmt[] = L":-moz-any(applet,embed,form,iframe,img,object)[name=\"%s\"]";
4927     WCHAR buf[128], *selector = buf;
4928     nsAString selector_str;
4929     nsIDOMElement *nselem;
4930     nsresult nsres;
4931     size_t len;
4932
4933     len = wcslen(name) + ARRAY_SIZE(fmt) - 2 /* %s */;
4934     if(len > ARRAY_SIZE(buf) && !(selector = malloc(len * sizeof(WCHAR))))
4935         return E_OUTOFMEMORY;
4936     swprintf(selector, len, fmt, name);
4937
4938     nsAString_InitDepend(&selector_str, selector);
4939     nsres = nsIDOMHTMLDocument_QuerySelector(html_document, &selector_str, &nselem);
4940     nsAString_Finish(&selector_str);
4941     if(selector != buf)
4942         free(selector);
4943     if(NS_FAILED(nsres))
4944         return map_nsresult(nsres);
4945
4946     if(!nselem)
4947         return DISP_E_UNKNOWNNAME;
4948     nsIDOMElement_Release(nselem);
4949     return S_OK;
4950 }
4951
4952 static HRESULT get_elem_by_name_or_id(nsIDOMHTMLDocument *html_document, const WCHAR *name, nsIDOMElement **ret)
4953 {
4954     static const WCHAR fmt[] = L":-moz-any(embed,form,iframe,img):-moz-any([name=\"%s\"],[id=\"%s\"][name]),"
4955                                L":-moz-any(applet,object):-moz-any([name=\"%s\"],[id=\"%s\"])";
4956     WCHAR buf[384], *selector = buf;
4957     nsAString selector_str;
4958     nsIDOMElement *nselem;
4959     nsresult nsres;
4960     size_t len;
4961
4962     len = wcslen(name) * 4 + ARRAY_SIZE(fmt) - 8 /* %s */;
4963     if(len > ARRAY_SIZE(buf) && !(selector = malloc(len * sizeof(WCHAR))))
4964         return E_OUTOFMEMORY;
4965     swprintf(selector, len, fmt, name, name, name, name);
4966
4967     nsAString_InitDepend(&selector_str, selector);
4968     nsres = nsIDOMHTMLDocument_QuerySelector(html_document, &selector_str, &nselem);
4969     nsAString_Finish(&selector_str);
4970     if(selector != buf)
4971         free(selector);
4972     if(NS_FAILED(nsres))
4973         return map_nsresult(nsres);
4974
4975     if(ret) {
4976         *ret = nselem;
4977         return S_OK;
4978     }
4979
4980     if(nselem) {
4981         nsIDOMElement_Release(nselem);
4982         return S_OK;
4983     }
4984     return DISP_E_UNKNOWNNAME;
4985 }
4986
4987 static HRESULT dispid_from_elem_name(HTMLDocumentNode *This, const WCHAR *name, DISPID *dispid)
4988 {
4989     unsigned i;
4990
4991     for(i=0; i < This->elem_vars_cnt; i++) {
4992         if(!wcscmp(name, This->elem_vars[i])) {
4993             *dispid = MSHTML_DISPID_CUSTOM_MIN+i;
4994             return S_OK;
4995         }
4996     }
4997
4998     if(This->elem_vars_cnt == This->elem_vars_size) {
4999         WCHAR **new_vars;
5000
5001         if(This->elem_vars_size) {
5002             new_vars = realloc(This->elem_vars, This->elem_vars_size * 2 * sizeof(WCHAR*));
5003             if(!new_vars)
5004                 return E_OUTOFMEMORY;
5005             This->elem_vars_size *= 2;
5006         }else {
5007             new_vars = malloc(16 * sizeof(WCHAR*));
5008             if(!new_vars)
5009                 return E_OUTOFMEMORY;
5010             This->elem_vars_size = 16;
5011         }
5012
5013         This->elem_vars = new_vars;
5014     }
5015
5016     This->elem_vars[This->elem_vars_cnt] = wcsdup(name);
5017     if(!This->elem_vars[This->elem_vars_cnt])
5018         return E_OUTOFMEMORY;
5019
5020     *dispid = MSHTML_DISPID_CUSTOM_MIN+This->elem_vars_cnt++;
5021     return S_OK;
5022 }
5023
5024 static HRESULT WINAPI DocDispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
5025 {
5026     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5027
5028     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
5029 }
5030
5031 static ULONG WINAPI DocDispatchEx_AddRef(IDispatchEx *iface)
5032 {
5033     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5034
5035     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
5036 }
5037
5038 static ULONG WINAPI DocDispatchEx_Release(IDispatchEx *iface)
5039 {
5040     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5041
5042     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
5043 }
5044
5045 static HRESULT WINAPI DocDispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
5046 {
5047     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5048
5049     return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
5050 }
5051
5052 static HRESULT WINAPI DocDispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
5053                                                LCID lcid, ITypeInfo **ppTInfo)
5054 {
5055     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5056
5057     return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
5058 }
5059
5060 static HRESULT WINAPI DocDispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
5061                                                  LPOLESTR *rgszNames, UINT cNames,
5062                                                  LCID lcid, DISPID *rgDispId)
5063 {
5064     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5065
5066     return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId);
5067 }
5068
5069 static HRESULT WINAPI DocDispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
5070                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
5071                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
5072 {
5073     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5074
5075     TRACE("(%p)->(%ld %s %ld %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
5076           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
5077
5078     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags, pDispParams,
5079             pVarResult, pExcepInfo, NULL);
5080 }
5081
5082 static HRESULT WINAPI DocDispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
5083 {
5084     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5085     HRESULT hres;
5086
5087     hres = IDispatchEx_GetDispID(&This->node.event_target.dispex.IDispatchEx_iface, bstrName, grfdex & ~fdexNameEnsure, pid);
5088     if(hres != DISP_E_UNKNOWNNAME)
5089         return hres;
5090
5091     if(This->html_document) {
5092         hres = get_elem_by_name_or_id(This->html_document, bstrName, NULL);
5093         if(SUCCEEDED(hres))
5094             hres = dispid_from_elem_name(This, bstrName, pid);
5095     }
5096
5097     if(hres == DISP_E_UNKNOWNNAME && (grfdex & fdexNameEnsure))
5098         hres = dispex_get_dynid(&This->node.event_target.dispex, bstrName, FALSE, pid);
5099     return hres;
5100 }
5101
5102 static HRESULT WINAPI DocDispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
5103         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
5104 {
5105     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5106
5107     if(This->window) {
5108         switch(id) {
5109         case DISPID_READYSTATE:
5110             TRACE("DISPID_READYSTATE\n");
5111
5112             if(!(wFlags & DISPATCH_PROPERTYGET))
5113                 return E_INVALIDARG;
5114
5115             V_VT(pvarRes) = VT_I4;
5116             V_I4(pvarRes) = This->window->base.outer_window->readystate;
5117             return S_OK;
5118         default:
5119             break;
5120         }
5121     }
5122
5123     return IDispatchEx_InvokeEx(&This->node.event_target.dispex.IDispatchEx_iface, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
5124 }
5125
5126 static HRESULT WINAPI DocDispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
5127 {
5128     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5129
5130     return IDispatchEx_DeleteMemberByName(&This->node.event_target.dispex.IDispatchEx_iface, bstrName, grfdex);
5131 }
5132
5133 static HRESULT WINAPI DocDispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
5134 {
5135     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5136
5137     return IDispatchEx_DeleteMemberByDispID(&This->node.event_target.dispex.IDispatchEx_iface, id);
5138 }
5139
5140 static HRESULT WINAPI DocDispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
5141 {
5142     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5143
5144     return IDispatchEx_GetMemberProperties(&This->node.event_target.dispex.IDispatchEx_iface, id, grfdexFetch, pgrfdex);
5145 }
5146
5147 static HRESULT WINAPI DocDispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
5148 {
5149     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5150
5151     return IDispatchEx_GetMemberName(&This->node.event_target.dispex.IDispatchEx_iface, id, pbstrName);
5152 }
5153
5154 static HRESULT WINAPI DocDispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
5155 {
5156     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5157
5158     return IDispatchEx_GetNextDispID(&This->node.event_target.dispex.IDispatchEx_iface, grfdex, id, pid);
5159 }
5160
5161 static HRESULT WINAPI DocDispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
5162 {
5163     HTMLDocumentNode *This = impl_from_IDispatchEx(iface);
5164
5165     return IDispatchEx_GetNameSpaceParent(&This->node.event_target.dispex.IDispatchEx_iface, ppunk);
5166 }
5167
5168 static const IDispatchExVtbl DocDispatchExVtbl = {
5169     DocDispatchEx_QueryInterface,
5170     DocDispatchEx_AddRef,
5171     DocDispatchEx_Release,
5172     DocDispatchEx_GetTypeInfoCount,
5173     DocDispatchEx_GetTypeInfo,
5174     DocDispatchEx_GetIDsOfNames,
5175     DocDispatchEx_Invoke,
5176     DocDispatchEx_GetDispID,
5177     DocDispatchEx_InvokeEx,
5178     DocDispatchEx_DeleteMemberByName,
5179     DocDispatchEx_DeleteMemberByDispID,
5180     DocDispatchEx_GetMemberProperties,
5181     DocDispatchEx_GetMemberName,
5182     DocDispatchEx_GetNextDispID,
5183     DocDispatchEx_GetNameSpaceParent
5184 };
5185
5186 static inline HTMLDocumentNode *impl_from_IProvideMultipleClassInfo(IProvideMultipleClassInfo *iface)
5187 {
5188     return CONTAINING_RECORD(iface, HTMLDocumentNode, IProvideMultipleClassInfo_iface);
5189 }
5190
5191 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideMultipleClassInfo *iface,
5192         REFIID riid, void **ppv)
5193 {
5194     HTMLDocumentNode *This = impl_from_IProvideMultipleClassInfo(iface);
5195     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
5196 }
5197
5198 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideMultipleClassInfo *iface)
5199 {
5200     HTMLDocumentNode *This = impl_from_IProvideMultipleClassInfo(iface);
5201     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
5202 }
5203
5204 static ULONG WINAPI ProvideClassInfo_Release(IProvideMultipleClassInfo *iface)
5205 {
5206     HTMLDocumentNode *This = impl_from_IProvideMultipleClassInfo(iface);
5207     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
5208 }
5209
5210 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideMultipleClassInfo *iface, ITypeInfo **ppTI)
5211 {
5212     HTMLDocumentNode *This = impl_from_IProvideMultipleClassInfo(iface);
5213     TRACE("(%p)->(%p)\n", This, ppTI);
5214     return get_class_typeinfo(&CLSID_HTMLDocument, ppTI);
5215 }
5216
5217 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideMultipleClassInfo *iface, DWORD dwGuidKind, GUID *pGUID)
5218 {
5219     HTMLDocumentNode *This = impl_from_IProvideMultipleClassInfo(iface);
5220     FIXME("(%p)->(%lu %p)\n", This, dwGuidKind, pGUID);
5221     return E_NOTIMPL;
5222 }
5223
5224 static HRESULT WINAPI ProvideMultipleClassInfo_GetMultiTypeInfoCount(IProvideMultipleClassInfo *iface, ULONG *pcti)
5225 {
5226     HTMLDocumentNode *This = impl_from_IProvideMultipleClassInfo(iface);
5227     FIXME("(%p)->(%p)\n", This, pcti);
5228     *pcti = 1;
5229     return S_OK;
5230 }
5231
5232 static HRESULT WINAPI ProvideMultipleClassInfo_GetInfoOfIndex(IProvideMultipleClassInfo *iface, ULONG iti,
5233         DWORD dwFlags, ITypeInfo **pptiCoClass, DWORD *pdwTIFlags, ULONG *pcdispidReserved, IID *piidPrimary, IID *piidSource)
5234 {
5235     HTMLDocumentNode *This = impl_from_IProvideMultipleClassInfo(iface);
5236     FIXME("(%p)->(%lu %lx %p %p %p %p %p)\n", This, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource);
5237     return E_NOTIMPL;
5238 }
5239
5240 static const IProvideMultipleClassInfoVtbl ProvideMultipleClassInfoVtbl = {
5241     ProvideClassInfo_QueryInterface,
5242     ProvideClassInfo_AddRef,
5243     ProvideClassInfo_Release,
5244     ProvideClassInfo_GetClassInfo,
5245     ProvideClassInfo2_GetGUID,
5246     ProvideMultipleClassInfo_GetMultiTypeInfoCount,
5247     ProvideMultipleClassInfo_GetInfoOfIndex
5248 };
5249
5250 /**********************************************************
5251  * IMarkupServices implementation
5252  */
5253 static inline HTMLDocumentNode *impl_from_IMarkupServices(IMarkupServices *iface)
5254 {
5255     return CONTAINING_RECORD(iface, HTMLDocumentNode, IMarkupServices_iface);
5256 }
5257
5258 static HRESULT WINAPI MarkupServices_QueryInterface(IMarkupServices *iface, REFIID riid, void **ppvObject)
5259 {
5260     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5261     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppvObject);
5262 }
5263
5264 static ULONG WINAPI MarkupServices_AddRef(IMarkupServices *iface)
5265 {
5266     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5267     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
5268 }
5269
5270 static ULONG WINAPI MarkupServices_Release(IMarkupServices *iface)
5271 {
5272     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5273     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
5274 }
5275
5276 static HRESULT WINAPI MarkupServices_CreateMarkupPointer(IMarkupServices *iface, IMarkupPointer **ppPointer)
5277 {
5278     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5279
5280     TRACE("(%p)->(%p)\n", This, ppPointer);
5281
5282     return create_markup_pointer(ppPointer);
5283 }
5284
5285 static HRESULT WINAPI MarkupServices_CreateMarkupContainer(IMarkupServices *iface, IMarkupContainer **ppMarkupContainer)
5286 {
5287     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5288     FIXME("(%p)->(%p)\n", This, ppMarkupContainer);
5289     return E_NOTIMPL;
5290 }
5291
5292 static HRESULT WINAPI MarkupServices_CreateElement(IMarkupServices *iface,
5293     ELEMENT_TAG_ID tagID, OLECHAR *pchAttributes, IHTMLElement **ppElement)
5294 {
5295     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5296     FIXME("(%p)->(%d,%s,%p)\n", This, tagID, debugstr_w(pchAttributes), ppElement);
5297     return E_NOTIMPL;
5298 }
5299
5300 static HRESULT WINAPI MarkupServices_CloneElement(IMarkupServices *iface,
5301     IHTMLElement *pElemCloneThis, IHTMLElement **ppElementTheClone)
5302 {
5303     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5304     FIXME("(%p)->(%p,%p)\n", This, pElemCloneThis, ppElementTheClone);
5305     return E_NOTIMPL;
5306 }
5307
5308 static HRESULT WINAPI MarkupServices_InsertElement(IMarkupServices *iface,
5309     IHTMLElement *pElementInsert, IMarkupPointer *pPointerStart,
5310     IMarkupPointer *pPointerFinish)
5311 {
5312     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5313     FIXME("(%p)->(%p,%p,%p)\n", This, pElementInsert, pPointerStart, pPointerFinish);
5314     return E_NOTIMPL;
5315 }
5316
5317 static HRESULT WINAPI MarkupServices_RemoveElement(IMarkupServices *iface, IHTMLElement *pElementRemove)
5318 {
5319     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5320     FIXME("(%p)->(%p)\n", This, pElementRemove);
5321     return E_NOTIMPL;
5322 }
5323
5324 static HRESULT WINAPI MarkupServices_Remove(IMarkupServices *iface,
5325     IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish)
5326 {
5327     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5328     FIXME("(%p)->(%p,%p)\n", This, pPointerStart, pPointerFinish);
5329     return E_NOTIMPL;
5330 }
5331
5332 static HRESULT WINAPI MarkupServices_Copy(IMarkupServices *iface,
5333     IMarkupPointer *pPointerSourceStart, IMarkupPointer *pPointerSourceFinish,
5334     IMarkupPointer *pPointerTarget)
5335 {
5336     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5337     FIXME("(%p)->(%p,%p,%p)\n", This, pPointerSourceStart, pPointerSourceFinish, pPointerTarget);
5338     return E_NOTIMPL;
5339 }
5340
5341 static HRESULT WINAPI MarkupServices_Move(IMarkupServices *iface,
5342     IMarkupPointer *pPointerSourceStart, IMarkupPointer *pPointerSourceFinish,
5343     IMarkupPointer *pPointerTarget)
5344 {
5345     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5346     FIXME("(%p)->(%p,%p,%p)\n", This, pPointerSourceStart, pPointerSourceFinish, pPointerTarget);
5347     return E_NOTIMPL;
5348 }
5349
5350 static HRESULT WINAPI MarkupServices_InsertText(IMarkupServices *iface,
5351     OLECHAR *pchText, LONG cch, IMarkupPointer *pPointerTarget)
5352 {
5353     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5354     FIXME("(%p)->(%s,%lx,%p)\n", This, debugstr_w(pchText), cch, pPointerTarget);
5355     return E_NOTIMPL;
5356 }
5357
5358 static HRESULT WINAPI MarkupServices_ParseString(IMarkupServices *iface,
5359     OLECHAR *pchHTML, DWORD dwFlags, IMarkupContainer **ppContainerResult,
5360     IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish)
5361 {
5362     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5363     FIXME("(%p)->(%s,%lx,%p,%p,%p)\n", This, debugstr_w(pchHTML), dwFlags, ppContainerResult, pPointerStart, pPointerFinish);
5364     return E_NOTIMPL;
5365 }
5366
5367 static HRESULT WINAPI MarkupServices_ParseGlobal(IMarkupServices *iface,
5368     HGLOBAL hglobalHTML, DWORD dwFlags, IMarkupContainer **ppContainerResult,
5369     IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish)
5370 {
5371     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5372     FIXME("(%p)->(%s,%lx,%p,%p,%p)\n", This, debugstr_w(hglobalHTML), dwFlags, ppContainerResult, pPointerStart, pPointerFinish);
5373     return E_NOTIMPL;
5374 }
5375
5376 static HRESULT WINAPI MarkupServices_IsScopedElement(IMarkupServices *iface,
5377     IHTMLElement *pElement, BOOL *pfScoped)
5378 {
5379     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5380     FIXME("(%p)->(%p,%p)\n", This, pElement, pfScoped);
5381     return E_NOTIMPL;
5382 }
5383
5384 static HRESULT WINAPI MarkupServices_GetElementTagId(IMarkupServices *iface,
5385     IHTMLElement *pElement, ELEMENT_TAG_ID *ptagId)
5386 {
5387     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5388     FIXME("(%p)->(%p,%p)\n", This, pElement, ptagId);
5389     return E_NOTIMPL;
5390 }
5391
5392 static HRESULT WINAPI MarkupServices_GetTagIDForName(IMarkupServices *iface,
5393     BSTR bstrName, ELEMENT_TAG_ID *ptagId)
5394 {
5395     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5396     FIXME("(%p)->(%s,%p)\n", This, debugstr_w(bstrName), ptagId);
5397     return E_NOTIMPL;
5398 }
5399
5400 static HRESULT WINAPI MarkupServices_GetNameForTagID(IMarkupServices *iface,
5401     ELEMENT_TAG_ID tagId, BSTR *pbstrName)
5402 {
5403     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5404     FIXME("(%p)->(%d,%p)\n", This, tagId, pbstrName);
5405     return E_NOTIMPL;
5406 }
5407
5408 static HRESULT WINAPI MarkupServices_MovePointersToRange(IMarkupServices *iface,
5409     IHTMLTxtRange *pIRange, IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish)
5410 {
5411     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5412     FIXME("(%p)->(%p,%p,%p)\n", This, pIRange, pPointerStart, pPointerFinish);
5413     return E_NOTIMPL;
5414 }
5415
5416 static HRESULT WINAPI MarkupServices_MoveRangeToPointers(IMarkupServices *iface,
5417     IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish, IHTMLTxtRange *pIRange)
5418 {
5419     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5420     FIXME("(%p)->(%p,%p,%p)\n", This, pPointerStart, pPointerFinish, pIRange);
5421     return E_NOTIMPL;
5422 }
5423
5424 static HRESULT WINAPI MarkupServices_BeginUndoUnit(IMarkupServices *iface, OLECHAR *pchTitle)
5425 {
5426     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5427     FIXME("(%p)->(%s)\n", This, debugstr_w(pchTitle));
5428     return E_NOTIMPL;
5429 }
5430
5431 static HRESULT WINAPI MarkupServices_EndUndoUnit(IMarkupServices *iface)
5432 {
5433     HTMLDocumentNode *This = impl_from_IMarkupServices(iface);
5434     FIXME("(%p)\n", This);
5435     return E_NOTIMPL;
5436 }
5437
5438 static const IMarkupServicesVtbl MarkupServicesVtbl = {
5439     MarkupServices_QueryInterface,
5440     MarkupServices_AddRef,
5441     MarkupServices_Release,
5442     MarkupServices_CreateMarkupPointer,
5443     MarkupServices_CreateMarkupContainer,
5444     MarkupServices_CreateElement,
5445     MarkupServices_CloneElement,
5446     MarkupServices_InsertElement,
5447     MarkupServices_RemoveElement,
5448     MarkupServices_Remove,
5449     MarkupServices_Copy,
5450     MarkupServices_Move,
5451     MarkupServices_InsertText,
5452     MarkupServices_ParseString,
5453     MarkupServices_ParseGlobal,
5454     MarkupServices_IsScopedElement,
5455     MarkupServices_GetElementTagId,
5456     MarkupServices_GetTagIDForName,
5457     MarkupServices_GetNameForTagID,
5458     MarkupServices_MovePointersToRange,
5459     MarkupServices_MoveRangeToPointers,
5460     MarkupServices_BeginUndoUnit,
5461     MarkupServices_EndUndoUnit
5462 };
5463
5464 /**********************************************************
5465  * IMarkupContainer implementation
5466  */
5467 static inline HTMLDocumentNode *impl_from_IMarkupContainer(IMarkupContainer *iface)
5468 {
5469     return CONTAINING_RECORD(iface, HTMLDocumentNode, IMarkupContainer_iface);
5470 }
5471
5472 static HRESULT WINAPI MarkupContainer_QueryInterface(IMarkupContainer *iface, REFIID riid, void **ppvObject)
5473 {
5474     HTMLDocumentNode *This = impl_from_IMarkupContainer(iface);
5475     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppvObject);
5476 }
5477
5478 static ULONG WINAPI MarkupContainer_AddRef(IMarkupContainer *iface)
5479 {
5480     HTMLDocumentNode *This = impl_from_IMarkupContainer(iface);
5481     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
5482 }
5483
5484 static ULONG WINAPI MarkupContainer_Release(IMarkupContainer *iface)
5485 {
5486     HTMLDocumentNode *This = impl_from_IMarkupContainer(iface);
5487     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
5488 }
5489
5490 static HRESULT WINAPI MarkupContainer_OwningDoc(IMarkupContainer *iface, IHTMLDocument2 **ppDoc)
5491 {
5492     HTMLDocumentNode *This = impl_from_IMarkupContainer(iface);
5493     FIXME("(%p)->(%p)\n", This, ppDoc);
5494     return E_NOTIMPL;
5495 }
5496
5497 static const IMarkupContainerVtbl MarkupContainerVtbl = {
5498     MarkupContainer_QueryInterface,
5499     MarkupContainer_AddRef,
5500     MarkupContainer_Release,
5501     MarkupContainer_OwningDoc
5502 };
5503
5504 /**********************************************************
5505  * IDisplayServices implementation
5506  */
5507 static inline HTMLDocumentNode *impl_from_IDisplayServices(IDisplayServices *iface)
5508 {
5509     return CONTAINING_RECORD(iface, HTMLDocumentNode, IDisplayServices_iface);
5510 }
5511
5512 static HRESULT WINAPI DisplayServices_QueryInterface(IDisplayServices *iface, REFIID riid, void **ppvObject)
5513 {
5514     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5515     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppvObject);
5516 }
5517
5518 static ULONG WINAPI DisplayServices_AddRef(IDisplayServices *iface)
5519 {
5520     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5521     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
5522 }
5523
5524 static ULONG WINAPI DisplayServices_Release(IDisplayServices *iface)
5525 {
5526     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5527     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
5528 }
5529
5530 static HRESULT WINAPI DisplayServices_CreateDisplayPointer(IDisplayServices *iface, IDisplayPointer **ppDispPointer)
5531 {
5532     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5533     FIXME("(%p)->(%p)\n", This, ppDispPointer);
5534     return E_NOTIMPL;
5535 }
5536
5537 static HRESULT WINAPI DisplayServices_TransformRect(IDisplayServices *iface,
5538     RECT *pRect, COORD_SYSTEM eSource, COORD_SYSTEM eDestination, IHTMLElement *pIElement)
5539 {
5540     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5541     FIXME("(%p)->(%s,%d,%d,%p)\n", This, wine_dbgstr_rect(pRect), eSource, eDestination, pIElement);
5542     return E_NOTIMPL;
5543 }
5544
5545 static HRESULT WINAPI DisplayServices_TransformPoint(IDisplayServices *iface,
5546     POINT *pPoint, COORD_SYSTEM eSource, COORD_SYSTEM eDestination, IHTMLElement *pIElement)
5547 {
5548     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5549     FIXME("(%p)->(%s,%d,%d,%p)\n", This, wine_dbgstr_point(pPoint), eSource, eDestination, pIElement);
5550     return E_NOTIMPL;
5551 }
5552
5553 static HRESULT WINAPI DisplayServices_GetCaret(IDisplayServices *iface, IHTMLCaret **ppCaret)
5554 {
5555     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5556     FIXME("(%p)->(%p)\n", This, ppCaret);
5557     return E_NOTIMPL;
5558 }
5559
5560 static HRESULT WINAPI DisplayServices_GetComputedStyle(IDisplayServices *iface,
5561     IMarkupPointer *pPointer, IHTMLComputedStyle **ppComputedStyle)
5562 {
5563     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5564     FIXME("(%p)->(%p,%p)\n", This, pPointer, ppComputedStyle);
5565     return E_NOTIMPL;
5566 }
5567
5568 static HRESULT WINAPI DisplayServices_ScrollRectIntoView(IDisplayServices *iface,
5569     IHTMLElement *pIElement, RECT rect)
5570 {
5571     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5572     FIXME("(%p)->(%p,%s)\n", This, pIElement, wine_dbgstr_rect(&rect));
5573     return E_NOTIMPL;
5574 }
5575
5576 static HRESULT WINAPI DisplayServices_HasFlowLayout(IDisplayServices *iface,
5577     IHTMLElement *pIElement, BOOL *pfHasFlowLayout)
5578 {
5579     HTMLDocumentNode *This = impl_from_IDisplayServices(iface);
5580     FIXME("(%p)->(%p,%p)\n", This, pIElement, pfHasFlowLayout);
5581     return E_NOTIMPL;
5582 }
5583
5584 static const IDisplayServicesVtbl DisplayServicesVtbl = {
5585     DisplayServices_QueryInterface,
5586     DisplayServices_AddRef,
5587     DisplayServices_Release,
5588     DisplayServices_CreateDisplayPointer,
5589     DisplayServices_TransformRect,
5590     DisplayServices_TransformPoint,
5591     DisplayServices_GetCaret,
5592     DisplayServices_GetComputedStyle,
5593     DisplayServices_ScrollRectIntoView,
5594     DisplayServices_HasFlowLayout
5595 };
5596
5597 /**********************************************************
5598  * IDocumentRange implementation
5599  */
5600 static inline HTMLDocumentNode *impl_from_IDocumentRange(IDocumentRange *iface)
5601 {
5602     return CONTAINING_RECORD(iface, HTMLDocumentNode, IDocumentRange_iface);
5603 }
5604
5605 static HRESULT WINAPI DocumentRange_QueryInterface(IDocumentRange *iface, REFIID riid, void **ppv)
5606 {
5607     HTMLDocumentNode *This = impl_from_IDocumentRange(iface);
5608
5609     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
5610 }
5611
5612 static ULONG WINAPI DocumentRange_AddRef(IDocumentRange *iface)
5613 {
5614     HTMLDocumentNode *This = impl_from_IDocumentRange(iface);
5615
5616     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
5617 }
5618
5619 static ULONG WINAPI DocumentRange_Release(IDocumentRange *iface)
5620 {
5621     HTMLDocumentNode *This = impl_from_IDocumentRange(iface);
5622
5623     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
5624 }
5625
5626 static HRESULT WINAPI DocumentRange_GetTypeInfoCount(IDocumentRange *iface, UINT *pctinfo)
5627 {
5628     HTMLDocumentNode *This = impl_from_IDocumentRange(iface);
5629
5630     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
5631 }
5632
5633 static HRESULT WINAPI DocumentRange_GetTypeInfo(IDocumentRange *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
5634 {
5635     HTMLDocumentNode *This = impl_from_IDocumentRange(iface);
5636
5637     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
5638 }
5639
5640 static HRESULT WINAPI DocumentRange_GetIDsOfNames(IDocumentRange *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
5641     LCID lcid, DISPID *rgDispId)
5642 {
5643     HTMLDocumentNode *This = impl_from_IDocumentRange(iface);
5644
5645     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
5646             rgDispId);
5647 }
5648
5649 static HRESULT WINAPI DocumentRange_Invoke(IDocumentRange *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
5650     WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
5651 {
5652     HTMLDocumentNode *This = impl_from_IDocumentRange(iface);
5653
5654     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
5655             pDispParams, pVarResult, pExcepInfo, puArgErr);
5656 }
5657
5658 static HRESULT WINAPI DocumentRange_createRange(IDocumentRange *iface, IHTMLDOMRange **p)
5659 {
5660     HTMLDocumentNode *This = impl_from_IDocumentRange(iface);
5661     nsIDOMRange *nsrange;
5662     HRESULT hres;
5663
5664     TRACE("(%p)->(%p)\n", This, p);
5665
5666     if(!This->dom_document) {
5667         WARN("NULL dom_document\n");
5668         return E_UNEXPECTED;
5669     }
5670
5671     if(NS_FAILED(nsIDOMDocument_CreateRange(This->dom_document, &nsrange)))
5672         return E_FAIL;
5673
5674     hres = create_dom_range(nsrange, dispex_compat_mode(&This->node.event_target.dispex), p);
5675     nsIDOMRange_Release(nsrange);
5676     return hres;
5677 }
5678
5679 static const IDocumentRangeVtbl DocumentRangeVtbl = {
5680     DocumentRange_QueryInterface,
5681     DocumentRange_AddRef,
5682     DocumentRange_Release,
5683     DocumentRange_GetTypeInfoCount,
5684     DocumentRange_GetTypeInfo,
5685     DocumentRange_GetIDsOfNames,
5686     DocumentRange_Invoke,
5687     DocumentRange_createRange
5688 };
5689
5690 static cp_static_data_t HTMLDocumentNodeEvents_data = { HTMLDocumentEvents_tid, HTMLDocumentNode_on_advise };
5691 static cp_static_data_t HTMLDocumentNodeEvents2_data = { HTMLDocumentEvents2_tid, HTMLDocumentNode_on_advise, TRUE };
5692
5693 static const cpc_entry_t HTMLDocumentNode_cpc[] = {
5694     {&IID_IDispatch, &HTMLDocumentNodeEvents_data},
5695     {&IID_IPropertyNotifySink},
5696     {&DIID_HTMLDocumentEvents, &HTMLDocumentNodeEvents_data},
5697     {&DIID_HTMLDocumentEvents2, &HTMLDocumentNodeEvents2_data},
5698     {NULL}
5699 };
5700
5701 static inline HTMLDocumentNode *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
5702 {
5703     return CONTAINING_RECORD(iface, HTMLDocumentNode, node);
5704 }
5705
5706 void detach_document_node(HTMLDocumentNode *doc)
5707 {
5708     unsigned i;
5709
5710     if(doc->window) {
5711         HTMLInnerWindow *window = doc->window;
5712         doc->window = NULL;
5713         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
5714     }
5715
5716     while(!list_empty(&doc->plugin_hosts))
5717         detach_plugin_host(LIST_ENTRY(list_head(&doc->plugin_hosts), PluginHost, entry));
5718
5719     if(doc->dom_implementation)
5720         detach_dom_implementation(doc->dom_implementation);
5721
5722     unlink_ref(&doc->dom_implementation);
5723     unlink_ref(&doc->namespaces);
5724     detach_events(doc);
5725     detach_selection(doc);
5726     detach_ranges(doc);
5727
5728     for(i=0; i < doc->elem_vars_cnt; i++)
5729         free(doc->elem_vars[i]);
5730     free(doc->elem_vars);
5731     doc->elem_vars_cnt = doc->elem_vars_size = 0;
5732     doc->elem_vars = NULL;
5733
5734     unlink_ref(&doc->catmgr);
5735     if(doc->browser) {
5736         list_remove(&doc->browser_entry);
5737         doc->browser = NULL;
5738     }
5739 }
5740
5741 static HRESULT HTMLDocumentNode_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
5742 {
5743     HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
5744     FIXME("%p\n", This);
5745     return E_NOTIMPL;
5746 }
5747
5748 static const NodeImplVtbl HTMLDocumentNodeImplVtbl = {
5749     .clsid                 = &CLSID_HTMLDocument,
5750     .cpc_entries           = HTMLDocumentNode_cpc,
5751     .clone                 = HTMLDocumentNode_clone,
5752 };
5753
5754 static HRESULT HTMLDocumentFragment_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
5755 {
5756     HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
5757     HTMLDocumentNode *new_node;
5758     HRESULT hres;
5759
5760     hres = create_document_fragment(nsnode, This->node.doc, &new_node);
5761     if(FAILED(hres))
5762         return hres;
5763
5764     *ret = &new_node->node;
5765     return S_OK;
5766 }
5767
5768 static inline HTMLDocumentNode *impl_from_DispatchEx(DispatchEx *iface)
5769 {
5770     return CONTAINING_RECORD(iface, HTMLDocumentNode, node.event_target.dispex);
5771 }
5772
5773 static void *HTMLDocumentNode_query_interface(DispatchEx *dispex, REFIID riid)
5774 {
5775     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5776
5777     if(IsEqualGUID(&IID_IDispatch, riid) || IsEqualGUID(&IID_IDispatchEx, riid))
5778         return &This->IDispatchEx_iface;
5779     if(IsEqualGUID(&IID_IHTMLDocument, riid) || IsEqualGUID(&IID_IHTMLDocument2, riid))
5780         return &This->IHTMLDocument2_iface;
5781     if(IsEqualGUID(&IID_IHTMLDocument3, riid))
5782         return &This->IHTMLDocument3_iface;
5783     if(IsEqualGUID(&IID_IHTMLDocument4, riid))
5784         return &This->IHTMLDocument4_iface;
5785     if(IsEqualGUID(&IID_IHTMLDocument5, riid))
5786         return &This->IHTMLDocument5_iface;
5787     if(IsEqualGUID(&IID_IHTMLDocument6, riid))
5788         return &This->IHTMLDocument6_iface;
5789     if(IsEqualGUID(&IID_IHTMLDocument7, riid))
5790         return &This->IHTMLDocument7_iface;
5791     if(IsEqualGUID(&IID_IDocumentSelector, riid))
5792         return &This->IDocumentSelector_iface;
5793     if(IsEqualGUID(&IID_IDocumentEvent, riid))
5794         return &This->IDocumentEvent_iface;
5795     if(IsEqualGUID(&DIID_DispHTMLDocument, riid))
5796         return &This->IHTMLDocument2_iface;
5797     if(IsEqualGUID(&IID_ISupportErrorInfo, riid))
5798         return &This->ISupportErrorInfo_iface;
5799     if(IsEqualGUID(&IID_IProvideClassInfo, riid))
5800         return &This->IProvideMultipleClassInfo_iface;
5801     if(IsEqualGUID(&IID_IProvideClassInfo2, riid))
5802         return &This->IProvideMultipleClassInfo_iface;
5803     if(IsEqualGUID(&IID_IProvideMultipleClassInfo, riid))
5804         return &This->IProvideMultipleClassInfo_iface;
5805     if(IsEqualGUID(&IID_IMarkupServices, riid))
5806         return &This->IMarkupServices_iface;
5807     if(IsEqualGUID(&IID_IMarkupContainer, riid))
5808         return &This->IMarkupContainer_iface;
5809     if(IsEqualGUID(&IID_IDisplayServices, riid))
5810         return &This->IDisplayServices_iface;
5811     if(IsEqualGUID(&IID_IDocumentRange, riid))
5812         return &This->IDocumentRange_iface;
5813     if(IsEqualGUID(&IID_IPersist, riid))
5814         return &This->IPersistFile_iface;
5815     if(IsEqualGUID(&IID_IPersistMoniker, riid))
5816         return &This->IPersistMoniker_iface;
5817     if(IsEqualGUID(&IID_IPersistFile, riid))
5818         return &This->IPersistFile_iface;
5819     if(IsEqualGUID(&IID_IMonikerProp, riid))
5820         return &This->IMonikerProp_iface;
5821     if(IsEqualGUID(&IID_IPersistStreamInit, riid))
5822         return &This->IPersistStreamInit_iface;
5823     if(IsEqualGUID(&IID_IPersistHistory, riid))
5824         return &This->IPersistHistory_iface;
5825     if(IsEqualGUID(&IID_IHlinkTarget, riid))
5826         return &This->IHlinkTarget_iface;
5827     if(IsEqualGUID(&IID_IOleCommandTarget, riid))
5828         return &This->IOleCommandTarget_iface;
5829     if(IsEqualGUID(&IID_IOleObject, riid))
5830         return &This->IOleObject_iface;
5831     if(IsEqualGUID(&IID_IOleDocument, riid))
5832         return &This->IOleDocument_iface;
5833     if(IsEqualGUID(&IID_IOleInPlaceActiveObject, riid))
5834         return &This->IOleInPlaceActiveObject_iface;
5835     if(IsEqualGUID(&IID_IOleWindow, riid))
5836         return &This->IOleInPlaceActiveObject_iface;
5837     if(IsEqualGUID(&IID_IOleInPlaceObject, riid))
5838         return &This->IOleInPlaceObjectWindowless_iface;
5839     if(IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid))
5840         return &This->IOleInPlaceObjectWindowless_iface;
5841     if(IsEqualGUID(&IID_IOleControl, riid))
5842         return &This->IOleControl_iface;
5843     if(IsEqualGUID(&IID_IObjectWithSite, riid))
5844         return &This->IObjectWithSite_iface;
5845     if(IsEqualGUID(&IID_IOleContainer, riid))
5846         return &This->IOleContainer_iface;
5847     if(IsEqualGUID(&IID_IObjectSafety, riid))
5848         return &This->IObjectSafety_iface;
5849     if(IsEqualGUID(&IID_IServiceProvider, riid))
5850         return &This->IServiceProvider_iface;
5851     if(IsEqualGUID(&IID_IInternetHostSecurityManager, riid))
5852         return &This->IInternetHostSecurityManager_iface;
5853     if(IsEqualGUID(&IID_IConnectionPointContainer, riid))
5854         return &This->cp_container.IConnectionPointContainer_iface;
5855     if(IsEqualGUID(&CLSID_CMarkup, riid)) {
5856         FIXME("(%p)->(CLSID_CMarkup)\n", This);
5857         return NULL;
5858     }else if(IsEqualGUID(&IID_IRunnableObject, riid)) {
5859         return NULL;
5860     }else if(IsEqualGUID(&IID_IPersistPropertyBag, riid)) {
5861         return NULL;
5862     }else if(IsEqualGUID(&IID_IExternalConnection, riid)) {
5863         return NULL;
5864     }else if(IsEqualGUID(&IID_IStdMarshalInfo, riid)) {
5865         return NULL;
5866     }
5867
5868     return HTMLDOMNode_query_interface(&This->node.event_target.dispex, riid);
5869 }
5870
5871 static void HTMLDocumentNode_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
5872 {
5873     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5874     HTMLDOMNode_traverse(dispex, cb);
5875
5876     if(This->window)
5877         note_cc_edge((nsISupports*)&This->window->base.IHTMLWindow2_iface, "window", cb);
5878     if(This->dom_implementation)
5879         note_cc_edge((nsISupports*)This->dom_implementation, "dom_implementation", cb);
5880     if(This->namespaces)
5881         note_cc_edge((nsISupports*)This->namespaces, "namespaces", cb);
5882 }
5883
5884 static void HTMLDocumentNode_unlink(DispatchEx *dispex)
5885 {
5886     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5887     HTMLDOMNode_unlink(dispex);
5888
5889     if(This->dom_document) {
5890         release_document_mutation(This);
5891         detach_document_node(This);
5892         This->dom_document = NULL;
5893         This->html_document = NULL;
5894     }else if(This->window) {
5895         detach_document_node(This);
5896     }
5897 }
5898
5899 static void HTMLDocumentNode_destructor(DispatchEx *dispex)
5900 {
5901     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5902
5903     free(This->event_vector);
5904     ConnectionPointContainer_Destroy(&This->cp_container);
5905     HTMLDOMNode_destructor(&This->node.event_target.dispex);
5906 }
5907
5908 static HRESULT HTMLDocumentNode_get_name(DispatchEx *dispex, DISPID id, BSTR *name)
5909 {
5910     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5911     DWORD idx = id - MSHTML_DISPID_CUSTOM_MIN;
5912
5913     if(!This->dom_document || idx >= This->elem_vars_cnt)
5914         return DISP_E_MEMBERNOTFOUND;
5915
5916     return (*name = SysAllocString(This->elem_vars[idx])) ? S_OK : E_OUTOFMEMORY;
5917 }
5918
5919 static HRESULT HTMLDocumentNode_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
5920         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
5921 {
5922     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5923     nsIDOMElement *nselem;
5924     HTMLDOMNode *node;
5925     unsigned i;
5926     HRESULT hres;
5927
5928     if(flags != DISPATCH_PROPERTYGET && flags != (DISPATCH_METHOD|DISPATCH_PROPERTYGET))
5929         return MSHTML_E_INVALID_PROPERTY;
5930
5931     i = id - MSHTML_DISPID_CUSTOM_MIN;
5932
5933     if(!This->html_document || i >= This->elem_vars_cnt)
5934         return DISP_E_MEMBERNOTFOUND;
5935
5936     hres = get_elem_by_name_or_id(This->html_document, This->elem_vars[i], &nselem);
5937     if(FAILED(hres))
5938         return hres;
5939     if(!nselem)
5940         return DISP_E_MEMBERNOTFOUND;
5941
5942     hres = get_node((nsIDOMNode*)nselem, TRUE, &node);
5943     nsIDOMElement_Release(nselem);
5944     if(FAILED(hres))
5945         return hres;
5946
5947     V_VT(res) = VT_DISPATCH;
5948     V_DISPATCH(res) = (IDispatch*)&node->IHTMLDOMNode_iface;
5949     return S_OK;
5950 }
5951
5952 static HRESULT HTMLDocumentNode_next_dispid(DispatchEx *dispex, DISPID id, DISPID *pid)
5953 {
5954     DWORD idx = (id == DISPID_STARTENUM) ? 0 : id - MSHTML_DISPID_CUSTOM_MIN + 1;
5955     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5956     nsIDOMNodeList *node_list = NULL;
5957     const PRUnichar *name;
5958     nsIDOMElement *nselem;
5959     nsIDOMNode *nsnode;
5960     nsAString nsstr;
5961     nsresult nsres;
5962     HRESULT hres;
5963     UINT32 i;
5964
5965     if(!This->html_document)
5966         return S_FALSE;
5967
5968     while(idx < This->elem_vars_cnt) {
5969         hres = has_elem_name(This->html_document, This->elem_vars[idx]);
5970         if(SUCCEEDED(hres)) {
5971             *pid = idx + MSHTML_DISPID_CUSTOM_MIN;
5972             return S_OK;
5973         }
5974         if(hres != DISP_E_UNKNOWNNAME)
5975             return hres;
5976         idx++;
5977     }
5978
5979     /* Populate possibly missing DISPIDs */
5980     nsAString_InitDepend(&nsstr, L":-moz-any(applet,embed,form,iframe,img,object)[name]");
5981     nsres = nsIDOMHTMLDocument_QuerySelectorAll(This->html_document, &nsstr, &node_list);
5982     nsAString_Finish(&nsstr);
5983     if(NS_FAILED(nsres)) {
5984         if(node_list)
5985             nsIDOMNodeList_Release(node_list);
5986         return map_nsresult(nsres);
5987     }
5988
5989     for(i = 0, hres = S_OK; SUCCEEDED(hres); i++) {
5990         nsres = nsIDOMNodeList_Item(node_list, i, &nsnode);
5991         if(NS_FAILED(nsres)) {
5992             hres = map_nsresult(nsres);
5993             break;
5994         }
5995         if(!nsnode)
5996             break;
5997
5998         nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMElement, (void**)&nselem);
5999         nsIDOMNode_Release(nsnode);
6000         if(nsres != S_OK)
6001             continue;
6002
6003         nsres = get_elem_attr_value(nselem, L"name", &nsstr, &name);
6004         nsIDOMElement_Release(nselem);
6005         if(NS_FAILED(nsres))
6006             hres = map_nsresult(nsres);
6007         else {
6008             hres = dispid_from_elem_name(This, name, &id);
6009             nsAString_Finish(&nsstr);
6010         }
6011     }
6012     nsIDOMNodeList_Release(node_list);
6013     if(FAILED(hres))
6014         return hres;
6015
6016     if(idx >= This->elem_vars_cnt)
6017         return S_FALSE;
6018
6019     *pid = idx + MSHTML_DISPID_CUSTOM_MIN;
6020     return S_OK;
6021 }
6022
6023 static compat_mode_t HTMLDocumentNode_get_compat_mode(DispatchEx *dispex)
6024 {
6025     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
6026
6027     TRACE("(%p) returning %u\n", This, This->document_mode);
6028
6029     return lock_document_mode(This);
6030 }
6031
6032 static nsISupports *HTMLDocumentNode_get_gecko_target(DispatchEx *dispex)
6033 {
6034     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
6035     return (nsISupports*)This->node.nsnode;
6036 }
6037
6038 static void HTMLDocumentNode_bind_event(DispatchEx *dispex, eventid_t eid)
6039 {
6040     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
6041     ensure_doc_nsevent_handler(This, This->node.nsnode, eid);
6042 }
6043
6044 static EventTarget *HTMLDocumentNode_get_parent_event_target(DispatchEx *dispex)
6045 {
6046     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
6047     if(!This->window)
6048         return NULL;
6049     IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
6050     return &This->window->event_target;
6051 }
6052
6053 static ConnectionPointContainer *HTMLDocumentNode_get_cp_container(DispatchEx *dispex)
6054 {
6055     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
6056     ConnectionPointContainer *container = This->doc_obj
6057         ? &This->doc_obj->cp_container : &This->cp_container;
6058     IConnectionPointContainer_AddRef(&container->IConnectionPointContainer_iface);
6059     return container;
6060 }
6061
6062 static IHTMLEventObj *HTMLDocumentNode_set_current_event(DispatchEx *dispex, IHTMLEventObj *event)
6063 {
6064     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
6065     return default_set_current_event(This->window, event);
6066 }
6067
6068 static HRESULT HTMLDocumentNode_location_hook(DispatchEx *dispex, WORD flags, DISPPARAMS *dp, VARIANT *res,
6069         EXCEPINFO *ei, IServiceProvider *caller)
6070 {
6071     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
6072
6073     if(!(flags & DISPATCH_PROPERTYPUT) || !This->outer_window)
6074         return S_FALSE;
6075
6076     return IDispatchEx_InvokeEx(&This->outer_window->base.IDispatchEx_iface, DISPID_IHTMLWINDOW2_LOCATION,
6077                                 0, flags, dp, res, ei, caller);
6078 }
6079
6080 static const event_target_vtbl_t HTMLDocumentNode_event_target_vtbl = {
6081     {
6082         .query_interface     = HTMLDocumentNode_query_interface,
6083         .destructor          = HTMLDocumentNode_destructor,
6084         .traverse            = HTMLDocumentNode_traverse,
6085         .unlink              = HTMLDocumentNode_unlink,
6086         .get_name            = HTMLDocumentNode_get_name,
6087         .invoke              = HTMLDocumentNode_invoke,
6088         .next_dispid         = HTMLDocumentNode_next_dispid,
6089         .get_compat_mode     = HTMLDocumentNode_get_compat_mode,
6090     },
6091     .get_gecko_target        = HTMLDocumentNode_get_gecko_target,
6092     .bind_event              = HTMLDocumentNode_bind_event,
6093     .get_parent_event_target = HTMLDocumentNode_get_parent_event_target,
6094     .get_cp_container        = HTMLDocumentNode_get_cp_container,
6095     .set_current_event       = HTMLDocumentNode_set_current_event
6096 };
6097
6098 static const NodeImplVtbl HTMLDocumentFragmentImplVtbl = {
6099     .clsid                 = &CLSID_HTMLDocument,
6100     .cpc_entries           = HTMLDocumentNode_cpc,
6101     .clone                 = HTMLDocumentFragment_clone,
6102 };
6103
6104 static const tid_t HTMLDocumentNode_iface_tids[] = {
6105     IHTMLDOMNode_tid,
6106     IHTMLDOMNode2_tid,
6107     IHTMLDocument4_tid,
6108     IHTMLDocument5_tid,
6109     IDocumentSelector_tid,
6110     0
6111 };
6112
6113 static void HTMLDocumentNode_init_dispex_info(dispex_data_t *info, compat_mode_t mode)
6114 {
6115     static const dispex_hook_t document2_hooks[] = {
6116         {DISPID_IHTMLDOCUMENT2_URL,      NULL, L"URL"},
6117         {DISPID_IHTMLDOCUMENT2_LOCATION, HTMLDocumentNode_location_hook},
6118         {DISPID_UNKNOWN}
6119     };
6120     static const dispex_hook_t document2_ie11_hooks[] = {
6121         {DISPID_IHTMLDOCUMENT2_URL,              NULL, L"URL"},
6122         {DISPID_IHTMLDOCUMENT2_LOCATION,         HTMLDocumentNode_location_hook},
6123         {DISPID_IHTMLDOCUMENT2_CREATESTYLESHEET, NULL},
6124         {DISPID_IHTMLDOCUMENT2_FILESIZE,         NULL},
6125         {DISPID_IHTMLDOCUMENT2_SELECTION,        NULL},
6126         {DISPID_UNKNOWN}
6127     };
6128     static const dispex_hook_t document3_ie11_hooks[] = {
6129         {DISPID_IHTMLDOCUMENT3_ATTACHEVENT, NULL},
6130         {DISPID_IHTMLDOCUMENT3_DETACHEVENT, NULL},
6131         {DISPID_UNKNOWN}
6132     };
6133     static const dispex_hook_t document6_ie9_hooks[] = {
6134         {DISPID_IHTMLDOCUMENT6_ONSTORAGE},
6135         {DISPID_UNKNOWN}
6136     };
6137
6138     HTMLDOMNode_init_dispex_info(info, mode);
6139
6140     if(mode >= COMPAT_MODE_IE9) {
6141         dispex_info_add_interface(info, IHTMLDocument7_tid, NULL);
6142         dispex_info_add_interface(info, IDocumentEvent_tid, NULL);
6143     }
6144
6145     /* Depending on compatibility version, we add interfaces in different order
6146      * so that the right getElementById implementation is used. */
6147     if(mode < COMPAT_MODE_IE8) {
6148         dispex_info_add_interface(info, IHTMLDocument3_tid, NULL);
6149         dispex_info_add_interface(info, IHTMLDocument6_tid, NULL);
6150     }else {
6151         dispex_info_add_interface(info, IHTMLDocument6_tid, mode >= COMPAT_MODE_IE9 ? document6_ie9_hooks : NULL);
6152         dispex_info_add_interface(info, IHTMLDocument3_tid, mode >= COMPAT_MODE_IE11 ? document3_ie11_hooks : NULL);
6153     }
6154     dispex_info_add_interface(info, IHTMLDocument2_tid, mode >= COMPAT_MODE_IE11 ? document2_ie11_hooks : document2_hooks);
6155 }
6156
6157 static dispex_static_data_t HTMLDocumentNode_dispex = {
6158     "HTMLDocument",
6159     &HTMLDocumentNode_event_target_vtbl.dispex_vtbl,
6160     DispHTMLDocument_tid,
6161     HTMLDocumentNode_iface_tids,
6162     HTMLDocumentNode_init_dispex_info
6163 };
6164
6165 static HTMLDocumentNode *alloc_doc_node(HTMLDocumentObj *doc_obj, HTMLInnerWindow *window)
6166 {
6167     HTMLDocumentNode *doc;
6168
6169     doc = calloc(1, sizeof(HTMLDocumentNode));
6170     if(!doc)
6171         return NULL;
6172
6173     doc->IDispatchEx_iface.lpVtbl = &DocDispatchExVtbl;
6174     doc->IHTMLDocument2_iface.lpVtbl = &HTMLDocumentVtbl;
6175     doc->IHTMLDocument3_iface.lpVtbl = &HTMLDocument3Vtbl;
6176     doc->IHTMLDocument4_iface.lpVtbl = &HTMLDocument4Vtbl;
6177     doc->IHTMLDocument5_iface.lpVtbl = &HTMLDocument5Vtbl;
6178     doc->IHTMLDocument6_iface.lpVtbl = &HTMLDocument6Vtbl;
6179     doc->IHTMLDocument7_iface.lpVtbl = &HTMLDocument7Vtbl;
6180     doc->IDocumentSelector_iface.lpVtbl = &DocumentSelectorVtbl;
6181     doc->IDocumentEvent_iface.lpVtbl = &DocumentEventVtbl;
6182     doc->ISupportErrorInfo_iface.lpVtbl = &SupportErrorInfoVtbl;
6183     doc->IProvideMultipleClassInfo_iface.lpVtbl = &ProvideMultipleClassInfoVtbl;
6184     doc->IMarkupServices_iface.lpVtbl = &MarkupServicesVtbl;
6185     doc->IMarkupContainer_iface.lpVtbl = &MarkupContainerVtbl;
6186     doc->IDisplayServices_iface.lpVtbl = &DisplayServicesVtbl;
6187     doc->IDocumentRange_iface.lpVtbl = &DocumentRangeVtbl;
6188
6189     doc->doc_obj = doc_obj;
6190     doc->outer_window = window ? window->base.outer_window : NULL;
6191     doc->window = window;
6192
6193     if(window)
6194         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
6195
6196     ConnectionPointContainer_Init(&doc->cp_container, (IUnknown*)&doc->IHTMLDocument2_iface, HTMLDocumentNode_cpc);
6197     HTMLDocumentNode_Persist_Init(doc);
6198     HTMLDocumentNode_Service_Init(doc);
6199     HTMLDocumentNode_OleCmd_Init(doc);
6200     HTMLDocumentNode_OleObj_Init(doc);
6201     HTMLDocumentNode_SecMgr_Init(doc);
6202
6203     list_init(&doc->selection_list);
6204     list_init(&doc->range_list);
6205     list_init(&doc->plugin_hosts);
6206
6207     return doc;
6208 }
6209
6210 HRESULT create_document_node(nsIDOMDocument *nsdoc, GeckoBrowser *browser, HTMLInnerWindow *window,
6211                              compat_mode_t parent_mode, HTMLDocumentNode **ret)
6212 {
6213     HTMLDocumentObj *doc_obj = browser->doc;
6214     HTMLDocumentNode *doc;
6215
6216     doc = alloc_doc_node(doc_obj, window);
6217     if(!doc)
6218         return E_OUTOFMEMORY;
6219
6220     if(parent_mode >= COMPAT_MODE_IE9) {
6221         TRACE("using parent mode %u\n", parent_mode);
6222         doc->document_mode = parent_mode;
6223         lock_document_mode(doc);
6224     }
6225
6226     if(doc_obj && (!doc_obj->window || (window && is_main_content_window(window->base.outer_window))))
6227         doc->cp_container.forward_container = &doc_obj->cp_container;
6228
6229     /* Share reference with HTMLDOMNode */
6230     if(NS_SUCCEEDED(nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&doc->html_document))) {
6231         doc->dom_document = (nsIDOMDocument*)doc->html_document;
6232         nsIDOMHTMLDocument_Release(doc->html_document);
6233     }else {
6234         doc->dom_document = nsdoc;
6235         doc->html_document = NULL;
6236     }
6237
6238     HTMLDOMNode_Init(doc, &doc->node, (nsIDOMNode*)doc->dom_document, &HTMLDocumentNode_dispex);
6239
6240     init_document_mutation(doc);
6241     doc_init_events(doc);
6242
6243     doc->node.vtbl = &HTMLDocumentNodeImplVtbl;
6244
6245     list_add_head(&browser->document_nodes, &doc->browser_entry);
6246     doc->browser = browser;
6247
6248     if(browser->usermode == EDITMODE && doc->html_document) {
6249         nsAString mode_str;
6250         nsresult nsres;
6251
6252         nsAString_InitDepend(&mode_str, L"on");
6253         nsres = nsIDOMHTMLDocument_SetDesignMode(doc->html_document, &mode_str);
6254         nsAString_Finish(&mode_str);
6255         if(NS_FAILED(nsres))
6256             ERR("SetDesignMode failed: %08lx\n", nsres);
6257     }
6258
6259     *ret = doc;
6260     return S_OK;
6261 }
6262
6263 static HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret)
6264 {
6265     HTMLDocumentNode *doc_frag;
6266
6267     doc_frag = alloc_doc_node(doc_node->doc_obj, doc_node->window);
6268     if(!doc_frag)
6269         return E_OUTOFMEMORY;
6270
6271     HTMLDOMNode_Init(doc_node, &doc_frag->node, nsnode, &HTMLDocumentNode_dispex);
6272     doc_frag->node.vtbl = &HTMLDocumentFragmentImplVtbl;
6273     doc_frag->document_mode = lock_document_mode(doc_node);
6274
6275     *ret = doc_frag;
6276     return S_OK;
6277 }
6278
6279 HRESULT get_document_node(nsIDOMDocument *dom_document, HTMLDocumentNode **ret)
6280 {
6281     HTMLDOMNode *node;
6282     HRESULT hres;
6283
6284     hres = get_node((nsIDOMNode*)dom_document, FALSE, &node);
6285     if(FAILED(hres))
6286         return hres;
6287
6288     if(!node) {
6289         ERR("document not initialized\n");
6290         return E_FAIL;
6291     }
6292
6293     assert(node->vtbl == &HTMLDocumentNodeImplVtbl);
6294     *ret = impl_from_HTMLDOMNode(node);
6295     return S_OK;
6296 }