static void get_font_size(HTMLDocument *This, WCHAR *ret) { nsISelection *nsselection = get_ns_selection(This); nsIDOMHTMLElement *elem = NULL; nsIDOMNode *node = NULL, *tmp_node; nsAString tag_str; LPCWSTR tag; UINT16 node_type; nsresult nsres; *ret = 0; if(!nsselection) return; nsISelection_GetFocusNode(nsselection, &node); nsISelection_Release(nsselection); while(node) { nsres = nsIDOMNode_GetNodeType(node, &node_type); if(NS_FAILED(nsres) || node_type == DOCUMENT_NODE) break; if(node_type == ELEMENT_NODE) { nsIDOMNode_QueryInterface(node, &IID_nsIDOMHTMLElement, (void**)&elem); nsAString_Init(&tag_str, NULL); nsIDOMHTMLElement_GetTagName(elem, &tag_str); nsAString_GetData(&tag_str, &tag); if(!strcmpiW(tag, fontW)) { nsAString val_str; const PRUnichar *val; TRACE("found font tag %p\n", elem); get_elem_attr_value(elem, sizeW, &val_str, &val); if(*val) { TRACE("found size %s\n", debugstr_w(val)); strcpyW(ret, val); } nsAString_Finish(&val_str); } nsAString_Finish(&tag_str); nsIDOMHTMLElement_Release(elem); } if(*ret) break; tmp_node = node; nsIDOMNode_GetParentNode(node, &node); nsIDOMNode_Release(tmp_node); } if(node) nsIDOMNode_Release(node); }
static nsresult NSAPI nsTooltipTextProvider_GetNodeText(nsITooltipTextProvider *iface, nsIDOMNode *aNode, PRUnichar **aText, PRBool *_retval) { nsIDOMHTMLElement *nselem; nsIDOMNode *node = aNode, *parent; nsAString title_str; const PRUnichar *title = NULL; nsresult nsres; TRACE("(%p %p %p)\n", aNode, aText, _retval); *aText = NULL; nsAString_Init(&title_str, NULL); do { nsres = nsIDOMNode_QueryInterface(node, &IID_nsIDOMHTMLElement, (void**)&nselem); if(NS_SUCCEEDED(nsres)) { title = NULL; nsIDOMHTMLElement_GetTitle(nselem, &title_str); nsIDOMHTMLElement_Release(nselem); nsAString_GetData(&title_str, &title); if(title && *title) { if(node != aNode) nsIDOMNode_Release(node); break; } } nsres = nsIDOMNode_GetParentNode(node, &parent); if(NS_FAILED(nsres)) parent = NULL; if(node != aNode) nsIDOMNode_Release(node); node = parent; } while(node); if(title && *title) { int size = (strlenW(title)+1)*sizeof(PRUnichar); *aText = nsalloc(size); memcpy(*aText, title, size); TRACE("aText = %s\n", debugstr_w(*aText)); *_retval = TRUE; }else { *_retval = FALSE; } nsAString_Finish(&title_str); return NS_OK; }
static HRESULT WINAPI HTMLOptionElement_put_text(IHTMLOptionElement *iface, BSTR v) { HTMLOptionElement *This = impl_from_IHTMLOptionElement(iface); nsIDOMText *text_node; nsAString text_str; nsIDOMNode *tmp; nsresult nsres; TRACE("(%p)->(%s)\n", This, debugstr_w(v)); if(!This->element.node.doc->nsdoc) { WARN("NULL nsdoc\n"); return E_UNEXPECTED; } while(1) { nsIDOMNode *child; nsres = nsIDOMHTMLOptionElement_GetFirstChild(This->nsoption, &child); if(NS_FAILED(nsres) || !child) break; nsres = nsIDOMHTMLOptionElement_RemoveChild(This->nsoption, child, &tmp); nsIDOMNode_Release(child); if(NS_SUCCEEDED(nsres)) { nsIDOMNode_Release(tmp); }else { ERR("RemoveChild failed: %08x\n", nsres); break; } } nsAString_InitDepend(&text_str, v); nsres = nsIDOMHTMLDocument_CreateTextNode(This->element.node.doc->nsdoc, &text_str, &text_node); nsAString_Finish(&text_str); if(NS_FAILED(nsres)) { ERR("CreateTextNode failed: %08x\n", nsres); return E_FAIL; } nsres = nsIDOMHTMLOptionElement_AppendChild(This->nsoption, (nsIDOMNode*)text_node, &tmp); if(NS_SUCCEEDED(nsres)) nsIDOMNode_Release(tmp); else ERR("AppendChild failed: %08x\n", nsres); return S_OK; }
static HRESULT get_doc_string(HTMLDocumentNode *This, char **str) { nsIDOMNode *nsnode; LPCWSTR strw; nsAString nsstr; nsresult nsres; if(!This->nsdoc) { WARN("NULL nsdoc\n"); return E_UNEXPECTED; } nsres = nsIDOMHTMLDocument_QueryInterface(This->nsdoc, &IID_nsIDOMNode, (void**)&nsnode); if(NS_FAILED(nsres)) { ERR("Could not get nsIDOMNode failed: %08x\n", nsres); return E_FAIL; } nsAString_Init(&nsstr, NULL); nsnode_to_nsstring(nsnode, &nsstr); nsIDOMNode_Release(nsnode); nsAString_GetData(&nsstr, &strw); TRACE("%s\n", debugstr_w(strw)); *str = heap_strdupWtoA(strw); nsAString_Finish(&nsstr); return S_OK; }
static HRESULT WINAPI HTMLDOMNode_replaceChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild, IHTMLDOMNode *oldChild, IHTMLDOMNode **node) { HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface); HTMLDOMNode *node_new, *node_old, *ret_node; nsIDOMNode *nsnode; nsresult nsres; HRESULT hres; TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, node); node_new = get_node_obj(newChild); if(!node_new) return E_FAIL; node_old = get_node_obj(oldChild); if(!node_old) { node_release(node_new); return E_FAIL; } nsres = nsIDOMNode_ReplaceChild(This->nsnode, node_new->nsnode, node_old->nsnode, &nsnode); node_release(node_new); node_release(node_old); if(NS_FAILED(nsres)) return E_FAIL; hres = get_node(This->doc, nsnode, TRUE, &ret_node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) return hres; *node = &ret_node->IHTMLDOMNode_iface; return S_OK; }
static HRESULT WINAPI HTMLDOMNode_removeChild(IHTMLDOMNode *iface, IHTMLDOMNode *oldChild, IHTMLDOMNode **node) { HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface); HTMLDOMNode *node_obj; nsIDOMNode *nsnode; nsresult nsres; HRESULT hres; TRACE("(%p)->(%p %p)\n", This, oldChild, node); node_obj = get_node_obj(oldChild); if(!node_obj) return E_FAIL; nsres = nsIDOMNode_RemoveChild(This->nsnode, node_obj->nsnode, &nsnode); node_release(node_obj); if(NS_FAILED(nsres)) { ERR("RemoveChild failed: %08x\n", nsres); return E_FAIL; } hres = get_node(This->doc, nsnode, TRUE, &node_obj); nsIDOMNode_Release(nsnode); if(FAILED(hres)) return hres; /* FIXME: Make sure that node != newChild */ *node = &node_obj->IHTMLDOMNode_iface; return S_OK; }
static nsresult NSAPI HTMLDOMNode_unlink(void *p) { HTMLDOMNode *This = impl_from_IHTMLDOMNode(p); TRACE("%p\n", This); if(This->vtbl->unlink) This->vtbl->unlink(This); dispex_unlink(&This->event_target.dispex); if(This->nsnode) { nsIDOMNode *nsnode = This->nsnode; This->nsnode = NULL; nsIDOMNode_Release(nsnode); } if(This->doc && &This->doc->node != This) { HTMLDocument *doc = &This->doc->basedoc; This->doc = NULL; htmldoc_release(doc); }else { This->doc = NULL; } return NS_OK; }
static HRESULT WINAPI HTMLDOMChildrenCollectionEnum_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched) { HTMLDOMChildrenCollectionEnum *This = impl_from_IEnumVARIANT(iface); ULONG fetched = 0, len; nsIDOMNode *nsnode; HTMLDOMNode *node; nsresult nsres; HRESULT hres; TRACE("(%p)->(%d %p %p)\n", This, celt, rgVar, pCeltFetched); len = get_enum_len(This); while(This->iter+fetched < len && fetched < celt) { nsres = nsIDOMNodeList_Item(This->col->nslist, This->iter+fetched, &nsnode); assert(nsres == NS_OK); hres = get_node(This->col->doc, nsnode, TRUE, &node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) { ERR("get_node failed: %08x\n", hres); break; } V_VT(rgVar+fetched) = VT_DISPATCH; IHTMLDOMNode_AddRef(&node->IHTMLDOMNode_iface); V_DISPATCH(rgVar+fetched) = (IDispatch*)&node->IHTMLDOMNode_iface; fetched++; } This->iter += fetched; if(pCeltFetched) *pCeltFetched = fetched; return fetched == celt ? S_OK : S_FALSE; }
static HRESULT WINAPI HTMLTextAreaElement_get_form(IHTMLTextAreaElement *iface, IHTMLFormElement **p) { HTMLTextAreaElement *This = impl_from_IHTMLTextAreaElement(iface); nsIDOMHTMLFormElement *nsform; nsIDOMNode *nsnode; HTMLDOMNode *node; nsresult nsres; HRESULT hres; TRACE("(%p)->(%p)\n", This, p); nsres = nsIDOMHTMLTextAreaElement_GetForm(This->nstextarea, &nsform); assert(nsres == NS_OK); if(!nsform) { *p = NULL; return S_OK; } nsres = nsIDOMHTMLFormElement_QueryInterface(nsform, &IID_nsIDOMNode, (void**)&nsnode); nsIDOMHTMLFormElement_Release(nsform); assert(nsres == NS_OK); hres = get_node(This->element.node.doc, nsnode, TRUE, &node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) return hres; hres = IHTMLDOMNode_QueryInterface(&node->IHTMLDOMNode_iface, &IID_IHTMLFormElement, (void**)p); IHTMLDOMNode_Release(&node->IHTMLDOMNode_iface); return hres; }
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); node_release(node); return nsres; }
static nsresult NSAPI handle_htmlevent(nsIDOMEventListener *iface, nsIDOMEvent *event) { NSContainer *This = NSEVENTLIST_THIS(iface)->This; const PRUnichar *type; nsIDOMEventTarget *event_target; nsIDOMNode *nsnode; nsAString type_str; eventid_t eid; nsresult nsres; nsAString_Init(&type_str, NULL); nsIDOMEvent_GetType(event, &type_str); nsAString_GetData(&type_str, &type); eid = str_to_eid(type); nsAString_Finish(&type_str); nsres = nsIDOMEvent_GetTarget(event, &event_target); if(NS_FAILED(nsres) || !event_target) { ERR("GetEventTarget failed: %08x\n", nsres); return NS_OK; } nsres = nsIDOMEventTarget_QueryInterface(event_target, &IID_nsIDOMNode, (void**)&nsnode); nsIDOMEventTarget_Release(event_target); if(NS_FAILED(nsres)) { ERR("Could not get nsIDOMNode: %08x\n", nsres); return NS_OK; } fire_event(This->doc, eid, nsnode); nsIDOMNode_Release(nsnode); return NS_OK; }
static nsresult NSAPI handle_node_insert(nsIDOMEventListener *iface, nsIDOMEvent *event) { NSContainer *This = NSEVENTLIST_THIS(iface)->This; nsIDOMHTMLScriptElement *script; nsIDOMEventTarget *target; nsIDOMElement *elem; nsresult nsres; TRACE("(%p %p)\n", This, event); nsres = nsIDOMEvent_GetTarget(event, &target); if(NS_FAILED(nsres)) { ERR("GetTarget failed: %08x\n", nsres); return NS_OK; } nsres = nsIDOMEventTarget_QueryInterface(target, &IID_nsIDOMElement, (void**)&elem); nsIDOMEventTarget_Release(target); if(NS_FAILED(nsres)) return NS_OK; nsres = nsIDOMElement_QueryInterface(elem, &IID_nsIDOMHTMLScriptElement, (void**)&script); if(SUCCEEDED(nsres)) { doc_insert_script(This->doc, script); nsIDOMHTMLScriptElement_Release(script); } check_event_attr(This->doc, elem); nsIDOMNode_Release(elem); return NS_OK; }
static HRESULT HTMLFormElement_invoke(HTMLDOMNode *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller) { HTMLFormElement *This = HTMLFORM_NODE_THIS(iface); nsIDOMHTMLCollection *elements; nsIDOMNode *item; HTMLDOMNode *node; nsresult nsres; TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller); nsres = nsIDOMHTMLFormElement_GetElements(This->nsform, &elements); if(NS_FAILED(nsres)) { FIXME("GetElements failed: 0x%08x\n", nsres); return E_FAIL; } nsres = nsIDOMHTMLCollection_Item(elements, id - MSHTML_DISPID_CUSTOM_MIN, &item); nsIDOMHTMLCollection_Release(elements); if(NS_FAILED(nsres)) { FIXME("Item failed: 0x%08x\n", nsres); return E_FAIL; } node = get_node(This->element.node.doc, item, TRUE); V_VT(res) = VT_DISPATCH; V_DISPATCH(res) = (IDispatch*)node; IHTMLDOMNode_AddRef(HTMLDOMNODE(node)); nsIDOMNode_Release(item); return S_OK; }
HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem) { HTMLTable *ret; nsresult nsres; ret = heap_alloc_zero(sizeof(HTMLTable)); if(!ret) return E_OUTOFMEMORY; ret->element.node.vtbl = &HTMLTableImplVtbl; ret->IHTMLTable_iface.lpVtbl = &HTMLTableVtbl; ret->IHTMLTable2_iface.lpVtbl = &HTMLTable2Vtbl; ret->IHTMLTable3_iface.lpVtbl = &HTMLTable3Vtbl; HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex); nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable); /* Share the reference with nsnode */ assert(nsres == NS_OK && (nsIDOMNode*)ret->nstable == ret->element.node.nsnode); nsIDOMNode_Release(ret->element.node.nsnode); *elem = &ret->element; return S_OK; }
static HRESULT ensure_nsevent_handler(HTMLDocumentNode *doc, event_target_t *event_target, eventid_t eid) { nsIDOMNode *nsnode = NULL; TRACE("%s\n", debugstr_w(event_info[eid].name)); if(!doc->nsdoc || doc->event_vector[eid] || !(event_info[eid].flags & (EVENT_DEFAULTLISTENER|EVENT_BIND_TO_BODY))) return S_OK; if(event_info[eid].flags & EVENT_BIND_TO_BODY) { nsIDOMHTMLElement *nsbody; nsresult nsres; nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody); if(NS_SUCCEEDED(nsres) && nsbody) { nsnode = (nsIDOMNode*)nsbody; }else { ERR("GetBody failed: %08x\n", nsres); return E_UNEXPECTED; } } doc->event_vector[eid] = TRUE; add_nsevent_listener(doc, nsnode, event_info[eid].name); if(nsnode) nsIDOMNode_Release(nsnode); return S_OK; }
static HRESULT WINAPI HTMLDOMNode_appendChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild, IHTMLDOMNode **node) { HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface); HTMLDOMNode *node_obj; nsIDOMNode *nsnode; nsresult nsres; HRESULT hres; TRACE("(%p)->(%p %p)\n", This, newChild, node); node_obj = get_node_obj(This->doc, (IUnknown*)newChild); if(!node_obj) return E_FAIL; nsres = nsIDOMNode_AppendChild(This->nsnode, node_obj->nsnode, &nsnode); if(NS_FAILED(nsres)) { WARN("AppendChild failed: %08x\n", nsres); nsnode = node_obj->nsnode; } hres = get_node(This->doc, nsnode, TRUE, &node_obj); nsIDOMNode_Release(nsnode); if(FAILED(hres)) return hres; /* FIXME: Make sure that node != newChild */ *node = &node_obj->IHTMLDOMNode_iface; IHTMLDOMNode_AddRef(*node); return S_OK; }
HRESULT HTMLDOMTextNode_Create(HTMLDocumentNode *doc, nsIDOMNode *nsnode, HTMLDOMNode **node) { HTMLDOMTextNode *ret; nsresult nsres; ret = heap_alloc_zero(sizeof(*ret)); if(!ret) return E_OUTOFMEMORY; ret->node.vtbl = &HTMLDOMTextNodeImplVtbl; ret->IHTMLDOMTextNode_iface.lpVtbl = &HTMLDOMTextNodeVtbl; init_dispex(&ret->node.dispex, (IUnknown*)&ret->IHTMLDOMTextNode_iface, &HTMLDOMTextNode_dispex); HTMLDOMNode_Init(doc, &ret->node, nsnode); nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMText, (void**)&ret->nstext); assert(nsres == NS_OK && (nsIDOMNode*)ret->nstext == ret->node.nsnode); /* Share reference with nsnode */ nsIDOMNode_Release(ret->node.nsnode); *node = &ret->node; return S_OK; }
void HTMLDOMNode_destructor(HTMLDOMNode *This) { if(This->nsnode) nsIDOMNode_Release(This->nsnode); if(This->event_target) release_event_target(This->event_target); }
static HRESULT WINAPI HTMLDOMNode_get_parentNode(IHTMLDOMNode *iface, IHTMLDOMNode **p) { HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface); HTMLDOMNode *node; nsIDOMNode *nsnode; nsresult nsres; HRESULT hres; TRACE("(%p)->(%p)\n", This, p); nsres = nsIDOMNode_GetParentNode(This->nsnode, &nsnode); if(NS_FAILED(nsres)) { ERR("GetParentNode failed: %08x\n", nsres); return E_FAIL; } if(!nsnode) { *p = NULL; return S_OK; } hres = get_node(This->doc, nsnode, TRUE, &node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) return hres; *p = &node->IHTMLDOMNode_iface; IHTMLDOMNode_AddRef(*p); return S_OK; }
IHTMLElementCollection *create_collection_from_htmlcol(HTMLDocumentNode *doc, nsIDOMHTMLCollection *nscol) { UINT32 length = 0, i; elem_vector_t buf; HTMLDOMNode *node; HRESULT hres = S_OK; nsIDOMHTMLCollection_GetLength(nscol, &length); buf.len = buf.size = length; if(buf.len) { nsIDOMNode *nsnode; buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*)); for(i=0; i<length; i++) { nsIDOMHTMLCollection_Item(nscol, i, &nsnode); hres = get_node(doc, nsnode, TRUE, &node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) break; buf.buf[i] = elem_from_HTMLDOMNode(node); } }else { buf.buf = NULL; } if(FAILED(hres)) { heap_free(buf.buf); return NULL; } return HTMLElementCollection_Create(buf.buf, buf.len); }
static HRESULT htmlform_item(HTMLFormElement *This, int i, IDispatch **ret) { nsIDOMHTMLCollection *elements; nsIDOMNode *item; HTMLDOMNode *node; nsresult nsres; HRESULT hres; nsres = nsIDOMHTMLFormElement_GetElements(This->nsform, &elements); if(NS_FAILED(nsres)) { FIXME("GetElements failed: 0x%08x\n", nsres); return E_FAIL; } nsres = nsIDOMHTMLCollection_Item(elements, i, &item); nsIDOMHTMLCollection_Release(elements); if(NS_FAILED(nsres)) { FIXME("Item failed: 0x%08x\n", nsres); return E_FAIL; } if(item) { hres = get_node(This->element.node.doc, item, TRUE, &node); if(FAILED(hres)) return hres; nsIDOMNode_Release(item); *ret = (IDispatch*)&node->IHTMLDOMNode_iface; }else { *ret = NULL; } return S_OK; }
IHTMLElementCollection *create_collection_from_nodelist(HTMLDocumentNode *doc, nsIDOMNodeList *nslist) { UINT32 length = 0, i; HTMLDOMNode *node; elem_vector_t buf; HRESULT hres; nsIDOMNodeList_GetLength(nslist, &length); buf.len = 0; buf.size = length; if(length) { nsIDOMNode *nsnode; buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*)); for(i=0; i<length; i++) { nsIDOMNodeList_Item(nslist, i, &nsnode); if(is_elem_node(nsnode)) { hres = get_node(doc, nsnode, TRUE, &node); if(FAILED(hres)) continue; buf.buf[buf.len++] = elem_from_HTMLDOMNode(node); } nsIDOMNode_Release(nsnode); } elem_vector_normalize(&buf); }else { buf.buf = NULL; } return HTMLElementCollection_Create(buf.buf, buf.len); }
static HRESULT htmlselect_item(HTMLSelectElement *This, int i, IDispatch **ret) { nsIDOMHTMLOptionsCollection *nscol; nsIDOMNode *nsnode; nsresult nsres; HRESULT hres; nsres = nsIDOMHTMLSelectElement_GetOptions(This->nsselect, &nscol); if(NS_FAILED(nsres)) { ERR("GetOptions failed: %08x\n", nsres); return E_FAIL; } nsres = nsIDOMHTMLOptionsCollection_Item(nscol, i, &nsnode); nsIDOMHTMLOptionsCollection_Release(nscol); if(NS_FAILED(nsres)) { ERR("Item failed: %08x\n", nsres); return E_FAIL; } if(nsnode) { HTMLDOMNode *node; hres = get_node(This->element.node.doc, nsnode, TRUE, &node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) return hres; IHTMLDOMNode_AddRef(&node->IHTMLDOMNode_iface); *ret = (IDispatch*)&node->IHTMLDOMNode_iface; }else { *ret = NULL; } return S_OK; }
static void remove_child_attr(nsIDOMElement *elem, LPCWSTR tag, nsAString *attr_str) { PRBool has_children; PRUint32 child_cnt, i; nsIDOMNode *child_node; nsIDOMNodeList *node_list; PRUint16 node_type; nsIDOMElement_HasChildNodes(elem, &has_children); if(!has_children) return; nsIDOMElement_GetChildNodes(elem, &node_list); nsIDOMNodeList_GetLength(node_list, &child_cnt); for(i=0; i<child_cnt; i++) { nsIDOMNodeList_Item(node_list, i, &child_node); nsIDOMNode_GetNodeType(child_node, &node_type); if(node_type == ELEMENT_NODE) { nsIDOMElement *child_elem; nsAString tag_str; const PRUnichar *ctag; nsIDOMNode_QueryInterface(child_node, &IID_nsIDOMElement, (void**)&child_elem); nsAString_Init(&tag_str, NULL); nsIDOMElement_GetTagName(child_elem, &tag_str); nsAString_GetData(&tag_str, &ctag); if(!strcmpiW(ctag, tag)) /* FIXME: remove node if there are no more attributes */ nsIDOMElement_RemoveAttribute(child_elem, attr_str); nsAString_Finish(&tag_str); remove_child_attr(child_elem, tag, attr_str); nsIDOMNode_Release(child_elem); } nsIDOMNode_Release(child_node); } nsIDOMNodeList_Release(node_list); }
void HTMLDOMNode_destructor(HTMLDOMNode *This) { if(This->nsnode) nsIDOMNode_Release(This->nsnode); if(This->doc && &This->doc->node != This) htmldoc_release(&This->doc->basedoc); if(This->event_target.ptr) release_event_target(This->event_target.ptr); }
static HRESULT WINAPI HTMLDOMNode_insertBefore(IHTMLDOMNode *iface, IHTMLDOMNode *newChild, VARIANT refChild, IHTMLDOMNode **node) { HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface); HTMLDOMNode *new_child, *node_obj, *ref_node = NULL; nsIDOMNode *nsnode; nsresult nsres; HRESULT hres = S_OK; TRACE("(%p)->(%p %s %p)\n", This, newChild, debugstr_variant(&refChild), node); new_child = get_node_obj(This->doc, (IUnknown*)newChild); if(!new_child) { ERR("invalid newChild\n"); return E_INVALIDARG; } switch(V_VT(&refChild)) { case VT_NULL: break; case VT_DISPATCH: { ref_node = get_node_obj(This->doc, (IUnknown*)V_DISPATCH(&refChild)); if(!ref_node) { ERR("unvalid node\n"); hres = E_FAIL; break; } break; } default: FIXME("unimplemented refChild %s\n", debugstr_variant(&refChild)); hres = E_NOTIMPL; } if(SUCCEEDED(hres)) { nsres = nsIDOMNode_InsertBefore(This->nsnode, new_child->nsnode, ref_node ? ref_node->nsnode : NULL, &nsnode); if(NS_FAILED(nsres)) { ERR("InsertBefore failed: %08x\n", nsres); hres = E_FAIL; } } node_release(new_child); if(ref_node) node_release(ref_node); if(FAILED(hres)) return hres; hres = get_node(This->doc, nsnode, TRUE, &node_obj); nsIDOMNode_Release(nsnode); if(FAILED(hres)) return hres; *node = &node_obj->IHTMLDOMNode_iface; return S_OK; }
static HRESULT WINAPI HTMLScriptElement_put_src(IHTMLScriptElement *iface, BSTR v) { HTMLScriptElement *This = impl_from_IHTMLScriptElement(iface); HTMLInnerWindow *window; nsIDOMNode *parent; nsAString src_str; nsresult nsres; TRACE("(%p)->(%s)\n", This, debugstr_w(v)); if(!This->element.node.doc || !This->element.node.doc->window) { WARN("no windoow\n"); return E_UNEXPECTED; } window = This->element.node.doc->window; nsAString_InitDepend(&src_str, v); nsres = nsIDOMHTMLScriptElement_SetSrc(This->nsscript, &src_str); nsAString_Finish(&src_str); if(NS_FAILED(nsres)) { ERR("SetSrc failed: %08x\n", nsres); return E_FAIL; } if(This->parsed) { WARN("already parsed\n"); return S_OK; } if(window->parser_callback_cnt) { script_queue_entry_t *queue; queue = heap_alloc(sizeof(*queue)); if(!queue) return E_OUTOFMEMORY; IHTMLScriptElement_AddRef(&This->IHTMLScriptElement_iface); queue->script = This; list_add_tail(&window->script_queue, &queue->entry); return S_OK; } nsres = nsIDOMHTMLElement_GetParentNode(This->element.nselem, &parent); if(NS_FAILED(nsres) || !parent) { TRACE("No parent, not executing\n"); This->parse_on_bind = TRUE; return S_OK; } nsIDOMNode_Release(parent); doc_insert_script(window, This); return S_OK; }
void release_nodes(HTMLDocument *This) { HTMLDOMNode *iter, *next; if(!This->nodes) return; for(iter = This->nodes; iter; iter = next) { next = iter->next; if(iter->destructor) iter->destructor(iter->impl.unk); nsIDOMNode_Release(iter->nsnode); mshtml_free(iter); } }
static nsresult NSAPI handle_htmlevent(nsIDOMEventListener *iface, nsIDOMEvent *event) { nsEventListener *This = impl_from_nsIDOMEventListener(iface); HTMLDocumentNode *doc = This->This->doc; const PRUnichar *type; nsIDOMEventTarget *event_target; nsIDOMNode *nsnode; nsAString type_str; eventid_t eid; nsresult nsres; TRACE("%p\n", This->This); if(!doc) { WARN("NULL doc\n"); return NS_OK; } nsAString_Init(&type_str, NULL); nsIDOMEvent_GetType(event, &type_str); nsAString_GetData(&type_str, &type); eid = str_to_eid(type); nsAString_Finish(&type_str); nsres = nsIDOMEvent_GetTarget(event, &event_target); if(NS_FAILED(nsres) || !event_target) { ERR("GetEventTarget failed: %08x\n", nsres); return NS_OK; } nsres = nsIDOMEventTarget_QueryInterface(event_target, &IID_nsIDOMNode, (void**)&nsnode); nsIDOMEventTarget_Release(event_target); if(NS_FAILED(nsres)) { ERR("Could not get nsIDOMNode: %08x\n", nsres); return NS_OK; } fire_event(doc, eid, TRUE, nsnode, event, NULL); nsIDOMNode_Release(nsnode); return NS_OK; }
HRESULT script_elem_from_nsscript(HTMLDocumentNode *doc, nsIDOMHTMLScriptElement *nsscript, HTMLScriptElement **ret) { nsIDOMNode *nsnode; HTMLDOMNode *node; nsresult nsres; HRESULT hres; nsres = nsIDOMHTMLScriptElement_QueryInterface(nsscript, &IID_nsIDOMNode, (void**)&nsnode); assert(nsres == NS_OK); hres = get_node(doc, nsnode, TRUE, &node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) return hres; assert(node->vtbl == &HTMLScriptElementImplVtbl); *ret = impl_from_HTMLDOMNode(node); return S_OK; }