mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/webshell/tests/viewer/nsBrowserWindow.cpp

3524 строки
88 KiB
C++
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is Netscape Communications
* Corporation. Portions created by Netscape are Copyright (C) 1998
* Netscape Communications Corporation. All Rights Reserved.
*/
#include "nsIPref.h"
#include "prmem.h"
#ifdef XP_MAC
#include "nsBrowserWindow.h"
#define NS_IMPL_IDS
#else
#define NS_IMPL_IDS
#include "nsBrowserWindow.h"
#endif
#include "nsIStreamListener.h"
#include "nsIAppShell.h"
#include "nsIWidget.h"
#include "nsITextWidget.h"
#include "nsIButton.h"
#include "nsIImageGroup.h"
#include "nsITimer.h"
#include "nsIDOMDocument.h"
#include "nsIURL.h"
#include "nsIFileWidget.h"
#include "nsILookAndFeel.h"
#include "nsIComponentManager.h"
#include "nsIFactory.h"
#include "nsCRT.h"
#include "nsWidgetsCID.h"
#include "nsViewerApp.h"
#include "prprf.h"
#include "nsIComponentManager.h"
#include "nsParserCIID.h"
#include "nsIEnumerator.h"
#include "nsCOMPtr.h"
#include "nsIServiceManager.h"
#include "nsIStringBundle.h"
#include "nsLayoutCID.h"
#include "nsIDocumentViewer.h"
#include "nsIContentViewer.h"
#include "nsIPresShell.h"
#include "nsIPresContext.h"
#include "nsIDocument.h"
#include "nsILayoutDebugger.h"
#include "nsThrobber.h"
#include "nsIDocumentLoader.h"
#include "nsXIFDTD.h"
#include "nsIParser.h"
#include "nsHTMLContentSinkStream.h"
#include "nsEditorMode.h"
// Needed for "Find" GUI
#include "nsICheckButton.h"
#include "nsIRadioButton.h"
#include "nsILabel.h"
#include "nsWidgetSupport.h"
#include "nsXPBaseWindow.h"
#include "nsFindDialog.h"
#include "resources.h"
#if defined(WIN32)
#include <windows.h>
#endif
#include <ctype.h> // tolower
// For Copy
#include "nsIDOMSelection.h"
// XXX For font setting below
#include "nsFont.h"
#include "nsUnitConversion.h"
#include "nsIDeviceContext.h"
#if defined(CookieManagement) || defined(SingleSignon) || defined(ClientWallet)
#include "nsIServiceManager.h"
#endif
#ifdef CookieManagement
#ifndef NECKO
#include "nsINetService.h"
static NS_DEFINE_IID(kINetServiceIID, NS_INETSERVICE_IID);
static NS_DEFINE_CID(kNetServiceCID, NS_NETSERVICE_CID);
#else
#include "nsIURL.h"
#endif // NECKO
#endif
#include "nsIIOService.h"
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
#if defined(ClientWallet) || defined(SingleSignon)
#include "nsIWalletService.h"
static NS_DEFINE_IID(kIWalletServiceIID, NS_IWALLETSERVICE_IID);
static NS_DEFINE_CID(kWalletServiceCID, NS_WALLETSERVICE_CID);
#endif
#ifdef PURIFY
#include "pure.h"
#endif
#define THROBBING_N
// XXX greasy constants
#ifdef THROBBING_N
#define THROBBER_WIDTH 32
#define THROBBER_HEIGHT 32
#define THROBBER_AT "resource:/res/throbber/anims%02d.gif"
#define THROB_NUM 29
#else
#define THROBBER_WIDTH 42
#define THROBBER_HEIGHT 42
#define THROBBER_AT "resource:/res/throbber/LargeAnimation%02d.gif"
#define THROB_NUM 38
#endif
#define BUTTON_WIDTH 90
#define BUTTON_HEIGHT THROBBER_HEIGHT
#ifdef INSET_WEBSHELL
#define WEBSHELL_LEFT_INSET 5
#define WEBSHELL_RIGHT_INSET 5
#define WEBSHELL_TOP_INSET 5
#define WEBSHELL_BOTTOM_INSET 5
#else
#define WEBSHELL_LEFT_INSET 0
#define WEBSHELL_RIGHT_INSET 0
#define WEBSHELL_TOP_INSET 0
#define WEBSHELL_BOTTOM_INSET 0
#endif
static NS_DEFINE_CID(kLookAndFeelCID, NS_LOOKANDFEEL_CID);
static NS_DEFINE_CID(kBrowserWindowCID, NS_BROWSER_WINDOW_CID);
static NS_DEFINE_CID(kButtonCID, NS_BUTTON_CID);
static NS_DEFINE_CID(kFileWidgetCID, NS_FILEWIDGET_CID);
static NS_DEFINE_CID(kTextFieldCID, NS_TEXTFIELD_CID);
static NS_DEFINE_CID(kWebShellCID, NS_WEB_SHELL_CID);
static NS_DEFINE_CID(kWindowCID, NS_WINDOW_CID);
static NS_DEFINE_CID(kDialogCID, NS_DIALOG_CID);
static NS_DEFINE_CID(kCheckButtonCID, NS_CHECKBUTTON_CID);
static NS_DEFINE_CID(kRadioButtonCID, NS_RADIOBUTTON_CID);
static NS_DEFINE_CID(kLabelCID, NS_LABEL_CID);
static NS_DEFINE_IID(kIXPBaseWindowIID, NS_IXPBASE_WINDOW_IID);
static NS_DEFINE_IID(kILookAndFeelIID, NS_ILOOKANDFEEL_IID);
static NS_DEFINE_IID(kIBrowserWindowIID, NS_IBROWSER_WINDOW_IID);
static NS_DEFINE_IID(kIButtonIID, NS_IBUTTON_IID);
static NS_DEFINE_IID(kIDOMDocumentIID, NS_IDOMDOCUMENT_IID);
static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
static NS_DEFINE_IID(kIFileWidgetIID, NS_IFILEWIDGET_IID);
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
static NS_DEFINE_IID(kITextWidgetIID, NS_ITEXTWIDGET_IID);
static NS_DEFINE_IID(kIWebShellIID, NS_IWEB_SHELL_IID);
static NS_DEFINE_IID(kIWebShellContainerIID, NS_IWEB_SHELL_CONTAINER_IID);
static NS_DEFINE_IID(kIWidgetIID, NS_IWIDGET_IID);
static NS_DEFINE_IID(kICheckButtonIID, NS_ICHECKBUTTON_IID);
static NS_DEFINE_IID(kIRadioButtonIID, NS_IRADIOBUTTON_IID);
static NS_DEFINE_IID(kILabelIID, NS_ILABEL_IID);
static NS_DEFINE_IID(kIPromptIID, NS_IPROMPT_IID);
static NS_DEFINE_IID(kIDocumentViewerIID, NS_IDOCUMENT_VIEWER_IID);
static NS_DEFINE_CID(kXPBaseWindowCID, NS_XPBASE_WINDOW_CID);
static NS_DEFINE_IID(kIStringBundleServiceIID, NS_ISTRINGBUNDLESERVICE_IID);
static NS_DEFINE_CID(kStringBundleServiceCID, NS_STRINGBUNDLESERVICE_CID);
static NS_DEFINE_IID(kILayoutDebuggerIID, NS_ILAYOUT_DEBUGGER_IID);
static NS_DEFINE_CID(kLayoutDebuggerCID, NS_LAYOUT_DEBUGGER_CID);
static NS_DEFINE_IID(kIDocumentLoaderObserverIID, NS_IDOCUMENT_LOADER_OBSERVER_IID);
#define FILE_PROTOCOL "file://"
// prototypes
#if 0
static nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent);
#endif
static void* GetItemsNativeData(nsISupports* aObject);
//----------------------------------------------------------------------
static
nsIPresShell*
GetPresShellFor(nsIWebShell* aWebShell)
{
nsIPresShell* shell = nsnull;
if (nsnull != aWebShell) {
nsIContentViewer* cv = nsnull;
aWebShell->GetContentViewer(&cv);
if (nsnull != cv) {
nsIDocumentViewer* docv = nsnull;
cv->QueryInterface(kIDocumentViewerIID, (void**) &docv);
if (nsnull != docv) {
nsIPresContext* cx;
docv->GetPresContext(cx);
if (nsnull != cx) {
cx->GetShell(&shell);
NS_RELEASE(cx);
}
NS_RELEASE(docv);
}
NS_RELEASE(cv);
}
}
return shell;
}
nsVoidArray nsBrowserWindow::gBrowsers;
nsBrowserWindow*
nsBrowserWindow::FindBrowserFor(nsIWidget* aWidget, PRIntn aWhich)
{
nsIWidget* widget;
nsBrowserWindow* result = nsnull;
PRInt32 i, n = gBrowsers.Count();
for (i = 0; i < n; i++) {
nsBrowserWindow* bw = (nsBrowserWindow*) gBrowsers.ElementAt(i);
if (nsnull != bw) {
switch (aWhich) {
case FIND_WINDOW:
if (bw->mWindow) {
bw->mWindow->QueryInterface(kIWidgetIID, (void**) &widget);
if (widget == aWidget) {
result = bw;
}
NS_IF_RELEASE(widget);
}
break;
case FIND_BACK:
if (bw->mBack) {
bw->mBack->QueryInterface(kIWidgetIID, (void**) &widget);
if (widget == aWidget) {
result = bw;
}
NS_IF_RELEASE(widget);
}
break;
case FIND_FORWARD:
if (bw->mForward) {
bw->mForward->QueryInterface(kIWidgetIID, (void**) &widget);
if (widget == aWidget) {
result = bw;
}
NS_IF_RELEASE(widget);
}
break;
case FIND_LOCATION:
if (bw->mLocation) {
bw->mLocation->QueryInterface(kIWidgetIID, (void**) &widget);
if (widget == aWidget) {
result = bw;
}
NS_IF_RELEASE(widget);
}
break;
}
}
}
if (nsnull != result) {
NS_ADDREF(result);
}
return result;
}
void
nsBrowserWindow::AddBrowser(nsBrowserWindow* aBrowser)
{
gBrowsers.AppendElement(aBrowser);
NS_ADDREF(aBrowser);
}
void
nsBrowserWindow::RemoveBrowser(nsBrowserWindow* aBrowser)
{
//nsViewerApp* app = aBrowser->mApp;
gBrowsers.RemoveElement(aBrowser);
NS_RELEASE(aBrowser);
}
void
nsBrowserWindow::CloseAllWindows()
{
while (0 != gBrowsers.Count()) {
nsBrowserWindow* bw = (nsBrowserWindow*) gBrowsers.ElementAt(0);
NS_ADDREF(bw);
bw->Close();
NS_RELEASE(bw);
}
gBrowsers.Clear();
}
static nsEventStatus PR_CALLBACK
HandleBrowserEvent(nsGUIEvent *aEvent)
{
nsEventStatus result = nsEventStatus_eIgnore;
nsBrowserWindow* bw =
nsBrowserWindow::FindBrowserFor(aEvent->widget, FIND_WINDOW);
if (nsnull != bw) {
nsSizeEvent* sizeEvent;
switch(aEvent->message) {
case NS_SIZE:
sizeEvent = (nsSizeEvent*)aEvent;
bw->Layout(sizeEvent->windowSize->width,
sizeEvent->windowSize->height);
result = nsEventStatus_eConsumeNoDefault;
break;
case NS_DESTROY:
{
nsViewerApp* app = bw->mApp;
app->CloseWindow(bw);
result = nsEventStatus_eConsumeDoDefault;
#ifndef XP_MAC
// XXX Really shouldn't just exit, we should just notify somebody...
if (0 == nsBrowserWindow::gBrowsers.Count()) {
app->Exit();
}
#endif
}
return result;
case NS_MENU_SELECTED:
result = bw->DispatchMenuItem(((nsMenuEvent*)aEvent)->mCommand);
break;
default:
break;
}
NS_RELEASE(bw);
}
return result;
}
static nsEventStatus PR_CALLBACK
HandleBackEvent(nsGUIEvent *aEvent)
{
nsEventStatus result = nsEventStatus_eIgnore;
nsBrowserWindow* bw =
nsBrowserWindow::FindBrowserFor(aEvent->widget, FIND_BACK);
if (nsnull != bw) {
switch(aEvent->message) {
case NS_MOUSE_LEFT_BUTTON_UP:
bw->Back();
break;
}
NS_RELEASE(bw);
}
return result;
}
static nsEventStatus PR_CALLBACK
HandleForwardEvent(nsGUIEvent *aEvent)
{
nsEventStatus result = nsEventStatus_eIgnore;
nsBrowserWindow* bw =
nsBrowserWindow::FindBrowserFor(aEvent->widget, FIND_FORWARD);
if (nsnull != bw) {
switch(aEvent->message) {
case NS_MOUSE_LEFT_BUTTON_UP:
bw->Forward();
break;
}
NS_RELEASE(bw);
}
return result;
}
static nsEventStatus PR_CALLBACK
HandleLocationEvent(nsGUIEvent *aEvent)
{
nsEventStatus result = nsEventStatus_eIgnore;
nsBrowserWindow* bw =
nsBrowserWindow::FindBrowserFor(aEvent->widget, FIND_LOCATION);
if (nsnull != bw) {
switch (aEvent->message) {
case NS_KEY_UP:
if (NS_VK_RETURN == ((nsKeyEvent*)aEvent)->keyCode) {
nsAutoString text;
PRUint32 size;
bw->mLocation->GetText(text, 1000, size);
bw->GoTo(text.GetUnicode());
}
break;
case NS_DRAGDROP_EVENT: {
/*printf("Drag & Drop Event\n");
nsDragDropEvent * ev = (nsDragDropEvent *)aEvent;
nsAutoString fileURL;
BuildFileURL(ev->mURL, fileURL);
nsAutoString fileName(ev->mURL);
char * str = fileName.ToNewCString();
PRInt32 len = strlen(str);
PRInt32 sum = len + sizeof(FILE_PROTOCOL);
char* lpszFileURL = new char[sum];
// Translate '\' to '/'
for (PRInt32 i = 0; i < len; i++) {
if (str[i] == '\\') {
str[i] = '/';
}
}
// Build the file URL
PR_snprintf(lpszFileURL, sum, "%s%s", FILE_PROTOCOL, str);
// Ask the Web widget to load the file URL
nsString urlStr(lpszFileURL);
const PRUnichar * uniStr = fileURL.GetUnicode();
bw->GoTo(uniStr);
//delete [] lpszFileURL;
//delete [] str;*/
} break;
default:
break;
}
NS_RELEASE(bw);
}
return result;
}
#ifdef PURIFY
static void
DispatchPurifyEvent(PRInt32 aID)
{
if (!PurifyIsRunning()) {
printf("!!! Re-run viewer under Purify to use this menu item.\n");
return;
}
switch (aID) {
case VIEWER_PURIFY_SHOW_NEW_LEAKS:
PurifyPrintf("viewer: new leaks");
PurifyNewLeaks();
break;
case VIEWER_PURIFY_SHOW_ALL_LEAKS:
PurifyPrintf("viewer: all leaks");
PurifyAllLeaks();
break;
case VIEWER_PURIFY_CLEAR_ALL_LEAKS:
PurifyPrintf("viewer: clear leaks");
PurifyClearLeaks();
break;
case VIEWER_PURIFY_SHOW_ALL_HANDLES_IN_USE:
PurifyPrintf("viewer: all handles");
PurifyAllHandlesInuse();
break;
case VIEWER_PURIFY_SHOW_NEW_IN_USE:
PurifyPrintf("viewer: new in-use");
PurifyNewInuse();
break;
case VIEWER_PURIFY_SHOW_ALL_IN_USE:
PurifyPrintf("viewer: all in-use");
PurifyAllInuse();
break;
case VIEWER_PURIFY_CLEAR_ALL_IN_USE:
PurifyPrintf("viewer: clear in-use");
PurifyClearInuse();
break;
case VIEWER_PURIFY_HEAP_VALIDATE:
PurifyPrintf("viewer: heap validate");
PurifyHeapValidate(PURIFY_HEAP_ALL, PURIFY_HEAP_BLOCKS_ALL, NULL);
break;
}
}
#endif
nsEventStatus
nsBrowserWindow::DispatchMenuItem(PRInt32 aID)
{
#if defined(CookieManagement) || defined(SingleSignon) || defined(ClientWallet)
nsresult res;
#if defined(ClientWallet) || defined(SingleSignon)
nsIWalletService *walletservice;
#endif
#ifdef ClientWallet
#define WALLET_EDITOR_URL "file:///y|/walleted.html"
nsAutoString urlString(WALLET_EDITOR_URL);
#endif
#endif
nsEventStatus result;
#ifdef NS_DEBUG
result = DispatchDebugMenu(aID);
if (nsEventStatus_eIgnore != result) {
return result;
}
#endif
result = DispatchStyleMenu(aID);
if (nsEventStatus_eIgnore != result) {
return result;
}
switch (aID) {
case VIEWER_EXIT:
mApp->Exit();
return nsEventStatus_eConsumeNoDefault;
case VIEWER_WINDOW_OPEN:
mApp->OpenWindow();
break;
case VIEWER_FILE_OPEN:
DoFileOpen();
break;
case VIEW_SOURCE:
{
PRInt32 theIndex;
mWebShell->GetHistoryIndex(theIndex);
const PRUnichar* theURL;
mWebShell->GetURL(theIndex,&theURL);
nsAutoString theString(theURL);
mApp->ViewSource(theString);
//XXX Find out how the string is allocated, and perhaps delete it...
}
break;
case VIEWER_EDIT_COPY:
DoCopy();
break;
case VIEWER_EDIT_PASTE:
DoPaste();
break;
case VIEWER_EDIT_FINDINPAGE:
DoFind();
break;
case VIEWER_DEMO0:
case VIEWER_DEMO1:
case VIEWER_DEMO2:
case VIEWER_DEMO3:
case VIEWER_DEMO4:
case VIEWER_DEMO5:
case VIEWER_DEMO6:
case VIEWER_DEMO7:
case VIEWER_DEMO8:
case VIEWER_DEMO9:
case VIEWER_DEMO10:
case VIEWER_DEMO11:
case VIEWER_DEMO12:
case VIEWER_DEMO13:
case VIEWER_DEMO14:
case VIEWER_DEMO15:
case VIEWER_DEMO16:
case VIEWER_DEMO17:
{
PRIntn ix = aID - VIEWER_DEMO0;
nsAutoString url(SAMPLES_BASE_URL);
url.Append("/test");
url.Append(ix, 10);
url.Append(".html");
mWebShell->LoadURL(url.GetUnicode());
}
break;
case VIEWER_XPTOOLKITTOOLBAR1:
{
nsAutoString url(SAMPLES_BASE_URL);
url.Append("/toolbarTest1.xul");
mWebShell->LoadURL(url.GetUnicode());
break;
}
case VIEWER_XPTOOLKITTREE1:
{
nsAutoString url(SAMPLES_BASE_URL);
url.Append("/treeTest1.xul");
mWebShell->LoadURL(url.GetUnicode());
break;
}
case JS_CONSOLE:
DoJSConsole();
break;
case VIEWER_PREFS:
DoPrefs();
break;
case EDITOR_MODE:
DoEditorMode(mWebShell);
break;
case VIEWER_ONE_COLUMN:
case VIEWER_TWO_COLUMN:
case VIEWER_THREE_COLUMN:
ShowPrintPreview(aID);
break;
case VIEWER_PRINT:
DoPrint();
break;
case VIEWER_PRINT_SETUP:
DoPrintSetup();
break;
case VIEWER_TABLE_INSPECTOR:
DoTableInspector();
break;
case VIEWER_IMAGE_INSPECTOR:
DoImageInspector();
break;
#ifdef PURIFY
case VIEWER_PURIFY_SHOW_NEW_LEAKS:
case VIEWER_PURIFY_SHOW_ALL_LEAKS:
case VIEWER_PURIFY_CLEAR_ALL_LEAKS:
case VIEWER_PURIFY_SHOW_ALL_HANDLES_IN_USE:
case VIEWER_PURIFY_SHOW_NEW_IN_USE:
case VIEWER_PURIFY_SHOW_ALL_IN_USE:
case VIEWER_PURIFY_CLEAR_ALL_IN_USE:
case VIEWER_PURIFY_HEAP_VALIDATE:
DispatchPurifyEvent(aID);
break;
#endif
case VIEWER_ZOOM_500:
case VIEWER_ZOOM_300:
case VIEWER_ZOOM_200:
case VIEWER_ZOOM_100:
case VIEWER_ZOOM_070:
case VIEWER_ZOOM_050:
case VIEWER_ZOOM_030:
case VIEWER_ZOOM_020:
mWebShell->SetZoom((aID - VIEWER_ZOOM_BASE) / 10.0f);
break;
#ifdef ClientWallet
case PRVCY_PREFILL:
case PRVCY_QPREFILL:
nsIPresShell* shell;
shell = nsnull;
shell = GetPresShell();
res = nsServiceManager::GetService(kWalletServiceCID,
kIWalletServiceIID,
(nsISupports **)&walletservice);
if ((NS_OK == res) && (nsnull != walletservice)) {
nsString urlString2 = nsString("");
res = walletservice->WALLET_Prefill(shell, (PRVCY_QPREFILL == aID));
NS_RELEASE(walletservice);
}
#ifndef HTMLDialogs
if (aID == PRVCY_PREFILL) {
nsAutoString url("file:///y|/htmldlgs.htm");
nsIBrowserWindow* bw = nsnull;
mApp->OpenWindow(PRUint32(~0), bw);
bw->Show();
((nsBrowserWindow *)bw)->GoTo(url.GetUnicode());
NS_RELEASE(bw);
}
#endif
break;
case PRVCY_DISPLAY_WALLET:
/* set a cookie for the javascript wallet editor */
res = nsServiceManager::GetService(kWalletServiceCID,
kIWalletServiceIID,
(nsISupports **)&walletservice);
if ((NS_OK == res) && (nsnull != walletservice)) {
nsIURI * url;
#ifndef NECKO
res = NS_NewURL(&url, WALLET_EDITOR_URL);
#else
NS_WITH_SERVICE(nsIIOService, service, kIOServiceCID, &res);
if (NS_FAILED(res)) return nsEventStatus_eIgnore;
nsIURI *uri = nsnull;
res = service->NewURI(WALLET_EDITOR_URL, nsnull, &uri);
if (NS_FAILED(res)) return nsEventStatus_eIgnore;
res = uri->QueryInterface(nsIURI::GetIID(), (void**)&url);
NS_RELEASE(uri);
#endif // NECKO
if (!NS_FAILED(res)) {
// res = walletservice->WALLET_PreEdit(url);
NS_RELEASE(walletservice);
}
}
/* invoke the javascript wallet editor */
mWebShell->LoadURL(urlString.GetUnicode());
break;
#endif
#if defined(CookieManagement)
case PRVCY_DISPLAY_COOKIES:
{
#ifndef NECKO
nsINetService *netservice;
res = nsServiceManager::GetService(kNetServiceCID,
kINetServiceIID,
(nsISupports **)&netservice);
if ((NS_OK == res) && (nsnull != netservice)) {
// res = netservice->Cookie_DisplayCookieInfoAsHTML();
NS_RELEASE(netservice);
}
#endif // NECKO
break;
}
#endif
#if defined(SingleSignon)
case PRVCY_DISPLAY_SIGNONS:
res = nsServiceManager::GetService(kWalletServiceCID,
kIWalletServiceIID,
(nsISupports **)&walletservice);
if ((NS_OK == res) && (nsnull != walletservice)) {
// res = walletservice->SI_DisplaySignonInfoAsHTML();
NS_RELEASE(walletservice);
}
break;
#endif
}
// Any menu IDs that the editor uses will be processed here
DoEditorTest(mWebShell, aID);
return nsEventStatus_eIgnore;
}
void
nsBrowserWindow::Back()
{
mWebShell->Back();
}
void
nsBrowserWindow::Forward()
{
mWebShell->Forward();
}
void
nsBrowserWindow::GoTo(const PRUnichar* aURL,const char* aCommand)
{
mWebShell->LoadURL(aURL, aCommand, nsnull);
}
static PRBool GetFileFromFileSelector(nsIWidget* aParentWindow,
nsFileSpec& aFileSpec,
nsFileSpec& aDisplayDirectory)
{
PRBool selectedFileName = PR_FALSE;
nsIFileWidget *fileWidget;
nsString title("Open HTML");
nsresult rv = nsComponentManager::CreateInstance(kFileWidgetCID,
nsnull,
kIFileWidgetIID,
(void**)&fileWidget);
if (NS_OK == rv) {
nsString titles[] = {"All Readable Files", "HTML Files",
"XML Files", "Image Files", "All Files"};
nsString filters[] = {"*.htm; *.html; *.xml; *.gif; *.jpg; *.jpeg; *.png",
"*.htm; *.html",
"*.xml",
"*.gif; *.jpg; *.jpeg; *.png",
"*.*"};
fileWidget->SetFilterList(5, titles, filters);
fileWidget->SetDisplayDirectory(aDisplayDirectory);
fileWidget->Create(aParentWindow,
title,
eMode_load,
nsnull,
nsnull);
PRUint32 result = fileWidget->Show();
if (result) {
fileWidget->GetFile(aFileSpec);
selectedFileName = PR_TRUE;
}
fileWidget->GetDisplayDirectory(aDisplayDirectory);
NS_RELEASE(fileWidget);
}
return selectedFileName;
}
void
nsBrowserWindow::DoFileOpen()
{
nsFileSpec fileSpec;
if (GetFileFromFileSelector(mWindow, fileSpec, mOpenFileDirectory)) {
nsFileURL fileURL(fileSpec);
// Ask the Web widget to load the file URL
mWebShell->LoadURL(nsString(fileURL.GetURLString()).GetUnicode());
Show();
}
}
#define DIALOG_FONT "Helvetica"
#define DIALOG_FONT_SIZE 10
/**--------------------------------------------------------------------------------
* Main Handler
*--------------------------------------------------------------------------------
*/
#if 0
nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent)
{
//printf("HandleEvent aEvent->message %d\n", aEvent->message);
nsEventStatus result = nsEventStatus_eIgnore;
if (aEvent == nsnull || aEvent->widget == nsnull) {
return result;
}
if (aEvent->message == 301 || aEvent->message == 302) {
//int x = 0;
}
void * data;
aEvent->widget->GetClientData(data);
if (data == nsnull) {
nsIWidget * parent = aEvent->widget->GetParent();
if (parent != nsnull) {
parent->GetClientData(data);
NS_RELEASE(parent);
}
}
if (data != nsnull) {
nsBrowserWindow * browserWindow = (nsBrowserWindow *)data;
result = browserWindow->ProcessDialogEvent(aEvent);
}
return result;
}
#endif
static void* GetItemsNativeData(nsISupports* aObject)
{
void* result = nsnull;
nsIWidget* widget;
if (NS_OK == aObject->QueryInterface(kIWidgetIID,(void**)&widget))
{
result = widget->GetNativeData(NS_NATIVE_WIDGET);
NS_RELEASE(widget);
}
return result;
}
//---------------------------------------------------------------
NS_IMETHODIMP nsBrowserWindow::FindNext(const nsString &aSearchStr, PRBool aMatchCase, PRBool aSearchDown, PRBool &aIsFound)
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsCOMPtr<nsIDocument> doc;
shell->GetDocument(getter_AddRefs(doc));
if (doc) {
//PRBool foundIt = PR_FALSE;
doc->FindNext(aSearchStr, aMatchCase, aSearchDown, aIsFound);
if (!aIsFound) {
// Display Dialog here
}
ForceRefresh();
}
NS_RELEASE(shell);
}
return NS_OK;
}
//---------------------------------------------------------------
NS_IMETHODIMP nsBrowserWindow::ForceRefresh()
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsCOMPtr<nsIViewManager> vm;
shell->GetViewManager(getter_AddRefs(vm));
if (vm) {
nsIView* root;
vm->GetRootView(root);
if (nsnull != root) {
vm->UpdateView(root, (nsIRegion*)nsnull, NS_VMREFRESH_IMMEDIATE);
}
}
NS_RELEASE(shell);
}
return NS_OK;
}
/**--------------------------------------------------------------------------------
* Main Handler
*--------------------------------------------------------------------------------
*/
nsEventStatus nsBrowserWindow::ProcessDialogEvent(nsGUIEvent *aEvent)
{
nsEventStatus result = nsEventStatus_eIgnore;
//printf("aEvent->message %d\n", aEvent->message);
switch(aEvent->message) {
case NS_KEY_DOWN: {
nsKeyEvent* keyEvent = (nsKeyEvent*)aEvent;
if (NS_VK_RETURN == keyEvent->keyCode) {
PRBool matchCase = PR_FALSE;
mMatchCheckBtn->GetState(matchCase);
PRBool findDwn = PR_FALSE;
mDwnRadioBtn->GetState(findDwn);
nsString searchStr;
PRUint32 actualSize;
mTextField->GetText(searchStr, 255,actualSize);
PRBool foundIt;
FindNext(searchStr, matchCase, findDwn, foundIt);
}
} break;
case NS_MOUSE_LEFT_BUTTON_UP: {
nsIWidget* dialogWidget = nsnull;
if (NS_OK != mDialog->QueryInterface(kIWidgetIID,(void**)&dialogWidget))
break;
if (aEvent->widget->GetNativeData(NS_NATIVE_WIDGET) == GetItemsNativeData(mCancelBtn)) {
dialogWidget->Show(PR_FALSE);
} else if (aEvent->widget->GetNativeData(NS_NATIVE_WIDGET) == GetItemsNativeData(mFindBtn)) {
PRBool matchCase = PR_FALSE;
mMatchCheckBtn->GetState(matchCase);
PRBool findDwn = PR_FALSE;
mDwnRadioBtn->GetState(findDwn);
PRUint32 actualSize;
nsString searchStr;
mTextField->GetText(searchStr, 255,actualSize);
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsCOMPtr<nsIDocument> doc;
shell->GetDocument(getter_AddRefs(doc));
if (doc) {
PRBool foundIt = PR_FALSE;
doc->FindNext(searchStr, matchCase, findDwn, foundIt);
if (!foundIt) {
// Display Dialog here
}
ForceRefresh();
}
NS_RELEASE(shell);
}
} else if (aEvent->widget->GetNativeData(NS_NATIVE_WIDGET) == GetItemsNativeData(mUpRadioBtn)) {
mUpRadioBtn->SetState(PR_TRUE);
mDwnRadioBtn->SetState(PR_FALSE);
} else if (aEvent->widget->GetNativeData(NS_NATIVE_WIDGET) == GetItemsNativeData(mDwnRadioBtn)) {
mDwnRadioBtn->SetState(PR_TRUE);
mUpRadioBtn->SetState(PR_FALSE);
} else if (aEvent->widget->GetNativeData(NS_NATIVE_WIDGET) == GetItemsNativeData(mMatchCheckBtn)) {
PRBool state = PR_FALSE;
mMatchCheckBtn->GetState(state);
mMatchCheckBtn->SetState(!state);
}
} break;
case NS_PAINT:
#ifndef XP_UNIX
// paint the background
if (aEvent->widget->GetNativeData(NS_NATIVE_WIDGET) == GetItemsNativeData(mDialog)) {
nsIRenderingContext *drawCtx = ((nsPaintEvent*)aEvent)->renderingContext;
drawCtx->SetColor(aEvent->widget->GetBackgroundColor());
drawCtx->FillRect(*(((nsPaintEvent*)aEvent)->rect));
return nsEventStatus_eIgnore;
}
#endif
break;
default:
result = nsEventStatus_eIgnore;
}
//printf("result: %d = %d\n", result, PR_FALSE);
return result;
}
void
nsBrowserWindow::DoFind()
{
if (mXPDialog) {
NS_RELEASE(mXPDialog);
//mXPDialog->SetVisible(PR_TRUE);
//return;
}
nsString findHTML("resource:/res/samples/find.html");
//nsString findHTML("resource:/res/samples/find-table.html");
nsRect rect(0, 0, 510, 170);
//nsRect rect(0, 0, 470, 126);
nsString title("Find");
nsXPBaseWindow * dialog = nsnull;
nsresult rv = nsComponentManager::CreateInstance(kXPBaseWindowCID, nsnull,
kIXPBaseWindowIID,
(void**) &dialog);
if (rv == NS_OK) {
dialog->Init(eXPBaseWindowType_dialog, mAppShell, nsnull, findHTML, title, rect, PRUint32(~0), PR_FALSE);
dialog->SetVisible(PR_TRUE);
if (NS_OK == dialog->QueryInterface(kIXPBaseWindowIID, (void**) &mXPDialog)) {
}
}
nsFindDialog * findDialog = new nsFindDialog(this);
if (nsnull != findDialog) {
dialog->AddWindowListener(findDialog);
}
//NS_IF_RELEASE(dialog);
}
//----------------------------------------------------------------------
#define VIEWER_BUNDLE_URL "resource:/res/viewer.properties"
static nsString* gTitleSuffix = nsnull;
#if XXX
static nsString*
GetTitleSuffix(void)
{
nsString* suffix = new nsString(" - Failed");
nsIStringBundleService* service = nsnull;
nsresult ret = nsServiceManager::GetService(kStringBundleServiceCID,
kIStringBundleServiceIID, (nsISupports**) &service);
if (NS_FAILED(ret)) {
return suffix;
}
nsIURI* url = nsnull;
#ifndef NECKO
ret = NS_NewURL(&url, nsString(VIEWER_BUNDLE_URL));
#else
NS_WITH_SERVICE(nsIIOService, service, kIOServiceCID, &ret);
if (NS_FAILED(ret)) return ret;
nsIURI *uri = nsnull;
ret = service->NewURI(VIEWER_BUNDLE_URL, nsnull, &uri);
if (NS_FAILED(ret)) return ret;
ret = uri->QueryInterface(nsIURI::GetIID(), (void**)&url);
NS_RELEASE(uri);
#endif // NECKO
if (NS_FAILED(ret)) {
NS_RELEASE(service);
return suffix;
}
nsILocale* locale = nsnull;
nsIStringBundle* bundle = nsnull;
ret = service->CreateBundle(url, locale, &bundle);
NS_RELEASE(url);
if (NS_FAILED(ret)) {
NS_RELEASE(service);
return suffix;
}
ret = bundle->GetStringFromID(1, *suffix);
NS_RELEASE(bundle);
NS_RELEASE(service);
return suffix;
}
#endif
// Note: operator new zeros our memory
nsBrowserWindow::nsBrowserWindow()
{
if (!gTitleSuffix) {
#if XXX
gTitleSuffix = GetTitleSuffix();
#endif
gTitleSuffix = new nsString(" - Raptor");
}
AddBrowser(this);
}
nsBrowserWindow::~nsBrowserWindow()
{
NS_IF_RELEASE(mPrefs);
NS_IF_RELEASE(mAppShell);
NS_IF_RELEASE(mTableInspectorDialog);
NS_IF_RELEASE(mImageInspectorDialog);
NS_IF_RELEASE(mWebCrawler);
if (nsnull != mTableInspector) {
delete mTableInspector;
}
if (nsnull != mImageInspector) {
delete mImageInspector;
}
}
NS_IMPL_ADDREF(nsBrowserWindow)
NS_IMPL_RELEASE(nsBrowserWindow)
nsresult
nsBrowserWindow::QueryInterface(const nsIID& aIID,
void** aInstancePtrResult)
{
NS_PRECONDITION(nsnull != aInstancePtrResult, "null pointer");
if (nsnull == aInstancePtrResult) {
return NS_ERROR_NULL_POINTER;
}
*aInstancePtrResult = NULL;
if (aIID.Equals(kIBrowserWindowIID)) {
*aInstancePtrResult = (void*) ((nsIBrowserWindow*)this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(kIDocumentLoaderObserverIID)) {
*aInstancePtrResult = (void*) ((nsIDocumentLoaderObserver*)this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(kIWebShellContainerIID)) {
*aInstancePtrResult = (void*) ((nsIWebShellContainer*)this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(nsIProgressEventSink::GetIID())) {
*aInstancePtrResult = (void*) ((nsIProgressEventSink*)this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(kIPromptIID)) {
*aInstancePtrResult = (void*) ((nsIPrompt*)this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(kISupportsIID)) {
*aInstancePtrResult = (void*) ((nsISupports*)((nsIBrowserWindow*)this));
NS_ADDREF_THIS();
return NS_OK;
}
return NS_NOINTERFACE;
}
nsresult
nsBrowserWindow::Init(nsIAppShell* aAppShell,
nsIPref* aPrefs,
const nsRect& aBounds,
PRUint32 aChromeMask,
PRBool aAllowPlugins)
{
mChromeMask = aChromeMask;
mAppShell = aAppShell;
NS_IF_ADDREF(mAppShell);
mPrefs = aPrefs;
NS_IF_ADDREF(mPrefs);
mAllowPlugins = aAllowPlugins;
// Create top level window
nsresult rv = nsComponentManager::CreateInstance(kWindowCID, nsnull,
kIWidgetIID,
(void**)&mWindow);
if (NS_OK != rv) {
return rv;
}
nsWidgetInitData initData;
initData.mWindowType = eWindowType_toplevel;
initData.mBorderStyle = eBorderStyle_default;
nsRect r(0, 0, aBounds.width, aBounds.height);
mWindow->Create((nsIWidget*)NULL, r, HandleBrowserEvent,
nsnull, aAppShell, nsnull, &initData);
mWindow->GetClientBounds(r);
// Create web shell
rv = nsComponentManager::CreateInstance(kWebShellCID, nsnull,
kIWebShellIID,
(void**)&mWebShell);
if (NS_OK != rv) {
return rv;
}
nsCOMPtr<nsIDocumentLoader> docLoader;
r.x = r.y = 0;
rv = mWebShell->Init(mWindow->GetNativeData(NS_NATIVE_WIDGET),
r.x, r.y, r.width, r.height,
nsScrollPreference_kAuto, aAllowPlugins, PR_TRUE);
mWebShell->SetContainer((nsIWebShellContainer*) this);
mWebShell->GetDocumentLoader(*getter_AddRefs(docLoader));
if (docLoader) {
docLoader->AddObserver(this);
}
mWebShell->SetPrefs(aPrefs);
mWebShell->Show();
if (NS_CHROME_MENU_BAR_ON & aChromeMask) {
rv = CreateMenuBar(r.width);
if (NS_OK != rv) {
return rv;
}
mWindow->GetClientBounds(r);
r.x = r.y = 0;
}
if (NS_CHROME_TOOL_BAR_ON & aChromeMask) {
rv = CreateToolBar(r.width);
if (NS_OK != rv) {
return rv;
}
}
if (NS_CHROME_STATUS_BAR_ON & aChromeMask) {
rv = CreateStatusBar(r.width);
if (NS_OK != rv) {
return rv;
}
}
// Give the embedding app a chance to do platforms-specific window setup
InitNativeWindow();
// Now lay it all out
Layout(r.width, r.height);
return NS_OK;
}
nsresult
nsBrowserWindow::Init(nsIAppShell* aAppShell,
nsIPref* aPrefs,
const nsRect& aBounds,
PRUint32 aChromeMask,
PRBool aAllowPlugins,
nsIDocumentViewer* aDocumentViewer,
nsIPresContext* aPresContext)
{
mChromeMask = aChromeMask;
mAppShell = aAppShell;
NS_IF_ADDREF(mAppShell);
mPrefs = aPrefs;
NS_IF_ADDREF(mPrefs);
mAllowPlugins = aAllowPlugins;
// Create top level window
nsresult rv = nsComponentManager::CreateInstance(kWindowCID, nsnull,
kIWidgetIID,
(void**)&mWindow);
if (NS_OK != rv) {
return rv;
}
nsRect r(0, 0, aBounds.width, aBounds.height);
mWindow->Create((nsIWidget*)NULL, r, HandleBrowserEvent,
nsnull, aAppShell);
mWindow->GetClientBounds(r);
// Create web shell
rv = nsComponentManager::CreateInstance(kWebShellCID, nsnull,
kIWebShellIID,
(void**)&mWebShell);
if (NS_OK != rv) {
return rv;
}
nsCOMPtr<nsIDocumentLoader> docLoader;
r.x = r.y = 0;
//nsRect ws = r;
rv = mWebShell->Init(mWindow->GetNativeData(NS_NATIVE_WIDGET),
r.x, r.y, r.width, r.height,
nsScrollPreference_kAuto, aAllowPlugins);
mWebShell->SetContainer((nsIWebShellContainer*) this);
mWebShell->GetDocumentLoader(*getter_AddRefs(docLoader));
if (docLoader) {
docLoader->AddObserver(this);
}
mWebShell->SetPrefs(aPrefs);
if (NS_CHROME_MENU_BAR_ON & aChromeMask) {
rv = CreateMenuBar(r.width);
if (NS_OK != rv) {
return rv;
}
mWindow->GetClientBounds(r);
r.x = r.y = 0;
}
if (NS_CHROME_TOOL_BAR_ON & aChromeMask) {
rv = CreateToolBar(r.width);
if (NS_OK != rv) {
return rv;
}
}
if (NS_CHROME_STATUS_BAR_ON & aChromeMask) {
rv = CreateStatusBar(r.width);
if (NS_OK != rv) {
return rv;
}
}
// Give the embedding app a chance to do platforms-specific window setup
InitNativeWindow();
// Now lay it all out
Layout(r.width, r.height);
// Create a document viewer and bind it to the webshell
nsIDocumentViewer* docv;
aDocumentViewer->CreateDocumentViewerUsing(aPresContext, docv);
mWebShell->Embed(docv, "duh", nsnull);
mWebShell->Show();
NS_RELEASE(docv);
return NS_OK;
}
void
nsBrowserWindow::SetWebCrawler(nsWebCrawler* aCrawler)
{
if (mWebCrawler) {
if (mWebShell) {
mWebShell->SetDocLoaderObserver(nsnull);
}
NS_RELEASE(mWebCrawler);
}
if (aCrawler) {
mWebCrawler = aCrawler;
/* Nisheeth: the crawler registers as a document loader observer with
* the webshell when nsWebCrawler::Start() is called.
if (mWebShell) {
mWebShell->SetDocLoaderObserver(aCrawler);
}
*/
NS_ADDREF(aCrawler);
}
}
// XXX This sort of thing should be in a resource
#define TOOL_BAR_FONT "Helvetica"
#define TOOL_BAR_FONT_SIZE 12
#define STATUS_BAR_FONT "Helvetica"
#define STATUS_BAR_FONT_SIZE 10
nsresult
nsBrowserWindow::CreateToolBar(PRInt32 aWidth)
{
nsresult rv;
nsIDeviceContext* dc = mWindow->GetDeviceContext();
float t2d;
dc->GetTwipsToDevUnits(t2d);
float d2a;
dc->GetDevUnitsToAppUnits(d2a);
nsFont font(TOOL_BAR_FONT, NS_FONT_STYLE_NORMAL, NS_FONT_VARIANT_NORMAL,
NS_FONT_WEIGHT_NORMAL, 0,
nscoord(NSIntPointsToTwips(TOOL_BAR_FONT_SIZE) * t2d * d2a));
NS_RELEASE(dc);
// Create and place back button
rv = nsComponentManager::CreateInstance(kButtonCID, nsnull, kIButtonIID,
(void**)&mBack);
if (NS_OK != rv) {
return rv;
}
nsRect r(0, 0, BUTTON_WIDTH, BUTTON_HEIGHT);
nsIWidget* widget = nsnull;
NS_CreateButton(mWindow,mBack,r,HandleBackEvent,&font);
if (NS_OK == mBack->QueryInterface(kIWidgetIID,(void**)&widget))
{
nsAutoString back("Back");
mBack->SetLabel(back);
NS_RELEASE(widget);
}
// Create and place forward button
r.SetRect(BUTTON_WIDTH, 0, BUTTON_WIDTH, BUTTON_HEIGHT);
rv = nsComponentManager::CreateInstance(kButtonCID, nsnull, kIButtonIID,
(void**)&mForward);
if (NS_OK != rv) {
return rv;
}
if (NS_OK == mForward->QueryInterface(kIWidgetIID,(void**)&widget))
{
widget->Create(mWindow, r, HandleForwardEvent, NULL);
widget->SetFont(font);
widget->Show(PR_TRUE);
nsAutoString forward("Forward");
mForward->SetLabel(forward);
NS_RELEASE(widget);
}
// Create and place location bar
r.SetRect(2*BUTTON_WIDTH, 0,
aWidth - 2*BUTTON_WIDTH - THROBBER_WIDTH,
BUTTON_HEIGHT);
rv = nsComponentManager::CreateInstance(kTextFieldCID, nsnull, kITextWidgetIID,
(void**)&mLocation);
if (NS_OK != rv) {
return rv;
}
NS_CreateTextWidget(mWindow,mLocation,r,HandleLocationEvent,&font);
if (NS_OK == mLocation->QueryInterface(kIWidgetIID,(void**)&widget))
{
widget->SetForegroundColor(NS_RGB(0, 0, 0));
widget->SetBackgroundColor(NS_RGB(255, 255, 255));
PRUint32 size;
nsAutoString empty;
mLocation->SetText(empty, size);
NS_RELEASE(widget);
}
// Create and place throbber
r.SetRect(aWidth - THROBBER_WIDTH, 0,
THROBBER_WIDTH, THROBBER_HEIGHT);
mThrobber = nsThrobber::NewThrobber();
nsString throbberURL(THROBBER_AT);
mThrobber->Init(mWindow, r, throbberURL, THROB_NUM);
mThrobber->Show();
return NS_OK;
}
// Overload this method in your nsNativeBrowserWindow if you need to
// have the logic in nsBrowserWindow::Layout() offset the menu within
// the parent window.
nsresult
nsBrowserWindow::GetMenuBarHeight(PRInt32 * aHeightOut)
{
NS_ASSERTION(nsnull != aHeightOut,"null out param.");
*aHeightOut = 0;
return NS_OK;
}
nsresult
nsBrowserWindow::CreateStatusBar(PRInt32 aWidth)
{
nsresult rv;
nsIDeviceContext* dc = mWindow->GetDeviceContext();
float t2d;
dc->GetTwipsToDevUnits(t2d);
nsFont font(STATUS_BAR_FONT, NS_FONT_STYLE_NORMAL, NS_FONT_VARIANT_NORMAL,
NS_FONT_WEIGHT_NORMAL, 0,
nscoord(t2d * NSIntPointsToTwips(STATUS_BAR_FONT_SIZE)));
NS_RELEASE(dc);
nsRect r(0, 0, aWidth, THROBBER_HEIGHT);
rv = nsComponentManager::CreateInstance(kTextFieldCID, nsnull, kITextWidgetIID,
(void**)&mStatus);
if (NS_OK != rv) {
return rv;
}
nsIWidget* widget = nsnull;
NS_CreateTextWidget(mWindow,mStatus,r,HandleLocationEvent,&font);
if (NS_OK == mStatus->QueryInterface(kIWidgetIID,(void**)&widget))
{
widget->SetForegroundColor(NS_RGB(0, 0, 0));
PRUint32 size;
mStatus->SetText("",size);
nsITextWidget* textWidget = nsnull;
if (NS_OK == mStatus->QueryInterface(kITextWidgetIID,(void**)&textWidget))
{
PRBool wasReadOnly;
textWidget->SetReadOnly(PR_TRUE, wasReadOnly);
NS_RELEASE(textWidget);
}
NS_RELEASE(widget);
}
return NS_OK;
}
void
nsBrowserWindow::Layout(PRInt32 aWidth, PRInt32 aHeight)
{
nscoord txtHeight;
nscoord menuBarHeight;
nsILookAndFeel * lookAndFeel;
if (NS_OK == nsComponentManager::CreateInstance(kLookAndFeelCID, nsnull, kILookAndFeelIID, (void**)&lookAndFeel)) {
lookAndFeel->GetMetric(nsILookAndFeel::eMetric_TextFieldHeight, txtHeight);
NS_RELEASE(lookAndFeel);
} else {
txtHeight = 24;
}
// Find out the menubar height
GetMenuBarHeight(&menuBarHeight);
nsRect rr(0, 0, aWidth, aHeight);
// position location bar (it's stretchy)
if (NS_CHROME_TOOL_BAR_ON & mChromeMask) {
nsIWidget* locationWidget = nsnull;
if (mLocation &&
NS_SUCCEEDED(mLocation->QueryInterface(kIWidgetIID,
(void**)&locationWidget))) {
if (mThrobber) {
PRInt32 width = PR_MAX(aWidth - (2*BUTTON_WIDTH + THROBBER_WIDTH), 0);
locationWidget->Resize(2*BUTTON_WIDTH, menuBarHeight,
width,
BUTTON_HEIGHT,
PR_TRUE);
mThrobber->MoveTo(aWidth - THROBBER_WIDTH, menuBarHeight);
}
else {
PRInt32 width = PR_MAX(aWidth - 2*BUTTON_WIDTH, 0);
locationWidget->Resize(2*BUTTON_WIDTH, menuBarHeight,
width,
BUTTON_HEIGHT,
PR_TRUE);
}
locationWidget->Show(PR_TRUE);
NS_RELEASE(locationWidget);
nsIWidget* w = nsnull;
if (mBack &&
NS_SUCCEEDED(mBack->QueryInterface(kIWidgetIID, (void**)&w))) {
w->Move(0, menuBarHeight);
w->Show(PR_TRUE);
NS_RELEASE(w);
}
if (mForward &&
NS_SUCCEEDED(mForward->QueryInterface(kIWidgetIID, (void**)&w))) {
w->Move(BUTTON_WIDTH, menuBarHeight);
w->Show(PR_TRUE);
NS_RELEASE(w);
}
}
}
else {
nsIWidget* w = nsnull;
if (mLocation &&
NS_SUCCEEDED(mLocation->QueryInterface(kIWidgetIID, (void**)&w))) {
w->Show(PR_FALSE);
NS_RELEASE(w);
}
if (mBack &&
NS_SUCCEEDED(mBack->QueryInterface(kIWidgetIID, (void**)&w))) {
w->Move(0, menuBarHeight);
w->Show(PR_FALSE);
NS_RELEASE(w);
}
if (mForward &&
NS_SUCCEEDED(mForward->QueryInterface(kIWidgetIID, (void**)&w))) {
w->Move(BUTTON_WIDTH, menuBarHeight);
w->Show(PR_FALSE);
NS_RELEASE(w);
}
if (mThrobber) {
mThrobber->Hide();
}
}
nsIWidget* statusWidget = nsnull;
if (mStatus && NS_OK == mStatus->QueryInterface(kIWidgetIID,(void**)&statusWidget)) {
if (mChromeMask & NS_CHROME_STATUS_BAR_ON) {
statusWidget->Resize(0, aHeight - txtHeight,
aWidth, txtHeight,
PR_TRUE);
//Since allowing a negative height is a bad idea, let's condition this...
rr.height = PR_MAX(0,rr.height-txtHeight);
statusWidget->Show(PR_TRUE);
}
else {
statusWidget->Show(PR_FALSE);
}
NS_RELEASE(statusWidget);
}
// inset the web widget
if (NS_CHROME_TOOL_BAR_ON & mChromeMask) {
rr.height -= BUTTON_HEIGHT;
rr.y += BUTTON_HEIGHT;
}
rr.x += WEBSHELL_LEFT_INSET;
rr.y += WEBSHELL_TOP_INSET + menuBarHeight;
rr.width -= WEBSHELL_LEFT_INSET + WEBSHELL_RIGHT_INSET;
rr.height -= WEBSHELL_TOP_INSET + WEBSHELL_BOTTOM_INSET + menuBarHeight;
//Since allowing a negative height is a bad idea, let's condition this...
if(rr.height<0)
rr.height=0;
if (mWebShell) {
mWebShell->SetBounds(rr.x, rr.y, rr.width, rr.height);
}
}
NS_IMETHODIMP
nsBrowserWindow::MoveTo(PRInt32 aX, PRInt32 aY)
{
NS_PRECONDITION(nsnull != mWindow, "null window");
mWindow->Move(aX, aY);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::SizeContentTo(PRInt32 aWidth, PRInt32 aHeight)
{
NS_PRECONDITION(nsnull != mWindow, "null window");
// XXX We want to do this in one shot
mWindow->Resize(aWidth, aHeight, PR_FALSE);
Layout(aWidth, aHeight);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::SizeWindowTo(PRInt32 aWidth, PRInt32 aHeight)
{
return SizeContentTo(aWidth, aHeight);
}
NS_IMETHODIMP
nsBrowserWindow::GetContentBounds(nsRect& aBounds)
{
mWindow->GetClientBounds(aBounds);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::GetWindowBounds(nsRect& aBounds)
{
mWindow->GetBounds(aBounds);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::Show()
{
NS_PRECONDITION(nsnull != mWindow, "null window");
mWindow->Show(PR_TRUE);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::Hide()
{
NS_PRECONDITION(nsnull != mWindow, "null window");
mWindow->Show(PR_FALSE);
return NS_OK;
}
static void DestroyWidget(nsISupports* aWidget)
{
if (aWidget) {
nsIWidget* w;
nsresult rv = aWidget->QueryInterface(kIWidgetIID, (void**) &w);
if (NS_SUCCEEDED(rv)) {
w->Destroy();
NS_RELEASE(w);
}
NS_RELEASE(aWidget);
}
}
NS_IMETHODIMP
nsBrowserWindow::Close()
{
RemoveBrowser(this);
if (nsnull != mWebShell) {
nsCOMPtr<nsIDocumentLoader> docLoader;
mWebShell->GetDocumentLoader(*getter_AddRefs(docLoader));
if (docLoader) {
docLoader->RemoveObserver(this);
}
mWebShell->Destroy();
NS_RELEASE(mWebShell);
}
DestroyWidget(mBack); mBack = nsnull;
DestroyWidget(mForward); mForward = nsnull;
DestroyWidget(mLocation); mLocation = nsnull;
DestroyWidget(mStatus); mStatus = nsnull;
if (mThrobber) {
mThrobber->Destroy();
NS_RELEASE(mThrobber);
mThrobber = nsnull;
}
DestroyWidget(mWindow); mWindow = nsnull;
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::ShowModally(PRBool aPrepare)
{
// unsupported by viewer
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsBrowserWindow::SetChrome(PRUint32 aChromeMask)
{
mChromeMask = aChromeMask;
nsRect r;
mWindow->GetClientBounds(r);
Layout(r.width, r.height);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::GetChrome(PRUint32& aChromeMaskResult)
{
aChromeMaskResult = mChromeMask;
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::GetWebShell(nsIWebShell*& aResult)
{
aResult = mWebShell;
NS_IF_ADDREF(mWebShell);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::GetContentWebShell(nsIWebShell **aResult)
{
*aResult = mWebShell;
NS_IF_ADDREF(mWebShell);
return NS_OK;
}
//----------------------------------------
NS_IMETHODIMP
nsBrowserWindow::IsIntrinsicallySized(PRBool& aResult)
{
aResult = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::SetTitle(const PRUnichar* aTitle)
{
NS_PRECONDITION(nsnull != mWindow, "null window");
mTitle = aTitle;
nsAutoString newTitle(aTitle);
//newTitle.Append(" - Raptor");
newTitle.Append(*gTitleSuffix);
mWindow->SetTitle(newTitle);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::GetTitle(const PRUnichar** aResult)
{
*aResult = mTitle.GetUnicode();
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::SetStatus(const PRUnichar* aStatus)
{
if (nsnull != mStatus) {
PRUint32 size;
mStatus->SetText(aStatus,size);
}
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::GetStatus(const PRUnichar** aResult)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::SetDefaultStatus(const PRUnichar* aStatus)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::GetDefaultStatus(const PRUnichar** aResult)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::SetProgress(PRInt32 aProgress, PRInt32 aProgressMax)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::ShowMenuBar(PRBool aShow)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::WillLoadURL(nsIWebShell* aShell, const PRUnichar* aURL,
nsLoadType aReason)
{
if (aShell == mWebShell) {
if (mStatus) {
nsAutoString url("Connecting to ");
url.Append(aURL);
PRUint32 size;
mStatus->SetText(url,size);
mLoadStartTime = PR_Now();
}
}
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::BeginLoadURL(nsIWebShell* aShell, const PRUnichar* aURL)
{
if (aShell == mWebShell) {
if (mThrobber) {
mThrobber->Start();
PRUint32 size;
nsAutoString tmp(aURL);
mLocation->SetText(tmp,size);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::ProgressLoadURL(nsIWebShell* aShell,
const PRUnichar* aURL,
PRInt32 aProgress,
PRInt32 aProgressMax)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::EndLoadURL(nsIWebShell* aShell,
const PRUnichar* aURL,
nsresult aStatus)
{
if (aShell == mWebShell) {
PRTime endLoadTime = PR_Now();
if (mShowLoadTimes) {
nsAutoString msg(aURL);
printf("Loading ");
fputs(msg, stdout);
PRTime delta;
LL_SUB(delta, endLoadTime, mLoadStartTime);
double usecs;
LL_L2D(usecs, delta);
printf(" took %g milliseconds\n", usecs / 1000.0);
}
if (mThrobber) {
mThrobber->Stop();
}
if (nsnull != mStatus) {
nsAutoString msg(aURL);
PRUint32 size;
msg.Append(" done.");
mStatus->SetText(msg, size);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::NewWebShell(PRUint32 aChromeMask,
PRBool aVisible,
nsIWebShell*& aNewWebShell)
{
nsresult rv = NS_OK;
// Create new window. By default, the refcnt will be 1 because of
// the registration of the browser window in gBrowsers.
nsNativeBrowserWindow* browser;
NS_NEWXPCOM(browser, nsNativeBrowserWindow);
if (nsnull != browser)
{
nsRect bounds;
GetContentBounds(bounds);
browser->SetApp(mApp);
// Assume no controls for now
rv = browser->Init(mAppShell, mPrefs, bounds, aChromeMask, mAllowPlugins);
if (NS_OK == rv)
{
// Default is to startup hidden
if (aVisible) {
browser->Show();
}
nsIWebShell *shell;
rv = browser->GetWebShell(shell);
aNewWebShell = shell;
}
else
{
browser->Close();
}
}
else
rv = NS_ERROR_OUT_OF_MEMORY;
return rv;
}
NS_IMETHODIMP
nsBrowserWindow::ContentShellAdded(nsIWebShell* aChildShell, nsIContent* frameNode)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::CreatePopup(nsIDOMElement* aElement, nsIDOMElement* aPopupContent,
PRInt32 aXPos, PRInt32 aYPos,
const nsString& aPopupType, const nsString& anAnchorAlignment,
const nsString& aPopupAlignment,
nsIDOMWindow* aWindow, nsIDOMWindow** outPopup)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::FindWebShellWithName(const PRUnichar* aName, nsIWebShell*& aResult)
{
PRInt32 i, n = gBrowsers.Count();
aResult = nsnull;
nsString aNameStr(aName);
for (i = 0; i < n; i++) {
nsBrowserWindow* bw = (nsBrowserWindow*) gBrowsers.ElementAt(i);
nsCOMPtr<nsIWebShell> ws;
if (NS_OK == bw->GetWebShell(*getter_AddRefs(ws))) {
const PRUnichar *name;
if (NS_OK == ws->GetName(&name)) {
if (aNameStr.Equals(name)) {
aResult = ws;
NS_ADDREF(aResult);
return NS_OK;
}
}
if (NS_OK == ws->FindChildWithName(aName, aResult)) {
if (nsnull != aResult) {
return NS_OK;
}
}
}
}
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::FocusAvailable(nsIWebShell* aFocusedWebShell, PRBool& aFocusTaken)
{
return NS_OK;
}
//----------------------------------------
// document loader observer implementation
NS_IMETHODIMP
nsBrowserWindow::OnStartDocumentLoad(nsIDocumentLoader* loader,
nsIURI* aURL,
const char* aCommand)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::OnEndDocumentLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsresult aStatus,
nsIDocumentLoaderObserver * aObserver)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::OnStartURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsIContentViewer* aViewer)
{
nsresult rv;
nsCOMPtr<nsIURI> aURL;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
if (mStatus) {
nsAutoString url;
if (nsnull != aURL) {
char* str;
aURL->GetSpec(&str);
url = str;
nsCRT::free(str);
}
url.Append(": start");
PRUint32 size;
mStatus->SetText(url,size);
}
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::OnProgressURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
PRUint32 aProgress,
PRUint32 aProgressMax)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::OnStatusURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsString& aMsg)
{
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::OnEndURLLoad(nsIDocumentLoader* loader,
nsIChannel* channel,
nsresult aStatus)
{
nsresult rv;
nsCOMPtr<nsIURI> aURL;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
if (mStatus) {
nsAutoString url;
if (nsnull != aURL) {
char* str;
aURL->GetSpec(&str);
url = str;
nsCRT::free(str);
}
url.Append(": stop");
PRUint32 size;
mStatus->SetText(url,size);
}
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::HandleUnknownContentType(nsIDocumentLoader* loader,
nsIChannel* channel,
const char *aContentType,
const char *aCommand)
{
return NS_OK;
}
NS_IMETHODIMP
#ifdef NECKO
nsBrowserWindow::OnProgress(nsIChannel* channel, nsISupports *ctxt,
PRUint32 aProgress, PRUint32 aProgressMax)
#else
nsBrowserWindow::OnProgress(nsIURI* aURL,
PRUint32 aProgress,
PRUint32 aProgressMax)
#endif
{
nsresult rv;
#ifdef NECKO
nsCOMPtr<nsIURI> aURL;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
#endif
if (mStatus) {
nsAutoString url;
if (nsnull != aURL) {
#ifdef NECKO
char* str;
aURL->GetSpec(&str);
#else
PRUnichar* str;
aURL->ToString(&str);
#endif
url = str;
#ifdef NECKO
nsCRT::free(str);
#else
delete[] str;
#endif
}
url.Append(": progress ");
url.Append(aProgress, 10);
if (0 != aProgressMax) {
url.Append(" (out of ");
url.Append(aProgressMax, 10);
url.Append(")");
}
PRUint32 size;
mStatus->SetText(url,size);
}
return NS_OK;
}
NS_IMETHODIMP
#ifdef NECKO
nsBrowserWindow::OnStatus(nsIChannel* channel, nsISupports *ctxt, const PRUnichar *aMsg)
#else
nsBrowserWindow::OnStatus(nsIURI* aURL, const PRUnichar* aMsg)
#endif
{
if (mStatus) {
PRUint32 size;
mStatus->SetText(aMsg,size);
}
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::Alert(const PRUnichar *text)
{
nsCAutoString str(text);
printf("%cBrowser Window Alert: %s\n", '\007', str.GetBuffer());
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::Confirm(const PRUnichar *text,
PRBool *result)
{
nsCAutoString str(text);
const char* msg= nsnull;
msg = str.GetBuffer();
if (nsnull != msg) {
printf("Browser Window Confirm: %s (y/n)? ", msg);
char c;
for (;;) {
c = getchar();
if (tolower(c) == 'y') {
*result = PR_TRUE;
}
if (tolower(c) == 'n') {
*result = PR_FALSE;
}
}
}
*result = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::ConfirmYN(const PRUnichar *text,
PRBool *result)
{
return Confirm(text, result);
}
NS_IMETHODIMP
nsBrowserWindow::ConfirmCheck(const PRUnichar *text,
const PRUnichar *checkMsg,
PRBool *checkValue,
PRBool *result)
{
return Confirm(text, result);
}
NS_IMETHODIMP
nsBrowserWindow::ConfirmCheckYN(const PRUnichar *text,
const PRUnichar *checkMsg,
PRBool *checkValue,
PRBool *result)
{
return Confirm(text, result);
}
NS_IMETHODIMP
nsBrowserWindow::Prompt(const PRUnichar *text,
const PRUnichar *defaultText,
PRUnichar **result,
PRBool *_retval)
{
nsCAutoString str(text);
const char* msg= nsnull;
char buf[256];
msg = str.GetBuffer();
if (nsnull != msg) {
printf("Browser Window: %s\n", msg);
printf("%cPrompt: ", '\007');
scanf("%s", buf);
nsAutoString response(buf);
*result = response.ToNewUnicode();
}
*_retval = (nsCRT::strlen(buf) > 0);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::PromptUsernameAndPassword(const PRUnichar *text,
PRUnichar **user,
PRUnichar **pwd,
PRBool *_retval)
{
nsCAutoString str(text);
const char* msg = nsnull;
char buf[256];
msg = str.GetBuffer();
if (nsnull != msg) {
nsAutoString response;
printf("Browser Window: %s\n", msg);
printf("%cUser: ", '\007');
scanf("%s", buf);
response.SetString(buf);
*user = response.ToNewUnicode();
printf("%cPassword: ", '\007');
scanf("%s", buf);
response.SetString(buf);
*pwd = response.ToNewUnicode();
}
*_retval = (nsCRT::strlen(*user) > 0);
return NS_OK;
}
NS_IMETHODIMP
nsBrowserWindow::PromptPassword(const PRUnichar *text,
PRUnichar **pwd,
PRBool *_retval)
{
nsCAutoString str(text);
const char* msg = nsnull;
char buf[256];
msg = str.GetBuffer();
if (nsnull != msg) {
printf("Browser Window: %s\n", msg);
printf("%cPassword: ", '\007');
scanf("%s", buf);
nsAutoString response(buf);
*pwd = response.ToNewUnicode();
}
*_retval = (nsCRT::strlen(*pwd) > 0);
return NS_OK;
}
//----------------------------------------
// Toolbar support
void
nsBrowserWindow::StartThrobber()
{
}
void
nsBrowserWindow::StopThrobber()
{
}
void
nsBrowserWindow::LoadThrobberImages()
{
}
void
nsBrowserWindow::DestroyThrobberImages()
{
}
nsIPresShell*
nsBrowserWindow::GetPresShell()
{
return GetPresShellFor(mWebShell);
}
void
nsBrowserWindow::DoCopy()
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
shell->DoCopy();
NS_RELEASE(shell);
}
}
void
nsBrowserWindow::DoPaste()
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
printf("nsBrowserWindow::DoPaste()\n");
NS_RELEASE(shell);
}
}
//----------------------------------------------------------------------
void
nsBrowserWindow::ShowPrintPreview(PRInt32 aID)
{
static NS_DEFINE_CID(kPrintPreviewContextCID, NS_PRINT_PREVIEW_CONTEXT_CID);
static NS_DEFINE_IID(kIPresContextIID, NS_IPRESCONTEXT_IID);
nsIContentViewer* cv = nsnull;
if (nsnull != mWebShell) {
if ((NS_OK == mWebShell->GetContentViewer(&cv)) && (nsnull != cv)) {
nsIDocumentViewer* docv = nsnull;
if (NS_OK == cv->QueryInterface(kIDocumentViewerIID, (void**)&docv)) {
nsIPresContext* printContext;
nsresult rv =
nsComponentManager::CreateInstance(kPrintPreviewContextCID,
nsnull,
kIPresContextIID,
(void **)&printContext);
if (NS_SUCCEEDED(rv)) {
// Prepare new printContext for print-preview
nsCOMPtr<nsIDeviceContext> dc;
nsIPresContext* presContext;
docv->GetPresContext(presContext);
presContext->GetDeviceContext(getter_AddRefs(dc));
printContext->Init(dc, mPrefs);
NS_RELEASE(presContext);
// Make a window using that content viewer
// XXX Some piece of code needs to properly hold the reference to this
// browser window. For the time being the reference is released by the
// browser event handling code during processing of the NS_DESTROY event...
nsBrowserWindow* bw = new nsNativeBrowserWindow;
bw->SetApp(mApp);
bw->Init(mAppShell, mPrefs, nsRect(0, 0, 600, 400),
NS_CHROME_MENU_BAR_ON, PR_TRUE, docv, printContext);
bw->Show();
NS_RELEASE(printContext);
}
NS_RELEASE(docv);
}
NS_RELEASE(cv);
}
}
}
void nsBrowserWindow::DoPrint(void)
{
nsCOMPtr <nsIContentViewer> viewer;
mWebShell->GetContentViewer(getter_AddRefs(viewer));
if (viewer)
{
viewer->Print();
}
}
//---------------------------------------------------------------
void nsBrowserWindow::DoPrintSetup()
{
if (mXPDialog) {
NS_RELEASE(mXPDialog);
//mXPDialog->SetVisible(PR_TRUE);
//return;
}
nsString printHTML("resource:/res/samples/printsetup.html");
nsRect rect(0, 0, 375, 510);
nsString title("Print Setup");
nsXPBaseWindow * dialog = nsnull;
nsresult rv = nsComponentManager::CreateInstance(kXPBaseWindowCID, nsnull,
kIXPBaseWindowIID,
(void**) &dialog);
if (rv == NS_OK) {
dialog->Init(eXPBaseWindowType_dialog, mAppShell, nsnull, printHTML,
title, rect, PRUint32(~0), PR_FALSE);
dialog->SetVisible(PR_TRUE);
if (NS_OK == dialog->QueryInterface(kIXPBaseWindowIID, (void**)&mXPDialog)) {
}
}
mPrintSetupInfo.mPortrait = PR_TRUE;
mPrintSetupInfo.mBevelLines = PR_TRUE;
mPrintSetupInfo.mBlackText = PR_FALSE;
mPrintSetupInfo.mBlackLines = PR_FALSE;
mPrintSetupInfo.mLastPageFirst = PR_FALSE;
mPrintSetupInfo.mPrintBackgrounds = PR_FALSE;
mPrintSetupInfo.mTopMargin = 0.50;
mPrintSetupInfo.mBottomMargin = 0.50;
mPrintSetupInfo.mLeftMargin = 0.50;
mPrintSetupInfo.mRightMargin = 0.50;
mPrintSetupInfo.mDocTitle = PR_TRUE;
mPrintSetupInfo.mDocLocation = PR_TRUE;
mPrintSetupInfo.mHeaderText = "Header Text";
mPrintSetupInfo.mFooterText = "Footer Text";
mPrintSetupInfo.mPageNum = PR_TRUE;
mPrintSetupInfo.mPageTotal = PR_TRUE;
mPrintSetupInfo.mDatePrinted = PR_TRUE;
nsPrintSetupDialog * printSetupDialog = new nsPrintSetupDialog(this);
if (nsnull != printSetupDialog) {
dialog->AddWindowListener(printSetupDialog);
}
printSetupDialog->SetSetupInfo(mPrintSetupInfo);
//NS_IF_RELEASE(dialog);
}
//---------------------------------------------------------------
nsIDOMDocument* nsBrowserWindow::GetDOMDocument(nsIWebShell *aWebShell)
{
nsIDOMDocument* domDoc = nsnull;
if (nsnull != aWebShell) {
nsIContentViewer* mCViewer;
aWebShell->GetContentViewer(&mCViewer);
if (nsnull != mCViewer) {
nsIDocumentViewer* mDViewer;
if (NS_OK == mCViewer->QueryInterface(kIDocumentViewerIID, (void**) &mDViewer)) {
nsIDocument* mDoc;
mDViewer->GetDocument(mDoc);
if (nsnull != mDoc) {
if (NS_OK == mDoc->QueryInterface(kIDOMDocumentIID, (void**) &domDoc)) {
}
NS_RELEASE(mDoc);
}
NS_RELEASE(mDViewer);
}
NS_RELEASE(mCViewer);
}
}
return domDoc;
}
//---------------------------------------------------------------
void nsBrowserWindow::DoTableInspector()
{
if (mTableInspectorDialog) {
mTableInspectorDialog->SetVisible(PR_TRUE);
return;
}
nsIDOMDocument* domDoc = GetDOMDocument(mWebShell);
if (nsnull != domDoc) {
nsString printHTML("resource:/res/samples/printsetup.html");
nsRect rect(0, 0, 375, 510);
nsString title("Table Inspector");
nsXPBaseWindow * xpWin = nsnull;
nsresult rv = nsComponentManager::CreateInstance(kXPBaseWindowCID, nsnull,
kIXPBaseWindowIID,
(void**) &xpWin);
if (rv == NS_OK) {
xpWin->Init(eXPBaseWindowType_dialog, mAppShell, nsnull, printHTML, title, rect, PRUint32(~0), PR_FALSE);
xpWin->SetVisible(PR_TRUE);
if (NS_OK == xpWin->QueryInterface(kIXPBaseWindowIID, (void**) &mTableInspectorDialog)) {
mTableInspector = new nsTableInspectorDialog(this, domDoc); // ref counts domDoc
if (nsnull != mTableInspector) {
xpWin->AddWindowListener(mTableInspector);
}
}
NS_RELEASE(xpWin);
}
NS_RELEASE(domDoc);
}
}
void nsBrowserWindow::DoImageInspector()
{
if (mImageInspectorDialog) {
mImageInspectorDialog->SetVisible(PR_TRUE);
return;
}
nsIDOMDocument* domDoc = GetDOMDocument(mWebShell);
if (nsnull != domDoc) {
nsString printHTML("resource:/res/samples/image_props.html");
nsRect rect(0, 0, 485, 124);
nsString title("Image Inspector");
nsXPBaseWindow * xpWin = nsnull;
nsresult rv = nsComponentManager::CreateInstance(kXPBaseWindowCID, nsnull, kIXPBaseWindowIID, (void**) &xpWin);
if (rv == NS_OK) {
xpWin->Init(eXPBaseWindowType_dialog, mAppShell, nsnull, printHTML, title, rect, PRUint32(~0), PR_FALSE);
xpWin->SetVisible(PR_TRUE);
if (NS_OK == xpWin->QueryInterface(kIXPBaseWindowIID, (void**) &mImageInspectorDialog)) {
mImageInspector = new nsImageInspectorDialog(this, domDoc); // ref counts domDoc
if (nsnull != mImageInspector) {
xpWin->AddWindowListener(mImageInspector);
}
}
NS_RELEASE(xpWin);
}
NS_RELEASE(domDoc);
}
}
//----------------------------------------------------------------------
void
nsBrowserWindow::DoJSConsole()
{
mApp->CreateJSConsole(this);
}
void
nsBrowserWindow::DoPrefs()
{
mApp->DoPrefs(this);
}
void
nsBrowserWindow::DoEditorMode(nsIWebShell *aWebShell)
{
PRInt32 i, n;
if (nsnull != aWebShell) {
nsIContentViewer* mCViewer;
aWebShell->GetContentViewer(&mCViewer);
if (nsnull != mCViewer) {
nsIDocumentViewer* mDViewer;
if (NS_OK == mCViewer->QueryInterface(kIDocumentViewerIID, (void**) &mDViewer))
{
nsIDocument* mDoc;
mDViewer->GetDocument(mDoc);
if (nsnull != mDoc) {
nsIDOMDocument* mDOMDoc;
if (NS_OK == mDoc->QueryInterface(kIDOMDocumentIID, (void**) &mDOMDoc))
{
nsIPresShell* shell = GetPresShellFor(aWebShell);
NS_InitEditorMode(mDOMDoc, shell);
NS_RELEASE(mDOMDoc);
NS_IF_RELEASE(shell);
}
NS_RELEASE(mDoc);
}
NS_RELEASE(mDViewer);
}
NS_RELEASE(mCViewer);
}
aWebShell->GetChildCount(n);
for (i = 0; i < n; i++) {
nsIWebShell* mChild;
aWebShell->ChildAt(i, mChild);
DoEditorMode(mChild);
NS_RELEASE(mChild);
}
}
}
// Same as above, but calls NS_DoEditorTest instead of starting an editor
void
nsBrowserWindow::DoEditorTest(nsIWebShell *aWebShell, PRInt32 aCommandID)
{
if (nsnull != aWebShell) {
nsIContentViewer* mCViewer;
aWebShell->GetContentViewer(&mCViewer);
if (nsnull != mCViewer) {
nsIDocumentViewer* mDViewer;
if (NS_OK == mCViewer->QueryInterface(kIDocumentViewerIID, (void**) &mDViewer))
{
nsIDocument* mDoc;
mDViewer->GetDocument(mDoc);
if (nsnull != mDoc) {
nsIDOMDocument* mDOMDoc;
if (NS_OK == mDoc->QueryInterface(kIDOMDocumentIID, (void**) &mDOMDoc))
{
NS_DoEditorTest(aCommandID);
NS_RELEASE(mDOMDoc);
}
NS_RELEASE(mDoc);
}
NS_RELEASE(mDViewer);
}
NS_RELEASE(mCViewer);
}
// Do we need to do all the children as in DoEditorMode?
// Its seems to work if we don't do that
}
}
#ifdef NS_DEBUG
#include "nsIContent.h"
#include "nsIFrame.h"
#include "nsIStyleContext.h"
#include "nsIStyleSet.h"
static void DumpAWebShell(nsIWebShell* aShell, FILE* out, PRInt32 aIndent)
{
const PRUnichar *name;
nsAutoString str;
nsIWebShell* parent;
PRInt32 i, n;
for (i = aIndent; --i >= 0; ) fprintf(out, " ");
fprintf(out, "%p '", aShell);
aShell->GetName(&name);
aShell->GetParent(parent);
str = name;
fputs(str, out);
fprintf(out, "' parent=%p <\n", parent);
NS_IF_RELEASE(parent);
aIndent++;
aShell->GetChildCount(n);
for (i = 0; i < n; i++) {
nsIWebShell* child;
aShell->ChildAt(i, child);
if (nsnull != child) {
DumpAWebShell(child, out, aIndent);
}
}
aIndent--;
for (i = aIndent; --i >= 0; ) fprintf(out, " ");
fputs(">\n", out);
}
void
nsBrowserWindow::DumpWebShells(FILE* out)
{
DumpAWebShell(mWebShell, out, 0);
}
static
void
DumpMultipleWebShells(nsBrowserWindow& aBrowserWindow, nsIWebShell* aWebShell, FILE* aOut)
{
PRInt32 count;
if (aWebShell) {
aWebShell->GetChildCount(count);
if (count > 0) {
fprintf(aOut, "webshells= \n");
aBrowserWindow.DumpWebShells(aOut);
}
}
}
static
void
DumpContentRecurse(nsIWebShell* aWebShell, FILE* out)
{
if (nsnull != aWebShell) {
fprintf(out, "webshell=%p \n", aWebShell);
nsIPresShell* shell = GetPresShellFor(aWebShell);
if (nsnull != shell) {
nsCOMPtr<nsIDocument> doc;
shell->GetDocument(getter_AddRefs(doc));
if (doc) {
nsIContent* root = doc->GetRootContent();
if (nsnull != root) {
root->List(out);
NS_RELEASE(root);
}
}
NS_RELEASE(shell);
}
else {
fputs("null pres shell\n", out);
}
// dump the frames of the sub documents
PRInt32 i, n;
aWebShell->GetChildCount(n);
for (i = 0; i < n; i++) {
nsIWebShell* child;
aWebShell->ChildAt(i, child);
if (nsnull != child) {
DumpContentRecurse(child, out);
}
}
}
}
void
nsBrowserWindow::DumpContent(FILE* out)
{
DumpContentRecurse(mWebShell, out);
DumpMultipleWebShells(*this, mWebShell, out);
}
static void
DumpFramesRecurse(nsIWebShell* aWebShell, FILE* out, nsString *aFilterName)
{
if (nsnull != aWebShell) {
fprintf(out, "webshell=%p \n", aWebShell);
nsIPresShell* shell = GetPresShellFor(aWebShell);
if (nsnull != shell) {
nsIFrame* root;
shell->GetRootFrame(&root);
if (nsnull != root) {
root->List(out, 0);
}
NS_RELEASE(shell);
}
else {
fputs("null pres shell\n", out);
}
// dump the frames of the sub documents
PRInt32 i, n;
aWebShell->GetChildCount(n);
for (i = 0; i < n; i++) {
nsIWebShell* child;
aWebShell->ChildAt(i, child);
if (nsnull != child) {
DumpFramesRecurse(child, out, aFilterName);
}
}
}
}
void
nsBrowserWindow::DumpFrames(FILE* out, nsString *aFilterName)
{
DumpFramesRecurse(mWebShell, out, aFilterName);
DumpMultipleWebShells(*this, mWebShell, out);
}
//----------------------------------------------------------------------
#include "nsISizeOfHandler.h"
static void
GatherFrameDataSizes(nsISizeOfHandler* aHandler, nsIFrame* aFrame)
{
if (aFrame) {
// Add in the frame
nsCOMPtr<nsIAtom> frameType;
aFrame->GetFrameType(getter_AddRefs(frameType));
PRUint32 frameDataSize;
aFrame->SizeOf(aHandler, &frameDataSize);
aHandler->AddSize(frameType, frameDataSize);
// And all of its children
PRInt32 listIndex = 0;
nsIAtom* listName = nsnull;
do {
nsIFrame* kid;
aFrame->FirstChild(listName, &kid);
while (kid) {
GatherFrameDataSizes(aHandler, kid);
kid->GetNextSibling(&kid);
}
NS_IF_RELEASE(listName);
aFrame->GetAdditionalChildListName(listIndex, &listName);
listIndex++;
} while (nsnull != listName);
}
}
static void
GatherFrameDataSizes(nsISizeOfHandler* aHandler, nsIWebShell* aWebShell)
{
if (nsnull != aWebShell) {
nsIPresShell* shell = GetPresShellFor(aWebShell);
if (nsnull != shell) {
nsIFrame* root;
shell->GetRootFrame(&root);
if (nsnull != root) {
GatherFrameDataSizes(aHandler, root);
}
NS_RELEASE(shell);
}
// dump the frames of the sub documents
PRInt32 i, n;
aWebShell->GetChildCount(n);
for (i = 0; i < n; i++) {
nsIWebShell* child;
aWebShell->ChildAt(i, child);
if (nsnull != child) {
GatherFrameDataSizes(aHandler, child);
}
}
}
}
static void
DumpSizeData(nsISizeOfHandler* aHandler,
nsIAtom* aKey,
PRUint32 aCount,
PRUint32 aTotalSize,
PRUint32 aMinSize,
PRUint32 aMaxSize,
void* arg)
{
if (aKey) {
FILE* out = (FILE*) arg;
nsAutoString type;
aKey->ToString(type);
char cbuf[20];
type.ToCString(cbuf, sizeof(cbuf));
fprintf(out, "%-20s %5d %9d %7d %7d %7d\n",
cbuf, aCount, aTotalSize, aMinSize, aMaxSize,
aCount ? aTotalSize / aCount : 0);
}
}
void
nsBrowserWindow::ShowFrameSize(FILE* out)
{
nsCOMPtr<nsISizeOfHandler> handler;
nsresult rv = NS_NewSizeOfHandler(getter_AddRefs(handler));
if (NS_SUCCEEDED(rv) && handler) {
GatherFrameDataSizes(handler, mWebShell);
fprintf(out, "%-20s %-5s %-9s %-7s %-7s %-7s\n",
"Frame Type", "Count", "TotalSize",
"MinSize", "MaxSize", "AvgSize");
fprintf(out, "%-20s %-5s %-9s %-7s %-7s %-7s\n",
"----------", "-----", "---------",
"-------", "-------", "-------");
handler->Report(DumpSizeData, (void*) out);
PRUint32 totalCount, totalSize;
handler->GetTotals(&totalCount, &totalSize);
fprintf(out, "%-20s %5d %9d\n",
"*** Total ***", totalCount, totalSize);
}
}
//----------------------------------------------------------------------
static
void
DumpViewsRecurse(nsIWebShell* aWebShell, FILE* out)
{
if (nsnull != aWebShell) {
fprintf(out, "webshell=%p \n", aWebShell);
nsIPresShell* shell = GetPresShellFor(aWebShell);
if (nsnull != shell) {
nsCOMPtr<nsIViewManager> vm;
shell->GetViewManager(getter_AddRefs(vm));
if (vm) {
nsIView* root;
vm->GetRootView(root);
if (nsnull != root) {
root->List(out);
}
}
NS_RELEASE(shell);
}
else {
fputs("null pres shell\n", out);
}
// dump the views of the sub documents
PRInt32 i, n;
aWebShell->GetChildCount(n);
for (i = 0; i < n; i++) {
nsIWebShell* child;
aWebShell->ChildAt(i, child);
if (nsnull != child) {
DumpViewsRecurse(child, out);
NS_RELEASE(child);
}
}
}
}
void
nsBrowserWindow::DumpViews(FILE* out)
{
DumpViewsRecurse(mWebShell, out);
DumpMultipleWebShells(*this, mWebShell, out);
}
void
nsBrowserWindow::DumpStyleSheets(FILE* out)
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsCOMPtr<nsIStyleSet> styleSet;
shell->GetStyleSet(getter_AddRefs(styleSet));
if (!styleSet) {
fputs("null style set\n", out);
} else {
styleSet->List(out);
}
NS_RELEASE(shell);
}
else {
fputs("null pres shell\n", out);
}
}
void
nsBrowserWindow::DumpStyleContexts(FILE* out)
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsCOMPtr<nsIStyleSet> styleSet;
shell->GetStyleSet(getter_AddRefs(styleSet));
if (!styleSet) {
fputs("null style set\n", out);
} else {
nsIFrame* root;
shell->GetRootFrame(&root);
if (nsnull == root) {
fputs("null root frame\n", out);
} else {
nsIStyleContext* rootContext;
root->GetStyleContext(&rootContext);
if (nsnull != rootContext) {
styleSet->ListContexts(rootContext, out);
NS_RELEASE(rootContext);
}
else {
fputs("null root context", out);
}
}
}
NS_RELEASE(shell);
} else {
fputs("null pres shell\n", out);
}
}
void
nsBrowserWindow::ToggleFrameBorders()
{
nsILayoutDebugger* ld;
nsresult rv = nsComponentManager::CreateInstance(kLayoutDebuggerCID,
nsnull,
kILayoutDebuggerIID,
(void **)&ld);
if (NS_SUCCEEDED(rv)) {
PRBool showing;
ld->GetShowFrameBorders(&showing);
ld->SetShowFrameBorders(!showing);
ForceRefresh();
NS_RELEASE(ld);
}
}
void
nsBrowserWindow::ToggleBoolPrefAndRefresh(const char * aPrefName)
{
NS_ASSERTION(nsnull != aPrefName,"null pref name");
if (nsnull != mPrefs && nsnull != aPrefName)
{
PRBool value;
mPrefs->GetBoolPref(aPrefName,&value);
mPrefs->SetBoolPref(aPrefName,!value);
mPrefs->SavePrefFile();
ForceRefresh();
}
}
//----------------------------------------------------------------------
static void
GatherContentDataSizes(nsISizeOfHandler* aHandler, nsIContent* aContent)
{
if (aContent) {
// Add in the content
nsCOMPtr<nsIAtom> tag;
aContent->GetTag(*getter_AddRefs(tag));
if (!tag) {
tag = getter_AddRefs(NS_NewAtom(":content-no-tag"));
}
PRUint32 contentDataSize;
aContent->SizeOf(aHandler, &contentDataSize);
aHandler->AddSize(tag, contentDataSize);
// And all of its children
PRInt32 i, childCount;
aContent->ChildCount(childCount);
for (i = 0; i < childCount; i++) {
nsIContent* kid;
aContent->ChildAt(i, kid);
if (kid) {
GatherContentDataSizes(aHandler, kid);
NS_RELEASE(kid);
}
}
}
}
static void
GatherContentDataSizes(nsISizeOfHandler* aHandler, nsIWebShell* aWebShell)
{
if (nsnull != aWebShell) {
nsIPresShell* shell = GetPresShellFor(aWebShell);
if (nsnull != shell) {
nsIDocument* doc;
shell->GetDocument(&doc);
if (doc) {
nsCOMPtr<nsIContent> rootContent = getter_AddRefs(
doc->GetRootContent()
);
if (rootContent) {
GatherContentDataSizes(aHandler, rootContent.get());
}
NS_RELEASE(doc);
}
NS_RELEASE(shell);
}
// dump the frames of the sub documents
PRInt32 i, n;
aWebShell->GetChildCount(n);
for (i = 0; i < n; i++) {
nsIWebShell* child;
aWebShell->ChildAt(i, child);
if (nsnull != child) {
GatherContentDataSizes(aHandler, child);
}
}
}
}
void
nsBrowserWindow::ShowContentSize(FILE* out)
{
nsCOMPtr<nsISizeOfHandler> handler;
nsresult rv = NS_NewSizeOfHandler(getter_AddRefs(handler));
if (NS_SUCCEEDED(rv) && handler) {
GatherContentDataSizes(handler, mWebShell);
fprintf(out, "%-20s %-5s %-9s %-7s %-7s %-7s\n",
"Content Type", "Count", "TotalSize",
"MinSize", "MaxSize", "AvgSize");
fprintf(out, "%-20s %-5s %-9s %-7s %-7s %-7s\n",
"----------", "-----", "---------",
"-------", "-------", "-------");
handler->Report(DumpSizeData, (void*) out);
PRUint32 totalCount, totalSize;
handler->GetTotals(&totalCount, &totalSize);
fprintf(out, "%-20s %5d %9d\n",
"*** Total ***", totalCount, totalSize);
}
}
//----------------------------------------------------------------------
void
nsBrowserWindow::ShowStyleSize()
{
// XXX not yet implemented
}
void
nsBrowserWindow::DoDebugSave()
{
/* Removed 04/01/99 -- gpk */
}
void
nsBrowserWindow::DoToggleSelection()
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsCOMPtr<nsIDocument> doc;
shell->GetDocument(getter_AddRefs(doc));
if (doc) {
PRBool current = doc->GetDisplaySelection();
doc->SetDisplaySelection(!current);
ForceRefresh();
}
NS_RELEASE(shell);
}
}
void
nsBrowserWindow::DoDebugRobot()
{
mApp->CreateRobot(this);
}
void
nsBrowserWindow::DoSiteWalker()
{
mApp->CreateSiteWalker(this);
}
nsEventStatus
nsBrowserWindow::DispatchDebugMenu(PRInt32 aID)
{
nsEventStatus result = nsEventStatus_eIgnore;
switch(aID) {
case VIEWER_VISUAL_DEBUGGING:
ToggleFrameBorders();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_TOGGLE_PAINT_FLASHING:
ToggleBoolPrefAndRefresh("nglayout.debug.paint_flashing");
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_TOGGLE_PAINT_DUMPING:
ToggleBoolPrefAndRefresh("nglayout.debug.paint_dumping");
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_TOGGLE_INVALIDATE_DUMPING:
ToggleBoolPrefAndRefresh("nglayout.debug.invalidate_dumping");
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_TOGGLE_EVENT_DUMPING:
ToggleBoolPrefAndRefresh("nglayout.debug.event_dumping");
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_TOGGLE_MOTION_EVENT_DUMPING:
ToggleBoolPrefAndRefresh("nglayout.debug.motion_event_dumping");
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_TOGGLE_CROSSING_EVENT_DUMPING:
ToggleBoolPrefAndRefresh("nglayout.debug.crossing_event_dumping");
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_DUMP_CONTENT:
DumpContent();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_DUMP_FRAMES:
DumpFrames();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_DUMP_VIEWS:
DumpViews();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_DUMP_STYLE_SHEETS:
DumpStyleSheets();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_DUMP_STYLE_CONTEXTS:
DumpStyleContexts();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_SHOW_CONTENT_SIZE:
ShowContentSize();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_SHOW_FRAME_SIZE:
ShowFrameSize();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_SHOW_STYLE_SIZE:
ShowStyleSize();
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_SHOW_CONTENT_QUALITY:
if (nsnull != mWebShell) {
nsIPresShell *ps = GetPresShellFor(mWebShell);
nsIViewManager *vm = nsnull;
PRBool qual;
if (ps) {
ps->GetViewManager(&vm);
if (vm) {
vm->GetShowQuality(qual);
vm->ShowQuality(!qual);
NS_RELEASE(vm);
}
NS_RELEASE(ps);
}
}
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_DEBUGSAVE:
DoDebugSave();
break;
case VIEWER_TOGGLE_SELECTION:
DoToggleSelection();
break;
case VIEWER_DEBUGROBOT:
DoDebugRobot();
break;
case VIEWER_TOP100:
DoSiteWalker();
break;
}
return(result);
}
#endif // NS_DEBUG
void
nsBrowserWindow::SetCompatibilityMode(PRBool aIsStandard)
{
if (nsnull != mPrefs) {
int32 prefInt = (aIsStandard) ? eCompatibility_Standard : eCompatibility_NavQuirks;
mPrefs->SetIntPref("nglayout.compatibility.mode", prefInt);
mPrefs->SavePrefFile();
}
}
void
nsBrowserWindow::SetWidgetRenderingMode(PRBool aIsNative)
{
if (nsnull != mPrefs) {
int32 prefInt = (aIsNative) ? eWidgetRendering_Native : eWidgetRendering_Gfx;
mPrefs->SetIntPref("nglayout.widget.mode", prefInt);
mPrefs->SavePrefFile();
}
}
nsEventStatus
nsBrowserWindow::DispatchStyleMenu(PRInt32 aID)
{
nsEventStatus result = nsEventStatus_eIgnore;
switch(aID) {
case VIEWER_SELECT_STYLE_LIST:
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsAutoString defaultStyle;
nsCOMPtr<nsIDocument> doc;
shell->GetDocument(getter_AddRefs(doc));
if (doc) {
nsIAtom* defStyleAtom = NS_NewAtom("default-style");
doc->GetHeaderData(defStyleAtom, defaultStyle);
NS_RELEASE(defStyleAtom);
}
nsStringArray titles;
shell->ListAlternateStyleSheets(titles);
nsAutoString current;
shell->GetActiveAlternateStyleSheet(current);
PRInt32 count = titles.Count();
fprintf(stdout, "There %s %d alternate style sheet%s\n",
((1 == count) ? "is" : "are"),
count,
((1 == count) ? "" : "s"));
PRInt32 index;
for (index = 0; index < count; index++) {
fprintf(stdout, "%d: \"", index + 1);
nsAutoString title;
titles.StringAt(index, title);
fputs(title, stdout);
fprintf(stdout, "\" %s%s\n",
((title.EqualsIgnoreCase(current)) ? "<< current " : ""),
((title.EqualsIgnoreCase(defaultStyle)) ? "** default" : ""));
}
NS_RELEASE(shell);
}
}
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_SELECT_STYLE_DEFAULT:
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsCOMPtr<nsIDocument> doc;
shell->GetDocument(getter_AddRefs(doc));
if (doc) {
nsAutoString defaultStyle;
nsIAtom* defStyleAtom = NS_NewAtom("default-style");
doc->GetHeaderData(defStyleAtom, defaultStyle);
NS_RELEASE(defStyleAtom);
fputs("Selecting default style sheet \"", stdout);
fputs(defaultStyle, stdout);
fputs("\"\n", stdout);
shell->SelectAlternateStyleSheet(defaultStyle);
}
NS_RELEASE(shell);
}
}
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_SELECT_STYLE_ONE:
case VIEWER_SELECT_STYLE_TWO:
case VIEWER_SELECT_STYLE_THREE:
case VIEWER_SELECT_STYLE_FOUR:
{
nsIPresShell* shell = GetPresShell();
if (nsnull != shell) {
nsStringArray titles;
shell->ListAlternateStyleSheets(titles);
nsAutoString title;
titles.StringAt(aID - VIEWER_SELECT_STYLE_ONE, title);
fputs("Selecting alternate style sheet \"", stdout);
fputs(title, stdout);
fputs("\"\n", stdout);
shell->SelectAlternateStyleSheet(title);
NS_RELEASE(shell);
}
}
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_NAV_QUIRKS_MODE:
case VIEWER_STANDARD_MODE:
SetCompatibilityMode(VIEWER_STANDARD_MODE == aID);
result = nsEventStatus_eConsumeNoDefault;
break;
case VIEWER_NATIVE_WIDGET_MODE:
case VIEWER_GFX_WIDGET_MODE:
SetWidgetRenderingMode(VIEWER_NATIVE_WIDGET_MODE == aID);
result = nsEventStatus_eConsumeNoDefault;
break;
}
return result;
}
//----------------------------------------------------------------------
// Factory code for creating nsBrowserWindow's
class nsBrowserWindowFactory : public nsIFactory
{
public:
nsBrowserWindowFactory();
virtual ~nsBrowserWindowFactory();
// nsISupports methods
NS_IMETHOD QueryInterface(const nsIID &aIID, void **aResult);
NS_IMETHOD_(nsrefcnt) AddRef(void);
NS_IMETHOD_(nsrefcnt) Release(void);
// nsIFactory methods
NS_IMETHOD CreateInstance(nsISupports *aOuter,
const nsIID &aIID,
void **aResult);
NS_IMETHOD LockFactory(PRBool aLock);
private:
nsrefcnt mRefCnt;
};
nsBrowserWindowFactory::nsBrowserWindowFactory()
{
mRefCnt = 0;
}
nsBrowserWindowFactory::~nsBrowserWindowFactory()
{
NS_ASSERTION(mRefCnt == 0, "non-zero refcnt at destruction");
}
nsresult
nsBrowserWindowFactory::QueryInterface(const nsIID &aIID, void **aResult)
{
if (aResult == NULL) {
return NS_ERROR_NULL_POINTER;
}
// Always NULL result, in case of failure
*aResult = NULL;
if (aIID.Equals(kISupportsIID)) {
*aResult = (void *)(nsISupports*)this;
} else if (aIID.Equals(kIFactoryIID)) {
*aResult = (void *)(nsIFactory*)this;
}
if (*aResult == NULL) {
return NS_NOINTERFACE;
}
NS_ADDREF_THIS(); // Increase reference count for caller
return NS_OK;
}
nsrefcnt
nsBrowserWindowFactory::AddRef()
{
return ++mRefCnt;
}
nsrefcnt
nsBrowserWindowFactory::Release()
{
if (--mRefCnt == 0) {
delete this;
return 0; // Don't access mRefCnt after deleting!
}
return mRefCnt;
}
nsresult
nsBrowserWindowFactory::CreateInstance(nsISupports *aOuter,
const nsIID &aIID,
void **aResult)
{
nsresult rv;
nsBrowserWindow *inst;
if (aResult == NULL) {
return NS_ERROR_NULL_POINTER;
}
*aResult = NULL;
if (nsnull != aOuter) {
rv = NS_ERROR_NO_AGGREGATION;
goto done;
}
NS_NEWXPCOM(inst, nsNativeBrowserWindow);
if (inst == NULL) {
rv = NS_ERROR_OUT_OF_MEMORY;
goto done;
}
NS_ADDREF(inst);
rv = inst->QueryInterface(aIID, aResult);
NS_RELEASE(inst);
done:
return rv;
}
nsresult
nsBrowserWindowFactory::LockFactory(PRBool aLock)
{
// Not implemented in simplest case.
return NS_OK;
}
nsresult NS_NewBrowserWindowFactory(nsIFactory** aFactory);
nsresult
NS_NewBrowserWindowFactory(nsIFactory** aFactory)
{
nsresult rv = NS_OK;
nsBrowserWindowFactory* inst;
NS_NEWXPCOM(inst, nsBrowserWindowFactory);
if (nsnull == inst) {
rv = NS_ERROR_OUT_OF_MEMORY;
}
else {
NS_ADDREF(inst);
}
*aFactory = inst;
return rv;
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку