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

   1 /*
   2  * Copyright 2006 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winnls.h"
  30 #include "ole2.h"
  31
  32 #include "wine/debug.h"
  33
  34 #include "mshtml_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  37
  38 #define NSSUPPORTS(x)  ((nsISupports*)  &(x)->lpSupportsVtbl)
  39
  40 #define HTMLDOMNODE_THIS(iface) DEFINE_THIS(HTMLDOMNode, HTMLDOMNode, iface)
  41
  42 static HRESULT WINAPI HTMLDOMNode_QueryInterface(IHTMLDOMNode *iface,
  43                                                  REFIID riid, void **ppv)
  44 {
  45     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
  46     HRESULT hres;
  47
  48     if(This->impl.unk)
  49         return IUnknown_QueryInterface(This->impl.unk, riid, ppv);
  50
  51     hres = HTMLDOMNode_QI(This, riid, ppv);
  52     if(FAILED(hres))
  53         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  54
  55     return hres;
  56 }
  57
  58 static ULONG WINAPI HTMLDOMNode_AddRef(IHTMLDOMNode *iface)
  59 {
  60     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
  61
  62     TRACE("(%p)\n", This);
  63
  64     return IHTMLDocument2_AddRef(HTMLDOC(This->doc));
  65 }
  66
  67 static ULONG WINAPI HTMLDOMNode_Release(IHTMLDOMNode *iface)
  68 {
  69     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
  70
  71     TRACE("(%p)\n", This);
  72
  73     return IHTMLDocument2_Release(HTMLDOC(This->doc));
  74 }
  75
  76 static HRESULT WINAPI HTMLDOMNode_GetTypeInfoCount(IHTMLDOMNode *iface, UINT *pctinfo)
  77 {
  78     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
  79     FIXME("(%p)->(%p)\n", This, pctinfo);
  80     return E_NOTIMPL;
  81 }
  82
  83 static HRESULT WINAPI HTMLDOMNode_GetTypeInfo(IHTMLDOMNode *iface, UINT iTInfo,
  84                                               LCID lcid, ITypeInfo **ppTInfo)
  85 {
  86     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
  87     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
  88     return E_NOTIMPL;
  89 }
  90
  91 static HRESULT WINAPI HTMLDOMNode_GetIDsOfNames(IHTMLDOMNode *iface, REFIID riid,
  92                                                 LPOLESTR *rgszNames, UINT cNames,
  93                                                 LCID lcid, DISPID *rgDispId)
  94 {
  95     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
  96     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
  97                                         lcid, rgDispId);
  98     return E_NOTIMPL;
  99 }
 100
 101 static HRESULT WINAPI HTMLDOMNode_Invoke(IHTMLDOMNode *iface, DISPID dispIdMember,
 102                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 103                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 104 {
 105     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 106     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 107             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 108     return E_NOTIMPL;
 109 }
 110
 111 static HRESULT WINAPI HTMLDOMNode_get_nodeType(IHTMLDOMNode *iface, long *p)
 112 {
 113     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 114     FIXME("(%p)->(%p)\n", This, p);
 115     return E_NOTIMPL;
 116 }
 117
 118 static HRESULT WINAPI HTMLDOMNode_get_parentNode(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 119 {
 120     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 121     FIXME("(%p)->(%p)\n", This, p);
 122     return E_NOTIMPL;
 123 }
 124
 125 static HRESULT WINAPI HTMLDOMNode_hasChildNodes(IHTMLDOMNode *iface, VARIANT_BOOL *fChildren)
 126 {
 127     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 128     FIXME("(%p)->(%p)\n", This, fChildren);
 129     return E_NOTIMPL;
 130 }
 131
 132 static HRESULT WINAPI HTMLDOMNode_get_childNodes(IHTMLDOMNode *iface, IDispatch **p)
 133 {
 134     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 135     FIXME("(%p)->(%p)\n", This, p);
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI HTMLDOMNode_get_attributes(IHTMLDOMNode *iface, IDispatch **p)
 140 {
 141     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 142     FIXME("(%p)->(%p)\n", This, p);
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI HTMLDOMNode_insertBefore(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 147                                                VARIANT refChild, IHTMLDOMNode **node)
 148 {
 149     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 150     FIXME("(%p)->(%p v %p)\n", This, newChild, node);
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI HTMLDOMNode_removeChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 155                                               IHTMLDOMNode **node)
 156 {
 157     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 158     FIXME("(%p)->(%p %p)\n", This, newChild, node);
 159     return E_NOTIMPL;
 160 }
 161
 162 static HRESULT WINAPI HTMLDOMNode_replaceChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 163                                                IHTMLDOMNode *oldChild, IHTMLDOMNode **node)
 164 {
 165     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 166     FIXME("(%p)->(%p %p %p)\n", This, newChild, oldChild, node);
 167     return E_NOTIMPL;
 168 }
 169
 170 static HRESULT WINAPI HTMLDOMNode_cloneNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
 171                                             IHTMLDOMNode **clonedNode)
 172 {
 173     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 174     FIXME("(%p)->(%x %p)\n", This, fDeep, clonedNode);
 175     return E_NOTIMPL;
 176 }
 177
 178 static HRESULT WINAPI HTMLDOMNode_removeNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
 179                                              IHTMLDOMNode **removed)
 180 {
 181     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 182     FIXME("(%p)->(%x %p)\n", This, fDeep, removed);
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT WINAPI HTMLDOMNode_swapNode(IHTMLDOMNode *iface, IHTMLDOMNode *otherNode,
 187                                            IHTMLDOMNode **swappedNode)
 188 {
 189     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 190     FIXME("(%p)->(%p %p)\n", This, otherNode, swappedNode);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI HTMLDOMNode_replaceNode(IHTMLDOMNode *iface, IHTMLDOMNode *replacement,
 195                                               IHTMLDOMNode **replaced)
 196 {
 197     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 198     FIXME("(%p)->(%p %p)\n", This, replacement, replaced);
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI HTMLDOMNode_appendChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 203                                               IHTMLDOMNode **node)
 204 {
 205     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 206     FIXME("(%p)->(%p %p)\n", This, newChild, node);
 207     return E_NOTIMPL;
 208 }
 209
 210 static HRESULT WINAPI HTMLDOMNode_get_nodeName(IHTMLDOMNode *iface, BSTR *p)
 211 {
 212     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 213
 214     TRACE("(%p)->(%p)\n", This, p);
 215
 216     *p = NULL;
 217
 218     if(This->nsnode) {
 219         nsAString name_str;
 220         const PRUnichar *name;
 221         nsresult nsres;
 222
 223         nsAString_Init(&name_str, NULL);
 224         nsres = nsIDOMNode_GetNodeName(This->nsnode, &name_str);
 225
 226         if(NS_SUCCEEDED(nsres)) {
 227             nsAString_GetData(&name_str, &name, NULL);
 228             *p = SysAllocString(name);
 229         }else {
 230             ERR("GetNodeName failed: %08x\n", nsres);
 231         }
 232
 233         nsAString_Finish(&name_str);
 234     }
 235
 236     return S_OK;
 237 }
 238
 239 static HRESULT WINAPI HTMLDOMNode_put_nodeValue(IHTMLDOMNode *iface, VARIANT v)
 240 {
 241     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 242     FIXME("(%p)->()\n", This);
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI HTMLDOMNode_get_nodeValue(IHTMLDOMNode *iface, VARIANT *p)
 247 {
 248     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 249     FIXME("(%p)->(%p)\n", This, p);
 250     return E_NOTIMPL;
 251 }
 252
 253 static HRESULT WINAPI HTMLDOMNode_get_firstChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 254 {
 255     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 256     FIXME("(%p)->(%p)\n", This, p);
 257     return E_NOTIMPL;
 258 }
 259
 260 static HRESULT WINAPI HTMLDOMNode_get_lastChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 261 {
 262     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 263     FIXME("(%p)->(%p)\n", This, p);
 264     return E_NOTIMPL;
 265 }
 266
 267 static HRESULT WINAPI HTMLDOMNode_get_previousSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 268 {
 269     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 270     FIXME("(%p)->(%p)\n", This, p);
 271     return E_NOTIMPL;
 272 }
 273
 274 static HRESULT WINAPI HTMLDOMNode_get_nextSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 275 {
 276     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 277     FIXME("(%p)->(%p)\n", This, p);
 278     return E_NOTIMPL;
 279 }
 280
 281 static const IHTMLDOMNodeVtbl HTMLDOMNodeVtbl = {
 282     HTMLDOMNode_QueryInterface,
 283     HTMLDOMNode_AddRef,
 284     HTMLDOMNode_Release,
 285     HTMLDOMNode_GetTypeInfoCount,
 286     HTMLDOMNode_GetTypeInfo,
 287     HTMLDOMNode_GetIDsOfNames,
 288     HTMLDOMNode_Invoke,
 289     HTMLDOMNode_get_nodeType,
 290     HTMLDOMNode_get_parentNode,
 291     HTMLDOMNode_hasChildNodes,
 292     HTMLDOMNode_get_childNodes,
 293     HTMLDOMNode_get_attributes,
 294     HTMLDOMNode_insertBefore,
 295     HTMLDOMNode_removeChild,
 296     HTMLDOMNode_replaceChild,
 297     HTMLDOMNode_cloneNode,
 298     HTMLDOMNode_removeNode,
 299     HTMLDOMNode_swapNode,
 300     HTMLDOMNode_replaceNode,
 301     HTMLDOMNode_appendChild,
 302     HTMLDOMNode_get_nodeName,
 303     HTMLDOMNode_put_nodeValue,
 304     HTMLDOMNode_get_nodeValue,
 305     HTMLDOMNode_get_firstChild,
 306     HTMLDOMNode_get_lastChild,
 307     HTMLDOMNode_get_previousSibling,
 308     HTMLDOMNode_get_nextSibling
 309 };
 310
 311 HRESULT HTMLDOMNode_QI(HTMLDOMNode *This, REFIID riid, void **ppv)
 312 {
 313     *ppv = NULL;
 314
 315     if(IsEqualGUID(&IID_IUnknown, riid)) {
 316         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 317         *ppv = HTMLDOMNODE(This);
 318     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 319         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 320         *ppv = HTMLDOMNODE(This);
 321     }else if(IsEqualGUID(&IID_IHTMLDOMNode, riid)) {
 322         TRACE("(%p)->(IID_IHTMLDOMNode %p)\n", This, ppv);
 323         *ppv = HTMLDOMNODE(This);
 324     }
 325
 326     if(*ppv) {
 327         IUnknown_AddRef((IUnknown*)*ppv);
 328         return S_OK;
 329     }
 330
 331     return E_NOINTERFACE;
 332 }
 333
 334 static HTMLDOMNode *create_node(HTMLDocument *doc, nsIDOMNode *nsnode)
 335 {
 336     HTMLDOMNode *ret;
 337     PRUint16 node_type;
 338
 339     nsIDOMNode_GetNodeType(nsnode, &node_type);
 340
 341     switch(node_type) {
 342     case ELEMENT_NODE:
 343         ret = &HTMLElement_Create(nsnode)->node;
 344         break;
 345     default:
 346         ret = mshtml_alloc(sizeof(HTMLDOMNode));
 347         ret->impl.unk = NULL;
 348         ret->destructor = NULL;
 349     }
 350
 351     ret->lpHTMLDOMNodeVtbl = &HTMLDOMNodeVtbl;
 352     ret->doc = doc;
 353
 354     nsIDOMNode_AddRef(nsnode);
 355     ret->nsnode = nsnode;
 356
 357     return ret;
 358 }
 359
 360 /*
 361  * FIXME
 362  * List looks really ugly here. We should use a better data structure or
 363  * (better) find a way to store HTMLDOMelement poiner in nsIDOMNode.
 364  */
 365
 366 HTMLDOMNode *get_node(HTMLDocument *This, nsIDOMNode *nsnode)
 367 {
 368     HTMLDOMNode *iter = This->nodes, *ret;
 369
 370     while(iter) {
 371         if(iter->nsnode == nsnode)
 372             break;
 373         iter = iter->next;
 374     }
 375
 376     if(iter)
 377         return iter;
 378
 379     ret = create_node(This, nsnode);
 380
 381     ret->next = This->nodes;
 382     This->nodes = ret;
 383
 384     return ret;
 385 }
 386
 387 void release_nodes(HTMLDocument *This)
 388 {
 389     HTMLDOMNode *iter, *next;
 390
 391     if(!This->nodes)
 392         return;
 393
 394     for(iter = This->nodes; iter; iter = next) {
 395         next = iter->next;
 396         nsIDOMNode_Release(iter->nsnode);
 397         if(iter->destructor)
 398             iter->destructor(iter->impl.unk);
 399         else
 400             mshtml_free(iter);
 401     }
 402 }