//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsISHistory.idl
//


/// `interface nsISHistory : nsISupports`
///

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

// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsISHistory {
    vtable: *const nsISHistoryVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsISHistory.
unsafe impl XpCom for nsISHistory {
    const IID: nsIID = nsID(0x7b807041, 0xe60a, 0x4384,
        [0x93, 0x5f, 0xaf, 0x30, 0x61, 0xd8, 0xb8, 0x15]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsISHistory {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsISHistory.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsISHistoryCoerce {
    /// Cheaply cast a value of this type from a `nsISHistory`.
    fn coerce_from(v: &nsISHistory) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsISHistoryCoerce for nsISHistory {
    #[inline]
    fn coerce_from(v: &nsISHistory) -> &Self {
        v
    }
}

impl nsISHistory {
    /// Cast this `nsISHistory` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISHistoryCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsISHistory {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsISHistoryCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISHistory) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsISHistory
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsISHistoryVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* readonly attribute bool isPartial; */
    pub GetIsPartial: unsafe extern "system" fn (this: *const nsISHistory, aIsPartial: *mut bool) -> nsresult,

    /* readonly attribute long count; */
    pub GetCount: unsafe extern "system" fn (this: *const nsISHistory, aCount: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long globalCount; */
    pub GetGlobalCount: unsafe extern "system" fn (this: *const nsISHistory, aGlobalCount: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long globalIndexOffset; */
    pub GetGlobalIndexOffset: unsafe extern "system" fn (this: *const nsISHistory, aGlobalIndexOffset: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long index; */
    pub GetIndex: unsafe extern "system" fn (this: *const nsISHistory, aIndex: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long globalIndex; */
    pub GetGlobalIndex: unsafe extern "system" fn (this: *const nsISHistory, aGlobalIndex: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long requestedIndex; */
    pub GetRequestedIndex: unsafe extern "system" fn (this: *const nsISHistory, aRequestedIndex: *mut libc::int32_t) -> nsresult,

    /* attribute long maxLength; */
    pub GetMaxLength: unsafe extern "system" fn (this: *const nsISHistory, aMaxLength: *mut libc::int32_t) -> nsresult,

    /* attribute long maxLength; */
    pub SetMaxLength: unsafe extern "system" fn (this: *const nsISHistory, aMaxLength: libc::int32_t) -> nsresult,

    /* nsISHEntry getEntryAtIndex (in long index, in boolean modifyIndex); */
    pub GetEntryAtIndex: unsafe extern "system" fn (this: *const nsISHistory, index: libc::int32_t, modifyIndex: bool, _retval: *mut *const nsISHEntry) -> nsresult,

    /* void restoreToEntryAtIndex (in long index); */
    pub RestoreToEntryAtIndex: unsafe extern "system" fn (this: *const nsISHistory, index: libc::int32_t) -> nsresult,

    /* void PurgeHistory (in long numEntries); */
    pub PurgeHistory: unsafe extern "system" fn (this: *const nsISHistory, numEntries: libc::int32_t) -> nsresult,

    /* void addSHistoryListener (in nsISHistoryListener aListener); */
    pub AddSHistoryListener: unsafe extern "system" fn (this: *const nsISHistory, aListener: *const nsISHistoryListener) -> nsresult,

    /* void removeSHistoryListener (in nsISHistoryListener aListener); */
    pub RemoveSHistoryListener: unsafe extern "system" fn (this: *const nsISHistory, aListener: *const nsISHistoryListener) -> nsresult,

    /* void setPartialSHistoryListener (in nsIPartialSHistoryListener aListener); */
    pub SetPartialSHistoryListener: unsafe extern "system" fn (this: *const nsISHistory, aListener: *const nsIPartialSHistoryListener) -> nsresult,

    /* readonly attribute nsISimpleEnumerator SHistoryEnumerator; */
    pub GetSHistoryEnumerator: unsafe extern "system" fn (this: *const nsISHistory, aSHistoryEnumerator: *mut *const nsISimpleEnumerator) -> nsresult,

    /* void reloadCurrentEntry (); */
    pub ReloadCurrentEntry: unsafe extern "system" fn (this: *const nsISHistory) -> nsresult,

    /* long getIndexOfEntry (in nsISHEntry aEntry); */
    pub GetIndexOfEntry: unsafe extern "system" fn (this: *const nsISHistory, aEntry: *const nsISHEntry, _retval: *mut libc::int32_t) -> nsresult,

    /* void onPartialSHistoryActive (in long globalLength, in long targetIndex); */
    pub OnPartialSHistoryActive: unsafe extern "system" fn (this: *const nsISHistory, globalLength: libc::int32_t, targetIndex: libc::int32_t) -> nsresult,

    /* void onPartialSHistoryDeactive (); */
    pub OnPartialSHistoryDeactive: unsafe extern "system" fn (this: *const nsISHistory) -> nsresult,

    /* void onAttachGroupedSHistory (in long offset); */
    pub OnAttachGroupedSHistory: unsafe extern "system" fn (this: *const nsISHistory, offset: libc::int32_t) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsISHistory {
    /// ```text
    /// /**
    ///    * 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 const VIEWER_WINDOW: i64 = 3;

    /// ```text
    /// /**
    ///    * 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;`
    #[inline]
    pub unsafe fn GetIsPartial(&self, aIsPartial: *mut bool) -> nsresult {
        ((*self.vtable).GetIsPartial)(self, aIsPartial)
    }


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

    /// `readonly attribute long count;`
    #[inline]
    pub unsafe fn GetCount(&self, aCount: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetCount)(self, aCount)
    }


    /// ```text
    /// /**
    ///    * 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;`
    #[inline]
    pub unsafe fn GetGlobalCount(&self, aGlobalCount: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetGlobalCount)(self, aGlobalCount)
    }


    /// ```text
    /// /**
    ///    * 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;`
    #[inline]
    pub unsafe fn GetGlobalIndexOffset(&self, aGlobalIndexOffset: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetGlobalIndexOffset)(self, aGlobalIndexOffset)
    }


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

    /// `readonly attribute long index;`
    #[inline]
    pub unsafe fn GetIndex(&self, aIndex: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetIndex)(self, aIndex)
    }


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

    /// `readonly attribute long globalIndex;`
    #[inline]
    pub unsafe fn GetGlobalIndex(&self, aGlobalIndex: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetGlobalIndex)(self, aGlobalIndex)
    }


    /// ```text
    /// /**
    ///    * 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;`
    #[inline]
    pub unsafe fn GetRequestedIndex(&self, aRequestedIndex: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetRequestedIndex)(self, aRequestedIndex)
    }


    /// ```text
    /// /**
    ///    * 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;`
    #[inline]
    pub unsafe fn GetMaxLength(&self, aMaxLength: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetMaxLength)(self, aMaxLength)
    }


    /// ```text
    /// /**
    ///    * 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;`
    #[inline]
    pub unsafe fn SetMaxLength(&self, aMaxLength: libc::int32_t) -> nsresult {
        ((*self.vtable).SetMaxLength)(self, aMaxLength)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn GetEntryAtIndex(&self, index: libc::int32_t, modifyIndex: bool, _retval: *mut *const nsISHEntry) -> nsresult {
        ((*self.vtable).GetEntryAtIndex)(self, index, modifyIndex, _retval)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn RestoreToEntryAtIndex(&self, index: libc::int32_t) -> nsresult {
        ((*self.vtable).RestoreToEntryAtIndex)(self, index)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn PurgeHistory(&self, numEntries: libc::int32_t) -> nsresult {
        ((*self.vtable).PurgeHistory)(self, numEntries)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn AddSHistoryListener(&self, aListener: *const nsISHistoryListener) -> nsresult {
        ((*self.vtable).AddSHistoryListener)(self, aListener)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn RemoveSHistoryListener(&self, aListener: *const nsISHistoryListener) -> nsresult {
        ((*self.vtable).RemoveSHistoryListener)(self, aListener)
    }


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

    /// `void setPartialSHistoryListener (in nsIPartialSHistoryListener aListener);`
    #[inline]
    pub unsafe fn SetPartialSHistoryListener(&self, aListener: *const nsIPartialSHistoryListener) -> nsresult {
        ((*self.vtable).SetPartialSHistoryListener)(self, aListener)
    }


    /// ```text
    /// /**
    ///    * 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;`
#[inline]
pub unsafe fn GetSHistoryEnumerator(&self, aSHistoryEnumerator: *mut *const nsISimpleEnumerator) -> nsresult {
((*self.vtable).GetSHistoryEnumerator)(self, aSHistoryEnumerator)
}



/// `void reloadCurrentEntry ();`
#[inline]
pub unsafe fn ReloadCurrentEntry(&self, ) -> nsresult {
((*self.vtable).ReloadCurrentEntry)(self, )
}


/// ```text
/// /**
///    * 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);`
#[inline]
pub unsafe fn GetIndexOfEntry(&self, aEntry: *const nsISHEntry, _retval: *mut libc::int32_t) -> nsresult {
((*self.vtable).GetIndexOfEntry)(self, aEntry, _retval)
}


/// ```text
/// /**
///    * 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);`
#[inline]
pub unsafe fn OnPartialSHistoryActive(&self, globalLength: libc::int32_t, targetIndex: libc::int32_t) -> nsresult {
((*self.vtable).OnPartialSHistoryActive)(self, globalLength, targetIndex)
}


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

/// `void onPartialSHistoryDeactive ();`
#[inline]
pub unsafe fn OnPartialSHistoryDeactive(&self, ) -> nsresult {
((*self.vtable).OnPartialSHistoryDeactive)(self, )
}


/// ```text
/// /**
///    * 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);`
#[inline]
pub unsafe fn OnAttachGroupedSHistory(&self, offset: libc::int32_t) -> nsresult {
((*self.vtable).OnAttachGroupedSHistory)(self, offset)
}


}