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