Struct xpcom::interfaces::nsISHistory

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

interface nsISHistory : nsISupports

/**
 * An interface to the primary properties of the Session History
 * component. In an embedded browser environment, the nsIWebBrowser
 * object creates an instance of session history for each open window.
 * A handle to the session history object can be obtained from
 * nsIWebNavigation. In a non-embedded situation, the  owner of the
 * session history component must create a instance of it and set
 * it in the nsIWebNavigation object.
 * This interface is accessible from javascript.
 */

Methods

impl nsISHistory

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

Cast this nsISHistory to one of its base interfaces.

impl nsISHistory

pub const VIEWER_WINDOW: i64

VIEWER_WINDOW: i64 = 3

/**
   * The size of the window of SHEntries which can have alive viewers in the
   * bfcache around the currently active SHEntry.
   *
   * We try to keep viewers for SHEntries between index - VIEWER_WINDOW and
   * index + VIEWER_WINDOW alive.
   */

pub unsafe fn GetIsPartial(&self, aIsPartial: *mut bool) -> nsresult

/**
   * An attribute denoting whether the nsISHistory is associated to a grouped
   * session history.
   *
   * The abstraction of grouped session history is implemented at
   * nsIWebNavigation level, so those canGoBack / canGoForward / gotoIndex
   * functions work transparently;
   *
   * On the other hand, nsISHistory works on partial session history directly.
   * Unless otherwise specified, count / index attributes and parameters all
   * indicate local count / index, so we won't mess up docshell.
   */

readonly attribute bool isPartial;

pub unsafe fn GetCount(&self, aCount: *mut int32_t) -> nsresult

/**
   * A readonly property of the interface that returns
   * the number of toplevel documents currently available
   * in session history.
   */

readonly attribute long count;

pub unsafe fn GetGlobalCount(&self, aGlobalCount: *mut int32_t) -> nsresult

/**
   * If isPartial, globalCount denotes the total number of entries in the
   * grouped session history; Otherwise it has the same value as count.
   */

readonly attribute long globalCount;

pub unsafe fn GetGlobalIndexOffset(
    &self,
    aGlobalIndexOffset: *mut int32_t
) -> nsresult

/**
   * A readonly property which represents the difference between global indices
   * of grouped session history and local indices of this particular session
   * history object.
   */

readonly attribute long globalIndexOffset;

pub unsafe fn GetIndex(&self, aIndex: *mut int32_t) -> nsresult

/**
   * A readonly property of the interface that returns
   * the index of the current document in session history.
   */

readonly attribute long index;

pub unsafe fn GetGlobalIndex(&self, aGlobalIndex: *mut int32_t) -> nsresult

/**
   * A readonly property which equals index + globalIndexOffset.
   */

readonly attribute long globalIndex;

pub unsafe fn GetRequestedIndex(
    &self,
    aRequestedIndex: *mut int32_t
) -> nsresult

/**
   * A readonly property of the interface that returns
   * the index of the last document that started to load and
   * didn't finished yet. When document finishes the loading
   * value -1 is returned.
   */

readonly attribute long requestedIndex;

pub unsafe fn GetMaxLength(&self, aMaxLength: *mut int32_t) -> nsresult

/**
   * A read/write property of the interface, used to Get/Set
   * the maximum number of toplevel documents, session history
   * can hold for each instance.
   */

attribute long maxLength;

pub unsafe fn SetMaxLength(&self, aMaxLength: int32_t) -> nsresult

/**
   * A read/write property of the interface, used to Get/Set
   * the maximum number of toplevel documents, session history
   * can hold for each instance.
   */

attribute long maxLength;

pub unsafe fn GetEntryAtIndex(
    &self,
    index: int32_t,
    modifyIndex: bool,
    _retval: *mut *const nsISHEntry
) -> nsresult

/**
   * Called to obtain handle to the history entry at a
   * given index.
   *
   * @param index             The index value whose entry is requested.
   *                          The oldest entry is located at index == 0.
   * @param modifyIndex       A boolean flag that indicates if the current
   *                          index of session history should be modified
   *                          to the parameter index.
   *
   * @return                  <code>NS_OK</code> history entry for
   *                          the index is obtained successfully.
   *                          <code>NS_ERROR_FAILURE</code> Error in obtaining
   *                          history entry for the given index.
   */

nsISHEntry getEntryAtIndex (in long index, in boolean modifyIndex);

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

/**
   * Load the entry at given index to root docshell directly in order to
   * restore to an entry in grouped session history navigation or session
   * restore case. This function will not notify nsISHistoryListener, as it's
   * not considered a normal history navigation.
   */

void restoreToEntryAtIndex (in long index);

pub unsafe fn PurgeHistory(&self, numEntries: int32_t) -> nsresult

/**
   * Called to purge older documents from history.
   * Documents can be removed from session history for various
   * reasons. For example to  control memory usage of the browser, to
   * prevent users from loading documents from history, to erase evidence of
   * prior page loads etc...
   *
   * @param numEntries        The number of toplevel documents to be
   *                          purged from history. During purge operation,
   *                          the latest documents are maintained and older
   *                          'numEntries' documents are removed from history.
   * @throws                  <code>NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA</code> Purge was vetod.
   * @throws                  <code>NS_ERROR_FAILURE</code> numEntries is
   *                          invalid or out of bounds with the size of history.
   *
   */

void PurgeHistory (in long numEntries);

pub unsafe fn AddSHistoryListener(
    &self,
    aListener: *const nsISHistoryListener
) -> nsresult

/**
   * Called to register a listener for the session history component.
   * Listeners are notified when pages are loaded or purged from history.
   *
   * @param aListener         Listener object to be notified for all
   *                          page loads that initiate in session history.
   *
   * @note                    A listener object must implement
   *                          nsISHistoryListener and nsSupportsWeakReference
   *
   * @see nsISHistoryListener
   * @see nsSupportsWeakReference
   */

void addSHistoryListener (in nsISHistoryListener aListener);

pub unsafe fn RemoveSHistoryListener(
    &self,
    aListener: *const nsISHistoryListener
) -> nsresult

/**
   * Called to remove a listener for the session history component.
   * Listeners are notified when pages are loaded from history.
   *
   * @param aListener         Listener object to be removed from
   *                          session history.
   *
   * @note                    A listener object must implement
   *                          nsISHistoryListener and nsSupportsWeakReference
   * @see nsISHistoryListener
   * @see nsSupportsWeakReference
   */

void removeSHistoryListener (in nsISHistoryListener aListener);

pub unsafe fn SetPartialSHistoryListener(
    &self,
    aListener: *const nsIPartialSHistoryListener
) -> nsresult

/**
   * Set the listener to handle cross nsISHistory navigation when it works
   * in "partial" mode.
   */

void setPartialSHistoryListener (in nsIPartialSHistoryListener aListener);

pub unsafe fn GetSHistoryEnumerator(
    &self,
    aSHistoryEnumerator: *mut *const nsISimpleEnumerator
) -> nsresult

/**
   * Called to obtain a enumerator for all the  documents stored in
   * session history. The enumerator object thus returned by this method
   * can be traversed using nsISimpleEnumerator.
   *
   * @note  To access individual history entries of the enumerator, perform the
   *        following steps:
   *        1) Call nsISHistory->GetSHistoryEnumerator() to obtain handle
   *           the nsISimpleEnumerator object.
   *        2) Use nsISimpleEnumerator->GetNext() on the object returned
   *           by step #1 to obtain handle to the next object in the list.
   *           The object returned by this step is of type nsISupports.
   *        3) Perform a QueryInterface on the object returned by step #2
   *           to nsISHEntry.
   *        4) Use nsISHEntry to access properties of each history entry.
   *
   * @see nsISimpleEnumerator
   * @see nsISHEntry
   * @see QueryInterface()
   * @see do_QueryInterface()
   */

readonly attribute nsISimpleEnumerator SHistoryEnumerator;

pub unsafe fn ReloadCurrentEntry(&self) -> nsresult

void reloadCurrentEntry ();

pub unsafe fn GetIndexOfEntry(
    &self,
    aEntry: *const nsISHEntry,
    _retval: *mut int32_t
) -> nsresult

/**
   * Called to obtain the index to a given history entry.
   *
   * @param aEntry            The entry to obtain the index of.
   *
   * @return                  <code>NS_OK</code> index for the history entry
   *                          is obtained successfully.
   *                          <code>NS_ERROR_FAILURE</code> Error in obtaining
   *                          index for the given history entry.
   */

long getIndexOfEntry (in nsISHEntry aEntry);

pub unsafe fn OnPartialSHistoryActive(
    &self,
    globalLength: int32_t,
    targetIndex: int32_t
) -> nsresult

/**
   * Called when this nsISHistory has became the active history of a grouped
   * session history.
   *
   * @param globalLength      The up to date number of entries in the grouped
   *                          session history.
   * @param targetIndex       The local index to navigate to.
   */

void onPartialSHistoryActive (in long globalLength, in long targetIndex);

pub unsafe fn OnPartialSHistoryDeactive(&self) -> nsresult

/**
   * Called when this nsISHistory has became inactive history of a grouped
   * session history.
   */

void onPartialSHistoryDeactive ();

pub unsafe fn OnAttachGroupedSHistory(&self, offset: int32_t) -> nsresult

/**
   * Called when it's attached to a nsIGroupedSHistory instance.
   *
   * @param offset            The number of entries in the grouped session
   *                          history before this session history object.
   */

void onAttachGroupedSHistory (in long offset);

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 nsISHistory

const IID: nsIID

IID: nsIID = nsID(2072014913, 58890, 17284, [147, 95, 175, 48, 97, 216, 184, 21])

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 nsISHistory

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsISHistory

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.