Struct xpcom::interfaces::nsIWebNavigation

#[repr(C)]
pub struct nsIWebNavigation { /* fields omitted */ }

interface nsIWebNavigation : nsISupports

/**
 * 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.
 */

Methods

impl nsIWebNavigation

pub fn coerce<T: nsIWebNavigationCoerce>(&self) -> &T

Cast this nsIWebNavigation to one of its base interfaces.

impl nsIWebNavigation

pub const LOAD_FLAGS_MASK: i64

LOAD_FLAGS_MASK: i64 = 65535

/****************************************************************************
   * 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().
   */

pub const LOAD_FLAGS_NONE: i64

LOAD_FLAGS_NONE: i64 = 0

/**
   * This is the default value for the load flags parameter.
   */

pub const LOAD_FLAGS_IS_REFRESH: i64

LOAD_FLAGS_IS_REFRESH: i64 = 16

/**
   * 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.
   */

pub const LOAD_FLAGS_IS_LINK: i64

LOAD_FLAGS_IS_LINK: i64 = 32

/**
   * 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.
   */

pub const LOAD_FLAGS_BYPASS_HISTORY: i64

LOAD_FLAGS_BYPASS_HISTORY: i64 = 64

/**
   * This flag specifies that history should not be updated.  This flag is only
   * applicable to loadURI.
   */

pub const LOAD_FLAGS_REPLACE_HISTORY: i64

LOAD_FLAGS_REPLACE_HISTORY: i64 = 128

/**
   * This flag specifies that any existing history entry should be replaced.
   * This flag is only applicable to loadURI.
   */

pub const LOAD_FLAGS_BYPASS_CACHE: i64

LOAD_FLAGS_BYPASS_CACHE: i64 = 256

/**
   * This flag specifies that the local web cache should be bypassed, but an
   * intermediate proxy cache could still be used to satisfy the load.
   */

pub const LOAD_FLAGS_BYPASS_PROXY: i64

LOAD_FLAGS_BYPASS_PROXY: i64 = 512

/**
   * This flag specifies that any intermediate proxy caches should be bypassed
   * (i.e., that the content should be loaded from the origin server).
   */

pub const LOAD_FLAGS_CHARSET_CHANGE: i64

LOAD_FLAGS_CHARSET_CHANGE: i64 = 1024

/**
   * This flag specifies that a reload was triggered as a result of detecting
   * an incorrect character encoding while parsing a previously loaded
   * document.
   */

pub const LOAD_FLAGS_STOP_CONTENT: i64

LOAD_FLAGS_STOP_CONTENT: i64 = 2048

/**
   * 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.
   */

pub const LOAD_FLAGS_FROM_EXTERNAL: i64

LOAD_FLAGS_FROM_EXTERNAL: i64 = 4096

/**
   * A hint this load was prompted by an external program: take care!
   */

pub const LOAD_FLAGS_ALLOW_MIXED_CONTENT: i64

LOAD_FLAGS_ALLOW_MIXED_CONTENT: i64 = 8192

/**
    This flag is set when a user explicitly disables the Mixed Content
    Blocker, and allows Mixed Content to load on an https page.
  */

pub const LOAD_FLAGS_FIRST_LOAD: i64

LOAD_FLAGS_FIRST_LOAD: i64 = 16384

/**
   * 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.
   */

pub const LOAD_FLAGS_ALLOW_POPUPS: i64

LOAD_FLAGS_ALLOW_POPUPS: i64 = 32768

/**
   * This flag specifies that the load should not be subject to popup
   * blocking checks.  This flag must not be passed to Reload.
   */

pub const LOAD_FLAGS_BYPASS_CLASSIFIER: i64

LOAD_FLAGS_BYPASS_CLASSIFIER: i64 = 65536

/**
   * This flag specifies that the URI classifier should not be checked for
   * this load.  This flag must not be passed to Reload.
   */

pub const LOAD_FLAGS_FORCE_ALLOW_COOKIES: i64

LOAD_FLAGS_FORCE_ALLOW_COOKIES: i64 = 131072

/**
   * Force relevant cookies to be sent with this load even if normally they
   * wouldn't be.
   */

pub const LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL: i64

LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL: i64 = 262144

/**
   * Prevent the owner principal from being inherited for this load.
   * Note: Within Gecko we use the term principal rather than owners
   *       but some legacy addons might still rely on the outdated term.
   */

pub const LOAD_FLAGS_DISALLOW_INHERIT_OWNER: i64

LOAD_FLAGS_DISALLOW_INHERIT_OWNER: i64 = 262144

pub const LOAD_FLAGS_ERROR_LOAD_CHANGES_RV: i64

LOAD_FLAGS_ERROR_LOAD_CHANGES_RV: i64 = 524288

/**
   * Overwrite the returned error code with a specific result code
   * when an error page is displayed.
   */

pub const LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP: i64

LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP: i64 = 1048576

/**
   * 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.
   */

pub const LOAD_FLAGS_FIXUP_SCHEME_TYPOS: i64

LOAD_FLAGS_FIXUP_SCHEME_TYPOS: i64 = 2097152

/**
   * This flag specifies that common scheme typos should be corrected.
   */

pub const LOAD_FLAGS_FORCE_ALLOW_DATA_URI: i64

LOAD_FLAGS_FORCE_ALLOW_DATA_URI: i64 = 4194304

/**
   * Allows a top-level data: navigation to occur. E.g. view-image
   * is an explicit user action which should be allowed.
   */

pub const STOP_NETWORK: i64

STOP_NETWORK: i64 = 1

/****************************************************************************
   * 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.
   */

pub const STOP_CONTENT: i64

STOP_CONTENT: i64 = 2

/**
   * This flag specifies that all content activity should be stopped.  This
   * includes animated images, plugins and pending Javascript timeouts.
   */

pub const STOP_ALL: i64

STOP_ALL: i64 = 3

/**
   * This flag specifies that all activity should be stopped.
   */

pub unsafe fn GetCanGoBack(&self, aCanGoBack: *mut bool) -> nsresult

/**
   * Indicates if the object can go back.  If true this indicates that
   * there is back session history available for navigation.
   */

readonly attribute boolean canGoBack;

pub unsafe fn GetCanGoForward(&self, aCanGoForward: *mut bool) -> nsresult

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

readonly attribute boolean canGoForward;

pub unsafe fn GoBack(&self) -> nsresult

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

pub unsafe fn GoForward(&self) -> nsresult

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

pub unsafe fn GotoIndex(&self, index: int32_t) -> nsresult

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

pub unsafe fn LoadURI(
    &self,
    aURI: *const int16_t,
    aLoadFlags: uint32_t,
    aReferrer: *const nsIURI,
    aPostData: *const nsIInputStream,
    aHeaders: *const nsIInputStream,
    aTriggeringPrincipal: *const nsIPrincipal
) -> nsresult

/**
   * 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.
   * @param aTriggeringPrincipal
   *        The principal that initiated the load of aURI. If omitted docShell
   *        tries to create a codeBasePrincipal from aReferrer if not null. If
   *        aReferrer is also null docShell peforms a load using the
   *        SystemPrincipal as the triggeringPrincipal.
   */

void loadURI (in wstring aURI, in unsigned long aLoadFlags, in nsIURI aReferrer, in nsIInputStream aPostData, in nsIInputStream aHeaders, [optional] in nsIPrincipal aTriggeringPrincipal);

pub unsafe fn LoadURIWithOptions(
    &self,
    aURI: *const int16_t,
    aLoadFlags: uint32_t,
    aReferrer: *const nsIURI,
    aReferrerPolicy: uint32_t,
    aPostData: *const nsIInputStream,
    aHeaders: *const nsIInputStream,
    aBaseURI: *const nsIURI,
    aTriggeringPrincipal: *const nsIPrincipal
) -> nsresult

/**
   * 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, but allows passing of additional parameters.
   *
   * @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 aReferrerPolicy
   *        One of the REFERRER_POLICY_* constants from nsIHttpChannel.
   *        Normal case is REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE.
   * @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.
   * @param aTriggeringPrincipal
   *        The principal that initiated the load of aURI. If omitted docShell
   *        tries to create a codeBasePrincipal from aReferrer if not null. If
   *        aReferrer is also null docShell peforms a load using the
   *        SystemPrincipal as the triggeringPrincipal.
   */

void loadURIWithOptions (in wstring aURI, in unsigned long aLoadFlags, in nsIURI aReferrer, in unsigned long aReferrerPolicy, in nsIInputStream aPostData, in nsIInputStream aHeaders, in nsIURI aBaseURI, [optional] in nsIPrincipal aTriggeringPrincipal);

pub unsafe fn Reload(&self, aReloadFlags: uint32_t) -> nsresult

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

pub unsafe fn Stop(&self, aStopFlags: uint32_t) -> nsresult

/**
   * Stops a load of a URI.
   *
   * @param aStopFlags
   *        This parameter is one of the stop flags defined above.
   */

void stop (in unsigned long aStopFlags);

pub unsafe fn GetDocument(
    &self,
    aDocument: *mut *const nsIDOMDocument
) -> nsresult

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

pub unsafe fn GetCurrentURI(&self, aCurrentURI: *mut *const nsIURI) -> nsresult

/**
   * The currently loaded URI or null.
   */

readonly attribute nsIURI currentURI;

pub unsafe fn GetReferringURI(
    &self,
    aReferringURI: *mut *const nsIURI
) -> nsresult

/**
   * The referring URI for the currently loaded URI or null.
   */

readonly attribute nsIURI referringURI;

pub unsafe fn GetSessionHistory(
    &self,
    aSessionHistory: *mut *const nsISHistory
) -> nsresult

/**
   * The session history object used by this web navigation instance.
   */

attribute nsISHistory sessionHistory;

pub unsafe fn SetSessionHistory(
    &self,
    aSessionHistory: *const nsISHistory
) -> nsresult

/**
   * The session history object used by this web navigation instance.
   */

attribute nsISHistory sessionHistory;

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIWebNavigation

const IID: nsIID

IID: nsIID = nsID(987658708, 36025, 18770, [177, 141, 79, 155, 99, 202, 13, 49])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIWebNavigation

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIWebNavigation

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.