/* -*- Mode: IDL; tab-width: 4; 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 nsIDOMDocument;
interface nsIInputStream;
interface nsISHistory;
interface nsIURI;

/**
 * The nsIWebNavigation interface defines an interface for navigating the web.
 * It provides methods and attributes to direct an object to navigate to a new
 * location, stop or restart an in process load, or determine where the object
 * has previously gone.
 */
[scriptable, uuid(b7568a50-4c50-442c-a6be-3a340a48d89a)]
interface nsIWebNavigation : nsISupports
{
  /**
   * Indicates if the object can go back.  If true this indicates that
   * there is back session history available for navigation.
   */
  readonly attribute boolean canGoBack;

  /**
   * Indicates if the object can go forward.  If true this indicates that
   * there is forward session history available for navigation
   */
  readonly attribute boolean canGoForward;

  /**
   * Tells the object to navigate to the previous session history item.  When a
   * page is loaded from session history, all content is loaded from the cache
   * (if available) and page state (such as form values and scroll position) is
   * restored.
   *
   * @throw NS_ERROR_UNEXPECTED
   *        Indicates that the call was unexpected at this time, which implies
   *        that canGoBack is false.
   */
  void goBack();

  /**
   * Tells the object to navigate to the next session history item.  When a
   * page is loaded from session history, all content is loaded from the cache
   * (if available) and page state (such as form values and scroll position) is
   * restored.
   *
   * @throw NS_ERROR_UNEXPECTED
   *        Indicates that the call was unexpected at this time, which implies
   *        that canGoForward is false.
   */
  void goForward();

  /**
   * Tells the object to navigate to the session history item at a given index.
   *
   * @throw NS_ERROR_UNEXPECTED
   *        Indicates that the call was unexpected at this time, which implies
   *        that session history entry at the given index does not exist.
   */
  void gotoIndex(in long index);

  /****************************************************************************
   * The following flags may be bitwise combined to form the load flags
   * parameter passed to either the loadURI or reload method.  Some of these
   * flags are only applicable to loadURI.
   */

  /**
   * This flags defines the range of bits that may be specified.  Flags
   * outside this range may be used, but may not be passed to Reload().
   */
  const unsigned long LOAD_FLAGS_MASK            = 0xffff;

  /**
   * This is the default value for the load flags parameter.
   */
  const unsigned long LOAD_FLAGS_NONE            = 0x0000;

  /**
   * Flags 0x1, 0x2, 0x4, 0x8 are reserved for internal use by
   * nsIWebNavigation implementations for now.
   */

  /**
   * This flag specifies that the load should have the semantics of an HTML
   * Meta-refresh tag (i.e., that the cache should be bypassed).  This flag
   * is only applicable to loadURI.
   * XXX the meaning of this flag is poorly defined.
   * XXX no one uses this, so we should probably deprecate and remove it.
   */
  const unsigned long LOAD_FLAGS_IS_REFRESH      = 0x0010;

  /**
   * This flag specifies that the load should have the semantics of a link
   * click.  This flag is only applicable to loadURI.
   * XXX the meaning of this flag is poorly defined.
   */
  const unsigned long LOAD_FLAGS_IS_LINK         = 0x0020;

  /**
   * This flag specifies that history should not be updated.  This flag is only
   * applicable to loadURI.
   */
  const unsigned long LOAD_FLAGS_BYPASS_HISTORY  = 0x0040;

  /**
   * This flag specifies that any existing history entry should be replaced.
   * This flag is only applicable to loadURI.
   */
  const unsigned long LOAD_FLAGS_REPLACE_HISTORY = 0x0080;

  /**
   * This flag specifies that the local web cache should be bypassed, but an
   * intermediate proxy cache could still be used to satisfy the load.
   */
  const unsigned long LOAD_FLAGS_BYPASS_CACHE    = 0x0100;

  /**
   * This flag specifies that any intermediate proxy caches should be bypassed
   * (i.e., that the content should be loaded from the origin server).
   */
  const unsigned long LOAD_FLAGS_BYPASS_PROXY    = 0x0200;

  /**
   * This flag specifies that a reload was triggered as a result of detecting
   * an incorrect character encoding while parsing a previously loaded
   * document.
   */
  const unsigned long LOAD_FLAGS_CHARSET_CHANGE  = 0x0400;
 
  /**
   * If this flag is set, Stop() will be called before the load starts
   * and will stop both content and network activity (the default is to
   * only stop network activity).  Effectively, this passes the
   * STOP_CONTENT flag to Stop(), in addition to the STOP_NETWORK flag.
   */
  const unsigned long LOAD_FLAGS_STOP_CONTENT    = 0x0800;

  /**
   * A hint this load was prompted by an external program: take care!
   */
  const unsigned long LOAD_FLAGS_FROM_EXTERNAL   = 0x1000;

  /**
    This flag is set when a user explicitly disables the Mixed Content
    Blocker, and allows Mixed Content to load on an https page.
  */
  const unsigned long LOAD_FLAGS_ALLOW_MIXED_CONTENT = 0x2000;

  /**
   * This flag specifies that this is the first load in this object.
   * Set with care, since setting incorrectly can cause us to assume that
   * nothing was actually loaded in this object if the load ends up being 
   * handled by an external application.  This flag must not be passed to
   * Reload.
   */
  const unsigned long LOAD_FLAGS_FIRST_LOAD = 0x4000;

  /**
   * This flag specifies that the load should not be subject to popup
   * blocking checks.  This flag must not be passed to Reload.
   */
  const unsigned long LOAD_FLAGS_ALLOW_POPUPS = 0x8000;

  /**
   * This flag specifies that the URI classifier should not be checked for
   * this load.  This flag must not be passed to Reload.
   */
  const unsigned long LOAD_FLAGS_BYPASS_CLASSIFIER = 0x10000;

  /**
   * Force relevant cookies to be sent with this load even if normally they
   * wouldn't be.
   */
  const unsigned long LOAD_FLAGS_FORCE_ALLOW_COOKIES = 0x20000;

  /**
   * Prevent the owner principal from being inherited for this load.
   */
  const unsigned long LOAD_FLAGS_DISALLOW_INHERIT_OWNER = 0x40000;

  /**
   * This flag specifies that the URI may be submitted to a third-party
   * server for correction. This should only be applied to non-sensitive
   * URIs entered by users.  This flag must not be passed to Reload.
   */
  const unsigned long LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP = 0x100000;

  /**
   * This flag specifies that common scheme typos should be corrected.
   */
  const unsigned long LOAD_FLAGS_FIXUP_SCHEME_TYPOS = 0x200000;

  /* Note that flag 0x80000 is available. */

  /**
   * Loads a given URI.  This will give priority to loading the requested URI
   * in the object implementing	this interface.  If it can't be loaded here
   * however, the URI dispatcher will go through its normal process of content
   * loading.
   *
   * @param aURI
   *        The URI string to load.  For HTTP and FTP URLs and possibly others,
   *        characters above U+007F will be converted to UTF-8 and then URL-
   *        escaped per the rules of RFC 2396.
   * @param aLoadFlags
   *        Flags modifying load behaviour.  This parameter is a bitwise
   *        combination of the load flags defined above.  (Undefined bits are
   *        reserved for future use.)  Generally you will pass LOAD_FLAGS_NONE
   *        for this parameter.
   * @param aReferrer
   *        The referring URI.  If this argument is null, then the referring
   *        URI will be inferred internally.
   * @param aPostData
   *        If the URI corresponds to a HTTP request, then this stream is
   *        appended directly to the HTTP request headers.  It may be prefixed
   *        with additional HTTP headers.  This stream must contain a "\r\n"
   *        sequence separating any HTTP headers from the HTTP request body.
   *        This parameter is optional and may be null.
   * @param aHeaders
   *        If the URI corresponds to a HTTP request, then any HTTP headers
   *        contained in this stream are set on the HTTP request.  The HTTP
   *        header stream is formatted as:
   *            ( HEADER "\r\n" )*
   *        This parameter is optional and may be null.
   */
  void loadURI(in wstring        aURI,
               in unsigned long  aLoadFlags,
               in nsIURI         aReferrer,
               in nsIInputStream aPostData,
               in nsIInputStream aHeaders);

  /**
   * Loads a given URI.  This will give priority to loading the requested URI
   * in the object implementing this interface.  If it can't be loaded here
   * however, the URI dispatcher will go through its normal process of content
   * loading.
   * Behaves like loadURI, except an additional parameter is provided to supply
   * a base URI to be used in specific situations where one cannot be inferred
   * by other means, for example when this is called to view selection source.
   * Outside of these situations, the behaviour of this function is no
   * different to loadURI.
   *
   * @param aURI
   *        The URI string to load.  For HTTP and FTP URLs and possibly others,
   *        characters above U+007F will be converted to UTF-8 and then URL-
   *        escaped per the rules of RFC 2396.
   * @param aLoadFlags
   *        Flags modifying load behaviour.  This parameter is a bitwise
   *        combination of the load flags defined above.  (Undefined bits are
   *        reserved for future use.)  Generally you will pass LOAD_FLAGS_NONE
   *        for this parameter.
   * @param aReferrer
   *        The referring URI.  If this argument is null, then the referring
   *        URI will be inferred internally.
   * @param aPostData
   *        If the URI corresponds to a HTTP request, then this stream is
   *        appended directly to the HTTP request headers.  It may be prefixed
   *        with additional HTTP headers.  This stream must contain a "\r\n"
   *        sequence separating any HTTP headers from the HTTP request body.
   *        This parameter is optional and may be null.
   * @param aHeaders
   *        If the URI corresponds to a HTTP request, then any HTTP headers
   *        contained in this stream are set on the HTTP request.  The HTTP
   *        header stream is formatted as:
   *            ( HEADER "\r\n" )*
   *        This parameter is optional and may be null.
   * @param aBaseURI
   *        Set to indicate a base URI to be associated with the load. Note
   *        that at present this argument is only used with view-source aURIs
   *        and cannot be used to resolve aURI.
   *        This parameter is optional and may be null.
   */
  void loadURIWithBase(in wstring        aURI,
                       in unsigned long  aLoadFlags,
                       in nsIURI         aReferrer,
                       in nsIInputStream aPostData,
                       in nsIInputStream aHeaders,
                       in nsIURI         aBaseURI);

  /**
   * Tells the Object to reload the current page.  There may be cases where the
   * user will be asked to confirm the reload (for example, when it is
   * determined that the request is non-idempotent).
   *
   * @param aReloadFlags
   *        Flags modifying load behaviour.  This parameter is a bitwise
   *        combination of the Load Flags defined above.  (Undefined bits are
   *        reserved for future use.)  Generally you will pass LOAD_FLAGS_NONE
   *        for this parameter.
   *
   * @throw NS_BINDING_ABORTED
   *        Indicating that the user canceled the reload.
   */
  void reload(in unsigned long aReloadFlags);

  /****************************************************************************
   * The following flags may be passed as the stop flags parameter to the stop
   * method defined on this interface.
   */

  /**
   * This flag specifies that all network activity should be stopped.  This
   * includes both active network loads and pending META-refreshes.
   */
  const unsigned long STOP_NETWORK = 0x01;

  /**
   * This flag specifies that all content activity should be stopped.  This
   * includes animated images, plugins and pending Javascript timeouts.
   */
  const unsigned long STOP_CONTENT = 0x02;

  /**
   * This flag specifies that all activity should be stopped.
   */
  const unsigned long STOP_ALL     = 0x03;

  /**
   * Stops a load of a URI.
   *
   * @param aStopFlags
   *        This parameter is one of the stop flags defined above.
   */
  void stop(in unsigned long aStopFlags);

  /**
   * Retrieves the current DOM document for the frame, or lazily creates a
   * blank document if there is none.  This attribute never returns null except
   * for unexpected error situations.
   */
  readonly attribute nsIDOMDocument document;

  /**
   * The currently loaded URI or null.
   */
  readonly attribute nsIURI currentURI;
 
  /**
   * The referring URI for the currently loaded URI or null.
   */
  readonly attribute nsIURI referringURI;

  /**
   * The session history object used by this web navigation instance.
   */
  attribute nsISHistory sessionHistory;
};
