2007-03-22 10:30:00 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=2 sw=2 et tw=80: */
|
|
|
|
/* ***** 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.org code.
|
|
|
|
*
|
|
|
|
* 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):
|
|
|
|
*
|
|
|
|
* 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 ***** */
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef nsPIDOMWindow_h__
|
|
|
|
#define nsPIDOMWindow_h__
|
|
|
|
|
|
|
|
#include "nsISupports.h"
|
|
|
|
#include "nsIDOMLocation.h"
|
|
|
|
#include "nsIDOMXULCommandDispatcher.h"
|
|
|
|
#include "nsIDOMElement.h"
|
|
|
|
#include "nsIDOMWindowInternal.h"
|
|
|
|
#include "nsPIDOMEventTarget.h"
|
|
|
|
#include "nsIDOMDocument.h"
|
|
|
|
#include "nsCOMPtr.h"
|
|
|
|
#include "nsEvent.h"
|
2011-03-31 13:30:32 -07:00
|
|
|
#include "nsIURI.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-02-13 15:41:17 -08:00
|
|
|
#define DOM_WINDOW_DESTROYED_TOPIC "dom-window-destroyed"
|
2011-05-22 14:30:07 -07:00
|
|
|
#define DOM_WINDOW_FROZEN_TOPIC "dom-window-frozen"
|
|
|
|
#define DOM_WINDOW_THAWED_TOPIC "dom-window-thawed"
|
2008-02-13 15:41:17 -08:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
class nsIPrincipal;
|
|
|
|
|
|
|
|
// Popup control state enum. The values in this enum must go from most
|
|
|
|
// permissive to least permissive so that it's safe to push state in
|
|
|
|
// all situations. Pushing popup state onto the stack never makes the
|
|
|
|
// current popup state less permissive (see
|
|
|
|
// nsGlobalWindow::PushPopupControlState()).
|
|
|
|
enum PopupControlState {
|
|
|
|
openAllowed = 0, // open that window without worries
|
|
|
|
openControlled, // it's a popup, but allow it
|
|
|
|
openAbused, // it's a popup. disallow it, but allow domain override.
|
|
|
|
openOverridden // disallow window open
|
|
|
|
};
|
|
|
|
|
|
|
|
class nsIDocShell;
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 11:00:39 -07:00
|
|
|
class nsIContent;
|
2007-03-22 10:30:00 -07:00
|
|
|
class nsIDocument;
|
|
|
|
class nsIScriptTimeoutHandler;
|
|
|
|
struct nsTimeout;
|
2008-02-12 20:17:18 -08:00
|
|
|
class nsScriptObjectHolder;
|
|
|
|
class nsXBLPrototypeHandler;
|
2009-10-06 17:09:16 -07:00
|
|
|
class nsIArray;
|
2010-02-20 08:07:03 -08:00
|
|
|
class nsPIWindowRoot;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
#define NS_PIDOMWINDOW_IID \
|
2011-05-23 11:53:31 -07:00
|
|
|
{ 0x176e69ce, 0x25d3, 0x4f2a, \
|
|
|
|
{ 0x9d, 0x99, 0x81, 0xa3, 0x9a, 0xfd, 0xe2, 0xf0 } }
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
class nsPIDOMWindow : public nsIDOMWindowInternal
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
NS_DECLARE_STATIC_IID_ACCESSOR(NS_PIDOMWINDOW_IID)
|
|
|
|
|
|
|
|
virtual nsPIDOMWindow* GetPrivateRoot() = 0;
|
|
|
|
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 11:00:39 -07:00
|
|
|
virtual void ActivateOrDeactivate(PRBool aActivate) = 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-02-20 08:07:03 -08:00
|
|
|
// this is called GetTopWindowRoot to avoid conflicts with nsIDOMWindow2::GetWindowRoot
|
|
|
|
virtual already_AddRefed<nsPIWindowRoot> GetTopWindowRoot() = 0;
|
|
|
|
|
2010-03-17 10:10:57 -07:00
|
|
|
virtual void SetActive(PRBool aActive)
|
|
|
|
{
|
|
|
|
mIsActive = aActive;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool IsActive()
|
|
|
|
{
|
|
|
|
return mIsActive;
|
|
|
|
}
|
|
|
|
|
2011-03-25 18:05:55 -07:00
|
|
|
void SetIsBackground(PRBool aIsBackground)
|
|
|
|
{
|
|
|
|
mIsBackground = aIsBackground;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool IsBackground()
|
|
|
|
{
|
|
|
|
return mIsBackground;
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
nsPIDOMEventTarget* GetChromeEventHandler() const
|
|
|
|
{
|
|
|
|
return mChromeEventHandler;
|
|
|
|
}
|
|
|
|
|
2008-08-07 16:15:40 -07:00
|
|
|
virtual void SetChromeEventHandler(nsPIDOMEventTarget* aChromeEventHandler) = 0;
|
|
|
|
|
2010-06-16 04:43:36 -07:00
|
|
|
nsPIDOMEventTarget* GetParentTarget()
|
|
|
|
{
|
|
|
|
if (!mParentTarget) {
|
|
|
|
UpdateParentTarget();
|
|
|
|
}
|
|
|
|
return mParentTarget;
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
PRBool HasMutationListeners(PRUint32 aMutationEventType) const
|
|
|
|
{
|
|
|
|
const nsPIDOMWindow *win;
|
|
|
|
|
|
|
|
if (IsOuterWindow()) {
|
|
|
|
win = GetCurrentInnerWindow();
|
|
|
|
|
|
|
|
if (!win) {
|
|
|
|
NS_ERROR("No current inner window available!");
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!mOuterWindow) {
|
|
|
|
NS_ERROR("HasMutationListeners() called on orphan inner window!");
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
win = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (win->mMutationBits & aMutationEventType) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetMutationListeners(PRUint32 aType)
|
|
|
|
{
|
|
|
|
nsPIDOMWindow *win;
|
|
|
|
|
|
|
|
if (IsOuterWindow()) {
|
|
|
|
win = GetCurrentInnerWindow();
|
|
|
|
|
|
|
|
if (!win) {
|
|
|
|
NS_ERROR("No inner window available to set mutation bits on!");
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!mOuterWindow) {
|
|
|
|
NS_ERROR("HasMutationListeners() called on orphan inner window!");
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
win = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
win->mMutationBits |= aType;
|
|
|
|
}
|
|
|
|
|
2010-08-02 06:34:54 -07:00
|
|
|
virtual void MaybeUpdateTouchState() {}
|
|
|
|
virtual void UpdateTouchState() {}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// GetExtantDocument provides a backdoor to the DOM GetDocument accessor
|
|
|
|
nsIDOMDocument* GetExtantDocument() const
|
|
|
|
{
|
|
|
|
return mDocument;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Internal getter/setter for the frame element, this version of the
|
|
|
|
// getter crosses chrome boundaries whereas the public scriptable
|
|
|
|
// one doesn't for security reasons.
|
|
|
|
nsIDOMElement* GetFrameElementInternal() const
|
|
|
|
{
|
|
|
|
if (mOuterWindow) {
|
|
|
|
return mOuterWindow->GetFrameElementInternal();
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ASSERTION(!IsInnerWindow(),
|
|
|
|
"GetFrameElementInternal() called on orphan inner window");
|
|
|
|
|
|
|
|
return mFrameElement;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetFrameElementInternal(nsIDOMElement *aFrameElement)
|
|
|
|
{
|
|
|
|
if (IsOuterWindow()) {
|
|
|
|
mFrameElement = aFrameElement;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mOuterWindow) {
|
|
|
|
NS_ERROR("frameElement set on inner window with no outer!");
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mOuterWindow->SetFrameElementInternal(aFrameElement);
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool IsLoadingOrRunningTimeout() const
|
|
|
|
{
|
|
|
|
const nsPIDOMWindow *win = GetCurrentInnerWindow();
|
|
|
|
|
|
|
|
if (!win) {
|
|
|
|
win = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !win->mIsDocumentLoaded || win->mRunningTimeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check whether a document is currently loading
|
|
|
|
PRBool IsLoading() const
|
|
|
|
{
|
|
|
|
const nsPIDOMWindow *win;
|
|
|
|
|
|
|
|
if (IsOuterWindow()) {
|
|
|
|
win = GetCurrentInnerWindow();
|
|
|
|
|
|
|
|
if (!win) {
|
|
|
|
NS_ERROR("No current inner window available!");
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!mOuterWindow) {
|
|
|
|
NS_ERROR("IsLoading() called on orphan inner window!");
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
win = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !win->mIsDocumentLoaded;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool IsHandlingResizeEvent() const
|
|
|
|
{
|
|
|
|
const nsPIDOMWindow *win;
|
|
|
|
|
|
|
|
if (IsOuterWindow()) {
|
|
|
|
win = GetCurrentInnerWindow();
|
|
|
|
|
|
|
|
if (!win) {
|
|
|
|
NS_ERROR("No current inner window available!");
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!mOuterWindow) {
|
|
|
|
NS_ERROR("IsHandlingResizeEvent() called on orphan inner window!");
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
win = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
return win->mIsHandlingResizeEvent;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Tell this window who opened it. This only has an effect if there is
|
|
|
|
// either no document currently in the window or if the document is the
|
|
|
|
// original document this window came with (an about:blank document either
|
|
|
|
// preloaded into it when it was created, or created by
|
|
|
|
// CreateAboutBlankContentViewer()).
|
|
|
|
virtual void SetOpenerScriptPrincipal(nsIPrincipal* aPrincipal) = 0;
|
|
|
|
// Ask this window who opened it.
|
|
|
|
virtual nsIPrincipal* GetOpenerScriptPrincipal() = 0;
|
|
|
|
|
|
|
|
virtual PopupControlState PushPopupControlState(PopupControlState aState,
|
|
|
|
PRBool aForce) const = 0;
|
|
|
|
virtual void PopPopupControlState(PopupControlState state) const = 0;
|
|
|
|
virtual PopupControlState GetPopupControlState() const = 0;
|
|
|
|
|
|
|
|
// Returns an object containing the window's state. This also suspends
|
|
|
|
// all running timeouts in the window.
|
|
|
|
virtual nsresult SaveWindowState(nsISupports **aState) = 0;
|
|
|
|
|
|
|
|
// Restore the window state from aState.
|
|
|
|
virtual nsresult RestoreWindowState(nsISupports *aState) = 0;
|
|
|
|
|
2009-02-17 12:07:39 -08:00
|
|
|
// Suspend timeouts in this window and in child windows.
|
2009-03-03 12:18:00 -08:00
|
|
|
virtual void SuspendTimeouts(PRUint32 aIncrease = 1,
|
|
|
|
PRBool aFreezeChildren = PR_TRUE) = 0;
|
2009-02-17 12:07:39 -08:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// Resume suspended timeouts in this window and in child windows.
|
2009-03-03 12:18:00 -08:00
|
|
|
virtual nsresult ResumeTimeouts(PRBool aThawChildren = PR_TRUE) = 0;
|
|
|
|
|
|
|
|
virtual PRUint32 TimeoutSuspendCount() = 0;
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// Fire any DOM notification events related to things that happened while
|
|
|
|
// the window was frozen.
|
|
|
|
virtual nsresult FireDelayedDOMEvents() = 0;
|
|
|
|
|
2008-01-16 13:54:33 -08:00
|
|
|
virtual PRBool IsFrozen() const = 0;
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// Add a timeout to this window.
|
|
|
|
virtual nsresult SetTimeoutOrInterval(nsIScriptTimeoutHandler *aHandler,
|
|
|
|
PRInt32 interval,
|
|
|
|
PRBool aIsInterval, PRInt32 *aReturn) = 0;
|
|
|
|
|
|
|
|
// Clear a timeout from this window.
|
|
|
|
virtual nsresult ClearTimeoutOrInterval(PRInt32 aTimerID) = 0;
|
|
|
|
|
|
|
|
nsPIDOMWindow *GetOuterWindow()
|
|
|
|
{
|
2010-10-12 15:03:15 -07:00
|
|
|
return mIsInnerWindow ? mOuterWindow.get() : this;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
nsPIDOMWindow *GetCurrentInnerWindow() const
|
|
|
|
{
|
|
|
|
return mInnerWindow;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsPIDOMWindow *EnsureInnerWindow()
|
|
|
|
{
|
|
|
|
NS_ASSERTION(IsOuterWindow(), "EnsureInnerWindow called on inner window");
|
|
|
|
// GetDocument forces inner window creation if there isn't one already
|
|
|
|
nsCOMPtr<nsIDOMDocument> doc;
|
|
|
|
GetDocument(getter_AddRefs(doc));
|
|
|
|
return GetCurrentInnerWindow();
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool IsInnerWindow() const
|
|
|
|
{
|
|
|
|
return mIsInnerWindow;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool IsOuterWindow() const
|
|
|
|
{
|
|
|
|
return !IsInnerWindow();
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual PRBool WouldReuseInnerWindow(nsIDocument *aNewDocument) = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the docshell in this window.
|
|
|
|
*/
|
|
|
|
nsIDocShell *GetDocShell()
|
|
|
|
{
|
|
|
|
if (mOuterWindow) {
|
|
|
|
return mOuterWindow->mDocShell;
|
|
|
|
}
|
|
|
|
|
|
|
|
return mDocShell;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set or unset the docshell in the window.
|
|
|
|
*/
|
|
|
|
virtual void SetDocShell(nsIDocShell *aDocShell) = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a new document in the window. Calling this method will in
|
|
|
|
* most cases create a new inner window. If this method is called on
|
|
|
|
* an inner window the call will be forewarded to the outer window,
|
|
|
|
* if the inner window is not the current inner window an
|
|
|
|
* NS_ERROR_NOT_AVAILABLE error code will be returned. This may be
|
|
|
|
* called with a pointer to the current document, in that case the
|
|
|
|
* document remains unchanged, but a new inner window will be
|
|
|
|
* created.
|
|
|
|
*/
|
|
|
|
virtual nsresult SetNewDocument(nsIDocument *aDocument,
|
2010-09-15 15:54:00 -07:00
|
|
|
nsISupports *aState,
|
|
|
|
PRBool aForceReuseInnerWindow) = 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the opener window. aOriginalOpener is true if and only if this is the
|
|
|
|
* original opener for the window. That is, it can only be true at most once
|
|
|
|
* during the life cycle of a window, and then only the first time
|
|
|
|
* SetOpenerWindow is called. It might never be true, of course, if the
|
|
|
|
* window does not have an opener when it's created.
|
|
|
|
*/
|
|
|
|
virtual void SetOpenerWindow(nsIDOMWindowInternal *aOpener,
|
|
|
|
PRBool aOriginalOpener) = 0;
|
|
|
|
|
|
|
|
virtual void EnsureSizeUpToDate() = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Callback for notifying a window about a modal dialog being
|
|
|
|
* opened/closed with the window as a parent.
|
|
|
|
*/
|
2011-02-01 19:23:00 -08:00
|
|
|
virtual nsIDOMWindow *EnterModalState() = 0;
|
|
|
|
virtual void LeaveModalState(nsIDOMWindow *) = 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-01-28 10:35:20 -08:00
|
|
|
virtual PRBool CanClose() = 0;
|
|
|
|
virtual nsresult ForceClose() = 0;
|
|
|
|
|
2007-07-26 10:52:26 -07:00
|
|
|
PRBool IsModalContentWindow() const
|
|
|
|
{
|
|
|
|
return mIsModalContentWindow;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-10-15 14:06:32 -07:00
|
|
|
/**
|
|
|
|
* Call this to indicate that some node (this window, its document,
|
|
|
|
* or content in that document) has a paint event listener.
|
|
|
|
*/
|
|
|
|
void SetHasPaintEventListeners()
|
|
|
|
{
|
|
|
|
mMayHavePaintEventListener = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call this to check whether some node (this window, its document,
|
|
|
|
* or content in that document) has a paint event listener.
|
|
|
|
*/
|
|
|
|
PRBool HasPaintEventListeners()
|
|
|
|
{
|
|
|
|
return mMayHavePaintEventListener;
|
|
|
|
}
|
|
|
|
|
2010-08-02 06:34:54 -07:00
|
|
|
/**
|
|
|
|
* Call this to indicate that some node (this window, its document,
|
|
|
|
* or content in that document) has a touch event listener.
|
|
|
|
*/
|
|
|
|
void SetHasTouchEventListeners()
|
|
|
|
{
|
|
|
|
mMayHaveTouchEventListener = PR_TRUE;
|
|
|
|
MaybeUpdateTouchState();
|
|
|
|
}
|
|
|
|
|
2011-04-26 05:31:21 -07:00
|
|
|
PRBool HasTouchEventListeners()
|
|
|
|
{
|
|
|
|
return mMayHaveTouchEventListener;
|
|
|
|
}
|
|
|
|
|
2010-08-25 06:10:00 -07:00
|
|
|
/**
|
|
|
|
* Call this to check whether some node (this window, its document,
|
|
|
|
* or content in that document) has a MozAudioAvailable event listener.
|
|
|
|
*/
|
|
|
|
PRBool HasAudioAvailableEventListeners()
|
|
|
|
{
|
|
|
|
return mMayHaveAudioAvailableEventListener;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call this to indicate that some node (this window, its document,
|
|
|
|
* or content in that document) has a MozAudioAvailable event listener.
|
|
|
|
*/
|
|
|
|
void SetHasAudioAvailableEventListeners()
|
|
|
|
{
|
|
|
|
mMayHaveAudioAvailableEventListener = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2007-10-31 15:52:11 -07:00
|
|
|
/**
|
2009-06-30 15:55:16 -07:00
|
|
|
* Initialize window.java and window.Packages.
|
2007-10-31 15:52:11 -07:00
|
|
|
*/
|
|
|
|
virtual void InitJavaProperties() = 0;
|
|
|
|
|
2008-02-12 20:17:18 -08:00
|
|
|
virtual void* GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey) = 0;
|
|
|
|
virtual void CacheXBLPrototypeHandler(nsXBLPrototypeHandler* aKey,
|
|
|
|
nsScriptObjectHolder& aHandler) = 0;
|
|
|
|
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 11:00:39 -07:00
|
|
|
/*
|
|
|
|
* Get and set the currently focused element within the document. If
|
|
|
|
* aNeedsFocus is true, then set mNeedsFocus to true to indicate that a
|
|
|
|
* document focus event is needed.
|
|
|
|
*
|
|
|
|
* DO NOT CALL EITHER OF THESE METHODS DIRECTLY. USE THE FOCUS MANAGER
|
|
|
|
* INSTEAD.
|
|
|
|
*/
|
2010-04-27 02:58:58 -07:00
|
|
|
nsIContent* GetFocusedNode()
|
|
|
|
{
|
|
|
|
if (IsOuterWindow()) {
|
|
|
|
return mInnerWindow ? mInnerWindow->mFocusedNode.get() : nsnull;
|
|
|
|
}
|
|
|
|
return mFocusedNode;
|
|
|
|
}
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 11:00:39 -07:00
|
|
|
virtual void SetFocusedNode(nsIContent* aNode,
|
|
|
|
PRUint32 aFocusMethod = 0,
|
|
|
|
PRBool aNeedsFocus = PR_FALSE) = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieves the method that was used to focus the current node.
|
|
|
|
*/
|
|
|
|
virtual PRUint32 GetFocusMethod() = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tells the window that it now has focus or has lost focus, based on the
|
|
|
|
* state of aFocus. If this method returns true, then the document loaded
|
|
|
|
* in the window has never received a focus event and expects to receive
|
|
|
|
* one. If false is returned, the document has received a focus event before
|
|
|
|
* and should only receive one if the window is being focused.
|
|
|
|
*
|
|
|
|
* aFocusMethod may be set to one of the focus method constants in
|
|
|
|
* nsIFocusManager to indicate how focus was set.
|
|
|
|
*/
|
|
|
|
virtual PRBool TakeFocus(PRBool aFocus, PRUint32 aFocusMethod) = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Indicates that the window may now accept a document focus event. This
|
|
|
|
* should be called once a document has been loaded into the window.
|
|
|
|
*/
|
|
|
|
virtual void SetReadyForFocus() = 0;
|
|
|
|
|
2010-04-21 07:53:42 -07:00
|
|
|
/**
|
|
|
|
* Whether the focused content within the window should show a focus ring.
|
|
|
|
*/
|
|
|
|
virtual PRBool ShouldShowFocusRing() = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the keyboard indicator state for accelerators and focus rings.
|
|
|
|
*/
|
|
|
|
virtual void SetKeyboardIndicators(UIStateChangeType aShowAccelerators,
|
|
|
|
UIStateChangeType aShowFocusRings) = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the keyboard indicator state for accelerators and focus rings.
|
|
|
|
*/
|
|
|
|
virtual void GetKeyboardIndicators(PRBool* aShowAccelerators,
|
|
|
|
PRBool* aShowFocusRings) = 0;
|
|
|
|
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 11:00:39 -07:00
|
|
|
/**
|
|
|
|
* Indicates that the page in the window has been hidden. This is used to
|
|
|
|
* reset the focus state.
|
|
|
|
*/
|
|
|
|
virtual void PageHidden() = 0;
|
|
|
|
|
2009-06-26 10:16:50 -07:00
|
|
|
/**
|
2010-11-29 11:13:12 -08:00
|
|
|
* Instructs this window to asynchronously dispatch a hashchange event. This
|
|
|
|
* method must be called on an inner window.
|
2009-06-26 10:16:50 -07:00
|
|
|
*/
|
2011-03-31 13:30:32 -07:00
|
|
|
virtual nsresult DispatchAsyncHashchange(nsIURI *aOldURI,
|
|
|
|
nsIURI *aNewURI) = 0;
|
2009-06-26 10:16:50 -07:00
|
|
|
|
2009-09-01 09:45:05 -07:00
|
|
|
/**
|
|
|
|
* Instructs this window to synchronously dispatch a popState event.
|
|
|
|
*/
|
2011-02-28 23:08:56 -08:00
|
|
|
virtual nsresult DispatchSyncPopState() = 0;
|
2009-08-21 07:42:37 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Tell this window that there is an observer for orientation changes
|
|
|
|
*/
|
|
|
|
virtual void SetHasOrientationEventListener() = 0;
|
|
|
|
|
2009-10-06 17:09:16 -07:00
|
|
|
/**
|
|
|
|
* Set a arguments for this window. This will be set on the window
|
|
|
|
* right away (if there's an existing document) and it will also be
|
|
|
|
* installed on the window when the next document is loaded. Each
|
|
|
|
* language impl is responsible for converting to an array of args
|
|
|
|
* as appropriate for that language.
|
|
|
|
*/
|
|
|
|
virtual nsresult SetArguments(nsIArray *aArguments, nsIPrincipal *aOrigin) = 0;
|
|
|
|
|
2010-09-09 15:15:40 -07:00
|
|
|
/**
|
|
|
|
* NOTE! This function *will* be called on multiple threads so the
|
|
|
|
* implementation must not do any AddRef/Release or other actions that will
|
|
|
|
* mutate internal state.
|
|
|
|
*/
|
|
|
|
virtual PRUint32 GetSerial() = 0;
|
|
|
|
|
2010-10-20 17:24:15 -07:00
|
|
|
/**
|
|
|
|
* Return the window id of this window
|
|
|
|
*/
|
|
|
|
PRUint64 WindowID() const { return mWindowID; }
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
protected:
|
|
|
|
// The nsPIDOMWindow constructor. The aOuterWindow argument should
|
|
|
|
// be null if and only if the created window itself is an outer
|
|
|
|
// window. In all other cases aOuterWindow should be the outer
|
|
|
|
// window for the inner window that is being created.
|
2010-04-27 02:58:58 -07:00
|
|
|
nsPIDOMWindow(nsPIDOMWindow *aOuterWindow);
|
|
|
|
|
|
|
|
~nsPIDOMWindow();
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-08-07 16:15:40 -07:00
|
|
|
void SetChromeEventHandlerInternal(nsPIDOMEventTarget* aChromeEventHandler) {
|
|
|
|
mChromeEventHandler = aChromeEventHandler;
|
2010-06-16 04:42:42 -07:00
|
|
|
// mParentTarget will be set when the next event is dispatched.
|
|
|
|
mParentTarget = nsnull;
|
2008-08-07 16:15:40 -07:00
|
|
|
}
|
|
|
|
|
2010-06-16 04:43:36 -07:00
|
|
|
virtual void UpdateParentTarget() = 0;
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// These two variables are special in that they're set to the same
|
|
|
|
// value on both the outer window and the current inner window. Make
|
|
|
|
// sure you keep them in sync!
|
|
|
|
nsCOMPtr<nsPIDOMEventTarget> mChromeEventHandler; // strong
|
|
|
|
nsCOMPtr<nsIDOMDocument> mDocument; // strong
|
|
|
|
|
2010-06-16 04:42:42 -07:00
|
|
|
nsCOMPtr<nsPIDOMEventTarget> mParentTarget; // strong
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// These members are only used on outer windows.
|
2009-04-10 09:06:34 -07:00
|
|
|
nsCOMPtr<nsIDOMElement> mFrameElement;
|
2007-03-22 10:30:00 -07:00
|
|
|
nsIDocShell *mDocShell; // Weak Reference
|
|
|
|
|
|
|
|
PRUint32 mModalStateDepth;
|
|
|
|
|
|
|
|
// These variables are only used on inner windows.
|
|
|
|
nsTimeout *mRunningTimeout;
|
|
|
|
|
|
|
|
PRUint32 mMutationBits;
|
|
|
|
|
|
|
|
PRPackedBool mIsDocumentLoaded;
|
|
|
|
PRPackedBool mIsHandlingResizeEvent;
|
|
|
|
PRPackedBool mIsInnerWindow;
|
2008-10-15 14:06:32 -07:00
|
|
|
PRPackedBool mMayHavePaintEventListener;
|
2010-08-02 06:34:54 -07:00
|
|
|
PRPackedBool mMayHaveTouchEventListener;
|
2010-08-25 06:10:00 -07:00
|
|
|
PRPackedBool mMayHaveAudioAvailableEventListener;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-07-26 10:52:26 -07:00
|
|
|
// This variable is used on both inner and outer windows (and they
|
|
|
|
// should match).
|
|
|
|
PRPackedBool mIsModalContentWindow;
|
|
|
|
|
2010-03-17 10:10:57 -07:00
|
|
|
// Tracks activation state that's used for :-moz-window-inactive.
|
2011-03-25 18:05:55 -07:00
|
|
|
// Only used on outer windows.
|
2010-03-17 10:10:57 -07:00
|
|
|
PRPackedBool mIsActive;
|
|
|
|
|
2011-03-25 18:05:55 -07:00
|
|
|
// Tracks whether our docshell is active. If it is, mIsBackground
|
|
|
|
// is false. Too bad we have so many different concepts of
|
|
|
|
// "active". Only used on outer windows.
|
|
|
|
PRPackedBool mIsBackground;
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
// And these are the references between inner and outer windows.
|
|
|
|
nsPIDOMWindow *mInnerWindow;
|
2010-10-12 15:03:15 -07:00
|
|
|
nsCOMPtr<nsPIDOMWindow> mOuterWindow;
|
2010-04-27 02:58:58 -07:00
|
|
|
|
|
|
|
// the element within the document that is currently focused when this
|
|
|
|
// window is active
|
|
|
|
nsCOMPtr<nsIContent> mFocusedNode;
|
2010-10-20 17:24:15 -07:00
|
|
|
|
|
|
|
// A unique (as long as our 64-bit counter doesn't roll over) id for
|
|
|
|
// this window.
|
|
|
|
PRUint64 mWindowID;
|
2010-11-23 00:50:56 -08:00
|
|
|
|
|
|
|
// This is only used by the inner window. Set to true once we've sent
|
|
|
|
// the (chrome|content)-document-global-created notification.
|
|
|
|
PRPackedBool mHasNotifiedGlobalCreated;
|
2007-03-22 10:30:00 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
NS_DEFINE_STATIC_IID_ACCESSOR(nsPIDOMWindow, NS_PIDOMWINDOW_IID)
|
|
|
|
|
|
|
|
#ifdef _IMPL_NS_LAYOUT
|
|
|
|
PopupControlState
|
|
|
|
PushPopupControlState(PopupControlState aState, PRBool aForce);
|
|
|
|
|
|
|
|
void
|
|
|
|
PopPopupControlState(PopupControlState aState);
|
|
|
|
|
|
|
|
#define NS_AUTO_POPUP_STATE_PUSHER nsAutoPopupStatePusherInternal
|
|
|
|
#else
|
|
|
|
#define NS_AUTO_POPUP_STATE_PUSHER nsAutoPopupStatePusherExternal
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Helper class that helps with pushing and popping popup control
|
|
|
|
// state. Note that this class looks different from within code that's
|
|
|
|
// part of the layout library than it does in code outside the layout
|
|
|
|
// library. We give the two object layouts different names so the symbols
|
|
|
|
// don't conflict, but code should always use the name
|
|
|
|
// |nsAutoPopupStatePusher|.
|
|
|
|
class NS_AUTO_POPUP_STATE_PUSHER
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
#ifdef _IMPL_NS_LAYOUT
|
|
|
|
NS_AUTO_POPUP_STATE_PUSHER(PopupControlState aState, PRBool aForce = PR_FALSE)
|
|
|
|
: mOldState(::PushPopupControlState(aState, aForce))
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
~NS_AUTO_POPUP_STATE_PUSHER()
|
|
|
|
{
|
|
|
|
PopPopupControlState(mOldState);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
NS_AUTO_POPUP_STATE_PUSHER(nsPIDOMWindow *aWindow, PopupControlState aState)
|
|
|
|
: mWindow(aWindow), mOldState(openAbused)
|
|
|
|
{
|
|
|
|
if (aWindow) {
|
|
|
|
mOldState = aWindow->PushPopupControlState(aState, PR_FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
~NS_AUTO_POPUP_STATE_PUSHER()
|
|
|
|
{
|
|
|
|
if (mWindow) {
|
|
|
|
mWindow->PopPopupControlState(mOldState);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
protected:
|
|
|
|
#ifndef _IMPL_NS_LAYOUT
|
|
|
|
nsCOMPtr<nsPIDOMWindow> mWindow;
|
|
|
|
#endif
|
|
|
|
PopupControlState mOldState;
|
|
|
|
|
|
|
|
private:
|
|
|
|
// Hide so that this class can only be stack-allocated
|
|
|
|
static void* operator new(size_t /*size*/) CPP_THROW_NEW { return nsnull; }
|
|
|
|
static void operator delete(void* /*memory*/) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
#define nsAutoPopupStatePusher NS_AUTO_POPUP_STATE_PUSHER
|
|
|
|
|
|
|
|
#endif // nsPIDOMWindow_h__
|