dlls/mshtml/htmlhead.c

   1  /*
   2  * Copyright 2011,2012 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
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27 #include "mshtmdid.h"
  28
  29 #include "wine/debug.h"
  30
  31 #include "mshtml_private.h"
  32 #include "htmlevent.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  35
  36 struct HTMLTitleElement {
  37     HTMLElement element;
  38
  39     IHTMLTitleElement IHTMLTitleElement_iface;
  40 };
  41
  42 static inline HTMLTitleElement *impl_from_IHTMLTitleElement(IHTMLTitleElement *iface)
  43 {
  44     return CONTAINING_RECORD(iface, HTMLTitleElement, IHTMLTitleElement_iface);
  45 }
  46
  47 static HRESULT WINAPI HTMLTitleElement_QueryInterface(IHTMLTitleElement *iface,
  48                                                          REFIID riid, void **ppv)
  49 {
  50     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
  51
  52     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
  53 }
  54
  55 static ULONG WINAPI HTMLTitleElement_AddRef(IHTMLTitleElement *iface)
  56 {
  57     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
  58
  59     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
  60 }
  61
  62 static ULONG WINAPI HTMLTitleElement_Release(IHTMLTitleElement *iface)
  63 {
  64     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
  65
  66     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
  67 }
  68
  69 static HRESULT WINAPI HTMLTitleElement_GetTypeInfoCount(IHTMLTitleElement *iface, UINT *pctinfo)
  70 {
  71     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
  72
  73     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
  74 }
  75
  76 static HRESULT WINAPI HTMLTitleElement_GetTypeInfo(IHTMLTitleElement *iface, UINT iTInfo,
  77         LCID lcid, ITypeInfo **ppTInfo)
  78 {
  79     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
  80
  81     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
  82             ppTInfo);
  83 }
  84
  85 static HRESULT WINAPI HTMLTitleElement_GetIDsOfNames(IHTMLTitleElement *iface, REFIID riid,
  86         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
  87 {
  88     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
  89
  90     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
  91             cNames, lcid, rgDispId);
  92 }
  93
  94 static HRESULT WINAPI HTMLTitleElement_Invoke(IHTMLTitleElement *iface, DISPID dispIdMember,
  95         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
  96         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
  97 {
  98     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
  99
 100     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 101             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 102 }
 103
 104 static HRESULT WINAPI HTMLTitleElement_put_text(IHTMLTitleElement *iface, BSTR v)
 105 {
 106     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
 107     nsAString text;
 108     nsresult nsres;
 109
 110     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 111
 112     nsAString_InitDepend(&text, v);
 113     nsres = nsIDOMNode_SetTextContent(This->element.node.nsnode, &text);
 114     nsAString_Finish(&text);
 115
 116     return map_nsresult(nsres);
 117 }
 118
 119 static HRESULT WINAPI HTMLTitleElement_get_text(IHTMLTitleElement *iface, BSTR *p)
 120 {
 121     HTMLTitleElement *This = impl_from_IHTMLTitleElement(iface);
 122     nsAString text;
 123     nsresult nsres;
 124
 125     TRACE("(%p)->(%p)\n", This, p);
 126
 127     nsAString_InitDepend(&text, NULL);
 128     nsres = nsIDOMNode_GetTextContent(This->element.node.nsnode, &text);
 129     return return_nsstr(nsres, &text, p);
 130 }
 131
 132 static const IHTMLTitleElementVtbl HTMLTitleElementVtbl = {
 133     HTMLTitleElement_QueryInterface,
 134     HTMLTitleElement_AddRef,
 135     HTMLTitleElement_Release,
 136     HTMLTitleElement_GetTypeInfoCount,
 137     HTMLTitleElement_GetTypeInfo,
 138     HTMLTitleElement_GetIDsOfNames,
 139     HTMLTitleElement_Invoke,
 140     HTMLTitleElement_put_text,
 141     HTMLTitleElement_get_text
 142 };
 143
 144 static inline HTMLTitleElement *HTMLTitleElement_from_DispatchEx(DispatchEx *iface)
 145 {
 146     return CONTAINING_RECORD(iface, HTMLTitleElement, element.node.event_target.dispex);
 147 }
 148
 149 static void *HTMLTitleElement_query_interface(DispatchEx *dispex, REFIID riid)
 150 {
 151     HTMLTitleElement *This = HTMLTitleElement_from_DispatchEx(dispex);
 152
 153     if(IsEqualGUID(&IID_IHTMLTitleElement, riid))
 154         return &This->IHTMLTitleElement_iface;
 155
 156     return HTMLElement_query_interface(&This->element.node.event_target.dispex, riid);
 157 }
 158
 159 static const NodeImplVtbl HTMLTitleElementImplVtbl = {
 160     .clsid                 = &CLSID_HTMLTitleElement,
 161     .cpc_entries           = HTMLElement_cpc,
 162     .clone                 = HTMLElement_clone,
 163     .get_attr_col          = HTMLElement_get_attr_col
 164 };
 165
 166 static const event_target_vtbl_t HTMLTitleElement_event_target_vtbl = {
 167     {
 168         HTMLELEMENT_DISPEX_VTBL_ENTRIES,
 169         .query_interface= HTMLTitleElement_query_interface,
 170         .destructor     = HTMLElement_destructor,
 171         .traverse       = HTMLDOMNode_traverse,
 172         .unlink         = HTMLDOMNode_unlink
 173     },
 174     HTMLELEMENT_EVENT_TARGET_VTBL_ENTRIES,
 175     .handle_event       = HTMLElement_handle_event
 176 };
 177
 178 static const tid_t HTMLTitleElement_iface_tids[] = {
 179     HTMLELEMENT_TIDS,
 180     IHTMLTitleElement_tid,
 181     0
 182 };
 183 static dispex_static_data_t HTMLTitleElement_dispex = {
 184     "HTMLTitleElement",
 185     &HTMLTitleElement_event_target_vtbl.dispex_vtbl,
 186     DispHTMLTitleElement_tid,
 187     HTMLTitleElement_iface_tids,
 188     HTMLElement_init_dispex_info
 189 };
 190
 191 HRESULT HTMLTitleElement_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
 192 {
 193     HTMLTitleElement *ret;
 194
 195     ret = calloc(1, sizeof(*ret));
 196     if(!ret)
 197         return E_OUTOFMEMORY;
 198
 199     ret->IHTMLTitleElement_iface.lpVtbl = &HTMLTitleElementVtbl;
 200     ret->element.node.vtbl = &HTMLTitleElementImplVtbl;
 201
 202     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTitleElement_dispex);
 203
 204     *elem = &ret->element;
 205     return S_OK;
 206 }
 207
 208 struct HTMLHtmlElement {
 209     HTMLElement element;
 210
 211     IHTMLHtmlElement IHTMLHtmlElement_iface;
 212 };
 213
 214 static inline HTMLHtmlElement *impl_from_IHTMLHtmlElement(IHTMLHtmlElement *iface)
 215 {
 216     return CONTAINING_RECORD(iface, HTMLHtmlElement, IHTMLHtmlElement_iface);
 217 }
 218
 219 static HRESULT WINAPI HTMLHtmlElement_QueryInterface(IHTMLHtmlElement *iface,
 220                                                          REFIID riid, void **ppv)
 221 {
 222     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 223
 224     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 225 }
 226
 227 static ULONG WINAPI HTMLHtmlElement_AddRef(IHTMLHtmlElement *iface)
 228 {
 229     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 230
 231     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 232 }
 233
 234 static ULONG WINAPI HTMLHtmlElement_Release(IHTMLHtmlElement *iface)
 235 {
 236     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 237
 238     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 239 }
 240
 241 static HRESULT WINAPI HTMLHtmlElement_GetTypeInfoCount(IHTMLHtmlElement *iface, UINT *pctinfo)
 242 {
 243     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 244
 245     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
 246 }
 247
 248 static HRESULT WINAPI HTMLHtmlElement_GetTypeInfo(IHTMLHtmlElement *iface, UINT iTInfo,
 249                                               LCID lcid, ITypeInfo **ppTInfo)
 250 {
 251     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 252
 253     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 254             ppTInfo);
 255 }
 256
 257 static HRESULT WINAPI HTMLHtmlElement_GetIDsOfNames(IHTMLHtmlElement *iface, REFIID riid,
 258                                                 LPOLESTR *rgszNames, UINT cNames,
 259                                                 LCID lcid, DISPID *rgDispId)
 260 {
 261     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 262
 263     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 264             cNames, lcid, rgDispId);
 265 }
 266
 267 static HRESULT WINAPI HTMLHtmlElement_Invoke(IHTMLHtmlElement *iface, DISPID dispIdMember,
 268                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 269                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 270 {
 271     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 272
 273     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 274             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 275 }
 276
 277 static HRESULT WINAPI HTMLHtmlElement_put_version(IHTMLHtmlElement *iface, BSTR v)
 278 {
 279     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 280     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 281     return E_NOTIMPL;
 282 }
 283
 284 static HRESULT WINAPI HTMLHtmlElement_get_version(IHTMLHtmlElement *iface, BSTR *p)
 285 {
 286     HTMLHtmlElement *This = impl_from_IHTMLHtmlElement(iface);
 287     FIXME("(%p)->(%p)\n", This, p);
 288     return E_NOTIMPL;
 289 }
 290
 291 static const IHTMLHtmlElementVtbl HTMLHtmlElementVtbl = {
 292     HTMLHtmlElement_QueryInterface,
 293     HTMLHtmlElement_AddRef,
 294     HTMLHtmlElement_Release,
 295     HTMLHtmlElement_GetTypeInfoCount,
 296     HTMLHtmlElement_GetTypeInfo,
 297     HTMLHtmlElement_GetIDsOfNames,
 298     HTMLHtmlElement_Invoke,
 299     HTMLHtmlElement_put_version,
 300     HTMLHtmlElement_get_version
 301 };
 302
 303 static inline HTMLHtmlElement *HTMLHtmlElement_from_DispatchEx(DispatchEx *iface)
 304 {
 305     return CONTAINING_RECORD(iface, HTMLHtmlElement, element.node.event_target.dispex);
 306 }
 307
 308 static BOOL HTMLHtmlElement_is_settable(HTMLDOMNode *iface, DISPID dispid)
 309 {
 310     switch(dispid) {
 311     case DISPID_IHTMLELEMENT_OUTERTEXT:
 312         return FALSE;
 313     default:
 314         return TRUE;
 315     }
 316 }
 317
 318 static void *HTMLHtmlElement_query_interface(DispatchEx *dispex, REFIID riid)
 319 {
 320     HTMLHtmlElement *This = HTMLHtmlElement_from_DispatchEx(dispex);
 321
 322     if(IsEqualGUID(&IID_IHTMLHtmlElement, riid))
 323         return &This->IHTMLHtmlElement_iface;
 324
 325     return HTMLElement_query_interface(&This->element.node.event_target.dispex, riid);
 326 }
 327
 328 static const NodeImplVtbl HTMLHtmlElementImplVtbl = {
 329     .clsid                 = &CLSID_HTMLHtmlElement,
 330     .cpc_entries           = HTMLElement_cpc,
 331     .clone                 = HTMLElement_clone,
 332     .get_attr_col          = HTMLElement_get_attr_col,
 333     .is_settable           = HTMLHtmlElement_is_settable
 334 };
 335
 336 static const event_target_vtbl_t HTMLHtmlElement_event_target_vtbl = {
 337     {
 338         HTMLELEMENT_DISPEX_VTBL_ENTRIES,
 339         .query_interface= HTMLHtmlElement_query_interface,
 340         .destructor     = HTMLElement_destructor,
 341         .traverse       = HTMLDOMNode_traverse,
 342         .unlink         = HTMLDOMNode_unlink
 343     },
 344     HTMLELEMENT_EVENT_TARGET_VTBL_ENTRIES,
 345     .handle_event       = HTMLElement_handle_event
 346 };
 347
 348 static const tid_t HTMLHtmlElement_iface_tids[] = {
 349     HTMLELEMENT_TIDS,
 350     IHTMLHtmlElement_tid,
 351     0
 352 };
 353 static dispex_static_data_t HTMLHtmlElement_dispex = {
 354     "HTMLHtmlElement",
 355     &HTMLHtmlElement_event_target_vtbl.dispex_vtbl,
 356     DispHTMLHtmlElement_tid,
 357     HTMLHtmlElement_iface_tids,
 358     HTMLElement_init_dispex_info
 359 };
 360
 361 HRESULT HTMLHtmlElement_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
 362 {
 363     HTMLHtmlElement *ret;
 364
 365     ret = calloc(1, sizeof(*ret));
 366     if(!ret)
 367         return E_OUTOFMEMORY;
 368
 369     ret->IHTMLHtmlElement_iface.lpVtbl = &HTMLHtmlElementVtbl;
 370     ret->element.node.vtbl = &HTMLHtmlElementImplVtbl;
 371
 372     HTMLElement_Init(&ret->element, doc, nselem, &HTMLHtmlElement_dispex);
 373
 374     *elem = &ret->element;
 375     return S_OK;
 376 }
 377
 378 struct HTMLMetaElement {
 379     HTMLElement element;
 380
 381     IHTMLMetaElement IHTMLMetaElement_iface;
 382 };
 383
 384 static inline HTMLMetaElement *impl_from_IHTMLMetaElement(IHTMLMetaElement *iface)
 385 {
 386     return CONTAINING_RECORD(iface, HTMLMetaElement, IHTMLMetaElement_iface);
 387 }
 388
 389 static HRESULT WINAPI HTMLMetaElement_QueryInterface(IHTMLMetaElement *iface, REFIID riid, void **ppv)
 390 {
 391     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 392
 393     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 394 }
 395
 396 static ULONG WINAPI HTMLMetaElement_AddRef(IHTMLMetaElement *iface)
 397 {
 398     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 399
 400     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 401 }
 402
 403 static ULONG WINAPI HTMLMetaElement_Release(IHTMLMetaElement *iface)
 404 {
 405     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 406
 407     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 408 }
 409
 410 static HRESULT WINAPI HTMLMetaElement_GetTypeInfoCount(IHTMLMetaElement *iface, UINT *pctinfo)
 411 {
 412     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 413     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
 414 }
 415
 416 static HRESULT WINAPI HTMLMetaElement_GetTypeInfo(IHTMLMetaElement *iface, UINT iTInfo,
 417                                               LCID lcid, ITypeInfo **ppTInfo)
 418 {
 419     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 420     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 421             ppTInfo);
 422 }
 423
 424 static HRESULT WINAPI HTMLMetaElement_GetIDsOfNames(IHTMLMetaElement *iface, REFIID riid,
 425         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 426 {
 427     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 428     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 429             cNames, lcid, rgDispId);
 430 }
 431
 432 static HRESULT WINAPI HTMLMetaElement_Invoke(IHTMLMetaElement *iface, DISPID dispIdMember, REFIID riid,
 433         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 434         UINT *puArgErr)
 435 {
 436     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 437     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 438             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 439 }
 440
 441 static HRESULT WINAPI HTMLMetaElement_put_httpEquiv(IHTMLMetaElement *iface, BSTR v)
 442 {
 443     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 444     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI HTMLMetaElement_get_httpEquiv(IHTMLMetaElement *iface, BSTR *p)
 449 {
 450     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 451
 452     TRACE("(%p)->(%p)\n", This, p);
 453
 454     return elem_string_attr_getter(&This->element, L"http-equiv", TRUE, p);
 455 }
 456
 457 static HRESULT WINAPI HTMLMetaElement_put_content(IHTMLMetaElement *iface, BSTR v)
 458 {
 459     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 460     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI HTMLMetaElement_get_content(IHTMLMetaElement *iface, BSTR *p)
 465 {
 466     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 467
 468     TRACE("(%p)->(%p)\n", This, p);
 469
 470     return elem_string_attr_getter(&This->element, L"content", TRUE, p);
 471 }
 472
 473 static HRESULT WINAPI HTMLMetaElement_put_name(IHTMLMetaElement *iface, BSTR v)
 474 {
 475     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 476     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 477     return E_NOTIMPL;
 478 }
 479
 480 static HRESULT WINAPI HTMLMetaElement_get_name(IHTMLMetaElement *iface, BSTR *p)
 481 {
 482     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 483
 484     TRACE("(%p)->(%p)\n", This, p);
 485
 486     return elem_string_attr_getter(&This->element, L"name", TRUE, p);
 487 }
 488
 489 static HRESULT WINAPI HTMLMetaElement_put_url(IHTMLMetaElement *iface, BSTR v)
 490 {
 491     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 492     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI HTMLMetaElement_get_url(IHTMLMetaElement *iface, BSTR *p)
 497 {
 498     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 499     FIXME("(%p)->(%p)\n", This, p);
 500     return E_NOTIMPL;
 501 }
 502
 503 static HRESULT WINAPI HTMLMetaElement_put_charset(IHTMLMetaElement *iface, BSTR v)
 504 {
 505     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 506
 507     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 508
 509     return elem_string_attr_setter(&This->element, L"charset", v);
 510 }
 511
 512 static HRESULT WINAPI HTMLMetaElement_get_charset(IHTMLMetaElement *iface, BSTR *p)
 513 {
 514     HTMLMetaElement *This = impl_from_IHTMLMetaElement(iface);
 515
 516     TRACE("(%p)->(%p)\n", This, p);
 517
 518     return elem_string_attr_getter(&This->element, L"charset", TRUE, p);
 519 }
 520
 521 static const IHTMLMetaElementVtbl HTMLMetaElementVtbl = {
 522     HTMLMetaElement_QueryInterface,
 523     HTMLMetaElement_AddRef,
 524     HTMLMetaElement_Release,
 525     HTMLMetaElement_GetTypeInfoCount,
 526     HTMLMetaElement_GetTypeInfo,
 527     HTMLMetaElement_GetIDsOfNames,
 528     HTMLMetaElement_Invoke,
 529     HTMLMetaElement_put_httpEquiv,
 530     HTMLMetaElement_get_httpEquiv,
 531     HTMLMetaElement_put_content,
 532     HTMLMetaElement_get_content,
 533     HTMLMetaElement_put_name,
 534     HTMLMetaElement_get_name,
 535     HTMLMetaElement_put_url,
 536     HTMLMetaElement_get_url,
 537     HTMLMetaElement_put_charset,
 538     HTMLMetaElement_get_charset
 539 };
 540
 541 static inline HTMLMetaElement *HTMLMetaElement_from_DispatchEx(DispatchEx *iface)
 542 {
 543     return CONTAINING_RECORD(iface, HTMLMetaElement, element.node.event_target.dispex);
 544 }
 545
 546 static void *HTMLMetaElement_query_interface(DispatchEx *dispex, REFIID riid)
 547 {
 548     HTMLMetaElement *This = HTMLMetaElement_from_DispatchEx(dispex);
 549
 550     if(IsEqualGUID(&IID_IHTMLMetaElement, riid))
 551         return &This->IHTMLMetaElement_iface;
 552
 553     return HTMLElement_query_interface(&This->element.node.event_target.dispex, riid);
 554 }
 555
 556 static const NodeImplVtbl HTMLMetaElementImplVtbl = {
 557     .clsid                 = &CLSID_HTMLMetaElement,
 558     .cpc_entries           = HTMLElement_cpc,
 559     .clone                 = HTMLElement_clone,
 560     .get_attr_col          = HTMLElement_get_attr_col
 561 };
 562
 563 static const event_target_vtbl_t HTMLMetaElement_event_target_vtbl = {
 564     {
 565         HTMLELEMENT_DISPEX_VTBL_ENTRIES,
 566         .query_interface= HTMLMetaElement_query_interface,
 567         .destructor     = HTMLElement_destructor,
 568         .traverse       = HTMLDOMNode_traverse,
 569         .unlink         = HTMLDOMNode_unlink
 570     },
 571     HTMLELEMENT_EVENT_TARGET_VTBL_ENTRIES,
 572     .handle_event       = HTMLElement_handle_event
 573 };
 574
 575 static const tid_t HTMLMetaElement_iface_tids[] = {
 576     HTMLELEMENT_TIDS,
 577     IHTMLMetaElement_tid,
 578     0
 579 };
 580
 581 static dispex_static_data_t HTMLMetaElement_dispex = {
 582     "HTMLMetaElement",
 583     &HTMLMetaElement_event_target_vtbl.dispex_vtbl,
 584     DispHTMLMetaElement_tid,
 585     HTMLMetaElement_iface_tids,
 586     HTMLElement_init_dispex_info
 587 };
 588
 589 HRESULT HTMLMetaElement_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
 590 {
 591     HTMLMetaElement *ret;
 592
 593     ret = calloc(1, sizeof(*ret));
 594     if(!ret)
 595         return E_OUTOFMEMORY;
 596
 597     ret->IHTMLMetaElement_iface.lpVtbl = &HTMLMetaElementVtbl;
 598     ret->element.node.vtbl = &HTMLMetaElementImplVtbl;
 599
 600     HTMLElement_Init(&ret->element, doc, nselem, &HTMLMetaElement_dispex);
 601
 602     *elem = &ret->element;
 603     return S_OK;
 604 }
 605
 606 struct HTMLHeadElement {
 607     HTMLElement element;
 608
 609     IHTMLHeadElement IHTMLHeadElement_iface;
 610 };
 611
 612 static inline HTMLHeadElement *impl_from_IHTMLHeadElement(IHTMLHeadElement *iface)
 613 {
 614     return CONTAINING_RECORD(iface, HTMLHeadElement, IHTMLHeadElement_iface);
 615 }
 616
 617 static HRESULT WINAPI HTMLHeadElement_QueryInterface(IHTMLHeadElement *iface,
 618                                                          REFIID riid, void **ppv)
 619 {
 620     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 621
 622     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 623 }
 624
 625 static ULONG WINAPI HTMLHeadElement_AddRef(IHTMLHeadElement *iface)
 626 {
 627     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 628
 629     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 630 }
 631
 632 static ULONG WINAPI HTMLHeadElement_Release(IHTMLHeadElement *iface)
 633 {
 634     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 635
 636     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 637 }
 638
 639 static HRESULT WINAPI HTMLHeadElement_GetTypeInfoCount(IHTMLHeadElement *iface, UINT *pctinfo)
 640 {
 641     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 642
 643     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
 644 }
 645
 646 static HRESULT WINAPI HTMLHeadElement_GetTypeInfo(IHTMLHeadElement *iface, UINT iTInfo,
 647                                               LCID lcid, ITypeInfo **ppTInfo)
 648 {
 649     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 650
 651     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 652             ppTInfo);
 653 }
 654
 655 static HRESULT WINAPI HTMLHeadElement_GetIDsOfNames(IHTMLHeadElement *iface, REFIID riid,
 656                                                 LPOLESTR *rgszNames, UINT cNames,
 657                                                 LCID lcid, DISPID *rgDispId)
 658 {
 659     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 660
 661     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 662             cNames, lcid, rgDispId);
 663 }
 664
 665 static HRESULT WINAPI HTMLHeadElement_Invoke(IHTMLHeadElement *iface, DISPID dispIdMember,
 666                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 667                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 668 {
 669     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 670
 671     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 672             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 673 }
 674
 675 static HRESULT WINAPI HTMLHeadElement_put_profile(IHTMLHeadElement *iface, BSTR v)
 676 {
 677     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 678     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 679     return E_NOTIMPL;
 680 }
 681
 682 static HRESULT WINAPI HTMLHeadElement_get_profile(IHTMLHeadElement *iface, BSTR *p)
 683 {
 684     HTMLHeadElement *This = impl_from_IHTMLHeadElement(iface);
 685     FIXME("(%p)->(%p)\n", This, p);
 686     return E_NOTIMPL;
 687 }
 688
 689 static const IHTMLHeadElementVtbl HTMLHeadElementVtbl = {
 690     HTMLHeadElement_QueryInterface,
 691     HTMLHeadElement_AddRef,
 692     HTMLHeadElement_Release,
 693     HTMLHeadElement_GetTypeInfoCount,
 694     HTMLHeadElement_GetTypeInfo,
 695     HTMLHeadElement_GetIDsOfNames,
 696     HTMLHeadElement_Invoke,
 697     HTMLHeadElement_put_profile,
 698     HTMLHeadElement_get_profile
 699 };
 700
 701 static inline HTMLHeadElement *impl_from_DispatchEx(DispatchEx *iface)
 702 {
 703     return CONTAINING_RECORD(iface, HTMLHeadElement, element.node.event_target.dispex);
 704 }
 705
 706 static void *HTMLHeadElement_query_interface(DispatchEx *dispex, REFIID riid)
 707 {
 708     HTMLHeadElement *This = impl_from_DispatchEx(dispex);
 709
 710     if(IsEqualGUID(&IID_IHTMLHeadElement, riid))
 711         return &This->IHTMLHeadElement_iface;
 712     if(IsEqualGUID(&DIID_DispHTMLHeadElement, riid))
 713         return &This->IHTMLHeadElement_iface;
 714
 715     return HTMLElement_query_interface(&This->element.node.event_target.dispex, riid);
 716 }
 717
 718 static const NodeImplVtbl HTMLHeadElementImplVtbl = {
 719     .clsid                 = &CLSID_HTMLHeadElement,
 720     .cpc_entries           = HTMLElement_cpc,
 721     .clone                 = HTMLElement_clone,
 722     .get_attr_col          = HTMLElement_get_attr_col
 723 };
 724
 725 static const event_target_vtbl_t HTMLHeadElement_event_target_vtbl = {
 726     {
 727         HTMLELEMENT_DISPEX_VTBL_ENTRIES,
 728         .query_interface= HTMLHeadElement_query_interface,
 729         .destructor     = HTMLElement_destructor,
 730         .traverse       = HTMLDOMNode_traverse,
 731         .unlink         = HTMLDOMNode_unlink
 732     },
 733     HTMLELEMENT_EVENT_TARGET_VTBL_ENTRIES,
 734     .handle_event       = HTMLElement_handle_event
 735 };
 736
 737 static const tid_t HTMLHeadElement_iface_tids[] = {
 738     HTMLELEMENT_TIDS,
 739     IHTMLHeadElement_tid,
 740     0
 741 };
 742 static dispex_static_data_t HTMLHeadElement_dispex = {
 743     "HTMLHeadElement",
 744     &HTMLHeadElement_event_target_vtbl.dispex_vtbl,
 745     DispHTMLHeadElement_tid,
 746     HTMLHeadElement_iface_tids,
 747     HTMLElement_init_dispex_info
 748 };
 749
 750 HRESULT HTMLHeadElement_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
 751 {
 752     HTMLHeadElement *ret;
 753
 754     ret = calloc(1, sizeof(*ret));
 755     if(!ret)
 756         return E_OUTOFMEMORY;
 757
 758     ret->IHTMLHeadElement_iface.lpVtbl = &HTMLHeadElementVtbl;
 759     ret->element.node.vtbl = &HTMLHeadElementImplVtbl;
 760
 761     HTMLElement_Init(&ret->element, doc, nselem, &HTMLHeadElement_dispex);
 762
 763     *elem = &ret->element;
 764     return S_OK;
 765 }