/* * Copyright 2008 Jacek Caban for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include <stdarg.h> #define COBJMACROS #include "windef.h" #include "winbase.h" #include "winuser.h" #include "winreg.h" #include "ole2.h" #include "shlguid.h" #include "mshtml_private.h" #include "htmlevent.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(mshtml); #define IE_MAJOR_VERSION 7 #define IE_MINOR_VERSION 0 static const IID NS_ICONTENTUTILS_CID = {0x762C4AE7,0xB923,0x422F,{0xB9,0x7E,0xB9,0xBF,0xC1,0xEF,0x7B,0xF0}}; static nsIContentUtils *content_utils; static BOOL handle_insert_comment(HTMLDocumentNode *doc, const PRUnichar *comment) { DWORD len; int majorv = 0, minorv = 0; const PRUnichar *ptr, *end; nsAString nsstr; PRUnichar *buf; nsresult nsres; enum { CMP_EQ, CMP_LT, CMP_LTE, CMP_GT, CMP_GTE } cmpt = CMP_EQ; static const PRUnichar endifW[] = {'<','!','[','e','n','d','i','f',']'}; if(comment[0] != '[' || comment[1] != 'i' || comment[2] != 'f') return FALSE; ptr = comment+3; while(isspaceW(*ptr)) ptr++; if(ptr[0] == 'l' && ptr[1] == 't') { ptr += 2; if(*ptr == 'e') { cmpt = CMP_LTE; ptr++; }else { cmpt = CMP_LT; } }else if(ptr[0] == 'g' && ptr[1] == 't') { ptr += 2; if(*ptr == 'e') { cmpt = CMP_GTE; ptr++; }else { cmpt = CMP_GT; } } if(!isspaceW(*ptr++)) return FALSE; while(isspaceW(*ptr)) ptr++; if(ptr[0] != 'I' || ptr[1] != 'E') return FALSE; ptr +=2; if(!isspaceW(*ptr++)) return FALSE; while(isspaceW(*ptr)) ptr++; if(!isdigitW(*ptr)) return FALSE; while(isdigitW(*ptr)) majorv = majorv*10 + (*ptr++ - '0'); if(*ptr == '.') { ptr++; if(!isdigitW(*ptr)) return FALSE; while(isdigitW(*ptr)) minorv = minorv*10 + (*ptr++ - '0'); } while(isspaceW(*ptr)) ptr++; if(ptr[0] != ']' || ptr[1] != '>') return FALSE; ptr += 2; len = strlenW(ptr); if(len < sizeof(endifW)/sizeof(WCHAR)) return FALSE; end = ptr + len-sizeof(endifW)/sizeof(WCHAR); if(memcmp(end, endifW, sizeof(endifW))) return FALSE; switch(cmpt) { case CMP_EQ: if(majorv == IE_MAJOR_VERSION && minorv == IE_MINOR_VERSION) break; return FALSE; case CMP_LT: if(majorv > IE_MAJOR_VERSION) break; if(majorv == IE_MAJOR_VERSION && minorv > IE_MINOR_VERSION) break; return FALSE; case CMP_LTE: if(majorv > IE_MAJOR_VERSION) break; if(majorv == IE_MAJOR_VERSION && minorv >= IE_MINOR_VERSION) break; return FALSE; case CMP_GT: if(majorv < IE_MAJOR_VERSION) break; if(majorv == IE_MAJOR_VERSION && minorv < IE_MINOR_VERSION) break; return FALSE; case CMP_GTE: if(majorv < IE_MAJOR_VERSION) break; if(majorv == IE_MAJOR_VERSION && minorv <= IE_MINOR_VERSION) break; return FALSE; } buf = heap_alloc((end-ptr+1)*sizeof(WCHAR)); if(!buf) return FALSE; memcpy(buf, ptr, (end-ptr)*sizeof(WCHAR)); buf[end-ptr] = 0; nsAString_InitDepend(&nsstr, buf); /* FIXME: Find better way to insert HTML to document. */ nsres = nsIDOMHTMLDocument_Write(doc->nsdoc, &nsstr); nsAString_Finish(&nsstr); heap_free(buf); if(NS_FAILED(nsres)) { ERR("Write failed: %08x\n", nsres); return FALSE; } return TRUE; } static nsresult run_insert_comment(HTMLDocumentNode *doc, nsISupports *comment_iface, nsISupports *arg2) { const PRUnichar *comment; nsIDOMComment *nscomment; nsAString comment_str; BOOL remove_comment; nsresult nsres; nsres = nsISupports_QueryInterface(comment_iface, &IID_nsIDOMComment, (void**)&nscomment); if(NS_FAILED(nsres)) { ERR("Could not get nsIDOMComment iface:%08x\n", nsres); return nsres; } nsAString_Init(&comment_str, NULL); nsres = nsIDOMComment_GetData(nscomment, &comment_str); if(NS_FAILED(nsres)) return nsres; nsAString_GetData(&comment_str, &comment); remove_comment = handle_insert_comment(doc, comment); nsAString_Finish(&comment_str); if(remove_comment) { nsIDOMNode *nsparent, *tmp; nsAString magic_str; static const PRUnichar remove_comment_magicW[] = {'#','!','w','i','n','e', 'r','e','m','o','v','e','!','#',0}; nsAString_InitDepend(&magic_str, remove_comment_magicW); nsres = nsIDOMComment_SetData(nscomment, &magic_str); nsAString_Finish(&magic_str); if(NS_FAILED(nsres)) ERR("SetData failed: %08x\n", nsres); nsIDOMComment_GetParentNode(nscomment, &nsparent); if(nsparent) { nsIDOMNode_RemoveChild(nsparent, (nsIDOMNode*)nscomment, &tmp); nsIDOMNode_Release(nsparent); nsIDOMNode_Release(tmp); } } nsIDOMComment_Release(nscomment); return NS_OK; } static nsresult run_bind_to_tree(HTMLDocumentNode *doc, nsISupports *nsiface, nsISupports *arg2) { nsIDOMNode *nsnode; HTMLDOMNode *node; nsresult nsres; HRESULT hres; TRACE("(%p)->(%p)\n", doc, nsiface); nsres = nsISupports_QueryInterface(nsiface, &IID_nsIDOMNode, (void**)&nsnode); if(NS_FAILED(nsres)) return nsres; hres = get_node(doc, nsnode, TRUE, &node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) { ERR("Could not get node\n"); return nsres; } if(node->vtbl->bind_to_tree) node->vtbl->bind_to_tree(node); return nsres; } /* Calls undocumented 69 cmd of CGID_Explorer */ static void call_explorer_69(HTMLDocumentObj *doc) { IOleCommandTarget *olecmd; VARIANT var; HRESULT hres; if(!doc->client) return; hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd); if(FAILED(hres)) return; VariantInit(&var); hres = IOleCommandTarget_Exec(olecmd, &CGID_Explorer, 69, 0, NULL, &var); IOleCommandTarget_Release(olecmd); if(SUCCEEDED(hres) && V_VT(&var) != VT_NULL) FIXME("handle result\n"); } static void parse_complete(HTMLDocumentObj *doc) { TRACE("(%p)\n", doc); if(doc->usermode == EDITMODE) init_editor(&doc->basedoc); call_explorer_69(doc); if(doc->view_sink) IAdviseSink_OnViewChange(doc->view_sink, DVASPECT_CONTENT, -1); call_property_onchanged(&doc->basedoc.cp_propnotif, 1005); call_explorer_69(doc); /* FIXME: IE7 calls EnableModelless(TRUE), EnableModelless(FALSE) and sets interactive state here */ } static nsresult run_end_load(HTMLDocumentNode *This, nsISupports *arg1, nsISupports *arg2) { TRACE("(%p)\n", This); if(!This->basedoc.doc_obj) return NS_OK; if(This == This->basedoc.doc_obj->basedoc.doc_node) { /* * This should be done in the worker thread that parses HTML, * but we don't have such thread (Gecko parses HTML for us). */ parse_complete(This->basedoc.doc_obj); } set_ready_state(This->basedoc.window, READYSTATE_INTERACTIVE); return NS_OK; } static nsresult run_insert_script(HTMLDocumentNode *doc, nsISupports *script_iface, nsISupports *parser_iface) { nsIDOMHTMLScriptElement *nsscript; nsIParser *nsparser = NULL; nsresult nsres; TRACE("(%p)->(%p)\n", doc, script_iface); nsres = nsISupports_QueryInterface(script_iface, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript); if(NS_FAILED(nsres)) { ERR("Could not get nsIDOMHTMLScriptElement: %08x\n", nsres); return nsres; } if(parser_iface) { nsres = nsISupports_QueryInterface(parser_iface, &IID_nsIParser, (void**)&nsparser); if(NS_FAILED(nsres)) { ERR("Could not get nsIParser iface: %08x\n", nsres); nsparser = NULL; } } if(nsparser) nsIParser_BeginEvaluatingParserInsertedScript(nsparser); doc_insert_script(doc->basedoc.window, nsscript); if(nsparser) { nsIParser_EndEvaluatingParserInsertedScript(nsparser); nsIParser_Release(nsparser); } nsIDOMHTMLScriptElement_Release(nsscript); return NS_OK; } typedef struct nsRunnable nsRunnable; typedef nsresult (*runnable_proc_t)(HTMLDocumentNode*,nsISupports*,nsISupports*); struct nsRunnable { nsIRunnable nsIRunnable_iface; LONG ref; runnable_proc_t proc; HTMLDocumentNode *doc; nsISupports *arg1; nsISupports *arg2; }; static inline nsRunnable *impl_from_nsIRunnable(nsIRunnable *iface) { return CONTAINING_RECORD(iface, nsRunnable, nsIRunnable_iface); } static nsresult NSAPI nsRunnable_QueryInterface(nsIRunnable *iface, nsIIDRef riid, void **result) { nsRunnable *This = impl_from_nsIRunnable(iface); if(IsEqualGUID(riid, &IID_nsISupports)) { TRACE("(%p)->(IID_nsISupports %p)\n", This, result); *result = &This->nsIRunnable_iface; }else if(IsEqualGUID(riid, &IID_nsIRunnable)) { TRACE("(%p)->(IID_nsIRunnable %p)\n", This, result); *result = &This->nsIRunnable_iface; }else { *result = NULL; WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), result); return NS_NOINTERFACE; } nsISupports_AddRef((nsISupports*)*result); return NS_OK; } static nsrefcnt NSAPI nsRunnable_AddRef(nsIRunnable *iface) { nsRunnable *This = impl_from_nsIRunnable(iface); LONG ref = InterlockedIncrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); return ref; } static nsrefcnt NSAPI nsRunnable_Release(nsIRunnable *iface) { nsRunnable *This = impl_from_nsIRunnable(iface); LONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); if(!ref) { htmldoc_release(&This->doc->basedoc); if(This->arg1) nsISupports_Release(This->arg1); if(This->arg2) nsISupports_Release(This->arg2); heap_free(This); } return ref; } static nsresult NSAPI nsRunnable_Run(nsIRunnable *iface) { nsRunnable *This = impl_from_nsIRunnable(iface); return This->proc(This->doc, This->arg1, This->arg2); } static const nsIRunnableVtbl nsRunnableVtbl = { nsRunnable_QueryInterface, nsRunnable_AddRef, nsRunnable_Release, nsRunnable_Run }; static void add_script_runner(HTMLDocumentNode *This, runnable_proc_t proc, nsISupports *arg1, nsISupports *arg2) { nsRunnable *runnable; runnable = heap_alloc_zero(sizeof(*runnable)); if(!runnable) return; runnable->nsIRunnable_iface.lpVtbl = &nsRunnableVtbl; runnable->ref = 1; htmldoc_addref(&This->basedoc); runnable->doc = This; runnable->proc = proc; if(arg1) nsISupports_AddRef(arg1); runnable->arg1 = arg1; if(arg2) nsISupports_AddRef(arg2); runnable->arg2 = arg2; nsIContentUtils_AddScriptRunner(content_utils, &runnable->nsIRunnable_iface); nsIRunnable_Release(&runnable->nsIRunnable_iface); } static inline HTMLDocumentNode *impl_from_nsIDocumentObserver(nsIDocumentObserver *iface) { return CONTAINING_RECORD(iface, HTMLDocumentNode, nsIDocumentObserver_iface); } static nsresult NSAPI nsDocumentObserver_QueryInterface(nsIDocumentObserver *iface, nsIIDRef riid, void **result) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); if(IsEqualGUID(&IID_nsISupports, riid)) { TRACE("(%p)->(IID_nsISupports, %p)\n", This, result); *result = &This->nsIDocumentObserver_iface; }else if(IsEqualGUID(&IID_nsIMutationObserver, riid)) { TRACE("(%p)->(IID_nsIMutationObserver %p)\n", This, result); *result = &This->nsIDocumentObserver_iface; }else if(IsEqualGUID(&IID_nsIDocumentObserver, riid)) { TRACE("(%p)->(IID_nsIDocumentObserver %p)\n", This, result); *result = &This->nsIDocumentObserver_iface; }else { *result = NULL; TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result); return NS_NOINTERFACE; } htmldoc_addref(&This->basedoc); return NS_OK; } static nsrefcnt NSAPI nsDocumentObserver_AddRef(nsIDocumentObserver *iface) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); return htmldoc_addref(&This->basedoc); } static nsrefcnt NSAPI nsDocumentObserver_Release(nsIDocumentObserver *iface) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); return htmldoc_release(&This->basedoc); } static void NSAPI nsDocumentObserver_CharacterDataWillChange(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, void /*CharacterDataChangeInfo*/ *aInfo) { } static void NSAPI nsDocumentObserver_CharacterDataChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, void /*CharacterDataChangeInfo*/ *aInfo) { } static void NSAPI nsDocumentObserver_AttributeWillChange(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, PRInt32 aNameSpaceID, nsIAtom *aAttribute, PRInt32 aModType) { } static void NSAPI nsDocumentObserver_AttributeChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, PRInt32 aNameSpaceID, nsIAtom *aAttribute, PRInt32 aModType) { } static void NSAPI nsDocumentObserver_ContentAppended(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aFirstNewContent, PRInt32 aNewIndexInContainer) { } static void NSAPI nsDocumentObserver_ContentInserted(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild, PRInt32 aIndexInContainer) { } static void NSAPI nsDocumentObserver_ContentRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild, PRInt32 aIndexInContainer, nsIContent *aProviousSibling) { } static void NSAPI nsDocumentObserver_NodeWillBeDestroyed(nsIDocumentObserver *iface, const nsINode *aNode) { } static void NSAPI nsDocumentObserver_ParentChainChanged(nsIDocumentObserver *iface, nsIContent *aContent) { } static void NSAPI nsDocumentObserver_BeginUpdate(nsIDocumentObserver *iface, nsIDocument *aDocument, nsUpdateType aUpdateType) { } static void NSAPI nsDocumentObserver_EndUpdate(nsIDocumentObserver *iface, nsIDocument *aDocument, nsUpdateType aUpdateType) { } static void NSAPI nsDocumentObserver_BeginLoad(nsIDocumentObserver *iface, nsIDocument *aDocument) { } static void NSAPI nsDocumentObserver_EndLoad(nsIDocumentObserver *iface, nsIDocument *aDocument) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); TRACE("(%p)\n", This); if(This->skip_mutation_notif) return; This->content_ready = TRUE; add_script_runner(This, run_end_load, NULL, NULL); } static void NSAPI nsDocumentObserver_ContentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent1, nsIContent *aContent2, nsEventStates aStateMask) { } static void NSAPI nsDocumentObserver_DocumentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsEventStates aStateMask) { } static void NSAPI nsDocumentObserver_StyleSheetAdded(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, PRBool aDocumentSheet) { } static void NSAPI nsDocumentObserver_StyleSheetRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, PRBool aDocumentSheet) { } static void NSAPI nsDocumentObserver_StyleSheetApplicableStateChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, PRBool aApplicable) { } static void NSAPI nsDocumentObserver_StyleRuleChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aOldStyleRule, nsIStyleSheet *aNewStyleRule) { } static void NSAPI nsDocumentObserver_StyleRuleAdded(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule) { } static void NSAPI nsDocumentObserver_StyleRuleRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule) { } static void NSAPI nsDocumentObserver_BindToDocument(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); nsIDOMHTMLIFrameElement *nsiframe; nsIDOMHTMLFrameElement *nsframe; nsIDOMComment *nscomment; nsIDOMElement *nselem; nsresult nsres; TRACE("(%p)\n", This); nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMElement, (void**)&nselem); if(NS_SUCCEEDED(nsres)) { check_event_attr(This, nselem); nsIDOMElement_Release(nselem); } nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMComment, (void**)&nscomment); if(NS_SUCCEEDED(nsres)) { TRACE("comment node\n"); add_script_runner(This, run_insert_comment, (nsISupports*)nscomment, NULL); nsIDOMComment_Release(nscomment); } nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMHTMLIFrameElement, (void**)&nsiframe); if(NS_SUCCEEDED(nsres)) { TRACE("iframe node\n"); add_script_runner(This, run_bind_to_tree, (nsISupports*)nsiframe, NULL); nsIDOMHTMLIFrameElement_Release(nsiframe); } nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMHTMLFrameElement, (void**)&nsframe); if(NS_SUCCEEDED(nsres)) { TRACE("frame node\n"); add_script_runner(This, run_bind_to_tree, (nsISupports*)nsframe, NULL); nsIDOMHTMLFrameElement_Release(nsframe); } } static nsresult NSAPI nsDocumentObserver_DoneAddingChildren(nsIDocumentObserver *iface, nsIContent *aContent, PRBool aHaveNotified, nsIParser *aParser) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); nsIDOMHTMLScriptElement *nsscript; nsresult nsres; TRACE("(%p)->(%p %x)\n", This, aContent, aHaveNotified); nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript); if(NS_SUCCEEDED(nsres)) { TRACE("script node\n"); add_script_runner(This, run_insert_script, (nsISupports*)nsscript, (nsISupports*)aParser); nsIDOMHTMLScriptElement_Release(nsscript); } return NS_OK; } static const nsIDocumentObserverVtbl nsDocumentObserverVtbl = { nsDocumentObserver_QueryInterface, nsDocumentObserver_AddRef, nsDocumentObserver_Release, nsDocumentObserver_CharacterDataWillChange, nsDocumentObserver_CharacterDataChanged, nsDocumentObserver_AttributeWillChange, nsDocumentObserver_AttributeChanged, nsDocumentObserver_ContentAppended, nsDocumentObserver_ContentInserted, nsDocumentObserver_ContentRemoved, nsDocumentObserver_NodeWillBeDestroyed, nsDocumentObserver_ParentChainChanged, nsDocumentObserver_BeginUpdate, nsDocumentObserver_EndUpdate, nsDocumentObserver_BeginLoad, nsDocumentObserver_EndLoad, nsDocumentObserver_ContentStatesChanged, nsDocumentObserver_DocumentStatesChanged, nsDocumentObserver_StyleSheetAdded, nsDocumentObserver_StyleSheetRemoved, nsDocumentObserver_StyleSheetApplicableStateChanged, nsDocumentObserver_StyleRuleChanged, nsDocumentObserver_StyleRuleAdded, nsDocumentObserver_StyleRuleRemoved, nsDocumentObserver_BindToDocument, nsDocumentObserver_DoneAddingChildren }; void init_document_mutation(HTMLDocumentNode *doc) { nsIDocument *nsdoc; nsresult nsres; doc->nsIDocumentObserver_iface.lpVtbl = &nsDocumentObserverVtbl; nsres = nsIDOMHTMLDocument_QueryInterface(doc->nsdoc, &IID_nsIDocument, (void**)&nsdoc); if(NS_FAILED(nsres)) { ERR("Could not get nsIDocument: %08x\n", nsres); return; } nsIContentUtils_AddDocumentObserver(content_utils, nsdoc, &doc->nsIDocumentObserver_iface); nsIDocument_Release(nsdoc); } void release_document_mutation(HTMLDocumentNode *doc) { nsIDocument *nsdoc; nsresult nsres; nsres = nsIDOMHTMLDocument_QueryInterface(doc->nsdoc, &IID_nsIDocument, (void**)&nsdoc); if(NS_FAILED(nsres)) { ERR("Could not get nsIDocument: %08x\n", nsres); return; } nsIContentUtils_RemoveDocumentObserver(content_utils, nsdoc, &doc->nsIDocumentObserver_iface); nsIDocument_Release(nsdoc); } void init_mutation(nsIComponentManager *component_manager) { nsIFactory *factory; nsresult nsres; if(!component_manager) { if(content_utils) { nsIContentUtils_Release(content_utils); content_utils = NULL; } return; } nsres = nsIComponentManager_GetClassObject(component_manager, &NS_ICONTENTUTILS_CID, &IID_nsIFactory, (void**)&factory); if(NS_FAILED(nsres)) { ERR("Could not create nsIContentUtils service: %08x\n", nsres); return; } nsres = nsIFactory_CreateInstance(factory, NULL, &IID_nsIContentUtils, (void**)&content_utils); nsIFactory_Release(factory); if(NS_FAILED(nsres)) ERR("Could not create nsIContentUtils instance: %08x\n", nsres); }