/* -*- 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(e4333e51-f2fa-4fdd-becd-75d000703355)]
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;

  /**
   * 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);
};
