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