dlls/mshtml/omnavigator.c

   1 /*
   2  * Copyright 2008,2009 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
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 typedef struct HTMLPluginsCollection HTMLPluginsCollection;
  35 typedef struct HTMLMimeTypesCollection HTMLMimeTypesCollection;
  36
  37 typedef struct {
  38     DispatchEx dispex;
  39     IOmNavigator IOmNavigator_iface;
  40
  41     HTMLPluginsCollection *plugins;
  42     HTMLMimeTypesCollection *mime_types;
  43 } OmNavigator;
  44
  45 typedef struct {
  46     DispatchEx dispex;
  47     IHTMLDOMImplementation IHTMLDOMImplementation_iface;
  48     IHTMLDOMImplementation2 IHTMLDOMImplementation2_iface;
  49
  50     nsIDOMDOMImplementation *implementation;
  51     GeckoBrowser *browser;
  52 } HTMLDOMImplementation;
  53
  54 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation(IHTMLDOMImplementation *iface)
  55 {
  56     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation_iface);
  57 }
  58
  59 static HRESULT WINAPI HTMLDOMImplementation_QueryInterface(IHTMLDOMImplementation *iface, REFIID riid, void **ppv)
  60 {
  61     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  62
  63     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
  64
  65     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IHTMLDOMImplementation, riid)) {
  66         *ppv = &This->IHTMLDOMImplementation_iface;
  67     }else if(IsEqualGUID(&IID_IHTMLDOMImplementation2, riid)) {
  68         *ppv = &This->IHTMLDOMImplementation2_iface;
  69     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
  70         return *ppv ? S_OK : E_NOINTERFACE;
  71     }else {
  72         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
  73         *ppv = NULL;
  74         return E_NOINTERFACE;
  75     }
  76
  77     IUnknown_AddRef((IUnknown*)*ppv);
  78     return S_OK;
  79 }
  80
  81 static ULONG WINAPI HTMLDOMImplementation_AddRef(IHTMLDOMImplementation *iface)
  82 {
  83     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  84     LONG ref = dispex_ref_incr(&This->dispex);
  85
  86     TRACE("(%p) ref=%ld\n", This, ref);
  87
  88     return ref;
  89 }
  90
  91 static ULONG WINAPI HTMLDOMImplementation_Release(IHTMLDOMImplementation *iface)
  92 {
  93     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  94     LONG ref = dispex_ref_decr(&This->dispex);
  95
  96     TRACE("(%p) ref=%ld\n", This, ref);
  97
  98     return ref;
  99 }
 100
 101 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfoCount(IHTMLDOMImplementation *iface, UINT *pctinfo)
 102 {
 103     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 104
 105     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 106 }
 107
 108 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfo(IHTMLDOMImplementation *iface, UINT iTInfo,
 109         LCID lcid, ITypeInfo **ppTInfo)
 110 {
 111     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 112
 113     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 114 }
 115
 116 static HRESULT WINAPI HTMLDOMImplementation_GetIDsOfNames(IHTMLDOMImplementation *iface, REFIID riid,
 117         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 118 {
 119     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 120
 121     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 122             cNames, lcid, rgDispId);
 123 }
 124
 125 static HRESULT WINAPI HTMLDOMImplementation_Invoke(IHTMLDOMImplementation *iface, DISPID dispIdMember,
 126         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 127         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 128 {
 129     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 130
 131     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 132             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 133 }
 134
 135 static HRESULT WINAPI HTMLDOMImplementation_hasFeature(IHTMLDOMImplementation *iface, BSTR feature,
 136         VARIANT version, VARIANT_BOOL *pfHasFeature)
 137 {
 138     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 139
 140     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 141
 142     *pfHasFeature = VARIANT_FALSE;
 143     return S_OK;
 144 }
 145
 146 static const IHTMLDOMImplementationVtbl HTMLDOMImplementationVtbl = {
 147     HTMLDOMImplementation_QueryInterface,
 148     HTMLDOMImplementation_AddRef,
 149     HTMLDOMImplementation_Release,
 150     HTMLDOMImplementation_GetTypeInfoCount,
 151     HTMLDOMImplementation_GetTypeInfo,
 152     HTMLDOMImplementation_GetIDsOfNames,
 153     HTMLDOMImplementation_Invoke,
 154     HTMLDOMImplementation_hasFeature
 155 };
 156
 157 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation2(IHTMLDOMImplementation2 *iface)
 158 {
 159     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation2_iface);
 160 }
 161
 162 static HRESULT WINAPI HTMLDOMImplementation2_QueryInterface(IHTMLDOMImplementation2 *iface, REFIID riid, void **ppv)
 163 {
 164     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 165     return IHTMLDOMImplementation_QueryInterface(&This->IHTMLDOMImplementation_iface, riid, ppv);
 166 }
 167
 168 static ULONG WINAPI HTMLDOMImplementation2_AddRef(IHTMLDOMImplementation2 *iface)
 169 {
 170     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 171     return IHTMLDOMImplementation_AddRef(&This->IHTMLDOMImplementation_iface);
 172 }
 173
 174 static ULONG WINAPI HTMLDOMImplementation2_Release(IHTMLDOMImplementation2 *iface)
 175 {
 176     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 177     return IHTMLDOMImplementation_Release(&This->IHTMLDOMImplementation_iface);
 178 }
 179
 180 static HRESULT WINAPI HTMLDOMImplementation2_GetTypeInfoCount(IHTMLDOMImplementation2 *iface, UINT *pctinfo)
 181 {
 182     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 183     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 184 }
 185
 186 static HRESULT WINAPI HTMLDOMImplementation2_GetTypeInfo(IHTMLDOMImplementation2 *iface, UINT iTInfo,
 187         LCID lcid, ITypeInfo **ppTInfo)
 188 {
 189     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 190     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 191 }
 192
 193 static HRESULT WINAPI HTMLDOMImplementation2_GetIDsOfNames(IHTMLDOMImplementation2 *iface, REFIID riid,
 194         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 195 {
 196     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 197     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 198             cNames, lcid, rgDispId);
 199 }
 200
 201 static HRESULT WINAPI HTMLDOMImplementation2_Invoke(IHTMLDOMImplementation2 *iface, DISPID dispIdMember,
 202         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 203         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 204 {
 205     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 206     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 207             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 208 }
 209
 210 static HRESULT WINAPI HTMLDOMImplementation2_createDocumentType(IHTMLDOMImplementation2 *iface, BSTR name,
 211         VARIANT *public_id, VARIANT *system_id, IDOMDocumentType **new_type)
 212 {
 213     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 214     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(name), debugstr_variant(public_id),
 215           debugstr_variant(system_id), new_type);
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT WINAPI HTMLDOMImplementation2_createDocument(IHTMLDOMImplementation2 *iface, VARIANT *ns,
 220         VARIANT *tag_name, IDOMDocumentType *document_type, IHTMLDocument7 **new_document)
 221 {
 222     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 223     FIXME("(%p)->(%s %s %p %p)\n", This, debugstr_variant(ns), debugstr_variant(tag_name),
 224           document_type, new_document);
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI HTMLDOMImplementation2_createHTMLDocument(IHTMLDOMImplementation2 *iface, BSTR title,
 229         IHTMLDocument7 **new_document)
 230 {
 231     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 232     HTMLDocumentNode *new_document_node;
 233     nsIDOMDocument *doc;
 234     nsAString title_str;
 235     nsresult nsres;
 236     HRESULT hres;
 237
 238     FIXME("(%p)->(%s %p)\n", This, debugstr_w(title), new_document);
 239
 240     if(!This->browser)
 241         return E_UNEXPECTED;
 242
 243     nsAString_InitDepend(&title_str, title);
 244     nsres = nsIDOMDOMImplementation_CreateHTMLDocument(This->implementation, &title_str, &doc);
 245     nsAString_Finish(&title_str);
 246     if(NS_FAILED(nsres)) {
 247         ERR("CreateHTMLDocument failed: %08lx\n", nsres);
 248         return E_FAIL;
 249     }
 250
 251     hres = create_document_node(doc, This->browser, NULL, dispex_compat_mode(&This->dispex), &new_document_node);
 252     nsIDOMDocument_Release(doc);
 253     if(FAILED(hres))
 254         return hres;
 255
 256     *new_document = &new_document_node->IHTMLDocument7_iface;
 257     return S_OK;
 258 }
 259
 260 static HRESULT WINAPI HTMLDOMImplementation2_hasFeature(IHTMLDOMImplementation2 *iface, BSTR feature,
 261         VARIANT version, VARIANT_BOOL *pfHasFeature)
 262 {
 263     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 264
 265     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 266
 267     *pfHasFeature = VARIANT_FALSE;
 268     return S_OK;
 269 }
 270
 271 static const IHTMLDOMImplementation2Vtbl HTMLDOMImplementation2Vtbl = {
 272     HTMLDOMImplementation2_QueryInterface,
 273     HTMLDOMImplementation2_AddRef,
 274     HTMLDOMImplementation2_Release,
 275     HTMLDOMImplementation2_GetTypeInfoCount,
 276     HTMLDOMImplementation2_GetTypeInfo,
 277     HTMLDOMImplementation2_GetIDsOfNames,
 278     HTMLDOMImplementation2_Invoke,
 279     HTMLDOMImplementation2_createDocumentType,
 280     HTMLDOMImplementation2_createDocument,
 281     HTMLDOMImplementation2_createHTMLDocument,
 282     HTMLDOMImplementation2_hasFeature
 283 };
 284
 285 static inline HTMLDOMImplementation *HTMLDOMImplementation_from_DispatchEx(DispatchEx *iface)
 286 {
 287     return CONTAINING_RECORD(iface, HTMLDOMImplementation, dispex);
 288 }
 289
 290 static void HTMLDOMImplementation_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
 291 {
 292     HTMLDOMImplementation *This = HTMLDOMImplementation_from_DispatchEx(dispex);
 293     if(This->implementation)
 294         note_cc_edge((nsISupports*)This->implementation, "implementation", cb);
 295 }
 296
 297 static void HTMLDOMImplementation_unlink(DispatchEx *dispex)
 298 {
 299     HTMLDOMImplementation *This = HTMLDOMImplementation_from_DispatchEx(dispex);
 300     unlink_ref(&This->implementation);
 301 }
 302
 303 static void HTMLDOMImplementation_destructor(DispatchEx *dispex)
 304 {
 305     HTMLDOMImplementation *This = HTMLDOMImplementation_from_DispatchEx(dispex);
 306     assert(!This->browser);
 307     free(This);
 308 }
 309
 310 static const dispex_static_data_vtbl_t HTMLDOMImplementation_dispex_vtbl = {
 311     .destructor       = HTMLDOMImplementation_destructor,
 312     .traverse         = HTMLDOMImplementation_traverse,
 313     .unlink           = HTMLDOMImplementation_unlink
 314 };
 315
 316 static void HTMLDOMImplementation_init_dispex_info(dispex_data_t *info, compat_mode_t compat_mode)
 317 {
 318     if(compat_mode >= COMPAT_MODE_IE9)
 319         dispex_info_add_interface(info, IHTMLDOMImplementation2_tid, NULL);
 320 }
 321
 322 static const tid_t HTMLDOMImplementation_iface_tids[] = {
 323     IHTMLDOMImplementation_tid,
 324     0
 325 };
 326 static dispex_static_data_t HTMLDOMImplementation_dispex = {
 327     "DOMImplementation",
 328     &HTMLDOMImplementation_dispex_vtbl,
 329     DispHTMLDOMImplementation_tid,
 330     HTMLDOMImplementation_iface_tids,
 331     HTMLDOMImplementation_init_dispex_info
 332 };
 333
 334 HRESULT create_dom_implementation(HTMLDocumentNode *doc_node, IHTMLDOMImplementation **ret)
 335 {
 336     HTMLDOMImplementation *dom_implementation;
 337     nsresult nsres;
 338
 339     if(!doc_node->browser)
 340         return E_UNEXPECTED;
 341
 342     dom_implementation = calloc(1, sizeof(*dom_implementation));
 343     if(!dom_implementation)
 344         return E_OUTOFMEMORY;
 345
 346     dom_implementation->IHTMLDOMImplementation_iface.lpVtbl = &HTMLDOMImplementationVtbl;
 347     dom_implementation->IHTMLDOMImplementation2_iface.lpVtbl = &HTMLDOMImplementation2Vtbl;
 348     dom_implementation->browser = doc_node->browser;
 349
 350     init_dispatch(&dom_implementation->dispex, (IUnknown*)&dom_implementation->IHTMLDOMImplementation_iface,
 351                   &HTMLDOMImplementation_dispex, doc_node->document_mode);
 352
 353     nsres = nsIDOMDocument_GetImplementation(doc_node->dom_document, &dom_implementation->implementation);
 354     if(NS_FAILED(nsres)) {
 355         ERR("GetDOMImplementation failed: %08lx\n", nsres);
 356         IHTMLDOMImplementation_Release(&dom_implementation->IHTMLDOMImplementation_iface);
 357         return E_FAIL;
 358     }
 359
 360     *ret = &dom_implementation->IHTMLDOMImplementation_iface;
 361     return S_OK;
 362 }
 363
 364 void detach_dom_implementation(IHTMLDOMImplementation *iface)
 365 {
 366     HTMLDOMImplementation *dom_implementation = impl_from_IHTMLDOMImplementation(iface);
 367     dom_implementation->browser = NULL;
 368 }
 369
 370 typedef struct {
 371     DispatchEx dispex;
 372     IHTMLScreen IHTMLScreen_iface;
 373 } HTMLScreen;
 374
 375 static inline HTMLScreen *impl_from_IHTMLScreen(IHTMLScreen *iface)
 376 {
 377     return CONTAINING_RECORD(iface, HTMLScreen, IHTMLScreen_iface);
 378 }
 379
 380 static HRESULT WINAPI HTMLScreen_QueryInterface(IHTMLScreen *iface, REFIID riid, void **ppv)
 381 {
 382     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 383
 384     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 385
 386     if(IsEqualGUID(&IID_IUnknown, riid)) {
 387         *ppv = &This->IHTMLScreen_iface;
 388     }else if(IsEqualGUID(&IID_IHTMLScreen, riid)) {
 389         *ppv = &This->IHTMLScreen_iface;
 390     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 391         return *ppv ? S_OK : E_NOINTERFACE;
 392     }else {
 393         *ppv = NULL;
 394         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 395         return E_NOINTERFACE;
 396     }
 397
 398     IUnknown_AddRef((IUnknown*)*ppv);
 399     return S_OK;
 400 }
 401
 402 static ULONG WINAPI HTMLScreen_AddRef(IHTMLScreen *iface)
 403 {
 404     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 405     LONG ref = dispex_ref_incr(&This->dispex);
 406
 407     TRACE("(%p) ref=%ld\n", This, ref);
 408
 409     return ref;
 410 }
 411
 412 static ULONG WINAPI HTMLScreen_Release(IHTMLScreen *iface)
 413 {
 414     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 415     LONG ref = dispex_ref_decr(&This->dispex);
 416
 417     TRACE("(%p) ref=%ld\n", This, ref);
 418
 419     return ref;
 420 }
 421
 422 static HRESULT WINAPI HTMLScreen_GetTypeInfoCount(IHTMLScreen *iface, UINT *pctinfo)
 423 {
 424     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 425     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 426 }
 427
 428 static HRESULT WINAPI HTMLScreen_GetTypeInfo(IHTMLScreen *iface, UINT iTInfo,
 429         LCID lcid, ITypeInfo **ppTInfo)
 430 {
 431     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 432     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 433 }
 434
 435 static HRESULT WINAPI HTMLScreen_GetIDsOfNames(IHTMLScreen *iface, REFIID riid,
 436         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 437 {
 438     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 439     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 440             lcid, rgDispId);
 441 }
 442
 443 static HRESULT WINAPI HTMLScreen_Invoke(IHTMLScreen *iface, DISPID dispIdMember,
 444         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 445         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 446 {
 447     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 448     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 449             pDispParams, pVarResult, pExcepInfo, puArgErr);
 450 }
 451
 452 static HRESULT WINAPI HTMLScreen_get_colorDepth(IHTMLScreen *iface, LONG *p)
 453 {
 454     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 455     HDC hdc = GetDC(0);
 456
 457     TRACE("(%p)->(%p)\n", This, p);
 458
 459     *p = GetDeviceCaps(hdc, BITSPIXEL);
 460     ReleaseDC(0, hdc);
 461     return S_OK;
 462 }
 463
 464 static HRESULT WINAPI HTMLScreen_put_bufferDepth(IHTMLScreen *iface, LONG v)
 465 {
 466     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 467     FIXME("(%p)->(%ld)\n", This, v);
 468     return E_NOTIMPL;
 469 }
 470
 471 static HRESULT WINAPI HTMLScreen_get_bufferDepth(IHTMLScreen *iface, LONG *p)
 472 {
 473     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 474     FIXME("(%p)->(%p)\n", This, p);
 475     return E_NOTIMPL;
 476 }
 477
 478 static HRESULT WINAPI HTMLScreen_get_width(IHTMLScreen *iface, LONG *p)
 479 {
 480     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 481
 482     TRACE("(%p)->(%p)\n", This, p);
 483
 484     *p = GetSystemMetrics(SM_CXSCREEN);
 485     return S_OK;
 486 }
 487
 488 static HRESULT WINAPI HTMLScreen_get_height(IHTMLScreen *iface, LONG *p)
 489 {
 490     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 491
 492     TRACE("(%p)->(%p)\n", This, p);
 493
 494     *p = GetSystemMetrics(SM_CYSCREEN);
 495     return S_OK;
 496 }
 497
 498 static HRESULT WINAPI HTMLScreen_put_updateInterval(IHTMLScreen *iface, LONG v)
 499 {
 500     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 501     FIXME("(%p)->(%ld)\n", This, v);
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI HTMLScreen_get_updateInterval(IHTMLScreen *iface, LONG *p)
 506 {
 507     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 508     FIXME("(%p)->(%p)\n", This, p);
 509     return E_NOTIMPL;
 510 }
 511
 512 static HRESULT WINAPI HTMLScreen_get_availHeight(IHTMLScreen *iface, LONG *p)
 513 {
 514     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 515     RECT work_area;
 516
 517     TRACE("(%p)->(%p)\n", This, p);
 518
 519     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 520         return E_FAIL;
 521
 522     *p = work_area.bottom-work_area.top;
 523     return S_OK;
 524 }
 525
 526 static HRESULT WINAPI HTMLScreen_get_availWidth(IHTMLScreen *iface, LONG *p)
 527 {
 528     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 529     RECT work_area;
 530
 531     TRACE("(%p)->(%p)\n", This, p);
 532
 533     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 534         return E_FAIL;
 535
 536     *p = work_area.right-work_area.left;
 537     return S_OK;
 538 }
 539
 540 static HRESULT WINAPI HTMLScreen_get_fontSmoothingEnabled(IHTMLScreen *iface, VARIANT_BOOL *p)
 541 {
 542     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 543     FIXME("(%p)->(%p)\n", This, p);
 544     return E_NOTIMPL;
 545 }
 546
 547 static const IHTMLScreenVtbl HTMLSreenVtbl = {
 548     HTMLScreen_QueryInterface,
 549     HTMLScreen_AddRef,
 550     HTMLScreen_Release,
 551     HTMLScreen_GetTypeInfoCount,
 552     HTMLScreen_GetTypeInfo,
 553     HTMLScreen_GetIDsOfNames,
 554     HTMLScreen_Invoke,
 555     HTMLScreen_get_colorDepth,
 556     HTMLScreen_put_bufferDepth,
 557     HTMLScreen_get_bufferDepth,
 558     HTMLScreen_get_width,
 559     HTMLScreen_get_height,
 560     HTMLScreen_put_updateInterval,
 561     HTMLScreen_get_updateInterval,
 562     HTMLScreen_get_availHeight,
 563     HTMLScreen_get_availWidth,
 564     HTMLScreen_get_fontSmoothingEnabled
 565 };
 566
 567 static inline HTMLScreen *HTMLScreen_from_DispatchEx(DispatchEx *iface)
 568 {
 569     return CONTAINING_RECORD(iface, HTMLScreen, dispex);
 570 }
 571
 572 static void HTMLScreen_destructor(DispatchEx *dispex)
 573 {
 574     HTMLScreen *This = HTMLScreen_from_DispatchEx(dispex);
 575     free(This);
 576 }
 577
 578 static const dispex_static_data_vtbl_t HTMLScreen_dispex_vtbl = {
 579     .destructor       = HTMLScreen_destructor,
 580 };
 581
 582 static const tid_t HTMLScreen_iface_tids[] = {
 583     IHTMLScreen_tid,
 584     0
 585 };
 586 static dispex_static_data_t HTMLScreen_dispex = {
 587     "Screen",
 588     &HTMLScreen_dispex_vtbl,
 589     DispHTMLScreen_tid,
 590     HTMLScreen_iface_tids
 591 };
 592
 593 HRESULT create_html_screen(compat_mode_t compat_mode, IHTMLScreen **ret)
 594 {
 595     HTMLScreen *screen;
 596
 597     screen = calloc(1, sizeof(HTMLScreen));
 598     if(!screen)
 599         return E_OUTOFMEMORY;
 600
 601     screen->IHTMLScreen_iface.lpVtbl = &HTMLSreenVtbl;
 602
 603     init_dispatch(&screen->dispex, (IUnknown*)&screen->IHTMLScreen_iface, &HTMLScreen_dispex, compat_mode);
 604
 605     *ret = &screen->IHTMLScreen_iface;
 606     return S_OK;
 607 }
 608
 609 static inline OmHistory *impl_from_IOmHistory(IOmHistory *iface)
 610 {
 611     return CONTAINING_RECORD(iface, OmHistory, IOmHistory_iface);
 612 }
 613
 614 static HRESULT WINAPI OmHistory_QueryInterface(IOmHistory *iface, REFIID riid, void **ppv)
 615 {
 616     OmHistory *This = impl_from_IOmHistory(iface);
 617
 618     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 619
 620     if(IsEqualGUID(&IID_IUnknown, riid)) {
 621         *ppv = &This->IOmHistory_iface;
 622     }else if(IsEqualGUID(&IID_IOmHistory, riid)) {
 623         *ppv = &This->IOmHistory_iface;
 624     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 625         return *ppv ? S_OK : E_NOINTERFACE;
 626     }else {
 627         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 628         *ppv = NULL;
 629         return E_NOINTERFACE;
 630     }
 631
 632     IUnknown_AddRef((IUnknown*)*ppv);
 633     return S_OK;
 634 }
 635
 636 static ULONG WINAPI OmHistory_AddRef(IOmHistory *iface)
 637 {
 638     OmHistory *This = impl_from_IOmHistory(iface);
 639     LONG ref = dispex_ref_incr(&This->dispex);
 640
 641     TRACE("(%p) ref=%ld\n", This, ref);
 642
 643     return ref;
 644 }
 645
 646 static ULONG WINAPI OmHistory_Release(IOmHistory *iface)
 647 {
 648     OmHistory *This = impl_from_IOmHistory(iface);
 649     LONG ref = dispex_ref_decr(&This->dispex);
 650
 651     TRACE("(%p) ref=%ld\n", This, ref);
 652
 653     return ref;
 654 }
 655
 656 static HRESULT WINAPI OmHistory_GetTypeInfoCount(IOmHistory *iface, UINT *pctinfo)
 657 {
 658     OmHistory *This = impl_from_IOmHistory(iface);
 659     FIXME("(%p)->(%p)\n", This, pctinfo);
 660     return E_NOTIMPL;
 661 }
 662
 663 static HRESULT WINAPI OmHistory_GetTypeInfo(IOmHistory *iface, UINT iTInfo,
 664         LCID lcid, ITypeInfo **ppTInfo)
 665 {
 666     OmHistory *This = impl_from_IOmHistory(iface);
 667
 668     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 669 }
 670
 671 static HRESULT WINAPI OmHistory_GetIDsOfNames(IOmHistory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 672         LCID lcid, DISPID *rgDispId)
 673 {
 674     OmHistory *This = impl_from_IOmHistory(iface);
 675
 676     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 677             lcid, rgDispId);
 678 }
 679
 680 static HRESULT WINAPI OmHistory_Invoke(IOmHistory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 681         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 682 {
 683     OmHistory *This = impl_from_IOmHistory(iface);
 684
 685     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 686             pDispParams, pVarResult, pExcepInfo, puArgErr);
 687 }
 688
 689 static HRESULT WINAPI OmHistory_get_length(IOmHistory *iface, short *p)
 690 {
 691     OmHistory *This = impl_from_IOmHistory(iface);
 692     GeckoBrowser *browser = NULL;
 693
 694     TRACE("(%p)->(%p)\n", This, p);
 695
 696     if(This->window && This->window->base.outer_window)
 697         browser = This->window->base.outer_window->browser;
 698
 699     *p = browser && browser->doc->travel_log
 700         ? ITravelLog_CountEntries(browser->doc->travel_log, browser->doc->browser_service)
 701         : 0;
 702     return S_OK;
 703 }
 704
 705 static HRESULT WINAPI OmHistory_back(IOmHistory *iface, VARIANT *pvargdistance)
 706 {
 707     OmHistory *This = impl_from_IOmHistory(iface);
 708     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 709     return E_NOTIMPL;
 710 }
 711
 712 static HRESULT WINAPI OmHistory_forward(IOmHistory *iface, VARIANT *pvargdistance)
 713 {
 714     OmHistory *This = impl_from_IOmHistory(iface);
 715     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI OmHistory_go(IOmHistory *iface, VARIANT *pvargdistance)
 720 {
 721     OmHistory *This = impl_from_IOmHistory(iface);
 722     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 723     return E_NOTIMPL;
 724 }
 725
 726 static const IOmHistoryVtbl OmHistoryVtbl = {
 727     OmHistory_QueryInterface,
 728     OmHistory_AddRef,
 729     OmHistory_Release,
 730     OmHistory_GetTypeInfoCount,
 731     OmHistory_GetTypeInfo,
 732     OmHistory_GetIDsOfNames,
 733     OmHistory_Invoke,
 734     OmHistory_get_length,
 735     OmHistory_back,
 736     OmHistory_forward,
 737     OmHistory_go
 738 };
 739
 740 static inline OmHistory *OmHistory_from_DispatchEx(DispatchEx *iface)
 741 {
 742     return CONTAINING_RECORD(iface, OmHistory, dispex);
 743 }
 744
 745 static void OmHistory_destructor(DispatchEx *dispex)
 746 {
 747     OmHistory *This = OmHistory_from_DispatchEx(dispex);
 748     free(This);
 749 }
 750
 751 static const dispex_static_data_vtbl_t OmHistory_dispex_vtbl = {
 752     .destructor       = OmHistory_destructor,
 753 };
 754
 755 static const tid_t OmHistory_iface_tids[] = {
 756     IOmHistory_tid,
 757     0
 758 };
 759 static dispex_static_data_t OmHistory_dispex = {
 760     "History",
 761     &OmHistory_dispex_vtbl,
 762     DispHTMLHistory_tid,
 763     OmHistory_iface_tids
 764 };
 765
 766
 767 HRESULT create_history(HTMLInnerWindow *window, OmHistory **ret)
 768 {
 769     OmHistory *history;
 770
 771     history = calloc(1, sizeof(*history));
 772     if(!history)
 773         return E_OUTOFMEMORY;
 774
 775     init_dispatch(&history->dispex, (IUnknown*)&history->IOmHistory_iface, &OmHistory_dispex,
 776                   dispex_compat_mode(&window->event_target.dispex));
 777     history->IOmHistory_iface.lpVtbl = &OmHistoryVtbl;
 778
 779     history->window = window;
 780
 781     *ret = history;
 782     return S_OK;
 783 }
 784
 785 struct HTMLPluginsCollection {
 786     DispatchEx dispex;
 787     IHTMLPluginsCollection IHTMLPluginsCollection_iface;
 788
 789     OmNavigator *navigator;
 790 };
 791
 792 static inline HTMLPluginsCollection *impl_from_IHTMLPluginsCollection(IHTMLPluginsCollection *iface)
 793 {
 794     return CONTAINING_RECORD(iface, HTMLPluginsCollection, IHTMLPluginsCollection_iface);
 795 }
 796
 797 static HRESULT WINAPI HTMLPluginsCollection_QueryInterface(IHTMLPluginsCollection *iface, REFIID riid, void **ppv)
 798 {
 799     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 800
 801     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 802
 803     if(IsEqualGUID(&IID_IUnknown, riid)) {
 804         *ppv = &This->IHTMLPluginsCollection_iface;
 805     }else if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid)) {
 806         *ppv = &This->IHTMLPluginsCollection_iface;
 807     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 808         return *ppv ? S_OK : E_NOINTERFACE;
 809     }else {
 810         *ppv = NULL;
 811         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 812         return E_NOINTERFACE;
 813     }
 814
 815     IUnknown_AddRef((IUnknown*)*ppv);
 816     return S_OK;
 817 }
 818
 819 static ULONG WINAPI HTMLPluginsCollection_AddRef(IHTMLPluginsCollection *iface)
 820 {
 821     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 822     LONG ref = dispex_ref_incr(&This->dispex);
 823
 824     TRACE("(%p) ref=%ld\n", This, ref);
 825
 826     return ref;
 827 }
 828
 829 static ULONG WINAPI HTMLPluginsCollection_Release(IHTMLPluginsCollection *iface)
 830 {
 831     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 832     LONG ref = dispex_ref_decr(&This->dispex);
 833
 834     TRACE("(%p) ref=%ld\n", This, ref);
 835
 836     return ref;
 837 }
 838
 839 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfoCount(IHTMLPluginsCollection *iface, UINT *pctinfo)
 840 {
 841     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 842     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 843 }
 844
 845 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfo(IHTMLPluginsCollection *iface, UINT iTInfo,
 846                                               LCID lcid, ITypeInfo **ppTInfo)
 847 {
 848     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 849     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 850 }
 851
 852 static HRESULT WINAPI HTMLPluginsCollection_GetIDsOfNames(IHTMLPluginsCollection *iface, REFIID riid,
 853         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 854 {
 855     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 856     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 857             lcid, rgDispId);
 858 }
 859
 860 static HRESULT WINAPI HTMLPluginsCollection_Invoke(IHTMLPluginsCollection *iface, DISPID dispIdMember,
 861         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 862         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 863 {
 864     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 865     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 866             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 867 }
 868
 869 static HRESULT WINAPI HTMLPluginsCollection_get_length(IHTMLPluginsCollection *iface, LONG *p)
 870 {
 871     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 872
 873     TRACE("(%p)->(%p)\n", This, p);
 874
 875     /* IE always returns 0 here */
 876     *p = 0;
 877     return S_OK;
 878 }
 879
 880 static HRESULT WINAPI HTMLPluginsCollection_refresh(IHTMLPluginsCollection *iface, VARIANT_BOOL reload)
 881 {
 882     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 883
 884     TRACE("(%p)->(%x)\n", This, reload);
 885
 886     /* Nothing to do here. */
 887     return S_OK;
 888 }
 889
 890 static const IHTMLPluginsCollectionVtbl HTMLPluginsCollectionVtbl = {
 891     HTMLPluginsCollection_QueryInterface,
 892     HTMLPluginsCollection_AddRef,
 893     HTMLPluginsCollection_Release,
 894     HTMLPluginsCollection_GetTypeInfoCount,
 895     HTMLPluginsCollection_GetTypeInfo,
 896     HTMLPluginsCollection_GetIDsOfNames,
 897     HTMLPluginsCollection_Invoke,
 898     HTMLPluginsCollection_get_length,
 899     HTMLPluginsCollection_refresh
 900 };
 901
 902 static inline HTMLPluginsCollection *HTMLPluginsCollection_from_DispatchEx(DispatchEx *iface)
 903 {
 904     return CONTAINING_RECORD(iface, HTMLPluginsCollection, dispex);
 905 }
 906
 907 static void HTMLPluginsCollection_unlink(DispatchEx *dispex)
 908 {
 909     HTMLPluginsCollection *This = HTMLPluginsCollection_from_DispatchEx(dispex);
 910     if(This->navigator) {
 911         This->navigator->plugins = NULL;
 912         This->navigator = NULL;
 913     }
 914 }
 915
 916 static void HTMLPluginsCollection_destructor(DispatchEx *dispex)
 917 {
 918     HTMLPluginsCollection *This = HTMLPluginsCollection_from_DispatchEx(dispex);
 919     free(This);
 920 }
 921
 922 static const dispex_static_data_vtbl_t HTMLPluginsCollection_dispex_vtbl = {
 923     .destructor       = HTMLPluginsCollection_destructor,
 924     .unlink           = HTMLPluginsCollection_unlink
 925 };
 926
 927 static const tid_t HTMLPluginsCollection_iface_tids[] = {
 928     IHTMLPluginsCollection_tid,
 929     0
 930 };
 931 static dispex_static_data_t HTMLPluginsCollection_dispex = {
 932     "PluginArray",
 933     &HTMLPluginsCollection_dispex_vtbl,
 934     DispCPlugins_tid,
 935     HTMLPluginsCollection_iface_tids
 936 };
 937
 938 static HRESULT create_plugins_collection(OmNavigator *navigator, HTMLPluginsCollection **ret)
 939 {
 940     HTMLPluginsCollection *col;
 941
 942     col = calloc(1, sizeof(*col));
 943     if(!col)
 944         return E_OUTOFMEMORY;
 945
 946     col->IHTMLPluginsCollection_iface.lpVtbl = &HTMLPluginsCollectionVtbl;
 947     col->navigator = navigator;
 948
 949     init_dispatch(&col->dispex, (IUnknown*)&col->IHTMLPluginsCollection_iface,
 950                   &HTMLPluginsCollection_dispex, dispex_compat_mode(&navigator->dispex));
 951
 952     *ret = col;
 953     return S_OK;
 954 }
 955
 956 struct HTMLMimeTypesCollection {
 957     DispatchEx dispex;
 958     IHTMLMimeTypesCollection IHTMLMimeTypesCollection_iface;
 959
 960     OmNavigator *navigator;
 961 };
 962
 963 static inline HTMLMimeTypesCollection *impl_from_IHTMLMimeTypesCollection(IHTMLMimeTypesCollection *iface)
 964 {
 965     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, IHTMLMimeTypesCollection_iface);
 966 }
 967
 968 static HRESULT WINAPI HTMLMimeTypesCollection_QueryInterface(IHTMLMimeTypesCollection *iface, REFIID riid, void **ppv)
 969 {
 970     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 971
 972     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 973
 974     if(IsEqualGUID(&IID_IUnknown, riid)) {
 975         *ppv = &This->IHTMLMimeTypesCollection_iface;
 976     }else if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid)) {
 977         *ppv = &This->IHTMLMimeTypesCollection_iface;
 978     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 979         return *ppv ? S_OK : E_NOINTERFACE;
 980     }else {
 981         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 982         *ppv = NULL;
 983         return E_NOINTERFACE;
 984     }
 985
 986     IUnknown_AddRef((IUnknown*)*ppv);
 987     return S_OK;
 988 }
 989
 990 static ULONG WINAPI HTMLMimeTypesCollection_AddRef(IHTMLMimeTypesCollection *iface)
 991 {
 992     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 993     LONG ref = dispex_ref_incr(&This->dispex);
 994
 995     TRACE("(%p) ref=%ld\n", This, ref);
 996
 997     return ref;
 998 }
 999
1000 static ULONG WINAPI HTMLMimeTypesCollection_Release(IHTMLMimeTypesCollection *iface)
1001 {
1002     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
1003     LONG ref = dispex_ref_decr(&This->dispex);
1004
1005     TRACE("(%p) ref=%ld\n", This, ref);
1006
1007     return ref;
1008 }
1009
1010 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfoCount(IHTMLMimeTypesCollection *iface, UINT *pctinfo)
1011 {
1012     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
1013     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1014 }
1015
1016 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfo(IHTMLMimeTypesCollection *iface, UINT iTInfo,
1017                                               LCID lcid, ITypeInfo **ppTInfo)
1018 {
1019     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
1020     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1021 }
1022
1023 static HRESULT WINAPI HTMLMimeTypesCollection_GetIDsOfNames(IHTMLMimeTypesCollection *iface, REFIID riid,
1024         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1025 {
1026     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
1027     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1028             lcid, rgDispId);
1029 }
1030
1031 static HRESULT WINAPI HTMLMimeTypesCollection_Invoke(IHTMLMimeTypesCollection *iface, DISPID dispIdMember,
1032         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1033         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1034 {
1035     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
1036     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1037             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1038 }
1039
1040 static HRESULT WINAPI HTMLMimeTypesCollection_get_length(IHTMLMimeTypesCollection *iface, LONG *p)
1041 {
1042     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
1043
1044     TRACE("(%p)->(%p)\n", This, p);
1045
1046     /* This is just a stub for compatibility with other browser in IE */
1047     *p = 0;
1048     return S_OK;
1049 }
1050
1051 static const IHTMLMimeTypesCollectionVtbl HTMLMimeTypesCollectionVtbl = {
1052     HTMLMimeTypesCollection_QueryInterface,
1053     HTMLMimeTypesCollection_AddRef,
1054     HTMLMimeTypesCollection_Release,
1055     HTMLMimeTypesCollection_GetTypeInfoCount,
1056     HTMLMimeTypesCollection_GetTypeInfo,
1057     HTMLMimeTypesCollection_GetIDsOfNames,
1058     HTMLMimeTypesCollection_Invoke,
1059     HTMLMimeTypesCollection_get_length
1060 };
1061
1062 static inline HTMLMimeTypesCollection *HTMLMimeTypesCollection_from_DispatchEx(DispatchEx *iface)
1063 {
1064     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, dispex);
1065 }
1066
1067 static void HTMLMimeTypesCollection_unlink(DispatchEx *dispex)
1068 {
1069     HTMLMimeTypesCollection *This = HTMLMimeTypesCollection_from_DispatchEx(dispex);
1070     if(This->navigator) {
1071         This->navigator->mime_types = NULL;
1072         This->navigator = NULL;
1073     }
1074 }
1075
1076 static void HTMLMimeTypesCollection_destructor(DispatchEx *dispex)
1077 {
1078     HTMLMimeTypesCollection *This = HTMLMimeTypesCollection_from_DispatchEx(dispex);
1079     free(This);
1080 }
1081
1082 static const dispex_static_data_vtbl_t HTMLMimeTypesCollection_dispex_vtbl = {
1083     .destructor       = HTMLMimeTypesCollection_destructor,
1084     .unlink           = HTMLMimeTypesCollection_unlink
1085 };
1086
1087 static const tid_t HTMLMimeTypesCollection_iface_tids[] = {
1088     IHTMLMimeTypesCollection_tid,
1089     0
1090 };
1091 static dispex_static_data_t HTMLMimeTypesCollection_dispex = {
1092     "MimeTypeArray",
1093     &HTMLMimeTypesCollection_dispex_vtbl,
1094     IHTMLMimeTypesCollection_tid,
1095     HTMLMimeTypesCollection_iface_tids
1096 };
1097
1098 static HRESULT create_mime_types_collection(OmNavigator *navigator, HTMLMimeTypesCollection **ret)
1099 {
1100     HTMLMimeTypesCollection *col;
1101
1102     col = calloc(1, sizeof(*col));
1103     if(!col)
1104         return E_OUTOFMEMORY;
1105
1106     col->IHTMLMimeTypesCollection_iface.lpVtbl = &HTMLMimeTypesCollectionVtbl;
1107     col->navigator = navigator;
1108
1109     init_dispatch(&col->dispex, (IUnknown*)&col->IHTMLMimeTypesCollection_iface,
1110                   &HTMLMimeTypesCollection_dispex, dispex_compat_mode(&navigator->dispex));
1111
1112     *ret = col;
1113     return S_OK;
1114 }
1115
1116 static inline OmNavigator *impl_from_IOmNavigator(IOmNavigator *iface)
1117 {
1118     return CONTAINING_RECORD(iface, OmNavigator, IOmNavigator_iface);
1119 }
1120
1121 static HRESULT WINAPI OmNavigator_QueryInterface(IOmNavigator *iface, REFIID riid, void **ppv)
1122 {
1123     OmNavigator *This = impl_from_IOmNavigator(iface);
1124
1125     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1126
1127     if(IsEqualGUID(&IID_IUnknown, riid)) {
1128         *ppv = &This->IOmNavigator_iface;
1129     }else if(IsEqualGUID(&IID_IOmNavigator, riid)) {
1130         *ppv = &This->IOmNavigator_iface;
1131     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1132         return *ppv ? S_OK : E_NOINTERFACE;
1133     }else {
1134         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1135         *ppv = NULL;
1136         return E_NOINTERFACE;
1137     }
1138
1139     IUnknown_AddRef((IUnknown*)*ppv);
1140     return S_OK;
1141 }
1142
1143 static ULONG WINAPI OmNavigator_AddRef(IOmNavigator *iface)
1144 {
1145     OmNavigator *This = impl_from_IOmNavigator(iface);
1146     LONG ref = dispex_ref_incr(&This->dispex);
1147
1148     TRACE("(%p) ref=%ld\n", This, ref);
1149
1150     return ref;
1151 }
1152
1153 static ULONG WINAPI OmNavigator_Release(IOmNavigator *iface)
1154 {
1155     OmNavigator *This = impl_from_IOmNavigator(iface);
1156     LONG ref = dispex_ref_decr(&This->dispex);
1157
1158     TRACE("(%p) ref=%ld\n", This, ref);
1159
1160     return ref;
1161 }
1162
1163 static HRESULT WINAPI OmNavigator_GetTypeInfoCount(IOmNavigator *iface, UINT *pctinfo)
1164 {
1165     OmNavigator *This = impl_from_IOmNavigator(iface);
1166     FIXME("(%p)->(%p)\n", This, pctinfo);
1167     return E_NOTIMPL;
1168 }
1169
1170 static HRESULT WINAPI OmNavigator_GetTypeInfo(IOmNavigator *iface, UINT iTInfo,
1171                                               LCID lcid, ITypeInfo **ppTInfo)
1172 {
1173     OmNavigator *This = impl_from_IOmNavigator(iface);
1174
1175     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1176 }
1177
1178 static HRESULT WINAPI OmNavigator_GetIDsOfNames(IOmNavigator *iface, REFIID riid,
1179                                                 LPOLESTR *rgszNames, UINT cNames,
1180                                                 LCID lcid, DISPID *rgDispId)
1181 {
1182     OmNavigator *This = impl_from_IOmNavigator(iface);
1183
1184     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1185             lcid, rgDispId);
1186 }
1187
1188 static HRESULT WINAPI OmNavigator_Invoke(IOmNavigator *iface, DISPID dispIdMember,
1189                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1190                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1191 {
1192     OmNavigator *This = impl_from_IOmNavigator(iface);
1193
1194     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1195             pDispParams, pVarResult, pExcepInfo, puArgErr);
1196 }
1197
1198 static HRESULT WINAPI OmNavigator_get_appCodeName(IOmNavigator *iface, BSTR *p)
1199 {
1200     OmNavigator *This = impl_from_IOmNavigator(iface);
1201
1202     TRACE("(%p)->(%p)\n", This, p);
1203
1204     *p = SysAllocString(L"Mozilla");
1205     return S_OK;
1206 }
1207
1208 static HRESULT WINAPI OmNavigator_get_appName(IOmNavigator *iface, BSTR *p)
1209 {
1210     OmNavigator *This = impl_from_IOmNavigator(iface);
1211
1212     TRACE("(%p)->(%p)\n", This, p);
1213
1214     *p = SysAllocString(dispex_compat_mode(&This->dispex) == COMPAT_MODE_IE11
1215                         ? L"Netscape" : L"Microsoft Internet Explorer");
1216     if(!*p)
1217         return E_OUTOFMEMORY;
1218
1219     return S_OK;
1220 }
1221
1222 /* undocumented, added in IE8 */
1223 extern HRESULT WINAPI MapBrowserEmulationModeToUserAgent(const void*,WCHAR**);
1224
1225 /* Retrieves allocated user agent via CoTaskMemAlloc */
1226 static HRESULT get_user_agent(OmNavigator *navigator, WCHAR **user_agent)
1227 {
1228     DWORD version = get_compat_mode_version(dispex_compat_mode(&navigator->dispex));
1229
1230     return MapBrowserEmulationModeToUserAgent(&version, user_agent);
1231 }
1232
1233 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
1234 {
1235     OmNavigator *This = impl_from_IOmNavigator(iface);
1236     WCHAR *user_agent;
1237     unsigned len;
1238     HRESULT hres;
1239     const unsigned skip_prefix = strlen("Mozilla/");
1240
1241     TRACE("(%p)->(%p)\n", This, p);
1242
1243     hres = get_user_agent(This, &user_agent);
1244     if(FAILED(hres))
1245         return hres;
1246     len = wcslen(user_agent);
1247
1248     if(len < skip_prefix) {
1249         CoTaskMemFree(user_agent);
1250         *p = NULL;
1251         return S_OK;
1252     }
1253
1254     *p = SysAllocStringLen(user_agent + skip_prefix, len - skip_prefix);
1255     CoTaskMemFree(user_agent);
1256     return *p ? S_OK : E_OUTOFMEMORY;
1257 }
1258
1259 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
1260 {
1261     OmNavigator *This = impl_from_IOmNavigator(iface);
1262     WCHAR *user_agent;
1263     HRESULT hres;
1264
1265     TRACE("(%p)->(%p)\n", This, p);
1266
1267     hres = get_user_agent(This, &user_agent);
1268     if(FAILED(hres))
1269         return hres;
1270
1271     *p = SysAllocString(user_agent);
1272     CoTaskMemFree(user_agent);
1273     return *p ? S_OK : E_OUTOFMEMORY;
1274 }
1275
1276 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1277 {
1278     OmNavigator *This = impl_from_IOmNavigator(iface);
1279
1280     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
1281
1282     *enabled = VARIANT_TRUE;
1283     return S_OK;
1284 }
1285
1286 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1287 {
1288     OmNavigator *This = impl_from_IOmNavigator(iface);
1289     FIXME("(%p)->(%p)\n", This, enabled);
1290     return E_NOTIMPL;
1291 }
1292
1293 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
1294 {
1295     OmNavigator *This = impl_from_IOmNavigator(iface);
1296
1297     TRACE("(%p)->(%p)\n", This, p);
1298
1299     if(!This->mime_types) {
1300         HRESULT hres;
1301
1302         hres = create_mime_types_collection(This, &This->mime_types);
1303         if(FAILED(hres))
1304             return hres;
1305     }else {
1306         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
1307     }
1308
1309     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
1310     return S_OK;
1311 }
1312
1313 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
1314 {
1315     OmNavigator *This = impl_from_IOmNavigator(iface);
1316
1317     TRACE("(%p)->(%p)\n", This, p);
1318
1319     if(!This->plugins) {
1320         HRESULT hres;
1321
1322         hres = create_plugins_collection(This, &This->plugins);
1323         if(FAILED(hres))
1324             return hres;
1325     }else {
1326         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
1327     }
1328
1329     *p = &This->plugins->IHTMLPluginsCollection_iface;
1330     return S_OK;
1331 }
1332
1333 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
1334 {
1335     OmNavigator *This = impl_from_IOmNavigator(iface);
1336
1337     WARN("(%p)->(%p) semi-stub\n", This, p);
1338
1339     *p = VARIANT_TRUE;
1340     return S_OK;
1341 }
1342
1343 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1344 {
1345     OmNavigator *This = impl_from_IOmNavigator(iface);
1346     FIXME("(%p)->(%p)\n", This, p);
1347     return E_NOTIMPL;
1348 }
1349
1350 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
1351 {
1352     OmNavigator *This = impl_from_IOmNavigator(iface);
1353
1354     TRACE("(%p)->(%p)\n", This, String);
1355
1356     return dispex_to_string(&This->dispex, String);
1357 }
1358
1359 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
1360 {
1361     OmNavigator *This = impl_from_IOmNavigator(iface);
1362
1363     TRACE("(%p)->(%p)\n", This, p);
1364
1365 #ifdef _WIN64
1366     *p = SysAllocString(L"x64");
1367 #else
1368     *p = SysAllocString(L"x86");
1369 #endif
1370     return *p ? S_OK : E_OUTOFMEMORY;
1371 }
1372
1373 static HRESULT get_language_string(LCID lcid, BSTR *p)
1374 {
1375     BSTR ret;
1376     int len;
1377
1378     len = LCIDToLocaleName(lcid, NULL, 0, 0);
1379     if(!len) {
1380         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
1381         return E_FAIL;
1382     }
1383
1384     ret = SysAllocStringLen(NULL, len-1);
1385     if(!ret)
1386         return E_OUTOFMEMORY;
1387
1388     len = LCIDToLocaleName(lcid, ret, len, 0);
1389     if(!len) {
1390         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
1391         SysFreeString(ret);
1392         return E_FAIL;
1393     }
1394
1395     *p = ret;
1396     return S_OK;
1397 }
1398
1399 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
1400 {
1401     OmNavigator *This = impl_from_IOmNavigator(iface);
1402
1403     TRACE("(%p)->(%p)\n", This, p);
1404
1405     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
1406 }
1407
1408 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
1409 {
1410     OmNavigator *This = impl_from_IOmNavigator(iface);
1411
1412     TRACE("(%p)->(%p)\n", This, p);
1413
1414     return get_language_string(GetUserDefaultUILanguage(), p);
1415 }
1416
1417 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
1418 {
1419     OmNavigator *This = impl_from_IOmNavigator(iface);
1420
1421     TRACE("(%p)->(%p)\n", This, p);
1422
1423     return get_language_string(LOCALE_USER_DEFAULT, p);
1424 }
1425
1426 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
1427 {
1428     OmNavigator *This = impl_from_IOmNavigator(iface);
1429
1430     TRACE("(%p)->(%p)\n", This, p);
1431
1432 #ifdef _WIN64
1433     *p = SysAllocString(L"Win64");
1434 #else
1435     *p = SysAllocString(L"Win32");
1436 #endif
1437     return S_OK;
1438 }
1439
1440 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1441 {
1442     OmNavigator *This = impl_from_IOmNavigator(iface);
1443
1444     TRACE("(%p)->(%p)\n", This, p);
1445
1446     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1447     *p = SysAllocString(L"0");
1448     return S_OK;
1449 }
1450
1451 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1452 {
1453     OmNavigator *This = impl_from_IOmNavigator(iface);
1454     FIXME("(%p)->(%p)\n", This, p);
1455     return E_NOTIMPL;
1456 }
1457
1458 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1459 {
1460     OmNavigator *This = impl_from_IOmNavigator(iface);
1461
1462     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1463
1464     *p = VARIANT_TRUE;
1465     return S_OK;
1466 }
1467
1468 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1469 {
1470     OmNavigator *This = impl_from_IOmNavigator(iface);
1471     FIXME("(%p)->(%p)\n", This, p);
1472     return E_NOTIMPL;
1473 }
1474
1475 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1476     OmNavigator_QueryInterface,
1477     OmNavigator_AddRef,
1478     OmNavigator_Release,
1479     OmNavigator_GetTypeInfoCount,
1480     OmNavigator_GetTypeInfo,
1481     OmNavigator_GetIDsOfNames,
1482     OmNavigator_Invoke,
1483     OmNavigator_get_appCodeName,
1484     OmNavigator_get_appName,
1485     OmNavigator_get_appVersion,
1486     OmNavigator_get_userAgent,
1487     OmNavigator_javaEnabled,
1488     OmNavigator_taintEnabled,
1489     OmNavigator_get_mimeTypes,
1490     OmNavigator_get_plugins,
1491     OmNavigator_get_cookieEnabled,
1492     OmNavigator_get_opsProfile,
1493     OmNavigator_toString,
1494     OmNavigator_get_cpuClass,
1495     OmNavigator_get_systemLanguage,
1496     OmNavigator_get_browserLanguage,
1497     OmNavigator_get_userLanguage,
1498     OmNavigator_get_platform,
1499     OmNavigator_get_appMinorVersion,
1500     OmNavigator_get_connectionSpeed,
1501     OmNavigator_get_onLine,
1502     OmNavigator_get_userProfile
1503 };
1504
1505 static inline OmNavigator *OmNavigator_from_DispatchEx(DispatchEx *iface)
1506 {
1507     return CONTAINING_RECORD(iface, OmNavigator, dispex);
1508 }
1509
1510 static void OmNavigator_unlink(DispatchEx *dispex)
1511 {
1512     OmNavigator *This = OmNavigator_from_DispatchEx(dispex);
1513     if(This->plugins) {
1514         This->plugins->navigator = NULL;
1515         This->plugins = NULL;
1516     }
1517     if(This->mime_types) {
1518         This->mime_types->navigator = NULL;
1519         This->mime_types = NULL;
1520     }
1521 }
1522
1523 static void OmNavigator_destructor(DispatchEx *dispex)
1524 {
1525     OmNavigator *This = OmNavigator_from_DispatchEx(dispex);
1526     free(This);
1527 }
1528
1529 static const dispex_static_data_vtbl_t OmNavigator_dispex_vtbl = {
1530     .destructor       = OmNavigator_destructor,
1531     .unlink           = OmNavigator_unlink
1532 };
1533
1534 static const tid_t OmNavigator_iface_tids[] = {
1535     IOmNavigator_tid,
1536     0
1537 };
1538 static dispex_static_data_t OmNavigator_dispex = {
1539     "Navigator",
1540     &OmNavigator_dispex_vtbl,
1541     DispHTMLNavigator_tid,
1542     OmNavigator_iface_tids
1543 };
1544
1545 HRESULT create_navigator(compat_mode_t compat_mode, IOmNavigator **navigator)
1546 {
1547     OmNavigator *ret;
1548
1549     ret = calloc(1, sizeof(*ret));
1550     if(!ret)
1551         return E_OUTOFMEMORY;
1552
1553     ret->IOmNavigator_iface.lpVtbl = &OmNavigatorVtbl;
1554
1555     init_dispatch(&ret->dispex, (IUnknown*)&ret->IOmNavigator_iface, &OmNavigator_dispex, compat_mode);
1556
1557     *navigator = &ret->IOmNavigator_iface;
1558     return S_OK;
1559 }
1560
1561 typedef struct {
1562     DispatchEx dispex;
1563     IHTMLPerformanceTiming IHTMLPerformanceTiming_iface;
1564
1565     HTMLInnerWindow *window;
1566 } HTMLPerformanceTiming;
1567
1568 static inline HTMLPerformanceTiming *impl_from_IHTMLPerformanceTiming(IHTMLPerformanceTiming *iface)
1569 {
1570     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, IHTMLPerformanceTiming_iface);
1571 }
1572
1573 static HRESULT WINAPI HTMLPerformanceTiming_QueryInterface(IHTMLPerformanceTiming *iface, REFIID riid, void **ppv)
1574 {
1575     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1576
1577     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1578
1579     if(IsEqualGUID(&IID_IUnknown, riid)) {
1580         *ppv = &This->IHTMLPerformanceTiming_iface;
1581     }else if(IsEqualGUID(&IID_IHTMLPerformanceTiming, riid)) {
1582         *ppv = &This->IHTMLPerformanceTiming_iface;
1583     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1584         return *ppv ? S_OK : E_NOINTERFACE;
1585     }else {
1586         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1587         *ppv = NULL;
1588         return E_NOINTERFACE;
1589     }
1590
1591     IUnknown_AddRef((IUnknown*)*ppv);
1592     return S_OK;
1593 }
1594
1595 static ULONG WINAPI HTMLPerformanceTiming_AddRef(IHTMLPerformanceTiming *iface)
1596 {
1597     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1598     LONG ref = dispex_ref_incr(&This->dispex);
1599
1600     TRACE("(%p) ref=%ld\n", This, ref);
1601
1602     return ref;
1603 }
1604
1605 static ULONG WINAPI HTMLPerformanceTiming_Release(IHTMLPerformanceTiming *iface)
1606 {
1607     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1608     LONG ref = dispex_ref_decr(&This->dispex);
1609
1610     TRACE("(%p) ref=%ld\n", This, ref);
1611
1612     return ref;
1613 }
1614
1615 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfoCount(IHTMLPerformanceTiming *iface, UINT *pctinfo)
1616 {
1617     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1618     FIXME("(%p)->(%p)\n", This, pctinfo);
1619     return E_NOTIMPL;
1620 }
1621
1622 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfo(IHTMLPerformanceTiming *iface, UINT iTInfo,
1623                                               LCID lcid, ITypeInfo **ppTInfo)
1624 {
1625     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1626
1627     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1628 }
1629
1630 static HRESULT WINAPI HTMLPerformanceTiming_GetIDsOfNames(IHTMLPerformanceTiming *iface, REFIID riid,
1631                                                           LPOLESTR *rgszNames, UINT cNames,
1632                                                           LCID lcid, DISPID *rgDispId)
1633 {
1634     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1635
1636     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1637             lcid, rgDispId);
1638 }
1639
1640 static HRESULT WINAPI HTMLPerformanceTiming_Invoke(IHTMLPerformanceTiming *iface, DISPID dispIdMember,
1641                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1642                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1643 {
1644     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1645
1646     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1647             pDispParams, pVarResult, pExcepInfo, puArgErr);
1648 }
1649
1650 static ULONGLONG get_fetch_time(HTMLPerformanceTiming *This)
1651 {
1652     HTMLInnerWindow *window = This->window;
1653
1654     /* If there's no prior doc unloaded and no redirects, fetch time == navigationStart time */
1655     if(!window->unload_event_end_time && !window->redirect_time)
1656         return window->navigation_start_time;
1657
1658     if(window->dns_lookup_time)
1659         return window->dns_lookup_time;
1660     if(window->connect_time)
1661         return window->connect_time;
1662     if(window->request_time)
1663         return window->request_time;
1664     if(window->unload_event_end_time)
1665         return window->unload_event_end_time;
1666
1667     return window->redirect_time;
1668 }
1669
1670 static HRESULT WINAPI HTMLPerformanceTiming_get_navigationStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1671 {
1672     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1673
1674     TRACE("(%p)->(%p)\n", This, p);
1675
1676     *p = This->window->navigation_start_time;
1677     return S_OK;
1678 }
1679
1680 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1681 {
1682     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1683
1684     TRACE("(%p)->(%p)\n", This, p);
1685
1686     *p = This->window->unload_event_start_time;
1687     return S_OK;
1688 }
1689
1690 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1691 {
1692     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1693
1694     TRACE("(%p)->(%p)\n", This, p);
1695
1696     *p = This->window->unload_event_end_time;
1697     return S_OK;
1698 }
1699
1700 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1701 {
1702     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1703
1704     TRACE("(%p)->(%p)\n", This, p);
1705
1706     *p = This->window->redirect_time;
1707     return S_OK;
1708 }
1709
1710 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1711 {
1712     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1713
1714     TRACE("(%p)->(%p)\n", This, p);
1715
1716     *p = This->window->redirect_time ? get_fetch_time(This) : 0;
1717     return S_OK;
1718 }
1719
1720 static HRESULT WINAPI HTMLPerformanceTiming_get_fetchStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1721 {
1722     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1723
1724     TRACE("(%p)->(%p)\n", This, p);
1725
1726     *p = get_fetch_time(This);
1727     return S_OK;
1728 }
1729
1730 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1731 {
1732     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1733
1734     TRACE("(%p)->(%p)\n", This, p);
1735
1736     *p = This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1737     return S_OK;
1738 }
1739
1740 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1741 {
1742     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1743
1744     TRACE("(%p)->(%p)\n", This, p);
1745
1746     *p = This->window->connect_time    ? This->window->connect_time    :
1747          This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1748     return S_OK;
1749 }
1750
1751 static HRESULT WINAPI HTMLPerformanceTiming_get_connectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1752 {
1753     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1754
1755     TRACE("(%p)->(%p)\n", This, p);
1756
1757     *p = This->window->connect_time    ? This->window->connect_time    :
1758          This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1759     return S_OK;
1760 }
1761
1762 static HRESULT WINAPI HTMLPerformanceTiming_get_connectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1763 {
1764     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1765
1766     TRACE("(%p)->(%p)\n", This, p);
1767
1768     *p = This->window->request_time    ? This->window->request_time    :
1769          This->window->connect_time    ? This->window->connect_time    :
1770          This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1771     return S_OK;
1772 }
1773
1774 static HRESULT WINAPI HTMLPerformanceTiming_get_requestStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1775 {
1776     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1777
1778     TRACE("(%p)->(%p)\n", This, p);
1779
1780     *p = This->window->request_time    ? This->window->request_time    :
1781          This->window->connect_time    ? This->window->connect_time    :
1782          This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1783     return S_OK;
1784 }
1785
1786 static HRESULT WINAPI HTMLPerformanceTiming_get_responseStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1787 {
1788     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1789
1790     TRACE("(%p)->(%p)\n", This, p);
1791
1792     *p = This->window->response_start_time;
1793     return S_OK;
1794 }
1795
1796 static HRESULT WINAPI HTMLPerformanceTiming_get_responseEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1797 {
1798     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1799
1800     TRACE("(%p)->(%p)\n", This, p);
1801
1802     *p = This->window->response_end_time;
1803     return S_OK;
1804 }
1805
1806 static HRESULT WINAPI HTMLPerformanceTiming_get_domLoading(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1807 {
1808     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1809
1810     TRACE("(%p)->(%p)\n", This, p);
1811
1812     /* Make sure this is after responseEnd, when the Gecko parser starts */
1813     *p = This->window->response_end_time;
1814     return S_OK;
1815 }
1816
1817 static HRESULT WINAPI HTMLPerformanceTiming_get_domInteractive(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1818 {
1819     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1820
1821     TRACE("(%p)->(%p)\n", This, p);
1822
1823     *p = This->window->dom_interactive_time;
1824     return S_OK;
1825 }
1826
1827 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1828 {
1829     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1830
1831     TRACE("(%p)->(%p)\n", This, p);
1832
1833     *p = This->window->dom_content_loaded_event_start_time;
1834     return S_OK;
1835 }
1836
1837 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1838 {
1839     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1840
1841     TRACE("(%p)->(%p)\n", This, p);
1842
1843     *p = This->window->dom_content_loaded_event_end_time;
1844     return S_OK;
1845 }
1846
1847 static HRESULT WINAPI HTMLPerformanceTiming_get_domComplete(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1848 {
1849     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1850
1851     TRACE("(%p)->(%p)\n", This, p);
1852
1853     *p = This->window->dom_complete_time;
1854     return S_OK;
1855 }
1856
1857 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1858 {
1859     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1860
1861     TRACE("(%p)->(%p)\n", This, p);
1862
1863     *p = This->window->load_event_start_time;
1864     return S_OK;
1865 }
1866
1867 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1868 {
1869     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1870
1871     TRACE("(%p)->(%p)\n", This, p);
1872
1873     *p = This->window->load_event_end_time;
1874     return S_OK;
1875 }
1876
1877 static HRESULT WINAPI HTMLPerformanceTiming_get_msFirstPaint(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1878 {
1879     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1880
1881     TRACE("(%p)->(%p)\n", This, p);
1882
1883     *p = This->window->first_paint_time;
1884     return S_OK;
1885 }
1886
1887 static HRESULT WINAPI HTMLPerformanceTiming_toString(IHTMLPerformanceTiming *iface, BSTR *string)
1888 {
1889     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1890
1891     TRACE("(%p)->(%p)\n", This, string);
1892
1893     return dispex_to_string(&This->dispex, string);
1894 }
1895
1896 static HRESULT WINAPI HTMLPerformanceTiming_toJSON(IHTMLPerformanceTiming *iface, VARIANT *p)
1897 {
1898     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1899     FIXME("(%p)->(%p)\n", This, p);
1900     return E_NOTIMPL;
1901 }
1902
1903 static const IHTMLPerformanceTimingVtbl HTMLPerformanceTimingVtbl = {
1904     HTMLPerformanceTiming_QueryInterface,
1905     HTMLPerformanceTiming_AddRef,
1906     HTMLPerformanceTiming_Release,
1907     HTMLPerformanceTiming_GetTypeInfoCount,
1908     HTMLPerformanceTiming_GetTypeInfo,
1909     HTMLPerformanceTiming_GetIDsOfNames,
1910     HTMLPerformanceTiming_Invoke,
1911     HTMLPerformanceTiming_get_navigationStart,
1912     HTMLPerformanceTiming_get_unloadEventStart,
1913     HTMLPerformanceTiming_get_unloadEventEnd,
1914     HTMLPerformanceTiming_get_redirectStart,
1915     HTMLPerformanceTiming_get_redirectEnd,
1916     HTMLPerformanceTiming_get_fetchStart,
1917     HTMLPerformanceTiming_get_domainLookupStart,
1918     HTMLPerformanceTiming_get_domainLookupEnd,
1919     HTMLPerformanceTiming_get_connectStart,
1920     HTMLPerformanceTiming_get_connectEnd,
1921     HTMLPerformanceTiming_get_requestStart,
1922     HTMLPerformanceTiming_get_responseStart,
1923     HTMLPerformanceTiming_get_responseEnd,
1924     HTMLPerformanceTiming_get_domLoading,
1925     HTMLPerformanceTiming_get_domInteractive,
1926     HTMLPerformanceTiming_get_domContentLoadedEventStart,
1927     HTMLPerformanceTiming_get_domContentLoadedEventEnd,
1928     HTMLPerformanceTiming_get_domComplete,
1929     HTMLPerformanceTiming_get_loadEventStart,
1930     HTMLPerformanceTiming_get_loadEventEnd,
1931     HTMLPerformanceTiming_get_msFirstPaint,
1932     HTMLPerformanceTiming_toString,
1933     HTMLPerformanceTiming_toJSON
1934 };
1935
1936 static inline HTMLPerformanceTiming *HTMLPerformanceTiming_from_DispatchEx(DispatchEx *iface)
1937 {
1938     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, dispex);
1939 }
1940
1941 static void HTMLPerformanceTiming_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
1942 {
1943     HTMLPerformanceTiming *This = HTMLPerformanceTiming_from_DispatchEx(dispex);
1944     if(This->window)
1945         note_cc_edge((nsISupports*)&This->window->base.IHTMLWindow2_iface, "window", cb);
1946 }
1947
1948 static void HTMLPerformanceTiming_unlink(DispatchEx *dispex)
1949 {
1950     HTMLPerformanceTiming *This = HTMLPerformanceTiming_from_DispatchEx(dispex);
1951     if(This->window) {
1952         HTMLInnerWindow *window = This->window;
1953         This->window = NULL;
1954         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
1955     }
1956 }
1957
1958 static void HTMLPerformanceTiming_destructor(DispatchEx *dispex)
1959 {
1960     HTMLPerformanceTiming *This = HTMLPerformanceTiming_from_DispatchEx(dispex);
1961     free(This);
1962 }
1963
1964 static const dispex_static_data_vtbl_t HTMLPerformanceTiming_dispex_vtbl = {
1965     .destructor       = HTMLPerformanceTiming_destructor,
1966     .traverse         = HTMLPerformanceTiming_traverse,
1967     .unlink           = HTMLPerformanceTiming_unlink
1968 };
1969
1970 static const tid_t HTMLPerformanceTiming_iface_tids[] = {
1971     IHTMLPerformanceTiming_tid,
1972     0
1973 };
1974 static dispex_static_data_t HTMLPerformanceTiming_dispex = {
1975     "PerformanceTiming",
1976     &HTMLPerformanceTiming_dispex_vtbl,
1977     IHTMLPerformanceTiming_tid,
1978     HTMLPerformanceTiming_iface_tids
1979 };
1980
1981 typedef struct {
1982     DispatchEx dispex;
1983     IHTMLPerformanceNavigation IHTMLPerformanceNavigation_iface;
1984
1985     HTMLInnerWindow *window;
1986 } HTMLPerformanceNavigation;
1987
1988 static inline HTMLPerformanceNavigation *impl_from_IHTMLPerformanceNavigation(IHTMLPerformanceNavigation *iface)
1989 {
1990     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, IHTMLPerformanceNavigation_iface);
1991 }
1992
1993 static HRESULT WINAPI HTMLPerformanceNavigation_QueryInterface(IHTMLPerformanceNavigation *iface, REFIID riid, void **ppv)
1994 {
1995     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1996
1997     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1998
1999     if(IsEqualGUID(&IID_IUnknown, riid)) {
2000         *ppv = &This->IHTMLPerformanceNavigation_iface;
2001     }else if(IsEqualGUID(&IID_IHTMLPerformanceNavigation, riid)) {
2002         *ppv = &This->IHTMLPerformanceNavigation_iface;
2003     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2004         return *ppv ? S_OK : E_NOINTERFACE;
2005     }else {
2006         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2007         *ppv = NULL;
2008         return E_NOINTERFACE;
2009     }
2010
2011     IUnknown_AddRef((IUnknown*)*ppv);
2012     return S_OK;
2013 }
2014
2015 static ULONG WINAPI HTMLPerformanceNavigation_AddRef(IHTMLPerformanceNavigation *iface)
2016 {
2017     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2018     LONG ref = dispex_ref_incr(&This->dispex);
2019
2020     TRACE("(%p) ref=%ld\n", This, ref);
2021
2022     return ref;
2023 }
2024
2025 static ULONG WINAPI HTMLPerformanceNavigation_Release(IHTMLPerformanceNavigation *iface)
2026 {
2027     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2028     LONG ref = dispex_ref_decr(&This->dispex);
2029
2030     TRACE("(%p) ref=%ld\n", This, ref);
2031
2032     return ref;
2033 }
2034
2035 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfoCount(IHTMLPerformanceNavigation *iface, UINT *pctinfo)
2036 {
2037     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2038     FIXME("(%p)->(%p)\n", This, pctinfo);
2039     return E_NOTIMPL;
2040 }
2041
2042 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfo(IHTMLPerformanceNavigation *iface, UINT iTInfo,
2043                                               LCID lcid, ITypeInfo **ppTInfo)
2044 {
2045     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2046
2047     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2048 }
2049
2050 static HRESULT WINAPI HTMLPerformanceNavigation_GetIDsOfNames(IHTMLPerformanceNavigation *iface, REFIID riid,
2051                                                           LPOLESTR *rgszNames, UINT cNames,
2052                                                           LCID lcid, DISPID *rgDispId)
2053 {
2054     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2055
2056     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2057             lcid, rgDispId);
2058 }
2059
2060 static HRESULT WINAPI HTMLPerformanceNavigation_Invoke(IHTMLPerformanceNavigation *iface, DISPID dispIdMember,
2061                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2062                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2063 {
2064     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2065
2066     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2067             pDispParams, pVarResult, pExcepInfo, puArgErr);
2068 }
2069
2070 static HRESULT WINAPI HTMLPerformanceNavigation_get_type(IHTMLPerformanceNavigation *iface, ULONG *p)
2071 {
2072     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2073
2074     TRACE("(%p)->(%p)\n", This, p);
2075
2076     *p = This->window->navigation_type;
2077     return S_OK;
2078 }
2079
2080 static HRESULT WINAPI HTMLPerformanceNavigation_get_redirectCount(IHTMLPerformanceNavigation *iface, ULONG *p)
2081 {
2082     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2083
2084     TRACE("(%p)->(%p)\n", This, p);
2085
2086     *p = This->window->redirect_count;
2087     return S_OK;
2088 }
2089
2090 static HRESULT WINAPI HTMLPerformanceNavigation_toString(IHTMLPerformanceNavigation *iface, BSTR *string)
2091 {
2092     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2093
2094     TRACE("(%p)->(%p)\n", This, string);
2095
2096     return dispex_to_string(&This->dispex, string);
2097 }
2098
2099 static HRESULT WINAPI HTMLPerformanceNavigation_toJSON(IHTMLPerformanceNavigation *iface, VARIANT *p)
2100 {
2101     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2102     FIXME("(%p)->(%p)\n", This, p);
2103     return E_NOTIMPL;
2104 }
2105
2106 static const IHTMLPerformanceNavigationVtbl HTMLPerformanceNavigationVtbl = {
2107     HTMLPerformanceNavigation_QueryInterface,
2108     HTMLPerformanceNavigation_AddRef,
2109     HTMLPerformanceNavigation_Release,
2110     HTMLPerformanceNavigation_GetTypeInfoCount,
2111     HTMLPerformanceNavigation_GetTypeInfo,
2112     HTMLPerformanceNavigation_GetIDsOfNames,
2113     HTMLPerformanceNavigation_Invoke,
2114     HTMLPerformanceNavigation_get_type,
2115     HTMLPerformanceNavigation_get_redirectCount,
2116     HTMLPerformanceNavigation_toString,
2117     HTMLPerformanceNavigation_toJSON
2118 };
2119
2120 static inline HTMLPerformanceNavigation *HTMLPerformanceNavigation_from_DispatchEx(DispatchEx *iface)
2121 {
2122     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, dispex);
2123 }
2124
2125 static void HTMLPerformanceNavigation_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
2126 {
2127     HTMLPerformanceNavigation *This = HTMLPerformanceNavigation_from_DispatchEx(dispex);
2128     if(This->window)
2129         note_cc_edge((nsISupports*)&This->window->base.IHTMLWindow2_iface, "window", cb);
2130 }
2131
2132 static void HTMLPerformanceNavigation_unlink(DispatchEx *dispex)
2133 {
2134     HTMLPerformanceNavigation *This = HTMLPerformanceNavigation_from_DispatchEx(dispex);
2135     if(This->window) {
2136         HTMLInnerWindow *window = This->window;
2137         This->window = NULL;
2138         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
2139     }
2140 }
2141
2142 static void HTMLPerformanceNavigation_destructor(DispatchEx *dispex)
2143 {
2144     HTMLPerformanceNavigation *This = HTMLPerformanceNavigation_from_DispatchEx(dispex);
2145     free(This);
2146 }
2147
2148 static const dispex_static_data_vtbl_t HTMLPerformanceNavigation_dispex_vtbl = {
2149     .destructor       = HTMLPerformanceNavigation_destructor,
2150     .traverse         = HTMLPerformanceNavigation_traverse,
2151     .unlink           = HTMLPerformanceNavigation_unlink
2152 };
2153
2154 static const tid_t HTMLPerformanceNavigation_iface_tids[] = {
2155     IHTMLPerformanceNavigation_tid,
2156     0
2157 };
2158 static dispex_static_data_t HTMLPerformanceNavigation_dispex = {
2159     "PerformanceNavigation",
2160     &HTMLPerformanceNavigation_dispex_vtbl,
2161     IHTMLPerformanceNavigation_tid,
2162     HTMLPerformanceNavigation_iface_tids
2163 };
2164
2165 typedef struct {
2166     DispatchEx dispex;
2167     IHTMLPerformance IHTMLPerformance_iface;
2168
2169     HTMLInnerWindow *window;
2170     IHTMLPerformanceNavigation *navigation;
2171     IHTMLPerformanceTiming *timing;
2172 } HTMLPerformance;
2173
2174 static inline HTMLPerformance *impl_from_IHTMLPerformance(IHTMLPerformance *iface)
2175 {
2176     return CONTAINING_RECORD(iface, HTMLPerformance, IHTMLPerformance_iface);
2177 }
2178
2179 static HRESULT WINAPI HTMLPerformance_QueryInterface(IHTMLPerformance *iface, REFIID riid, void **ppv)
2180 {
2181     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2182
2183     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2184
2185     if(IsEqualGUID(&IID_IUnknown, riid)) {
2186         *ppv = &This->IHTMLPerformance_iface;
2187     }else if(IsEqualGUID(&IID_IHTMLPerformance, riid)) {
2188         *ppv = &This->IHTMLPerformance_iface;
2189     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2190         return *ppv ? S_OK : E_NOINTERFACE;
2191     }else {
2192         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2193         *ppv = NULL;
2194         return E_NOINTERFACE;
2195     }
2196
2197     IUnknown_AddRef((IUnknown*)*ppv);
2198     return S_OK;
2199 }
2200
2201 static ULONG WINAPI HTMLPerformance_AddRef(IHTMLPerformance *iface)
2202 {
2203     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2204     LONG ref = dispex_ref_incr(&This->dispex);
2205
2206     TRACE("(%p) ref=%ld\n", This, ref);
2207
2208     return ref;
2209 }
2210
2211 static ULONG WINAPI HTMLPerformance_Release(IHTMLPerformance *iface)
2212 {
2213     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2214     LONG ref = dispex_ref_decr(&This->dispex);
2215
2216     TRACE("(%p) ref=%ld\n", This, ref);
2217
2218     return ref;
2219 }
2220
2221 static HRESULT WINAPI HTMLPerformance_GetTypeInfoCount(IHTMLPerformance *iface, UINT *pctinfo)
2222 {
2223     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2224     FIXME("(%p)->(%p)\n", This, pctinfo);
2225     return E_NOTIMPL;
2226 }
2227
2228 static HRESULT WINAPI HTMLPerformance_GetTypeInfo(IHTMLPerformance *iface, UINT iTInfo,
2229                                                   LCID lcid, ITypeInfo **ppTInfo)
2230 {
2231     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2232
2233     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2234 }
2235
2236 static HRESULT WINAPI HTMLPerformance_GetIDsOfNames(IHTMLPerformance *iface, REFIID riid,
2237                                                     LPOLESTR *rgszNames, UINT cNames,
2238                                                     LCID lcid, DISPID *rgDispId)
2239 {
2240     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2241
2242     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2243             lcid, rgDispId);
2244 }
2245
2246 static HRESULT WINAPI HTMLPerformance_Invoke(IHTMLPerformance *iface, DISPID dispIdMember,
2247                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2248                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2249 {
2250     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2251
2252     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2253             pDispParams, pVarResult, pExcepInfo, puArgErr);
2254 }
2255
2256 static HRESULT WINAPI HTMLPerformance_get_navigation(IHTMLPerformance *iface,
2257                                                      IHTMLPerformanceNavigation **p)
2258 {
2259     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2260
2261     TRACE("(%p)->(%p)\n", This, p);
2262
2263     if(!This->navigation) {
2264         HTMLPerformanceNavigation *navigation;
2265
2266         navigation = calloc(1, sizeof(*navigation));
2267         if(!navigation)
2268             return E_OUTOFMEMORY;
2269
2270         navigation->IHTMLPerformanceNavigation_iface.lpVtbl = &HTMLPerformanceNavigationVtbl;
2271         navigation->window = This->window;
2272         IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
2273
2274         init_dispatch(&navigation->dispex, (IUnknown*)&navigation->IHTMLPerformanceNavigation_iface,
2275                       &HTMLPerformanceNavigation_dispex, dispex_compat_mode(&This->dispex));
2276
2277         This->navigation = &navigation->IHTMLPerformanceNavigation_iface;
2278     }
2279
2280     IHTMLPerformanceNavigation_AddRef(*p = This->navigation);
2281     return S_OK;
2282 }
2283
2284 static HRESULT WINAPI HTMLPerformance_get_timing(IHTMLPerformance *iface, IHTMLPerformanceTiming **p)
2285 {
2286     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2287
2288     TRACE("(%p)->(%p)\n", This, p);
2289
2290     if(!This->timing) {
2291         HTMLPerformanceTiming *timing;
2292
2293         timing = calloc(1, sizeof(*timing));
2294         if(!timing)
2295             return E_OUTOFMEMORY;
2296
2297         timing->IHTMLPerformanceTiming_iface.lpVtbl = &HTMLPerformanceTimingVtbl;
2298         timing->window = This->window;
2299         IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
2300
2301         init_dispatch(&timing->dispex, (IUnknown*)&timing->IHTMLPerformanceTiming_iface,
2302                       &HTMLPerformanceTiming_dispex, dispex_compat_mode(&This->dispex));
2303
2304         This->timing = &timing->IHTMLPerformanceTiming_iface;
2305     }
2306
2307     IHTMLPerformanceTiming_AddRef(*p = This->timing);
2308     return S_OK;
2309 }
2310
2311 static HRESULT WINAPI HTMLPerformance_toString(IHTMLPerformance *iface, BSTR *string)
2312 {
2313     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2314
2315     TRACE("(%p)->(%p)\n", This, string);
2316
2317     return dispex_to_string(&This->dispex, string);
2318 }
2319
2320 static HRESULT WINAPI HTMLPerformance_toJSON(IHTMLPerformance *iface, VARIANT *var)
2321 {
2322     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2323     FIXME("(%p)->(%p)\n", This, var);
2324     return E_NOTIMPL;
2325 }
2326
2327 static const IHTMLPerformanceVtbl HTMLPerformanceVtbl = {
2328     HTMLPerformance_QueryInterface,
2329     HTMLPerformance_AddRef,
2330     HTMLPerformance_Release,
2331     HTMLPerformance_GetTypeInfoCount,
2332     HTMLPerformance_GetTypeInfo,
2333     HTMLPerformance_GetIDsOfNames,
2334     HTMLPerformance_Invoke,
2335     HTMLPerformance_get_navigation,
2336     HTMLPerformance_get_timing,
2337     HTMLPerformance_toString,
2338     HTMLPerformance_toJSON
2339 };
2340
2341 static inline HTMLPerformance *HTMLPerformance_from_DispatchEx(DispatchEx *iface)
2342 {
2343     return CONTAINING_RECORD(iface, HTMLPerformance, dispex);
2344 }
2345
2346 static void HTMLPerformance_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
2347 {
2348     HTMLPerformance *This = HTMLPerformance_from_DispatchEx(dispex);
2349     if(This->window)
2350         note_cc_edge((nsISupports*)&This->window->base.IHTMLWindow2_iface, "window", cb);
2351     if(This->navigation)
2352         note_cc_edge((nsISupports*)This->navigation, "navigation", cb);
2353     if(This->timing)
2354         note_cc_edge((nsISupports*)This->timing, "timing", cb);
2355 }
2356
2357 static void HTMLPerformance_unlink(DispatchEx *dispex)
2358 {
2359     HTMLPerformance *This = HTMLPerformance_from_DispatchEx(dispex);
2360     if(This->window) {
2361         HTMLInnerWindow *window = This->window;
2362         This->window = NULL;
2363         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
2364     }
2365     unlink_ref(&This->navigation);
2366     unlink_ref(&This->timing);
2367 }
2368
2369 static void HTMLPerformance_destructor(DispatchEx *dispex)
2370 {
2371     HTMLPerformance *This = HTMLPerformance_from_DispatchEx(dispex);
2372     free(This);
2373 }
2374
2375 static const dispex_static_data_vtbl_t HTMLPerformance_dispex_vtbl = {
2376     .destructor       = HTMLPerformance_destructor,
2377     .traverse         = HTMLPerformance_traverse,
2378     .unlink           = HTMLPerformance_unlink
2379 };
2380
2381 static const tid_t HTMLPerformance_iface_tids[] = {
2382     IHTMLPerformance_tid,
2383     0
2384 };
2385 static dispex_static_data_t HTMLPerformance_dispex = {
2386     "Performance",
2387     &HTMLPerformance_dispex_vtbl,
2388     IHTMLPerformance_tid,
2389     HTMLPerformance_iface_tids
2390 };
2391
2392 HRESULT create_performance(HTMLInnerWindow *window, IHTMLPerformance **ret)
2393 {
2394     compat_mode_t compat_mode = dispex_compat_mode(&window->event_target.dispex);
2395     HTMLPerformance *performance;
2396
2397     performance = calloc(1, sizeof(*performance));
2398     if(!performance)
2399         return E_OUTOFMEMORY;
2400
2401     performance->IHTMLPerformance_iface.lpVtbl = &HTMLPerformanceVtbl;
2402     performance->window = window;
2403     IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
2404
2405     init_dispatch(&performance->dispex, (IUnknown*)&performance->IHTMLPerformance_iface,
2406                   &HTMLPerformance_dispex, compat_mode);
2407
2408     *ret = &performance->IHTMLPerformance_iface;
2409     return S_OK;
2410 }
2411
2412 typedef struct {
2413     DispatchEx dispex;
2414     IHTMLNamespaceCollection IHTMLNamespaceCollection_iface;
2415 } HTMLNamespaceCollection;
2416
2417 static inline HTMLNamespaceCollection *impl_from_IHTMLNamespaceCollection(IHTMLNamespaceCollection *iface)
2418 {
2419     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, IHTMLNamespaceCollection_iface);
2420 }
2421
2422 static HRESULT WINAPI HTMLNamespaceCollection_QueryInterface(IHTMLNamespaceCollection *iface, REFIID riid, void **ppv)
2423 {
2424     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2425
2426     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2427
2428     if(IsEqualGUID(&IID_IUnknown, riid)) {
2429         *ppv = &This->IHTMLNamespaceCollection_iface;
2430     }else if(IsEqualGUID(&IID_IHTMLNamespaceCollection, riid)) {
2431         *ppv = &This->IHTMLNamespaceCollection_iface;
2432     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2433         return *ppv ? S_OK : E_NOINTERFACE;
2434     }else {
2435         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2436         *ppv = NULL;
2437         return E_NOINTERFACE;
2438     }
2439
2440     IUnknown_AddRef((IUnknown*)*ppv);
2441     return S_OK;
2442 }
2443
2444 static ULONG WINAPI HTMLNamespaceCollection_AddRef(IHTMLNamespaceCollection *iface)
2445 {
2446     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2447     LONG ref = dispex_ref_incr(&This->dispex);
2448
2449     TRACE("(%p) ref=%ld\n", This, ref);
2450
2451     return ref;
2452 }
2453
2454 static ULONG WINAPI HTMLNamespaceCollection_Release(IHTMLNamespaceCollection *iface)
2455 {
2456     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2457     LONG ref = dispex_ref_decr(&This->dispex);
2458
2459     TRACE("(%p) ref=%ld\n", This, ref);
2460
2461     return ref;
2462 }
2463
2464 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfoCount(IHTMLNamespaceCollection *iface, UINT *pctinfo)
2465 {
2466     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2467     FIXME("(%p)->(%p)\n", This, pctinfo);
2468     return E_NOTIMPL;
2469 }
2470
2471 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfo(IHTMLNamespaceCollection *iface, UINT iTInfo,
2472                                                   LCID lcid, ITypeInfo **ppTInfo)
2473 {
2474     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2475
2476     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2477 }
2478
2479 static HRESULT WINAPI HTMLNamespaceCollection_GetIDsOfNames(IHTMLNamespaceCollection *iface, REFIID riid,
2480                                                     LPOLESTR *rgszNames, UINT cNames,
2481                                                     LCID lcid, DISPID *rgDispId)
2482 {
2483     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2484
2485     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2486             lcid, rgDispId);
2487 }
2488
2489 static HRESULT WINAPI HTMLNamespaceCollection_Invoke(IHTMLNamespaceCollection *iface, DISPID dispIdMember,
2490                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2491                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2492 {
2493     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2494
2495     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2496             pDispParams, pVarResult, pExcepInfo, puArgErr);
2497 }
2498
2499 static HRESULT WINAPI HTMLNamespaceCollection_get_length(IHTMLNamespaceCollection *iface, LONG *p)
2500 {
2501     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2502     FIXME("(%p)->(%p) returning 0\n", This, p);
2503     *p = 0;
2504     return S_OK;
2505 }
2506
2507 static HRESULT WINAPI HTMLNamespaceCollection_item(IHTMLNamespaceCollection *iface, VARIANT index, IDispatch **p)
2508 {
2509     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2510     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(&index), p);
2511     return E_NOTIMPL;
2512 }
2513
2514 static HRESULT WINAPI HTMLNamespaceCollection_add(IHTMLNamespaceCollection *iface, BSTR namespace, BSTR urn,
2515                                                   VARIANT implementation_url, IDispatch **p)
2516 {
2517     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2518     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(namespace), debugstr_w(urn), debugstr_variant(&implementation_url), p);
2519     return E_NOTIMPL;
2520 }
2521
2522 static const IHTMLNamespaceCollectionVtbl HTMLNamespaceCollectionVtbl = {
2523     HTMLNamespaceCollection_QueryInterface,
2524     HTMLNamespaceCollection_AddRef,
2525     HTMLNamespaceCollection_Release,
2526     HTMLNamespaceCollection_GetTypeInfoCount,
2527     HTMLNamespaceCollection_GetTypeInfo,
2528     HTMLNamespaceCollection_GetIDsOfNames,
2529     HTMLNamespaceCollection_Invoke,
2530     HTMLNamespaceCollection_get_length,
2531     HTMLNamespaceCollection_item,
2532     HTMLNamespaceCollection_add
2533 };
2534
2535 static inline HTMLNamespaceCollection *HTMLNamespaceCollection_from_DispatchEx(DispatchEx *iface)
2536 {
2537     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, dispex);
2538 }
2539
2540 static void HTMLNamespaceCollection_destructor(DispatchEx *dispex)
2541 {
2542     HTMLNamespaceCollection *This = HTMLNamespaceCollection_from_DispatchEx(dispex);
2543     free(This);
2544 }
2545
2546 static const dispex_static_data_vtbl_t HTMLNamespaceCollection_dispex_vtbl = {
2547     .destructor       = HTMLNamespaceCollection_destructor,
2548 };
2549
2550 static const tid_t HTMLNamespaceCollection_iface_tids[] = {
2551     IHTMLNamespaceCollection_tid,
2552     0
2553 };
2554 static dispex_static_data_t HTMLNamespaceCollection_dispex = {
2555     "MSNamespaceInfoCollection",
2556     &HTMLNamespaceCollection_dispex_vtbl,
2557     DispHTMLNamespaceCollection_tid,
2558     HTMLNamespaceCollection_iface_tids
2559 };
2560
2561 HRESULT create_namespace_collection(compat_mode_t compat_mode, IHTMLNamespaceCollection **ret)
2562 {
2563     HTMLNamespaceCollection *namespaces;
2564
2565     if (!(namespaces = calloc(1, sizeof(*namespaces))))
2566         return E_OUTOFMEMORY;
2567
2568     namespaces->IHTMLNamespaceCollection_iface.lpVtbl = &HTMLNamespaceCollectionVtbl;
2569     init_dispatch(&namespaces->dispex, (IUnknown*)&namespaces->IHTMLNamespaceCollection_iface,
2570                   &HTMLNamespaceCollection_dispex, compat_mode);
2571     *ret = &namespaces->IHTMLNamespaceCollection_iface;
2572     return S_OK;
2573 }
2574
2575 struct console {
2576     DispatchEx dispex;
2577     IWineMSHTMLConsole IWineMSHTMLConsole_iface;
2578 };
2579
2580 static inline struct console *impl_from_IWineMSHTMLConsole(IWineMSHTMLConsole *iface)
2581 {
2582     return CONTAINING_RECORD(iface, struct console, IWineMSHTMLConsole_iface);
2583 }
2584
2585 static HRESULT WINAPI console_QueryInterface(IWineMSHTMLConsole *iface, REFIID riid, void **ppv)
2586 {
2587     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2588
2589     TRACE("(%p)->(%s %p)\n", console, debugstr_mshtml_guid(riid), ppv);
2590
2591     if(IsEqualGUID(&IID_IUnknown, riid)) {
2592         *ppv = &console->IWineMSHTMLConsole_iface;
2593     }else if(IsEqualGUID(&IID_IWineMSHTMLConsole, riid)) {
2594         *ppv = &console->IWineMSHTMLConsole_iface;
2595     }else if(dispex_query_interface(&console->dispex, riid, ppv)) {
2596         return *ppv ? S_OK : E_NOINTERFACE;
2597     }else {
2598         WARN("(%p)->(%s %p)\n", console, debugstr_mshtml_guid(riid), ppv);
2599         *ppv = NULL;
2600         return E_NOINTERFACE;
2601     }
2602
2603     IUnknown_AddRef((IUnknown*)*ppv);
2604     return S_OK;
2605 }
2606
2607 static ULONG WINAPI console_AddRef(IWineMSHTMLConsole *iface)
2608 {
2609     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2610     LONG ref = dispex_ref_incr(&console->dispex);
2611
2612     TRACE("(%p) ref=%ld\n", console, ref);
2613
2614     return ref;
2615 }
2616
2617 static ULONG WINAPI console_Release(IWineMSHTMLConsole *iface)
2618 {
2619     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2620     LONG ref = dispex_ref_decr(&console->dispex);
2621
2622     TRACE("(%p) ref=%ld\n", console, ref);
2623
2624     return ref;
2625 }
2626
2627 static HRESULT WINAPI console_GetTypeInfoCount(IWineMSHTMLConsole *iface, UINT *pctinfo)
2628 {
2629     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2630     FIXME("(%p)->(%p)\n", console, pctinfo);
2631     return E_NOTIMPL;
2632 }
2633
2634 static HRESULT WINAPI console_GetTypeInfo(IWineMSHTMLConsole *iface, UINT iTInfo,
2635         LCID lcid, ITypeInfo **ppTInfo)
2636 {
2637     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2638
2639     return IDispatchEx_GetTypeInfo(&console->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2640 }
2641
2642 static HRESULT WINAPI console_GetIDsOfNames(IWineMSHTMLConsole *iface, REFIID riid,
2643         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2644 {
2645     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2646
2647     return IDispatchEx_GetIDsOfNames(&console->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2648             lcid, rgDispId);
2649 }
2650
2651 static HRESULT WINAPI console_Invoke(IWineMSHTMLConsole *iface, DISPID dispIdMember,
2652         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2653         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2654 {
2655     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2656
2657     return IDispatchEx_Invoke(&console->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2658             pDispParams, pVarResult, pExcepInfo, puArgErr);
2659 }
2660
2661 static HRESULT WINAPI console_assert(IWineMSHTMLConsole *iface, VARIANT_BOOL *assertion, VARIANT *vararg_start)
2662 {
2663     FIXME("iface %p, assertion %p, vararg_start %p stub.\n", iface, assertion, vararg_start);
2664
2665     return S_OK;
2666 }
2667
2668 static HRESULT WINAPI console_clear(IWineMSHTMLConsole *iface)
2669 {
2670     FIXME("iface %p stub.\n", iface);
2671
2672     return S_OK;
2673 }
2674
2675 static HRESULT WINAPI console_count(IWineMSHTMLConsole *iface, VARIANT *label)
2676 {
2677     FIXME("iface %p, label %p stub.\n", iface, label);
2678
2679     return S_OK;
2680 }
2681
2682 static HRESULT WINAPI console_debug(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2683 {
2684     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2685
2686     return S_OK;
2687 }
2688
2689 static HRESULT WINAPI console_dir(IWineMSHTMLConsole *iface, VARIANT *object)
2690 {
2691     FIXME("iface %p, object %p stub.\n", iface, object);
2692
2693     return S_OK;
2694 }
2695
2696 static HRESULT WINAPI console_dirxml(IWineMSHTMLConsole *iface, VARIANT *object)
2697 {
2698     FIXME("iface %p, object %p stub.\n", iface, object);
2699
2700     return S_OK;
2701 }
2702
2703 static HRESULT WINAPI console_error(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2704 {
2705     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2706
2707     return S_OK;
2708 }
2709
2710 static HRESULT WINAPI console_group(IWineMSHTMLConsole *iface, VARIANT *label)
2711 {
2712     FIXME("iface %p, label %p stub.\n", iface, label);
2713
2714     return S_OK;
2715 }
2716
2717 static HRESULT WINAPI console_group_collapsed(IWineMSHTMLConsole *iface, VARIANT *label)
2718 {
2719     FIXME("iface %p, label %p stub.\n", iface, label);
2720
2721     return S_OK;
2722 }
2723
2724 static HRESULT WINAPI console_group_end(IWineMSHTMLConsole *iface)
2725 {
2726     FIXME("iface %p, stub.\n", iface);
2727
2728     return S_OK;
2729 }
2730
2731 static HRESULT WINAPI console_info(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2732 {
2733     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2734
2735     return S_OK;
2736 }
2737
2738 static HRESULT WINAPI console_log(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2739 {
2740     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2741
2742     return S_OK;
2743 }
2744
2745 static HRESULT WINAPI console_time(IWineMSHTMLConsole *iface, VARIANT *label)
2746 {
2747     FIXME("iface %p, label %p stub.\n", iface, label);
2748
2749     return S_OK;
2750 }
2751
2752 static HRESULT WINAPI console_time_end(IWineMSHTMLConsole *iface, VARIANT *label)
2753 {
2754     FIXME("iface %p, label %p stub.\n", iface, label);
2755
2756     return S_OK;
2757 }
2758
2759 static HRESULT WINAPI console_trace(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2760 {
2761     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2762
2763     return S_OK;
2764 }
2765
2766 static HRESULT WINAPI console_warn(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2767 {
2768     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2769
2770     return S_OK;
2771 }
2772
2773 static const IWineMSHTMLConsoleVtbl WineMSHTMLConsoleVtbl = {
2774     console_QueryInterface,
2775     console_AddRef,
2776     console_Release,
2777     console_GetTypeInfoCount,
2778     console_GetTypeInfo,
2779     console_GetIDsOfNames,
2780     console_Invoke,
2781     console_assert,
2782     console_clear,
2783     console_count,
2784     console_debug,
2785     console_dir,
2786     console_dirxml,
2787     console_error,
2788     console_group,
2789     console_group_collapsed,
2790     console_group_end,
2791     console_info,
2792     console_log,
2793     console_time,
2794     console_time_end,
2795     console_trace,
2796     console_warn,
2797 };
2798
2799 static inline struct console *console_from_DispatchEx(DispatchEx *iface)
2800 {
2801     return CONTAINING_RECORD(iface, struct console, dispex);
2802 }
2803
2804 static void console_destructor(DispatchEx *dispex)
2805 {
2806     struct console *console = console_from_DispatchEx(dispex);
2807     free(console);
2808 }
2809
2810 static const dispex_static_data_vtbl_t console_dispex_vtbl = {
2811     .destructor       = console_destructor,
2812 };
2813
2814 static const tid_t console_iface_tids[] = {
2815     IWineMSHTMLConsole_tid,
2816     0
2817 };
2818 static dispex_static_data_t console_dispex = {
2819     "Console",
2820     &console_dispex_vtbl,
2821     IWineMSHTMLConsole_tid,
2822     console_iface_tids
2823 };
2824
2825 void create_console(compat_mode_t compat_mode, IWineMSHTMLConsole **ret)
2826 {
2827     struct console *obj;
2828
2829     obj = calloc(1, sizeof(*obj));
2830     if(!obj)
2831     {
2832         ERR("No memory.\n");
2833         return;
2834     }
2835
2836     obj->IWineMSHTMLConsole_iface.lpVtbl = &WineMSHTMLConsoleVtbl;
2837     init_dispatch(&obj->dispex, (IUnknown*)&obj->IWineMSHTMLConsole_iface, &console_dispex, compat_mode);
2838
2839     *ret = &obj->IWineMSHTMLConsole_iface;
2840 }
2841
2842 struct media_query_list_listener {
2843     struct list entry;
2844     IDispatch *function;
2845 };
2846
2847 struct media_query_list_callback;
2848 struct media_query_list {
2849     DispatchEx dispex;
2850     IWineMSHTMLMediaQueryList IWineMSHTMLMediaQueryList_iface;
2851     nsIDOMMediaQueryList *nsquerylist;
2852     struct media_query_list_callback *callback;
2853     struct list listeners;
2854 };
2855
2856 struct media_query_list_callback {
2857     nsIDOMMediaQueryListListener nsIDOMMediaQueryListListener_iface;
2858     struct media_query_list *media_query_list;
2859     LONG ref;
2860 };
2861
2862 static inline struct media_query_list *impl_from_IWineMSHTMLMediaQueryList(IWineMSHTMLMediaQueryList *iface)
2863 {
2864     return CONTAINING_RECORD(iface, struct media_query_list, IWineMSHTMLMediaQueryList_iface);
2865 }
2866
2867 static HRESULT WINAPI media_query_list_QueryInterface(IWineMSHTMLMediaQueryList *iface, REFIID riid, void **ppv)
2868 {
2869     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2870
2871     TRACE("(%p)->(%s %p)\n", media_query_list, debugstr_mshtml_guid(riid), ppv);
2872
2873     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IWineMSHTMLMediaQueryList, riid)) {
2874         *ppv = &media_query_list->IWineMSHTMLMediaQueryList_iface;
2875     }else if(dispex_query_interface(&media_query_list->dispex, riid, ppv)) {
2876         return *ppv ? S_OK : E_NOINTERFACE;
2877     }else {
2878         *ppv = NULL;
2879         return E_NOINTERFACE;
2880     }
2881
2882     IUnknown_AddRef((IUnknown*)*ppv);
2883     return S_OK;
2884 }
2885
2886 static ULONG WINAPI media_query_list_AddRef(IWineMSHTMLMediaQueryList *iface)
2887 {
2888     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2889     LONG ref = dispex_ref_incr(&media_query_list->dispex);
2890
2891     TRACE("(%p) ref=%ld\n", media_query_list, ref);
2892
2893     return ref;
2894 }
2895
2896 static ULONG WINAPI media_query_list_Release(IWineMSHTMLMediaQueryList *iface)
2897 {
2898     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2899     LONG ref = dispex_ref_decr(&media_query_list->dispex);
2900
2901     TRACE("(%p) ref=%ld\n", media_query_list, ref);
2902
2903     return ref;
2904 }
2905
2906 static HRESULT WINAPI media_query_list_GetTypeInfoCount(IWineMSHTMLMediaQueryList *iface, UINT *pctinfo)
2907 {
2908     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2909
2910     TRACE("(%p)->(%p)\n", media_query_list, pctinfo);
2911
2912     return IDispatchEx_GetTypeInfoCount(&media_query_list->dispex.IDispatchEx_iface, pctinfo);
2913 }
2914
2915 static HRESULT WINAPI media_query_list_GetTypeInfo(IWineMSHTMLMediaQueryList *iface, UINT iTInfo,
2916         LCID lcid, ITypeInfo **ppTInfo)
2917 {
2918     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2919
2920     return IDispatchEx_GetTypeInfo(&media_query_list->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2921 }
2922
2923 static HRESULT WINAPI media_query_list_GetIDsOfNames(IWineMSHTMLMediaQueryList *iface, REFIID riid,
2924         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2925 {
2926     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2927
2928     return IDispatchEx_GetIDsOfNames(&media_query_list->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2929             lcid, rgDispId);
2930 }
2931
2932 static HRESULT WINAPI media_query_list_Invoke(IWineMSHTMLMediaQueryList *iface, DISPID dispIdMember,
2933         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2934         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2935 {
2936     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2937
2938     return IDispatchEx_Invoke(&media_query_list->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2939             pDispParams, pVarResult, pExcepInfo, puArgErr);
2940 }
2941
2942 static HRESULT WINAPI media_query_list_get_media(IWineMSHTMLMediaQueryList *iface, BSTR *p)
2943 {
2944     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2945     nsAString nsstr;
2946
2947     TRACE("(%p)->(%p)\n", media_query_list, p);
2948
2949     nsAString_InitDepend(&nsstr, NULL);
2950     return return_nsstr(nsIDOMMediaQueryList_GetMedia(media_query_list->nsquerylist, &nsstr), &nsstr, p);
2951 }
2952
2953 static HRESULT WINAPI media_query_list_get_matches(IWineMSHTMLMediaQueryList *iface, VARIANT_BOOL *p)
2954 {
2955     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2956     nsresult nsres;
2957     cpp_bool b;
2958
2959     TRACE("(%p)->(%p)\n", media_query_list, p);
2960
2961     nsres = nsIDOMMediaQueryList_GetMatches(media_query_list->nsquerylist, &b);
2962     if(NS_FAILED(nsres))
2963         return map_nsresult(nsres);
2964     *p = b ? VARIANT_TRUE : VARIANT_FALSE;
2965     return S_OK;
2966 }
2967
2968 static HRESULT WINAPI media_query_list_addListener(IWineMSHTMLMediaQueryList *iface, VARIANT *listener)
2969 {
2970     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2971     struct media_query_list_listener *entry;
2972
2973     TRACE("(%p)->(%s)\n", media_query_list, debugstr_variant(listener));
2974
2975     if(V_VT(listener) != VT_DISPATCH || !V_DISPATCH(listener))
2976         return S_OK;
2977
2978     LIST_FOR_EACH_ENTRY(entry, &media_query_list->listeners, struct media_query_list_listener, entry)
2979         if(entry->function == V_DISPATCH(listener))
2980             return S_OK;
2981
2982     if(!(entry = malloc(sizeof(*entry))))
2983         return E_OUTOFMEMORY;
2984     entry->function = V_DISPATCH(listener);
2985     IDispatch_AddRef(V_DISPATCH(listener));
2986
2987     list_add_tail(&media_query_list->listeners, &entry->entry);
2988     return S_OK;
2989 }
2990
2991 static HRESULT WINAPI media_query_list_removeListener(IWineMSHTMLMediaQueryList *iface, VARIANT *listener)
2992 {
2993     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2994     struct media_query_list_listener *entry;
2995
2996     TRACE("(%p)->(%s)\n", media_query_list, debugstr_variant(listener));
2997
2998     if(V_VT(listener) != VT_DISPATCH || !V_DISPATCH(listener))
2999         return S_OK;
3000
3001     LIST_FOR_EACH_ENTRY(entry, &media_query_list->listeners, struct media_query_list_listener, entry) {
3002         if(entry->function == V_DISPATCH(listener)) {
3003             list_remove(&entry->entry);
3004             IDispatch_Release(entry->function);
3005             free(entry);
3006             break;
3007         }
3008     }
3009
3010     return S_OK;
3011 }
3012
3013 static const IWineMSHTMLMediaQueryListVtbl media_query_list_vtbl = {
3014     media_query_list_QueryInterface,
3015     media_query_list_AddRef,
3016     media_query_list_Release,
3017     media_query_list_GetTypeInfoCount,
3018     media_query_list_GetTypeInfo,
3019     media_query_list_GetIDsOfNames,
3020     media_query_list_Invoke,
3021     media_query_list_get_media,
3022     media_query_list_get_matches,
3023     media_query_list_addListener,
3024     media_query_list_removeListener
3025 };
3026
3027 static inline struct media_query_list_callback *impl_from_nsIDOMMediaQueryListListener(nsIDOMMediaQueryListListener *iface)
3028 {
3029     return CONTAINING_RECORD(iface, struct media_query_list_callback, nsIDOMMediaQueryListListener_iface);
3030 }
3031
3032 static nsresult NSAPI media_query_list_callback_QueryInterface(nsIDOMMediaQueryListListener *iface,
3033         nsIIDRef riid, void **result)
3034 {
3035     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
3036
3037     if(IsEqualGUID(&IID_nsISupports, riid) || IsEqualGUID(&IID_nsIDOMMediaQueryListListener, riid)) {
3038         *result = &callback->nsIDOMMediaQueryListListener_iface;
3039     }else {
3040         *result = NULL;
3041         return NS_NOINTERFACE;
3042     }
3043
3044     nsIDOMMediaQueryListListener_AddRef(&callback->nsIDOMMediaQueryListListener_iface);
3045     return NS_OK;
3046 }
3047
3048 static nsrefcnt NSAPI media_query_list_callback_AddRef(nsIDOMMediaQueryListListener *iface)
3049 {
3050     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
3051     LONG ref = InterlockedIncrement(&callback->ref);
3052
3053     TRACE("(%p) ref=%ld\n", callback, ref);
3054
3055     return ref;
3056 }
3057
3058 static nsrefcnt NSAPI media_query_list_callback_Release(nsIDOMMediaQueryListListener *iface)
3059 {
3060     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
3061     LONG ref = InterlockedDecrement(&callback->ref);
3062
3063     TRACE("(%p) ref=%ld\n", callback, ref);
3064
3065     if(!ref)
3066         free(callback);
3067     return ref;
3068 }
3069
3070 static nsresult NSAPI media_query_list_callback_HandleChange(nsIDOMMediaQueryListListener *iface, nsIDOMMediaQueryList *mql)
3071 {
3072     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
3073     IDispatch *listener_funcs_buf[4], **listener_funcs = listener_funcs_buf;
3074     struct media_query_list *media_query_list = callback->media_query_list;
3075     struct media_query_list_listener *listener;
3076     unsigned cnt, i = 0;
3077     VARIANT args[1], v;
3078     HRESULT hres;
3079
3080     if(!media_query_list)
3081         return NS_OK;
3082
3083     cnt = list_count(&media_query_list->listeners);
3084     if(cnt > ARRAY_SIZE(listener_funcs_buf) && !(listener_funcs = malloc(cnt * sizeof(*listener_funcs))))
3085         return NS_ERROR_OUT_OF_MEMORY;
3086
3087     LIST_FOR_EACH_ENTRY(listener, &media_query_list->listeners, struct media_query_list_listener, entry) {
3088         listener_funcs[i] = listener->function;
3089         IDispatch_AddRef(listener_funcs[i++]);
3090     }
3091
3092     for(i = 0; i < cnt; i++) {
3093         DISPPARAMS dp = { args, NULL, 1, 0 };
3094
3095         V_VT(args) = VT_DISPATCH;
3096         V_DISPATCH(args) = (IDispatch*)&media_query_list->dispex.IDispatchEx_iface;
3097         V_VT(&v) = VT_EMPTY;
3098
3099         TRACE("%p >>>\n", media_query_list);
3100         hres = call_disp_func(listener_funcs[i], &dp, &v);
3101         if(hres == S_OK) {
3102             TRACE("%p <<< %s\n", media_query_list, debugstr_variant(&v));
3103             VariantClear(&v);
3104         }else {
3105             WARN("%p <<< %08lx\n", media_query_list, hres);
3106         }
3107         IDispatch_Release(listener_funcs[i]);
3108     }
3109
3110     if(listener_funcs != listener_funcs_buf)
3111         free(listener_funcs);
3112     return NS_OK;
3113 }
3114
3115 static const nsIDOMMediaQueryListListenerVtbl media_query_list_callback_vtbl = {
3116     media_query_list_callback_QueryInterface,
3117     media_query_list_callback_AddRef,
3118     media_query_list_callback_Release,
3119     media_query_list_callback_HandleChange
3120 };
3121
3122 static inline struct media_query_list *media_query_list_from_DispatchEx(DispatchEx *iface)
3123 {
3124     return CONTAINING_RECORD(iface, struct media_query_list, dispex);
3125 }
3126
3127 static void media_query_list_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
3128 {
3129     struct media_query_list *media_query_list = media_query_list_from_DispatchEx(dispex);
3130     struct media_query_list_listener *listener;
3131
3132     LIST_FOR_EACH_ENTRY(listener, &media_query_list->listeners, struct media_query_list_listener, entry)
3133         note_cc_edge((nsISupports*)listener->function, "function", cb);
3134     if(media_query_list->nsquerylist)
3135         note_cc_edge((nsISupports*)media_query_list->nsquerylist, "nsquerylist", cb);
3136 }
3137
3138 static void media_query_list_unlink(DispatchEx *dispex)
3139 {
3140     struct media_query_list *media_query_list = media_query_list_from_DispatchEx(dispex);
3141
3142     media_query_list->callback->media_query_list = NULL;
3143     while(!list_empty(&media_query_list->listeners)) {
3144         struct media_query_list_listener *listener = LIST_ENTRY(list_head(&media_query_list->listeners), struct media_query_list_listener, entry);
3145         list_remove(&listener->entry);
3146         IDispatch_Release(listener->function);
3147         free(listener);
3148     }
3149     unlink_ref(&media_query_list->nsquerylist);
3150 }
3151
3152 static void media_query_list_destructor(DispatchEx *dispex)
3153 {
3154     struct media_query_list *media_query_list = media_query_list_from_DispatchEx(dispex);
3155     nsIDOMMediaQueryListListener_Release(&media_query_list->callback->nsIDOMMediaQueryListListener_iface);
3156     free(media_query_list);
3157 }
3158
3159 static const dispex_static_data_vtbl_t media_query_list_dispex_vtbl = {
3160     .destructor       = media_query_list_destructor,
3161     .traverse         = media_query_list_traverse,
3162     .unlink           = media_query_list_unlink
3163 };
3164
3165 static const tid_t media_query_list_iface_tids[] = {
3166     IWineMSHTMLMediaQueryList_tid,
3167     0
3168 };
3169 static dispex_static_data_t media_query_list_dispex = {
3170     "MediaQueryList",
3171     &media_query_list_dispex_vtbl,
3172     IWineMSHTMLMediaQueryList_tid,
3173     media_query_list_iface_tids
3174 };
3175
3176 HRESULT create_media_query_list(HTMLWindow *window, BSTR media_query, IDispatch **ret)
3177 {
3178     struct media_query_list *media_query_list;
3179     nsISupports *nsunk;
3180     nsAString nsstr;
3181     nsresult nsres;
3182
3183     if(!media_query || !media_query[0])
3184         return E_INVALIDARG;
3185
3186     if(!(media_query_list = malloc(sizeof(*media_query_list))))
3187         return E_OUTOFMEMORY;
3188
3189     if(!(media_query_list->callback = malloc(sizeof(*media_query_list->callback)))) {
3190         free(media_query_list);
3191         return E_OUTOFMEMORY;
3192     }
3193     media_query_list->callback->nsIDOMMediaQueryListListener_iface.lpVtbl = &media_query_list_callback_vtbl;
3194     media_query_list->callback->media_query_list = media_query_list;
3195     media_query_list->callback->ref = 1;
3196
3197     nsAString_InitDepend(&nsstr, media_query);
3198     nsres = nsIDOMWindow_MatchMedia(window->outer_window->nswindow, &nsstr, &nsunk);
3199     nsAString_Finish(&nsstr);
3200     if(NS_FAILED(nsres)) {
3201         free(media_query_list->callback);
3202         free(media_query_list);
3203         return map_nsresult(nsres);
3204     }
3205     nsres = nsISupports_QueryInterface(nsunk, &IID_nsIDOMMediaQueryList, (void**)&media_query_list->nsquerylist);
3206     assert(NS_SUCCEEDED(nsres));
3207     nsISupports_Release(nsunk);
3208
3209     nsres = nsIDOMMediaQueryList_SetListener(media_query_list->nsquerylist, &media_query_list->callback->nsIDOMMediaQueryListListener_iface);
3210     assert(NS_SUCCEEDED(nsres));
3211
3212     media_query_list->IWineMSHTMLMediaQueryList_iface.lpVtbl = &media_query_list_vtbl;
3213     list_init(&media_query_list->listeners);
3214     init_dispatch(&media_query_list->dispex, (IUnknown*)&media_query_list->IWineMSHTMLMediaQueryList_iface,
3215                   &media_query_list_dispex, dispex_compat_mode(&window->inner_window->event_target.dispex));
3216
3217     *ret = (IDispatch*)&media_query_list->IWineMSHTMLMediaQueryList_iface;
3218     return S_OK;
3219 }