gecko/dom/interfaces/base/nsIDOMWindowUtils.idl

832 lines
32 KiB
Plaintext

/* -*- Mode: IDL; 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.org code.
*
* The Initial Developer of the Original Code is
* Mozilla.org
* Portions created by the Initial Developer are Copyright (C) 2004
* 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 ***** */
#include "nsISupports.idl"
/**
* nsIDOMWindowUtils is intended for infrequently-used methods related
* to the current nsIDOMWindow. Some of the methods may require
* elevated privileges; the method implementations should contain the
* necessary security checks. Access this interface by calling
* getInterface on a DOMWindow.
*/
%{C++
#include "nsColor.h"
#include "nsRect.h"
#include "gfxContext.h"
%}
[ref] native nsConstRect(const nsRect);
native nscolor(nscolor);
[ptr] native gfxContext(gfxContext);
interface nsICycleCollectorListener;
interface nsIDOMNode;
interface nsIDOMNodeList;
interface nsIDOMElement;
interface nsIDOMHTMLCanvasElement;
interface nsIDOMEvent;
interface nsITransferable;
interface nsIQueryContentEventResult;
interface nsIDOMWindow;
[scriptable, uuid(85fa978a-fc91-4513-9f11-8911e671577f)]
interface nsIDOMWindowUtils : nsISupports {
/**
* Image animation mode of the window. When this attribute's value
* is changed, the implementation should set all images in the window
* to the given value. That is, when set to kDontAnimMode, all images
* will stop animating. The attribute's value must be one of the
* animationMode values from imgIContainer.
* @note Images may individually override the window's setting after
* the window's mode is set. Therefore images given different modes
* since the last setting of the window's mode may behave
* out of line with the window's overall mode.
* @note The attribute's value is the window's overall mode. It may
* for example continue to report kDontAnimMode after all images
* have subsequently been individually animated.
* @note Only images immediately in this window are affected;
* this is not recursive to subwindows.
* @see imgIContainer
*/
attribute unsigned short imageAnimationMode;
/**
* Whether the charset of the window's current document has been forced by
* the user.
* Cannot be accessed from unprivileged context (not content-accessible)
*/
readonly attribute boolean docCharsetIsForced;
/**
* Get current cursor type from this window
* @return the current value of nsCursor
*/
short getCursorType();
/**
* Function to get metadata associated with the window's current document
* @param aName the name of the metadata. This should be all lowercase.
* @return the value of the metadata, or the empty string if it's not set
*
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*/
AString getDocumentMetadata(in AString aName);
/**
* Force an immediate redraw of this window. The parameter specifies
* the number of times to redraw, and the return value is the length,
* in milliseconds, that the redraws took. If aCount is not specified
* or is 0, it is taken to be 1.
*/
unsigned long redraw([optional] in unsigned long aCount);
/**
* Set the CSS viewport to be |widthPx| x |heightPx| in units of CSS
* pixels, regardless of the size of the enclosing widget/view.
* This will trigger reflow.
*
* The caller of this method must have UniversalXPConnect
* privileges.
*/
void setCSSViewport(in float aWidthPx, in float aHeightPx);
/**
* Set the "displayport" to be <xPx, yPx, widthPx, heightPx> in
* units of CSS pixels, regardless of the size of the enclosing
* widget/view. This will *not* trigger reflow.
*
* <x, y> is relative to the top-left of the CSS viewport. This
* means that the pixels rendered to the displayport take scrolling
* into account, for example.
*
* The displayport will be used as the window's visible region for
* the purposes of invalidation and painting. The displayport can
* approximately be thought of as a "persistent" drawWindow()
* (albeit with coordinates relative to the CSS viewport): the
* bounds are remembered by the platform, and layer pixels are
* retained and updated inside the viewport bounds.
*
* It's legal to set a displayport that extends beyond the CSS
* viewport in any direction (left/right/top/bottom).
*
* It's also legal to set a displayport that extends beyond the
* document's bounds. The value of the pixels rendered outside the
* document bounds is not yet defined.
*
* The caller of this method must have UniversalXPConnect
* privileges.
*/
void setDisplayPort(in float aXPx, in float aYPx,
in float aWidthPx, in float aHeightPx);
/**
* Get/set the resolution at which rescalable web content is drawn.
* Currently this is only (some) thebes content.
*
* Setting a new resolution does *not* trigger reflow. This API is
* entirely separate from textZoom and fullZoom; a resolution scale
* can be applied together with both textZoom and fullZoom.
*
* The effect of is API for gfx code to allocate more or fewer
* pixels for rescalable content by a factor of |resolution| in
* either or both dimensions. setResolution() together with
* setDisplayport() can be used to implement a non-reflowing
* scale-zoom in concert with another entity that can draw with a
* scale. For example, to scale a content |window| inside a
* <browser> by a factor of 2.0
*
* window.setDisplayport(x, y, oldW / 2.0, oldH / 2.0);
* window.setResolution(2.0, 2.0);
* // elsewhere
* browser.setViewportScale(2.0, 2.0);
*
* The caller of this method must have UniversalXPConnect
* privileges.
*/
void setResolution(in float aXResolution, in float aYResolution);
/** Synthesize a mouse event. The event types supported are:
* mousedown, mouseup, mousemove, mouseover, mouseout, contextmenu
*
* Events are sent in coordinates offset by aX and aY from the window.
*
* Note that additional events may be fired as a result of this call. For
* instance, typically a click event will be fired as a result of a
* mousedown and mouseup in sequence.
*
* Normally at this level of events, the mouseover and mouseout events are
* only fired when the window is entered or exited. For inter-element
* mouseover and mouseout events, a movemove event fired on the new element
* should be sufficient to generate the correct over and out events as well.
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*
* The event is dispatched via the toplevel window, so it could go to any
* window under the toplevel window, in some cases it could never reach this
* window at all.
*
* @param aType event type
* @param aX x offset in CSS pixels
* @param aY y offset in CSS pixels
* @param aButton button to synthesize
* @param aClickCount number of clicks that have been performed
* @param aModifiers modifiers pressed, using constants defined in nsIDOMNSEvent
* @param aIgnoreRootScrollFrame whether the event should ignore viewport bounds
* during dispatch
*/
void sendMouseEvent(in AString aType,
in float aX,
in float aY,
in long aButton,
in long aClickCount,
in long aModifiers,
[optional] in boolean aIgnoreRootScrollFrame);
/** The same as sendMouseEvent but ensures that the event is dispatched to
* this DOM window or one of its children.
*/
void sendMouseEventToWindow(in AString aType,
in float aX,
in float aY,
in long aButton,
in long aClickCount,
in long aModifiers,
[optional] in boolean aIgnoreRootScrollFrame);
/** Synthesize a mouse scroll event for a window. The event types supported
* are:
* DOMMouseScroll
* MozMousePixelScroll
*
* Events are sent in coordinates offset by aX and aY from the window.
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*
* @param aType event type
* @param aX x offset in CSS pixels
* @param aY y offset in CSS pixels
* @param aButton button to synthesize
* @param aScrollFlags flag bits --- see nsMouseScrollFlags in nsGUIEvent.h
* @param aDelta the direction and amount to scroll (in lines or pixels,
* depending on the event type)
* @param aModifiers modifiers pressed, using constants defined in nsIDOMNSEvent
*/
void sendMouseScrollEvent(in AString aType,
in float aX,
in float aY,
in long aButton,
in long aScrollFlags,
in long aDelta,
in long aModifiers);
/**
* Synthesize a key event to the window. The event types supported are:
* keydown, keyup, keypress
*
* Key events generally end up being sent to the focused node.
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*
* @param aType event type
* @param aKeyCode key code
* @param aCharCode character code
* @param aModifiers modifiers pressed, using constants defined in nsIDOMNSEvent
* @param aPreventDefault if true, preventDefault() the event before dispatch
*
* @return false if the event had preventDefault() called on it,
* true otherwise. In other words, true if and only if the
* default action was taken.
*/
boolean sendKeyEvent(in AString aType,
in long aKeyCode,
in long aCharCode,
in long aModifiers,
[optional] in boolean aPreventDefault);
/**
* See nsIWidget::SynthesizeNativeKeyEvent
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*/
void sendNativeKeyEvent(in long aNativeKeyboardLayout,
in long aNativeKeyCode,
in long aModifierFlags,
in AString aCharacters,
in AString aUnmodifiedCharacters);
/**
* See nsIWidget::SynthesizeNativeMouseEvent
*
* Will be called on the widget that contains aElement.
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*/
void sendNativeMouseEvent(in long aScreenX,
in long aScreenY,
in long aNativeMessage,
in long aModifierFlags,
in nsIDOMElement aElement);
/**
* See nsIWidget::ActivateNativeMenuItemAt
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*/
void activateNativeMenuItemAt(in AString indexString);
/**
* See nsIWidget::ForceUpdateNativeMenuAt
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*/
void forceUpdateNativeMenuAt(in AString indexString);
/**
* Focus the element aElement. The element should be in the same document
* that the window is displaying. Pass null to blur the element, if any,
* that currently has focus, and focus the document.
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*
* @param aElement the element to focus
*
* Do not use this method. Just use element.focus if available or
* nsIFocusManager::SetFocus instead.
*
*/
void focus(in nsIDOMElement aElement);
/**
* Force a garbage collection followed by a cycle collection.
*
* Will throw a DOM security error if called without UniversalXPConnect
* privileges in non-debug builds. Available to all callers in debug builds.
*
* @param aListener listener that receives information about the CC graph
* (see @mozilla.org/cycle-collector-logger;1 for a logger
* component)
*/
void garbageCollect([optional] in nsICycleCollectorListener aListener);
/**
* Force processing of any queued paints
*/
void processUpdates();
/** Synthesize a simple gesture event for a window. The event types
* supported are: MozSwipeGesture, MozMagnifyGestureStart,
* MozMagnifyGestureUpdate, MozMagnifyGesture, MozRotateGestureStart,
* MozRotateGestureUpdate, MozRotateGesture, MozPressTapGesture, and
* MozTapGesture.
*
* Cannot be accessed from unprivileged context (not
* content-accessible) Will throw a DOM security error if called
* without UniversalXPConnect privileges.
*
* @param aType event type
* @param aX x offset in CSS pixels
* @param aY y offset in CSS pixels
* @param aDirection direction, using constants defined in nsIDOMSimpleGestureEvent
* @param aDelta amount of magnification or rotation for magnify and rotation events
* @param aModifiers modifiers pressed, using constants defined in nsIDOMNSEvent
*/
void sendSimpleGestureEvent(in AString aType,
in float aX,
in float aY,
in unsigned long aDirection,
in double aDelta,
in long aModifiers);
/**
* Retrieve the element at point aX, aY in the window's document.
*
* @param aIgnoreRootScrollFrame whether or not to ignore the root scroll
* frame when retrieving the element. If false, this method returns
* null for coordinates outside of the viewport.
* @param aFlushLayout flushes layout if true. Otherwise, no flush occurs.
*/
nsIDOMElement elementFromPoint(in float aX,
in float aY,
in boolean aIgnoreRootScrollFrame,
in boolean aFlushLayout);
/**
* Retrieve all nodes that intersect a rect in the window's document.
*
* @param aX x reference for the rectangle in CSS pixels
* @param aY y reference for the rectangle in CSS pixels
* @param aTopSize How much to expand up the rectangle
* @param aRightSize How much to expand right the rectangle
* @param aBottomSize How much to expand down the rectangle
* @param aLeftSize How much to expand left the rectangle
* @param aIgnoreRootScrollFrame whether or not to ignore the root scroll
* frame when retrieving the element. If false, this method returns
* null for coordinates outside of the viewport.
* @param aFlushLayout flushes layout if true. Otherwise, no flush occurs.
*/
nsIDOMNodeList nodesFromRect(in float aX,
in float aY,
in float aTopSize,
in float aRightSize,
in float aBottomSize,
in float aLeftSize,
in boolean aIgnoreRootScrollFrame,
in boolean aFlushLayout);
/**
* Compare the two canvases, returning the number of differing pixels and
* the maximum difference in a channel. This will throw an error if
* the dimensions of the two canvases are different.
*
* This method requires UniversalXPConnect privileges.
*/
PRUint32 compareCanvases(in nsIDOMHTMLCanvasElement aCanvas1,
in nsIDOMHTMLCanvasElement aCanvas2,
out unsigned long aMaxDifference);
/**
* Returns true if a MozAfterPaint event has been queued but not yet
* fired.
*/
readonly attribute boolean isMozAfterPaintPending;
/**
* Suppresses/unsuppresses user initiated event handling in window's document
* and subdocuments.
*
* @throw NS_ERROR_DOM_SECURITY_ERR if called without UniversalXPConnect
* privileges and NS_ERROR_FAILURE if window doesn't have a document.
*/
void suppressEventHandling(in boolean aSuppress);
void clearMozAfterPaintEvents();
/**
* Disable or enable non synthetic test mouse events on *all* windows.
*
* Cannot be accessed from unprivileged context (not content-accessible).
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*
* @param aDisable If true, disable all non synthetic test mouse events
* on all windows. Otherwise, enable them.
*/
void disableNonTestMouseEvents(in boolean aDisable);
/**
* Returns the scroll position of the window's currently loaded document.
*
* @param aFlushLayout flushes layout if true. Otherwise, no flush occurs.
* @see nsIDOMWindow::scrollX/Y
*/
void getScrollXY(in boolean aFlushLayout, out long aScrollX, out long aScrollY);
/**
* Get IME open state. TRUE means 'Open', otherwise, 'Close'.
* This property works only when IMEEnabled is IME_STATUS_ENABLED.
*/
readonly attribute boolean IMEIsOpen;
/**
* WARNING: These values must be same as nsIWidget's values.
*/
/**
* DISABLED means users cannot use IME completely.
* Note that this state is *not* same as |ime-mode: disabled;|.
*/
const unsigned long IME_STATUS_DISABLED = 0;
/**
* ENABLED means users can use all functions of IME. This state is same as
* |ime-mode: normal;|.
*/
const unsigned long IME_STATUS_ENABLED = 1;
/**
* PASSWORD means users cannot use most functions of IME. But on GTK2,
* users can use "Simple IM" which only supports dead key inputting.
* The behavior is same as the behavior of the native password field.
* This state is same as |ime-mode: disabled;|.
*/
const unsigned long IME_STATUS_PASSWORD = 2;
/**
* PLUGIN means a plug-in has focus. At this time we should not touch to
* controlling the IME state.
*/
const unsigned long IME_STATUS_PLUGIN = 3;
/**
* Get IME status, see above IME_STATUS_* definitions.
*/
readonly attribute unsigned long IMEStatus;
/**
* Get the number of screen pixels per CSS pixel.
*/
readonly attribute float screenPixelsPerCSSPixel;
/**
* Dispatches aEvent via the nsIPresShell object of the window's document.
* The event is dispatched to aTarget, which should be an object
* which implements nsIContent interface (#element, #text, etc).
*
* Cannot be accessed from unprivileged context (not
* content-accessible) Will throw a DOM security error if called
* without UniversalXPConnect privileges.
*
* @note Event handlers won't get aEvent as parameter, but a similar event.
* Also, aEvent should not be reused.
*/
boolean dispatchDOMEventViaPresShell(in nsIDOMNode aTarget,
in nsIDOMEvent aEvent,
in boolean aTrusted);
/**
* Returns the real classname (possibly of the mostly-transparent security
* wrapper) of aObj.
*/
string getClassName(/*in JSObjectPtr aObj*/);
/**
* Generate a content command event.
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*
* @param aType Type of command content event to send. Can be one of "cut",
* "copy", "paste", "delete", "undo", "redo", or "pasteTransferable".
* @param aTransferable an instance of nsITransferable when aType is
* "pasteTransferable"
*/
void sendContentCommandEvent(in AString aType,
[optional] in nsITransferable aTransferable);
/**
* Synthesize a composition event to the window.
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*
* @param aType The event type: "compositionstart" or "compositionend".
*/
void sendCompositionEvent(in AString aType);
/**
* Synthesize a text event to the window.
*
* Cannot be accessed from unprivileged context (not content-accessible)
* Will throw a DOM security error if called without UniversalXPConnect
* privileges.
*
* Currently, this method doesn't support 4 or more clauses composition
* string.
*
* @param aCompositionString composition string
* @param a*ClauseLengh the length of nth clause, set 0 when you
* don't need second or third clause.
* @param a*ClauseAttr the attribute of nth clause, uese following
* const values.
* @param aCaretStart the caret position in the composition string,
* if you set negative value, this method don't
* set the caret position to the event.
* @param aCaretLength the caret length, if this is one or more,
* the caret will be wide caret, otherwise,
* it's collapsed.
* XXX nsEditor doesn't support wide caret yet.
*/
// NOTE: These values must be same to NS_TEXTRANGE_* in nsGUIEvent.h
const unsigned long COMPOSITION_ATTR_RAWINPUT = 0x02;
const unsigned long COMPOSITION_ATTR_SELECTEDRAWTEXT = 0x03;
const unsigned long COMPOSITION_ATTR_CONVERTEDTEXT = 0x04;
const unsigned long COMPOSITION_ATTR_SELECTEDCONVERTEDTEXT = 0x05;
void sendTextEvent(in AString aCompositionString,
in long aFirstClauseLength,
in unsigned long aFirstClauseAttr,
in long aSecondClauseLength,
in unsigned long aSecondClauseAttr,
in long aThirdClauseLength,
in unsigned long aThirdClauseAttr,
in long aCaretStart,
in long aCaretLength);
/**
* Synthesize a query content event.
*
* @param aType On of the following const values. And see also each comment
* for the other parameters and the result.
*/
nsIQueryContentEventResult sendQueryContentEvent(in unsigned long aType,
in unsigned long aOffset,
in unsigned long aLength,
in long aX,
in long aY);
// NOTE: following values are same as NS_QUERY_* in nsGUIEvent.h
/**
* QUERY_SELECTED_TEXT queries the first selection range's information.
*
* @param aOffset Not used.
* @param aLength Not used.
* @param aX Not used.
* @param aY Not used.
*
* @return offset, reversed and text properties of the result are available.
*/
const unsigned long QUERY_SELECTED_TEXT = 3200;
/**
* QUERY_TEXT_CONTENT queries the text at the specified range.
*
* @param aOffset The first character's offset. 0 is the first character.
* @param aLength The length of getting text. If the aLength is too long,
* the result text is shorter than this value.
* @param aX Not used.
* @param aY Not used.
*
* @return text property of the result is available.
*/
const unsigned long QUERY_TEXT_CONTENT = 3201;
/**
* QUERY_CARET_RECT queries the (collapsed) caret rect of the offset.
* If the actual caret is there at the specified offset, this returns the
* actual caret rect. Otherwise, this guesses the caret rect from the
* metrics of the text.
*
* @param aOffset The caret offset. 0 is the left side of the first
* caracter in LTR text.
* @param aLength Not used.
* @param aX Not used.
* @param aY Not used.
*
* @return left, top, width and height properties of the result are available.
* The left and the top properties are offset in the client area of
* the DOM window.
*/
const unsigned long QUERY_CARET_RECT = 3203;
/**
* QUERY_TEXT_RECT queries the specified text's rect.
*
* @param aOffset The first character's offset. 0 is the first character.
* @param aLength The length of getting text. If the aLength is too long,
* the extra length is ignored.
* @param aX Not used.
* @param aY Not used.
*
* @return left, top, width and height properties of the result are available.
* The left and the top properties are offset in the client area of
* the DOM window.
*/
const unsigned long QUERY_TEXT_RECT = 3204;
/**
* QUERY_TEXT_RECT queries the focused editor's rect.
*
* @param aOffset Not used.
* @param aLength Not used.
* @param aX Not used.
* @param aY Not used.
*
* @return left, top, width and height properties of the result are available.
*/
const unsigned long QUERY_EDITOR_RECT = 3205;
/**
* QUERY_CHARACTER_AT_POINT queries the character information at the
* specified point. The point is offset in the window.
* NOTE: If there are some panels at the point, this method send the query
* event to the panel's widget automatically.
*
* @param aOffset Not used.
* @param aLength Not used.
* @param aX X offset in the widget.
* @param aY Y offset in the widget.
*
* @return offset, notFound, left, top, width and height properties of the
* result are available.
*/
const unsigned long QUERY_CHARACTER_AT_POINT = 3208;
/**
* Synthesize a selection set event to the window.
*
* This sets the selection as the specified information.
*
* @param aOffset The caret offset of the selection start.
* @param aLength The length of the selection. If this is too long, the
* extra length is ignored.
* @param aReverse If true, the selection set from |aOffset + aLength| to
* |aOffset|. Otherwise, set from |aOffset| to
* |aOffset + aLength|.
* @return True, if succeeded. Otherwise, false.
*/
boolean sendSelectionSetEvent(in unsigned long aOffset,
in unsigned long aLength,
in boolean aReverse);
/**
* Perform the equivalent of:
* window.getComputedStyle(aElement, aPseudoElement).
* getPropertyValue(aPropertyName)
* except that, when the link whose presence in history is allowed to
* influence aElement's style is visited, get the value the property
* would have if allowed all properties to change as a result of
* :visited selectors (except for cases where getComputedStyle uses
* data from the frame).
*
* This is easier to implement than adding our property restrictions
* to this API, and is sufficient for the present testing
* requirements (which are essentially testing 'color').
*/
AString getVisitedDependentComputedStyle(in nsIDOMElement aElement,
in AString aPseudoElement,
in AString aPropertyName);
/**
* Returns the parent of obj.
*
* @param obj The JavaScript object whose parent is to be gotten.
* @return the parent.
*/
void getParent(/* obj */);
/**
* Get the id of the outer window of this window. This will never throw.
*/
readonly attribute unsigned long long outerWindowID;
/**
* Get the id of the current inner window of this window. If there
* is no current inner window, throws NS_ERROR_NOT_AVAILABLE.
*/
readonly attribute unsigned long long currentInnerWindowID;
/**
* Put the window into a state where scripts are frozen and events
* suppressed, for use when the window has launched a modal prompt.
*/
void enterModalState();
/**
* Resume normal window state, where scripts can run and events are
* delivered.
*/
void leaveModalState();
/**
* Is the window is in a modal state? [See enterModalState()]
*/
boolean isInModalState();
/**
* Suspend/resume timeouts on this window and its descendant windows.
*/
void suspendTimeouts();
void resumeTimeouts();
/**
* What type of layer manager the widget associated with this window is
* using. "Basic" is unaccelerated; other types are accelerated. Throws an
* error if there is no widget associated with this window.
*/
readonly attribute AString layerManagerType;
/**
* The DPI of the display
*/
readonly attribute float displayDPI;
/**
* Return the outer window with the given ID, if any. Can return null.
*/
nsIDOMWindow getOuterWindowWithId(in unsigned long long aOuterWindowID);
[noscript] void RenderDocument(in nsConstRect aRect,
in PRUint32 aFlags,
in nscolor aBackgroundColor,
in gfxContext aThebesContext);
/**
* Method for testing nsStyleAnimation::ComputeDistance.
*
* Returns the distance between the two values as reported by
* nsStyleAnimation::ComputeDistance for the given element and
* property.
*/
double computeAnimationDistance(in nsIDOMElement element,
in AString property,
in AString value1,
in AString value2);
};
[scriptable, uuid(3a0334aa-b9cc-4b32-9b6c-599cd4e40d5b)]
interface nsIDOMWindowUtils_MOZILLA_2_0_BRANCH : nsISupports {
/**
* Get the type of the currently focused html input, if any.
*/
readonly attribute string focusedInputType;
};