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


/// `interface nsISHistoryListener : nsISupports`
///

/// ```text
/// /**
///  * nsISHistoryListener defines the interface one can implement to receive
///  * notifications about activities in session history and to be able to
///  * cancel them.
///  *
///  * A session history listener will be notified when pages are added, removed
///  * and loaded from session history. It can prevent any action (except adding
    ///  * a new session history entry) from happening by returning false from the
///  * corresponding callback method.
///  *
///  * A session history listener can be registered on a particular nsISHistory
///  * instance via the nsISHistory::addSHistoryListener() method.
///  */
/// ```
///

// 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 nsISHistoryListener {
    vtable: *const nsISHistoryListenerVTable,

    /// 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 nsISHistoryListener.
unsafe impl XpCom for nsISHistoryListener {
    const IID: nsIID = nsID(0x125c0833, 0x746a, 0x400e,
        [0x9b, 0x89, 0xd2, 0xd1, 0x85, 0x45, 0xc0, 0x8a]);
}

// 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 nsISHistoryListener {
    #[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 nsISHistoryListener.
// 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 nsISHistoryListenerCoerce {
    /// Cheaply cast a value of this type from a `nsISHistoryListener`.
    fn coerce_from(v: &nsISHistoryListener) -> &Self;
}

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

impl nsISHistoryListener {
    /// Cast this `nsISHistoryListener` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISHistoryListenerCoerce>(&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 nsISHistoryListener {
    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> nsISHistoryListenerCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISHistoryListener) -> &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 nsISHistoryListener
// 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 nsISHistoryListenerVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* void OnHistoryNewEntry (in nsIURI aNewURI, in long aOldIndex); */
    pub OnHistoryNewEntry: unsafe extern "system" fn (this: *const nsISHistoryListener, aNewURI: *const nsIURI, aOldIndex: libc::int32_t) -> nsresult,

    /* boolean OnHistoryGoBack (in nsIURI aBackURI); */
    pub OnHistoryGoBack: unsafe extern "system" fn (this: *const nsISHistoryListener, aBackURI: *const nsIURI, _retval: *mut bool) -> nsresult,

    /* boolean OnHistoryGoForward (in nsIURI aForwardURI); */
    pub OnHistoryGoForward: unsafe extern "system" fn (this: *const nsISHistoryListener, aForwardURI: *const nsIURI, _retval: *mut bool) -> nsresult,

    /* boolean OnHistoryReload (in nsIURI aReloadURI, in unsigned long aReloadFlags); */
    pub OnHistoryReload: unsafe extern "system" fn (this: *const nsISHistoryListener, aReloadURI: *const nsIURI, aReloadFlags: libc::uint32_t, _retval: *mut bool) -> nsresult,

    /* boolean OnHistoryGotoIndex (in long aIndex, in nsIURI aGotoURI); */
    pub OnHistoryGotoIndex: unsafe extern "system" fn (this: *const nsISHistoryListener, aIndex: libc::int32_t, aGotoURI: *const nsIURI, _retval: *mut bool) -> nsresult,

    /* boolean OnHistoryPurge (in long aNumEntries); */
    pub OnHistoryPurge: unsafe extern "system" fn (this: *const nsISHistoryListener, aNumEntries: libc::int32_t, _retval: *mut bool) -> nsresult,

    /* void OnHistoryReplaceEntry (in long aIndex); */
    pub OnHistoryReplaceEntry: unsafe extern "system" fn (this: *const nsISHistoryListener, aIndex: libc::int32_t) -> nsresult,

    /* void OnLengthChanged (in long aCount); */
    pub OnLengthChanged: unsafe extern "system" fn (this: *const nsISHistoryListener, aCount: libc::int32_t) -> nsresult,

    /* void OnIndexChanged (in long aIndex); */
    pub OnIndexChanged: unsafe extern "system" fn (this: *const nsISHistoryListener, aIndex: 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 nsISHistoryListener {

    /// ```text
    /// /**
    ///    * Called when a new document is added to session history. New documents are
    ///    * added to session history by docshell when new pages are loaded in a frame
    ///    * or content area, for example via nsIWebNavigation::loadURI()
    ///    *
    ///    * @param aNewURI     The URI of the document to be added to session history.
    ///    * @param aOldIndex   The index of the current history item before the operation.
    ///    */
    /// ```
    ///

    /// `void OnHistoryNewEntry (in nsIURI aNewURI, in long aOldIndex);`
    #[inline]
    pub unsafe fn OnHistoryNewEntry(&self, aNewURI: *const nsIURI, aOldIndex: libc::int32_t) -> nsresult {
        ((*self.vtable).OnHistoryNewEntry)(self, aNewURI, aOldIndex)
    }


    /// ```text
    /// /**
    ///    * Called when navigating to a previous session history entry, for example
    ///    * due to a nsIWebNavigation::goBack() call.
    ///    *
    ///    * @param aBackURI    The URI of the session history entry being navigated to.
    ///    *                    It could be null in case of a grouped session history
    ///    *                    navigation since we have no URI information of entries
    ///    *                    existing in other partial histories.
    ///    * @return            Whether the operation can proceed.
    ///    */
    /// ```
    ///

    /// `boolean OnHistoryGoBack (in nsIURI aBackURI);`
    #[inline]
    pub unsafe fn OnHistoryGoBack(&self, aBackURI: *const nsIURI, _retval: *mut bool) -> nsresult {
        ((*self.vtable).OnHistoryGoBack)(self, aBackURI, _retval)
    }


    /// ```text
    /// /**
    ///    * Called when navigating to a next session history entry, for example
    ///    * due to a nsIWebNavigation::goForward() call.
    ///    *
    ///    * @param aForwardURI   The URI of the session history entry being navigated to.
    ///    *                      It could be null in case of a grouped session history
    ///    *                      navigation since we have no URI information of entries
    ///    *                      existing in other partial histories.
    ///    * @return              Whether the operation can proceed.
    ///    */
    /// ```
    ///

    /// `boolean OnHistoryGoForward (in nsIURI aForwardURI);`
    #[inline]
    pub unsafe fn OnHistoryGoForward(&self, aForwardURI: *const nsIURI, _retval: *mut bool) -> nsresult {
        ((*self.vtable).OnHistoryGoForward)(self, aForwardURI, _retval)
    }


    /// ```text
    /// /**
    ///    * Called when the current document is reloaded, for example due to a
    ///    * nsIWebNavigation::reload() call.
    ///    *
    ///    * @param aReloadURI    The URI of the document to be reloaded.
    ///    * @param aReloadFlags  Flags that indicate how the document is to be
    ///    *                      refreshed. See constants on the nsIWebNavigation
    ///    *                      interface.
    ///    * @return              Whether the operation can proceed.
    ///    *
    ///    * @see  nsIWebNavigation
    ///    */
    /// ```
    ///

    /// `boolean OnHistoryReload (in nsIURI aReloadURI, in unsigned long aReloadFlags);`
    #[inline]
    pub unsafe fn OnHistoryReload(&self, aReloadURI: *const nsIURI, aReloadFlags: libc::uint32_t, _retval: *mut bool) -> nsresult {
        ((*self.vtable).OnHistoryReload)(self, aReloadURI, aReloadFlags, _retval)
    }


    /// ```text
    /// /**
    ///    * Called when navigating to a session history entry by index, for example,
    ///    * when nsIWebNavigation::gotoIndex() is called.
    ///    *
    ///    * @param aIndex        The index in session history of the entry to be loaded.
    ///    * @param aGotoURI      The URI of the session history entry to be loaded.
    ///    *                      It could be null in case of a grouped session history
    ///    *                      navigation since we have no URI information of entries
    ///    *                      existing in other partial histories.
    ///    * @return              Whether the operation can proceed.
    ///    */
    /// ```
    ///

    /// `boolean OnHistoryGotoIndex (in long aIndex, in nsIURI aGotoURI);`
    #[inline]
    pub unsafe fn OnHistoryGotoIndex(&self, aIndex: libc::int32_t, aGotoURI: *const nsIURI, _retval: *mut bool) -> nsresult {
        ((*self.vtable).OnHistoryGotoIndex)(self, aIndex, aGotoURI, _retval)
    }


    /// ```text
    /// /**
    ///    * Called when entries are removed from session history. Entries can be
    ///    * removed from session history for various reasons, for example to control
    ///    * the memory usage of the browser, to prevent users from loading documents
    ///    * from history, to erase evidence of prior page loads, etc.
    ///    *
    ///    * To purge documents from session history call nsISHistory::PurgeHistory()
    ///    *
    ///    * @param aNumEntries   The number of entries to be removed from session history.
    ///    * @return              Whether the operation can proceed.
    ///    */
    /// ```
    ///

    /// `boolean OnHistoryPurge (in long aNumEntries);`
    #[inline]
    pub unsafe fn OnHistoryPurge(&self, aNumEntries: libc::int32_t, _retval: *mut bool) -> nsresult {
        ((*self.vtable).OnHistoryPurge)(self, aNumEntries, _retval)
    }


    /// ```text
    /// /**
    ///    * Called when an entry is replaced in the session history. Entries are
    ///    * replaced when navigating away from non-persistent history entries (such as
        ///    * about pages) and when history.replaceState is called.
    ///    *
    ///    * @param aIndex        The index in session history of the entry being
    ///   *                       replaced
    ///    */
    /// ```
    ///

    /// `void OnHistoryReplaceEntry (in long aIndex);`
    #[inline]
    pub unsafe fn OnHistoryReplaceEntry(&self, aIndex: libc::int32_t) -> nsresult {
        ((*self.vtable).OnHistoryReplaceEntry)(self, aIndex)
    }


    /// ```text
    /// /**
    ///     * Called when nsISHistory::count has been updated. Unlike OnHistoryNewEntry
    ///     * and OnHistoryPurge which happen before the modifications are actually done
    ///     * and maybe cancellable, this function is called after these modifications.
    ///     */
    /// ```
    ///

    /// `void OnLengthChanged (in long aCount);`
    #[inline]
    pub unsafe fn OnLengthChanged(&self, aCount: libc::int32_t) -> nsresult {
        ((*self.vtable).OnLengthChanged)(self, aCount)
    }


    /// ```text
    /// /**
    ///    * Called when nsISHistory::index has been updated. Unlike the other methods
    ///    * on this interface, which happen before the modifications are actually done
    ///    * and maybe cancellable, this function is called after these modifications.
    ///    */
    /// ```
    ///

    /// `void OnIndexChanged (in long aIndex);`
    #[inline]
    pub unsafe fn OnIndexChanged(&self, aIndex: libc::int32_t) -> nsresult {
        ((*self.vtable).OnIndexChanged)(self, aIndex)
    }


}