mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
985 lines
37 KiB
Plaintext
985 lines
37 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);
|
|
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;
|
|
|
|
[scriptable, uuid(9df58cf3-7094-4c8d-96f2-bebd765099fe)]
|
|
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);
|
|
|
|
/**
|
|
* 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
|
|
* <xPx, yPx, widthPx, heightPx> 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).
|
|
*
|
|
* <x, y> 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 UniversalXPConnect
|
|
* privileges.
|
|
*/
|
|
void setDisplayPortForElement(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
|
|
* <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 a cycle collection without garbage 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 cycleCollect([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.
|
|
*/
|
|
[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 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", "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);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
[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.
|
|
*/
|
|
[noscript] void enterModalState();
|
|
|
|
/**
|
|
* Resume normal window state, where scripts can run and events are
|
|
* delivered.
|
|
*/
|
|
[noscript] void leaveModalState();
|
|
|
|
/**
|
|
* Same as enterModalState, but returns the window associated with the
|
|
* current JS context.
|
|
*/
|
|
nsIDOMWindow enterModalStateWithWindow();
|
|
|
|
/**
|
|
* Same as leaveModalState, but takes a window associated with the active
|
|
* context when enterModalStateWithWindow was called. The currently context
|
|
* might be different at the moment (see bug 621764).
|
|
*/
|
|
void leaveModalStateWithWindow(in nsIDOMWindow aWindow);
|
|
|
|
/**
|
|
* 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();
|
|
|
|
/**
|
|
* Set the network status to online from the Offline mode error page.
|
|
*
|
|
* The caller of this method must be about:neterror.
|
|
*/
|
|
void goOnline();
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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();
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/*
|
|
* Get internal id of the stored blob.
|
|
*/
|
|
long long getFileId(in nsIDOMBlob aBlob);
|
|
|
|
/*
|
|
* Get file ref count info for given database and file id.
|
|
*
|
|
*/
|
|
boolean getFileReferences(in AString aDatabaseName, in long long aId,
|
|
[optional] out long aRefCnt,
|
|
[optional] out long aDBRefCnt,
|
|
[optional] out long aSliceRefCnt);
|
|
|
|
/**
|
|
* 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);
|
|
};
|