embedding/tests/winEmbed/winEmbed.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: Mozilla-sample-code 1.0
   4  *
   5  * Copyright (c) 2002 Netscape Communications Corporation and
   6  * other contributors
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this Mozilla sample software and associated documentation files
  10  * (the "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sublicense, and/or sell copies of the Software, and to permit
  13  * persons to whom the Software is furnished to do so, subject to the
  14  * following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  22  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25  * DEALINGS IN THE SOFTWARE.
  26  *
  27  * Contributor(s):
  28  *   Doug Turner <dougt@netscape.com>
  29  *   Adam Lock <adamlock@netscape.com>
  30  *
  31  * ***** END LICENSE BLOCK ***** */
  32
  33 // C RunTime Header Files
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <malloc.h>
  37 #include <memory.h>
  38 #include <tchar.h>
  39
  40 // Win32 header files
  41 #include <windows.h>
  42 #include <commctrl.h>
  43 #include <commdlg.h>
  44
  45 // Mozilla Frozen APIs
  46 #include "nsXULAppAPI.h"
  47
  48 XRE_InitEmbeddingType XRE_InitEmbedding;
  49 XRE_TermEmbeddingType XRE_TermEmbedding;
  50
  51 #include "nsAppDirectoryServiceDefs.h"
  52 #include "nsDirectoryServiceDefs.h"
  53 #include "nsProfileDirServiceProvider.h"
  54 #include "nsStringAPI.h"
  55 #include "nsXPCOMGlue.h"
  56
  57 #include "nsIClipboardCommands.h"
  58 #include "nsIInterfaceRequestor.h"
  59 #include "nsIObserverService.h"
  60 #include "nsIObserver.h"
  61 #include "nsIURI.h"
  62 #include "nsIWebBrowserFocus.h"
  63 #include "nsIWindowWatcher.h"
  64
  65 // NON-FROZEN APIs!
  66 #include "nsIBaseWindow.h"
  67 #include "nsIWebNavigation.h"
  68
  69 // Local header files
  70 #include "winEmbed.h"
  71 #include "WebBrowserChrome.h"
  72 #include "WindowCreator.h"
  73 #include "resource.h"
  74
  75 #define MAX_LOADSTRING 100
  76
  77 const TCHAR *szWindowClass = _T("WINEMBED");
  78
  79 // Foward declarations of functions included in this code module:
  80 static ATOM             MyRegisterClass(HINSTANCE hInstance);
  81 static LRESULT CALLBACK BrowserWndProc(HWND, UINT, WPARAM, LPARAM);
  82 static BOOL    CALLBACK BrowserDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
  83
  84 static nsresult InitializeWindowCreator();
  85 static nsresult OpenWebPage(const char * url);
  86 static nsresult ResizeEmbedding(nsIWebBrowserChrome* chrome);
  87
  88 // Profile chooser stuff
  89 static nsresult StartupProfile();
  90
  91 // Global variables
  92 static UINT gDialogCount = 0;
  93 static HINSTANCE ghInstanceApp = NULL;
  94 static char gFirstURL[1024];
  95
  96 // like strpbrk but finds the *last* char, not the first
  97 static char*
  98 ns_strrpbrk(char *string, const char *strCharSet)
  99 {
 100     char *found = NULL;
 101     for (; *string; ++string) {
 102         for (const char *search = strCharSet; *search; ++search) {
 103             if (*search == *string) {
 104                 found = string;
 105                 // Since we're looking for the last char, we save "found"
 106                 // until we're at the end of the string.
 107             }
 108         }
 109     }
 110
 111     return found;
 112 }
 113
 114 // A list of URLs to populate the URL drop down list with
 115 static const TCHAR *gDefaultURLs[] =
 116 {
 117     _T("http://www.mozilla.org/"),
 118     _T("http://www.netscape.com/"),
 119     _T("http://browsertest.web.aol.com/tests/javascript/javascpt/index.htm"),
 120     _T("http://127.0.0.1/"),
 121     _T("http://www.yahoo.com/"),
 122     _T("http://www.travelocity.com/"),
 123     _T("http://www.disney.com/"),
 124     _T("http://www.go.com/"),
 125     _T("http://www.google.com/"),
 126     _T("http://www.ebay.com/"),
 127     _T("http://www.shockwave.com/"),
 128     _T("http://www.slashdot.org/"),
 129     _T("http://www.quicken.com/"),
 130     _T("http://www.hotmail.com/"),
 131     _T("http://www.cnn.com/"),
 132     _T("http://www.javasoft.com/")
 133 };
 134
 135 int main(int argc, char *argv[])
 136 {
 137     nsresult rv;
 138
 139     printf("You are embedded, man!\n\n");
 140     printf("******************************************************************\n");
 141     printf("*                                                                *\n");
 142     printf("*  IMPORTANT NOTE:                                               *\n");
 143     printf("*                                                                *\n");
 144     printf("*  WinEmbed is not supported!!! Do not raise bugs on it unless   *\n");
 145     printf("*  it is badly broken (e.g. crash on start/exit, build errors)   *\n");
 146     printf("*  or you have the patch to make it better! MFCEmbed is now our  *\n");
 147     printf("*  embedding test application on Win32 and all testing should    *\n");
 148     printf("*  be done on that.                                              *\n");
 149     printf("*                                                                *\n");
 150     printf("******************************************************************\n");
 151     printf("\n\n");
 152
 153     // Sophisticated command-line parsing in action
 154     char *szFirstURL = "http://www.mozilla.org/projects/embedding/";
 155         int argn;
 156     for (argn = 1; argn < argc; argn++)
 157     {
 158                 szFirstURL = argv[argn];
 159     }
 160     strncpy(gFirstURL, szFirstURL, sizeof(gFirstURL) - 1);
 161
 162     ghInstanceApp = GetModuleHandle(NULL);
 163
 164     // Initialize global strings
 165     TCHAR szTitle[MAX_LOADSTRING];
 166     LoadString(ghInstanceApp, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
 167     MyRegisterClass(ghInstanceApp);
 168
 169     // Find the GRE (libxul). We are only using frozen interfaces, so we
 170     // should be compatible all the way up to (but not including) mozilla 2.0
 171     static const GREVersionRange vr = {
 172         "1.8a1",
 173         PR_TRUE,
 174         "2.0",
 175         PR_FALSE
 176     };
 177
 178     char xpcomPath[_MAX_PATH];
 179     rv = GRE_GetGREPathWithProperties(&vr, 1, nsnull, 0,
 180                                       xpcomPath, sizeof(xpcomPath));
 181     if (NS_FAILED(rv))
 182         return 1;
 183
 184     char *lastslash = ns_strrpbrk(xpcomPath, "/\\");
 185     if (!lastslash)
 186         return 2;
 187
 188     rv = XPCOMGlueStartup(xpcomPath);
 189     if (NS_FAILED(rv))
 190         return 3;
 191
 192     *lastslash = '\0';
 193
 194     char xulPath[_MAX_PATH];
 195     _snprintf(xulPath, sizeof(xulPath), "%s\\xul.dll", xpcomPath);
 196     xulPath[sizeof(xulPath) - 1] = '\0';
 197
 198     HINSTANCE xulModule = LoadLibraryEx(xulPath, NULL, 0);
 199     if (!xulModule)
 200         return 4;
 201
 202     char temp[_MAX_PATH];
 203     GetModuleFileName(xulModule, temp, sizeof(temp));
 204
 205     XRE_InitEmbedding =
 206         (XRE_InitEmbeddingType) GetProcAddress(xulModule, "XRE_InitEmbedding");
 207     if (!XRE_InitEmbedding) {
 208         fprintf(stderr, "Error: %i\n", GetLastError());
 209         return 5;
 210     }
 211
 212     XRE_TermEmbedding =
 213         (XRE_TermEmbeddingType) GetProcAddress(xulModule, "XRE_TermEmbedding");
 214     if (!XRE_TermEmbedding) {
 215         fprintf(stderr, "Error: %i\n", GetLastError());
 216         return 5;
 217     }
 218
 219     // Scope all the XPCOM stuff
 220     {
 221         nsCOMPtr<nsILocalFile> xuldir;
 222         rv = NS_NewNativeLocalFile(nsCString(xpcomPath), PR_FALSE,
 223                                    getter_AddRefs(xuldir));
 224         if (NS_FAILED(rv))
 225             return 6;
 226
 227         char self[_MAX_PATH];
 228         GetModuleFileName(ghInstanceApp, self, sizeof(self));
 229         lastslash = ns_strrpbrk(xpcomPath, "/\\");
 230         if (!lastslash)
 231             return 7;
 232
 233         *lastslash = '\0';
 234
 235         nsCOMPtr<nsILocalFile> appdir;
 236         rv = NS_NewNativeLocalFile(nsCString(self), PR_FALSE,
 237                                    getter_AddRefs(appdir));
 238         if (NS_FAILED(rv))
 239             return 8;
 240
 241         rv = XRE_InitEmbedding(xuldir, appdir, nsnull, nsnull, 0);
 242         if (NS_FAILED(rv))
 243             return 9;
 244
 245         int result = 0;
 246         if (NS_FAILED(StartupProfile())) {
 247             result = 8;
 248         }
 249         else {
 250             InitializeWindowCreator();
 251
 252             // Open the initial browser window
 253             OpenWebPage(gFirstURL);
 254
 255             // Main message loop.
 256             // NOTE: We use a fake event and a timeout in order to process idle stuff for
 257             //       Mozilla every 1/10th of a second.
 258             PRBool runCondition = PR_TRUE;
 259
 260             rv = AppCallbacks::RunEventLoop(runCondition);
 261         }
 262     }
 263     XRE_TermEmbedding();
 264
 265     return rv;
 266 }
 267
 268 /* InitializeWindowCreator creates and hands off an object with a callback
 269    to a window creation function. This is how all new windows are opened,
 270    except any created directly by the embedding app. */
 271 nsresult
 272 InitializeWindowCreator()
 273 {
 274     // create an nsWindowCreator and give it to the WindowWatcher service
 275     nsCOMPtr<nsIWindowCreator> creator(new WindowCreator());
 276     if (!creator)
 277         return NS_ERROR_OUT_OF_MEMORY;
 278
 279     nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
 280     if (!wwatch)
 281         return NS_ERROR_UNEXPECTED;
 282
 283     return wwatch->SetWindowCreator(creator);
 284 }
 285
 286 //-----------------------------------------------------------------------------
 287
 288 //
 289 //  FUNCTION: OpenWebPage()
 290 //
 291 //  PURPOSE: Opens a new browser dialog and starts it loading to the
 292 //           specified url.
 293 //
 294 nsresult OpenWebPage(const char *url)
 295 {
 296     nsresult  rv;
 297
 298     // Create the chrome object. Note that it leaves this function
 299     // with an extra reference so that it can released correctly during
 300     // destruction (via Win32UI::Destroy)
 301
 302     nsCOMPtr<nsIWebBrowserChrome> chrome;
 303     rv = AppCallbacks::CreateBrowserWindow(nsIWebBrowserChrome::CHROME_ALL,
 304            nsnull, getter_AddRefs(chrome));
 305     if (NS_SUCCEEDED(rv))
 306     {
 307         // Start loading a page
 308         nsCOMPtr<nsIWebBrowser> newBrowser;
 309         chrome->GetWebBrowser(getter_AddRefs(newBrowser));
 310         nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(newBrowser));
 311
 312         return webNav->LoadURI(NS_ConvertASCIItoUTF16(url).get(),
 313                                nsIWebNavigation::LOAD_FLAGS_NONE,
 314                                nsnull,
 315                                nsnull,
 316                                nsnull);
 317     }
 318
 319     return rv;
 320 }
 321
 322 //
 323 //  FUNCTION: GetBrowserFromChrome()
 324 //
 325 //  PURPOSE: Returns the HWND for the webbrowser container associated
 326 //           with the specified chrome.
 327 //
 328 HWND GetBrowserFromChrome(nsIWebBrowserChrome *aChrome)
 329 {
 330     if (!aChrome)
 331     {
 332         return NULL;
 333     }
 334     nsCOMPtr<nsIEmbeddingSiteWindow> baseWindow = do_QueryInterface(aChrome);
 335     HWND hwnd = NULL;
 336     baseWindow->GetSiteWindow((void **) & hwnd);
 337     return hwnd;
 338 }
 339
 340
 341 //
 342 //  FUNCTION: GetBrowserDlgFromChrome()
 343 //
 344 //  PURPOSE: Returns the HWND for the browser dialog associated with
 345 //           the specified chrome.
 346 //
 347 HWND GetBrowserDlgFromChrome(nsIWebBrowserChrome *aChrome)
 348 {
 349     return GetParent(GetBrowserFromChrome(aChrome));
 350 }
 351
 352
 353 //
 354 //  FUNCTION: ResizeEmbedding()
 355 //
 356 //  PURPOSE: Resizes the webbrowser window to fit its container.
 357 //
 358 nsresult ResizeEmbedding(nsIWebBrowserChrome* chrome)
 359 {
 360     if (!chrome)
 361         return NS_ERROR_FAILURE;
 362
 363     nsCOMPtr<nsIEmbeddingSiteWindow> embeddingSite = do_QueryInterface(chrome);
 364     HWND hWnd;
 365     embeddingSite->GetSiteWindow((void **) & hWnd);
 366
 367     if (!hWnd)
 368         return NS_ERROR_NULL_POINTER;
 369
 370     RECT rect;
 371     GetClientRect(hWnd, &rect);
 372
 373     // Make sure the browser is visible and sized
 374     nsCOMPtr<nsIWebBrowser> webBrowser;
 375     chrome->GetWebBrowser(getter_AddRefs(webBrowser));
 376     nsCOMPtr<nsIBaseWindow> webBrowserAsWin = do_QueryInterface(webBrowser);
 377     if (webBrowserAsWin)
 378     {
 379         webBrowserAsWin->SetPositionAndSize(rect.left,
 380                                    rect.top,
 381                                    rect.right - rect.left,
 382                                    rect.bottom - rect.top,
 383                                    PR_TRUE);
 384         webBrowserAsWin->SetVisibility(PR_TRUE);
 385     }
 386
 387     return NS_OK;
 388 }
 389
 390
 391 //
 392 //  FUNCTION: MyRegisterClass()
 393 //
 394 //  PURPOSE: Registers the window class.
 395 //
 396 //  COMMENTS:
 397 //
 398 //    This function and its usage is only necessary if you want this code
 399 //    to be compatible with Win32 systems prior to the 'RegisterClassEx'
 400 //    function that was added to Windows 95. It is important to call this function
 401 //    so that the application will get 'well formed' small icons associated
 402 //    with it.
 403 //
 404 ATOM MyRegisterClass(HINSTANCE hInstance)
 405 {
 406     WNDCLASSEX wcex;
 407
 408     memset(&wcex, 0, sizeof(wcex));
 409     wcex.cbSize = sizeof(WNDCLASSEX);
 410
 411     wcex.style            = CS_HREDRAW | CS_VREDRAW;
 412     wcex.lpfnWndProc    = (WNDPROC) BrowserWndProc;
 413     wcex.cbClsExtra        = 0;
 414     wcex.cbWndExtra        = 0;
 415     wcex.hInstance        = hInstance;
 416     wcex.hIcon            = LoadIcon(ghInstanceApp, (LPCTSTR)IDI_WINEMBED);
 417     wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
 418     wcex.hbrBackground    = (HBRUSH)(COLOR_WINDOW+1);
 419     wcex.lpszClassName    = szWindowClass;
 420     wcex.hIconSm        = LoadIcon(ghInstanceApp, (LPCTSTR)IDI_SMALL);
 421
 422     return RegisterClassEx(&wcex);
 423 }
 424
 425
 426 //
 427 //  FUNCTION: UpdateUI()
 428 //
 429 //  PURPOSE: Refreshes the buttons and menu items in the browser dialog
 430 //
 431 void UpdateUI(nsIWebBrowserChrome *aChrome)
 432 {
 433     HWND hwndDlg = GetBrowserDlgFromChrome(aChrome);
 434     nsCOMPtr<nsIWebBrowser> webBrowser;
 435     nsCOMPtr<nsIWebNavigation> webNavigation;
 436     aChrome->GetWebBrowser(getter_AddRefs(webBrowser));
 437     webNavigation = do_QueryInterface(webBrowser);
 438
 439     PRBool canGoBack = PR_FALSE;
 440     PRBool canGoForward = PR_FALSE;
 441     if (webNavigation)
 442     {
 443         webNavigation->GetCanGoBack(&canGoBack);
 444         webNavigation->GetCanGoForward(&canGoForward);
 445     }
 446
 447     PRBool canCutSelection = PR_FALSE;
 448     PRBool canCopySelection = PR_FALSE;
 449     PRBool canPaste = PR_FALSE;
 450
 451     nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(webBrowser);
 452     if (clipCmds)
 453     {
 454         clipCmds->CanCutSelection(&canCutSelection);
 455         clipCmds->CanCopySelection(&canCopySelection);
 456         clipCmds->CanPaste(&canPaste);
 457     }
 458
 459     HMENU hmenu = GetMenu(hwndDlg);
 460     if (hmenu)
 461     {
 462         EnableMenuItem(hmenu, MOZ_GoBack, MF_BYCOMMAND |
 463             ((canGoBack) ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
 464         EnableMenuItem(hmenu, MOZ_GoForward, MF_BYCOMMAND |
 465             ((canGoForward) ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
 466
 467         EnableMenuItem(hmenu, MOZ_Cut, MF_BYCOMMAND |
 468             ((canCutSelection) ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
 469         EnableMenuItem(hmenu, MOZ_Copy, MF_BYCOMMAND |
 470             ((canCopySelection) ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
 471         EnableMenuItem(hmenu, MOZ_Paste, MF_BYCOMMAND |
 472             ((canPaste) ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
 473     }
 474
 475     HWND button;
 476     button = GetDlgItem(hwndDlg, IDC_BACK);
 477     if (button)
 478       EnableWindow(button, canGoBack);
 479     button = GetDlgItem(hwndDlg, IDC_FORWARD);
 480     if (button)
 481       EnableWindow(button, canGoForward);
 482 }
 483
 484
 485 //
 486 //  FUNCTION: BrowserDlgProc()
 487 //
 488 //  PURPOSE: Browser dialog windows message handler.
 489 //
 490 //  COMMENTS:
 491 //
 492 //    The code for handling buttons and menu actions is here.
 493 //
 494 BOOL CALLBACK BrowserDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 495 {
 496     // Get the browser and other pointers since they are used a lot below
 497     HWND hwndBrowser = GetDlgItem(hwndDlg, IDC_BROWSER);
 498     nsIWebBrowserChrome *chrome = nsnull ;
 499     if (hwndBrowser)
 500     {
 501         chrome = (nsIWebBrowserChrome *) GetWindowLong(hwndBrowser, GWL_USERDATA);
 502     }
 503     nsCOMPtr<nsIWebBrowser> webBrowser;
 504     nsCOMPtr<nsIWebNavigation> webNavigation;
 505     if (chrome)
 506     {
 507         chrome->GetWebBrowser(getter_AddRefs(webBrowser));
 508         webNavigation = do_QueryInterface(webBrowser);
 509     }
 510
 511     // Test the message
 512     switch (uMsg)
 513     {
 514     case WM_INITDIALOG:
 515         return TRUE;
 516
 517     case WM_INITMENU:
 518         UpdateUI(chrome);
 519         return TRUE;
 520
 521     case WM_SYSCOMMAND:
 522         if (wParam == SC_CLOSE)
 523         {
 524             WebBrowserChromeUI::Destroy(chrome);
 525             return TRUE;
 526         }
 527         break;
 528
 529     case WM_DESTROY:
 530         return TRUE;
 531
 532     case WM_COMMAND:
 533         if (!webBrowser)
 534         {
 535             return TRUE;
 536         }
 537
 538         // Test which command was selected
 539         switch (LOWORD(wParam))
 540         {
 541         case IDC_ADDRESS:
 542             if (HIWORD(wParam) == CBN_EDITCHANGE || HIWORD(wParam) == CBN_SELCHANGE)
 543             {
 544                 // User has changed the address field so enable the Go button
 545                 EnableWindow(GetDlgItem(hwndDlg, IDC_GO), TRUE);
 546             }
 547             break;
 548
 549         case IDC_GO:
 550             {
 551                 TCHAR szURL[2048];
 552                 memset(szURL, 0, sizeof(szURL));
 553                 GetDlgItemText(hwndDlg, IDC_ADDRESS, szURL,
 554                     sizeof(szURL) / sizeof(szURL[0]) - 1);
 555                 webNavigation->LoadURI(
 556                     NS_ConvertASCIItoUTF16(szURL).get(),
 557                     nsIWebNavigation::LOAD_FLAGS_NONE,
 558                     nsnull,
 559                     nsnull,
 560                     nsnull);
 561             }
 562             break;
 563
 564         case IDC_STOP:
 565             webNavigation->Stop(nsIWebNavigation::STOP_ALL);
 566             UpdateUI(chrome);
 567             break;
 568
 569         case IDC_RELOAD:
 570             webNavigation->Reload(nsIWebNavigation::LOAD_FLAGS_NONE);
 571             break;
 572
 573         case IDM_EXIT:
 574             PostMessage(hwndDlg, WM_SYSCOMMAND, SC_CLOSE, 0);
 575             break;
 576
 577         // File menu commands
 578
 579         case MOZ_NewBrowser:
 580             OpenWebPage(gFirstURL);
 581             break;
 582
 583         // Edit menu commands
 584
 585         case MOZ_Cut:
 586             {
 587                 nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(webBrowser);
 588                 clipCmds->CutSelection();
 589             }
 590             break;
 591
 592         case MOZ_Copy:
 593             {
 594                 nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(webBrowser);
 595                 clipCmds->CopySelection();
 596             }
 597             break;
 598
 599         case MOZ_Paste:
 600             {
 601                 nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(webBrowser);
 602                 clipCmds->Paste();
 603             }
 604             break;
 605
 606         case MOZ_SelectAll:
 607             {
 608                 nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(webBrowser);
 609                 clipCmds->SelectAll();
 610             }
 611             break;
 612
 613         case MOZ_SelectNone:
 614             {
 615                 nsCOMPtr<nsIClipboardCommands> clipCmds = do_GetInterface(webBrowser);
 616                 clipCmds->SelectNone();
 617             }
 618             break;
 619
 620         // Go menu commands
 621         case IDC_BACK:
 622         case MOZ_GoBack:
 623             webNavigation->GoBack();
 624             UpdateUI(chrome);
 625             break;
 626
 627         case IDC_FORWARD:
 628         case MOZ_GoForward:
 629             webNavigation->GoForward();
 630             UpdateUI(chrome);
 631             break;
 632
 633         // Help menu commands
 634         case MOZ_About:
 635             {
 636                 TCHAR szAboutTitle[MAX_LOADSTRING];
 637                 TCHAR szAbout[MAX_LOADSTRING];
 638                 LoadString(ghInstanceApp, IDS_ABOUT_TITLE, szAboutTitle, MAX_LOADSTRING);
 639                 LoadString(ghInstanceApp, IDS_ABOUT, szAbout, MAX_LOADSTRING);
 640                 MessageBox(NULL, szAbout, szAboutTitle, MB_OK);
 641             }
 642             break;
 643         }
 644
 645         return TRUE;
 646
 647     case WM_ACTIVATE:
 648         {
 649             nsCOMPtr<nsIWebBrowserFocus> focus(do_GetInterface(webBrowser));
 650             if(focus)
 651             {
 652                 switch (wParam)
 653                 {
 654                 case WA_ACTIVE:
 655                     focus->Activate();
 656                     break;
 657                 case WA_INACTIVE:
 658                     focus->Deactivate();
 659                     break;
 660                 default:
 661                     break;
 662                 }
 663             }
 664         }
 665         break;
 666
 667     case WM_SIZE:
 668         {
 669             UINT newDlgWidth = LOWORD(lParam);
 670             UINT newDlgHeight = HIWORD(lParam);
 671
 672             // TODO Reposition the control bar - for the moment it's fixed size
 673
 674             // Reposition the status area. Status bar
 675             // gets any space that the fixed size progress bar doesn't use.
 676             int progressWidth;
 677             int statusWidth;
 678             int statusHeight;
 679             HWND hwndStatus = GetDlgItem(hwndDlg, IDC_STATUS);
 680             if (hwndStatus) {
 681               RECT rcStatus;
 682               GetWindowRect(hwndStatus, &rcStatus);
 683               statusHeight = rcStatus.bottom - rcStatus.top;
 684             } else
 685               statusHeight = 0;
 686
 687             HWND hwndProgress = GetDlgItem(hwndDlg, IDC_PROGRESS);
 688             if (hwndProgress) {
 689               RECT rcProgress;
 690               GetWindowRect(hwndProgress, &rcProgress);
 691               progressWidth = rcProgress.right - rcProgress.left;
 692             } else
 693               progressWidth = 0;
 694             statusWidth = newDlgWidth - progressWidth;
 695
 696             if (hwndStatus)
 697               SetWindowPos(hwndStatus,
 698                            HWND_TOP,
 699                            0, newDlgHeight - statusHeight,
 700                            statusWidth,
 701                            statusHeight,
 702                            SWP_NOZORDER);
 703             if (hwndProgress)
 704               SetWindowPos(hwndProgress,
 705                            HWND_TOP,
 706                            statusWidth, newDlgHeight - statusHeight,
 707                            0, 0,
 708                            SWP_NOSIZE | SWP_NOZORDER);
 709
 710             // Resize the browser area (assuming the browse is
 711             // sandwiched between the control bar and status area)
 712             RECT rcBrowser;
 713             POINT ptBrowser;
 714             GetWindowRect(hwndBrowser, &rcBrowser);
 715             ptBrowser.x = rcBrowser.left;
 716             ptBrowser.y = rcBrowser.top;
 717             ScreenToClient(hwndDlg, &ptBrowser);
 718             int browserHeight = newDlgHeight - ptBrowser.y - statusHeight;
 719             if (browserHeight < 1)
 720             {
 721                 browserHeight = 1;
 722             }
 723             SetWindowPos(hwndBrowser,
 724                          HWND_TOP,
 725                          0, 0,
 726                          newDlgWidth,
 727                          newDlgHeight - ptBrowser.y - statusHeight,
 728                          SWP_NOMOVE | SWP_NOZORDER);
 729         }
 730         return TRUE;
 731     }
 732     return FALSE;
 733 }
 734
 735
 736 //
 737 //  FUNCTION: BrowserWndProc(HWND, unsigned, WORD, LONG)
 738 //
 739 //  PURPOSE:  Processes messages for the browser container window.
 740 //
 741 LRESULT CALLBACK BrowserWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 742 {
 743     nsIWebBrowserChrome *chrome = (nsIWebBrowserChrome *) GetWindowLong(hWnd, GWL_USERDATA);
 744     switch (message)
 745     {
 746     case WM_SIZE:
 747         // Resize the embedded browser
 748         ResizeEmbedding(chrome);
 749         return 0;
 750     case WM_ERASEBKGND:
 751         // Reduce flicker by not painting the non-visible background
 752         return 1;
 753     }
 754     return DefWindowProc(hWnd, message, wParam, lParam);
 755 }
 756
 757 //
 758 //  FUNCTION: StartupProfile()
 759 //
 760 //  PURPOSE:
 761 //
 762 nsresult StartupProfile()
 763 {
 764
 765         nsCOMPtr<nsIFile> appDataDir;
 766         nsresult rv = NS_GetSpecialDirectory(NS_APP_APPLICATION_REGISTRY_DIR, getter_AddRefs(appDataDir));
 767         if (NS_FAILED(rv))
 768       return rv;
 769
 770         appDataDir->AppendNative(nsCString("winembed"));
 771         nsCOMPtr<nsILocalFile> localAppDataDir(do_QueryInterface(appDataDir));
 772
 773         nsCOMPtr<nsProfileDirServiceProvider> locProvider;
 774     NS_NewProfileDirServiceProvider(PR_TRUE, getter_AddRefs(locProvider));
 775     if (!locProvider)
 776       return NS_ERROR_FAILURE;
 777
 778         rv = locProvider->Register();
 779     if (NS_FAILED(rv))
 780       return rv;
 781
 782         return locProvider->SetProfileDir(localAppDataDir);
 783
 784 }
 785
 786
 787 ///////////////////////////////////////////////////////////////////////////////
 788 // WebBrowserChromeUI
 789
 790 //
 791 //  FUNCTION: CreateNativeWindow()
 792 //
 793 //  PURPOSE: Creates a new browser dialog.
 794 //
 795 //  COMMENTS:
 796 //
 797 //    This function loads the browser dialog from a resource template
 798 //    and returns the HWND for the webbrowser container dialog item
 799 //    to the caller.
 800 //
 801 HWND WebBrowserChromeUI::CreateNativeWindow(nsIWebBrowserChrome* chrome)
 802 {
 803   // Load the browser dialog from resource
 804   HWND hwndDialog;
 805   PRUint32 chromeFlags;
 806
 807   chrome->GetChromeFlags(&chromeFlags);
 808   if ((chromeFlags & nsIWebBrowserChrome::CHROME_ALL) == nsIWebBrowserChrome::CHROME_ALL)
 809     hwndDialog = CreateDialog(ghInstanceApp,
 810                               MAKEINTRESOURCE(IDD_BROWSER),
 811                               NULL,
 812                               BrowserDlgProc);
 813   else
 814     hwndDialog = CreateDialog(ghInstanceApp,
 815                               MAKEINTRESOURCE(IDD_BROWSER_NC),
 816                               NULL,
 817                               BrowserDlgProc);
 818   if (!hwndDialog)
 819     return NULL;
 820
 821   // Stick a menu onto it
 822   if (chromeFlags & nsIWebBrowserChrome::CHROME_MENUBAR) {
 823     HMENU hmenuDlg = LoadMenu(ghInstanceApp, MAKEINTRESOURCE(IDC_WINEMBED));
 824     SetMenu(hwndDialog, hmenuDlg);
 825   } else
 826     SetMenu(hwndDialog, 0);
 827
 828   // Add some interesting URLs to the address drop down
 829   HWND hwndAddress = GetDlgItem(hwndDialog, IDC_ADDRESS);
 830   if (hwndAddress) {
 831     for (int i = 0; i < sizeof(gDefaultURLs) / sizeof(gDefaultURLs[0]); i++)
 832     {
 833       SendMessage(hwndAddress, CB_ADDSTRING, 0, (LPARAM) gDefaultURLs[i]);
 834     }
 835   }
 836
 837   // Fetch the browser window handle
 838   HWND hwndBrowser = GetDlgItem(hwndDialog, IDC_BROWSER);
 839   SetWindowLong(hwndBrowser, GWL_USERDATA, (LONG)chrome);  // save the browser LONG_PTR.
 840   SetWindowLong(hwndBrowser, GWL_STYLE, GetWindowLong(hwndBrowser, GWL_STYLE) | WS_CLIPCHILDREN);
 841
 842   // Activate the window
 843   PostMessage(hwndDialog, WM_ACTIVATE, WA_ACTIVE, 0);
 844
 845   gDialogCount++;
 846
 847   return hwndBrowser;
 848 }
 849
 850
 851 //
 852 // FUNCTION: Destroy()
 853 //
 854 // PURPOSE: Destroy the window specified by the chrome
 855 //
 856 void WebBrowserChromeUI::Destroy(nsIWebBrowserChrome* chrome)
 857 {
 858   nsCOMPtr<nsIWebBrowser> webBrowser;
 859   nsCOMPtr<nsIWebNavigation> webNavigation;
 860
 861   chrome->GetWebBrowser(getter_AddRefs(webBrowser));
 862   webNavigation = do_QueryInterface(webBrowser);
 863   if (webNavigation)
 864     webNavigation->Stop(nsIWebNavigation::STOP_ALL);
 865
 866   chrome->ExitModalEventLoop(NS_OK);
 867
 868   HWND hwndDlg = GetBrowserDlgFromChrome(chrome);
 869   if (hwndDlg == NULL)
 870     return;
 871
 872   // Explicitly destroy the embedded browser and then the chrome
 873
 874   // First the browser
 875   nsCOMPtr<nsIWebBrowser> browser = nsnull;
 876   chrome->GetWebBrowser(getter_AddRefs(browser));
 877   nsCOMPtr<nsIBaseWindow> browserAsWin = do_QueryInterface(browser);
 878   if (browserAsWin)
 879     browserAsWin->Destroy();
 880
 881       // Now the chrome
 882   chrome->SetWebBrowser(nsnull);
 883   NS_RELEASE(chrome);
 884 }
 885
 886
 887 //
 888 // FUNCTION: Called as the final act of a chrome object during its destructor
 889 //
 890 void WebBrowserChromeUI::Destroyed(nsIWebBrowserChrome* chrome)
 891 {
 892     HWND hwndDlg = GetBrowserDlgFromChrome(chrome);
 893     if (hwndDlg == NULL)
 894     {
 895         return;
 896     }
 897
 898     // Clear the window user data
 899     HWND hwndBrowser = GetDlgItem(hwndDlg, IDC_BROWSER);
 900     SetWindowLong(hwndBrowser, GWL_USERDATA, nsnull);
 901     DestroyWindow(hwndBrowser);
 902     DestroyWindow(hwndDlg);
 903
 904     --gDialogCount;
 905     if (gDialogCount == 0)
 906     {
 907         // Quit when there are no more browser objects
 908         PostQuitMessage(0);
 909     }
 910 }
 911
 912
 913 //
 914 // FUNCTION: Set the input focus onto the browser window
 915 //
 916 void WebBrowserChromeUI::SetFocus(nsIWebBrowserChrome *chrome)
 917 {
 918     HWND hwndDlg = GetBrowserDlgFromChrome(chrome);
 919     if (hwndDlg == NULL)
 920     {
 921         return;
 922     }
 923
 924     HWND hwndBrowser = GetDlgItem(hwndDlg, IDC_BROWSER);
 925     ::SetFocus(hwndBrowser);
 926 }
 927
 928 //
 929 //  FUNCTION: UpdateStatusBarText()
 930 //
 931 //  PURPOSE: Set the status bar text.
 932 //
 933 void WebBrowserChromeUI::UpdateStatusBarText(nsIWebBrowserChrome *aChrome, const PRUnichar* aStatusText)
 934 {
 935     HWND hwndDlg = GetBrowserDlgFromChrome(aChrome);
 936     nsCString status;
 937     if (aStatusText) {
 938         nsString wStatusText(aStatusText);
 939         NS_UTF16ToCString(wStatusText, NS_CSTRING_ENCODING_NATIVE_FILESYSTEM,
 940                           status);
 941     }
 942
 943     SetDlgItemText(hwndDlg, IDC_STATUS, status.get());
 944 }
 945
 946
 947 //
 948 //  FUNCTION: UpdateCurrentURI()
 949 //
 950 //  PURPOSE: Updates the URL address field
 951 //
 952 void WebBrowserChromeUI::UpdateCurrentURI(nsIWebBrowserChrome *aChrome)
 953 {
 954     nsCOMPtr<nsIWebBrowser> webBrowser;
 955     nsCOMPtr<nsIWebNavigation> webNavigation;
 956     aChrome->GetWebBrowser(getter_AddRefs(webBrowser));
 957     webNavigation = do_QueryInterface(webBrowser);
 958
 959     nsCOMPtr<nsIURI> currentURI;
 960     webNavigation->GetCurrentURI(getter_AddRefs(currentURI));
 961     if (currentURI)
 962     {
 963         nsCString uriString;
 964         currentURI->GetAsciiSpec(uriString);
 965         HWND hwndDlg = GetBrowserDlgFromChrome(aChrome);
 966         SetDlgItemText(hwndDlg, IDC_ADDRESS, uriString.get());
 967     }
 968 }
 969
 970
 971 //
 972 //  FUNCTION: UpdateBusyState()
 973 //
 974 //  PURPOSE: Refreshes the stop/go buttons in the browser dialog
 975 //
 976 void WebBrowserChromeUI::UpdateBusyState(nsIWebBrowserChrome *aChrome, PRBool aBusy)
 977 {
 978     HWND hwndDlg = GetBrowserDlgFromChrome(aChrome);
 979     HWND button;
 980     button = GetDlgItem(hwndDlg, IDC_STOP);
 981     if (button)
 982         EnableWindow(button, aBusy);
 983     button = GetDlgItem(hwndDlg, IDC_GO);
 984     if (button)
 985         EnableWindow(button, !aBusy);
 986     UpdateUI(aChrome);
 987 }
 988
 989
 990 //
 991 //  FUNCTION: UpdateProgress()
 992 //
 993 //  PURPOSE: Refreshes the progress bar in the browser dialog
 994 //
 995 void WebBrowserChromeUI::UpdateProgress(nsIWebBrowserChrome *aChrome, PRInt32 aCurrent, PRInt32 aMax)
 996 {
 997     HWND hwndDlg = GetBrowserDlgFromChrome(aChrome);
 998     HWND hwndProgress = GetDlgItem(hwndDlg, IDC_PROGRESS);
 999     if (aCurrent < 0)
1000     {
1001         aCurrent = 0;
1002     }
1003     if (aCurrent > aMax)
1004     {
1005         aMax = aCurrent + 20; // What to do?
1006     }
1007     if (hwndProgress)
1008     {
1009         SendMessage(hwndProgress, PBM_SETRANGE, 0, MAKELPARAM(0, aMax));
1010         SendMessage(hwndProgress, PBM_SETPOS, aCurrent, 0);
1011     }
1012 }
1013
1014 //
1015 //  FUNCTION: ShowContextMenu()
1016 //
1017 //  PURPOSE: Display a context menu for the given node
1018 //
1019 void WebBrowserChromeUI::ShowContextMenu(nsIWebBrowserChrome *aChrome, PRUint32 aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode)
1020 {
1021     // TODO code to test context flags and display a popup menu should go here
1022 }
1023
1024 //
1025 //  FUNCTION: ShowTooltip()
1026 //
1027 //  PURPOSE: Show a tooltip
1028 //
1029 void WebBrowserChromeUI::ShowTooltip(nsIWebBrowserChrome *aChrome, PRInt32 aXCoords, PRInt32 aYCoords, const PRUnichar *aTipText)
1030 {
1031     // TODO code to show a tooltip should go here
1032 }
1033
1034 //
1035 //  FUNCTION: HideTooltip()
1036 //
1037 //  PURPOSE: Hide the tooltip
1038 //
1039 void WebBrowserChromeUI::HideTooltip(nsIWebBrowserChrome *aChrome)
1040 {
1041     // TODO code to hide a tooltip should go here
1042 }
1043
1044 void WebBrowserChromeUI::ShowWindow(nsIWebBrowserChrome *aChrome, PRBool aShow)
1045 {
1046   HWND win = GetBrowserDlgFromChrome(aChrome);
1047   ::ShowWindow(win, aShow ? SW_RESTORE : SW_HIDE);
1048 }
1049
1050 void WebBrowserChromeUI::SizeTo(nsIWebBrowserChrome *aChrome, PRInt32 aWidth, PRInt32 aHeight)
1051 {
1052   HWND hchrome = GetBrowserDlgFromChrome(aChrome);
1053   HWND hbrowser = GetBrowserFromChrome(aChrome);
1054   RECT chromeRect, browserRect;
1055
1056   ::GetWindowRect(hchrome,  &chromeRect);
1057   ::GetWindowRect(hbrowser, &browserRect);
1058
1059   PRInt32 decoration_x = (browserRect.left - chromeRect.left) +
1060                          (chromeRect.right - browserRect.right);
1061   PRInt32 decoration_y = (browserRect.top - chromeRect.top) +
1062                          (chromeRect.bottom - browserRect.bottom);
1063
1064   ::MoveWindow(hchrome, chromeRect.left, chromeRect.top,
1065       aWidth+decoration_x,
1066       aHeight+decoration_y, TRUE);
1067 }
1068
1069 //
1070 //  FUNCTION: GetResourceStringByID()
1071 //
1072 //  PURPOSE: Get the resource string for the ID
1073 //
1074 void WebBrowserChromeUI::GetResourceStringById(PRInt32 aID, char ** aReturn)
1075 {
1076     char resBuf[MAX_LOADSTRING];
1077     int retval = LoadString( ghInstanceApp, aID, (LPTSTR)resBuf, sizeof(resBuf) );
1078     if (retval != 0)
1079     {
1080         int resLen = strlen(resBuf);
1081         *aReturn = (char *)calloc(resLen+1, sizeof(char *));
1082         if (!*aReturn) return;
1083             strncpy(*aReturn, resBuf, resLen);
1084     }
1085     return;
1086 }
1087
1088 //-----------------------------------------------------------------------------
1089 // AppCallbacks
1090 //-----------------------------------------------------------------------------
1091
1092 nsresult AppCallbacks::CreateBrowserWindow(PRUint32 aChromeFlags,
1093            nsIWebBrowserChrome *aParent,
1094            nsIWebBrowserChrome **aNewWindow)
1095 {
1096   WebBrowserChrome * chrome = new WebBrowserChrome();
1097   if (!chrome)
1098     return NS_ERROR_FAILURE;
1099
1100   // the interface to return and one addref, which we assume will be
1101   // immediately released
1102   CallQueryInterface(static_cast<nsIWebBrowserChrome*>(chrome), aNewWindow);
1103   // now an extra addref; the window owns itself (to be released by
1104   // WebBrowserChromeUI::Destroy)
1105   NS_ADDREF(*aNewWindow);
1106
1107   chrome->SetChromeFlags(aChromeFlags);
1108   chrome->SetParent(aParent);
1109
1110   // Insert the browser
1111   nsCOMPtr<nsIWebBrowser> newBrowser;
1112   chrome->CreateBrowser(-1, -1, -1, -1, getter_AddRefs(newBrowser));
1113   if (!newBrowser)
1114     return NS_ERROR_FAILURE;
1115
1116   // Place it where we want it.
1117   ResizeEmbedding(static_cast<nsIWebBrowserChrome*>(chrome));
1118
1119   // if opened as chrome, it'll be made visible after the chrome has loaded.
1120   // otherwise, go ahead and show it now.
1121   if (!(aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME))
1122     WebBrowserChromeUI::ShowWindow(*aNewWindow, PR_TRUE);
1123
1124   return NS_OK;
1125 }
1126
1127 void AppCallbacks::EnableChromeWindow(nsIWebBrowserChrome *aWindow,
1128                       PRBool aEnabled)
1129 {
1130   HWND hwnd = GetBrowserDlgFromChrome(aWindow);
1131   ::EnableWindow(hwnd, aEnabled ? TRUE : FALSE);
1132 }
1133
1134 PRUint32 AppCallbacks::RunEventLoop(PRBool &aRunCondition)
1135 {
1136   MSG msg;
1137   HANDLE hFakeEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
1138
1139   while (aRunCondition ) {
1140     // Process pending messages
1141     while (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
1142       if (!::GetMessage(&msg, NULL, 0, 0)) {
1143         // WM_QUIT
1144         aRunCondition = PR_FALSE;
1145         break;
1146       }
1147
1148       ::TranslateMessage(&msg);
1149       ::DispatchMessage(&msg);
1150     }
1151
1152     // Do idle stuff
1153     ::MsgWaitForMultipleObjects(1, &hFakeEvent, FALSE, 100, QS_ALLEVENTS);
1154   }
1155   ::CloseHandle(hFakeEvent);
1156   return msg.wParam;
1157 }