dlls/mshtml/omnavigator.c

   1 /*
   2  * Copyright 2008 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     NULL,
 168     HTMLDOMImplementation_iface_tids
 169 };
 170
 171 HRESULT create_dom_implementation(IHTMLDOMImplementation **ret)
 172 {
 173     HTMLDOMImplementation *dom_implementation;
 174
 175     dom_implementation = heap_alloc_zero(sizeof(*dom_implementation));
 176     if(!dom_implementation)
 177         return E_OUTOFMEMORY;
 178
 179     dom_implementation->IHTMLDOMImplementation_iface.lpVtbl = &HTMLDOMImplementationVtbl;
 180     dom_implementation->ref = 1;
 181
 182     init_dispex(&dom_implementation->dispex, (IUnknown*)&dom_implementation->IHTMLDOMImplementation_iface,
 183             &HTMLDOMImplementation_dispex);
 184
 185     *ret = &dom_implementation->IHTMLDOMImplementation_iface;
 186     return S_OK;
 187 }
 188
 189 static inline OmHistory *impl_from_IOmHistory(IOmHistory *iface)
 190 {
 191     return CONTAINING_RECORD(iface, OmHistory, IOmHistory_iface);
 192 }
 193
 194 static HRESULT WINAPI OmHistory_QueryInterface(IOmHistory *iface, REFIID riid, void **ppv)
 195 {
 196     OmHistory *This = impl_from_IOmHistory(iface);
 197
 198     *ppv = NULL;
 199
 200     if(IsEqualGUID(&IID_IUnknown, riid)) {
 201         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 202         *ppv = &This->IOmHistory_iface;
 203     }else if(IsEqualGUID(&IID_IOmHistory, riid)) {
 204         TRACE("(%p)->(IID_IOmHistory %p)\n", This, ppv);
 205         *ppv = &This->IOmHistory_iface;
 206     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 207         return *ppv ? S_OK : E_NOINTERFACE;
 208     }
 209
 210     if(*ppv) {
 211         IUnknown_AddRef((IUnknown*)*ppv);
 212         return S_OK;
 213     }
 214
 215     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 216     return E_NOINTERFACE;
 217 }
 218
 219 static ULONG WINAPI OmHistory_AddRef(IOmHistory *iface)
 220 {
 221     OmHistory *This = impl_from_IOmHistory(iface);
 222     LONG ref = InterlockedIncrement(&This->ref);
 223
 224     TRACE("(%p) ref=%d\n", This, ref);
 225
 226     return ref;
 227 }
 228
 229 static ULONG WINAPI OmHistory_Release(IOmHistory *iface)
 230 {
 231     OmHistory *This = impl_from_IOmHistory(iface);
 232     LONG ref = InterlockedDecrement(&This->ref);
 233
 234     TRACE("(%p) ref=%d\n", This, ref);
 235
 236     if(!ref) {
 237         release_dispex(&This->dispex);
 238         heap_free(This);
 239     }
 240
 241     return ref;
 242 }
 243
 244 static HRESULT WINAPI OmHistory_GetTypeInfoCount(IOmHistory *iface, UINT *pctinfo)
 245 {
 246     OmHistory *This = impl_from_IOmHistory(iface);
 247     FIXME("(%p)->(%p)\n", This, pctinfo);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI OmHistory_GetTypeInfo(IOmHistory *iface, UINT iTInfo,
 252         LCID lcid, ITypeInfo **ppTInfo)
 253 {
 254     OmHistory *This = impl_from_IOmHistory(iface);
 255
 256     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 257 }
 258
 259 static HRESULT WINAPI OmHistory_GetIDsOfNames(IOmHistory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 260         LCID lcid, DISPID *rgDispId)
 261 {
 262     OmHistory *This = impl_from_IOmHistory(iface);
 263
 264     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 265             lcid, rgDispId);
 266 }
 267
 268 static HRESULT WINAPI OmHistory_Invoke(IOmHistory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 269         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 270 {
 271     OmHistory *This = impl_from_IOmHistory(iface);
 272
 273     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 274             pDispParams, pVarResult, pExcepInfo, puArgErr);
 275 }
 276
 277 static HRESULT WINAPI OmHistory_get_length(IOmHistory *iface, short *p)
 278 {
 279     OmHistory *This = impl_from_IOmHistory(iface);
 280
 281     TRACE("(%p)->(%p)\n", This, p);
 282
 283     if(!This->window || !This->window->base.outer_window->doc_obj
 284             || !This->window->base.outer_window->doc_obj->travel_log) {
 285         *p = 0;
 286     }else {
 287         *p = ITravelLog_CountEntries(This->window->base.outer_window->doc_obj->travel_log,
 288                 This->window->base.outer_window->doc_obj->browser_service);
 289     }
 290     return S_OK;
 291 }
 292
 293 static HRESULT WINAPI OmHistory_back(IOmHistory *iface, VARIANT *pvargdistance)
 294 {
 295     OmHistory *This = impl_from_IOmHistory(iface);
 296     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 297     return E_NOTIMPL;
 298 }
 299
 300 static HRESULT WINAPI OmHistory_forward(IOmHistory *iface, VARIANT *pvargdistance)
 301 {
 302     OmHistory *This = impl_from_IOmHistory(iface);
 303     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI OmHistory_go(IOmHistory *iface, VARIANT *pvargdistance)
 308 {
 309     OmHistory *This = impl_from_IOmHistory(iface);
 310     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 311     return E_NOTIMPL;
 312 }
 313
 314 static const IOmHistoryVtbl OmHistoryVtbl = {
 315     OmHistory_QueryInterface,
 316     OmHistory_AddRef,
 317     OmHistory_Release,
 318     OmHistory_GetTypeInfoCount,
 319     OmHistory_GetTypeInfo,
 320     OmHistory_GetIDsOfNames,
 321     OmHistory_Invoke,
 322     OmHistory_get_length,
 323     OmHistory_back,
 324     OmHistory_forward,
 325     OmHistory_go
 326 };
 327
 328 static const tid_t OmHistory_iface_tids[] = {
 329     IOmHistory_tid,
 330     0
 331 };
 332 static dispex_static_data_t OmHistory_dispex = {
 333     NULL,
 334     DispHTMLHistory_tid,
 335     NULL,
 336     OmHistory_iface_tids
 337 };
 338
 339
 340 HRESULT create_history(HTMLInnerWindow *window, OmHistory **ret)
 341 {
 342     OmHistory *history;
 343
 344     history = heap_alloc_zero(sizeof(*history));
 345     if(!history)
 346         return E_OUTOFMEMORY;
 347
 348     init_dispex(&history->dispex, (IUnknown*)&history->IOmHistory_iface, &OmHistory_dispex);
 349     history->IOmHistory_iface.lpVtbl = &OmHistoryVtbl;
 350     history->ref = 1;
 351
 352     history->window = window;
 353
 354     *ret = history;
 355     return S_OK;
 356 }
 357
 358 struct HTMLPluginsCollection {
 359     DispatchEx dispex;
 360     IHTMLPluginsCollection IHTMLPluginsCollection_iface;
 361
 362     LONG ref;
 363
 364     OmNavigator *navigator;
 365 };
 366
 367 static inline HTMLPluginsCollection *impl_from_IHTMLPluginsCollection(IHTMLPluginsCollection *iface)
 368 {
 369     return CONTAINING_RECORD(iface, HTMLPluginsCollection, IHTMLPluginsCollection_iface);
 370 }
 371
 372 static HRESULT WINAPI HTMLPluginsCollection_QueryInterface(IHTMLPluginsCollection *iface, REFIID riid, void **ppv)
 373 {
 374     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 375
 376     if(IsEqualGUID(&IID_IUnknown, riid)) {
 377         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 378         *ppv = &This->IHTMLPluginsCollection_iface;
 379     }else if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid)) {
 380         TRACE("(%p)->(IID_IHTMLPluginCollection %p)\n", This, ppv);
 381         *ppv = &This->IHTMLPluginsCollection_iface;
 382     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 383         return *ppv ? S_OK : E_NOINTERFACE;
 384     }else {
 385         *ppv = NULL;
 386         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 387         return E_NOINTERFACE;
 388     }
 389
 390     IUnknown_AddRef((IUnknown*)*ppv);
 391     return S_OK;
 392 }
 393
 394 static ULONG WINAPI HTMLPluginsCollection_AddRef(IHTMLPluginsCollection *iface)
 395 {
 396     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 397     LONG ref = InterlockedIncrement(&This->ref);
 398
 399     TRACE("(%p) ref=%d\n", This, ref);
 400
 401     return ref;
 402 }
 403
 404 static ULONG WINAPI HTMLPluginsCollection_Release(IHTMLPluginsCollection *iface)
 405 {
 406     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 407     LONG ref = InterlockedDecrement(&This->ref);
 408
 409     TRACE("(%p) ref=%d\n", This, ref);
 410
 411     if(!ref) {
 412         if(This->navigator)
 413             This->navigator->plugins = NULL;
 414         release_dispex(&This->dispex);
 415         heap_free(This);
 416     }
 417
 418     return ref;
 419 }
 420
 421 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfoCount(IHTMLPluginsCollection *iface, UINT *pctinfo)
 422 {
 423     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 424     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 425 }
 426
 427 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfo(IHTMLPluginsCollection *iface, UINT iTInfo,
 428                                               LCID lcid, ITypeInfo **ppTInfo)
 429 {
 430     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 431     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 432 }
 433
 434 static HRESULT WINAPI HTMLPluginsCollection_GetIDsOfNames(IHTMLPluginsCollection *iface, REFIID riid,
 435         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 436 {
 437     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 438     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 439             lcid, rgDispId);
 440 }
 441
 442 static HRESULT WINAPI HTMLPluginsCollection_Invoke(IHTMLPluginsCollection *iface, DISPID dispIdMember,
 443         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 444         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 445 {
 446     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 447     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 448             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 449 }
 450
 451 static HRESULT WINAPI HTMLPluginsCollection_get_length(IHTMLPluginsCollection *iface, LONG *p)
 452 {
 453     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 454
 455     TRACE("(%p)->(%p)\n", This, p);
 456
 457     /* IE always returns 0 here */
 458     *p = 0;
 459     return S_OK;
 460 }
 461
 462 static HRESULT WINAPI HTMLPluginsCollection_refresh(IHTMLPluginsCollection *iface, VARIANT_BOOL reload)
 463 {
 464     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 465     FIXME("(%p)->(%x)\n", This, reload);
 466     return E_NOTIMPL;
 467 }
 468
 469 static const IHTMLPluginsCollectionVtbl HTMLPluginsCollectionVtbl = {
 470     HTMLPluginsCollection_QueryInterface,
 471     HTMLPluginsCollection_AddRef,
 472     HTMLPluginsCollection_Release,
 473     HTMLPluginsCollection_GetTypeInfoCount,
 474     HTMLPluginsCollection_GetTypeInfo,
 475     HTMLPluginsCollection_GetIDsOfNames,
 476     HTMLPluginsCollection_Invoke,
 477     HTMLPluginsCollection_get_length,
 478     HTMLPluginsCollection_refresh
 479 };
 480
 481 static const tid_t HTMLPluginsCollection_iface_tids[] = {
 482     IHTMLPluginsCollection_tid,
 483     0
 484 };
 485 static dispex_static_data_t HTMLPluginsCollection_dispex = {
 486     NULL,
 487     DispCPlugins_tid,
 488     NULL,
 489     HTMLPluginsCollection_iface_tids
 490 };
 491
 492 static HRESULT create_plugins_collection(OmNavigator *navigator, HTMLPluginsCollection **ret)
 493 {
 494     HTMLPluginsCollection *col;
 495
 496     col = heap_alloc_zero(sizeof(*col));
 497     if(!col)
 498         return E_OUTOFMEMORY;
 499
 500     col->IHTMLPluginsCollection_iface.lpVtbl = &HTMLPluginsCollectionVtbl;
 501     col->ref = 1;
 502     col->navigator = navigator;
 503
 504     init_dispex(&col->dispex, (IUnknown*)&col->IHTMLPluginsCollection_iface,
 505                 &HTMLPluginsCollection_dispex);
 506
 507     *ret = col;
 508     return S_OK;
 509 }
 510
 511 struct HTMLMimeTypesCollection {
 512     DispatchEx dispex;
 513     IHTMLMimeTypesCollection IHTMLMimeTypesCollection_iface;
 514
 515     LONG ref;
 516
 517     OmNavigator *navigator;
 518 };
 519
 520 static inline HTMLMimeTypesCollection *impl_from_IHTMLMimeTypesCollection(IHTMLMimeTypesCollection *iface)
 521 {
 522     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, IHTMLMimeTypesCollection_iface);
 523 }
 524
 525 static HRESULT WINAPI HTMLMimeTypesCollection_QueryInterface(IHTMLMimeTypesCollection *iface, REFIID riid, void **ppv)
 526 {
 527     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 528
 529     if(IsEqualGUID(&IID_IUnknown, riid)) {
 530         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 531         *ppv = &This->IHTMLMimeTypesCollection_iface;
 532     }else if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid)) {
 533         TRACE("(%p)->(IID_IHTMLMimeTypesCollection %p)\n", This, ppv);
 534         *ppv = &This->IHTMLMimeTypesCollection_iface;
 535     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 536         return *ppv ? S_OK : E_NOINTERFACE;
 537     }else {
 538         *ppv = NULL;
 539         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 540         return E_NOINTERFACE;
 541     }
 542
 543     IUnknown_AddRef((IUnknown*)*ppv);
 544     return S_OK;
 545 }
 546
 547 static ULONG WINAPI HTMLMimeTypesCollection_AddRef(IHTMLMimeTypesCollection *iface)
 548 {
 549     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 550     LONG ref = InterlockedIncrement(&This->ref);
 551
 552     TRACE("(%p) ref=%d\n", This, ref);
 553
 554     return ref;
 555 }
 556
 557 static ULONG WINAPI HTMLMimeTypesCollection_Release(IHTMLMimeTypesCollection *iface)
 558 {
 559     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 560     LONG ref = InterlockedDecrement(&This->ref);
 561
 562     TRACE("(%p) ref=%d\n", This, ref);
 563
 564     if(!ref) {
 565         if(This->navigator)
 566             This->navigator->mime_types = NULL;
 567         release_dispex(&This->dispex);
 568         heap_free(This);
 569     }
 570
 571     return ref;
 572 }
 573
 574 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfoCount(IHTMLMimeTypesCollection *iface, UINT *pctinfo)
 575 {
 576     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 577     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 578 }
 579
 580 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfo(IHTMLMimeTypesCollection *iface, UINT iTInfo,
 581                                               LCID lcid, ITypeInfo **ppTInfo)
 582 {
 583     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 584     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 585 }
 586
 587 static HRESULT WINAPI HTMLMimeTypesCollection_GetIDsOfNames(IHTMLMimeTypesCollection *iface, REFIID riid,
 588         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 589 {
 590     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 591     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 592             lcid, rgDispId);
 593 }
 594
 595 static HRESULT WINAPI HTMLMimeTypesCollection_Invoke(IHTMLMimeTypesCollection *iface, DISPID dispIdMember,
 596         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 597         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 598 {
 599     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 600     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 601             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 602 }
 603
 604 static HRESULT WINAPI HTMLMimeTypesCollection_get_length(IHTMLMimeTypesCollection *iface, LONG *p)
 605 {
 606     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 607
 608     TRACE("(%p)->(%p)\n", This, p);
 609
 610     /* This is just a stub for compatibility with other browser in IE */
 611     *p = 0;
 612     return S_OK;
 613 }
 614
 615 static const IHTMLMimeTypesCollectionVtbl HTMLMimeTypesCollectionVtbl = {
 616     HTMLMimeTypesCollection_QueryInterface,
 617     HTMLMimeTypesCollection_AddRef,
 618     HTMLMimeTypesCollection_Release,
 619     HTMLMimeTypesCollection_GetTypeInfoCount,
 620     HTMLMimeTypesCollection_GetTypeInfo,
 621     HTMLMimeTypesCollection_GetIDsOfNames,
 622     HTMLMimeTypesCollection_Invoke,
 623     HTMLMimeTypesCollection_get_length
 624 };
 625
 626 static const tid_t HTMLMimeTypesCollection_iface_tids[] = {
 627     IHTMLMimeTypesCollection_tid,
 628     0
 629 };
 630 static dispex_static_data_t HTMLMimeTypesCollection_dispex = {
 631     NULL,
 632     IHTMLMimeTypesCollection_tid,
 633     NULL,
 634     HTMLMimeTypesCollection_iface_tids
 635 };
 636
 637 static HRESULT create_mime_types_collection(OmNavigator *navigator, HTMLMimeTypesCollection **ret)
 638 {
 639     HTMLMimeTypesCollection *col;
 640
 641     col = heap_alloc_zero(sizeof(*col));
 642     if(!col)
 643         return E_OUTOFMEMORY;
 644
 645     col->IHTMLMimeTypesCollection_iface.lpVtbl = &HTMLMimeTypesCollectionVtbl;
 646     col->ref = 1;
 647     col->navigator = navigator;
 648
 649     init_dispex(&col->dispex, (IUnknown*)&col->IHTMLMimeTypesCollection_iface,
 650                 &HTMLMimeTypesCollection_dispex);
 651
 652     *ret = col;
 653     return S_OK;
 654 }
 655
 656 static inline OmNavigator *impl_from_IOmNavigator(IOmNavigator *iface)
 657 {
 658     return CONTAINING_RECORD(iface, OmNavigator, IOmNavigator_iface);
 659 }
 660
 661 static HRESULT WINAPI OmNavigator_QueryInterface(IOmNavigator *iface, REFIID riid, void **ppv)
 662 {
 663     OmNavigator *This = impl_from_IOmNavigator(iface);
 664
 665     *ppv = NULL;
 666
 667     if(IsEqualGUID(&IID_IUnknown, riid)) {
 668         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 669         *ppv = &This->IOmNavigator_iface;
 670     }else if(IsEqualGUID(&IID_IOmNavigator, riid)) {
 671         TRACE("(%p)->(IID_IOmNavigator %p)\n", This, ppv);
 672         *ppv = &This->IOmNavigator_iface;
 673     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 674         return *ppv ? S_OK : E_NOINTERFACE;
 675     }
 676
 677     if(*ppv) {
 678         IUnknown_AddRef((IUnknown*)*ppv);
 679         return S_OK;
 680     }
 681
 682     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 683     return E_NOINTERFACE;
 684 }
 685
 686 static ULONG WINAPI OmNavigator_AddRef(IOmNavigator *iface)
 687 {
 688     OmNavigator *This = impl_from_IOmNavigator(iface);
 689     LONG ref = InterlockedIncrement(&This->ref);
 690
 691     TRACE("(%p) ref=%d\n", This, ref);
 692
 693     return ref;
 694 }
 695
 696 static ULONG WINAPI OmNavigator_Release(IOmNavigator *iface)
 697 {
 698     OmNavigator *This = impl_from_IOmNavigator(iface);
 699     LONG ref = InterlockedDecrement(&This->ref);
 700
 701     TRACE("(%p) ref=%d\n", This, ref);
 702
 703     if(!ref) {
 704         if(This->plugins)
 705             This->plugins->navigator = NULL;
 706         if(This->mime_types)
 707             This->mime_types->navigator = NULL;
 708         release_dispex(&This->dispex);
 709         heap_free(This);
 710     }
 711
 712     return ref;
 713 }
 714
 715 static HRESULT WINAPI OmNavigator_GetTypeInfoCount(IOmNavigator *iface, UINT *pctinfo)
 716 {
 717     OmNavigator *This = impl_from_IOmNavigator(iface);
 718     FIXME("(%p)->(%p)\n", This, pctinfo);
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI OmNavigator_GetTypeInfo(IOmNavigator *iface, UINT iTInfo,
 723                                               LCID lcid, ITypeInfo **ppTInfo)
 724 {
 725     OmNavigator *This = impl_from_IOmNavigator(iface);
 726
 727     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 728 }
 729
 730 static HRESULT WINAPI OmNavigator_GetIDsOfNames(IOmNavigator *iface, REFIID riid,
 731                                                 LPOLESTR *rgszNames, UINT cNames,
 732                                                 LCID lcid, DISPID *rgDispId)
 733 {
 734     OmNavigator *This = impl_from_IOmNavigator(iface);
 735
 736     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 737             lcid, rgDispId);
 738 }
 739
 740 static HRESULT WINAPI OmNavigator_Invoke(IOmNavigator *iface, DISPID dispIdMember,
 741                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 742                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 743 {
 744     OmNavigator *This = impl_from_IOmNavigator(iface);
 745
 746     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 747             pDispParams, pVarResult, pExcepInfo, puArgErr);
 748 }
 749
 750 static HRESULT WINAPI OmNavigator_get_appCodeName(IOmNavigator *iface, BSTR *p)
 751 {
 752     OmNavigator *This = impl_from_IOmNavigator(iface);
 753
 754     static const WCHAR mozillaW[] = {'M','o','z','i','l','l','a',0};
 755
 756     TRACE("(%p)->(%p)\n", This, p);
 757
 758     *p = SysAllocString(mozillaW);
 759     return S_OK;
 760 }
 761
 762 static HRESULT WINAPI OmNavigator_get_appName(IOmNavigator *iface, BSTR *p)
 763 {
 764     OmNavigator *This = impl_from_IOmNavigator(iface);
 765
 766     static const WCHAR app_nameW[] =
 767         {'M','i','c','r','o','s','o','f','t',' ',
 768          'I','n','t','e','r','n','e','t',' ',
 769          'E','x','p','l','o','r','e','r',0};
 770
 771     TRACE("(%p)->(%p)\n", This, p);
 772
 773     *p = SysAllocString(app_nameW);
 774     if(!*p)
 775         return E_OUTOFMEMORY;
 776
 777     return S_OK;
 778 }
 779
 780 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
 781 {
 782     OmNavigator *This = impl_from_IOmNavigator(iface);
 783
 784     char user_agent[512];
 785     DWORD size;
 786     HRESULT hres;
 787
 788     TRACE("(%p)->(%p)\n", This, p);
 789
 790     size = sizeof(user_agent);
 791     hres = ObtainUserAgentString(0, user_agent, &size);
 792     if(FAILED(hres))
 793         return hres;
 794
 795     if(strncmp(user_agent, "Mozilla/", 8)) {
 796         FIXME("Unsupported user agent\n");
 797         return E_FAIL;
 798     }
 799
 800     size = MultiByteToWideChar(CP_ACP, 0, user_agent+8, -1, NULL, 0);
 801     *p = SysAllocStringLen(NULL, size-1);
 802     if(!*p)
 803         return E_OUTOFMEMORY;
 804
 805     MultiByteToWideChar(CP_ACP, 0, user_agent+8, -1, *p, size);
 806     return S_OK;
 807 }
 808
 809 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
 810 {
 811     OmNavigator *This = impl_from_IOmNavigator(iface);
 812     char user_agent[512];
 813     DWORD size;
 814     HRESULT hres;
 815
 816     TRACE("(%p)->(%p)\n", This, p);
 817
 818     size = sizeof(user_agent);
 819     hres = ObtainUserAgentString(0, user_agent, &size);
 820     if(FAILED(hres))
 821         return hres;
 822
 823     size = MultiByteToWideChar(CP_ACP, 0, user_agent, -1, NULL, 0);
 824     *p = SysAllocStringLen(NULL, size-1);
 825     if(!*p)
 826         return E_OUTOFMEMORY;
 827
 828     MultiByteToWideChar(CP_ACP, 0, user_agent, -1, *p, size);
 829     return S_OK;
 830 }
 831
 832 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
 833 {
 834     OmNavigator *This = impl_from_IOmNavigator(iface);
 835
 836     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
 837
 838     *enabled = VARIANT_TRUE;
 839     return S_OK;
 840 }
 841
 842 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
 843 {
 844     OmNavigator *This = impl_from_IOmNavigator(iface);
 845     FIXME("(%p)->(%p)\n", This, enabled);
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
 850 {
 851     OmNavigator *This = impl_from_IOmNavigator(iface);
 852
 853     TRACE("(%p)->(%p)\n", This, p);
 854
 855     if(!This->mime_types) {
 856         HRESULT hres;
 857
 858         hres = create_mime_types_collection(This, &This->mime_types);
 859         if(FAILED(hres))
 860             return hres;
 861     }else {
 862         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
 863     }
 864
 865     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
 866     return S_OK;
 867 }
 868
 869 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
 870 {
 871     OmNavigator *This = impl_from_IOmNavigator(iface);
 872
 873     TRACE("(%p)->(%p)\n", This, p);
 874
 875     if(!This->plugins) {
 876         HRESULT hres;
 877
 878         hres = create_plugins_collection(This, &This->plugins);
 879         if(FAILED(hres))
 880             return hres;
 881     }else {
 882         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
 883     }
 884
 885     *p = &This->plugins->IHTMLPluginsCollection_iface;
 886     return S_OK;
 887 }
 888
 889 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
 890 {
 891     OmNavigator *This = impl_from_IOmNavigator(iface);
 892
 893     WARN("(%p)->(%p) semi-stub\n", This, p);
 894
 895     *p = VARIANT_TRUE;
 896     return S_OK;
 897 }
 898
 899 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
 900 {
 901     OmNavigator *This = impl_from_IOmNavigator(iface);
 902     FIXME("(%p)->(%p)\n", This, p);
 903     return E_NOTIMPL;
 904 }
 905
 906 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
 907 {
 908     OmNavigator *This = impl_from_IOmNavigator(iface);
 909
 910     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
 911
 912     TRACE("(%p)->(%p)\n", This, String);
 913
 914     if(!String)
 915         return E_INVALIDARG;
 916
 917     *String = SysAllocString(objectW);
 918     return *String ? S_OK : E_OUTOFMEMORY;
 919 }
 920
 921 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
 922 {
 923     OmNavigator *This = impl_from_IOmNavigator(iface);
 924
 925     static const WCHAR cpu_classW[] =
 926 #ifdef _WIN64
 927         {'x','6','4',0};
 928 #else
 929         {'x','8','6',0};
 930 #endif
 931
 932     TRACE("(%p)->(%p)\n", This, p);
 933
 934     *p = SysAllocString(cpu_classW);
 935     return *p ? S_OK : E_OUTOFMEMORY;
 936 }
 937
 938 static HRESULT get_language_string(LCID lcid, BSTR *p)
 939 {
 940     BSTR ret;
 941     int len;
 942
 943     len = LCIDToLocaleName(lcid, NULL, 0, 0);
 944     if(!len) {
 945         WARN("LCIDToLocaleName failed: %u\n", GetLastError());
 946         return E_FAIL;
 947     }
 948
 949     ret = SysAllocStringLen(NULL, len-1);
 950     if(!ret)
 951         return E_OUTOFMEMORY;
 952
 953     len = LCIDToLocaleName(lcid, ret, len, 0);
 954     if(!len) {
 955         WARN("LCIDToLocaleName failed: %u\n", GetLastError());
 956         SysFreeString(ret);
 957         return E_FAIL;
 958     }
 959
 960     *p = ret;
 961     return S_OK;
 962 }
 963
 964 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
 965 {
 966     OmNavigator *This = impl_from_IOmNavigator(iface);
 967
 968     TRACE("(%p)->(%p)\n", This, p);
 969
 970     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
 971 }
 972
 973 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
 974 {
 975     OmNavigator *This = impl_from_IOmNavigator(iface);
 976
 977     TRACE("(%p)->(%p)\n", This, p);
 978
 979     return get_language_string(GetUserDefaultUILanguage(), p);
 980 }
 981
 982 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
 983 {
 984     OmNavigator *This = impl_from_IOmNavigator(iface);
 985
 986     TRACE("(%p)->(%p)\n", This, p);
 987
 988     return get_language_string(LOCALE_USER_DEFAULT, p);
 989 }
 990
 991 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
 992 {
 993     OmNavigator *This = impl_from_IOmNavigator(iface);
 994
 995 #ifdef _WIN64
 996     static const WCHAR platformW[] = {'W','i','n','6','4',0};
 997 #else
 998     static const WCHAR platformW[] = {'W','i','n','3','2',0};
 999 #endif
1000
1001     TRACE("(%p)->(%p)\n", This, p);
1002
1003     *p = SysAllocString(platformW);
1004     return S_OK;
1005 }
1006
1007 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1008 {
1009     OmNavigator *This = impl_from_IOmNavigator(iface);
1010
1011     static const WCHAR zeroW[] = {'0',0};
1012
1013     TRACE("(%p)->(%p)\n", This, p);
1014
1015     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1016     *p = SysAllocString(zeroW);
1017     return S_OK;
1018 }
1019
1020 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1021 {
1022     OmNavigator *This = impl_from_IOmNavigator(iface);
1023     FIXME("(%p)->(%p)\n", This, p);
1024     return E_NOTIMPL;
1025 }
1026
1027 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1028 {
1029     OmNavigator *This = impl_from_IOmNavigator(iface);
1030
1031     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1032
1033     *p = VARIANT_TRUE;
1034     return S_OK;
1035 }
1036
1037 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1038 {
1039     OmNavigator *This = impl_from_IOmNavigator(iface);
1040     FIXME("(%p)->(%p)\n", This, p);
1041     return E_NOTIMPL;
1042 }
1043
1044 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1045     OmNavigator_QueryInterface,
1046     OmNavigator_AddRef,
1047     OmNavigator_Release,
1048     OmNavigator_GetTypeInfoCount,
1049     OmNavigator_GetTypeInfo,
1050     OmNavigator_GetIDsOfNames,
1051     OmNavigator_Invoke,
1052     OmNavigator_get_appCodeName,
1053     OmNavigator_get_appName,
1054     OmNavigator_get_appVersion,
1055     OmNavigator_get_userAgent,
1056     OmNavigator_javaEnabled,
1057     OmNavigator_taintEnabled,
1058     OmNavigator_get_mimeTypes,
1059     OmNavigator_get_plugins,
1060     OmNavigator_get_cookieEnabled,
1061     OmNavigator_get_opsProfile,
1062     OmNavigator_toString,
1063     OmNavigator_get_cpuClass,
1064     OmNavigator_get_systemLanguage,
1065     OmNavigator_get_browserLanguage,
1066     OmNavigator_get_userLanguage,
1067     OmNavigator_get_platform,
1068     OmNavigator_get_appMinorVersion,
1069     OmNavigator_get_connectionSpeed,
1070     OmNavigator_get_onLine,
1071     OmNavigator_get_userProfile
1072 };
1073
1074 static const tid_t OmNavigator_iface_tids[] = {
1075     IOmNavigator_tid,
1076     0
1077 };
1078 static dispex_static_data_t OmNavigator_dispex = {
1079     NULL,
1080     DispHTMLNavigator_tid,
1081     NULL,
1082     OmNavigator_iface_tids
1083 };
1084
1085 IOmNavigator *OmNavigator_Create(void)
1086 {
1087     OmNavigator *ret;
1088
1089     ret = heap_alloc_zero(sizeof(*ret));
1090     if(!ret)
1091         return NULL;
1092
1093     ret->IOmNavigator_iface.lpVtbl = &OmNavigatorVtbl;
1094     ret->ref = 1;
1095
1096     init_dispex(&ret->dispex, (IUnknown*)&ret->IOmNavigator_iface, &OmNavigator_dispex);
1097
1098     return &ret->IOmNavigator_iface;
1099 }