516 lines
16 KiB
C++
516 lines
16 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (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/MPL/
|
|
*
|
|
* 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. This file was split
|
|
* from xpfe/appshell/src/nsAppShellService.cpp
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Pierre Phaneuf <pp@ludusdesign.com>
|
|
* Robert O'Callahan <roc+moz@cs.cmu.edu>
|
|
* Benjamin Smedberg <bsmedberg@covad.net>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#include "nsAppStartup.h"
|
|
|
|
#include "nsIAppShellService.h"
|
|
#include "nsICloseAllWindows.h"
|
|
#include "nsIDOMWindowInternal.h"
|
|
#include "nsIEventQueue.h"
|
|
#include "nsIEventQueueService.h"
|
|
#include "nsIInterfaceRequestor.h"
|
|
#include "nsILocalFile.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsIPrefBranch.h"
|
|
#include "nsIPrefService.h"
|
|
#include "nsIProfileChangeStatus.h"
|
|
#include "nsIPromptService.h"
|
|
#include "nsIStringBundle.h"
|
|
#include "nsISupportsPrimitives.h"
|
|
#include "nsITimelineService.h"
|
|
#include "nsIWebBrowserChrome.h"
|
|
#include "nsIWindowMediator.h"
|
|
#include "nsIWindowWatcher.h"
|
|
#include "nsIXULWindow.h"
|
|
#include "nsNativeCharsetUtils.h"
|
|
|
|
#include "prprf.h"
|
|
#include "nsCRT.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsWidgetsCID.h"
|
|
#include "nsAppShellCID.h"
|
|
#include "nsXPFEComponentsCID.h"
|
|
|
|
NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
|
|
|
|
//
|
|
// nsAppStartup
|
|
//
|
|
|
|
nsAppStartup::nsAppStartup() :
|
|
mConsiderQuitStopper(0),
|
|
mShuttingDown(PR_FALSE),
|
|
mAttemptingQuit(PR_FALSE),
|
|
mRestart(PR_FALSE)
|
|
{ }
|
|
|
|
|
|
nsresult
|
|
nsAppStartup::Init()
|
|
{
|
|
nsresult rv;
|
|
|
|
// Create widget application shell
|
|
mAppShell = do_CreateInstance(kAppShellCID, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = mAppShell->Create(nsnull, nsnull);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// listen to EventQueues' comings and goings. do this after the appshell
|
|
// has been created, but after the event queue has been created. that
|
|
// latter bit is unfortunate, but we deal with it.
|
|
nsCOMPtr<nsIObserverService> os
|
|
(do_GetService("@mozilla.org/observer-service;1", &rv));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
os->AddObserver(this, "nsIEventQueueActivated", PR_TRUE);
|
|
os->AddObserver(this, "nsIEventQueueDestroyed", PR_TRUE);
|
|
os->AddObserver(this, "profile-change-teardown", PR_TRUE);
|
|
os->AddObserver(this, "xul-window-registered", PR_TRUE);
|
|
os->AddObserver(this, "xul-window-destroyed", PR_TRUE);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// nsAppStartup->nsISupports
|
|
//
|
|
|
|
NS_IMPL_THREADSAFE_ISUPPORTS5(nsAppStartup,
|
|
nsIAppStartup,
|
|
nsIWindowCreator,
|
|
nsIWindowCreator2,
|
|
nsIObserver,
|
|
nsISupportsWeakReference)
|
|
|
|
|
|
//
|
|
// nsAppStartup->nsIAppStartup
|
|
//
|
|
|
|
NS_IMETHODIMP
|
|
nsAppStartup::CreateHiddenWindow()
|
|
{
|
|
nsCOMPtr<nsIAppShellService> appShellService
|
|
(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
|
|
NS_ENSURE_TRUE(appShellService, NS_ERROR_FAILURE);
|
|
|
|
return appShellService->CreateHiddenWindow(mAppShell);
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsAppStartup::Run(void)
|
|
{
|
|
nsresult rv = mAppShell->Run();
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
return mRestart ? NS_SUCCESS_RESTART_APP : NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsAppStartup::Quit(PRUint32 aMode)
|
|
{
|
|
PRUint32 ferocity = (aMode & 0xF);
|
|
|
|
// Quit the application. We will asynchronously call the appshell's
|
|
// Exit() method via HandleExitEvent() to allow one last pass
|
|
// through any events in the queue. This guarantees a tidy cleanup.
|
|
nsresult rv = NS_OK;
|
|
PRBool postedExitEvent = PR_FALSE;
|
|
|
|
if (mShuttingDown)
|
|
return NS_OK;
|
|
|
|
/* eForceQuit doesn't actually work; it can cause a subtle crash if
|
|
there are windows open which have unload handlers which open
|
|
new windows. Use eAttemptQuit for now. */
|
|
if (ferocity == eForceQuit) {
|
|
NS_WARNING("attempted to force quit");
|
|
// it will be treated the same as eAttemptQuit, below
|
|
}
|
|
|
|
mShuttingDown = PR_TRUE;
|
|
mRestart = aMode & eRestart;
|
|
|
|
nsCOMPtr<nsIWindowMediator> mediator
|
|
(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID));
|
|
|
|
if (ferocity == eConsiderQuit && mConsiderQuitStopper == 0) {
|
|
// attempt quit if the last window has been unregistered/closed
|
|
|
|
PRBool windowsRemain = PR_TRUE;
|
|
|
|
if (mediator) {
|
|
nsCOMPtr<nsISimpleEnumerator> windowEnumerator;
|
|
mediator->GetEnumerator(nsnull, getter_AddRefs(windowEnumerator));
|
|
if (windowEnumerator)
|
|
windowEnumerator->HasMoreElements(&windowsRemain);
|
|
}
|
|
if (!windowsRemain) {
|
|
ferocity = eAttemptQuit;
|
|
}
|
|
}
|
|
|
|
/* Currently ferocity can never have the value of eForceQuit here.
|
|
That's temporary (in an unscheduled kind of way) and logically
|
|
this code is part of the eForceQuit case, so I'm checking against
|
|
that value anyway. Reviewers made me add this comment. */
|
|
if (ferocity == eAttemptQuit || ferocity == eForceQuit) {
|
|
|
|
AttemptingQuit(PR_TRUE);
|
|
|
|
/* Enumerate through each open window and close it. It's important to do
|
|
this before we forcequit because this can control whether we really quit
|
|
at all. e.g. if one of these windows has an unload handler that
|
|
opens a new window. Ugh. I know. */
|
|
if (mediator) {
|
|
nsCOMPtr<nsISimpleEnumerator> windowEnumerator;
|
|
|
|
mediator->GetEnumerator(nsnull, getter_AddRefs(windowEnumerator));
|
|
|
|
if (windowEnumerator) {
|
|
|
|
while (1) {
|
|
PRBool more;
|
|
if (NS_FAILED(rv = windowEnumerator->HasMoreElements(&more)) || !more)
|
|
break;
|
|
|
|
nsCOMPtr<nsISupports> isupports;
|
|
rv = windowEnumerator->GetNext(getter_AddRefs(isupports));
|
|
if (NS_FAILED(rv))
|
|
break;
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> window = do_QueryInterface(isupports);
|
|
NS_ASSERTION(window, "not an nsIDOMWindowInternal");
|
|
if (!window)
|
|
continue;
|
|
|
|
window->Close();
|
|
}
|
|
}
|
|
|
|
if (ferocity == eAttemptQuit) {
|
|
|
|
ferocity = eForceQuit; // assume success
|
|
|
|
/* Were we able to immediately close all windows? if not, eAttemptQuit
|
|
failed. This could happen for a variety of reasons; in fact it's
|
|
very likely. Perhaps we're being called from JS and the window->Close
|
|
method hasn't had a chance to wrap itself up yet. So give up.
|
|
We'll return (with eConsiderQuit) as the remaining windows are
|
|
closed. */
|
|
mediator->GetEnumerator(nsnull, getter_AddRefs(windowEnumerator));
|
|
if (windowEnumerator) {
|
|
PRBool more;
|
|
while (windowEnumerator->HasMoreElements(&more), more) {
|
|
/* we can't quit immediately. we'll try again as the last window
|
|
finally closes. */
|
|
ferocity = eAttemptQuit;
|
|
nsCOMPtr<nsISupports> window;
|
|
windowEnumerator->GetNext(getter_AddRefs(window));
|
|
nsCOMPtr<nsIDOMWindowInternal> domWindow(do_QueryInterface(window));
|
|
if (domWindow) {
|
|
PRBool closed = PR_FALSE;
|
|
domWindow->GetClosed(&closed);
|
|
if (!closed) {
|
|
rv = NS_ERROR_FAILURE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ferocity == eForceQuit) {
|
|
// do it!
|
|
|
|
// No chance of the shutdown being cancelled from here on; tell people
|
|
// we're shutting down for sure while all services are still available.
|
|
nsCOMPtr<nsIObserverService> obsService
|
|
(do_GetService("@mozilla.org/observer-service;1"));
|
|
if (obsService)
|
|
obsService->NotifyObservers(nsnull, "quit-application", nsnull);
|
|
|
|
nsCOMPtr<nsIAppShellService> appShellService
|
|
(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
|
|
NS_ASSERTION(appShellService, "We're gonna leak something.");
|
|
if (appShellService)
|
|
appShellService->DestroyHiddenWindow();
|
|
|
|
// no matter what, make sure we send the exit event. If
|
|
// worst comes to worst, we'll do a leaky shutdown but we WILL
|
|
// shut down. Well, assuming that all *this* stuff works ;-).
|
|
nsCOMPtr<nsIEventQueueService> svc = do_GetService(NS_EVENTQUEUESERVICE_CONTRACTID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
nsCOMPtr<nsIEventQueue> queue;
|
|
rv = svc->GetThreadEventQueue(NS_CURRENT_THREAD, getter_AddRefs(queue));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
PLEvent* event = new PLEvent;
|
|
if (event) {
|
|
NS_ADDREF_THIS();
|
|
PL_InitEvent(event,
|
|
this,
|
|
HandleExitEvent,
|
|
DestroyExitEvent);
|
|
|
|
rv = queue->PostEvent(event);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
postedExitEvent = PR_TRUE;
|
|
}
|
|
else {
|
|
PL_DestroyEvent(event);
|
|
}
|
|
}
|
|
else {
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// turn off the reentrancy check flag, but not if we have
|
|
// more asynchronous work to do still.
|
|
if (!postedExitEvent)
|
|
mShuttingDown = PR_FALSE;
|
|
return rv;
|
|
}
|
|
|
|
|
|
/* We know we're trying to quit the app, but may not be able to do so
|
|
immediately. Enter a state where we're more ready to quit.
|
|
(Does useful work only on the Mac.) */
|
|
void
|
|
nsAppStartup::AttemptingQuit(PRBool aAttempt)
|
|
{
|
|
#if defined(XP_MAC) || defined(XP_MACOSX)
|
|
if (aAttempt) {
|
|
// now even the Mac wants to quit when the last window is closed
|
|
if (!mAttemptingQuit)
|
|
ExitLastWindowClosingSurvivalArea();
|
|
mAttemptingQuit = PR_TRUE;
|
|
} else {
|
|
// changed our mind. back to normal.
|
|
if (mAttemptingQuit)
|
|
EnterLastWindowClosingSurvivalArea();
|
|
mAttemptingQuit = PR_FALSE;
|
|
}
|
|
#else
|
|
mAttemptingQuit = aAttempt;
|
|
#endif
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsAppStartup::EnterLastWindowClosingSurvivalArea(void)
|
|
{
|
|
++mConsiderQuitStopper;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsAppStartup::ExitLastWindowClosingSurvivalArea(void)
|
|
{
|
|
NS_ASSERTION(mConsiderQuitStopper > 0, "consider quit stopper out of bounds");
|
|
--mConsiderQuitStopper;
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
void* PR_CALLBACK
|
|
nsAppStartup::HandleExitEvent(PLEvent* aEvent)
|
|
{
|
|
nsAppStartup *service =
|
|
NS_REINTERPRET_CAST(nsAppStartup*, aEvent->owner);
|
|
|
|
// Tell the appshell to exit
|
|
service->mAppShell->Exit();
|
|
|
|
// We're done "shutting down".
|
|
service->mShuttingDown = PR_FALSE;
|
|
|
|
return nsnull;
|
|
}
|
|
|
|
void PR_CALLBACK
|
|
nsAppStartup::DestroyExitEvent(PLEvent* aEvent)
|
|
{
|
|
nsAppStartup *service =
|
|
NS_REINTERPRET_CAST(nsAppStartup*, aEvent->owner);
|
|
NS_RELEASE(service);
|
|
delete aEvent;
|
|
}
|
|
|
|
|
|
//
|
|
// nsAppStartup->nsIWindowCreator
|
|
//
|
|
|
|
NS_IMETHODIMP
|
|
nsAppStartup::CreateChromeWindow(nsIWebBrowserChrome *aParent,
|
|
PRUint32 aChromeFlags,
|
|
nsIWebBrowserChrome **_retval)
|
|
{
|
|
PRBool cancel;
|
|
return CreateChromeWindow2(aParent, aChromeFlags, 0, 0, &cancel, _retval);
|
|
}
|
|
|
|
|
|
//
|
|
// nsAppStartup->nsIWindowCreator2
|
|
//
|
|
|
|
NS_IMETHODIMP
|
|
nsAppStartup::CreateChromeWindow2(nsIWebBrowserChrome *aParent,
|
|
PRUint32 aChromeFlags,
|
|
PRUint32 aContextFlags,
|
|
nsIURI *aURI,
|
|
PRBool *aCancel,
|
|
nsIWebBrowserChrome **_retval)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aCancel);
|
|
NS_ENSURE_ARG_POINTER(_retval);
|
|
*aCancel = PR_FALSE;
|
|
*_retval = 0;
|
|
|
|
nsCOMPtr<nsIXULWindow> newWindow;
|
|
|
|
if (aParent) {
|
|
nsCOMPtr<nsIXULWindow> xulParent(do_GetInterface(aParent));
|
|
NS_ASSERTION(xulParent, "window created using non-XUL parent. that's unexpected, but may work.");
|
|
|
|
if (xulParent)
|
|
xulParent->CreateNewWindow(aChromeFlags, mAppShell, getter_AddRefs(newWindow));
|
|
// And if it fails, don't try again without a parent. It could fail
|
|
// intentionally (bug 115969).
|
|
} else { // try using basic methods:
|
|
/* You really shouldn't be making dependent windows without a parent.
|
|
But unparented modal (and therefore dependent) windows happen
|
|
in our codebase, so we allow it after some bellyaching: */
|
|
if (aChromeFlags & nsIWebBrowserChrome::CHROME_DEPENDENT)
|
|
NS_WARNING("dependent window created without a parent");
|
|
|
|
nsCOMPtr<nsIAppShellService> appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
|
|
if (!appShell)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
appShell->CreateTopLevelWindow(0, 0, aChromeFlags,
|
|
nsIAppShellService::SIZE_TO_CONTENT,
|
|
nsIAppShellService::SIZE_TO_CONTENT,
|
|
mAppShell, getter_AddRefs(newWindow));
|
|
}
|
|
|
|
// if anybody gave us anything to work with, use it
|
|
if (newWindow) {
|
|
newWindow->SetContextFlags(aContextFlags);
|
|
nsCOMPtr<nsIInterfaceRequestor> thing(do_QueryInterface(newWindow));
|
|
if (thing)
|
|
CallGetInterface(thing.get(), _retval);
|
|
}
|
|
|
|
return *_retval ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
|
|
|
|
//
|
|
// nsAppStartup->nsIObserver
|
|
//
|
|
|
|
NS_IMETHODIMP
|
|
nsAppStartup::Observe(nsISupports *aSubject,
|
|
const char *aTopic, const PRUnichar *aData)
|
|
{
|
|
NS_ASSERTION(mAppShell, "appshell service notified before appshell built");
|
|
if (!strcmp(aTopic, "nsIEventQueueActivated")) {
|
|
nsCOMPtr<nsIEventQueue> eq(do_QueryInterface(aSubject));
|
|
if (eq) {
|
|
PRBool isNative = PR_TRUE;
|
|
// we only add native event queues to the appshell
|
|
eq->IsQueueNative(&isNative);
|
|
if (isNative)
|
|
mAppShell->ListenToEventQueue(eq, PR_TRUE);
|
|
}
|
|
} else if (!strcmp(aTopic, "nsIEventQueueDestroyed")) {
|
|
nsCOMPtr<nsIEventQueue> eq(do_QueryInterface(aSubject));
|
|
if (eq) {
|
|
PRBool isNative = PR_TRUE;
|
|
// we only remove native event queues from the appshell
|
|
eq->IsQueueNative(&isNative);
|
|
if (isNative)
|
|
mAppShell->ListenToEventQueue(eq, PR_FALSE);
|
|
}
|
|
} else if (!strcmp(aTopic, "profile-change-teardown")) {
|
|
nsresult rv;
|
|
EnterLastWindowClosingSurvivalArea();
|
|
// NOTE: No early error exits because we need to execute the
|
|
// balancing ExitLastWindowClosingSurvivalArea().
|
|
nsCOMPtr<nsICloseAllWindows> closer =
|
|
do_CreateInstance("@mozilla.org/appshell/closeallwindows;1", &rv);
|
|
NS_ASSERTION(closer, "Failed to create nsICloseAllWindows impl.");
|
|
PRBool proceedWithSwitch = PR_FALSE;
|
|
if (closer)
|
|
rv = closer->CloseAll(PR_TRUE, &proceedWithSwitch);
|
|
|
|
if (NS_FAILED(rv) || !proceedWithSwitch) {
|
|
nsCOMPtr<nsIProfileChangeStatus> changeStatus(do_QueryInterface(aSubject));
|
|
if (changeStatus)
|
|
changeStatus->VetoChange();
|
|
}
|
|
ExitLastWindowClosingSurvivalArea();
|
|
} else if (!strcmp(aTopic, "xul-window-registered")) {
|
|
AttemptingQuit(PR_FALSE);
|
|
} else if (!strcmp(aTopic, "xul-window-destroyed")) {
|
|
Quit(eConsiderQuit);
|
|
} else {
|
|
NS_ERROR("Unexpected observer topic.");
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|