gecko/content/base/public/nsIFrameLoader.idl

304 lines
9.7 KiB
Plaintext

/* -*- 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"
interface nsFrameLoader;
interface nsIDocShell;
interface nsIURI;
interface nsIFrame;
interface nsSubDocumentFrame;
interface nsIMessageSender;
interface nsIVariant;
interface nsIDOMElement;
interface nsITabParent;
typedef unsigned long long nsContentViewId;
/**
* These interfaces do *not* scroll or scale the content document;
* instead they set a "goal" scroll/scale wrt the current content
* view. When the content document is painted, the scroll*
* attributes are used to set a compensating transform. If the
* metrics of the content document's current pixels don't match the
* view config, the transform matrix may need to translate
* content pixels and/or perform a "fuzzy-scale" that doesn't
* re-rasterize fonts or intelligently resample images.
*
* The attrs are allowed to transform content pixels in
* such a way that the <browser>'s visible rect encloses pixels that
* the content document does not (yet) define.
*
* The view scroll values are in units of chrome-document CSS
* pixels.
*
* These APIs are designed to be used with nsIDOMWindowUtils
* setDisplayPort() and setResolution().
*/
[scriptable, uuid(c04c5c40-fa2a-4e9c-94f5-b362a10a86cb)]
interface nsIContentView : nsISupports
{
/**
* Scroll view to or by the given chrome-document CSS pixels.
* Fails if the view is no longer valid.
*/
void scrollTo(in float xPx, in float yPx);
void scrollBy(in float dxPx, in float dyPx);
void setScale(in float xScale, in float yScale);
/**
* Scroll offset in chrome-document CSS pixels.
*
* When this view is active (i.e. it is being painted because it's in the
* visible region of the screen), this value is at first lined up with the
* content's scroll offset.
*
* Note that when this view becomes inactive, the new content view will have
* scroll values that are reset to the default!
*/
readonly attribute float scrollX;
readonly attribute float scrollY;
/**
* Dimensions of the viewport in chrome-document CSS pixels.
*/
readonly attribute float viewportWidth;
readonly attribute float viewportHeight;
/**
* Dimensions of scrolled content in chrome-document CSS pixels.
*/
readonly attribute float contentWidth;
readonly attribute float contentHeight;
/**
* ID that can be used in conjunction with nsIDOMWindowUtils to change
* the actual document, instead of just how it is transformed.
*/
readonly attribute nsContentViewId id;
};
[scriptable, uuid(ba5af90d-ece5-40b2-9a1d-a0154128db1c)]
interface nsIContentViewManager : nsISupports
{
/**
* Retrieve view scrolling/scaling interfaces in a given area,
* used to support asynchronous re-paints of content pixels.
* These interfaces are only meaningful for <browser>.
*
* Pixels are in chrome device pixels and are relative to the browser
* element.
*
* @param aX x coordinate that will be in target rectangle
* @param aY y coordinate that will be in target rectangle
* @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
*/
void getContentViewsIn(in float aXPx, in float aYPx,
in float aTopSize, in float aRightSize,
in float aBottomSize, in float aLeftSize,
[optional] out unsigned long aLength,
[retval, array, size_is(aLength)] out nsIContentView aResult);
/**
* The root content view.
*/
readonly attribute nsIContentView rootContentView;
};
[scriptable, builtinclass, uuid(5b9949dc-56f1-47b6-b6d2-3785bb90ed6d)]
interface nsIFrameLoader : nsISupports
{
/**
* Get the docshell from the frame loader.
*/
readonly attribute nsIDocShell docShell;
/**
* Get this frame loader's TabParent, if it has a remote frame. Otherwise,
* returns null.
*/
readonly attribute nsITabParent tabParent;
/**
* Start loading the frame. This method figures out what to load
* from the owner content in the frame loader.
*/
void loadFrame();
/**
* Loads the specified URI in this frame. Behaves identically to loadFrame,
* except that this method allows specifying the URI to load.
*/
void loadURI(in nsIURI aURI);
/**
* Destroy the frame loader and everything inside it. This will
* clear the weak owner content reference.
*/
void destroy();
/**
* Find out whether the loader's frame is at too great a depth in
* the frame tree. This can be used to decide what operations may
* or may not be allowed on the loader's docshell.
*/
readonly attribute boolean depthTooGreat;
/**
* Updates the position and size of the subdocument loaded by this frameloader.
*
* @param aIFrame The nsIFrame for the content node that owns this frameloader
*/
[noscript] void updatePositionAndSize(in nsSubDocumentFrame aIFrame);
/**
* Activate remote frame.
* Throws an exception with non-remote frames.
*/
void activateRemoteFrame();
/**
* Deactivate remote frame.
* Throws an exception with non-remote frames.
*/
void deactivateRemoteFrame();
/**
* @see nsIDOMWindowUtils sendMouseEvent.
*/
void sendCrossProcessMouseEvent(in AString aType,
in float aX,
in float aY,
in long aButton,
in long aClickCount,
in long aModifiers,
[optional] in boolean aIgnoreRootScrollFrame);
/**
* Activate event forwarding from client (remote frame) to parent.
*/
void activateFrameEvent(in AString aType, in boolean capture);
// Note, when frameloaders are swapped, also messageManagers are swapped.
readonly attribute nsIMessageSender messageManager;
/**
* @see nsIDOMWindowUtils sendKeyEvent.
*/
void sendCrossProcessKeyEvent(in AString aType,
in long aKeyCode,
in long aCharCode,
in long aModifiers,
[optional] in boolean aPreventDefault);
attribute boolean delayRemoteDialogs;
/**
* The default rendering mode is synchronous scrolling. In this
* mode, it's an error to try to set a target viewport.
*/
const unsigned long RENDER_MODE_DEFAULT = 0x00000000;
/**
* When asynchronous scrolling is enabled, a target viewport can be
* set to transform content pixels wrt its CSS viewport.
*
* NB: when async scrolling is enabled, it's the *user's*
* responsibility to update the target scroll offset. In effect,
* the platform hands over control of scroll offset to the user.
*/
const unsigned long RENDER_MODE_ASYNC_SCROLL = 0x00000001;
attribute unsigned long renderMode;
/**
* The default event mode automatically forwards the events
* handled in nsEventStateManager::HandleCrossProcessEvent to
* the child content process when these events are targeted to
* the remote browser element.
*
* Used primarly for input events (mouse, keyboard)
*/
const unsigned long EVENT_MODE_NORMAL_DISPATCH = 0x00000000;
/**
* With this event mode, it's the application's responsability to
* convert and forward events to the content process
*/
const unsigned long EVENT_MODE_DONT_FORWARD_TO_CHILD = 0x00000001;
attribute unsigned long eventMode;
/**
* If false, then the subdocument is not clipped to its CSS viewport, and the
* subdocument's viewport scrollbar(s) are not rendered.
* Defaults to true.
*/
attribute boolean clipSubdocument;
/**
* If false, then the subdocument's scroll coordinates will not be clamped
* to their scroll boundaries.
* Defaults to true.
*/
attribute boolean clampScrollPosition;
/**
* The element which owns this frame loader.
*
* For example, if this is a frame loader for an <iframe>, this attribute
* returns the iframe element.
*/
readonly attribute nsIDOMElement ownerElement;
/**
* Cached childID of the ContentParent owning the TabParent in this frame
* loader. This can be used to obtain the childID after the TabParent died.
*/
readonly attribute unsigned long long childID;
/**
* Get or set this frame loader's visibility.
*
* The notion of "visibility" here is separate from the notion of a
* window/docshell's visibility. This field is mostly here so that we can
* have a notion of visibility in the parent process when frames are OOP.
*/
[infallible] attribute boolean visible;
};
%{C++
class nsFrameLoader;
%}
native alreadyAddRefed_nsFrameLoader(already_AddRefed<nsFrameLoader>);
[scriptable, uuid(5879040e-83e9-40e3-b2bb-5ddf43b76e47)]
interface nsIFrameLoaderOwner : nsISupports
{
/**
* The frame loader owned by this nsIFrameLoaderOwner
*/
readonly attribute nsIFrameLoader frameLoader;
[noscript, notxpcom] alreadyAddRefed_nsFrameLoader GetFrameLoader();
/**
* Swap frame loaders with the given nsIFrameLoaderOwner. This may
* only be posible in a very limited range of circumstances, or
* never, depending on the object implementing this interface.
*
* @throws NS_ERROR_NOT_IMPLEMENTED if the swapping logic is not
* implemented for the two given frame loader owners.
* @throws NS_ERROR_DOM_SECURITY_ERR if the swap is not allowed on
* security grounds.
*/
void swapFrameLoaders(in nsIFrameLoaderOwner aOtherOwner);
};