diff -r 000000000000 -r 6474c204b198 dom/interfaces/base/nsIDOMWindowUtils.idl
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/interfaces/base/nsIDOMWindowUtils.idl Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,1694 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#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"
+class gfxContext;
+class nsRect;
+%}
+
+[ref] native nsConstRect(const nsRect);
+native nscolor(nscolor);
+[ptr] native gfxContext(gfxContext);
+typedef unsigned long long nsViewID;
+
+interface nsICycleCollectorListener;
+interface nsIDOMNode;
+interface nsIDOMNodeList;
+interface nsIDOMElement;
+interface nsIDOMHTMLCanvasElement;
+interface nsIDOMEvent;
+interface nsITransferable;
+interface nsIQueryContentEventResult;
+interface nsIDOMWindow;
+interface nsIDOMBlob;
+interface nsIDOMFile;
+interface nsIFile;
+interface nsIDOMClientRect;
+interface nsIURI;
+interface nsIDOMEventTarget;
+interface nsIRunnable;
+interface nsICompositionStringSynthesizer;
+interface nsITranslationNodeList;
+
+[scriptable, uuid(d4ed34fc-9c07-4cef-b9e1-623794558db3)]
+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 chrome 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 chrome privileges.
+ */
+ void setCSSViewport(in float aWidthPx, in float aHeightPx);
+
+ /**
+ * Information retrieved from the tag.
+ * See nsContentUtils::GetViewportInfo for more information.
+ */
+ void getViewportInfo(in uint32_t aDisplayWidth, in uint32_t aDisplayHeight,
+ out double aDefaultZoom, out boolean aAllowZoom,
+ out double aMinZoom, out double aMaxZoom,
+ out uint32_t aWidth, out uint32_t aHeight,
+ out boolean aAutoSize);
+
+ /**
+ * For any scrollable element, this allows you to override the
+ * visible region and draw more than what is visible, which is
+ * useful for asynchronous drawing. The "displayport" will be
+ * in units of CSS pixels,
+ * regardless of the size of the enclosing container. This
+ * will *not* trigger reflow.
+ *
+ * For the root scroll area, pass in the root document element.
+ * For scrollable elements, pass in the container element (for
+ * instance, the element with overflow: scroll).
+ *
+ * is relative to the top-left of what would normally be
+ * the visible area of the element. This means that the pixels
+ * rendered to the displayport take scrolling into account,
+ * for example.
+ *
+ * It's legal to set a displayport that extends beyond the overflow
+ * area in any direction (left/right/top/bottom).
+ *
+ * It's also legal to set a displayport that extends beyond the
+ * area's bounds. No pixels are rendered outside the area bounds.
+ *
+ * The caller of this method must have chrome privileges.
+ *
+ * Calling this will always force a recomposite, so it should be
+ * avoided if at all possible. Client code should do checks before
+ * calling this so that duplicate sets are not made with the same
+ * displayport.
+ *
+ * aPriority is recorded along with the displayport rectangle. If this
+ * method is called with a lower priority than the current priority, the
+ * call is ignored.
+ */
+ void setDisplayPortForElement(in float aXPx, in float aYPx,
+ in float aWidthPx, in float aHeightPx,
+ in nsIDOMElement aElement,
+ in uint32_t aPriority);
+ /**
+ * An alternate way to represent a displayport rect as a set of margins and a
+ * base rect to apply those margins to. A consumer of pixels may ask for as
+ * many extra pixels as it would like in each direction. Layout then sets
+ * the base rect to the "visible rect" of the element, which is just the
+ * subrect of the element that is drawn (it does not take in account content
+ * covering the element).
+ *
+ * If both a displayport rect and displayport margins with corresponding base
+ * rect are set with the same priority then the margins will take precendence.
+ *
+ * Specifying an alignment value will ensure that after the base rect has
+ * been expanded by the displayport margins, it will be further expanded so
+ * that each edge is located at a multiple of the "alignment" value.
+ *
+ * Note that both the margin values and alignment are treated as values in
+ * LayerPixels. Refer to layout/base/Units.h for a description of this unit.
+ * The base rect values are in app units.
+ */
+ void setDisplayPortMarginsForElement(in float aLeftMargin,
+ in float aTopMargin,
+ in float aRightMargin,
+ in float aBottomMargin,
+ in uint32_t aAlignmentX,
+ in uint32_t aAlignmentY,
+ in nsIDOMElement aElement,
+ in uint32_t aPriority);
+
+ void setDisplayPortBaseForElement(in int32_t aX,
+ in int32_t aY,
+ in int32_t aWidth,
+ in int32_t aHeight,
+ in nsIDOMElement aElement);
+
+ /**
+ * When a display port is set, this allows a sub-section of that
+ * display port to be marked as 'critical'. In this scenario, the
+ * area outside of this rectangle may be rendered at a lower
+ * detail (for example, by reducing its resolution), or not rendered
+ * at all under some circumstances.
+ * This call will have no effect if a display port has not been set.
+ */
+ void setCriticalDisplayPortForElement(in float aXPx, in float aYPx,
+ in float aWidthPx, in float aHeightPx,
+ in nsIDOMElement aElement);
+
+ /**
+ * 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
+ * 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 chrome privileges.
+ */
+ void setResolution(in float aXResolution, in float aYResolution);
+
+ void getResolution(out float aXResolution, out float aYResolution);
+
+ /**
+ * Whether the resolution has been set by the user.
+ * This gives a way to check whether the provided resolution is the default
+ * value or restored from a previous session.
+ *
+ * Can only be accessed with chrome privileges.
+ */
+ readonly attribute boolean isResolutionSet;
+
+ /**
+ * Whether the next paint should be flagged as the first paint for a document.
+ * This gives a way to track the next paint that occurs after the flag is
+ * set. The flag gets cleared after the next paint.
+ *
+ * Can only be accessed with chrome privileges.
+ */
+ attribute boolean isFirstPaint;
+
+ void getPresShellId(out uint32_t aPresShellId);
+
+ /**
+ * Following modifiers are for sent*Event() except sendNative*Event().
+ * NOTE: MODIFIER_ALT, MODIFIER_CONTROL, MODIFIER_SHIFT and MODIFIER_META
+ * are must be same values as nsIDOMNSEvent::*_MASK for backward
+ * compatibility.
+ */
+ const long MODIFIER_ALT = 0x0001;
+ const long MODIFIER_CONTROL = 0x0002;
+ const long MODIFIER_SHIFT = 0x0004;
+ const long MODIFIER_META = 0x0008;
+ const long MODIFIER_ALTGRAPH = 0x0010;
+ const long MODIFIER_CAPSLOCK = 0x0020;
+ const long MODIFIER_FN = 0x0040;
+ const long MODIFIER_NUMLOCK = 0x0080;
+ const long MODIFIER_SCROLLLOCK = 0x0100;
+ const long MODIFIER_SYMBOLLOCK = 0x0200;
+ const long MODIFIER_OS = 0x0400;
+
+ /** Synthesize a mouse event. The event types supported are:
+ * mousedown, mouseup, mousemove, mouseover, mouseout, contextmenu,
+ * MozMouseHitTest
+ *
+ * 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 chrome 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 as MODIFIER_*
+ * @param aIgnoreRootScrollFrame whether the event should ignore viewport bounds
+ * during dispatch
+ * @param aPressure touch input pressure: 0.0 -> 1.0
+ * @param aInputSourceArg input source, see nsIDOMMouseEvent for values,
+ * defaults to mouse input.
+ * @param aIsSynthesized controls nsIDOMEvent.isSynthesized value
+ * that helps identifying test related events,
+ * defaults to true
+ *
+ * returns true if the page called prevent default on this event
+ */
+ [optional_argc]
+ boolean sendMouseEvent(in AString aType,
+ in float aX,
+ in float aY,
+ in long aButton,
+ in long aClickCount,
+ in long aModifiers,
+ [optional] in boolean aIgnoreRootScrollFrame,
+ [optional] in float aPressure,
+ [optional] in unsigned short aInputSourceArg,
+ [optional] in boolean aIsSynthesized);
+
+
+ /** Synthesize a pointer event. The event types supported are:
+ * pointerdown, pointerup, pointermove, pointerover, pointerout
+ *
+ * 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 pointerover and pointerout events are
+ * only fired when the window is entered or exited. For inter-element
+ * pointerover and pointerout 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 chrome 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 as MODIFIER_*
+ * @param aIgnoreRootScrollFrame whether the event should ignore viewport bounds
+ * during dispatch
+ * @param aPressure touch input pressure: 0.0 -> 1.0
+ * @param aInputSourceArg input source, see nsIDOMMouseEvent for values,
+ * defaults to mouse input.
+ * @param aPointerId A unique identifier for the pointer causing the event. default is 0
+ * @param aWidth The width (magnitude on the X axis), default is 0
+ * @param aHeight The height (magnitude on the Y axis), default is 0
+ * @param aTilt The plane angle between the Y-Z plane
+ * and the plane containing both the transducer (e.g. pen stylus) axis and the Y axis. default is 0
+ * @param aTiltX The plane angle between the X-Z plane
+ * and the plane containing both the transducer (e.g. pen stylus) axis and the X axis. default is 0
+ * @param aIsPrimary Indicates if the pointer represents the primary pointer of this pointer type.
+ * @param aIsSynthesized controls nsIDOMEvent.isSynthesized value
+ * that helps identifying test related events,
+ * defaults to true
+ *
+ * returns true if the page called prevent default on this event
+ */
+
+ [optional_argc]
+ boolean sendPointerEvent(in AString aType,
+ in float aX,
+ in float aY,
+ in long aButton,
+ in long aClickCount,
+ in long aModifiers,
+ [optional] in boolean aIgnoreRootScrollFrame,
+ [optional] in float aPressure,
+ [optional] in unsigned short aInputSourceArg,
+ [optional] in long aPointerId,
+ [optional] in long aWidth,
+ [optional] in long aHeight,
+ [optional] in long tiltX,
+ [optional] in long tiltY,
+ [optional] in boolean aIsPrimary,
+ [optional] in boolean aIsSynthesized);
+
+ /** Synthesize a touch event. The event types supported are:
+ * touchstart, touchend, touchmove, and touchcancel
+ *
+ * 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 chrome 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 xs array of offsets in CSS pixels for each touch to be sent
+ * @param ys array of offsets in CSS pixels for each touch to be sent
+ * @param rxs array of radii in CSS pixels for each touch to be sent
+ * @param rys array of radii in CSS pixels for each touch to be sent
+ * @param rotationAngles array of angles in degrees for each touch to be sent
+ * @param forces array of forces (floats from 0 to 1) for each touch to be sent
+ * @param count number of touches in this set
+ * @param aModifiers modifiers pressed, using constants defined as MODIFIER_*
+ * @param aIgnoreRootScrollFrame whether the event should ignore viewport bounds
+ * during dispatch
+ *
+ * returns true if the page called prevent default on this touch event
+ */
+ boolean sendTouchEvent(in AString aType,
+ [array, size_is(count)] in uint32_t aIdentifiers,
+ [array, size_is(count)] in int32_t aXs,
+ [array, size_is(count)] in int32_t aYs,
+ [array, size_is(count)] in uint32_t aRxs,
+ [array, size_is(count)] in uint32_t aRys,
+ [array, size_is(count)] in float aRotationAngles,
+ [array, size_is(count)] in float aForces,
+ in uint32_t count,
+ 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.
+ */
+ [optional_argc]
+ void sendMouseEventToWindow(in AString aType,
+ in float aX,
+ in float aY,
+ in long aButton,
+ in long aClickCount,
+ in long aModifiers,
+ [optional] in boolean aIgnoreRootScrollFrame,
+ [optional] in float aPressure,
+ [optional] in unsigned short aInputSourceArg,
+ [optional] in boolean aIsSynthesized);
+
+ /** The same as sendTouchEvent but ensures that the event is dispatched to
+ * this DOM window or one of its children.
+ */
+ boolean sendTouchEventToWindow(in AString aType,
+ [array, size_is(count)] in uint32_t aIdentifiers,
+ [array, size_is(count)] in int32_t aXs,
+ [array, size_is(count)] in int32_t aYs,
+ [array, size_is(count)] in uint32_t aRxs,
+ [array, size_is(count)] in uint32_t aRys,
+ [array, size_is(count)] in float aRotationAngles,
+ [array, size_is(count)] in float aForces,
+ in uint32_t count,
+ in long aModifiers,
+ [optional] in boolean aIgnoreRootScrollFrame);
+
+ /** Synthesize a wheel event for a window. The event types supported is only
+ * wheel.
+ *
+ * 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 chrome privileges.
+ *
+ * @param aX x offset in CSS pixels
+ * @param aY y offset in CSS pixels
+ * @param aDeltaX deltaX value.
+ * @param aDeltaY deltaY value.
+ * @param aDeltaZ deltaZ value.
+ * @param aDeltaMode deltaMode value which must be one of
+ * nsIDOMWheelEvent::DOM_DELTA_*.
+ * @param aModifiers modifiers pressed, using constants defined as
+ * MODIFIER_*
+ * @param aLineOrPageDeltaX If you set this value non-zero for
+ * DOM_DELTA_PIXEL event, EventStateManager will
+ * dispatch NS_MOUSE_SCROLL event for horizontal
+ * scroll.
+ * @param aLineOrPageDeltaY If you set this value non-zero for
+ * DOM_DELTA_PIXEL event, EventStateManager will
+ * dispatch NS_MOUSE_SCROLL event for vertical
+ * scroll.
+ * @param aOptions Set following flags.
+ */
+ const unsigned long WHEEL_EVENT_CAUSED_BY_PIXEL_ONLY_DEVICE = 0x0001;
+ const unsigned long WHEEL_EVENT_CAUSED_BY_MOMENTUM = 0x0002;
+ const unsigned long WHEEL_EVENT_CUSTOMIZED_BY_USER_PREFS = 0x0004;
+ // If any of the following flags is specified this method will throw an
+ // exception in case the relevant overflowDelta has an unexpected value.
+ const unsigned long WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_ZERO = 0x0010;
+ const unsigned long WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_POSITIVE = 0x0020;
+ const unsigned long WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_NEGATIVE = 0x0040;
+ const unsigned long WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_ZERO = 0x0100;
+ const unsigned long WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_POSITIVE = 0x0200;
+ const unsigned long WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_NEGATIVE = 0x0400;
+ void sendWheelEvent(in float aX,
+ in float aY,
+ in double aDeltaX,
+ in double aDeltaY,
+ in double aDeltaZ,
+ in unsigned long aDeltaMode,
+ in long aModifiers,
+ in long aLineOrPageDeltaX,
+ in long aLineOrPageDeltaY,
+ in unsigned long aOptions);
+
+ /**
+ * 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 chrome privileges.
+ *
+ * @param aType event type
+ * @param aKeyCode key code
+ * @param aCharCode character code
+ * @param aModifiers modifiers pressed, using constants defined as MODIFIER_*
+ * @param aAdditionalFlags special flags for the key event, see KEY_FLAG_*.
+ *
+ * @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.
+ */
+
+ // If this is set, preventDefault() the event before dispatch.
+ const unsigned long KEY_FLAG_PREVENT_DEFAULT = 0x0001;
+
+ // if one of these flags is set, the KeyboardEvent.location will be the value.
+ // Otherwise, it will be computed from aKeyCode.
+ const unsigned long KEY_FLAG_LOCATION_STANDARD = 0x0010;
+ const unsigned long KEY_FLAG_LOCATION_LEFT = 0x0020;
+ const unsigned long KEY_FLAG_LOCATION_RIGHT = 0x0040;
+ const unsigned long KEY_FLAG_LOCATION_NUMPAD = 0x0080;
+ const unsigned long KEY_FLAG_LOCATION_MOBILE = 0x0100;
+ const unsigned long KEY_FLAG_LOCATION_JOYSTICK = 0x0200;
+
+ boolean sendKeyEvent(in AString aType,
+ in long aKeyCode,
+ in long aCharCode,
+ in long aModifiers,
+ [optional] in unsigned long aAdditionalFlags);
+
+ /**
+ * See nsIWidget::SynthesizeNativeKeyEvent
+ *
+ * Cannot be accessed from unprivileged context (not content-accessible)
+ * Will throw a DOM security error if called without chrome privileges.
+ *
+ * When you use this for tests, use the constants defined in NativeKeyCodes.js
+ */
+ 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 chrome privileges.
+ */
+ void sendNativeMouseEvent(in long aScreenX,
+ in long aScreenY,
+ in long aNativeMessage,
+ in long aModifierFlags,
+ in nsIDOMElement aElement);
+
+ /**
+ * The values for sendNativeMouseScrollEvent's aAdditionalFlags.
+ */
+
+ /**
+ * If MOUSESCROLL_PREFER_WIDGET_AT_POINT is set, widget will dispatch
+ * the event to a widget which is under the cursor. Otherwise, dispatch to
+ * a default target on the platform. E.g., on Windows, it's focused window.
+ */
+ const unsigned long MOUSESCROLL_PREFER_WIDGET_AT_POINT = 0x00000001;
+
+ /**
+ * The platform specific values of aAdditionalFlags. Must be over 0x00010000.
+ */
+
+ /**
+ * If MOUSESCROLL_WIN_SCROLL_LPARAM_NOT_NULL is set and aNativeMessage is
+ * WM_VSCROLL or WM_HSCROLL, widget will set the window handle to the lParam
+ * instead of NULL.
+ */
+ const unsigned long MOUSESCROLL_WIN_SCROLL_LPARAM_NOT_NULL = 0x00010000;
+
+ /**
+ * See nsIWidget::SynthesizeNativeMouseScrollEvent
+ *
+ * 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 chrome privileges.
+ *
+ * NOTE: The synthesized native event may be fired asynchronously.
+ *
+ * @param aNativeMessage
+ * On Windows: WM_MOUSEWHEEL (0x020A), WM_MOUSEHWHEEL(0x020E),
+ * WM_VSCROLL (0x0115) or WM_HSCROLL (0x114).
+ */
+ void sendNativeMouseScrollEvent(in long aScreenX,
+ in long aScreenY,
+ in unsigned long aNativeMessage,
+ in double aDeltaX,
+ in double aDeltaY,
+ in double aDeltaZ,
+ in unsigned long aModifierFlags,
+ in unsigned long aAdditionalFlags,
+ in nsIDOMElement aElement);
+
+ /**
+ * Touch states for sendNativeTouchPoint. These values match
+ * nsIWidget's TouchPointerState.
+ */
+
+ // The pointer is in a hover state above the digitizer
+ const long TOUCH_HOVER = 0x01;
+ // The pointer is in contact with the digitizer
+ const long TOUCH_CONTACT = 0x02;
+ // The pointer has been removed from the digitizer detection area
+ const long TOUCH_REMOVE = 0x04;
+ // The pointer has been canceled. Will cancel any pending os level
+ // gestures that would be triggered as a result of completion of the
+ // input sequence. This may not cancel moz platform related events
+ // that might get tirggered by input already delivered.
+ const long TOUCH_CANCEL = 0x08;
+
+ /**
+ * Create a new or update an existing touch point on the digitizer.
+ * To trigger os level gestures, individual touch points should
+ * transition through a complete set of touch states which should be
+ * sent as individual calls. For example:
+ * tap - msg1:TOUCH_CONTACT, msg2:TOUCH_REMOVE
+ * drag - msg1-n:TOUCH_CONTACT (moving), msgn+1:TOUCH_REMOVE
+ * hover drag - msg1-n:TOUCH_HOVER (moving), msgn+1:TOUCH_REMOVE
+ *
+ * Widget support: Windows 8.0+, Winrt/Win32. Other widgets will
+ * throw.
+ *
+ * @param aPointerId The touch point id to create or update.
+ * @param aTouchState one or more of the touch states listed above
+ * @param aScreenX, aScreenY screen coords of this event
+ * @param aPressure 0.0 -> 1.0 float val indicating pressure
+ * @param aOrientation 0 -> 359 degree value indicating the
+ * orientation of the pointer. Use 90 for normal taps.
+ */
+ void sendNativeTouchPoint(in unsigned long aPointerId,
+ in unsigned long aTouchState,
+ in long aScreenX,
+ in long aScreenY,
+ in double aPressure,
+ in unsigned long aOrientation);
+
+ /**
+ * Simulates native touch based taps on the input digitizer. Events
+ * triggered by this call are injected at the os level. Events do not
+ * bypass widget level input processing and as such can be used to
+ * test widget event logic and async pan-zoom controller functionality.
+ * Cannot be accessed from an unprivileged context.
+ *
+ * Long taps (based on the aLongTap parameter) will be completed
+ * asynchrnously after the call returns. Long tap delay is based on
+ * the ui.click_hold_context_menus.delay pref or 1500 msec if pref
+ * is not set.
+ *
+ * Widget support: Windows 8.0+, Winrt/Win32. Other widgets will
+ * throw.
+ *
+ * @param aScreenX, aScreenY screen coords of this event
+ * @param aLongTap true if the tap should be long, false for a short
+ * tap.
+ */
+ void sendNativeTouchTap(in long aScreenX,
+ in long aScreenY,
+ in boolean aLongTap);
+
+ /**
+ * Cancel any existing touch points or long tap delays. Calling this is safe
+ * even if you're sure there aren't any pointers recorded. You should call
+ * this when tests shut down to reset the digitizer driver. Not doing so can
+ * leave the digitizer in an undetermined state which can screw up subsequent
+ * tests and native input.
+ */
+ void clearNativeTouchSequence();
+
+ /**
+ * See nsIWidget::ActivateNativeMenuItemAt
+ *
+ * Cannot be accessed from unprivileged context (not content-accessible)
+ * Will throw a DOM security error if called without chrome 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 chrome 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 chrome 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 chrome 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)
+ * @param aExtraForgetSkippableCalls indicates how many times
+ * nsCycleCollector_forgetSkippable will
+ * be called before running cycle collection.
+ * -1 prevents the default
+ * nsCycleCollector_forgetSkippable call
+ * which happens after garbage collection.
+ */
+ void garbageCollect([optional] in nsICycleCollectorListener aListener,
+ [optional] in long aExtraForgetSkippableCalls);
+
+ /**
+ * Force a cycle collection without garbage collection.
+ *
+ * Will throw a DOM security error if called without chrome 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)
+ * @param aExtraForgetSkippableCalls indicates how many times
+ * nsCycleCollector_forgetSkippable will
+ * be called before running cycle collection.
+ * -1 prevents the default
+ * nsCycleCollector_forgetSkippable call
+ * which happens after garbage collection.
+ */
+ void cycleCollect([optional] in nsICycleCollectorListener aListener,
+ [optional] in long aExtraForgetSkippableCalls);
+
+ /**
+ * Trigger whichever GC or CC timer is currently active and waiting to fire.
+ * Don't do this too much for initiating heavy actions, like the start of a IGC.
+ */
+ void runNextCollectorTimer();
+
+ /** Synthesize a simple gesture event for a window. The event types
+ * supported are: MozSwipeGestureStart, MozSwipeGestureUpdate,
+ * MozSwipeGestureEnd, MozSwipeGesture, MozMagnifyGestureStart,
+ * MozMagnifyGestureUpdate, MozMagnifyGesture, MozRotateGestureStart,
+ * MozRotateGestureUpdate, MozRotateGesture, MozPressTapGesture,
+ * MozTapGesture, and MozEdgeUIGesture.
+ *
+ * Cannot be accessed from unprivileged context (not
+ * content-accessible) Will throw a DOM security error if called
+ * without chrome 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
+ * @param aClickCount For tap gestures, the number of taps.
+ */
+ void sendSimpleGestureEvent(in AString aType,
+ in float aX,
+ in float aY,
+ in unsigned long aDirection,
+ in double aDelta,
+ in long aModifiers,
+ [optional] in unsigned long aClickCount);
+
+ /**
+ * 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);
+
+
+ /**
+ * Get a list of nodes that have meaningful textual content to
+ * be translated. The implementation of this algorithm is in flux
+ * as we experiment and refine which approach works best.
+ *
+ * This method requires chrome privileges.
+ */
+ nsITranslationNodeList getTranslationNodes(in nsIDOMNode aRoot);
+
+ /**
+ * 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 chrome privileges.
+ */
+ uint32_t 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 chrome 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 chrome 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);
+
+ /**
+ * 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 getScrollXYFloat(in boolean aFlushLayout, out float aScrollX, out float aScrollY);
+
+ /**
+ * Returns the scrollbar width of the window's scroll frame.
+ *
+ * @param aFlushLayout flushes layout if true. Otherwise, no flush occurs.
+ */
+ void getScrollbarSize(in boolean aFlushLayout, out long aWidth, out long aHeight);
+
+ /**
+ * Returns the given element's bounds without flushing pending layout changes.
+ */
+ nsIDOMClientRect getBoundsWithoutFlushing(in nsIDOMElement aElement);
+
+ /**
+ * Returns the bounds of the window's currently loaded document. This will
+ * generally be (0, 0, pageWidth, pageHeight) but in some cases (e.g. RTL
+ * documents) may have a negative left value.
+ */
+ nsIDOMClientRect getRootBounds();
+
+ /**
+ * 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;
+
+ /**
+ * Get the current zoom factor.
+ * This is _approximately_ the same as nsIMarkupDocumentViewer.fullZoom,
+ * but takes into account Gecko's quantization of the zoom factor, which is
+ * implemented by adjusting the (integer) number of appUnits per devPixel.
+ */
+ readonly attribute float fullZoom;
+
+ /**
+ * 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 chrome 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);
+
+ /**
+ * Sets WidgetEvent::mFlags::mOnlyChromeDispatch to true to ensure that
+ * the event is propagated only to chrome.
+ * Event's .target property will be aTarget.
+ * Returns the same value as what EventTarget.dispatchEvent does.
+ */
+ boolean dispatchEventToChromeOnly(in nsIDOMEventTarget aTarget,
+ in nsIDOMEvent aEvent);
+
+ /**
+ * Returns the real classname (possibly of the mostly-transparent security
+ * wrapper) of aObj.
+ */
+ [implicit_jscontext] string getClassName(in jsval aObject);
+
+ /**
+ * Generate a content command event.
+ *
+ * Cannot be accessed from unprivileged context (not content-accessible)
+ * Will throw a DOM security error if called without chrome 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 chrome privileges.
+ *
+ * @param aType The event type: "compositionstart", "compositionend" or
+ * "compositionupdate".
+ * @param aData The data property value. Note that this isn't applied
+ * for compositionstart event because its value is the
+ * selected text which is automatically computed.
+ * @param aLocale The locale property value.
+ */
+ void sendCompositionEvent(in AString aType,
+ in AString aData,
+ in AString aLocale);
+
+ /**
+ * Creating synthesizer of composition string on the window.
+ *
+ * Cannot be accessed from unprivileged context (not content-accessible)
+ * Will throw a DOM security error if called without chrome privileges.
+ */
+ nsICompositionStringSynthesizer createCompositionStringSynthesizer();
+
+ /**
+ * If sendQueryContentEvent()'s aAdditionalFlags argument is
+ * QUERY_CONTENT_FLAG_USE_XP_LINE_BREAK, plain text generated from content
+ * is created with "\n".
+ * Otherwise, platform dependent. E.g., on Windows, "\r\n" is used.
+ * aOffset and aLength are offset and length in/of the plain text content.
+ * This flag also affects the result values such as offset, length and string.
+ */
+ const unsigned long QUERY_CONTENT_FLAG_USE_NATIVE_LINE_BREAK = 0x0000;
+ const unsigned long QUERY_CONTENT_FLAG_USE_XP_LINE_BREAK = 0x0001;
+
+ /**
+ * Synthesize a query content event. Note that the result value returned here
+ * is in LayoutDevice pixels rather than CSS pixels.
+ *
+ * @param aType One of the following const values. And see also each comment
+ * for the other parameters and the result.
+ * @param aAdditionalFlags See the description of QUERY_CONTENT_FLAG_*.
+ */
+ nsIQueryContentEventResult sendQueryContentEvent(
+ in unsigned long aType,
+ in unsigned long aOffset,
+ in unsigned long aLength,
+ in long aX,
+ in long aY,
+ [optional] in unsigned long aAdditionalFlags);
+
+ // NOTE: following values are same as NS_QUERY_* in BasicEvents.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;
+
+ /**
+ * Called when the remote child frame has changed its fullscreen state,
+ * when entering fullscreen, and when the origin which is fullscreen changes.
+ * aFrameElement is the iframe element which contains the child-process
+ * fullscreen document, and aNewOrigin is the origin of the new fullscreen
+ * document.
+ */
+ void remoteFrameFullscreenChanged(in nsIDOMElement aFrameElement,
+ in AString aNewOrigin);
+
+ /**
+ * Called when the remote frame has popped all fullscreen elements off its
+ * stack, so that the operation can complete on the parent side.
+ */
+ void remoteFrameFullscreenReverted();
+
+ /**
+ * Called when the child frame has fully exit fullscreen, so that the parent
+ * process can also fully exit.
+ */
+ void exitFullscreen();
+
+ /**
+ * If sendQueryContentEvent()'s aAdditionalFlags argument is
+ * SELECTION_SET_FLAG_USE_NATIVE_LINE_BREAK, aOffset and aLength are offset
+ * and length in/of plain text generated from content is created with "\n".
+ * Otherwise, platform dependent. E.g., on Windows, "\r\n" is used.
+ */
+ const unsigned long SELECTION_SET_FLAG_USE_NATIVE_LINE_BREAK = 0x0000;
+ const unsigned long SELECTION_SET_FLAG_USE_XP_LINE_BREAK = 0x0001;
+
+ /**
+ * If SELECTION_SET_FLAG_REVERSE is set, the selection is set from
+ * |aOffset + aLength| to |aOffset|. Otherwise, it's set from |aOffset| to
+ * |aOffset + aLength|.
+ */
+ const unsigned long SELECTION_SET_FLAG_REVERSE = 0x0002;
+
+ /**
+ * 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 aAdditionalFlags See the description of SELECTION_SET_FLAG_*.
+ * @return True, if succeeded. Otherwise, false.
+ */
+ boolean sendSelectionSetEvent(in unsigned long aOffset,
+ in unsigned long aLength,
+ [optional] in unsigned long aAdditionalFlags);
+
+ /* Selection behaviors - mirror nsIFrame's nsSelectionAmount constants */
+ const unsigned long SELECT_CHARACTER = 0;
+ const unsigned long SELECT_CLUSTER = 1;
+ const unsigned long SELECT_WORD = 2;
+ const unsigned long SELECT_LINE = 3;
+ const unsigned long SELECT_BEGINLINE = 4;
+ const unsigned long SELECT_ENDLINE = 5;
+ const unsigned long SELECT_PARAGRAPH = 6;
+ const unsigned long SELECT_WORDNOSPACE = 7;
+
+ /**
+ * Select content at a client point based on a selection behavior if the
+ * underlying content is selectable. Selection will accumulate with any
+ * existing selection, callers should clear selection prior if needed.
+ * May fire selection changed events. Calls nsFrame's SelectByTypeAtPoint.
+ *
+ * @param aX, aY The selection point in client coordinates.
+ * @param aSelectType The selection behavior requested.
+ * @return True if a selection occured, false otherwise.
+ * @throw NS_ERROR_DOM_SECURITY_ERR, NS_ERROR_UNEXPECTED for utils
+ * issues, and NS_ERROR_INVALID_ARG for coordinates that are outside
+ * this window.
+ */
+ boolean selectAtPoint(in float aX,
+ in float aY,
+ in unsigned long aSelectBehavior);
+
+ /**
+ * 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.
+ */
+ [implicit_jscontext] jsval getParent(in jsval 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()]
+ */
+ [noscript] 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;
+
+ /**
+ * True if the layer manager for the widget associated with this window is
+ * forwarding layers to a remote compositor, false otherwise. Throws an
+ * error if there is no widget associated with this window.
+ */
+ readonly attribute boolean layerManagerRemote;
+
+ /**
+ * Record (and return) frame-intervals for frames which were presented
+ * between calling StartFrameTimeRecording and StopFrameTimeRecording.
+ *
+ * - Uses a cyclic buffer and serves concurrent consumers, so if Stop is called too late
+ * (elements were overwritten since Start), result is considered invalid and hence empty.
+ * - Buffer is capable of holding 10 seconds @ 60fps (or more if frames were less frequent).
+ * Can be changed (up to 1 hour) via pref: toolkit.framesRecording.bufferSize.
+ * - Note: the first frame-interval may be longer than expected because last frame
+ * might have been presented some time before calling StartFrameTimeRecording.
+ */
+
+ /**
+ * Returns a handle which represents current recording start position.
+ */
+ void startFrameTimeRecording([retval] out unsigned long startIndex);
+
+ /**
+ * Returns number of recorded frames since startIndex was issued,
+ * and allocates+populates 2 arraye with the recorded data.
+ * - Allocation is infallible. Should be released even if size is 0.
+ */
+ void stopFrameTimeRecording(in unsigned long startIndex,
+ [optional] out unsigned long frameCount,
+ [retval, array, size_is(frameCount)] out float frameIntervals);
+
+ /**
+ * Signals that we're begining to tab switch. This is used by painting code to
+ * determine total tab switch time.
+ */
+ void beginTabSwitch();
+
+ /**
+ * The DPI of the display
+ */
+ readonly attribute float displayDPI;
+
+ /**
+ * Return the outer window with the given ID, if any. Can return null.
+ * @deprecated Use nsIWindowMediator.getOuterWindowWithId. See bug 865664.
+ */
+ nsIDOMWindow getOuterWindowWithId(in unsigned long long aOuterWindowID);
+
+ /**
+ * Return this window's frame element.
+ * Ignores all chrome/content or mozbrowser boundaries.
+ */
+ readonly attribute nsIDOMElement containerElement;
+
+ [noscript] void RenderDocument(in nsConstRect aRect,
+ in uint32_t aFlags,
+ in nscolor aBackgroundColor,
+ in gfxContext aThebesContext);
+
+ /**
+ * advanceTimeAndRefresh allows the caller to take over the refresh
+ * driver timing for a window. A call to advanceTimeAndRefresh does
+ * three things:
+ * (1) It marks the refresh driver for this presentation so that it
+ * no longer refreshes on its own, but is instead driven entirely
+ * by the caller (except for the refresh that happens when a
+ * document comes out of the bfcache).
+ * (2) It advances the refresh driver's current refresh time by the
+ * argument given. Negative advances are permitted.
+ * (3) It does a refresh (i.e., notifies refresh observers) at that
+ * new time.
+ *
+ * Note that this affects other connected docshells of the same type
+ * in the same docshell tree, such as parent frames.
+ *
+ * When callers have completed their use of advanceTimeAndRefresh,
+ * they must call restoreNormalRefresh.
+ */
+ void advanceTimeAndRefresh(in long long aMilliseconds);
+
+ /**
+ * Undoes the effects of advanceTimeAndRefresh.
+ */
+ void restoreNormalRefresh();
+
+ /**
+ * Reports whether the current state is test-controlled refreshes
+ * (see advanceTimeAndRefresh and restoreNormalRefresh above).
+ */
+ readonly attribute bool isTestControllingRefreshes;
+
+ /**
+ * Set async scroll offset on an element. The next composite will render
+ * with that offset if async scrolling is enabled, and then the offset
+ * will be removed. Only call this while test-controlled refreshes is enabled.
+ */
+ void setAsyncScrollOffset(in nsIDOMNode aNode, in int32_t aX, in int32_t aY);
+
+ /**
+ * 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);
+
+ /**
+ * Wrap an nsIFile in an nsIDOMFile
+ */
+ nsIDOMFile wrapDOMFile(in nsIFile aFile);
+
+ /**
+ * Get the type of the currently focused html input, if any.
+ */
+ readonly attribute string focusedInputType;
+
+ /**
+ * Given a view ID from the compositor process, retrieve the element
+ * associated with a view. For scrollpanes for documents, the root
+ * element of the document is returned.
+ */
+ nsIDOMElement findElementWithViewId(in nsViewID aId);
+
+ /**
+ * Find the view ID for a given element. This is the reverse of
+ * findElementWithViewId().
+ */
+ nsViewID getViewId(in nsIDOMElement aElement);
+
+ /**
+ * Checks the layer tree for this window and returns true
+ * if all layers have transforms that are translations by integers,
+ * no leaf layers overlap, and the union of the leaf layers is exactly
+ * the bounds of the window. Always returns true in non-DEBUG builds.
+ */
+ boolean leafLayersPartitionWindow();
+
+ /**
+ * true if the (current inner) window may have event listeners for touch events.
+ */
+ readonly attribute boolean mayHaveTouchEventListeners;
+
+ /**
+ * Check if any ThebesLayer painting has been done for this element,
+ * clears the painted flags if they have.
+ */
+ boolean checkAndClearPaintedState(in nsIDOMElement aElement);
+
+ /**
+ * Internal file constructor intended for testing of File objects.
+ * Example of constructor usage:
+ * getFile("myfile.txt", [b1, "foo"], { type: "text/plain" })
+ */
+ [optional_argc, implicit_jscontext]
+ nsIDOMFile getFile(in DOMString aName, [optional] in jsval aBlobParts,
+ [optional] in jsval aParameters);
+
+ /**
+ * Internal blob constructor intended for testing of Blob objects.
+ * Example of constructor usage:
+ * getBlob([b1, "foo"], { type: "text/plain" })
+ */
+ [optional_argc, implicit_jscontext]
+ nsIDOMBlob getBlob([optional] in jsval aBlobParts,
+ [optional] in jsval aParameters);
+
+ /**
+ * Get internal id of the stored blob, file or file handle.
+ */
+ [implicit_jscontext] long long getFileId(in jsval aFile);
+
+ /**
+ * Get file ref count info for given database and file id.
+ *
+ */
+ [implicit_jscontext]
+ boolean getFileReferences(in AString aDatabaseName, in long long aId,
+ [optional] in jsval aOptions,
+ [optional] out long aRefCnt,
+ [optional] out long aDBRefCnt,
+ [optional] out long aSliceRefCnt);
+
+ /**
+ * Return whether incremental GC has been disabled due to a binary add-on.
+ */
+ [implicit_jscontext]
+ boolean isIncrementalGCEnabled();
+
+ /**
+ * Begin opcode-level profiling of all JavaScript execution in the window's
+ * runtime.
+ */
+ [implicit_jscontext]
+ void startPCCountProfiling();
+
+ /**
+ * Stop opcode-level profiling of JavaScript execution in the runtime, and
+ * collect all counts for use by getPCCount methods.
+ */
+ [implicit_jscontext]
+ void stopPCCountProfiling();
+
+ /**
+ * Purge collected PC counters.
+ */
+ [implicit_jscontext]
+ void purgePCCounts();
+
+ /**
+ * Get the number of scripts with opcode-level profiling information.
+ */
+ [implicit_jscontext]
+ long getPCCountScriptCount();
+
+ /**
+ * Get a JSON string for a short summary of a script and the PC counts
+ * accumulated for it.
+ */
+ [implicit_jscontext]
+ AString getPCCountScriptSummary(in long script);
+
+ /**
+ * Get a JSON string with full information about a profiled script,
+ * including the decompilation of the script and placement of decompiled
+ * operations within it, and PC counts for each operation.
+ */
+ [implicit_jscontext]
+ AString getPCCountScriptContents(in long script);
+
+ /**
+ * Returns true if painting is suppressed for this window and false
+ * otherwise.
+ */
+ readonly attribute boolean paintingSuppressed;
+
+ /**
+ * Returns an array of plugins on the page for opt-in activation.
+ *
+ * Cannot be accessed from unprivileged context (not content-accessible).
+ * Will throw a DOM security error if called without chrome privileges.
+ *
+ */
+ [implicit_jscontext]
+ readonly attribute jsval plugins;
+
+ /**
+ * Set the scrollport size for the purposes of clamping scroll positions for
+ * the root scroll frame of this document to be (aWidth,aHeight) in CSS pixels.
+ *
+ * The caller of this method must have chrome privileges.
+ */
+ void setScrollPositionClampingScrollPortSize(in float aWidth, in float aHeight);
+
+ /**
+ * Set margins for the layout of fixed position elements in the content
+ * document. These are used on mobile, where the viewable area can be
+ * temporarily obscured by the browser chrome. In this situation, we're ok
+ * with scrollable page content being obscured, but fixed position content
+ * cannot be revealed without removing the obscuring chrome, so we use these
+ * margins so that it can remain visible.
+ *
+ * The caller of this method must have chrome privileges.
+ */
+ void setContentDocumentFixedPositionMargins(in float aTop, in float aRight,
+ in float aBottom, in float aLeft);
+
+ /**
+ * These are used to control whether dialogs (alert, prompt, confirm) are
+ * allowed.
+ */
+ void disableDialogs();
+ void enableDialogs();
+ bool areDialogsEnabled();
+
+ const unsigned long AGENT_SHEET = 0;
+ const unsigned long USER_SHEET = 1;
+ const unsigned long AUTHOR_SHEET = 2;
+ /**
+ * Synchronously loads a style sheet from |sheetURI| and adds it to the list
+ * of additional style sheets of the document.
+ *
+ * These additional style sheets are very much like user/agent sheets loaded
+ * with loadAndRegisterSheet. The only difference is that they are applied only
+ * on the document owned by this window.
+ *
+ * Sheets added via this API take effect immediately on the document.
+ */
+ void loadSheet(in nsIURI sheetURI,
+ in unsigned long type);
+
+ /**
+ * Remove the document style sheet at |sheetURI| from the list of additional
+ * style sheets of the document. The removal takes effect immediately.
+ */
+ void removeSheet(in nsIURI sheetURI,
+ in unsigned long type);
+
+ /**
+ * Returns true if a user input is being handled.
+ *
+ * This calls EventStateManager::IsHandlingUserInput().
+ */
+ readonly attribute boolean isHandlingUserInput;
+
+ /**
+ * After calling the method, the window for which this DOMWindowUtils
+ * was created can be closed using scripts.
+ */
+ void allowScriptsToClose();
+
+ /**
+ * Is the parent window's main widget visible? If it isn't, we probably
+ * don't want to display any dialogs etc it may request. This corresponds
+ * to the visibility check in nsWindowWatcher::OpenWindowInternal().
+ *
+ * Will throw a DOM security error if called without chrome privileges or
+ * NS_ERROR_NOT_AVAILABLE in the unlikely event that the parent window's
+ * main widget can't be reached.
+ */
+ readonly attribute boolean isParentWindowMainWidgetVisible;
+
+ /**
+ * In certain cases the event handling of nodes, form controls in practice,
+ * may be disabled. Such cases are for example the existence of disabled
+ * attribute or -moz-user-input: none/disabled.
+ */
+ boolean isNodeDisabledForEvents(in nsIDOMNode aNode);
+
+ /**
+ * Setting paintFlashing to true will flash newly painted area.
+ */
+ attribute boolean paintFlashing;
+
+ /**
+ * Allows running of a "synchronous section", in the form of an nsIRunnable
+ * once the event loop has reached a "stable state". We've reached a stable
+ * state when the currently executing task/event has finished, see:
+ * http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#synchronous-section
+ * In practice this runs aRunnable once the currently executing event
+ * finishes. If called multiple times per task/event, all the runnables will
+ * be executed, in the order in which runInStableState() was called.
+ *
+ * XXX - This can wreak havoc if you're not using this for very simple
+ * purposes, eg testing or setting a flag.
+ */
+ void runInStableState(in nsIRunnable runnable);
+
+ /**
+ * Run the given runnable before the next iteration of the event loop (this
+ * includes native events too). If a nested loop is spawned within the current
+ * event then the runnable will not be run until that loop has terminated.
+ *
+ * XXX - This can wreak havoc if you're not using this for very simple
+ * purposes, eg testing or setting a flag.
+ */
+ void runBeforeNextEvent(in nsIRunnable runnable);
+
+ /*
+ * Returns the value of a given property animated on the compositor thread.
+ * If the property is NOT currently being animated on the compositor thread,
+ * returns an empty string.
+ */
+ AString getOMTAStyle(in nsIDOMElement aElement, in AString aProperty);
+
+ /*
+ * Returns the value of a given property. If the property is animated off
+ * the main thread, this function will fetch the correct value from the
+ * compositor.
+ */
+ AString getOMTAOrComputedStyle(in nsIDOMElement aElement,
+ in AString aProperty);
+
+ /**
+ * With this it's possible to mute all the MediaElements in this window.
+ * We have audioMuted and audioVolume to preserve the volume across
+ * mute/umute.
+ */
+ attribute boolean audioMuted;
+
+ /**
+ * range: greater or equal to 0. The real volume level is affected by the
+ * volume of all ancestor windows.
+ */
+ attribute float audioVolume;
+};
+
+[scriptable, uuid(c694e359-7227-4392-a138-33c0cc1f15a6)]
+interface nsITranslationNodeList : nsISupports {
+ readonly attribute unsigned long length;
+ nsIDOMNode item(in unsigned long index);
+
+ // A translation root is a block element, or an inline element
+ // which its parent is not a translation node.
+ boolean isTranslationRootAtIndex(in unsigned long index);
+};