git.oblomov.eu Git - wine/blob - dlls/mshtml/script.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 "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "ole2.h"
  29 #include "activscp.h"
  30 #include "activdbg.h"
  31
  32 #include "wine/debug.h"
  33
  34 #include "mshtml_private.h"
  35 #include "binding.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  38
  39 #ifdef _WIN64
  40
  41 #define CTXARG_T DWORDLONG
  42 #define IActiveScriptSiteDebugVtbl IActiveScriptSiteDebug64Vtbl
  43
  44 #define IActiveScriptParse_Release IActiveScriptParse64_Release
  45 #define IActiveScriptParse_InitNew IActiveScriptParse64_InitNew
  46 #define IActiveScriptParse_ParseScriptText IActiveScriptParse64_ParseScriptText
  47 #define IActiveScriptParseProcedure_Release IActiveScriptParseProcedure64_Release
  48 #define IActiveScriptParseProcedure_ParseProcedureText IActiveScriptParseProcedure64_ParseProcedureText
  49
  50 #else
  51
  52 #define CTXARG_T DWORD
  53 #define IActiveScriptSiteDebugVtbl IActiveScriptSiteDebug32Vtbl
  54
  55 #define IActiveScriptParse_Release IActiveScriptParse32_Release
  56 #define IActiveScriptParse_InitNew IActiveScriptParse32_InitNew
  57 #define IActiveScriptParse_ParseScriptText IActiveScriptParse32_ParseScriptText
  58 #define IActiveScriptParseProcedure_Release IActiveScriptParseProcedure32_Release
  59 #define IActiveScriptParseProcedure_ParseProcedureText IActiveScriptParseProcedure32_ParseProcedureText
  60
  61 #endif
  62
  63 static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
  64 static const WCHAR emptyW[] = {0};
  65
  66 struct ScriptHost {
  67     IActiveScriptSite              IActiveScriptSite_iface;
  68     IActiveScriptSiteInterruptPoll IActiveScriptSiteInterruptPoll_iface;
  69     IActiveScriptSiteWindow        IActiveScriptSiteWindow_iface;
  70     IActiveScriptSiteUIControl     IActiveScriptSiteUIControl_iface;
  71     IActiveScriptSiteDebug         IActiveScriptSiteDebug_iface;
  72     IServiceProvider               IServiceProvider_iface;
  73
  74     LONG ref;
  75
  76     IActiveScript *script;
  77     IActiveScriptParse *parse;
  78     IActiveScriptParseProcedure *parse_proc;
  79
  80     SCRIPTSTATE script_state;
  81
  82     HTMLInnerWindow *window;
  83
  84     GUID guid;
  85     struct list entry;
  86 };
  87
  88 static void set_script_prop(ScriptHost *script_host, DWORD property, VARIANT *val)
  89 {
  90     IActiveScriptProperty *script_prop;
  91     HRESULT hres;
  92
  93     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptProperty,
  94             (void**)&script_prop);
  95     if(FAILED(hres)) {
  96         WARN("Could not get IActiveScriptProperty iface: %08x\n", hres);
  97         return;
  98     }
  99
 100     hres = IActiveScriptProperty_SetProperty(script_prop, property, NULL, val);
 101     IActiveScriptProperty_Release(script_prop);
 102     if(FAILED(hres))
 103         WARN("SetProperty(%x) failed: %08x\n", property, hres);
 104 }
 105
 106 static BOOL init_script_engine(ScriptHost *script_host)
 107 {
 108     IObjectSafety *safety;
 109     SCRIPTSTATE state;
 110     DWORD supported_opts=0, enabled_opts=0;
 111     VARIANT var;
 112     HRESULT hres;
 113
 114     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptParse, (void**)&script_host->parse);
 115     if(FAILED(hres)) {
 116         WARN("Could not get IActiveScriptHost: %08x\n", hres);
 117         return FALSE;
 118     }
 119
 120     hres = IActiveScript_QueryInterface(script_host->script, &IID_IObjectSafety, (void**)&safety);
 121     if(FAILED(hres)) {
 122         FIXME("Could not get IObjectSafety: %08x\n", hres);
 123         return FALSE;
 124     }
 125
 126     hres = IObjectSafety_GetInterfaceSafetyOptions(safety, &IID_IActiveScriptParse, &supported_opts, &enabled_opts);
 127     if(FAILED(hres)) {
 128         FIXME("GetInterfaceSafetyOptions failed: %08x\n", hres);
 129     }else if(!(supported_opts & INTERFACE_USES_DISPEX)) {
 130         FIXME("INTERFACE_USES_DISPEX is not supported\n");
 131     }else {
 132         hres = IObjectSafety_SetInterfaceSafetyOptions(safety, &IID_IActiveScriptParse,
 133                 INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER,
 134                 INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER);
 135         if(FAILED(hres))
 136             FIXME("SetInterfaceSafetyOptions failed: %08x\n", hres);
 137     }
 138
 139     IObjectSafety_Release(safety);
 140     if(FAILED(hres))
 141         return FALSE;
 142
 143     V_VT(&var) = VT_I4;
 144     V_I4(&var) = 1;
 145     set_script_prop(script_host, SCRIPTPROP_INVOKEVERSIONING, &var);
 146
 147     V_VT(&var) = VT_BOOL;
 148     V_BOOL(&var) = VARIANT_TRUE;
 149     set_script_prop(script_host, SCRIPTPROP_HACK_TRIDENTEVENTSINK, &var);
 150
 151     hres = IActiveScriptParse_InitNew(script_host->parse);
 152     if(FAILED(hres)) {
 153         WARN("InitNew failed: %08x\n", hres);
 154         return FALSE;
 155     }
 156
 157     hres = IActiveScript_SetScriptSite(script_host->script, &script_host->IActiveScriptSite_iface);
 158     if(FAILED(hres)) {
 159         WARN("SetScriptSite failed: %08x\n", hres);
 160         IActiveScript_Close(script_host->script);
 161         return FALSE;
 162     }
 163
 164     hres = IActiveScript_GetScriptState(script_host->script, &state);
 165     if(FAILED(hres))
 166         WARN("GetScriptState failed: %08x\n", hres);
 167     else if(state != SCRIPTSTATE_INITIALIZED)
 168         FIXME("state = %x\n", state);
 169
 170     hres = IActiveScript_SetScriptState(script_host->script, SCRIPTSTATE_STARTED);
 171     if(FAILED(hres)) {
 172         WARN("Starting script failed: %08x\n", hres);
 173         return FALSE;
 174     }
 175
 176     hres = IActiveScript_AddNamedItem(script_host->script, windowW,
 177             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
 178     if(SUCCEEDED(hres)) {
 179         V_VT(&var) = VT_BOOL;
 180         V_BOOL(&var) = VARIANT_TRUE;
 181         set_script_prop(script_host, SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION, &var);
 182     }else {
 183        WARN("AddNamedItem failed: %08x\n", hres);
 184     }
 185
 186     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptParseProcedure2,
 187                                         (void**)&script_host->parse_proc);
 188     if(FAILED(hres)) {
 189         /* FIXME: QI for IActiveScriptParseProcedure */
 190         WARN("Could not get IActiveScriptParseProcedure iface: %08x\n", hres);
 191     }
 192
 193     return TRUE;
 194 }
 195
 196 static void release_script_engine(ScriptHost *This)
 197 {
 198     if(!This->script)
 199         return;
 200
 201     switch(This->script_state) {
 202     case SCRIPTSTATE_CONNECTED:
 203         IActiveScript_SetScriptState(This->script, SCRIPTSTATE_DISCONNECTED);
 204
 205     case SCRIPTSTATE_STARTED:
 206     case SCRIPTSTATE_DISCONNECTED:
 207     case SCRIPTSTATE_INITIALIZED:
 208         IActiveScript_Close(This->script);
 209
 210     default:
 211         if(This->parse_proc) {
 212             IActiveScriptParseProcedure_Release(This->parse_proc);
 213             This->parse_proc = NULL;
 214         }
 215
 216         if(This->parse) {
 217             IActiveScriptParse_Release(This->parse);
 218             This->parse = NULL;
 219         }
 220     }
 221
 222     IActiveScript_Release(This->script);
 223     This->script = NULL;
 224     This->script_state = SCRIPTSTATE_UNINITIALIZED;
 225 }
 226
 227 void connect_scripts(HTMLInnerWindow *window)
 228 {
 229     ScriptHost *iter;
 230
 231     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
 232         if(iter->script_state == SCRIPTSTATE_STARTED)
 233             IActiveScript_SetScriptState(iter->script, SCRIPTSTATE_CONNECTED);
 234     }
 235 }
 236
 237 static inline ScriptHost *impl_from_IActiveScriptSite(IActiveScriptSite *iface)
 238 {
 239     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSite_iface);
 240 }
 241
 242 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 243 {
 244     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 245
 246     *ppv = NULL;
 247
 248     if(IsEqualGUID(&IID_IUnknown, riid)) {
 249         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 250         *ppv = &This->IActiveScriptSite_iface;
 251     }else if(IsEqualGUID(&IID_IActiveScriptSite, riid)) {
 252         TRACE("(%p)->(IID_IActiveScriptSite %p)\n", This, ppv);
 253         *ppv = &This->IActiveScriptSite_iface;
 254     }else if(IsEqualGUID(&IID_IActiveScriptSiteInterruptPoll, riid)) {
 255         TRACE("(%p)->(IID_IActiveScriptSiteInterruprtPoll %p)\n", This, ppv);
 256         *ppv = &This->IActiveScriptSiteInterruptPoll_iface;
 257     }else if(IsEqualGUID(&IID_IActiveScriptSiteWindow, riid)) {
 258         TRACE("(%p)->(IID_IActiveScriptSiteWindow %p)\n", This, ppv);
 259         *ppv = &This->IActiveScriptSiteWindow_iface;
 260     }else if(IsEqualGUID(&IID_IActiveScriptSiteUIControl, riid)) {
 261         TRACE("(%p)->(IID_IActiveScriptSiteUIControl %p)\n", This, ppv);
 262         *ppv = &This->IActiveScriptSiteUIControl_iface;
 263     }else if(IsEqualGUID(&IID_IActiveScriptSiteDebug, riid)) {
 264         TRACE("(%p)->(IID_IActiveScriptSiteDebug %p)\n", This, ppv);
 265         *ppv = &This->IActiveScriptSiteDebug_iface;
 266     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 267         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 268         *ppv = &This->IServiceProvider_iface;
 269     }else if(IsEqualGUID(&IID_ICanHandleException, riid)) {
 270         TRACE("(%p)->(IID_ICanHandleException not supported %p)\n", This, ppv);
 271         return E_NOINTERFACE;
 272     }else {
 273         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 274         return E_NOINTERFACE;
 275     }
 276
 277     IUnknown_AddRef((IUnknown*)*ppv);
 278     return S_OK;
 279 }
 280
 281 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 282 {
 283     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 284     LONG ref = InterlockedIncrement(&This->ref);
 285
 286     TRACE("(%p) ref=%d\n", This, ref);
 287
 288     return ref;
 289 }
 290
 291 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 292 {
 293     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 294     LONG ref = InterlockedDecrement(&This->ref);
 295
 296     TRACE("(%p) ref=%d\n", This, ref);
 297
 298     if(!ref) {
 299         release_script_engine(This);
 300         if(This->window)
 301             list_remove(&This->entry);
 302         heap_free(This);
 303     }
 304
 305     return ref;
 306 }
 307
 308 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
 309 {
 310     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 311
 312     TRACE("(%p)->(%p)\n", This, plcid);
 313
 314     *plcid = GetUserDefaultLCID();
 315     return S_OK;
 316 }
 317
 318 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
 319         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
 320 {
 321     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 322
 323     TRACE("(%p)->(%s %x %p %p)\n", This, debugstr_w(pstrName), dwReturnMask, ppiunkItem, ppti);
 324
 325     if(dwReturnMask != SCRIPTINFO_IUNKNOWN) {
 326         FIXME("Unsupported mask %x\n", dwReturnMask);
 327         return E_NOTIMPL;
 328     }
 329
 330     *ppiunkItem = NULL;
 331
 332     if(strcmpW(pstrName, windowW))
 333         return DISP_E_MEMBERNOTFOUND;
 334
 335     if(!This->window)
 336         return E_FAIL;
 337
 338     /* FIXME: Return proxy object */
 339     *ppiunkItem = (IUnknown*)&This->window->base.IHTMLWindow2_iface;
 340     IUnknown_AddRef(*ppiunkItem);
 341
 342     return S_OK;
 343 }
 344
 345 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
 346 {
 347     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 348     FIXME("(%p)->(%p)\n", This, pbstrVersion);
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 353         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 354 {
 355     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 356     FIXME("(%p)->(%p %p)\n", This, pvarResult, pexcepinfo);
 357     return E_NOTIMPL;
 358 }
 359
 360 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
 361 {
 362     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 363
 364     TRACE("(%p)->(%x)\n", This, ssScriptState);
 365
 366     This->script_state = ssScriptState;
 367     return S_OK;
 368 }
 369
 370 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
 371 {
 372     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 373     FIXME("(%p)->(%p)\n", This, pscripterror);
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 378 {
 379     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 380
 381     TRACE("(%p)->()\n", This);
 382
 383     return S_OK;
 384 }
 385
 386 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 387 {
 388     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 389
 390     TRACE("(%p)->()\n", This);
 391
 392     return S_OK;
 393 }
 394
 395 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 396     ActiveScriptSite_QueryInterface,
 397     ActiveScriptSite_AddRef,
 398     ActiveScriptSite_Release,
 399     ActiveScriptSite_GetLCID,
 400     ActiveScriptSite_GetItemInfo,
 401     ActiveScriptSite_GetDocVersionString,
 402     ActiveScriptSite_OnScriptTerminate,
 403     ActiveScriptSite_OnStateChange,
 404     ActiveScriptSite_OnScriptError,
 405     ActiveScriptSite_OnEnterScript,
 406     ActiveScriptSite_OnLeaveScript
 407 };
 408
 409 static inline ScriptHost *impl_from_IActiveScriptSiteInterruptPoll(IActiveScriptSiteInterruptPoll *iface)
 410 {
 411     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSiteInterruptPoll_iface);
 412 }
 413
 414 static HRESULT WINAPI ActiveScriptSiteInterruptPoll_QueryInterface(IActiveScriptSiteInterruptPoll *iface,
 415         REFIID riid, void **ppv)
 416 {
 417     ScriptHost *This = impl_from_IActiveScriptSiteInterruptPoll(iface);
 418     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 419 }
 420
 421 static ULONG WINAPI ActiveScriptSiteInterruptPoll_AddRef(IActiveScriptSiteInterruptPoll *iface)
 422 {
 423     ScriptHost *This = impl_from_IActiveScriptSiteInterruptPoll(iface);
 424     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 425 }
 426
 427 static ULONG WINAPI ActiveScriptSiteInterruptPoll_Release(IActiveScriptSiteInterruptPoll *iface)
 428 {
 429     ScriptHost *This = impl_from_IActiveScriptSiteInterruptPoll(iface);
 430     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 431 }
 432
 433 static HRESULT WINAPI ActiveScriptSiteInterruptPoll_QueryContinue(IActiveScriptSiteInterruptPoll *iface)
 434 {
 435     ScriptHost *This = impl_from_IActiveScriptSiteInterruptPoll(iface);
 436
 437     TRACE("(%p)\n", This);
 438
 439     return S_OK;
 440 }
 441
 442 static const IActiveScriptSiteInterruptPollVtbl ActiveScriptSiteInterruptPollVtbl = {
 443     ActiveScriptSiteInterruptPoll_QueryInterface,
 444     ActiveScriptSiteInterruptPoll_AddRef,
 445     ActiveScriptSiteInterruptPoll_Release,
 446     ActiveScriptSiteInterruptPoll_QueryContinue
 447 };
 448
 449 static inline ScriptHost *impl_from_IActiveScriptSiteWindow(IActiveScriptSiteWindow *iface)
 450 {
 451     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSiteWindow_iface);
 452 }
 453
 454 static HRESULT WINAPI ActiveScriptSiteWindow_QueryInterface(IActiveScriptSiteWindow *iface,
 455         REFIID riid, void **ppv)
 456 {
 457     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 458     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 459 }
 460
 461 static ULONG WINAPI ActiveScriptSiteWindow_AddRef(IActiveScriptSiteWindow *iface)
 462 {
 463     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 464     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 465 }
 466
 467 static ULONG WINAPI ActiveScriptSiteWindow_Release(IActiveScriptSiteWindow *iface)
 468 {
 469     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 470     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 471 }
 472
 473 static HRESULT WINAPI ActiveScriptSiteWindow_GetWindow(IActiveScriptSiteWindow *iface, HWND *phwnd)
 474 {
 475     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 476
 477     TRACE("(%p)->(%p)\n", This, phwnd);
 478
 479     if(!This->window || !This->window->base.outer_window || !This->window->base.outer_window->doc_obj)
 480         return E_UNEXPECTED;
 481
 482     *phwnd = This->window->base.outer_window->doc_obj->hwnd;
 483     return S_OK;
 484 }
 485
 486 static HRESULT WINAPI ActiveScriptSiteWindow_EnableModeless(IActiveScriptSiteWindow *iface, BOOL fEnable)
 487 {
 488     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 489     FIXME("(%p)->(%x)\n", This, fEnable);
 490     return S_OK;
 491 }
 492
 493 static const IActiveScriptSiteWindowVtbl ActiveScriptSiteWindowVtbl = {
 494     ActiveScriptSiteWindow_QueryInterface,
 495     ActiveScriptSiteWindow_AddRef,
 496     ActiveScriptSiteWindow_Release,
 497     ActiveScriptSiteWindow_GetWindow,
 498     ActiveScriptSiteWindow_EnableModeless
 499 };
 500
 501 static inline ScriptHost *impl_from_IActiveScriptSiteUIControl(IActiveScriptSiteUIControl *iface)
 502 {
 503     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSiteUIControl_iface);
 504 }
 505
 506 static HRESULT WINAPI ActiveScriptSiteUIControl_QueryInterface(IActiveScriptSiteUIControl *iface, REFIID riid, void **ppv)
 507 {
 508     ScriptHost *This = impl_from_IActiveScriptSiteUIControl(iface);
 509     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 510 }
 511
 512 static ULONG WINAPI ActiveScriptSiteUIControl_AddRef(IActiveScriptSiteUIControl *iface)
 513 {
 514     ScriptHost *This = impl_from_IActiveScriptSiteUIControl(iface);
 515     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 516 }
 517
 518 static ULONG WINAPI ActiveScriptSiteUIControl_Release(IActiveScriptSiteUIControl *iface)
 519 {
 520     ScriptHost *This = impl_from_IActiveScriptSiteUIControl(iface);
 521     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 522 }
 523
 524 static HRESULT WINAPI ActiveScriptSiteUIControl_GetUIBehavior(IActiveScriptSiteUIControl *iface, SCRIPTUICITEM UicItem,
 525         SCRIPTUICHANDLING *pUicHandling)
 526 {
 527     ScriptHost *This = impl_from_IActiveScriptSiteUIControl(iface);
 528
 529     WARN("(%p)->(%d %p) semi-stub\n", This, UicItem, pUicHandling);
 530
 531     *pUicHandling = SCRIPTUICHANDLING_ALLOW;
 532     return S_OK;
 533 }
 534
 535 static const IActiveScriptSiteUIControlVtbl ActiveScriptSiteUIControlVtbl = {
 536     ActiveScriptSiteUIControl_QueryInterface,
 537     ActiveScriptSiteUIControl_AddRef,
 538     ActiveScriptSiteUIControl_Release,
 539     ActiveScriptSiteUIControl_GetUIBehavior
 540 };
 541
 542 static inline ScriptHost *impl_from_IActiveScriptSiteDebug(IActiveScriptSiteDebug *iface)
 543 {
 544     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSiteDebug_iface);
 545 }
 546
 547 static HRESULT WINAPI ActiveScriptSiteDebug_QueryInterface(IActiveScriptSiteDebug *iface,
 548         REFIID riid, void **ppv)
 549 {
 550     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 551     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 552 }
 553
 554 static ULONG WINAPI ActiveScriptSiteDebug_AddRef(IActiveScriptSiteDebug *iface)
 555 {
 556     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 557     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 558 }
 559
 560 static ULONG WINAPI ActiveScriptSiteDebug_Release(IActiveScriptSiteDebug *iface)
 561 {
 562     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 563     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 564 }
 565
 566 static HRESULT WINAPI ActiveScriptSiteDebug_GetDocumentContextFromPosition(IActiveScriptSiteDebug *iface,
 567             CTXARG_T dwSourceContext, ULONG uCharacterOffset, ULONG uNumChars, IDebugDocumentContext **ppsc)
 568 {
 569     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 570     FIXME("(%p)->(%s %u %u %p)\n", This, wine_dbgstr_longlong(dwSourceContext), uCharacterOffset,
 571           uNumChars, ppsc);
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI ActiveScriptSiteDebug_GetApplication(IActiveScriptSiteDebug *iface, IDebugApplication **ppda)
 576 {
 577     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 578     FIXME("(%p)->(%p)\n", This, ppda);
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI ActiveScriptSiteDebug_GetRootApplicationNode(IActiveScriptSiteDebug *iface,
 583             IDebugApplicationNode **ppdanRoot)
 584 {
 585     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 586     FIXME("(%p)->(%p)\n", This, ppdanRoot);
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI ActiveScriptSiteDebug_OnScriptErrorDebug(IActiveScriptSiteDebug *iface,
 591             IActiveScriptErrorDebug *pErrorDebug, BOOL *pfEnterDebugger, BOOL *pfCallOnScriptErrorWhenContinuing)
 592 {
 593     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 594     FIXME("(%p)->(%p %p %p)\n", This, pErrorDebug, pfEnterDebugger, pfCallOnScriptErrorWhenContinuing);
 595     return E_NOTIMPL;
 596 }
 597
 598 static const IActiveScriptSiteDebugVtbl ActiveScriptSiteDebugVtbl = {
 599     ActiveScriptSiteDebug_QueryInterface,
 600     ActiveScriptSiteDebug_AddRef,
 601     ActiveScriptSiteDebug_Release,
 602     ActiveScriptSiteDebug_GetDocumentContextFromPosition,
 603     ActiveScriptSiteDebug_GetApplication,
 604     ActiveScriptSiteDebug_GetRootApplicationNode,
 605     ActiveScriptSiteDebug_OnScriptErrorDebug
 606 };
 607
 608 static inline ScriptHost *impl_from_IServiceProvider(IServiceProvider *iface)
 609 {
 610     return CONTAINING_RECORD(iface, ScriptHost, IServiceProvider_iface);
 611 }
 612
 613 static HRESULT WINAPI ASServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
 614 {
 615     ScriptHost *This = impl_from_IServiceProvider(iface);
 616     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 617 }
 618
 619 static ULONG WINAPI ASServiceProvider_AddRef(IServiceProvider *iface)
 620 {
 621     ScriptHost *This = impl_from_IServiceProvider(iface);
 622     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 623 }
 624
 625 static ULONG WINAPI ASServiceProvider_Release(IServiceProvider *iface)
 626 {
 627     ScriptHost *This = impl_from_IServiceProvider(iface);
 628     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 629 }
 630
 631 static HRESULT WINAPI ASServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
 632         REFIID riid, void **ppv)
 633 {
 634     ScriptHost *This = impl_from_IServiceProvider(iface);
 635
 636     if(IsEqualGUID(&SID_SInternetHostSecurityManager, guidService)) {
 637         TRACE("(%p)->(SID_SInternetHostSecurityManager)\n", This);
 638
 639         if(!This->window || !This->window->doc)
 640             return E_NOINTERFACE;
 641
 642         return IInternetHostSecurityManager_QueryInterface(&This->window->doc->IInternetHostSecurityManager_iface,
 643                 riid, ppv);
 644     }
 645
 646     FIXME("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 647     return E_NOINTERFACE;
 648 }
 649
 650 static const IServiceProviderVtbl ASServiceProviderVtbl = {
 651     ASServiceProvider_QueryInterface,
 652     ASServiceProvider_AddRef,
 653     ASServiceProvider_Release,
 654     ASServiceProvider_QueryService
 655 };
 656
 657 static ScriptHost *create_script_host(HTMLInnerWindow *window, const GUID *guid)
 658 {
 659     ScriptHost *ret;
 660     HRESULT hres;
 661
 662     ret = heap_alloc_zero(sizeof(*ret));
 663     ret->IActiveScriptSite_iface.lpVtbl = &ActiveScriptSiteVtbl;
 664     ret->IActiveScriptSiteInterruptPoll_iface.lpVtbl = &ActiveScriptSiteInterruptPollVtbl;
 665     ret->IActiveScriptSiteWindow_iface.lpVtbl = &ActiveScriptSiteWindowVtbl;
 666     ret->IActiveScriptSiteUIControl_iface.lpVtbl = &ActiveScriptSiteUIControlVtbl;
 667     ret->IActiveScriptSiteDebug_iface.lpVtbl = &ActiveScriptSiteDebugVtbl;
 668     ret->IServiceProvider_iface.lpVtbl = &ASServiceProviderVtbl;
 669     ret->ref = 1;
 670     ret->window = window;
 671     ret->script_state = SCRIPTSTATE_UNINITIALIZED;
 672
 673     ret->guid = *guid;
 674     list_add_tail(&window->script_hosts, &ret->entry);
 675
 676     hres = CoCreateInstance(&ret->guid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 677             &IID_IActiveScript, (void**)&ret->script);
 678     if(FAILED(hres))
 679         WARN("Could not load script engine: %08x\n", hres);
 680     else if(!init_script_engine(ret))
 681         release_script_engine(ret);
 682
 683     return ret;
 684 }
 685
 686 static void parse_text(ScriptHost *script_host, LPCWSTR text)
 687 {
 688     EXCEPINFO excepinfo;
 689     VARIANT var;
 690     HRESULT hres;
 691
 692     static const WCHAR script_endW[] = {'<','/','S','C','R','I','P','T','>',0};
 693
 694     TRACE("%s\n", debugstr_w(text));
 695
 696     VariantInit(&var);
 697     memset(&excepinfo, 0, sizeof(excepinfo));
 698     TRACE(">>>\n");
 699     hres = IActiveScriptParse_ParseScriptText(script_host->parse, text, windowW, NULL, script_endW,
 700                                               0, 0, SCRIPTTEXT_ISVISIBLE|SCRIPTTEXT_HOSTMANAGESSOURCE,
 701                                               &var, &excepinfo);
 702     if(SUCCEEDED(hres))
 703         TRACE("<<<\n");
 704     else
 705         WARN("<<< %08x\n", hres);
 706
 707 }
 708
 709 static void parse_extern_script(ScriptHost *script_host, LPCWSTR src)
 710 {
 711     IMoniker *mon;
 712     WCHAR *text;
 713     HRESULT hres;
 714
 715     static const WCHAR wine_schemaW[] = {'w','i','n','e',':'};
 716
 717     if(strlenW(src) > sizeof(wine_schemaW)/sizeof(WCHAR) && !memcmp(src, wine_schemaW, sizeof(wine_schemaW)))
 718         src += sizeof(wine_schemaW)/sizeof(WCHAR);
 719
 720     hres = CreateURLMoniker(NULL, src, &mon);
 721     if(FAILED(hres))
 722         return;
 723
 724     hres = bind_mon_to_wstr(script_host->window, mon, &text);
 725     IMoniker_Release(mon);
 726     if(FAILED(hres))
 727         return;
 728
 729     parse_text(script_host, text);
 730
 731     heap_free(text);
 732 }
 733
 734 static void parse_inline_script(ScriptHost *script_host, nsIDOMHTMLScriptElement *nsscript)
 735 {
 736     const PRUnichar *text;
 737     nsAString text_str;
 738     nsresult nsres;
 739
 740     nsAString_Init(&text_str, NULL);
 741
 742     nsres = nsIDOMHTMLScriptElement_GetText(nsscript, &text_str);
 743
 744     if(NS_SUCCEEDED(nsres)) {
 745         nsAString_GetData(&text_str, &text);
 746         parse_text(script_host, text);
 747     }else {
 748         ERR("GetText failed: %08x\n", nsres);
 749     }
 750
 751     nsAString_Finish(&text_str);
 752 }
 753
 754 static void parse_script_elem(ScriptHost *script_host, nsIDOMHTMLScriptElement *nsscript)
 755 {
 756     const PRUnichar *src;
 757     nsAString src_str;
 758     nsresult nsres;
 759
 760     nsAString_Init(&src_str, NULL);
 761
 762     nsres = nsIDOMHTMLScriptElement_GetSrc(nsscript, &src_str);
 763     nsAString_GetData(&src_str, &src);
 764
 765     if(NS_FAILED(nsres))
 766         ERR("GetSrc failed: %08x\n", nsres);
 767     else if(*src)
 768         parse_extern_script(script_host, src);
 769     else
 770         parse_inline_script(script_host, nsscript);
 771
 772     nsAString_Finish(&src_str);
 773 }
 774
 775 static GUID get_default_script_guid(HTMLInnerWindow *window)
 776 {
 777     /* If not specified, we should use very first script host that was created for the page (or JScript if none) */
 778     return list_empty(&window->script_hosts)
 779         ? CLSID_JScript
 780         : LIST_ENTRY(list_head(&window->script_hosts), ScriptHost, entry)->guid;
 781 }
 782
 783 static BOOL get_guid_from_type(LPCWSTR type, GUID *guid)
 784 {
 785     const WCHAR text_javascriptW[] =
 786         {'t','e','x','t','/','j','a','v','a','s','c','r','i','p','t',0};
 787     const WCHAR text_vbscriptW[] =
 788         {'t','e','x','t','/','v','b','s','c','r','i','p','t',0};
 789
 790     /* FIXME: Handle more types */
 791     if(!strcmpiW(type, text_javascriptW)) {
 792         *guid = CLSID_JScript;
 793     }else if(!strcmpiW(type, text_vbscriptW)) {
 794         *guid = CLSID_VBScript;
 795     }else {
 796         FIXME("Unknown type %s\n", debugstr_w(type));
 797         return FALSE;
 798     }
 799
 800     return TRUE;
 801 }
 802
 803 static BOOL get_guid_from_language(LPCWSTR type, GUID *guid)
 804 {
 805     HRESULT hres;
 806
 807     hres = CLSIDFromProgID(type, guid);
 808     if(FAILED(hres))
 809         return FALSE;
 810
 811     /* FIXME: Check CATID_ActiveScriptParse */
 812
 813     return TRUE;
 814 }
 815
 816 static BOOL get_script_guid(HTMLInnerWindow *window, nsIDOMHTMLScriptElement *nsscript, GUID *guid)
 817 {
 818     nsAString attr_str, val_str;
 819     BOOL ret = FALSE;
 820     nsresult nsres;
 821
 822     static const PRUnichar languageW[] = {'l','a','n','g','u','a','g','e',0};
 823
 824     nsAString_Init(&val_str, NULL);
 825
 826     nsres = nsIDOMHTMLScriptElement_GetType(nsscript, &val_str);
 827     if(NS_SUCCEEDED(nsres)) {
 828         const PRUnichar *type;
 829
 830         nsAString_GetData(&val_str, &type);
 831         if(*type) {
 832             ret = get_guid_from_type(type, guid);
 833             nsAString_Finish(&val_str);
 834             return ret;
 835         }
 836     }else {
 837         ERR("GetType failed: %08x\n", nsres);
 838     }
 839
 840     nsAString_InitDepend(&attr_str, languageW);
 841     nsres = nsIDOMHTMLScriptElement_GetAttribute(nsscript, &attr_str, &val_str);
 842     nsAString_Finish(&attr_str);
 843     if(NS_SUCCEEDED(nsres)) {
 844         const PRUnichar *language;
 845
 846         nsAString_GetData(&val_str, &language);
 847
 848         if(*language) {
 849             ret = get_guid_from_language(language, guid);
 850         }else {
 851             *guid = get_default_script_guid(window);
 852             ret = TRUE;
 853         }
 854     }else {
 855         ERR("GetAttribute(language) failed: %08x\n", nsres);
 856     }
 857
 858     nsAString_Finish(&val_str);
 859
 860     return ret;
 861 }
 862
 863 static ScriptHost *get_script_host(HTMLInnerWindow *window, const GUID *guid)
 864 {
 865     ScriptHost *iter;
 866
 867     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
 868         if(IsEqualGUID(guid, &iter->guid))
 869             return iter;
 870     }
 871
 872     return create_script_host(window, guid);
 873 }
 874
 875 void doc_insert_script(HTMLInnerWindow *window, nsIDOMHTMLScriptElement *nsscript)
 876 {
 877     ScriptHost *script_host;
 878     GUID guid;
 879
 880     if(!get_script_guid(window, nsscript, &guid)) {
 881         WARN("Could not find script GUID\n");
 882         return;
 883     }
 884
 885     if(IsEqualGUID(&CLSID_JScript, &guid)
 886        && (!window->base.outer_window || window->base.outer_window->scriptmode != SCRIPTMODE_ACTIVESCRIPT)) {
 887         TRACE("Ignoring JScript\n");
 888         return;
 889     }
 890
 891     script_host = get_script_host(window, &guid);
 892     if(!script_host)
 893         return;
 894
 895     if(script_host->parse)
 896         parse_script_elem(script_host, nsscript);
 897 }
 898
 899 IDispatch *script_parse_event(HTMLInnerWindow *window, LPCWSTR text)
 900 {
 901     ScriptHost *script_host;
 902     GUID guid;
 903     const WCHAR *ptr;
 904     IDispatch *disp;
 905     HRESULT hres;
 906
 907     static const WCHAR delimiterW[] = {'\"',0};
 908
 909     TRACE("%s\n", debugstr_w(text));
 910
 911     for(ptr = text; isalnumW(*ptr); ptr++);
 912     if(*ptr == ':') {
 913         LPWSTR language;
 914         BOOL b;
 915
 916         language = heap_alloc((ptr-text+1)*sizeof(WCHAR));
 917         memcpy(language, text, (ptr-text)*sizeof(WCHAR));
 918         language[ptr-text] = 0;
 919
 920         b = get_guid_from_language(language, &guid);
 921
 922         heap_free(language);
 923
 924         if(!b) {
 925             WARN("Could not find language\n");
 926             return NULL;
 927         }
 928
 929         ptr++;
 930     }else {
 931         ptr = text;
 932         guid = get_default_script_guid(window);
 933     }
 934
 935     if(IsEqualGUID(&CLSID_JScript, &guid)
 936        && (!window->base.outer_window || window->base.outer_window->scriptmode != SCRIPTMODE_ACTIVESCRIPT)) {
 937         TRACE("Ignoring JScript\n");
 938         return NULL;
 939     }
 940
 941     script_host = get_script_host(window, &guid);
 942     if(!script_host || !script_host->parse_proc)
 943         return NULL;
 944
 945     hres = IActiveScriptParseProcedure_ParseProcedureText(script_host->parse_proc, ptr, NULL, emptyW,
 946             NULL, NULL, delimiterW, 0 /* FIXME */, 0,
 947             SCRIPTPROC_HOSTMANAGESSOURCE|SCRIPTPROC_IMPLICIT_THIS|SCRIPTPROC_IMPLICIT_PARENTS, &disp);
 948     if(FAILED(hres)) {
 949         WARN("ParseProcedureText failed: %08x\n", hres);
 950         return NULL;
 951     }
 952
 953     TRACE("ret %p\n", disp);
 954     return disp;
 955 }
 956
 957 HRESULT exec_script(HTMLInnerWindow *window, const WCHAR *code, const WCHAR *lang, VARIANT *ret)
 958 {
 959     ScriptHost *script_host;
 960     EXCEPINFO ei;
 961     GUID guid;
 962     HRESULT hres;
 963
 964     static const WCHAR delimW[] = {'"',0};
 965
 966     if(!get_guid_from_language(lang, &guid)) {
 967         WARN("Could not find script GUID\n");
 968         return CO_E_CLASSSTRING;
 969     }
 970
 971     script_host = get_script_host(window, &guid);
 972     if(!script_host) {
 973         FIXME("No script host\n");
 974         return E_FAIL;
 975     }
 976
 977     if(!script_host->parse) {
 978         FIXME("script_host->parse == NULL\n");
 979         return E_FAIL;
 980     }
 981
 982     memset(&ei, 0, sizeof(ei));
 983     TRACE(">>>\n");
 984     hres = IActiveScriptParse_ParseScriptText(script_host->parse, code, NULL, NULL, delimW, 0, 0, SCRIPTTEXT_ISVISIBLE, ret, &ei);
 985     if(SUCCEEDED(hres))
 986         TRACE("<<<\n");
 987     else
 988         WARN("<<< %08x\n", hres);
 989
 990     return hres;
 991 }
 992
 993 IDispatch *get_script_disp(ScriptHost *script_host)
 994 {
 995     IDispatch *disp;
 996     HRESULT hres;
 997
 998     if(!script_host->script)
 999         return NULL;
1000
1001     hres = IActiveScript_GetScriptDispatch(script_host->script, windowW, &disp);
1002     if(FAILED(hres))
1003         return NULL;
1004
1005     return disp;
1006 }
1007
1008 BOOL find_global_prop(HTMLInnerWindow *window, BSTR name, DWORD flags, ScriptHost **ret_host, DISPID *ret_id)
1009 {
1010     IDispatchEx *dispex;
1011     IDispatch *disp;
1012     ScriptHost *iter;
1013     HRESULT hres;
1014
1015     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
1016         disp = get_script_disp(iter);
1017         if(!disp)
1018             continue;
1019
1020         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1021         if(SUCCEEDED(hres)) {
1022             hres = IDispatchEx_GetDispID(dispex, name, flags & (~fdexNameEnsure), ret_id);
1023             IDispatchEx_Release(dispex);
1024         }else {
1025             FIXME("No IDispatchEx\n");
1026             hres = E_NOTIMPL;
1027         }
1028
1029         IDispatch_Release(disp);
1030         if(SUCCEEDED(hres)) {
1031             *ret_host = iter;
1032             return TRUE;
1033         }
1034     }
1035
1036     return FALSE;
1037 }
1038
1039 static BOOL is_jscript_available(void)
1040 {
1041     static BOOL available, checked;
1042
1043     if(!checked) {
1044         IUnknown *unk;
1045         HRESULT hres = CoGetClassObject(&CLSID_JScript, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
1046
1047         if(SUCCEEDED(hres)) {
1048             available = TRUE;
1049             IUnknown_Release(unk);
1050         }else {
1051             available = FALSE;
1052         }
1053         checked = TRUE;
1054     }
1055
1056     return available;
1057 }
1058
1059 void set_script_mode(HTMLOuterWindow *window, SCRIPTMODE mode)
1060 {
1061     nsIWebBrowserSetup *setup;
1062     nsresult nsres;
1063
1064     if(mode == SCRIPTMODE_ACTIVESCRIPT && !is_jscript_available()) {
1065         TRACE("jscript.dll not available\n");
1066         window->scriptmode = SCRIPTMODE_GECKO;
1067         return;
1068     }
1069
1070     window->scriptmode = mode;
1071
1072     if(!window->doc_obj->nscontainer || !window->doc_obj->nscontainer->webbrowser)
1073         return;
1074
1075     nsres = nsIWebBrowser_QueryInterface(window->doc_obj->nscontainer->webbrowser,
1076             &IID_nsIWebBrowserSetup, (void**)&setup);
1077     if(NS_SUCCEEDED(nsres)) {
1078         nsres = nsIWebBrowserSetup_SetProperty(setup, SETUP_ALLOW_JAVASCRIPT,
1079                 window->scriptmode == SCRIPTMODE_GECKO);
1080         nsIWebBrowserSetup_Release(setup);
1081     }
1082
1083     if(NS_FAILED(nsres))
1084         ERR("JavaScript setup failed: %08x\n", nsres);
1085 }
1086
1087 void release_script_hosts(HTMLInnerWindow *window)
1088 {
1089     ScriptHost *iter;
1090
1091     while(!list_empty(&window->script_hosts)) {
1092         iter = LIST_ENTRY(list_head(&window->script_hosts), ScriptHost, entry);
1093
1094         release_script_engine(iter);
1095         list_remove(&iter->entry);
1096         iter->window = NULL;
1097         IActiveScriptSite_Release(&iter->IActiveScriptSite_iface);
1098     }
1099 }