git.oblomov.eu Git - wine/blob - dlls/mshtml/mutation.c

   1 /*
   2  * Copyright 2008 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "winreg.h"
  29 #include "ole2.h"
  30 #include "shlguid.h"
  31
  32 #include "mshtml_private.h"
  33 #include "htmlscript.h"
  34 #include "htmlevent.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  39
  40 #define IE_MAJOR_VERSION 7
  41 #define IE_MINOR_VERSION 0
  42
  43 static const IID NS_ICONTENTUTILS_CID =
  44     {0x762C4AE7,0xB923,0x422F,{0xB9,0x7E,0xB9,0xBF,0xC1,0xEF,0x7B,0xF0}};
  45
  46 static nsIContentUtils *content_utils;
  47
  48 static PRUnichar *handle_insert_comment(HTMLDocumentNode *doc, const PRUnichar *comment)
  49 {
  50     int majorv = 0, minorv = 0;
  51     const PRUnichar *ptr, *end;
  52     PRUnichar *buf;
  53     DWORD len;
  54
  55     enum {
  56         CMP_EQ,
  57         CMP_LT,
  58         CMP_LTE,
  59         CMP_GT,
  60         CMP_GTE
  61     } cmpt = CMP_EQ;
  62
  63     static const PRUnichar endifW[] = {'<','!','[','e','n','d','i','f',']'};
  64
  65     if(comment[0] != '[' || comment[1] != 'i' || comment[2] != 'f')
  66         return NULL;
  67
  68     ptr = comment+3;
  69     while(isspaceW(*ptr))
  70         ptr++;
  71
  72     if(ptr[0] == 'l' && ptr[1] == 't') {
  73         ptr += 2;
  74         if(*ptr == 'e') {
  75             cmpt = CMP_LTE;
  76             ptr++;
  77         }else {
  78             cmpt = CMP_LT;
  79         }
  80     }else if(ptr[0] == 'g' && ptr[1] == 't') {
  81         ptr += 2;
  82         if(*ptr == 'e') {
  83             cmpt = CMP_GTE;
  84             ptr++;
  85         }else {
  86             cmpt = CMP_GT;
  87         }
  88     }
  89
  90     if(!isspaceW(*ptr++))
  91         return NULL;
  92     while(isspaceW(*ptr))
  93         ptr++;
  94
  95     if(ptr[0] != 'I' || ptr[1] != 'E')
  96         return NULL;
  97
  98     ptr +=2;
  99     if(!isspaceW(*ptr++))
 100         return NULL;
 101     while(isspaceW(*ptr))
 102         ptr++;
 103
 104     if(!isdigitW(*ptr))
 105         return NULL;
 106     while(isdigitW(*ptr))
 107         majorv = majorv*10 + (*ptr++ - '0');
 108
 109     if(*ptr == '.') {
 110         ptr++;
 111         if(!isdigitW(*ptr))
 112             return NULL;
 113         while(isdigitW(*ptr))
 114             minorv = minorv*10 + (*ptr++ - '0');
 115     }
 116
 117     while(isspaceW(*ptr))
 118         ptr++;
 119     if(ptr[0] != ']' || ptr[1] != '>')
 120         return NULL;
 121     ptr += 2;
 122
 123     len = strlenW(ptr);
 124     if(len < sizeof(endifW)/sizeof(WCHAR))
 125         return NULL;
 126
 127     end = ptr + len-sizeof(endifW)/sizeof(WCHAR);
 128     if(memcmp(end, endifW, sizeof(endifW)))
 129         return NULL;
 130
 131     switch(cmpt) {
 132     case CMP_EQ:
 133         if(majorv == IE_MAJOR_VERSION && minorv == IE_MINOR_VERSION)
 134             break;
 135         return NULL;
 136     case CMP_LT:
 137         if(majorv > IE_MAJOR_VERSION)
 138             break;
 139         if(majorv == IE_MAJOR_VERSION && minorv > IE_MINOR_VERSION)
 140             break;
 141         return NULL;
 142     case CMP_LTE:
 143         if(majorv > IE_MAJOR_VERSION)
 144             break;
 145         if(majorv == IE_MAJOR_VERSION && minorv >= IE_MINOR_VERSION)
 146             break;
 147         return NULL;
 148     case CMP_GT:
 149         if(majorv < IE_MAJOR_VERSION)
 150             break;
 151         if(majorv == IE_MAJOR_VERSION && minorv < IE_MINOR_VERSION)
 152             break;
 153         return NULL;
 154     case CMP_GTE:
 155         if(majorv < IE_MAJOR_VERSION)
 156             break;
 157         if(majorv == IE_MAJOR_VERSION && minorv <= IE_MINOR_VERSION)
 158             break;
 159         return NULL;
 160     }
 161
 162     buf = heap_alloc((end-ptr+1)*sizeof(WCHAR));
 163     if(!buf)
 164         return NULL;
 165
 166     memcpy(buf, ptr, (end-ptr)*sizeof(WCHAR));
 167     buf[end-ptr] = 0;
 168
 169     return buf;
 170 }
 171
 172 static nsresult run_insert_comment(HTMLDocumentNode *doc, nsISupports *comment_iface, nsISupports *arg2)
 173 {
 174     const PRUnichar *comment;
 175     nsIDOMComment *nscomment;
 176     PRUnichar *replace_html;
 177     nsAString comment_str;
 178     nsresult nsres;
 179
 180     nsres = nsISupports_QueryInterface(comment_iface, &IID_nsIDOMComment, (void**)&nscomment);
 181     if(NS_FAILED(nsres)) {
 182         ERR("Could not get nsIDOMComment iface:%08x\n", nsres);
 183         return nsres;
 184     }
 185
 186     nsAString_Init(&comment_str, NULL);
 187     nsres = nsIDOMComment_GetData(nscomment, &comment_str);
 188     if(NS_FAILED(nsres))
 189         return nsres;
 190
 191     nsAString_GetData(&comment_str, &comment);
 192     replace_html = handle_insert_comment(doc, comment);
 193     nsAString_Finish(&comment_str);
 194
 195     if(replace_html) {
 196         HRESULT hres;
 197
 198         hres = replace_node_by_html(doc->nsdoc, (nsIDOMNode*)nscomment, replace_html);
 199         heap_free(replace_html);
 200         if(FAILED(hres))
 201             nsres = NS_ERROR_FAILURE;
 202     }
 203
 204
 205     nsIDOMComment_Release(nscomment);
 206     return nsres;
 207 }
 208
 209 static nsresult run_bind_to_tree(HTMLDocumentNode *doc, nsISupports *nsiface, nsISupports *arg2)
 210 {
 211     nsIDOMNode *nsnode;
 212     HTMLDOMNode *node;
 213     nsresult nsres;
 214     HRESULT hres;
 215
 216     TRACE("(%p)->(%p)\n", doc, nsiface);
 217
 218     nsres = nsISupports_QueryInterface(nsiface, &IID_nsIDOMNode, (void**)&nsnode);
 219     if(NS_FAILED(nsres))
 220         return nsres;
 221
 222     hres = get_node(doc, nsnode, TRUE, &node);
 223     nsIDOMNode_Release(nsnode);
 224     if(FAILED(hres)) {
 225         ERR("Could not get node\n");
 226         return nsres;
 227     }
 228
 229     if(node->vtbl->bind_to_tree)
 230         node->vtbl->bind_to_tree(node);
 231
 232     node_release(node);
 233     return nsres;
 234 }
 235
 236 /* Calls undocumented 69 cmd of CGID_Explorer */
 237 static void call_explorer_69(HTMLDocumentObj *doc)
 238 {
 239     IOleCommandTarget *olecmd;
 240     VARIANT var;
 241     HRESULT hres;
 242
 243     if(!doc->client)
 244         return;
 245
 246     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 247     if(FAILED(hres))
 248         return;
 249
 250     VariantInit(&var);
 251     hres = IOleCommandTarget_Exec(olecmd, &CGID_Explorer, 69, 0, NULL, &var);
 252     IOleCommandTarget_Release(olecmd);
 253     if(SUCCEEDED(hres) && V_VT(&var) != VT_NULL)
 254         FIXME("handle result\n");
 255 }
 256
 257 static void parse_complete(HTMLDocumentObj *doc)
 258 {
 259     TRACE("(%p)\n", doc);
 260
 261     if(doc->usermode == EDITMODE)
 262         init_editor(&doc->basedoc);
 263
 264     call_explorer_69(doc);
 265     if(doc->view_sink)
 266         IAdviseSink_OnViewChange(doc->view_sink, DVASPECT_CONTENT, -1);
 267     call_property_onchanged(&doc->basedoc.cp_propnotif, 1005);
 268     call_explorer_69(doc);
 269
 270     if(doc->is_webbrowser && doc->usermode != EDITMODE)
 271         IDocObjectService_FireNavigateComplete2(doc->doc_object_service, &doc->basedoc.window->base.IHTMLWindow2_iface, 0);
 272
 273     /* FIXME: IE7 calls EnableModelless(TRUE), EnableModelless(FALSE) and sets interactive state here */
 274 }
 275
 276 static nsresult run_end_load(HTMLDocumentNode *This, nsISupports *arg1, nsISupports *arg2)
 277 {
 278     TRACE("(%p)\n", This);
 279
 280     if(!This->basedoc.doc_obj)
 281         return NS_OK;
 282
 283     if(This == This->basedoc.doc_obj->basedoc.doc_node) {
 284         /*
 285          * This should be done in the worker thread that parses HTML,
 286          * but we don't have such thread (Gecko parses HTML for us).
 287          */
 288         parse_complete(This->basedoc.doc_obj);
 289     }
 290
 291     bind_event_scripts(This);
 292     set_ready_state(This->basedoc.window, READYSTATE_INTERACTIVE);
 293     return NS_OK;
 294 }
 295
 296 static nsresult run_insert_script(HTMLDocumentNode *doc, nsISupports *script_iface, nsISupports *parser_iface)
 297 {
 298     nsIDOMHTMLScriptElement *nsscript;
 299     HTMLScriptElement *script_elem;
 300     nsIParser *nsparser = NULL;
 301     script_queue_entry_t *iter;
 302     HTMLInnerWindow *window;
 303     nsresult nsres;
 304     HRESULT hres;
 305
 306     TRACE("(%p)->(%p)\n", doc, script_iface);
 307
 308     window = doc->window;
 309     if(!window)
 310         return NS_OK;
 311
 312     nsres = nsISupports_QueryInterface(script_iface, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript);
 313     if(NS_FAILED(nsres)) {
 314         ERR("Could not get nsIDOMHTMLScriptElement: %08x\n", nsres);
 315         return nsres;
 316     }
 317
 318     if(parser_iface) {
 319         nsres = nsISupports_QueryInterface(parser_iface, &IID_nsIParser, (void**)&nsparser);
 320         if(NS_FAILED(nsres)) {
 321             ERR("Could not get nsIParser iface: %08x\n", nsres);
 322             nsparser = NULL;
 323         }
 324     }
 325
 326     hres = script_elem_from_nsscript(doc, nsscript, &script_elem);
 327     nsIDOMHTMLScriptElement_Release(nsscript);
 328     if(FAILED(hres))
 329         return NS_ERROR_FAILURE;
 330
 331     if(nsparser) {
 332         nsIParser_BeginEvaluatingParserInsertedScript(nsparser);
 333         window->parser_callback_cnt++;
 334     }
 335
 336     IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 337
 338     doc_insert_script(window, script_elem);
 339
 340     while(!list_empty(&window->script_queue)) {
 341         iter = LIST_ENTRY(list_head(&window->script_queue), script_queue_entry_t, entry);
 342         list_remove(&iter->entry);
 343         doc_insert_script(window, iter->script);
 344         IHTMLScriptElement_Release(&iter->script->IHTMLScriptElement_iface);
 345         heap_free(iter);
 346     }
 347
 348     IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
 349
 350     if(nsparser) {
 351         window->parser_callback_cnt--;
 352         nsIParser_EndEvaluatingParserInsertedScript(nsparser);
 353         nsIParser_Release(nsparser);
 354     }
 355
 356     IHTMLScriptElement_Release(&script_elem->IHTMLScriptElement_iface);
 357
 358     return NS_OK;
 359 }
 360
 361 typedef struct nsRunnable nsRunnable;
 362
 363 typedef nsresult (*runnable_proc_t)(HTMLDocumentNode*,nsISupports*,nsISupports*);
 364
 365 struct nsRunnable {
 366     nsIRunnable  nsIRunnable_iface;
 367
 368     LONG ref;
 369
 370     runnable_proc_t proc;
 371
 372     HTMLDocumentNode *doc;
 373     nsISupports *arg1;
 374     nsISupports *arg2;
 375 };
 376
 377 static inline nsRunnable *impl_from_nsIRunnable(nsIRunnable *iface)
 378 {
 379     return CONTAINING_RECORD(iface, nsRunnable, nsIRunnable_iface);
 380 }
 381
 382 static nsresult NSAPI nsRunnable_QueryInterface(nsIRunnable *iface,
 383         nsIIDRef riid, void **result)
 384 {
 385     nsRunnable *This = impl_from_nsIRunnable(iface);
 386
 387     if(IsEqualGUID(riid, &IID_nsISupports)) {
 388         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
 389         *result = &This->nsIRunnable_iface;
 390     }else if(IsEqualGUID(riid, &IID_nsIRunnable)) {
 391         TRACE("(%p)->(IID_nsIRunnable %p)\n", This, result);
 392         *result = &This->nsIRunnable_iface;
 393     }else {
 394         *result = NULL;
 395         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 396         return NS_NOINTERFACE;
 397     }
 398
 399     nsISupports_AddRef((nsISupports*)*result);
 400     return NS_OK;
 401 }
 402
 403 static nsrefcnt NSAPI nsRunnable_AddRef(nsIRunnable *iface)
 404 {
 405     nsRunnable *This = impl_from_nsIRunnable(iface);
 406     LONG ref = InterlockedIncrement(&This->ref);
 407
 408     TRACE("(%p) ref=%d\n", This, ref);
 409
 410     return ref;
 411 }
 412
 413 static nsrefcnt NSAPI nsRunnable_Release(nsIRunnable *iface)
 414 {
 415     nsRunnable *This = impl_from_nsIRunnable(iface);
 416     LONG ref = InterlockedDecrement(&This->ref);
 417
 418     TRACE("(%p) ref=%d\n", This, ref);
 419
 420     if(!ref) {
 421         htmldoc_release(&This->doc->basedoc);
 422         if(This->arg1)
 423             nsISupports_Release(This->arg1);
 424         if(This->arg2)
 425             nsISupports_Release(This->arg2);
 426         heap_free(This);
 427     }
 428
 429     return ref;
 430 }
 431
 432 static nsresult NSAPI nsRunnable_Run(nsIRunnable *iface)
 433 {
 434     nsRunnable *This = impl_from_nsIRunnable(iface);
 435
 436     return This->proc(This->doc, This->arg1, This->arg2);
 437 }
 438
 439 static const nsIRunnableVtbl nsRunnableVtbl = {
 440     nsRunnable_QueryInterface,
 441     nsRunnable_AddRef,
 442     nsRunnable_Release,
 443     nsRunnable_Run
 444 };
 445
 446 static void add_script_runner(HTMLDocumentNode *This, runnable_proc_t proc, nsISupports *arg1, nsISupports *arg2)
 447 {
 448     nsRunnable *runnable;
 449
 450     runnable = heap_alloc_zero(sizeof(*runnable));
 451     if(!runnable)
 452         return;
 453
 454     runnable->nsIRunnable_iface.lpVtbl = &nsRunnableVtbl;
 455     runnable->ref = 1;
 456
 457     htmldoc_addref(&This->basedoc);
 458     runnable->doc = This;
 459     runnable->proc = proc;
 460
 461     if(arg1)
 462         nsISupports_AddRef(arg1);
 463     runnable->arg1 = arg1;
 464
 465     if(arg2)
 466         nsISupports_AddRef(arg2);
 467     runnable->arg2 = arg2;
 468
 469     nsIContentUtils_AddScriptRunner(content_utils, &runnable->nsIRunnable_iface);
 470
 471     nsIRunnable_Release(&runnable->nsIRunnable_iface);
 472 }
 473
 474 static inline HTMLDocumentNode *impl_from_nsIDocumentObserver(nsIDocumentObserver *iface)
 475 {
 476     return CONTAINING_RECORD(iface, HTMLDocumentNode, nsIDocumentObserver_iface);
 477 }
 478
 479 static nsresult NSAPI nsDocumentObserver_QueryInterface(nsIDocumentObserver *iface,
 480         nsIIDRef riid, void **result)
 481 {
 482     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
 483
 484     if(IsEqualGUID(&IID_nsISupports, riid)) {
 485         TRACE("(%p)->(IID_nsISupports, %p)\n", This, result);
 486         *result = &This->nsIDocumentObserver_iface;
 487     }else if(IsEqualGUID(&IID_nsIMutationObserver, riid)) {
 488         TRACE("(%p)->(IID_nsIMutationObserver %p)\n", This, result);
 489         *result = &This->nsIDocumentObserver_iface;
 490     }else if(IsEqualGUID(&IID_nsIDocumentObserver, riid)) {
 491         TRACE("(%p)->(IID_nsIDocumentObserver %p)\n", This, result);
 492         *result = &This->nsIDocumentObserver_iface;
 493     }else {
 494         *result = NULL;
 495         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 496         return NS_NOINTERFACE;
 497     }
 498
 499     htmldoc_addref(&This->basedoc);
 500     return NS_OK;
 501 }
 502
 503 static nsrefcnt NSAPI nsDocumentObserver_AddRef(nsIDocumentObserver *iface)
 504 {
 505     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
 506     return htmldoc_addref(&This->basedoc);
 507 }
 508
 509 static nsrefcnt NSAPI nsDocumentObserver_Release(nsIDocumentObserver *iface)
 510 {
 511     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
 512     return htmldoc_release(&This->basedoc);
 513 }
 514
 515 static void NSAPI nsDocumentObserver_CharacterDataWillChange(nsIDocumentObserver *iface,
 516         nsIDocument *aDocument, nsIContent *aContent, void /*CharacterDataChangeInfo*/ *aInfo)
 517 {
 518 }
 519
 520 static void NSAPI nsDocumentObserver_CharacterDataChanged(nsIDocumentObserver *iface,
 521         nsIDocument *aDocument, nsIContent *aContent, void /*CharacterDataChangeInfo*/ *aInfo)
 522 {
 523 }
 524
 525 static void NSAPI nsDocumentObserver_AttributeWillChange(nsIDocumentObserver *iface, nsIDocument *aDocument,
 526         nsIContent *aContent, PRInt32 aNameSpaceID, nsIAtom *aAttribute, PRInt32 aModType)
 527 {
 528 }
 529
 530 static void NSAPI nsDocumentObserver_AttributeChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
 531         nsIContent *aContent, PRInt32 aNameSpaceID, nsIAtom *aAttribute, PRInt32 aModType)
 532 {
 533 }
 534
 535 static void NSAPI nsDocumentObserver_ContentAppended(nsIDocumentObserver *iface, nsIDocument *aDocument,
 536         nsIContent *aContainer, nsIContent *aFirstNewContent, PRInt32 aNewIndexInContainer)
 537 {
 538 }
 539
 540 static void NSAPI nsDocumentObserver_ContentInserted(nsIDocumentObserver *iface, nsIDocument *aDocument,
 541         nsIContent *aContainer, nsIContent *aChild, PRInt32 aIndexInContainer)
 542 {
 543 }
 544
 545 static void NSAPI nsDocumentObserver_ContentRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument,
 546         nsIContent *aContainer, nsIContent *aChild, PRInt32 aIndexInContainer,
 547         nsIContent *aProviousSibling)
 548 {
 549 }
 550
 551 static void NSAPI nsDocumentObserver_NodeWillBeDestroyed(nsIDocumentObserver *iface, const nsINode *aNode)
 552 {
 553 }
 554
 555 static void NSAPI nsDocumentObserver_ParentChainChanged(nsIDocumentObserver *iface, nsIContent *aContent)
 556 {
 557 }
 558
 559 static void NSAPI nsDocumentObserver_BeginUpdate(nsIDocumentObserver *iface, nsIDocument *aDocument,
 560         nsUpdateType aUpdateType)
 561 {
 562 }
 563
 564 static void NSAPI nsDocumentObserver_EndUpdate(nsIDocumentObserver *iface, nsIDocument *aDocument,
 565         nsUpdateType aUpdateType)
 566 {
 567 }
 568
 569 static void NSAPI nsDocumentObserver_BeginLoad(nsIDocumentObserver *iface, nsIDocument *aDocument)
 570 {
 571 }
 572
 573 static void NSAPI nsDocumentObserver_EndLoad(nsIDocumentObserver *iface, nsIDocument *aDocument)
 574 {
 575     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
 576
 577     TRACE("(%p)\n", This);
 578
 579     if(This->skip_mutation_notif)
 580         return;
 581
 582     This->content_ready = TRUE;
 583     add_script_runner(This, run_end_load, NULL, NULL);
 584 }
 585
 586 static void NSAPI nsDocumentObserver_ContentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
 587         nsIContent *aContent, nsEventStates *aStateMask)
 588 {
 589 }
 590
 591 static void NSAPI nsDocumentObserver_DocumentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
 592         nsEventStates *aStateMask)
 593 {
 594 }
 595
 596 static void NSAPI nsDocumentObserver_StyleSheetAdded(nsIDocumentObserver *iface, nsIDocument *aDocument,
 597         nsIStyleSheet *aStyleSheet, cpp_bool aDocumentSheet)
 598 {
 599 }
 600
 601 static void NSAPI nsDocumentObserver_StyleSheetRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument,
 602         nsIStyleSheet *aStyleSheet, cpp_bool aDocumentSheet)
 603 {
 604 }
 605
 606 static void NSAPI nsDocumentObserver_StyleSheetApplicableStateChanged(nsIDocumentObserver *iface,
 607         nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, cpp_bool aApplicable)
 608 {
 609 }
 610
 611 static void NSAPI nsDocumentObserver_StyleRuleChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
 612         nsIStyleSheet *aStyleSheet, nsIStyleRule *aOldStyleRule, nsIStyleSheet *aNewStyleRule)
 613 {
 614 }
 615
 616 static void NSAPI nsDocumentObserver_StyleRuleAdded(nsIDocumentObserver *iface, nsIDocument *aDocument,
 617         nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule)
 618 {
 619 }
 620
 621 static void NSAPI nsDocumentObserver_StyleRuleRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument,
 622         nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule)
 623 {
 624 }
 625
 626 static void NSAPI nsDocumentObserver_BindToDocument(nsIDocumentObserver *iface, nsIDocument *aDocument,
 627         nsIContent *aContent)
 628 {
 629     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
 630     nsIDOMHTMLIFrameElement *nsiframe;
 631     nsIDOMHTMLFrameElement *nsframe;
 632     nsIDOMHTMLScriptElement *nsscript;
 633     nsIDOMComment *nscomment;
 634     nsIDOMElement *nselem;
 635     nsresult nsres;
 636
 637     TRACE("(%p)\n", This);
 638
 639     nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMElement, (void**)&nselem);
 640     if(NS_SUCCEEDED(nsres)) {
 641         check_event_attr(This, nselem);
 642         nsIDOMElement_Release(nselem);
 643     }
 644
 645     nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMComment, (void**)&nscomment);
 646     if(NS_SUCCEEDED(nsres)) {
 647         TRACE("comment node\n");
 648
 649         add_script_runner(This, run_insert_comment, (nsISupports*)nscomment, NULL);
 650         nsIDOMComment_Release(nscomment);
 651         return;
 652     }
 653
 654     nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLIFrameElement, (void**)&nsiframe);
 655     if(NS_SUCCEEDED(nsres)) {
 656         TRACE("iframe node\n");
 657
 658         add_script_runner(This, run_bind_to_tree, (nsISupports*)nsiframe, NULL);
 659         nsIDOMHTMLIFrameElement_Release(nsiframe);
 660         return;
 661     }
 662
 663     nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLFrameElement, (void**)&nsframe);
 664     if(NS_SUCCEEDED(nsres)) {
 665         TRACE("frame node\n");
 666
 667         add_script_runner(This, run_bind_to_tree, (nsISupports*)nsframe, NULL);
 668         nsIDOMHTMLFrameElement_Release(nsframe);
 669         return;
 670     }
 671
 672     nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript);
 673     if(NS_SUCCEEDED(nsres)) {
 674         HTMLScriptElement *script_elem;
 675         HRESULT hres;
 676
 677         TRACE("script element\n");
 678
 679         hres = script_elem_from_nsscript(This, nsscript, &script_elem);
 680         nsIDOMHTMLScriptElement_Release(nsscript);
 681         if(FAILED(hres))
 682             return;
 683
 684         if(script_elem->parse_on_bind)
 685             add_script_runner(This, run_insert_script, (nsISupports*)nsscript, NULL);
 686
 687         IHTMLScriptElement_Release(&script_elem->IHTMLScriptElement_iface);
 688     }
 689 }
 690
 691 static void NSAPI nsDocumentObserver_AttemptToExecuteScript(nsIDocumentObserver *iface, nsIContent *aContent,
 692         nsIParser *aParser, cpp_bool *aBlock)
 693 {
 694     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
 695     nsIDOMHTMLScriptElement *nsscript;
 696     nsresult nsres;
 697
 698     TRACE("(%p)->(%p %p %p)\n", This, aContent, aParser, aBlock);
 699
 700     nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript);
 701     if(NS_SUCCEEDED(nsres)) {
 702         TRACE("script node\n");
 703
 704         add_script_runner(This, run_insert_script, (nsISupports*)nsscript, (nsISupports*)aParser);
 705         nsIDOMHTMLScriptElement_Release(nsscript);
 706     }
 707 }
 708
 709 static const nsIDocumentObserverVtbl nsDocumentObserverVtbl = {
 710     nsDocumentObserver_QueryInterface,
 711     nsDocumentObserver_AddRef,
 712     nsDocumentObserver_Release,
 713     nsDocumentObserver_CharacterDataWillChange,
 714     nsDocumentObserver_CharacterDataChanged,
 715     nsDocumentObserver_AttributeWillChange,
 716     nsDocumentObserver_AttributeChanged,
 717     nsDocumentObserver_ContentAppended,
 718     nsDocumentObserver_ContentInserted,
 719     nsDocumentObserver_ContentRemoved,
 720     nsDocumentObserver_NodeWillBeDestroyed,
 721     nsDocumentObserver_ParentChainChanged,
 722     nsDocumentObserver_BeginUpdate,
 723     nsDocumentObserver_EndUpdate,
 724     nsDocumentObserver_BeginLoad,
 725     nsDocumentObserver_EndLoad,
 726     nsDocumentObserver_ContentStatesChanged,
 727     nsDocumentObserver_DocumentStatesChanged,
 728     nsDocumentObserver_StyleSheetAdded,
 729     nsDocumentObserver_StyleSheetRemoved,
 730     nsDocumentObserver_StyleSheetApplicableStateChanged,
 731     nsDocumentObserver_StyleRuleChanged,
 732     nsDocumentObserver_StyleRuleAdded,
 733     nsDocumentObserver_StyleRuleRemoved,
 734     nsDocumentObserver_BindToDocument,
 735     nsDocumentObserver_AttemptToExecuteScript
 736 };
 737
 738 void init_document_mutation(HTMLDocumentNode *doc)
 739 {
 740     nsIDocument *nsdoc;
 741     nsresult nsres;
 742
 743     doc->nsIDocumentObserver_iface.lpVtbl = &nsDocumentObserverVtbl;
 744
 745     nsres = nsIDOMHTMLDocument_QueryInterface(doc->nsdoc, &IID_nsIDocument, (void**)&nsdoc);
 746     if(NS_FAILED(nsres)) {
 747         ERR("Could not get nsIDocument: %08x\n", nsres);
 748         return;
 749     }
 750
 751     nsIContentUtils_AddDocumentObserver(content_utils, nsdoc, &doc->nsIDocumentObserver_iface);
 752     nsIDocument_Release(nsdoc);
 753 }
 754
 755 void release_document_mutation(HTMLDocumentNode *doc)
 756 {
 757     nsIDocument *nsdoc;
 758     nsresult nsres;
 759
 760     nsres = nsIDOMHTMLDocument_QueryInterface(doc->nsdoc, &IID_nsIDocument, (void**)&nsdoc);
 761     if(NS_FAILED(nsres)) {
 762         ERR("Could not get nsIDocument: %08x\n", nsres);
 763         return;
 764     }
 765
 766     nsIContentUtils_RemoveDocumentObserver(content_utils, nsdoc, &doc->nsIDocumentObserver_iface);
 767     nsIDocument_Release(nsdoc);
 768 }
 769
 770 void init_mutation(nsIComponentManager *component_manager)
 771 {
 772     nsIFactory *factory;
 773     nsresult nsres;
 774
 775     if(!component_manager) {
 776         if(content_utils) {
 777             nsIContentUtils_Release(content_utils);
 778             content_utils = NULL;
 779         }
 780         return;
 781     }
 782
 783     nsres = nsIComponentManager_GetClassObject(component_manager, &NS_ICONTENTUTILS_CID,
 784             &IID_nsIFactory, (void**)&factory);
 785     if(NS_FAILED(nsres)) {
 786         ERR("Could not create nsIContentUtils service: %08x\n", nsres);
 787         return;
 788     }
 789
 790     nsres = nsIFactory_CreateInstance(factory, NULL, &IID_nsIContentUtils, (void**)&content_utils);
 791     nsIFactory_Release(factory);
 792     if(NS_FAILED(nsres))
 793         ERR("Could not create nsIContentUtils instance: %08x\n", nsres);
 794 }