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     LONG ref;
  42
  43     HTMLPluginsCollection *plugins;
  44     HTMLMimeTypesCollection *mime_types;
  45 } OmNavigator;
  46
  47 typedef struct {
  48     DispatchEx dispex;
  49     IHTMLDOMImplementation IHTMLDOMImplementation_iface;
  50
  51     LONG ref;
  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(dispex_query_interface(&This->dispex, riid, ppv)) {
  68         return *ppv ? S_OK : E_NOINTERFACE;
  69     }else {
  70         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
  71         *ppv = NULL;
  72         return E_NOINTERFACE;
  73     }
  74
  75     IUnknown_AddRef((IUnknown*)*ppv);
  76     return S_OK;
  77 }
  78
  79 static ULONG WINAPI HTMLDOMImplementation_AddRef(IHTMLDOMImplementation *iface)
  80 {
  81     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  82     LONG ref = InterlockedIncrement(&This->ref);
  83
  84     TRACE("(%p) ref=%d\n", This, ref);
  85
  86     return ref;
  87 }
  88
  89 static ULONG WINAPI HTMLDOMImplementation_Release(IHTMLDOMImplementation *iface)
  90 {
  91     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  92     LONG ref = InterlockedDecrement(&This->ref);
  93
  94     TRACE("(%p) ref=%d\n", This, ref);
  95
  96     if(!ref) {
  97         release_dispex(&This->dispex);
  98         heap_free(This);
  99     }
 100
 101     return ref;
 102 }
 103
 104 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfoCount(IHTMLDOMImplementation *iface, UINT *pctinfo)
 105 {
 106     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 107
 108     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 109 }
 110
 111 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfo(IHTMLDOMImplementation *iface, UINT iTInfo,
 112         LCID lcid, ITypeInfo **ppTInfo)
 113 {
 114     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 115
 116     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 117 }
 118
 119 static HRESULT WINAPI HTMLDOMImplementation_GetIDsOfNames(IHTMLDOMImplementation *iface, REFIID riid,
 120         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 121 {
 122     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 123
 124     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 125             cNames, lcid, rgDispId);
 126 }
 127
 128 static HRESULT WINAPI HTMLDOMImplementation_Invoke(IHTMLDOMImplementation *iface, DISPID dispIdMember,
 129         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 130         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 131 {
 132     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 133
 134     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 135             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 136 }
 137
 138 static HRESULT WINAPI HTMLDOMImplementation_hasFeature(IHTMLDOMImplementation *iface, BSTR feature,
 139         VARIANT version, VARIANT_BOOL *pfHasFeature)
 140 {
 141     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 142
 143     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 144
 145     *pfHasFeature = VARIANT_FALSE;
 146     return S_OK;
 147 }
 148
 149 static const IHTMLDOMImplementationVtbl HTMLDOMImplementationVtbl = {
 150     HTMLDOMImplementation_QueryInterface,
 151     HTMLDOMImplementation_AddRef,
 152     HTMLDOMImplementation_Release,
 153     HTMLDOMImplementation_GetTypeInfoCount,
 154     HTMLDOMImplementation_GetTypeInfo,
 155     HTMLDOMImplementation_GetIDsOfNames,
 156     HTMLDOMImplementation_Invoke,
 157     HTMLDOMImplementation_hasFeature
 158 };
 159
 160 static const tid_t HTMLDOMImplementation_iface_tids[] = {
 161     IHTMLDOMImplementation_tid,
 162     0
 163 };
 164 static dispex_static_data_t HTMLDOMImplementation_dispex = {
 165     NULL,
 166     IHTMLDOMImplementation_tid,
 167     HTMLDOMImplementation_iface_tids
 168 };
 169
 170 HRESULT create_dom_implementation(IHTMLDOMImplementation **ret)
 171 {
 172     HTMLDOMImplementation *dom_implementation;
 173
 174     dom_implementation = heap_alloc_zero(sizeof(*dom_implementation));
 175     if(!dom_implementation)
 176         return E_OUTOFMEMORY;
 177
 178     dom_implementation->IHTMLDOMImplementation_iface.lpVtbl = &HTMLDOMImplementationVtbl;
 179     dom_implementation->ref = 1;
 180
 181     init_dispex(&dom_implementation->dispex, (IUnknown*)&dom_implementation->IHTMLDOMImplementation_iface,
 182             &HTMLDOMImplementation_dispex);
 183
 184     *ret = &dom_implementation->IHTMLDOMImplementation_iface;
 185     return S_OK;
 186 }
 187
 188 typedef struct {
 189     DispatchEx dispex;
 190     IHTMLScreen IHTMLScreen_iface;
 191
 192     LONG ref;
 193 } HTMLScreen;
 194
 195 static inline HTMLScreen *impl_from_IHTMLScreen(IHTMLScreen *iface)
 196 {
 197     return CONTAINING_RECORD(iface, HTMLScreen, IHTMLScreen_iface);
 198 }
 199
 200 static HRESULT WINAPI HTMLScreen_QueryInterface(IHTMLScreen *iface, REFIID riid, void **ppv)
 201 {
 202     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 203
 204     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 205
 206     if(IsEqualGUID(&IID_IUnknown, riid)) {
 207         *ppv = &This->IHTMLScreen_iface;
 208     }else if(IsEqualGUID(&IID_IHTMLScreen, riid)) {
 209         *ppv = &This->IHTMLScreen_iface;
 210     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 211         return *ppv ? S_OK : E_NOINTERFACE;
 212     }else {
 213         *ppv = NULL;
 214         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 215         return E_NOINTERFACE;
 216     }
 217
 218     IUnknown_AddRef((IUnknown*)*ppv);
 219     return S_OK;
 220 }
 221
 222 static ULONG WINAPI HTMLScreen_AddRef(IHTMLScreen *iface)
 223 {
 224     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 225     LONG ref = InterlockedIncrement(&This->ref);
 226
 227     TRACE("(%p) ref=%d\n", This, ref);
 228
 229     return ref;
 230 }
 231
 232 static ULONG WINAPI HTMLScreen_Release(IHTMLScreen *iface)
 233 {
 234     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 235     LONG ref = InterlockedDecrement(&This->ref);
 236
 237     TRACE("(%p) ref=%d\n", This, ref);
 238
 239     if(!ref) {
 240         release_dispex(&This->dispex);
 241         heap_free(This);
 242     }
 243
 244     return ref;
 245 }
 246
 247 static HRESULT WINAPI HTMLScreen_GetTypeInfoCount(IHTMLScreen *iface, UINT *pctinfo)
 248 {
 249     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 250     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 251 }
 252
 253 static HRESULT WINAPI HTMLScreen_GetTypeInfo(IHTMLScreen *iface, UINT iTInfo,
 254         LCID lcid, ITypeInfo **ppTInfo)
 255 {
 256     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 257     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 258 }
 259
 260 static HRESULT WINAPI HTMLScreen_GetIDsOfNames(IHTMLScreen *iface, REFIID riid,
 261         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 262 {
 263     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 264     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 265             lcid, rgDispId);
 266 }
 267
 268 static HRESULT WINAPI HTMLScreen_Invoke(IHTMLScreen *iface, DISPID dispIdMember,
 269         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 270         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 271 {
 272     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 273     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 274             pDispParams, pVarResult, pExcepInfo, puArgErr);
 275 }
 276
 277 static HRESULT WINAPI HTMLScreen_get_colorDepth(IHTMLScreen *iface, LONG *p)
 278 {
 279     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 280     HDC hdc = GetDC(0);
 281
 282     TRACE("(%p)->(%p)\n", This, p);
 283
 284     *p = GetDeviceCaps(hdc, BITSPIXEL);
 285     ReleaseDC(0, hdc);
 286     return S_OK;
 287 }
 288
 289 static HRESULT WINAPI HTMLScreen_put_bufferDepth(IHTMLScreen *iface, LONG v)
 290 {
 291     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 292     FIXME("(%p)->(%d)\n", This, v);
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI HTMLScreen_get_bufferDepth(IHTMLScreen *iface, LONG *p)
 297 {
 298     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 299     FIXME("(%p)->(%p)\n", This, p);
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI HTMLScreen_get_width(IHTMLScreen *iface, LONG *p)
 304 {
 305     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 306
 307     TRACE("(%p)->(%p)\n", This, p);
 308
 309     *p = GetSystemMetrics(SM_CXSCREEN);
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI HTMLScreen_get_height(IHTMLScreen *iface, LONG *p)
 314 {
 315     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 316
 317     TRACE("(%p)->(%p)\n", This, p);
 318
 319     *p = GetSystemMetrics(SM_CYSCREEN);
 320     return S_OK;
 321 }
 322
 323 static HRESULT WINAPI HTMLScreen_put_updateInterval(IHTMLScreen *iface, LONG v)
 324 {
 325     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 326     FIXME("(%p)->(%d)\n", This, v);
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT WINAPI HTMLScreen_get_updateInterval(IHTMLScreen *iface, LONG *p)
 331 {
 332     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 333     FIXME("(%p)->(%p)\n", This, p);
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI HTMLScreen_get_availHeight(IHTMLScreen *iface, LONG *p)
 338 {
 339     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 340     RECT work_area;
 341
 342     TRACE("(%p)->(%p)\n", This, p);
 343
 344     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 345         return E_FAIL;
 346
 347     *p = work_area.bottom-work_area.top;
 348     return S_OK;
 349 }
 350
 351 static HRESULT WINAPI HTMLScreen_get_availWidth(IHTMLScreen *iface, LONG *p)
 352 {
 353     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 354     RECT work_area;
 355
 356     TRACE("(%p)->(%p)\n", This, p);
 357
 358     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 359         return E_FAIL;
 360
 361     *p = work_area.right-work_area.left;
 362     return S_OK;
 363 }
 364
 365 static HRESULT WINAPI HTMLScreen_get_fontSmoothingEnabled(IHTMLScreen *iface, VARIANT_BOOL *p)
 366 {
 367     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 368     FIXME("(%p)->(%p)\n", This, p);
 369     return E_NOTIMPL;
 370 }
 371
 372 static const IHTMLScreenVtbl HTMLSreenVtbl = {
 373     HTMLScreen_QueryInterface,
 374     HTMLScreen_AddRef,
 375     HTMLScreen_Release,
 376     HTMLScreen_GetTypeInfoCount,
 377     HTMLScreen_GetTypeInfo,
 378     HTMLScreen_GetIDsOfNames,
 379     HTMLScreen_Invoke,
 380     HTMLScreen_get_colorDepth,
 381     HTMLScreen_put_bufferDepth,
 382     HTMLScreen_get_bufferDepth,
 383     HTMLScreen_get_width,
 384     HTMLScreen_get_height,
 385     HTMLScreen_put_updateInterval,
 386     HTMLScreen_get_updateInterval,
 387     HTMLScreen_get_availHeight,
 388     HTMLScreen_get_availWidth,
 389     HTMLScreen_get_fontSmoothingEnabled
 390 };
 391
 392 static const tid_t HTMLScreen_iface_tids[] = {
 393     IHTMLScreen_tid,
 394     0
 395 };
 396 static dispex_static_data_t HTMLScreen_dispex = {
 397     NULL,
 398     DispHTMLScreen_tid,
 399     HTMLScreen_iface_tids
 400 };
 401
 402 HRESULT HTMLScreen_Create(IHTMLScreen **ret)
 403 {
 404     HTMLScreen *screen;
 405
 406     screen = heap_alloc_zero(sizeof(HTMLScreen));
 407     if(!screen)
 408         return E_OUTOFMEMORY;
 409
 410     screen->IHTMLScreen_iface.lpVtbl = &HTMLSreenVtbl;
 411     screen->ref = 1;
 412
 413     init_dispex(&screen->dispex, (IUnknown*)&screen->IHTMLScreen_iface, &HTMLScreen_dispex);
 414
 415     *ret = &screen->IHTMLScreen_iface;
 416     return S_OK;
 417 }
 418
 419 static inline OmHistory *impl_from_IOmHistory(IOmHistory *iface)
 420 {
 421     return CONTAINING_RECORD(iface, OmHistory, IOmHistory_iface);
 422 }
 423
 424 static HRESULT WINAPI OmHistory_QueryInterface(IOmHistory *iface, REFIID riid, void **ppv)
 425 {
 426     OmHistory *This = impl_from_IOmHistory(iface);
 427
 428     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 429
 430     if(IsEqualGUID(&IID_IUnknown, riid)) {
 431         *ppv = &This->IOmHistory_iface;
 432     }else if(IsEqualGUID(&IID_IOmHistory, riid)) {
 433         *ppv = &This->IOmHistory_iface;
 434     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 435         return *ppv ? S_OK : E_NOINTERFACE;
 436     }else {
 437         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 438         *ppv = NULL;
 439         return E_NOINTERFACE;
 440     }
 441
 442     IUnknown_AddRef((IUnknown*)*ppv);
 443     return S_OK;
 444 }
 445
 446 static ULONG WINAPI OmHistory_AddRef(IOmHistory *iface)
 447 {
 448     OmHistory *This = impl_from_IOmHistory(iface);
 449     LONG ref = InterlockedIncrement(&This->ref);
 450
 451     TRACE("(%p) ref=%d\n", This, ref);
 452
 453     return ref;
 454 }
 455
 456 static ULONG WINAPI OmHistory_Release(IOmHistory *iface)
 457 {
 458     OmHistory *This = impl_from_IOmHistory(iface);
 459     LONG ref = InterlockedDecrement(&This->ref);
 460
 461     TRACE("(%p) ref=%d\n", This, ref);
 462
 463     if(!ref) {
 464         release_dispex(&This->dispex);
 465         heap_free(This);
 466     }
 467
 468     return ref;
 469 }
 470
 471 static HRESULT WINAPI OmHistory_GetTypeInfoCount(IOmHistory *iface, UINT *pctinfo)
 472 {
 473     OmHistory *This = impl_from_IOmHistory(iface);
 474     FIXME("(%p)->(%p)\n", This, pctinfo);
 475     return E_NOTIMPL;
 476 }
 477
 478 static HRESULT WINAPI OmHistory_GetTypeInfo(IOmHistory *iface, UINT iTInfo,
 479         LCID lcid, ITypeInfo **ppTInfo)
 480 {
 481     OmHistory *This = impl_from_IOmHistory(iface);
 482
 483     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 484 }
 485
 486 static HRESULT WINAPI OmHistory_GetIDsOfNames(IOmHistory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 487         LCID lcid, DISPID *rgDispId)
 488 {
 489     OmHistory *This = impl_from_IOmHistory(iface);
 490
 491     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 492             lcid, rgDispId);
 493 }
 494
 495 static HRESULT WINAPI OmHistory_Invoke(IOmHistory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 496         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 497 {
 498     OmHistory *This = impl_from_IOmHistory(iface);
 499
 500     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 501             pDispParams, pVarResult, pExcepInfo, puArgErr);
 502 }
 503
 504 static HRESULT WINAPI OmHistory_get_length(IOmHistory *iface, short *p)
 505 {
 506     OmHistory *This = impl_from_IOmHistory(iface);
 507
 508     TRACE("(%p)->(%p)\n", This, p);
 509
 510     if(!This->window || !This->window->base.outer_window->doc_obj
 511             || !This->window->base.outer_window->doc_obj->travel_log) {
 512         *p = 0;
 513     }else {
 514         *p = ITravelLog_CountEntries(This->window->base.outer_window->doc_obj->travel_log,
 515                 This->window->base.outer_window->doc_obj->browser_service);
 516     }
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI OmHistory_back(IOmHistory *iface, VARIANT *pvargdistance)
 521 {
 522     OmHistory *This = impl_from_IOmHistory(iface);
 523     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI OmHistory_forward(IOmHistory *iface, VARIANT *pvargdistance)
 528 {
 529     OmHistory *This = impl_from_IOmHistory(iface);
 530     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 531     return E_NOTIMPL;
 532 }
 533
 534 static HRESULT WINAPI OmHistory_go(IOmHistory *iface, VARIANT *pvargdistance)
 535 {
 536     OmHistory *This = impl_from_IOmHistory(iface);
 537     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 538     return E_NOTIMPL;
 539 }
 540
 541 static const IOmHistoryVtbl OmHistoryVtbl = {
 542     OmHistory_QueryInterface,
 543     OmHistory_AddRef,
 544     OmHistory_Release,
 545     OmHistory_GetTypeInfoCount,
 546     OmHistory_GetTypeInfo,
 547     OmHistory_GetIDsOfNames,
 548     OmHistory_Invoke,
 549     OmHistory_get_length,
 550     OmHistory_back,
 551     OmHistory_forward,
 552     OmHistory_go
 553 };
 554
 555 static const tid_t OmHistory_iface_tids[] = {
 556     IOmHistory_tid,
 557     0
 558 };
 559 static dispex_static_data_t OmHistory_dispex = {
 560     NULL,
 561     DispHTMLHistory_tid,
 562     OmHistory_iface_tids
 563 };
 564
 565
 566 HRESULT create_history(HTMLInnerWindow *window, OmHistory **ret)
 567 {
 568     OmHistory *history;
 569
 570     history = heap_alloc_zero(sizeof(*history));
 571     if(!history)
 572         return E_OUTOFMEMORY;
 573
 574     init_dispex(&history->dispex, (IUnknown*)&history->IOmHistory_iface, &OmHistory_dispex);
 575     history->IOmHistory_iface.lpVtbl = &OmHistoryVtbl;
 576     history->ref = 1;
 577
 578     history->window = window;
 579
 580     *ret = history;
 581     return S_OK;
 582 }
 583
 584 struct HTMLPluginsCollection {
 585     DispatchEx dispex;
 586     IHTMLPluginsCollection IHTMLPluginsCollection_iface;
 587
 588     LONG ref;
 589
 590     OmNavigator *navigator;
 591 };
 592
 593 static inline HTMLPluginsCollection *impl_from_IHTMLPluginsCollection(IHTMLPluginsCollection *iface)
 594 {
 595     return CONTAINING_RECORD(iface, HTMLPluginsCollection, IHTMLPluginsCollection_iface);
 596 }
 597
 598 static HRESULT WINAPI HTMLPluginsCollection_QueryInterface(IHTMLPluginsCollection *iface, REFIID riid, void **ppv)
 599 {
 600     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 601
 602     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 603
 604     if(IsEqualGUID(&IID_IUnknown, riid)) {
 605         *ppv = &This->IHTMLPluginsCollection_iface;
 606     }else if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid)) {
 607         *ppv = &This->IHTMLPluginsCollection_iface;
 608     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 609         return *ppv ? S_OK : E_NOINTERFACE;
 610     }else {
 611         *ppv = NULL;
 612         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 613         return E_NOINTERFACE;
 614     }
 615
 616     IUnknown_AddRef((IUnknown*)*ppv);
 617     return S_OK;
 618 }
 619
 620 static ULONG WINAPI HTMLPluginsCollection_AddRef(IHTMLPluginsCollection *iface)
 621 {
 622     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 623     LONG ref = InterlockedIncrement(&This->ref);
 624
 625     TRACE("(%p) ref=%d\n", This, ref);
 626
 627     return ref;
 628 }
 629
 630 static ULONG WINAPI HTMLPluginsCollection_Release(IHTMLPluginsCollection *iface)
 631 {
 632     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 633     LONG ref = InterlockedDecrement(&This->ref);
 634
 635     TRACE("(%p) ref=%d\n", This, ref);
 636
 637     if(!ref) {
 638         if(This->navigator)
 639             This->navigator->plugins = NULL;
 640         release_dispex(&This->dispex);
 641         heap_free(This);
 642     }
 643
 644     return ref;
 645 }
 646
 647 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfoCount(IHTMLPluginsCollection *iface, UINT *pctinfo)
 648 {
 649     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 650     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 651 }
 652
 653 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfo(IHTMLPluginsCollection *iface, UINT iTInfo,
 654                                               LCID lcid, ITypeInfo **ppTInfo)
 655 {
 656     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 657     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 658 }
 659
 660 static HRESULT WINAPI HTMLPluginsCollection_GetIDsOfNames(IHTMLPluginsCollection *iface, REFIID riid,
 661         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 662 {
 663     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 664     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 665             lcid, rgDispId);
 666 }
 667
 668 static HRESULT WINAPI HTMLPluginsCollection_Invoke(IHTMLPluginsCollection *iface, DISPID dispIdMember,
 669         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 670         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 671 {
 672     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 673     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 674             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 675 }
 676
 677 static HRESULT WINAPI HTMLPluginsCollection_get_length(IHTMLPluginsCollection *iface, LONG *p)
 678 {
 679     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 680
 681     TRACE("(%p)->(%p)\n", This, p);
 682
 683     /* IE always returns 0 here */
 684     *p = 0;
 685     return S_OK;
 686 }
 687
 688 static HRESULT WINAPI HTMLPluginsCollection_refresh(IHTMLPluginsCollection *iface, VARIANT_BOOL reload)
 689 {
 690     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 691
 692     TRACE("(%p)->(%x)\n", This, reload);
 693
 694     /* Nothing to do here. */
 695     return S_OK;
 696 }
 697
 698 static const IHTMLPluginsCollectionVtbl HTMLPluginsCollectionVtbl = {
 699     HTMLPluginsCollection_QueryInterface,
 700     HTMLPluginsCollection_AddRef,
 701     HTMLPluginsCollection_Release,
 702     HTMLPluginsCollection_GetTypeInfoCount,
 703     HTMLPluginsCollection_GetTypeInfo,
 704     HTMLPluginsCollection_GetIDsOfNames,
 705     HTMLPluginsCollection_Invoke,
 706     HTMLPluginsCollection_get_length,
 707     HTMLPluginsCollection_refresh
 708 };
 709
 710 static const tid_t HTMLPluginsCollection_iface_tids[] = {
 711     IHTMLPluginsCollection_tid,
 712     0
 713 };
 714 static dispex_static_data_t HTMLPluginsCollection_dispex = {
 715     NULL,
 716     DispCPlugins_tid,
 717     HTMLPluginsCollection_iface_tids
 718 };
 719
 720 static HRESULT create_plugins_collection(OmNavigator *navigator, HTMLPluginsCollection **ret)
 721 {
 722     HTMLPluginsCollection *col;
 723
 724     col = heap_alloc_zero(sizeof(*col));
 725     if(!col)
 726         return E_OUTOFMEMORY;
 727
 728     col->IHTMLPluginsCollection_iface.lpVtbl = &HTMLPluginsCollectionVtbl;
 729     col->ref = 1;
 730     col->navigator = navigator;
 731
 732     init_dispex(&col->dispex, (IUnknown*)&col->IHTMLPluginsCollection_iface,
 733                 &HTMLPluginsCollection_dispex);
 734
 735     *ret = col;
 736     return S_OK;
 737 }
 738
 739 struct HTMLMimeTypesCollection {
 740     DispatchEx dispex;
 741     IHTMLMimeTypesCollection IHTMLMimeTypesCollection_iface;
 742
 743     LONG ref;
 744
 745     OmNavigator *navigator;
 746 };
 747
 748 static inline HTMLMimeTypesCollection *impl_from_IHTMLMimeTypesCollection(IHTMLMimeTypesCollection *iface)
 749 {
 750     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, IHTMLMimeTypesCollection_iface);
 751 }
 752
 753 static HRESULT WINAPI HTMLMimeTypesCollection_QueryInterface(IHTMLMimeTypesCollection *iface, REFIID riid, void **ppv)
 754 {
 755     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 756
 757     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 758
 759     if(IsEqualGUID(&IID_IUnknown, riid)) {
 760         *ppv = &This->IHTMLMimeTypesCollection_iface;
 761     }else if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid)) {
 762         *ppv = &This->IHTMLMimeTypesCollection_iface;
 763     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 764         return *ppv ? S_OK : E_NOINTERFACE;
 765     }else {
 766         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 767         *ppv = NULL;
 768         return E_NOINTERFACE;
 769     }
 770
 771     IUnknown_AddRef((IUnknown*)*ppv);
 772     return S_OK;
 773 }
 774
 775 static ULONG WINAPI HTMLMimeTypesCollection_AddRef(IHTMLMimeTypesCollection *iface)
 776 {
 777     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 778     LONG ref = InterlockedIncrement(&This->ref);
 779
 780     TRACE("(%p) ref=%d\n", This, ref);
 781
 782     return ref;
 783 }
 784
 785 static ULONG WINAPI HTMLMimeTypesCollection_Release(IHTMLMimeTypesCollection *iface)
 786 {
 787     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 788     LONG ref = InterlockedDecrement(&This->ref);
 789
 790     TRACE("(%p) ref=%d\n", This, ref);
 791
 792     if(!ref) {
 793         if(This->navigator)
 794             This->navigator->mime_types = NULL;
 795         release_dispex(&This->dispex);
 796         heap_free(This);
 797     }
 798
 799     return ref;
 800 }
 801
 802 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfoCount(IHTMLMimeTypesCollection *iface, UINT *pctinfo)
 803 {
 804     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 805     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 806 }
 807
 808 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfo(IHTMLMimeTypesCollection *iface, UINT iTInfo,
 809                                               LCID lcid, ITypeInfo **ppTInfo)
 810 {
 811     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 812     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 813 }
 814
 815 static HRESULT WINAPI HTMLMimeTypesCollection_GetIDsOfNames(IHTMLMimeTypesCollection *iface, REFIID riid,
 816         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 817 {
 818     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 819     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 820             lcid, rgDispId);
 821 }
 822
 823 static HRESULT WINAPI HTMLMimeTypesCollection_Invoke(IHTMLMimeTypesCollection *iface, DISPID dispIdMember,
 824         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 825         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 826 {
 827     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 828     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 829             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 830 }
 831
 832 static HRESULT WINAPI HTMLMimeTypesCollection_get_length(IHTMLMimeTypesCollection *iface, LONG *p)
 833 {
 834     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 835
 836     TRACE("(%p)->(%p)\n", This, p);
 837
 838     /* This is just a stub for compatibility with other browser in IE */
 839     *p = 0;
 840     return S_OK;
 841 }
 842
 843 static const IHTMLMimeTypesCollectionVtbl HTMLMimeTypesCollectionVtbl = {
 844     HTMLMimeTypesCollection_QueryInterface,
 845     HTMLMimeTypesCollection_AddRef,
 846     HTMLMimeTypesCollection_Release,
 847     HTMLMimeTypesCollection_GetTypeInfoCount,
 848     HTMLMimeTypesCollection_GetTypeInfo,
 849     HTMLMimeTypesCollection_GetIDsOfNames,
 850     HTMLMimeTypesCollection_Invoke,
 851     HTMLMimeTypesCollection_get_length
 852 };
 853
 854 static const tid_t HTMLMimeTypesCollection_iface_tids[] = {
 855     IHTMLMimeTypesCollection_tid,
 856     0
 857 };
 858 static dispex_static_data_t HTMLMimeTypesCollection_dispex = {
 859     NULL,
 860     IHTMLMimeTypesCollection_tid,
 861     HTMLMimeTypesCollection_iface_tids
 862 };
 863
 864 static HRESULT create_mime_types_collection(OmNavigator *navigator, HTMLMimeTypesCollection **ret)
 865 {
 866     HTMLMimeTypesCollection *col;
 867
 868     col = heap_alloc_zero(sizeof(*col));
 869     if(!col)
 870         return E_OUTOFMEMORY;
 871
 872     col->IHTMLMimeTypesCollection_iface.lpVtbl = &HTMLMimeTypesCollectionVtbl;
 873     col->ref = 1;
 874     col->navigator = navigator;
 875
 876     init_dispex(&col->dispex, (IUnknown*)&col->IHTMLMimeTypesCollection_iface,
 877                 &HTMLMimeTypesCollection_dispex);
 878
 879     *ret = col;
 880     return S_OK;
 881 }
 882
 883 static inline OmNavigator *impl_from_IOmNavigator(IOmNavigator *iface)
 884 {
 885     return CONTAINING_RECORD(iface, OmNavigator, IOmNavigator_iface);
 886 }
 887
 888 static HRESULT WINAPI OmNavigator_QueryInterface(IOmNavigator *iface, REFIID riid, void **ppv)
 889 {
 890     OmNavigator *This = impl_from_IOmNavigator(iface);
 891
 892     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 893
 894     if(IsEqualGUID(&IID_IUnknown, riid)) {
 895         *ppv = &This->IOmNavigator_iface;
 896     }else if(IsEqualGUID(&IID_IOmNavigator, riid)) {
 897         *ppv = &This->IOmNavigator_iface;
 898     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 899         return *ppv ? S_OK : E_NOINTERFACE;
 900     }else {
 901         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 902         *ppv = NULL;
 903         return E_NOINTERFACE;
 904     }
 905
 906     IUnknown_AddRef((IUnknown*)*ppv);
 907     return S_OK;
 908 }
 909
 910 static ULONG WINAPI OmNavigator_AddRef(IOmNavigator *iface)
 911 {
 912     OmNavigator *This = impl_from_IOmNavigator(iface);
 913     LONG ref = InterlockedIncrement(&This->ref);
 914
 915     TRACE("(%p) ref=%d\n", This, ref);
 916
 917     return ref;
 918 }
 919
 920 static ULONG WINAPI OmNavigator_Release(IOmNavigator *iface)
 921 {
 922     OmNavigator *This = impl_from_IOmNavigator(iface);
 923     LONG ref = InterlockedDecrement(&This->ref);
 924
 925     TRACE("(%p) ref=%d\n", This, ref);
 926
 927     if(!ref) {
 928         if(This->plugins)
 929             This->plugins->navigator = NULL;
 930         if(This->mime_types)
 931             This->mime_types->navigator = NULL;
 932         release_dispex(&This->dispex);
 933         heap_free(This);
 934     }
 935
 936     return ref;
 937 }
 938
 939 static HRESULT WINAPI OmNavigator_GetTypeInfoCount(IOmNavigator *iface, UINT *pctinfo)
 940 {
 941     OmNavigator *This = impl_from_IOmNavigator(iface);
 942     FIXME("(%p)->(%p)\n", This, pctinfo);
 943     return E_NOTIMPL;
 944 }
 945
 946 static HRESULT WINAPI OmNavigator_GetTypeInfo(IOmNavigator *iface, UINT iTInfo,
 947                                               LCID lcid, ITypeInfo **ppTInfo)
 948 {
 949     OmNavigator *This = impl_from_IOmNavigator(iface);
 950
 951     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 952 }
 953
 954 static HRESULT WINAPI OmNavigator_GetIDsOfNames(IOmNavigator *iface, REFIID riid,
 955                                                 LPOLESTR *rgszNames, UINT cNames,
 956                                                 LCID lcid, DISPID *rgDispId)
 957 {
 958     OmNavigator *This = impl_from_IOmNavigator(iface);
 959
 960     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 961             lcid, rgDispId);
 962 }
 963
 964 static HRESULT WINAPI OmNavigator_Invoke(IOmNavigator *iface, DISPID dispIdMember,
 965                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 966                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 967 {
 968     OmNavigator *This = impl_from_IOmNavigator(iface);
 969
 970     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 971             pDispParams, pVarResult, pExcepInfo, puArgErr);
 972 }
 973
 974 static HRESULT WINAPI OmNavigator_get_appCodeName(IOmNavigator *iface, BSTR *p)
 975 {
 976     OmNavigator *This = impl_from_IOmNavigator(iface);
 977
 978     static const WCHAR mozillaW[] = {'M','o','z','i','l','l','a',0};
 979
 980     TRACE("(%p)->(%p)\n", This, p);
 981
 982     *p = SysAllocString(mozillaW);
 983     return S_OK;
 984 }
 985
 986 static HRESULT WINAPI OmNavigator_get_appName(IOmNavigator *iface, BSTR *p)
 987 {
 988     OmNavigator *This = impl_from_IOmNavigator(iface);
 989
 990     static const WCHAR app_nameW[] =
 991         {'M','i','c','r','o','s','o','f','t',' ',
 992          'I','n','t','e','r','n','e','t',' ',
 993          'E','x','p','l','o','r','e','r',0};
 994
 995     TRACE("(%p)->(%p)\n", This, p);
 996
 997     *p = SysAllocString(app_nameW);
 998     if(!*p)
 999         return E_OUTOFMEMORY;
1000
1001     return S_OK;
1002 }
1003
1004 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
1005 {
1006     OmNavigator *This = impl_from_IOmNavigator(iface);
1007
1008     char user_agent[512];
1009     DWORD size;
1010     HRESULT hres;
1011
1012     TRACE("(%p)->(%p)\n", This, p);
1013
1014     size = sizeof(user_agent);
1015     hres = ObtainUserAgentString(0, user_agent, &size);
1016     if(FAILED(hres))
1017         return hres;
1018
1019     if(strncmp(user_agent, "Mozilla/", 8)) {
1020         FIXME("Unsupported user agent\n");
1021         return E_FAIL;
1022     }
1023
1024     size = MultiByteToWideChar(CP_ACP, 0, user_agent+8, -1, NULL, 0);
1025     *p = SysAllocStringLen(NULL, size-1);
1026     if(!*p)
1027         return E_OUTOFMEMORY;
1028
1029     MultiByteToWideChar(CP_ACP, 0, user_agent+8, -1, *p, size);
1030     return S_OK;
1031 }
1032
1033 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
1034 {
1035     OmNavigator *This = impl_from_IOmNavigator(iface);
1036     char user_agent[512];
1037     DWORD size;
1038     HRESULT hres;
1039
1040     TRACE("(%p)->(%p)\n", This, p);
1041
1042     size = sizeof(user_agent);
1043     hres = ObtainUserAgentString(0, user_agent, &size);
1044     if(FAILED(hres))
1045         return hres;
1046
1047     size = MultiByteToWideChar(CP_ACP, 0, user_agent, -1, NULL, 0);
1048     *p = SysAllocStringLen(NULL, size-1);
1049     if(!*p)
1050         return E_OUTOFMEMORY;
1051
1052     MultiByteToWideChar(CP_ACP, 0, user_agent, -1, *p, size);
1053     return S_OK;
1054 }
1055
1056 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1057 {
1058     OmNavigator *This = impl_from_IOmNavigator(iface);
1059
1060     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
1061
1062     *enabled = VARIANT_TRUE;
1063     return S_OK;
1064 }
1065
1066 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1067 {
1068     OmNavigator *This = impl_from_IOmNavigator(iface);
1069     FIXME("(%p)->(%p)\n", This, enabled);
1070     return E_NOTIMPL;
1071 }
1072
1073 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
1074 {
1075     OmNavigator *This = impl_from_IOmNavigator(iface);
1076
1077     TRACE("(%p)->(%p)\n", This, p);
1078
1079     if(!This->mime_types) {
1080         HRESULT hres;
1081
1082         hres = create_mime_types_collection(This, &This->mime_types);
1083         if(FAILED(hres))
1084             return hres;
1085     }else {
1086         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
1087     }
1088
1089     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
1090     return S_OK;
1091 }
1092
1093 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
1094 {
1095     OmNavigator *This = impl_from_IOmNavigator(iface);
1096
1097     TRACE("(%p)->(%p)\n", This, p);
1098
1099     if(!This->plugins) {
1100         HRESULT hres;
1101
1102         hres = create_plugins_collection(This, &This->plugins);
1103         if(FAILED(hres))
1104             return hres;
1105     }else {
1106         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
1107     }
1108
1109     *p = &This->plugins->IHTMLPluginsCollection_iface;
1110     return S_OK;
1111 }
1112
1113 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
1114 {
1115     OmNavigator *This = impl_from_IOmNavigator(iface);
1116
1117     WARN("(%p)->(%p) semi-stub\n", This, p);
1118
1119     *p = VARIANT_TRUE;
1120     return S_OK;
1121 }
1122
1123 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1124 {
1125     OmNavigator *This = impl_from_IOmNavigator(iface);
1126     FIXME("(%p)->(%p)\n", This, p);
1127     return E_NOTIMPL;
1128 }
1129
1130 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
1131 {
1132     OmNavigator *This = impl_from_IOmNavigator(iface);
1133
1134     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
1135
1136     TRACE("(%p)->(%p)\n", This, String);
1137
1138     if(!String)
1139         return E_INVALIDARG;
1140
1141     *String = SysAllocString(objectW);
1142     return *String ? S_OK : E_OUTOFMEMORY;
1143 }
1144
1145 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
1146 {
1147     OmNavigator *This = impl_from_IOmNavigator(iface);
1148
1149     static const WCHAR cpu_classW[] =
1150 #ifdef _WIN64
1151         {'x','6','4',0};
1152 #else
1153         {'x','8','6',0};
1154 #endif
1155
1156     TRACE("(%p)->(%p)\n", This, p);
1157
1158     *p = SysAllocString(cpu_classW);
1159     return *p ? S_OK : E_OUTOFMEMORY;
1160 }
1161
1162 static HRESULT get_language_string(LCID lcid, BSTR *p)
1163 {
1164     BSTR ret;
1165     int len;
1166
1167     len = LCIDToLocaleName(lcid, NULL, 0, 0);
1168     if(!len) {
1169         WARN("LCIDToLocaleName failed: %u\n", GetLastError());
1170         return E_FAIL;
1171     }
1172
1173     ret = SysAllocStringLen(NULL, len-1);
1174     if(!ret)
1175         return E_OUTOFMEMORY;
1176
1177     len = LCIDToLocaleName(lcid, ret, len, 0);
1178     if(!len) {
1179         WARN("LCIDToLocaleName failed: %u\n", GetLastError());
1180         SysFreeString(ret);
1181         return E_FAIL;
1182     }
1183
1184     *p = ret;
1185     return S_OK;
1186 }
1187
1188 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
1189 {
1190     OmNavigator *This = impl_from_IOmNavigator(iface);
1191
1192     TRACE("(%p)->(%p)\n", This, p);
1193
1194     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
1195 }
1196
1197 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
1198 {
1199     OmNavigator *This = impl_from_IOmNavigator(iface);
1200
1201     TRACE("(%p)->(%p)\n", This, p);
1202
1203     return get_language_string(GetUserDefaultUILanguage(), p);
1204 }
1205
1206 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
1207 {
1208     OmNavigator *This = impl_from_IOmNavigator(iface);
1209
1210     TRACE("(%p)->(%p)\n", This, p);
1211
1212     return get_language_string(LOCALE_USER_DEFAULT, p);
1213 }
1214
1215 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
1216 {
1217     OmNavigator *This = impl_from_IOmNavigator(iface);
1218
1219 #ifdef _WIN64
1220     static const WCHAR platformW[] = {'W','i','n','6','4',0};
1221 #else
1222     static const WCHAR platformW[] = {'W','i','n','3','2',0};
1223 #endif
1224
1225     TRACE("(%p)->(%p)\n", This, p);
1226
1227     *p = SysAllocString(platformW);
1228     return S_OK;
1229 }
1230
1231 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1232 {
1233     OmNavigator *This = impl_from_IOmNavigator(iface);
1234
1235     static const WCHAR zeroW[] = {'0',0};
1236
1237     TRACE("(%p)->(%p)\n", This, p);
1238
1239     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1240     *p = SysAllocString(zeroW);
1241     return S_OK;
1242 }
1243
1244 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1245 {
1246     OmNavigator *This = impl_from_IOmNavigator(iface);
1247     FIXME("(%p)->(%p)\n", This, p);
1248     return E_NOTIMPL;
1249 }
1250
1251 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1252 {
1253     OmNavigator *This = impl_from_IOmNavigator(iface);
1254
1255     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1256
1257     *p = VARIANT_TRUE;
1258     return S_OK;
1259 }
1260
1261 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1262 {
1263     OmNavigator *This = impl_from_IOmNavigator(iface);
1264     FIXME("(%p)->(%p)\n", This, p);
1265     return E_NOTIMPL;
1266 }
1267
1268 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1269     OmNavigator_QueryInterface,
1270     OmNavigator_AddRef,
1271     OmNavigator_Release,
1272     OmNavigator_GetTypeInfoCount,
1273     OmNavigator_GetTypeInfo,
1274     OmNavigator_GetIDsOfNames,
1275     OmNavigator_Invoke,
1276     OmNavigator_get_appCodeName,
1277     OmNavigator_get_appName,
1278     OmNavigator_get_appVersion,
1279     OmNavigator_get_userAgent,
1280     OmNavigator_javaEnabled,
1281     OmNavigator_taintEnabled,
1282     OmNavigator_get_mimeTypes,
1283     OmNavigator_get_plugins,
1284     OmNavigator_get_cookieEnabled,
1285     OmNavigator_get_opsProfile,
1286     OmNavigator_toString,
1287     OmNavigator_get_cpuClass,
1288     OmNavigator_get_systemLanguage,
1289     OmNavigator_get_browserLanguage,
1290     OmNavigator_get_userLanguage,
1291     OmNavigator_get_platform,
1292     OmNavigator_get_appMinorVersion,
1293     OmNavigator_get_connectionSpeed,
1294     OmNavigator_get_onLine,
1295     OmNavigator_get_userProfile
1296 };
1297
1298 static const tid_t OmNavigator_iface_tids[] = {
1299     IOmNavigator_tid,
1300     0
1301 };
1302 static dispex_static_data_t OmNavigator_dispex = {
1303     NULL,
1304     DispHTMLNavigator_tid,
1305     OmNavigator_iface_tids
1306 };
1307
1308 IOmNavigator *OmNavigator_Create(void)
1309 {
1310     OmNavigator *ret;
1311
1312     ret = heap_alloc_zero(sizeof(*ret));
1313     if(!ret)
1314         return NULL;
1315
1316     ret->IOmNavigator_iface.lpVtbl = &OmNavigatorVtbl;
1317     ret->ref = 1;
1318
1319     init_dispex(&ret->dispex, (IUnknown*)&ret->IOmNavigator_iface, &OmNavigator_dispex);
1320
1321     return &ret->IOmNavigator_iface;
1322 }
1323
1324 typedef struct {
1325     DispatchEx dispex;
1326     IHTMLPerformanceTiming IHTMLPerformanceTiming_iface;
1327
1328     LONG ref;
1329 } HTMLPerformanceTiming;
1330
1331 static inline HTMLPerformanceTiming *impl_from_IHTMLPerformanceTiming(IHTMLPerformanceTiming *iface)
1332 {
1333     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, IHTMLPerformanceTiming_iface);
1334 }
1335
1336 static HRESULT WINAPI HTMLPerformanceTiming_QueryInterface(IHTMLPerformanceTiming *iface, REFIID riid, void **ppv)
1337 {
1338     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1339
1340     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1341
1342     if(IsEqualGUID(&IID_IUnknown, riid)) {
1343         *ppv = &This->IHTMLPerformanceTiming_iface;
1344     }else if(IsEqualGUID(&IID_IHTMLPerformanceTiming, riid)) {
1345         *ppv = &This->IHTMLPerformanceTiming_iface;
1346     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1347         return *ppv ? S_OK : E_NOINTERFACE;
1348     }else {
1349         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1350         *ppv = NULL;
1351         return E_NOINTERFACE;
1352     }
1353
1354     IUnknown_AddRef((IUnknown*)*ppv);
1355     return S_OK;
1356 }
1357
1358 static ULONG WINAPI HTMLPerformanceTiming_AddRef(IHTMLPerformanceTiming *iface)
1359 {
1360     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1361     LONG ref = InterlockedIncrement(&This->ref);
1362
1363     TRACE("(%p) ref=%d\n", This, ref);
1364
1365     return ref;
1366 }
1367
1368 static ULONG WINAPI HTMLPerformanceTiming_Release(IHTMLPerformanceTiming *iface)
1369 {
1370     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1371     LONG ref = InterlockedDecrement(&This->ref);
1372
1373     TRACE("(%p) ref=%d\n", This, ref);
1374
1375     if(!ref) {
1376         release_dispex(&This->dispex);
1377         heap_free(This);
1378     }
1379
1380     return ref;
1381 }
1382
1383 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfoCount(IHTMLPerformanceTiming *iface, UINT *pctinfo)
1384 {
1385     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1386     FIXME("(%p)->(%p)\n", This, pctinfo);
1387     return E_NOTIMPL;
1388 }
1389
1390 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfo(IHTMLPerformanceTiming *iface, UINT iTInfo,
1391                                               LCID lcid, ITypeInfo **ppTInfo)
1392 {
1393     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1394
1395     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1396 }
1397
1398 static HRESULT WINAPI HTMLPerformanceTiming_GetIDsOfNames(IHTMLPerformanceTiming *iface, REFIID riid,
1399                                                           LPOLESTR *rgszNames, UINT cNames,
1400                                                           LCID lcid, DISPID *rgDispId)
1401 {
1402     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1403
1404     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1405             lcid, rgDispId);
1406 }
1407
1408 static HRESULT WINAPI HTMLPerformanceTiming_Invoke(IHTMLPerformanceTiming *iface, DISPID dispIdMember,
1409                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1410                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1411 {
1412     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1413
1414     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1415             pDispParams, pVarResult, pExcepInfo, puArgErr);
1416 }
1417
1418 #define TIMING_FAKE_TIMESTAMP 0xdeadbeef
1419
1420 static HRESULT WINAPI HTMLPerformanceTiming_get_navigationStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1421 {
1422     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1423
1424     FIXME("(%p)->(%p) returning fake value\n", This, p);
1425
1426     *p = TIMING_FAKE_TIMESTAMP;
1427     return S_OK;
1428 }
1429
1430 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1431 {
1432     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1433
1434     FIXME("(%p)->(%p) returning fake value\n", This, p);
1435
1436     *p = TIMING_FAKE_TIMESTAMP;
1437     return S_OK;
1438 }
1439
1440 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1441 {
1442     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1443
1444     FIXME("(%p)->(%p) returning fake value\n", This, p);
1445
1446     *p = TIMING_FAKE_TIMESTAMP;
1447     return S_OK;
1448 }
1449
1450 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1451 {
1452     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1453
1454     FIXME("(%p)->(%p) returning fake value\n", This, p);
1455
1456     *p = TIMING_FAKE_TIMESTAMP;
1457     return S_OK;
1458 }
1459
1460 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1461 {
1462     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1463
1464     FIXME("(%p)->(%p) returning fake value\n", This, p);
1465
1466     *p = TIMING_FAKE_TIMESTAMP;
1467     return S_OK;
1468 }
1469
1470 static HRESULT WINAPI HTMLPerformanceTiming_get_fetchStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1471 {
1472     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1473
1474     FIXME("(%p)->(%p) returning fake value\n", This, p);
1475
1476     *p = TIMING_FAKE_TIMESTAMP;
1477     return S_OK;
1478 }
1479
1480 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1481 {
1482     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1483
1484     FIXME("(%p)->(%p) returning fake value\n", This, p);
1485
1486     *p = TIMING_FAKE_TIMESTAMP;
1487     return S_OK;
1488 }
1489
1490 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1491 {
1492     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1493
1494     FIXME("(%p)->(%p) returning fake value\n", This, p);
1495
1496     *p = TIMING_FAKE_TIMESTAMP;
1497     return S_OK;
1498 }
1499
1500 static HRESULT WINAPI HTMLPerformanceTiming_get_connectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1501 {
1502     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1503
1504     FIXME("(%p)->(%p) returning fake value\n", This, p);
1505
1506     *p = TIMING_FAKE_TIMESTAMP;
1507     return S_OK;
1508 }
1509
1510 static HRESULT WINAPI HTMLPerformanceTiming_get_connectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1511 {
1512     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1513
1514     FIXME("(%p)->(%p) returning fake value\n", This, p);
1515
1516     *p = TIMING_FAKE_TIMESTAMP;
1517     return S_OK;
1518 }
1519
1520 static HRESULT WINAPI HTMLPerformanceTiming_get_requestStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1521 {
1522     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1523
1524     FIXME("(%p)->(%p) returning fake value\n", This, p);
1525
1526     *p = TIMING_FAKE_TIMESTAMP;
1527     return S_OK;
1528 }
1529
1530 static HRESULT WINAPI HTMLPerformanceTiming_get_responseStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1531 {
1532     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1533
1534     FIXME("(%p)->(%p) returning fake value\n", This, p);
1535
1536     *p = TIMING_FAKE_TIMESTAMP;
1537     return S_OK;
1538 }
1539
1540 static HRESULT WINAPI HTMLPerformanceTiming_get_responseEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1541 {
1542     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1543
1544     FIXME("(%p)->(%p) returning fake value\n", This, p);
1545
1546     *p = TIMING_FAKE_TIMESTAMP;
1547     return S_OK;
1548 }
1549
1550 static HRESULT WINAPI HTMLPerformanceTiming_get_domLoading(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1551 {
1552     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1553
1554     FIXME("(%p)->(%p) returning fake value\n", This, p);
1555
1556     *p = TIMING_FAKE_TIMESTAMP;
1557     return S_OK;
1558 }
1559
1560 static HRESULT WINAPI HTMLPerformanceTiming_get_domInteractive(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1561 {
1562     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1563
1564     FIXME("(%p)->(%p) returning fake value\n", This, p);
1565
1566     *p = TIMING_FAKE_TIMESTAMP;
1567     return S_OK;
1568 }
1569
1570 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1571 {
1572     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1573
1574     FIXME("(%p)->(%p) returning fake value\n", This, p);
1575
1576     *p = TIMING_FAKE_TIMESTAMP;
1577     return S_OK;
1578 }
1579
1580 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1581 {
1582     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1583
1584     FIXME("(%p)->(%p) returning fake value\n", This, p);
1585
1586     *p = TIMING_FAKE_TIMESTAMP;
1587     return S_OK;
1588 }
1589
1590 static HRESULT WINAPI HTMLPerformanceTiming_get_domComplete(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1591 {
1592     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1593
1594     FIXME("(%p)->(%p) returning fake value\n", This, p);
1595
1596     *p = TIMING_FAKE_TIMESTAMP;
1597     return S_OK;
1598 }
1599
1600 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1601 {
1602     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1603
1604     FIXME("(%p)->(%p) returning fake value\n", This, p);
1605
1606     *p = TIMING_FAKE_TIMESTAMP;
1607     return S_OK;
1608 }
1609
1610 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1611 {
1612     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1613
1614     FIXME("(%p)->(%p) returning fake value\n", This, p);
1615
1616     *p = TIMING_FAKE_TIMESTAMP;
1617     return S_OK;
1618 }
1619
1620 static HRESULT WINAPI HTMLPerformanceTiming_get_msFirstPaint(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1621 {
1622     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1623
1624     FIXME("(%p)->(%p) returning fake value\n", This, p);
1625
1626     *p = TIMING_FAKE_TIMESTAMP;
1627     return S_OK;
1628 }
1629
1630 static HRESULT WINAPI HTMLPerformanceTiming_toString(IHTMLPerformanceTiming *iface, BSTR *string)
1631 {
1632     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1633     FIXME("(%p)->(%p)\n", This, string);
1634     return E_NOTIMPL;
1635 }
1636
1637 static HRESULT WINAPI HTMLPerformanceTiming_toJSON(IHTMLPerformanceTiming *iface, VARIANT *p)
1638 {
1639     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1640     FIXME("(%p)->(%p)\n", This, p);
1641     return E_NOTIMPL;
1642 }
1643
1644 static const IHTMLPerformanceTimingVtbl HTMLPerformanceTimingVtbl = {
1645     HTMLPerformanceTiming_QueryInterface,
1646     HTMLPerformanceTiming_AddRef,
1647     HTMLPerformanceTiming_Release,
1648     HTMLPerformanceTiming_GetTypeInfoCount,
1649     HTMLPerformanceTiming_GetTypeInfo,
1650     HTMLPerformanceTiming_GetIDsOfNames,
1651     HTMLPerformanceTiming_Invoke,
1652     HTMLPerformanceTiming_get_navigationStart,
1653     HTMLPerformanceTiming_get_unloadEventStart,
1654     HTMLPerformanceTiming_get_unloadEventEnd,
1655     HTMLPerformanceTiming_get_redirectStart,
1656     HTMLPerformanceTiming_get_redirectEnd,
1657     HTMLPerformanceTiming_get_fetchStart,
1658     HTMLPerformanceTiming_get_domainLookupStart,
1659     HTMLPerformanceTiming_get_domainLookupEnd,
1660     HTMLPerformanceTiming_get_connectStart,
1661     HTMLPerformanceTiming_get_connectEnd,
1662     HTMLPerformanceTiming_get_requestStart,
1663     HTMLPerformanceTiming_get_responseStart,
1664     HTMLPerformanceTiming_get_responseEnd,
1665     HTMLPerformanceTiming_get_domLoading,
1666     HTMLPerformanceTiming_get_domInteractive,
1667     HTMLPerformanceTiming_get_domContentLoadedEventStart,
1668     HTMLPerformanceTiming_get_domContentLoadedEventEnd,
1669     HTMLPerformanceTiming_get_domComplete,
1670     HTMLPerformanceTiming_get_loadEventStart,
1671     HTMLPerformanceTiming_get_loadEventEnd,
1672     HTMLPerformanceTiming_get_msFirstPaint,
1673     HTMLPerformanceTiming_toString,
1674     HTMLPerformanceTiming_toJSON
1675 };
1676
1677 static const tid_t HTMLPerformanceTiming_iface_tids[] = {
1678     IHTMLPerformanceTiming_tid,
1679     0
1680 };
1681 static dispex_static_data_t HTMLPerformanceTiming_dispex = {
1682     NULL,
1683     IHTMLPerformanceTiming_tid,
1684     HTMLPerformanceTiming_iface_tids
1685 };
1686
1687 typedef struct {
1688     DispatchEx dispex;
1689     IHTMLPerformanceNavigation IHTMLPerformanceNavigation_iface;
1690
1691     LONG ref;
1692 } HTMLPerformanceNavigation;
1693
1694 static inline HTMLPerformanceNavigation *impl_from_IHTMLPerformanceNavigation(IHTMLPerformanceNavigation *iface)
1695 {
1696     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, IHTMLPerformanceNavigation_iface);
1697 }
1698
1699 static HRESULT WINAPI HTMLPerformanceNavigation_QueryInterface(IHTMLPerformanceNavigation *iface, REFIID riid, void **ppv)
1700 {
1701     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1702
1703     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1704
1705     if(IsEqualGUID(&IID_IUnknown, riid)) {
1706         *ppv = &This->IHTMLPerformanceNavigation_iface;
1707     }else if(IsEqualGUID(&IID_IHTMLPerformanceNavigation, riid)) {
1708         *ppv = &This->IHTMLPerformanceNavigation_iface;
1709     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1710         return *ppv ? S_OK : E_NOINTERFACE;
1711     }else {
1712         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1713         *ppv = NULL;
1714         return E_NOINTERFACE;
1715     }
1716
1717     IUnknown_AddRef((IUnknown*)*ppv);
1718     return S_OK;
1719 }
1720
1721 static ULONG WINAPI HTMLPerformanceNavigation_AddRef(IHTMLPerformanceNavigation *iface)
1722 {
1723     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1724     LONG ref = InterlockedIncrement(&This->ref);
1725
1726     TRACE("(%p) ref=%d\n", This, ref);
1727
1728     return ref;
1729 }
1730
1731 static ULONG WINAPI HTMLPerformanceNavigation_Release(IHTMLPerformanceNavigation *iface)
1732 {
1733     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1734     LONG ref = InterlockedDecrement(&This->ref);
1735
1736     TRACE("(%p) ref=%d\n", This, ref);
1737
1738     if(!ref) {
1739         release_dispex(&This->dispex);
1740         heap_free(This);
1741     }
1742
1743     return ref;
1744 }
1745
1746 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfoCount(IHTMLPerformanceNavigation *iface, UINT *pctinfo)
1747 {
1748     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1749     FIXME("(%p)->(%p)\n", This, pctinfo);
1750     return E_NOTIMPL;
1751 }
1752
1753 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfo(IHTMLPerformanceNavigation *iface, UINT iTInfo,
1754                                               LCID lcid, ITypeInfo **ppTInfo)
1755 {
1756     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1757
1758     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1759 }
1760
1761 static HRESULT WINAPI HTMLPerformanceNavigation_GetIDsOfNames(IHTMLPerformanceNavigation *iface, REFIID riid,
1762                                                           LPOLESTR *rgszNames, UINT cNames,
1763                                                           LCID lcid, DISPID *rgDispId)
1764 {
1765     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1766
1767     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1768             lcid, rgDispId);
1769 }
1770
1771 static HRESULT WINAPI HTMLPerformanceNavigation_Invoke(IHTMLPerformanceNavigation *iface, DISPID dispIdMember,
1772                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1773                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1774 {
1775     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1776
1777     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1778             pDispParams, pVarResult, pExcepInfo, puArgErr);
1779 }
1780
1781 static HRESULT WINAPI HTMLPerformanceNavigation_get_type(IHTMLPerformanceNavigation *iface, ULONG *p)
1782 {
1783     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1784
1785     FIXME("(%p)->(%p) returning TYPE_NAVIGATE\n", This, p);
1786
1787     *p = 0; /* TYPE_NAVIGATE */
1788     return S_OK;
1789 }
1790
1791 static HRESULT WINAPI HTMLPerformanceNavigation_get_redirectCount(IHTMLPerformanceNavigation *iface, ULONG *p)
1792 {
1793     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1794     FIXME("(%p)->(%p)\n", This, p);
1795     return E_NOTIMPL;
1796 }
1797
1798 static HRESULT WINAPI HTMLPerformanceNavigation_toString(IHTMLPerformanceNavigation *iface, BSTR *string)
1799 {
1800     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1801     FIXME("(%p)->(%p)\n", This, string);
1802     return E_NOTIMPL;
1803 }
1804
1805 static HRESULT WINAPI HTMLPerformanceNavigation_toJSON(IHTMLPerformanceNavigation *iface, VARIANT *p)
1806 {
1807     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1808     FIXME("(%p)->(%p)\n", This, p);
1809     return E_NOTIMPL;
1810 }
1811
1812 static const IHTMLPerformanceNavigationVtbl HTMLPerformanceNavigationVtbl = {
1813     HTMLPerformanceNavigation_QueryInterface,
1814     HTMLPerformanceNavigation_AddRef,
1815     HTMLPerformanceNavigation_Release,
1816     HTMLPerformanceNavigation_GetTypeInfoCount,
1817     HTMLPerformanceNavigation_GetTypeInfo,
1818     HTMLPerformanceNavigation_GetIDsOfNames,
1819     HTMLPerformanceNavigation_Invoke,
1820     HTMLPerformanceNavigation_get_type,
1821     HTMLPerformanceNavigation_get_redirectCount,
1822     HTMLPerformanceNavigation_toString,
1823     HTMLPerformanceNavigation_toJSON
1824 };
1825
1826 static const tid_t HTMLPerformanceNavigation_iface_tids[] = {
1827     IHTMLPerformanceNavigation_tid,
1828     0
1829 };
1830 static dispex_static_data_t HTMLPerformanceNavigation_dispex = {
1831     NULL,
1832     IHTMLPerformanceNavigation_tid,
1833     HTMLPerformanceNavigation_iface_tids
1834 };
1835
1836 typedef struct {
1837     DispatchEx dispex;
1838     IHTMLPerformance IHTMLPerformance_iface;
1839
1840     LONG ref;
1841
1842     IHTMLPerformanceNavigation *navigation;
1843     IHTMLPerformanceTiming *timing;
1844 } HTMLPerformance;
1845
1846 static inline HTMLPerformance *impl_from_IHTMLPerformance(IHTMLPerformance *iface)
1847 {
1848     return CONTAINING_RECORD(iface, HTMLPerformance, IHTMLPerformance_iface);
1849 }
1850
1851 static HRESULT WINAPI HTMLPerformance_QueryInterface(IHTMLPerformance *iface, REFIID riid, void **ppv)
1852 {
1853     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1854
1855     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1856
1857     if(IsEqualGUID(&IID_IUnknown, riid)) {
1858         *ppv = &This->IHTMLPerformance_iface;
1859     }else if(IsEqualGUID(&IID_IHTMLPerformance, riid)) {
1860         *ppv = &This->IHTMLPerformance_iface;
1861     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1862         return *ppv ? S_OK : E_NOINTERFACE;
1863     }else {
1864         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1865         *ppv = NULL;
1866         return E_NOINTERFACE;
1867     }
1868
1869     IUnknown_AddRef((IUnknown*)*ppv);
1870     return S_OK;
1871 }
1872
1873 static ULONG WINAPI HTMLPerformance_AddRef(IHTMLPerformance *iface)
1874 {
1875     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1876     LONG ref = InterlockedIncrement(&This->ref);
1877
1878     TRACE("(%p) ref=%d\n", This, ref);
1879
1880     return ref;
1881 }
1882
1883 static ULONG WINAPI HTMLPerformance_Release(IHTMLPerformance *iface)
1884 {
1885     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1886     LONG ref = InterlockedDecrement(&This->ref);
1887
1888     TRACE("(%p) ref=%d\n", This, ref);
1889
1890     if(!ref) {
1891         if(This->timing)
1892             IHTMLPerformanceTiming_Release(This->timing);
1893         if(This->navigation)
1894             IHTMLPerformanceNavigation_Release(This->navigation);
1895         release_dispex(&This->dispex);
1896         heap_free(This);
1897     }
1898
1899     return ref;
1900 }
1901
1902 static HRESULT WINAPI HTMLPerformance_GetTypeInfoCount(IHTMLPerformance *iface, UINT *pctinfo)
1903 {
1904     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1905     FIXME("(%p)->(%p)\n", This, pctinfo);
1906     return E_NOTIMPL;
1907 }
1908
1909 static HRESULT WINAPI HTMLPerformance_GetTypeInfo(IHTMLPerformance *iface, UINT iTInfo,
1910                                                   LCID lcid, ITypeInfo **ppTInfo)
1911 {
1912     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1913
1914     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1915 }
1916
1917 static HRESULT WINAPI HTMLPerformance_GetIDsOfNames(IHTMLPerformance *iface, REFIID riid,
1918                                                     LPOLESTR *rgszNames, UINT cNames,
1919                                                     LCID lcid, DISPID *rgDispId)
1920 {
1921     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1922
1923     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1924             lcid, rgDispId);
1925 }
1926
1927 static HRESULT WINAPI HTMLPerformance_Invoke(IHTMLPerformance *iface, DISPID dispIdMember,
1928                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1929                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1930 {
1931     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1932
1933     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1934             pDispParams, pVarResult, pExcepInfo, puArgErr);
1935 }
1936
1937 static HRESULT WINAPI HTMLPerformance_get_navigation(IHTMLPerformance *iface,
1938                                                      IHTMLPerformanceNavigation **p)
1939 {
1940     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1941
1942     TRACE("(%p)->(%p)\n", This, p);
1943
1944     if(!This->navigation) {
1945         HTMLPerformanceNavigation *navigation;
1946
1947         navigation = heap_alloc_zero(sizeof(*navigation));
1948         if(!navigation)
1949             return E_OUTOFMEMORY;
1950
1951         navigation->IHTMLPerformanceNavigation_iface.lpVtbl = &HTMLPerformanceNavigationVtbl;
1952         navigation->ref = 1;
1953         init_dispex(&navigation->dispex, (IUnknown*)&navigation->IHTMLPerformanceNavigation_iface,
1954                     &HTMLPerformanceNavigation_dispex);
1955
1956         This->navigation = &navigation->IHTMLPerformanceNavigation_iface;
1957     }
1958
1959     IHTMLPerformanceNavigation_AddRef(*p = This->navigation);
1960     return S_OK;
1961 }
1962
1963 static HRESULT WINAPI HTMLPerformance_get_timing(IHTMLPerformance *iface, IHTMLPerformanceTiming **p)
1964 {
1965     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1966
1967     TRACE("(%p)->(%p)\n", This, p);
1968
1969     if(!This->timing) {
1970         HTMLPerformanceTiming *timing;
1971
1972         timing = heap_alloc_zero(sizeof(*timing));
1973         if(!timing)
1974             return E_OUTOFMEMORY;
1975
1976         timing->IHTMLPerformanceTiming_iface.lpVtbl = &HTMLPerformanceTimingVtbl;
1977         timing->ref = 1;
1978         init_dispex(&timing->dispex, (IUnknown*)&timing->IHTMLPerformanceTiming_iface,
1979                     &HTMLPerformanceTiming_dispex);
1980
1981         This->timing = &timing->IHTMLPerformanceTiming_iface;
1982     }
1983
1984     IHTMLPerformanceTiming_AddRef(*p = This->timing);
1985     return S_OK;
1986 }
1987
1988 static HRESULT WINAPI HTMLPerformance_toString(IHTMLPerformance *iface, BSTR *string)
1989 {
1990     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1991     FIXME("(%p)->(%p)\n", This, string);
1992     return E_NOTIMPL;
1993 }
1994
1995 static HRESULT WINAPI HTMLPerformance_toJSON(IHTMLPerformance *iface, VARIANT *var)
1996 {
1997     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1998     FIXME("(%p)->(%p)\n", This, var);
1999     return E_NOTIMPL;
2000 }
2001
2002 static const IHTMLPerformanceVtbl HTMLPerformanceVtbl = {
2003     HTMLPerformance_QueryInterface,
2004     HTMLPerformance_AddRef,
2005     HTMLPerformance_Release,
2006     HTMLPerformance_GetTypeInfoCount,
2007     HTMLPerformance_GetTypeInfo,
2008     HTMLPerformance_GetIDsOfNames,
2009     HTMLPerformance_Invoke,
2010     HTMLPerformance_get_navigation,
2011     HTMLPerformance_get_timing,
2012     HTMLPerformance_toString,
2013     HTMLPerformance_toJSON
2014 };
2015
2016 static const tid_t HTMLPerformance_iface_tids[] = {
2017     IHTMLPerformance_tid,
2018     0
2019 };
2020 static dispex_static_data_t HTMLPerformance_dispex = {
2021     NULL,
2022     IHTMLPerformance_tid,
2023     HTMLPerformance_iface_tids
2024 };
2025
2026 HRESULT create_performance(IHTMLPerformance **ret)
2027 {
2028     HTMLPerformance *performance;
2029
2030     performance = heap_alloc_zero(sizeof(*performance));
2031     if(!performance)
2032         return E_OUTOFMEMORY;
2033
2034     performance->IHTMLPerformance_iface.lpVtbl = &HTMLPerformanceVtbl;
2035     performance->ref = 1;
2036
2037     init_dispex(&performance->dispex, (IUnknown*)&performance->IHTMLPerformance_iface,
2038                 &HTMLPerformance_dispex);
2039
2040     *ret = &performance->IHTMLPerformance_iface;
2041     return S_OK;
2042 }