git.oblomov.eu Git - wine/blob - dlls/mshtml/nsembed.c

   1 /*
   2  * Copyright 2005-2007 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 "winreg.h"
  29 #include "ole2.h"
  30 #include "shlobj.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/unicode.h"
  34
  35 #include "mshtml_private.h"
  36 #include "htmlevent.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  39 WINE_DECLARE_DEBUG_CHANNEL(gecko);
  40
  41 #define NS_APPSTARTUPNOTIFIER_CONTRACTID "@mozilla.org/embedcomp/appstartup-notifier;1"
  42 #define NS_WEBBROWSER_CONTRACTID "@mozilla.org/embedding/browser/nsWebBrowser;1"
  43 #define NS_MEMORY_CONTRACTID "@mozilla.org/xpcom/memory-service;1"
  44 #define NS_COMMANDPARAMS_CONTRACTID "@mozilla.org/embedcomp/command-params;1"
  45 #define NS_HTMLSERIALIZER_CONTRACTID "@mozilla.org/layout/contentserializer;1?mimetype=text/html"
  46 #define NS_EDITORCONTROLLER_CONTRACTID "@mozilla.org/editor/editorcontroller;1"
  47 #define NS_PREFERENCES_CONTRACTID "@mozilla.org/preferences;1"
  48
  49 #define PR_UINT32_MAX 0xffffffff
  50
  51 #define NS_STRING_CONTAINER_INIT_DEPEND  0x0002
  52 #define NS_CSTRING_CONTAINER_INIT_DEPEND 0x0002
  53
  54 static nsresult (CDECL *NS_InitXPCOM2)(nsIServiceManager**,void*,void*);
  55 static nsresult (CDECL *NS_ShutdownXPCOM)(nsIServiceManager*);
  56 static nsresult (CDECL *NS_GetComponentRegistrar)(nsIComponentRegistrar**);
  57 static nsresult (CDECL *NS_StringContainerInit2)(nsStringContainer*,const PRUnichar*,PRUint32,PRUint32);
  58 static nsresult (CDECL *NS_CStringContainerInit2)(nsCStringContainer*,const char*,PRUint32,PRUint32);
  59 static nsresult (CDECL *NS_StringContainerFinish)(nsStringContainer*);
  60 static nsresult (CDECL *NS_CStringContainerFinish)(nsCStringContainer*);
  61 static nsresult (CDECL *NS_StringSetData)(nsAString*,const PRUnichar*,PRUint32);
  62 static nsresult (CDECL *NS_CStringSetData)(nsACString*,const char*,PRUint32);
  63 static nsresult (CDECL *NS_NewLocalFile)(const nsAString*,PRBool,nsIFile**);
  64 static PRUint32 (CDECL *NS_StringGetData)(const nsAString*,const PRUnichar **,PRBool*);
  65 static PRUint32 (CDECL *NS_CStringGetData)(const nsACString*,const char**,PRBool*);
  66
  67 static HINSTANCE xul_handle = NULL;
  68
  69 static nsIServiceManager *pServMgr = NULL;
  70 static nsIComponentManager *pCompMgr = NULL;
  71 static nsIMemory *nsmem = NULL;
  72 static nsIFile *profile_directory;
  73
  74 static const WCHAR wszNsContainer[] = {'N','s','C','o','n','t','a','i','n','e','r',0};
  75
  76 static ATOM nscontainer_class;
  77 static WCHAR gecko_path[MAX_PATH];
  78 static unsigned gecko_path_len;
  79
  80 static nsresult NSAPI nsDirectoryServiceProvider_QueryInterface(nsIDirectoryServiceProvider *iface,
  81         nsIIDRef riid, void **result)
  82 {
  83     if(IsEqualGUID(&IID_nsISupports, riid)) {
  84         TRACE("(IID_nsISupports %p)\n", result);
  85         *result = iface;
  86     }else if(IsEqualGUID(&IID_nsIDirectoryServiceProvider, riid)) {
  87         TRACE("(IID_nsIDirectoryServiceProvider %p)\n", result);
  88         *result = iface;
  89     }else {
  90         WARN("(%s %p)\n", debugstr_guid(riid), result);
  91         *result = NULL;
  92         return NS_NOINTERFACE;
  93     }
  94
  95     nsISupports_AddRef((nsISupports*)*result);
  96     return NS_OK;
  97 }
  98
  99 static nsrefcnt NSAPI nsDirectoryServiceProvider_AddRef(nsIDirectoryServiceProvider *iface)
 100 {
 101     return 2;
 102 }
 103
 104 static nsrefcnt NSAPI nsDirectoryServiceProvider_Release(nsIDirectoryServiceProvider *iface)
 105 {
 106     return 1;
 107 }
 108
 109 static nsresult create_profile_directory(void)
 110 {
 111     static const WCHAR wine_geckoW[] = {'\\','w','i','n','e','_','g','e','c','k','o',0};
 112
 113     WCHAR path[MAX_PATH + sizeof(wine_geckoW)/sizeof(WCHAR)];
 114     nsAString str;
 115     PRBool exists;
 116     nsresult nsres;
 117     HRESULT hres;
 118
 119     hres = SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_DEFAULT, path);
 120     if(FAILED(hres)) {
 121         ERR("SHGetFolderPath failed: %08x\n", hres);
 122         return NS_ERROR_FAILURE;
 123     }
 124
 125     strcatW(path, wine_geckoW);
 126     nsAString_InitDepend(&str, path);
 127     nsres = NS_NewLocalFile(&str, FALSE, &profile_directory);
 128     nsAString_Finish(&str);
 129     if(NS_FAILED(nsres)) {
 130         ERR("NS_NewLocalFile failed: %08x\n", nsres);
 131         return nsres;
 132     }
 133
 134     nsres = nsIFile_Exists(profile_directory, &exists);
 135     if(NS_FAILED(nsres)) {
 136         ERR("Exists failed: %08x\n", nsres);
 137         return nsres;
 138     }
 139
 140     if(!exists) {
 141         nsres = nsIFile_Create(profile_directory, 1, 0700);
 142         if(NS_FAILED(nsres))
 143             ERR("Create failed: %08x\n", nsres);
 144     }
 145
 146     return nsres;
 147 }
 148
 149 static nsresult NSAPI nsDirectoryServiceProvider_GetFile(nsIDirectoryServiceProvider *iface,
 150         const char *prop, PRBool *persistent, nsIFile **_retval)
 151 {
 152     TRACE("(%s %p %p)\n", debugstr_a(prop), persistent, _retval);
 153
 154     if(!strcmp(prop, "ProfD")) {
 155         if(!profile_directory) {
 156             nsresult nsres;
 157
 158             nsres = create_profile_directory();
 159             if(NS_FAILED(nsres))
 160                 return nsres;
 161         }
 162
 163         return nsIFile_Clone(profile_directory, _retval);
 164     }
 165
 166     return NS_ERROR_FAILURE;
 167 }
 168
 169 static const nsIDirectoryServiceProviderVtbl nsDirectoryServiceProviderVtbl = {
 170     nsDirectoryServiceProvider_QueryInterface,
 171     nsDirectoryServiceProvider_AddRef,
 172     nsDirectoryServiceProvider_Release,
 173     nsDirectoryServiceProvider_GetFile
 174 };
 175
 176 static nsIDirectoryServiceProvider nsDirectoryServiceProvider =
 177     { &nsDirectoryServiceProviderVtbl };
 178
 179 static LRESULT WINAPI nsembed_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 180 {
 181     NSContainer *This;
 182     nsresult nsres;
 183
 184     static const WCHAR wszTHIS[] = {'T','H','I','S',0};
 185
 186     if(msg == WM_CREATE) {
 187         This = *(NSContainer**)lParam;
 188         SetPropW(hwnd, wszTHIS, This);
 189     }else {
 190         This = GetPropW(hwnd, wszTHIS);
 191     }
 192
 193     switch(msg) {
 194     case WM_SIZE:
 195         TRACE("(%p)->(WM_SIZE)\n", This);
 196
 197         nsres = nsIBaseWindow_SetSize(This->window,
 198                 LOWORD(lParam), HIWORD(lParam), TRUE);
 199         if(NS_FAILED(nsres))
 200             WARN("SetSize failed: %08x\n", nsres);
 201         break;
 202
 203     case WM_PARENTNOTIFY:
 204         TRACE("WM_PARENTNOTIFY %x\n", (unsigned)wParam);
 205
 206         switch(wParam) {
 207         case WM_LBUTTONDOWN:
 208         case WM_RBUTTONDOWN:
 209             nsIWebBrowserFocus_Activate(This->focus);
 210         }
 211     }
 212
 213     return DefWindowProcW(hwnd, msg, wParam, lParam);
 214 }
 215
 216
 217 static void register_nscontainer_class(void)
 218 {
 219     static WNDCLASSEXW wndclass = {
 220         sizeof(WNDCLASSEXW),
 221         CS_DBLCLKS,
 222         nsembed_proc,
 223         0, 0, NULL, NULL, NULL, NULL, NULL,
 224         wszNsContainer,
 225         NULL,
 226     };
 227     wndclass.hInstance = hInst;
 228     nscontainer_class = RegisterClassExW(&wndclass);
 229 }
 230
 231 static BOOL install_wine_gecko(BOOL silent)
 232 {
 233     PROCESS_INFORMATION pi;
 234     STARTUPINFOW si;
 235     WCHAR app[MAX_PATH];
 236     WCHAR *args;
 237     LONG len;
 238     BOOL ret;
 239
 240     static const WCHAR controlW[] = {'\\','c','o','n','t','r','o','l','.','e','x','e',0};
 241     static const WCHAR argsW[] =
 242         {' ','a','p','p','w','i','z','.','c','p','l',' ','i','n','s','t','a','l','l','_','g','e','c','k','o',0};
 243
 244     len = GetSystemDirectoryW(app, MAX_PATH-sizeof(controlW)/sizeof(WCHAR));
 245     memcpy(app+len, controlW, sizeof(controlW));
 246
 247     args = heap_alloc(len*sizeof(WCHAR) + sizeof(controlW) + sizeof(argsW));
 248     if(!args)
 249         return FALSE;
 250
 251     memcpy(args, app, len*sizeof(WCHAR) + sizeof(controlW));
 252     memcpy(args + len + sizeof(controlW)/sizeof(WCHAR)-1, argsW, sizeof(argsW));
 253
 254     TRACE("starting %s\n", debugstr_w(args));
 255
 256     memset(&si, 0, sizeof(si));
 257     si.cb = sizeof(si);
 258     ret = CreateProcessW(app, args, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
 259     heap_free(args);
 260     if (ret) {
 261         CloseHandle(pi.hThread);
 262         WaitForSingleObject(pi.hProcess, INFINITE);
 263         CloseHandle(pi.hProcess);
 264     }
 265
 266     return ret;
 267 }
 268
 269 static void set_environment(LPCWSTR gre_path)
 270 {
 271     WCHAR path_env[MAX_PATH], buf[20];
 272     int len, debug_level = 0;
 273
 274     static const WCHAR pathW[] = {'P','A','T','H',0};
 275     static const WCHAR warnW[] = {'w','a','r','n',0};
 276     static const WCHAR xpcom_debug_breakW[] =
 277         {'X','P','C','O','M','_','D','E','B','U','G','_','B','R','E','A','K',0};
 278     static const WCHAR nspr_log_modulesW[] =
 279         {'N','S','P','R','_','L','O','G','_','M','O','D','U','L','E','S',0};
 280     static const WCHAR debug_formatW[] = {'a','l','l',':','%','d',0};
 281     static const WCHAR moz_plugin_pathW[] = {'M','O','Z','_','P','L','U','G','I','N','_','P','A','T','H',0};
 282     static const WCHAR gecko_pluginW[] = {'\\','g','e','c','k','o','\\','p','l','u','g','i','n',0};
 283
 284     /* We have to modify PATH as XPCOM loads other DLLs from this directory. */
 285     GetEnvironmentVariableW(pathW, path_env, sizeof(path_env)/sizeof(WCHAR));
 286     len = strlenW(path_env);
 287     path_env[len++] = ';';
 288     strcpyW(path_env+len, gre_path);
 289     SetEnvironmentVariableW(pathW, path_env);
 290
 291     SetEnvironmentVariableW(xpcom_debug_breakW, warnW);
 292
 293     if(TRACE_ON(gecko))
 294         debug_level = 5;
 295     else if(WARN_ON(gecko))
 296         debug_level = 3;
 297     else if(ERR_ON(gecko))
 298         debug_level = 2;
 299
 300     sprintfW(buf, debug_formatW, debug_level);
 301     SetEnvironmentVariableW(nspr_log_modulesW, buf);
 302
 303     len = GetSystemDirectoryW(path_env, (sizeof(path_env)-sizeof(gecko_pluginW))/sizeof(WCHAR)+1);
 304     if(len) {
 305         strcpyW(path_env+len, gecko_pluginW);
 306         SetEnvironmentVariableW(moz_plugin_pathW, path_env);
 307     }
 308 }
 309
 310 static BOOL load_xul(const PRUnichar *gre_path)
 311 {
 312     static const WCHAR xul_dllW[] = {'\\','x','u','l','.','d','l','l',0};
 313     WCHAR file_name[MAX_PATH];
 314
 315     strcpyW(file_name, gre_path);
 316     strcatW(file_name, xul_dllW);
 317
 318     TRACE("(%s)\n", debugstr_w(file_name));
 319
 320     set_environment(gre_path);
 321
 322     xul_handle = LoadLibraryExW(file_name, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
 323     if(!xul_handle) {
 324         WARN("Could not load XPCOM: %d\n", GetLastError());
 325         return FALSE;
 326     }
 327
 328 #define NS_DLSYM(func) \
 329     func = (void *)GetProcAddress(xul_handle, #func "_P"); \
 330     if(!func) \
 331         ERR("Could not GetProcAddress(" #func ") failed\n")
 332
 333     NS_DLSYM(NS_InitXPCOM2);
 334     NS_DLSYM(NS_ShutdownXPCOM);
 335     NS_DLSYM(NS_GetComponentRegistrar);
 336     NS_DLSYM(NS_StringContainerInit2);
 337     NS_DLSYM(NS_CStringContainerInit2);
 338     NS_DLSYM(NS_StringContainerFinish);
 339     NS_DLSYM(NS_CStringContainerFinish);
 340     NS_DLSYM(NS_StringSetData);
 341     NS_DLSYM(NS_CStringSetData);
 342     NS_DLSYM(NS_NewLocalFile);
 343     NS_DLSYM(NS_StringGetData);
 344     NS_DLSYM(NS_CStringGetData);
 345
 346 #undef NS_DLSYM
 347
 348     return TRUE;
 349 }
 350
 351 static BOOL check_version(LPCWSTR gre_path, const char *version_string)
 352 {
 353     WCHAR file_name[MAX_PATH];
 354     char version[128];
 355     DWORD read=0;
 356     HANDLE hfile;
 357
 358     static const WCHAR wszVersion[] = {'\\','V','E','R','S','I','O','N',0};
 359
 360     strcpyW(file_name, gre_path);
 361     strcatW(file_name, wszVersion);
 362
 363     hfile = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
 364                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 365     if(hfile == INVALID_HANDLE_VALUE) {
 366         ERR("Could not open VERSION file\n");
 367         return FALSE;
 368     }
 369
 370     ReadFile(hfile, version, sizeof(version), &read, NULL);
 371     version[read] = 0;
 372     CloseHandle(hfile);
 373
 374     TRACE("%s\n", debugstr_a(version));
 375
 376     if(strcmp(version, version_string)) {
 377         ERR("Unexpected version %s, expected %s\n", debugstr_a(version),
 378             debugstr_a(version_string));
 379         return FALSE;
 380     }
 381
 382     return TRUE;
 383 }
 384
 385 static BOOL load_wine_gecko_v(PRUnichar *gre_path, HKEY mshtml_key,
 386         const char *version, const char *version_string)
 387 {
 388     DWORD res, type, size = MAX_PATH;
 389     HKEY hkey = mshtml_key;
 390
 391     static const WCHAR wszGeckoPath[] =
 392         {'G','e','c','k','o','P','a','t','h',0};
 393
 394     if(version) {
 395         /* @@ Wine registry key: HKLM\Software\Wine\MSHTML\<version> */
 396         res = RegOpenKeyA(mshtml_key, version, &hkey);
 397         if(res != ERROR_SUCCESS)
 398             return FALSE;
 399     }
 400
 401     res = RegQueryValueExW(hkey, wszGeckoPath, NULL, &type, (LPBYTE)gre_path, &size);
 402     if(hkey != mshtml_key)
 403         RegCloseKey(hkey);
 404     if(res != ERROR_SUCCESS || type != REG_SZ)
 405         return FALSE;
 406
 407     if(!check_version(gre_path, version_string))
 408         return FALSE;
 409
 410     return load_xul(gre_path);
 411 }
 412
 413 static BOOL load_wine_gecko(PRUnichar *gre_path)
 414 {
 415     HKEY hkey;
 416     DWORD res;
 417     BOOL ret;
 418
 419     static const WCHAR wszMshtmlKey[] = {
 420         'S','o','f','t','w','a','r','e','\\','W','i','n','e',
 421         '\\','M','S','H','T','M','L',0};
 422
 423     /* @@ Wine registry key: HKLM\Software\Wine\MSHTML */
 424     res = RegOpenKeyW(HKEY_LOCAL_MACHINE, wszMshtmlKey, &hkey);
 425     if(res != ERROR_SUCCESS)
 426         return FALSE;
 427
 428     ret = load_wine_gecko_v(gre_path, hkey, GECKO_VERSION, GECKO_VERSION_STRING);
 429
 430     RegCloseKey(hkey);
 431     return ret;
 432 }
 433
 434 static void set_bool_pref(nsIPrefBranch *pref, const char *pref_name, BOOL val)
 435 {
 436     nsresult nsres;
 437
 438     nsres = nsIPrefBranch_SetBoolPref(pref, pref_name, val);
 439     if(NS_FAILED(nsres))
 440         ERR("Could not set pref %s\n", debugstr_a(pref_name));
 441 }
 442
 443 static void set_int_pref(nsIPrefBranch *pref, const char *pref_name, int val)
 444 {
 445     nsresult nsres;
 446
 447     nsres = nsIPrefBranch_SetIntPref(pref, pref_name, val);
 448     if(NS_FAILED(nsres))
 449         ERR("Could not set pref %s\n", debugstr_a(pref_name));
 450 }
 451
 452 static void set_string_pref(nsIPrefBranch *pref, const char *pref_name, const char *val)
 453 {
 454     nsresult nsres;
 455
 456     nsres = nsIPrefBranch_SetCharPref(pref, pref_name, val);
 457     if(NS_FAILED(nsres))
 458         ERR("Could not set pref %s\n", debugstr_a(pref_name));
 459 }
 460
 461 static void set_lang(nsIPrefBranch *pref)
 462 {
 463     char langs[100];
 464     DWORD res, size, type;
 465     HKEY hkey;
 466
 467     static const WCHAR international_keyW[] =
 468         {'S','o','f','t','w','a','r','e',
 469          '\\','M','i','c','r','o','s','o','f','t',
 470          '\\','I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r',
 471          '\\','I','n','t','e','r','n','a','t','i','o','n','a','l',0};
 472
 473     res = RegOpenKeyW(HKEY_CURRENT_USER, international_keyW, &hkey);
 474     if(res != ERROR_SUCCESS)
 475         return;
 476
 477     size = sizeof(langs);
 478     res = RegQueryValueExA(hkey, "AcceptLanguage", 0, &type, (LPBYTE)langs, &size);
 479     RegCloseKey(hkey);
 480     if(res != ERROR_SUCCESS || type != REG_SZ)
 481         return;
 482
 483     TRACE("Setting lang %s\n", debugstr_a(langs));
 484
 485     set_string_pref(pref, "intl.accept_languages", langs);
 486 }
 487
 488 static void set_proxy(nsIPrefBranch *pref)
 489 {
 490     char proxy[512];
 491     char * proxy_port;
 492     int proxy_port_num;
 493     DWORD enabled = 0, res, size, type;
 494     HKEY hkey;
 495
 496     static const WCHAR proxy_keyW[] =
 497         {'S','o','f','t','w','a','r','e',
 498          '\\','M','i','c','r','o','s','o','f','t',
 499          '\\','W','i','n','d','o','w','s',
 500          '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',
 501          '\\','I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s',0};
 502
 503     res = RegOpenKeyW(HKEY_CURRENT_USER, proxy_keyW, &hkey);
 504     if(res != ERROR_SUCCESS)
 505         return;
 506
 507     size = sizeof(enabled);
 508     res = RegQueryValueExA(hkey, "ProxyEnable", 0, &type, (LPBYTE)&enabled, &size);
 509     if(res != ERROR_SUCCESS || type != REG_DWORD || enabled == 0)
 510     {
 511         RegCloseKey(hkey);
 512         return;
 513     }
 514
 515     size = sizeof(proxy);
 516     res = RegQueryValueExA(hkey, "ProxyServer", 0, &type, (LPBYTE)proxy, &size);
 517     RegCloseKey(hkey);
 518     if(res != ERROR_SUCCESS || type != REG_SZ)
 519         return;
 520
 521     proxy_port = strchr(proxy, ':');
 522     if (!proxy_port)
 523         return;
 524
 525     *proxy_port = 0;
 526     proxy_port_num = atoi(proxy_port + 1);
 527     TRACE("Setting proxy to %s, port %d\n", debugstr_a(proxy), proxy_port_num);
 528
 529     set_string_pref(pref, "network.proxy.http", proxy);
 530     set_string_pref(pref, "network.proxy.ssl", proxy);
 531
 532     set_int_pref(pref, "network.proxy.type", 1);
 533     set_int_pref(pref, "network.proxy.http_port", proxy_port_num);
 534     set_int_pref(pref, "network.proxy.ssl_port", proxy_port_num);
 535 }
 536
 537 static void set_preferences(void)
 538 {
 539     nsIPrefBranch *pref;
 540     nsresult nsres;
 541
 542     nsres = nsIServiceManager_GetServiceByContractID(pServMgr, NS_PREFERENCES_CONTRACTID,
 543             &IID_nsIPrefBranch, (void**)&pref);
 544     if(NS_FAILED(nsres)) {
 545         ERR("Could not get preference service: %08x\n", nsres);
 546         return;
 547     }
 548
 549     set_lang(pref);
 550     set_proxy(pref);
 551     set_bool_pref(pref, "security.warn_entering_secure", FALSE);
 552     set_bool_pref(pref, "security.warn_submit_insecure", FALSE);
 553     set_int_pref(pref, "layout.spellcheckDefault", 0);
 554
 555     nsIPrefBranch_Release(pref);
 556 }
 557
 558 static BOOL init_xpcom(const PRUnichar *gre_path)
 559 {
 560     nsIComponentRegistrar *registrar = NULL;
 561     nsAString path;
 562     nsIFile *gre_dir;
 563     WCHAR *ptr;
 564     nsresult nsres;
 565
 566     nsAString_InitDepend(&path, gre_path);
 567     nsres = NS_NewLocalFile(&path, FALSE, &gre_dir);
 568     nsAString_Finish(&path);
 569     if(NS_FAILED(nsres)) {
 570         ERR("NS_NewLocalFile failed: %08x\n", nsres);
 571         FreeLibrary(xul_handle);
 572         return FALSE;
 573     }
 574
 575     nsres = NS_InitXPCOM2(&pServMgr, gre_dir, &nsDirectoryServiceProvider);
 576     if(NS_FAILED(nsres)) {
 577         ERR("NS_InitXPCOM2 failed: %08x\n", nsres);
 578         FreeLibrary(xul_handle);
 579         return FALSE;
 580     }
 581
 582     strcpyW(gecko_path, gre_path);
 583     for(ptr = gecko_path; *ptr; ptr++) {
 584         if(*ptr == '\\')
 585             *ptr = '/';
 586     }
 587     gecko_path_len = ptr-gecko_path;
 588
 589     nsres = nsIServiceManager_QueryInterface(pServMgr, &IID_nsIComponentManager, (void**)&pCompMgr);
 590     if(NS_FAILED(nsres))
 591         ERR("Could not get nsIComponentManager: %08x\n", nsres);
 592
 593     nsres = NS_GetComponentRegistrar(&registrar);
 594     if(NS_SUCCEEDED(nsres))
 595         init_nsio(pCompMgr, registrar);
 596     else
 597         ERR("NS_GetComponentRegistrar failed: %08x\n", nsres);
 598
 599     init_mutation(pCompMgr);
 600     set_preferences();
 601
 602     nsres = nsIComponentManager_CreateInstanceByContractID(pCompMgr, NS_MEMORY_CONTRACTID,
 603             NULL, &IID_nsIMemory, (void**)&nsmem);
 604     if(NS_FAILED(nsres))
 605         ERR("Could not get nsIMemory: %08x\n", nsres);
 606
 607     if(registrar) {
 608         register_nsservice(registrar, pServMgr);
 609         nsIComponentRegistrar_Release(registrar);
 610     }
 611
 612     return TRUE;
 613 }
 614
 615 static CRITICAL_SECTION cs_load_gecko;
 616 static CRITICAL_SECTION_DEBUG cs_load_gecko_dbg =
 617 {
 618     0, 0, &cs_load_gecko,
 619     { &cs_load_gecko_dbg.ProcessLocksList, &cs_load_gecko_dbg.ProcessLocksList },
 620       0, 0, { (DWORD_PTR)(__FILE__ ": load_gecko") }
 621 };
 622 static CRITICAL_SECTION cs_load_gecko = { &cs_load_gecko_dbg, -1, 0, 0, 0, 0 };
 623
 624 BOOL load_gecko(BOOL silent)
 625 {
 626     PRUnichar gre_path[MAX_PATH];
 627     BOOL ret = FALSE;
 628
 629     static DWORD loading_thread;
 630
 631     TRACE("()\n");
 632
 633     /* load_gecko may be called recursively */
 634     if(loading_thread == GetCurrentThreadId())
 635         return pCompMgr != NULL;
 636
 637     EnterCriticalSection(&cs_load_gecko);
 638
 639     if(!loading_thread) {
 640         loading_thread = GetCurrentThreadId();
 641
 642         if(load_wine_gecko(gre_path)
 643            || (install_wine_gecko(silent) && load_wine_gecko(gre_path)))
 644             ret = init_xpcom(gre_path);
 645         else
 646            MESSAGE("Could not load wine-gecko. HTML rendering will be disabled.\n");
 647     }else {
 648         ret = pCompMgr != NULL;
 649     }
 650
 651     LeaveCriticalSection(&cs_load_gecko);
 652
 653     return ret;
 654 }
 655
 656 void *nsalloc(size_t size)
 657 {
 658     return nsIMemory_Alloc(nsmem, size);
 659 }
 660
 661 void nsfree(void *mem)
 662 {
 663     nsIMemory_Free(nsmem, mem);
 664 }
 665
 666 static BOOL nsACString_Init(nsACString *str, const char *data)
 667 {
 668     return NS_SUCCEEDED(NS_CStringContainerInit2(str, data, PR_UINT32_MAX, 0));
 669 }
 670
 671 /*
 672  * Initializes nsACString with data owned by caller.
 673  * Caller must ensure that data is valid during lifetime of string object.
 674  */
 675 void nsACString_InitDepend(nsACString *str, const char *data)
 676 {
 677     NS_CStringContainerInit2(str, data, PR_UINT32_MAX, NS_CSTRING_CONTAINER_INIT_DEPEND);
 678 }
 679
 680 void nsACString_SetData(nsACString *str, const char *data)
 681 {
 682     NS_CStringSetData(str, data, PR_UINT32_MAX);
 683 }
 684
 685 PRUint32 nsACString_GetData(const nsACString *str, const char **data)
 686 {
 687     return NS_CStringGetData(str, data, NULL);
 688 }
 689
 690 void nsACString_Finish(nsACString *str)
 691 {
 692     NS_CStringContainerFinish(str);
 693 }
 694
 695 BOOL nsAString_Init(nsAString *str, const PRUnichar *data)
 696 {
 697     return NS_SUCCEEDED(NS_StringContainerInit2(str, data, PR_UINT32_MAX, 0));
 698 }
 699
 700 /*
 701  * Initializes nsAString with data owned by caller.
 702  * Caller must ensure that data is valid during lifetime of string object.
 703  */
 704 void nsAString_InitDepend(nsAString *str, const PRUnichar *data)
 705 {
 706     NS_StringContainerInit2(str, data, PR_UINT32_MAX, NS_STRING_CONTAINER_INIT_DEPEND);
 707 }
 708
 709 void nsAString_SetData(nsAString *str, const PRUnichar *data)
 710 {
 711     NS_StringSetData(str, data, PR_UINT32_MAX);
 712 }
 713
 714 PRUint32 nsAString_GetData(const nsAString *str, const PRUnichar **data)
 715 {
 716     return NS_StringGetData(str, data, NULL);
 717 }
 718
 719 void nsAString_Finish(nsAString *str)
 720 {
 721     NS_StringContainerFinish(str);
 722 }
 723
 724 HRESULT return_nsstr(nsresult nsres, nsAString *nsstr, BSTR *p)
 725 {
 726     const PRUnichar *str;
 727
 728     if(NS_FAILED(nsres)) {
 729         ERR("failed: %08x\n", nsres);
 730         nsAString_Finish(nsstr);
 731         return E_FAIL;
 732     }
 733
 734     nsAString_GetData(nsstr, &str);
 735     TRACE("ret %s\n", debugstr_w(str));
 736     if(*str) {
 737         *p = SysAllocString(str);
 738         if(!*p)
 739             return E_OUTOFMEMORY;
 740     }else {
 741         *p = NULL;
 742     }
 743
 744     nsAString_Finish(nsstr);
 745     return S_OK;
 746 }
 747
 748 nsICommandParams *create_nscommand_params(void)
 749 {
 750     nsICommandParams *ret = NULL;
 751     nsresult nsres;
 752
 753     if(!pCompMgr)
 754         return NULL;
 755
 756     nsres = nsIComponentManager_CreateInstanceByContractID(pCompMgr,
 757             NS_COMMANDPARAMS_CONTRACTID, NULL, &IID_nsICommandParams,
 758             (void**)&ret);
 759     if(NS_FAILED(nsres))
 760         ERR("Could not get nsICommandParams\n");
 761
 762     return ret;
 763 }
 764
 765 nsresult get_nsinterface(nsISupports *iface, REFIID riid, void **ppv)
 766 {
 767     nsIInterfaceRequestor *iface_req;
 768     nsresult nsres;
 769
 770     nsres = nsISupports_QueryInterface(iface, &IID_nsIInterfaceRequestor, (void**)&iface_req);
 771     if(NS_FAILED(nsres))
 772         return nsres;
 773
 774     nsres = nsIInterfaceRequestor_GetInterface(iface_req, riid, ppv);
 775     nsIInterfaceRequestor_Release(iface_req);
 776
 777     return nsres;
 778 }
 779
 780 static HRESULT nsnode_to_nsstring_rec(nsIContentSerializer *serializer, nsIDOMNode *nsnode, nsAString *str)
 781 {
 782     nsIDOMNodeList *node_list = NULL;
 783     PRBool has_children = FALSE;
 784     nsIContent *nscontent;
 785     PRUint16 type;
 786     nsresult nsres;
 787
 788     nsIDOMNode_HasChildNodes(nsnode, &has_children);
 789
 790     nsres = nsIDOMNode_GetNodeType(nsnode, &type);
 791     if(NS_FAILED(nsres)) {
 792         ERR("GetType failed: %08x\n", nsres);
 793         return E_FAIL;
 794     }
 795
 796     nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIContent, (void**)&nscontent);
 797     if(NS_FAILED(nsres)) {
 798         ERR("Could not get nsIDontent interface: %08x\n", nsres);
 799         return E_FAIL;
 800     }
 801
 802     switch(type) {
 803     case ELEMENT_NODE:
 804         nsIContentSerializer_AppendElementStart(serializer, nscontent, nscontent, str);
 805         break;
 806     case TEXT_NODE:
 807         nsIContentSerializer_AppendText(serializer, nscontent, 0, -1, str);
 808         break;
 809     case COMMENT_NODE:
 810         nsres = nsIContentSerializer_AppendComment(serializer, nscontent, 0, -1, str);
 811         break;
 812     case DOCUMENT_NODE: {
 813         nsIDocument *nsdoc;
 814         nsIDOMNode_QueryInterface(nsnode, &IID_nsIDocument, (void**)&nsdoc);
 815         nsIContentSerializer_AppendDocumentStart(serializer, nsdoc, str);
 816         nsIDocument_Release(nsdoc);
 817         break;
 818     }
 819     case DOCUMENT_TYPE_NODE:
 820         WARN("Ignoring DOCUMENT_TYPE_NODE\n");
 821         break;
 822     case DOCUMENT_FRAGMENT_NODE:
 823         break;
 824     default:
 825         FIXME("Unhandled type %u\n", type);
 826     }
 827
 828     if(has_children) {
 829         PRUint32 child_cnt, i;
 830         nsIDOMNode *child_node;
 831
 832         nsIDOMNode_GetChildNodes(nsnode, &node_list);
 833         nsIDOMNodeList_GetLength(node_list, &child_cnt);
 834
 835         for(i=0; i<child_cnt; i++) {
 836             nsres = nsIDOMNodeList_Item(node_list, i, &child_node);
 837             if(NS_SUCCEEDED(nsres)) {
 838                 nsnode_to_nsstring_rec(serializer, child_node, str);
 839                 nsIDOMNode_Release(child_node);
 840             }else {
 841                 ERR("Item failed: %08x\n", nsres);
 842             }
 843         }
 844
 845         nsIDOMNodeList_Release(node_list);
 846     }
 847
 848     if(type == ELEMENT_NODE)
 849         nsIContentSerializer_AppendElementEnd(serializer, nscontent, str);
 850
 851     nsIContent_Release(nscontent);
 852     return S_OK;
 853 }
 854
 855 HRESULT nsnode_to_nsstring(nsIDOMNode *nsnode, nsAString *str)
 856 {
 857     nsIContentSerializer *serializer;
 858     nsresult nsres;
 859     HRESULT hres;
 860
 861     nsres = nsIComponentManager_CreateInstanceByContractID(pCompMgr,
 862             NS_HTMLSERIALIZER_CONTRACTID, NULL, &IID_nsIContentSerializer,
 863             (void**)&serializer);
 864     if(NS_FAILED(nsres)) {
 865         ERR("Could not get nsIContentSerializer: %08x\n", nsres);
 866         return E_FAIL;
 867     }
 868
 869     nsres = nsIContentSerializer_Init(serializer, 0, 100, NULL, FALSE, FALSE /* FIXME */);
 870     if(NS_FAILED(nsres))
 871         ERR("Init failed: %08x\n", nsres);
 872
 873     hres = nsnode_to_nsstring_rec(serializer, nsnode, str);
 874     if(SUCCEEDED(hres)) {
 875         nsres = nsIContentSerializer_Flush(serializer, str);
 876         if(NS_FAILED(nsres))
 877             ERR("Flush failed: %08x\n", nsres);
 878     }
 879
 880     nsIContentSerializer_Release(serializer);
 881     return hres;
 882 }
 883
 884 void get_editor_controller(NSContainer *This)
 885 {
 886     nsIEditingSession *editing_session = NULL;
 887     nsIControllerContext *ctrlctx;
 888     nsresult nsres;
 889
 890     if(This->editor) {
 891         nsIEditor_Release(This->editor);
 892         This->editor = NULL;
 893     }
 894
 895     if(This->editor_controller) {
 896         nsIController_Release(This->editor_controller);
 897         This->editor_controller = NULL;
 898     }
 899
 900     nsres = get_nsinterface((nsISupports*)This->webbrowser, &IID_nsIEditingSession,
 901             (void**)&editing_session);
 902     if(NS_FAILED(nsres)) {
 903         ERR("Could not get nsIEditingSession: %08x\n", nsres);
 904         return;
 905     }
 906
 907     nsres = nsIEditingSession_GetEditorForWindow(editing_session,
 908             This->doc->basedoc.window->nswindow, &This->editor);
 909     nsIEditingSession_Release(editing_session);
 910     if(NS_FAILED(nsres)) {
 911         ERR("Could not get editor: %08x\n", nsres);
 912         return;
 913     }
 914
 915     nsres = nsIComponentManager_CreateInstanceByContractID(pCompMgr,
 916             NS_EDITORCONTROLLER_CONTRACTID, NULL, &IID_nsIControllerContext, (void**)&ctrlctx);
 917     if(NS_SUCCEEDED(nsres)) {
 918         nsres = nsIControllerContext_SetCommandContext(ctrlctx, (nsISupports *)This->editor);
 919         if(NS_FAILED(nsres))
 920             ERR("SetCommandContext failed: %08x\n", nsres);
 921         nsres = nsIControllerContext_QueryInterface(ctrlctx, &IID_nsIController,
 922                 (void**)&This->editor_controller);
 923         nsIControllerContext_Release(ctrlctx);
 924         if(NS_FAILED(nsres))
 925             ERR("Could not get nsIController interface: %08x\n", nsres);
 926     }else {
 927         ERR("Could not create edit controller: %08x\n", nsres);
 928     }
 929 }
 930
 931 void close_gecko(void)
 932 {
 933     TRACE("()\n");
 934
 935     release_nsio();
 936     init_mutation(NULL);
 937
 938     if(profile_directory) {
 939         nsIFile_Release(profile_directory);
 940         profile_directory = NULL;
 941     }
 942
 943     if(pCompMgr)
 944         nsIComponentManager_Release(pCompMgr);
 945
 946     if(pServMgr)
 947         nsIServiceManager_Release(pServMgr);
 948
 949     if(nsmem)
 950         nsIMemory_Release(nsmem);
 951
 952     /* Gecko doesn't really support being unloaded */
 953     /* if (hXPCOM) FreeLibrary(hXPCOM); */
 954 }
 955
 956 BOOL is_gecko_path(const char *path)
 957 {
 958     WCHAR *buf, *ptr;
 959     BOOL ret;
 960
 961     buf = heap_strdupAtoW(path);
 962     if(strlenW(buf) < gecko_path_len)
 963         return FALSE;
 964
 965     buf[gecko_path_len] = 0;
 966     for(ptr = buf; *ptr; ptr++) {
 967         if(*ptr == '\\')
 968             *ptr = '/';
 969     }
 970
 971     ret = !strcmpiW(buf, gecko_path);
 972     heap_free(buf);
 973     return ret;
 974 }
 975
 976 /**********************************************************
 977  *      nsIWebBrowserChrome interface
 978  */
 979
 980 static inline NSContainer *impl_from_nsIWebBrowserChrome(nsIWebBrowserChrome *iface)
 981 {
 982     return CONTAINING_RECORD(iface, NSContainer, nsIWebBrowserChrome_iface);
 983 }
 984
 985 static nsresult NSAPI nsWebBrowserChrome_QueryInterface(nsIWebBrowserChrome *iface,
 986         nsIIDRef riid, void **result)
 987 {
 988     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
 989
 990     *result = NULL;
 991     if(IsEqualGUID(&IID_nsISupports, riid)) {
 992         TRACE("(%p)->(IID_nsISupports, %p)\n", This, result);
 993         *result = &This->nsIWebBrowserChrome_iface;
 994     }else if(IsEqualGUID(&IID_nsIWebBrowserChrome, riid)) {
 995         TRACE("(%p)->(IID_nsIWebBrowserChrome, %p)\n", This, result);
 996         *result = &This->nsIWebBrowserChrome_iface;
 997     }else if(IsEqualGUID(&IID_nsIContextMenuListener, riid)) {
 998         TRACE("(%p)->(IID_nsIContextMenuListener, %p)\n", This, result);
 999         *result = &This->nsIContextMenuListener_iface;
1000     }else if(IsEqualGUID(&IID_nsIURIContentListener, riid)) {
1001         TRACE("(%p)->(IID_nsIURIContentListener %p)\n", This, result);
1002         *result = &This->nsIURIContentListener_iface;
1003     }else if(IsEqualGUID(&IID_nsIEmbeddingSiteWindow, riid)) {
1004         TRACE("(%p)->(IID_nsIEmbeddingSiteWindow %p)\n", This, result);
1005         *result = &This->nsIEmbeddingSiteWindow_iface;
1006     }else if(IsEqualGUID(&IID_nsITooltipListener, riid)) {
1007         TRACE("(%p)->(IID_nsITooltipListener %p)\n", This, result);
1008         *result = &This->nsITooltipListener_iface;
1009     }else if(IsEqualGUID(&IID_nsIInterfaceRequestor, riid)) {
1010         TRACE("(%p)->(IID_nsIInterfaceRequestor %p)\n", This, result);
1011         *result = &This->nsIInterfaceRequestor_iface;
1012     }else if(IsEqualGUID(&IID_nsIWeakReference, riid)) {
1013         TRACE("(%p)->(IID_nsIWeakReference %p)\n", This, result);
1014         *result = &This->nsIWeakReference_iface;
1015     }else if(IsEqualGUID(&IID_nsISupportsWeakReference, riid)) {
1016         TRACE("(%p)->(IID_nsISupportsWeakReference %p)\n", This, result);
1017         *result = &This->nsISupportsWeakReference_iface;
1018     }
1019
1020     if(*result) {
1021         nsIWebBrowserChrome_AddRef(&This->nsIWebBrowserChrome_iface);
1022         return NS_OK;
1023     }
1024
1025     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
1026     return NS_NOINTERFACE;
1027 }
1028
1029 static nsrefcnt NSAPI nsWebBrowserChrome_AddRef(nsIWebBrowserChrome *iface)
1030 {
1031     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1032     LONG ref = InterlockedIncrement(&This->ref);
1033
1034     TRACE("(%p) ref=%d\n", This, ref);
1035
1036     return ref;
1037 }
1038
1039 static nsrefcnt NSAPI nsWebBrowserChrome_Release(nsIWebBrowserChrome *iface)
1040 {
1041     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1042     LONG ref = InterlockedDecrement(&This->ref);
1043
1044     TRACE("(%p) ref=%d\n", This, ref);
1045
1046     if(!ref) {
1047         if(This->parent)
1048             nsIWebBrowserChrome_Release(&This->parent->nsIWebBrowserChrome_iface);
1049         heap_free(This);
1050     }
1051
1052     return ref;
1053 }
1054
1055 static nsresult NSAPI nsWebBrowserChrome_SetStatus(nsIWebBrowserChrome *iface,
1056         PRUint32 statusType, const PRUnichar *status)
1057 {
1058     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1059     TRACE("(%p)->(%d %s)\n", This, statusType, debugstr_w(status));
1060     return NS_OK;
1061 }
1062
1063 static nsresult NSAPI nsWebBrowserChrome_GetWebBrowser(nsIWebBrowserChrome *iface,
1064         nsIWebBrowser **aWebBrowser)
1065 {
1066     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1067
1068     TRACE("(%p)->(%p)\n", This, aWebBrowser);
1069
1070     if(!aWebBrowser)
1071         return NS_ERROR_INVALID_ARG;
1072
1073     if(This->webbrowser)
1074         nsIWebBrowser_AddRef(This->webbrowser);
1075     *aWebBrowser = This->webbrowser;
1076     return S_OK;
1077 }
1078
1079 static nsresult NSAPI nsWebBrowserChrome_SetWebBrowser(nsIWebBrowserChrome *iface,
1080         nsIWebBrowser *aWebBrowser)
1081 {
1082     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1083
1084     TRACE("(%p)->(%p)\n", This, aWebBrowser);
1085
1086     if(aWebBrowser != This->webbrowser)
1087         ERR("Wrong nsWebBrowser!\n");
1088
1089     return NS_OK;
1090 }
1091
1092 static nsresult NSAPI nsWebBrowserChrome_GetChromeFlags(nsIWebBrowserChrome *iface,
1093         PRUint32 *aChromeFlags)
1094 {
1095     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1096     WARN("(%p)->(%p)\n", This, aChromeFlags);
1097     return NS_ERROR_NOT_IMPLEMENTED;
1098 }
1099
1100 static nsresult NSAPI nsWebBrowserChrome_SetChromeFlags(nsIWebBrowserChrome *iface,
1101         PRUint32 aChromeFlags)
1102 {
1103     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1104     WARN("(%p)->(%08x)\n", This, aChromeFlags);
1105     return NS_ERROR_NOT_IMPLEMENTED;
1106 }
1107
1108 static nsresult NSAPI nsWebBrowserChrome_DestroyBrowserWindow(nsIWebBrowserChrome *iface)
1109 {
1110     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1111     TRACE("(%p)\n", This);
1112     return NS_ERROR_NOT_IMPLEMENTED;
1113 }
1114
1115 static nsresult NSAPI nsWebBrowserChrome_SizeBrowserTo(nsIWebBrowserChrome *iface,
1116         PRInt32 aCX, PRInt32 aCY)
1117 {
1118     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1119     WARN("(%p)->(%d %d)\n", This, aCX, aCY);
1120     return NS_ERROR_NOT_IMPLEMENTED;
1121 }
1122
1123 static nsresult NSAPI nsWebBrowserChrome_ShowAsModal(nsIWebBrowserChrome *iface)
1124 {
1125     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1126     WARN("(%p)\n", This);
1127     return NS_ERROR_NOT_IMPLEMENTED;
1128 }
1129
1130 static nsresult NSAPI nsWebBrowserChrome_IsWindowModal(nsIWebBrowserChrome *iface, PRBool *_retval)
1131 {
1132     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1133     WARN("(%p)->(%p)\n", This, _retval);
1134     return NS_ERROR_NOT_IMPLEMENTED;
1135 }
1136
1137 static nsresult NSAPI nsWebBrowserChrome_ExitModalEventLoop(nsIWebBrowserChrome *iface,
1138         nsresult aStatus)
1139 {
1140     NSContainer *This = impl_from_nsIWebBrowserChrome(iface);
1141     WARN("(%p)->(%08x)\n", This, aStatus);
1142     return NS_ERROR_NOT_IMPLEMENTED;
1143 }
1144
1145 static const nsIWebBrowserChromeVtbl nsWebBrowserChromeVtbl = {
1146     nsWebBrowserChrome_QueryInterface,
1147     nsWebBrowserChrome_AddRef,
1148     nsWebBrowserChrome_Release,
1149     nsWebBrowserChrome_SetStatus,
1150     nsWebBrowserChrome_GetWebBrowser,
1151     nsWebBrowserChrome_SetWebBrowser,
1152     nsWebBrowserChrome_GetChromeFlags,
1153     nsWebBrowserChrome_SetChromeFlags,
1154     nsWebBrowserChrome_DestroyBrowserWindow,
1155     nsWebBrowserChrome_SizeBrowserTo,
1156     nsWebBrowserChrome_ShowAsModal,
1157     nsWebBrowserChrome_IsWindowModal,
1158     nsWebBrowserChrome_ExitModalEventLoop
1159 };
1160
1161 /**********************************************************
1162  *      nsIContextMenuListener interface
1163  */
1164
1165 static inline NSContainer *impl_from_nsIContextMenuListener(nsIContextMenuListener *iface)
1166 {
1167     return CONTAINING_RECORD(iface, NSContainer, nsIContextMenuListener_iface);
1168 }
1169
1170 static nsresult NSAPI nsContextMenuListener_QueryInterface(nsIContextMenuListener *iface,
1171         nsIIDRef riid, void **result)
1172 {
1173     NSContainer *This = impl_from_nsIContextMenuListener(iface);
1174     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1175 }
1176
1177 static nsrefcnt NSAPI nsContextMenuListener_AddRef(nsIContextMenuListener *iface)
1178 {
1179     NSContainer *This = impl_from_nsIContextMenuListener(iface);
1180     return nsIWebBrowserChrome_AddRef(&This->nsIWebBrowserChrome_iface);
1181 }
1182
1183 static nsrefcnt NSAPI nsContextMenuListener_Release(nsIContextMenuListener *iface)
1184 {
1185     NSContainer *This = impl_from_nsIContextMenuListener(iface);
1186     return nsIWebBrowserChrome_Release(&This->nsIWebBrowserChrome_iface);
1187 }
1188
1189 static nsresult NSAPI nsContextMenuListener_OnShowContextMenu(nsIContextMenuListener *iface,
1190         PRUint32 aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode)
1191 {
1192     NSContainer *This = impl_from_nsIContextMenuListener(iface);
1193     nsIDOMMouseEvent *event;
1194     HTMLDOMNode *node;
1195     POINT pt;
1196     DWORD dwID = CONTEXT_MENU_DEFAULT;
1197     nsresult nsres;
1198     HRESULT hres;
1199
1200     TRACE("(%p)->(%08x %p %p)\n", This, aContextFlags, aEvent, aNode);
1201
1202     fire_event(This->doc->basedoc.doc_node /* FIXME */, EVENTID_CONTEXTMENU, TRUE, aNode, aEvent);
1203
1204     nsres = nsIDOMEvent_QueryInterface(aEvent, &IID_nsIDOMMouseEvent, (void**)&event);
1205     if(NS_FAILED(nsres)) {
1206         ERR("Could not get nsIDOMMouseEvent interface: %08x\n", nsres);
1207         return nsres;
1208     }
1209
1210     nsIDOMMouseEvent_GetScreenX(event, &pt.x);
1211     nsIDOMMouseEvent_GetScreenY(event, &pt.y);
1212     nsIDOMMouseEvent_Release(event);
1213
1214     switch(aContextFlags) {
1215     case CONTEXT_NONE:
1216     case CONTEXT_DOCUMENT:
1217     case CONTEXT_TEXT:
1218         dwID = CONTEXT_MENU_DEFAULT;
1219         break;
1220     case CONTEXT_IMAGE:
1221     case CONTEXT_IMAGE|CONTEXT_LINK:
1222         dwID = CONTEXT_MENU_IMAGE;
1223         break;
1224     case CONTEXT_LINK:
1225         dwID = CONTEXT_MENU_ANCHOR;
1226         break;
1227     case CONTEXT_INPUT:
1228         dwID = CONTEXT_MENU_CONTROL;
1229         break;
1230     default:
1231         FIXME("aContextFlags=%08x\n", aContextFlags);
1232     };
1233
1234     hres = get_node(This->doc->basedoc.doc_node, aNode, TRUE, &node);
1235     if(FAILED(hres))
1236         return NS_ERROR_FAILURE;
1237
1238     show_context_menu(This->doc, dwID, &pt, (IDispatch*)&node->IHTMLDOMNode_iface);
1239     return NS_OK;
1240 }
1241
1242 static const nsIContextMenuListenerVtbl nsContextMenuListenerVtbl = {
1243     nsContextMenuListener_QueryInterface,
1244     nsContextMenuListener_AddRef,
1245     nsContextMenuListener_Release,
1246     nsContextMenuListener_OnShowContextMenu
1247 };
1248
1249 /**********************************************************
1250  *      nsIURIContentListener interface
1251  */
1252
1253 static inline NSContainer *impl_from_nsIURIContentListener(nsIURIContentListener *iface)
1254 {
1255     return CONTAINING_RECORD(iface, NSContainer, nsIURIContentListener_iface);
1256 }
1257
1258 static nsresult NSAPI nsURIContentListener_QueryInterface(nsIURIContentListener *iface,
1259         nsIIDRef riid, void **result)
1260 {
1261     NSContainer *This = impl_from_nsIURIContentListener(iface);
1262     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1263 }
1264
1265 static nsrefcnt NSAPI nsURIContentListener_AddRef(nsIURIContentListener *iface)
1266 {
1267     NSContainer *This = impl_from_nsIURIContentListener(iface);
1268     return nsIWebBrowserChrome_AddRef(&This->nsIWebBrowserChrome_iface);
1269 }
1270
1271 static nsrefcnt NSAPI nsURIContentListener_Release(nsIURIContentListener *iface)
1272 {
1273     NSContainer *This = impl_from_nsIURIContentListener(iface);
1274     return nsIWebBrowserChrome_Release(&This->nsIWebBrowserChrome_iface);
1275 }
1276
1277 static nsresult NSAPI nsURIContentListener_OnStartURIOpen(nsIURIContentListener *iface,
1278                                                           nsIURI *aURI, PRBool *_retval)
1279 {
1280     NSContainer *This = impl_from_nsIURIContentListener(iface);
1281     nsACString spec_str;
1282     const char *spec;
1283     nsresult nsres;
1284
1285     nsACString_Init(&spec_str, NULL);
1286     nsIURI_GetSpec(aURI, &spec_str);
1287     nsACString_GetData(&spec_str, &spec);
1288
1289     TRACE("(%p)->(%p(%s) %p)\n", This, aURI, debugstr_a(spec), _retval);
1290
1291     nsACString_Finish(&spec_str);
1292
1293     nsres = on_start_uri_open(This, aURI, _retval);
1294     if(NS_FAILED(nsres))
1295         return nsres;
1296
1297     return !*_retval && This->content_listener
1298         ? nsIURIContentListener_OnStartURIOpen(This->content_listener, aURI, _retval)
1299         : NS_OK;
1300 }
1301
1302 static nsresult NSAPI nsURIContentListener_DoContent(nsIURIContentListener *iface,
1303         const char *aContentType, PRBool aIsContentPreferred, nsIRequest *aRequest,
1304         nsIStreamListener **aContentHandler, PRBool *_retval)
1305 {
1306     NSContainer *This = impl_from_nsIURIContentListener(iface);
1307
1308     TRACE("(%p)->(%s %x %p %p %p)\n", This, debugstr_a(aContentType), aIsContentPreferred,
1309             aRequest, aContentHandler, _retval);
1310
1311     return This->content_listener
1312         ? nsIURIContentListener_DoContent(This->content_listener, aContentType,
1313                   aIsContentPreferred, aRequest, aContentHandler, _retval)
1314         : NS_ERROR_NOT_IMPLEMENTED;
1315 }
1316
1317 static nsresult NSAPI nsURIContentListener_IsPreferred(nsIURIContentListener *iface,
1318         const char *aContentType, char **aDesiredContentType, PRBool *_retval)
1319 {
1320     NSContainer *This = impl_from_nsIURIContentListener(iface);
1321
1322     TRACE("(%p)->(%s %p %p)\n", This, debugstr_a(aContentType), aDesiredContentType, _retval);
1323
1324     /* FIXME: Should we do something here? */
1325     *_retval = TRUE;
1326
1327     return This->content_listener
1328         ? nsIURIContentListener_IsPreferred(This->content_listener, aContentType,
1329                   aDesiredContentType, _retval)
1330         : NS_OK;
1331 }
1332
1333 static nsresult NSAPI nsURIContentListener_CanHandleContent(nsIURIContentListener *iface,
1334         const char *aContentType, PRBool aIsContentPreferred, char **aDesiredContentType,
1335         PRBool *_retval)
1336 {
1337     NSContainer *This = impl_from_nsIURIContentListener(iface);
1338
1339     TRACE("(%p)->(%s %x %p %p)\n", This, debugstr_a(aContentType), aIsContentPreferred,
1340             aDesiredContentType, _retval);
1341
1342     return This->content_listener
1343         ? nsIURIContentListener_CanHandleContent(This->content_listener, aContentType,
1344                 aIsContentPreferred, aDesiredContentType, _retval)
1345         : NS_ERROR_NOT_IMPLEMENTED;
1346 }
1347
1348 static nsresult NSAPI nsURIContentListener_GetLoadCookie(nsIURIContentListener *iface,
1349         nsISupports **aLoadCookie)
1350 {
1351     NSContainer *This = impl_from_nsIURIContentListener(iface);
1352
1353     WARN("(%p)->(%p)\n", This, aLoadCookie);
1354
1355     return This->content_listener
1356         ? nsIURIContentListener_GetLoadCookie(This->content_listener, aLoadCookie)
1357         : NS_ERROR_NOT_IMPLEMENTED;
1358 }
1359
1360 static nsresult NSAPI nsURIContentListener_SetLoadCookie(nsIURIContentListener *iface,
1361         nsISupports *aLoadCookie)
1362 {
1363     NSContainer *This = impl_from_nsIURIContentListener(iface);
1364
1365     WARN("(%p)->(%p)\n", This, aLoadCookie);
1366
1367     return This->content_listener
1368         ? nsIURIContentListener_SetLoadCookie(This->content_listener, aLoadCookie)
1369         : NS_ERROR_NOT_IMPLEMENTED;
1370 }
1371
1372 static nsresult NSAPI nsURIContentListener_GetParentContentListener(nsIURIContentListener *iface,
1373         nsIURIContentListener **aParentContentListener)
1374 {
1375     NSContainer *This = impl_from_nsIURIContentListener(iface);
1376
1377     TRACE("(%p)->(%p)\n", This, aParentContentListener);
1378
1379     if(This->content_listener)
1380         nsIURIContentListener_AddRef(This->content_listener);
1381
1382     *aParentContentListener = This->content_listener;
1383     return NS_OK;
1384 }
1385
1386 static nsresult NSAPI nsURIContentListener_SetParentContentListener(nsIURIContentListener *iface,
1387         nsIURIContentListener *aParentContentListener)
1388 {
1389     NSContainer *This = impl_from_nsIURIContentListener(iface);
1390
1391     TRACE("(%p)->(%p)\n", This, aParentContentListener);
1392
1393     if(aParentContentListener == &This->nsIURIContentListener_iface)
1394         return NS_OK;
1395
1396     if(This->content_listener)
1397         nsIURIContentListener_Release(This->content_listener);
1398
1399     This->content_listener = aParentContentListener;
1400     if(This->content_listener)
1401         nsIURIContentListener_AddRef(This->content_listener);
1402
1403     return NS_OK;
1404 }
1405
1406 static const nsIURIContentListenerVtbl nsURIContentListenerVtbl = {
1407     nsURIContentListener_QueryInterface,
1408     nsURIContentListener_AddRef,
1409     nsURIContentListener_Release,
1410     nsURIContentListener_OnStartURIOpen,
1411     nsURIContentListener_DoContent,
1412     nsURIContentListener_IsPreferred,
1413     nsURIContentListener_CanHandleContent,
1414     nsURIContentListener_GetLoadCookie,
1415     nsURIContentListener_SetLoadCookie,
1416     nsURIContentListener_GetParentContentListener,
1417     nsURIContentListener_SetParentContentListener
1418 };
1419
1420 /**********************************************************
1421  *      nsIEmbeddinSiteWindow interface
1422  */
1423
1424 static inline NSContainer *impl_from_nsIEmbeddingSiteWindow(nsIEmbeddingSiteWindow *iface)
1425 {
1426     return CONTAINING_RECORD(iface, NSContainer, nsIEmbeddingSiteWindow_iface);
1427 }
1428
1429 static nsresult NSAPI nsEmbeddingSiteWindow_QueryInterface(nsIEmbeddingSiteWindow *iface,
1430         nsIIDRef riid, void **result)
1431 {
1432     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1433     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1434 }
1435
1436 static nsrefcnt NSAPI nsEmbeddingSiteWindow_AddRef(nsIEmbeddingSiteWindow *iface)
1437 {
1438     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1439     return nsIWebBrowserChrome_AddRef(&This->nsIWebBrowserChrome_iface);
1440 }
1441
1442 static nsrefcnt NSAPI nsEmbeddingSiteWindow_Release(nsIEmbeddingSiteWindow *iface)
1443 {
1444     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1445     return nsIWebBrowserChrome_Release(&This->nsIWebBrowserChrome_iface);
1446 }
1447
1448 static nsresult NSAPI nsEmbeddingSiteWindow_SetDimensions(nsIEmbeddingSiteWindow *iface,
1449         PRUint32 flags, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy)
1450 {
1451     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1452     WARN("(%p)->(%08x %d %d %d %d)\n", This, flags, x, y, cx, cy);
1453     return NS_ERROR_NOT_IMPLEMENTED;
1454 }
1455
1456 static nsresult NSAPI nsEmbeddingSiteWindow_GetDimensions(nsIEmbeddingSiteWindow *iface,
1457         PRUint32 flags, PRInt32 *x, PRInt32 *y, PRInt32 *cx, PRInt32 *cy)
1458 {
1459     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1460     WARN("(%p)->(%08x %p %p %p %p)\n", This, flags, x, y, cx, cy);
1461     return NS_ERROR_NOT_IMPLEMENTED;
1462 }
1463
1464 static nsresult NSAPI nsEmbeddingSiteWindow_SetFocus(nsIEmbeddingSiteWindow *iface)
1465 {
1466     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1467
1468     TRACE("(%p)\n", This);
1469
1470     return nsIBaseWindow_SetFocus(This->window);
1471 }
1472
1473 static nsresult NSAPI nsEmbeddingSiteWindow_GetVisibility(nsIEmbeddingSiteWindow *iface,
1474         PRBool *aVisibility)
1475 {
1476     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1477
1478     TRACE("(%p)->(%p)\n", This, aVisibility);
1479
1480     *aVisibility = This->doc && This->doc->hwnd && IsWindowVisible(This->doc->hwnd);
1481     return NS_OK;
1482 }
1483
1484 static nsresult NSAPI nsEmbeddingSiteWindow_SetVisibility(nsIEmbeddingSiteWindow *iface,
1485         PRBool aVisibility)
1486 {
1487     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1488
1489     TRACE("(%p)->(%x)\n", This, aVisibility);
1490
1491     return NS_OK;
1492 }
1493
1494 static nsresult NSAPI nsEmbeddingSiteWindow_GetTitle(nsIEmbeddingSiteWindow *iface,
1495         PRUnichar **aTitle)
1496 {
1497     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1498     WARN("(%p)->(%p)\n", This, aTitle);
1499     return NS_ERROR_NOT_IMPLEMENTED;
1500 }
1501
1502 static nsresult NSAPI nsEmbeddingSiteWindow_SetTitle(nsIEmbeddingSiteWindow *iface,
1503         const PRUnichar *aTitle)
1504 {
1505     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1506     WARN("(%p)->(%s)\n", This, debugstr_w(aTitle));
1507     return NS_ERROR_NOT_IMPLEMENTED;
1508 }
1509
1510 static nsresult NSAPI nsEmbeddingSiteWindow_GetSiteWindow(nsIEmbeddingSiteWindow *iface,
1511         void **aSiteWindow)
1512 {
1513     NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
1514
1515     TRACE("(%p)->(%p)\n", This, aSiteWindow);
1516
1517     *aSiteWindow = This->hwnd;
1518     return NS_OK;
1519 }
1520
1521 static const nsIEmbeddingSiteWindowVtbl nsEmbeddingSiteWindowVtbl = {
1522     nsEmbeddingSiteWindow_QueryInterface,
1523     nsEmbeddingSiteWindow_AddRef,
1524     nsEmbeddingSiteWindow_Release,
1525     nsEmbeddingSiteWindow_SetDimensions,
1526     nsEmbeddingSiteWindow_GetDimensions,
1527     nsEmbeddingSiteWindow_SetFocus,
1528     nsEmbeddingSiteWindow_GetVisibility,
1529     nsEmbeddingSiteWindow_SetVisibility,
1530     nsEmbeddingSiteWindow_GetTitle,
1531     nsEmbeddingSiteWindow_SetTitle,
1532     nsEmbeddingSiteWindow_GetSiteWindow
1533 };
1534
1535 static inline NSContainer *impl_from_nsITooltipListener(nsITooltipListener *iface)
1536 {
1537     return CONTAINING_RECORD(iface, NSContainer, nsITooltipListener_iface);
1538 }
1539
1540 static nsresult NSAPI nsTooltipListener_QueryInterface(nsITooltipListener *iface, nsIIDRef riid,
1541         void **result)
1542 {
1543     NSContainer *This = impl_from_nsITooltipListener(iface);
1544     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1545 }
1546
1547 static nsrefcnt NSAPI nsTooltipListener_AddRef(nsITooltipListener *iface)
1548 {
1549     NSContainer *This = impl_from_nsITooltipListener(iface);
1550     return nsIWebBrowserChrome_AddRef(&This->nsIWebBrowserChrome_iface);
1551 }
1552
1553 static nsrefcnt NSAPI nsTooltipListener_Release(nsITooltipListener *iface)
1554 {
1555     NSContainer *This = impl_from_nsITooltipListener(iface);
1556     return nsIWebBrowserChrome_Release(&This->nsIWebBrowserChrome_iface);
1557 }
1558
1559 static nsresult NSAPI nsTooltipListener_OnShowTooltip(nsITooltipListener *iface,
1560         PRInt32 aXCoord, PRInt32 aYCoord, const PRUnichar *aTipText)
1561 {
1562     NSContainer *This = impl_from_nsITooltipListener(iface);
1563
1564     if (This->doc)
1565         show_tooltip(This->doc, aXCoord, aYCoord, aTipText);
1566
1567     return NS_OK;
1568 }
1569
1570 static nsresult NSAPI nsTooltipListener_OnHideTooltip(nsITooltipListener *iface)
1571 {
1572     NSContainer *This = impl_from_nsITooltipListener(iface);
1573
1574     if (This->doc)
1575         hide_tooltip(This->doc);
1576
1577     return NS_OK;
1578 }
1579
1580 static const nsITooltipListenerVtbl nsTooltipListenerVtbl = {
1581     nsTooltipListener_QueryInterface,
1582     nsTooltipListener_AddRef,
1583     nsTooltipListener_Release,
1584     nsTooltipListener_OnShowTooltip,
1585     nsTooltipListener_OnHideTooltip
1586 };
1587
1588 static inline NSContainer *impl_from_nsIInterfaceRequestor(nsIInterfaceRequestor *iface)
1589 {
1590     return CONTAINING_RECORD(iface, NSContainer, nsIInterfaceRequestor_iface);
1591 }
1592
1593 static nsresult NSAPI nsInterfaceRequestor_QueryInterface(nsIInterfaceRequestor *iface,
1594         nsIIDRef riid, void **result)
1595 {
1596     NSContainer *This = impl_from_nsIInterfaceRequestor(iface);
1597     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1598 }
1599
1600 static nsrefcnt NSAPI nsInterfaceRequestor_AddRef(nsIInterfaceRequestor *iface)
1601 {
1602     NSContainer *This = impl_from_nsIInterfaceRequestor(iface);
1603     return nsIWebBrowserChrome_AddRef(&This->nsIWebBrowserChrome_iface);
1604 }
1605
1606 static nsrefcnt NSAPI nsInterfaceRequestor_Release(nsIInterfaceRequestor *iface)
1607 {
1608     NSContainer *This = impl_from_nsIInterfaceRequestor(iface);
1609     return nsIWebBrowserChrome_Release(&This->nsIWebBrowserChrome_iface);
1610 }
1611
1612 static nsresult NSAPI nsInterfaceRequestor_GetInterface(nsIInterfaceRequestor *iface,
1613         nsIIDRef riid, void **result)
1614 {
1615     NSContainer *This = impl_from_nsIInterfaceRequestor(iface);
1616
1617     if(IsEqualGUID(&IID_nsIDOMWindow, riid)) {
1618         TRACE("(%p)->(IID_nsIDOMWindow %p)\n", This, result);
1619         return nsIWebBrowser_GetContentDOMWindow(This->webbrowser, (nsIDOMWindow**)result);
1620     }
1621
1622     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1623 }
1624
1625 static const nsIInterfaceRequestorVtbl nsInterfaceRequestorVtbl = {
1626     nsInterfaceRequestor_QueryInterface,
1627     nsInterfaceRequestor_AddRef,
1628     nsInterfaceRequestor_Release,
1629     nsInterfaceRequestor_GetInterface
1630 };
1631
1632 static inline NSContainer *impl_from_nsIWeakReference(nsIWeakReference *iface)
1633 {
1634     return CONTAINING_RECORD(iface, NSContainer, nsIWeakReference_iface);
1635 }
1636
1637 static nsresult NSAPI nsWeakReference_QueryInterface(nsIWeakReference *iface,
1638         nsIIDRef riid, void **result)
1639 {
1640     NSContainer *This = impl_from_nsIWeakReference(iface);
1641     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1642 }
1643
1644 static nsrefcnt NSAPI nsWeakReference_AddRef(nsIWeakReference *iface)
1645 {
1646     NSContainer *This = impl_from_nsIWeakReference(iface);
1647     return nsIWebBrowserChrome_AddRef(&This->nsIWebBrowserChrome_iface);
1648 }
1649
1650 static nsrefcnt NSAPI nsWeakReference_Release(nsIWeakReference *iface)
1651 {
1652     NSContainer *This = impl_from_nsIWeakReference(iface);
1653     return nsIWebBrowserChrome_Release(&This->nsIWebBrowserChrome_iface);
1654 }
1655
1656 static nsresult NSAPI nsWeakReference_QueryReferent(nsIWeakReference *iface,
1657         const nsIID *riid, void **result)
1658 {
1659     NSContainer *This = impl_from_nsIWeakReference(iface);
1660     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1661 }
1662
1663 static const nsIWeakReferenceVtbl nsWeakReferenceVtbl = {
1664     nsWeakReference_QueryInterface,
1665     nsWeakReference_AddRef,
1666     nsWeakReference_Release,
1667     nsWeakReference_QueryReferent
1668 };
1669
1670 static inline NSContainer *impl_from_nsISupportsWeakReference(nsISupportsWeakReference *iface)
1671 {
1672     return CONTAINING_RECORD(iface, NSContainer, nsISupportsWeakReference_iface);
1673 }
1674
1675 static nsresult NSAPI nsSupportsWeakReference_QueryInterface(nsISupportsWeakReference *iface,
1676         nsIIDRef riid, void **result)
1677 {
1678     NSContainer *This = impl_from_nsISupportsWeakReference(iface);
1679     return nsIWebBrowserChrome_QueryInterface(&This->nsIWebBrowserChrome_iface, riid, result);
1680 }
1681
1682 static nsrefcnt NSAPI nsSupportsWeakReference_AddRef(nsISupportsWeakReference *iface)
1683 {
1684     NSContainer *This = impl_from_nsISupportsWeakReference(iface);
1685     return nsIWebBrowserChrome_AddRef(&This->nsIWebBrowserChrome_iface);
1686 }
1687
1688 static nsrefcnt NSAPI nsSupportsWeakReference_Release(nsISupportsWeakReference *iface)
1689 {
1690     NSContainer *This = impl_from_nsISupportsWeakReference(iface);
1691     return nsIWebBrowserChrome_Release(&This->nsIWebBrowserChrome_iface);
1692 }
1693
1694 static nsresult NSAPI nsSupportsWeakReference_GetWeakReference(nsISupportsWeakReference *iface,
1695         nsIWeakReference **_retval)
1696 {
1697     NSContainer *This = impl_from_nsISupportsWeakReference(iface);
1698
1699     TRACE("(%p)->(%p)\n", This, _retval);
1700
1701     nsIWeakReference_AddRef(&This->nsIWeakReference_iface);
1702     *_retval = &This->nsIWeakReference_iface;
1703     return NS_OK;
1704 }
1705
1706 static const nsISupportsWeakReferenceVtbl nsSupportsWeakReferenceVtbl = {
1707     nsSupportsWeakReference_QueryInterface,
1708     nsSupportsWeakReference_AddRef,
1709     nsSupportsWeakReference_Release,
1710     nsSupportsWeakReference_GetWeakReference
1711 };
1712
1713 nsresult create_chrome_window(nsIWebBrowserChrome *parent, nsIWebBrowserChrome **ret)
1714 {
1715     NSContainer *new_container;
1716
1717     if(parent->lpVtbl != &nsWebBrowserChromeVtbl)
1718         return NS_ERROR_UNEXPECTED;
1719
1720     new_container = NSContainer_Create(NULL, impl_from_nsIWebBrowserChrome(parent));
1721     *ret = &new_container->nsIWebBrowserChrome_iface;
1722     return NS_OK;
1723 }
1724
1725 NSContainer *NSContainer_Create(HTMLDocumentObj *doc, NSContainer *parent)
1726 {
1727     nsIWebBrowserSetup *wbsetup;
1728     nsIScrollable *scrollable;
1729     NSContainer *ret;
1730     nsresult nsres;
1731
1732     if(!load_gecko(TRUE))
1733         return NULL;
1734
1735     ret = heap_alloc_zero(sizeof(NSContainer));
1736
1737     ret->nsIWebBrowserChrome_iface.lpVtbl = &nsWebBrowserChromeVtbl;
1738     ret->nsIContextMenuListener_iface.lpVtbl = &nsContextMenuListenerVtbl;
1739     ret->nsIURIContentListener_iface.lpVtbl = &nsURIContentListenerVtbl;
1740     ret->nsIEmbeddingSiteWindow_iface.lpVtbl = &nsEmbeddingSiteWindowVtbl;
1741     ret->nsITooltipListener_iface.lpVtbl = &nsTooltipListenerVtbl;
1742     ret->nsIInterfaceRequestor_iface.lpVtbl = &nsInterfaceRequestorVtbl;
1743     ret->nsIWeakReference_iface.lpVtbl = &nsWeakReferenceVtbl;
1744     ret->nsISupportsWeakReference_iface.lpVtbl = &nsSupportsWeakReferenceVtbl;
1745
1746     ret->doc = doc;
1747     ret->ref = 1;
1748
1749     nsres = nsIComponentManager_CreateInstanceByContractID(pCompMgr, NS_WEBBROWSER_CONTRACTID,
1750             NULL, &IID_nsIWebBrowser, (void**)&ret->webbrowser);
1751     if(NS_FAILED(nsres)) {
1752         ERR("Creating WebBrowser failed: %08x\n", nsres);
1753         heap_free(ret);
1754         return NULL;
1755     }
1756
1757     if(parent)
1758         nsIWebBrowserChrome_AddRef(&parent->nsIWebBrowserChrome_iface);
1759     ret->parent = parent;
1760
1761     nsres = nsIWebBrowser_SetContainerWindow(ret->webbrowser, &ret->nsIWebBrowserChrome_iface);
1762     if(NS_FAILED(nsres))
1763         ERR("SetContainerWindow failed: %08x\n", nsres);
1764
1765     nsres = nsIWebBrowser_QueryInterface(ret->webbrowser, &IID_nsIBaseWindow,
1766             (void**)&ret->window);
1767     if(NS_FAILED(nsres))
1768         ERR("Could not get nsIBaseWindow interface: %08x\n", nsres);
1769
1770     nsres = nsIWebBrowser_QueryInterface(ret->webbrowser, &IID_nsIWebBrowserSetup,
1771                                          (void**)&wbsetup);
1772     if(NS_SUCCEEDED(nsres)) {
1773         nsres = nsIWebBrowserSetup_SetProperty(wbsetup, SETUP_IS_CHROME_WRAPPER, FALSE);
1774         nsIWebBrowserSetup_Release(wbsetup);
1775         if(NS_FAILED(nsres))
1776             ERR("SetProperty(SETUP_IS_CHROME_WRAPPER) failed: %08x\n", nsres);
1777     }else {
1778         ERR("Could not get nsIWebBrowserSetup interface\n");
1779     }
1780
1781     nsres = nsIWebBrowser_QueryInterface(ret->webbrowser, &IID_nsIWebNavigation,
1782             (void**)&ret->navigation);
1783     if(NS_FAILED(nsres))
1784         ERR("Could not get nsIWebNavigation interface: %08x\n", nsres);
1785
1786     nsres = nsIWebBrowserFocus_QueryInterface(ret->webbrowser, &IID_nsIWebBrowserFocus,
1787             (void**)&ret->focus);
1788     if(NS_FAILED(nsres))
1789         ERR("Could not get nsIWebBrowserFocus interface: %08x\n", nsres);
1790
1791     if(!nscontainer_class)
1792         register_nscontainer_class();
1793
1794     ret->hwnd = CreateWindowExW(0, wszNsContainer, NULL,
1795             WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 0, 0, 100, 100,
1796             GetDesktopWindow(), NULL, hInst, ret);
1797
1798     nsres = nsIBaseWindow_InitWindow(ret->window, ret->hwnd, NULL, 0, 0, 100, 100);
1799     if(NS_SUCCEEDED(nsres)) {
1800         nsres = nsIBaseWindow_Create(ret->window);
1801         if(NS_FAILED(nsres))
1802             WARN("Creating window failed: %08x\n", nsres);
1803
1804         nsIBaseWindow_SetVisibility(ret->window, FALSE);
1805         nsIBaseWindow_SetEnabled(ret->window, FALSE);
1806     }else {
1807         ERR("InitWindow failed: %08x\n", nsres);
1808     }
1809
1810     nsres = nsIWebBrowser_SetParentURIContentListener(ret->webbrowser,
1811             &ret->nsIURIContentListener_iface);
1812     if(NS_FAILED(nsres))
1813         ERR("SetParentURIContentListener failed: %08x\n", nsres);
1814
1815     nsres = nsIWebBrowser_QueryInterface(ret->webbrowser, &IID_nsIScrollable, (void**)&scrollable);
1816     if(NS_SUCCEEDED(nsres)) {
1817         nsres = nsIScrollable_SetDefaultScrollbarPreferences(scrollable,
1818                 ScrollOrientation_Y, Scrollbar_Always);
1819         if(NS_FAILED(nsres))
1820             ERR("Could not set default Y scrollbar prefs: %08x\n", nsres);
1821
1822         nsres = nsIScrollable_SetDefaultScrollbarPreferences(scrollable,
1823                 ScrollOrientation_X, Scrollbar_Auto);
1824         if(NS_FAILED(nsres))
1825             ERR("Could not set default X scrollbar prefs: %08x\n", nsres);
1826
1827         nsIScrollable_Release(scrollable);
1828     }else {
1829         ERR("Could not get nsIScrollable: %08x\n", nsres);
1830     }
1831
1832     return ret;
1833 }
1834
1835 void NSContainer_Release(NSContainer *This)
1836 {
1837     TRACE("(%p)\n", This);
1838
1839     This->doc = NULL;
1840
1841     ShowWindow(This->hwnd, SW_HIDE);
1842     SetParent(This->hwnd, NULL);
1843
1844     nsIBaseWindow_SetVisibility(This->window, FALSE);
1845     nsIBaseWindow_Destroy(This->window);
1846
1847     nsIWebBrowser_SetContainerWindow(This->webbrowser, NULL);
1848
1849     nsIWebBrowser_Release(This->webbrowser);
1850     This->webbrowser = NULL;
1851
1852     nsIWebNavigation_Release(This->navigation);
1853     This->navigation = NULL;
1854
1855     nsIBaseWindow_Release(This->window);
1856     This->window = NULL;
1857
1858     nsIWebBrowserFocus_Release(This->focus);
1859     This->focus = NULL;
1860
1861     if(This->editor_controller) {
1862         nsIController_Release(This->editor_controller);
1863         This->editor_controller = NULL;
1864     }
1865
1866     if(This->editor) {
1867         nsIEditor_Release(This->editor);
1868         This->editor = NULL;
1869     }
1870
1871     if(This->content_listener) {
1872         nsIURIContentListener_Release(This->content_listener);
1873         This->content_listener = NULL;
1874     }
1875
1876     if(This->hwnd) {
1877         DestroyWindow(This->hwnd);
1878         This->hwnd = NULL;
1879     }
1880
1881     nsIWebBrowserChrome_Release(&This->nsIWebBrowserChrome_iface);
1882 }