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


/// `interface nsIXULBrowserWindow : nsISupports`
///

/// ```text
/// /**
///  * The nsIXULBrowserWindow supplies the methods that may be called from the
///  * internals of the browser area to tell the containing xul window to update
///  * its ui.
///  */
/// ```
///

// 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 nsIXULBrowserWindow {
    vtable: *const nsIXULBrowserWindowVTable,

    /// 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 nsIXULBrowserWindow.
unsafe impl XpCom for nsIXULBrowserWindow {
    const IID: nsIID = nsID(0xa8675fa9, 0xc8b4, 0x4350,
        [0x98, 0x03, 0xc3, 0x8f, 0x34, 0x4a, 0x9e, 0x38]);
}

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

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

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

    /* void setJSStatus (in AString status); */
    pub SetJSStatus: unsafe extern "system" fn (this: *const nsIXULBrowserWindow, status: &::nsstring::nsAString) -> nsresult,

    /* void setOverLink (in AString link, in nsIDOMElement element); */
    pub SetOverLink: unsafe extern "system" fn (this: *const nsIXULBrowserWindow, link: &::nsstring::nsAString, element: *const nsIDOMElement) -> nsresult,

    /* AString onBeforeLinkTraversal (in AString originalTarget, in nsIURI linkURI, in nsIDOMNode linkNode, in boolean isAppTab); */
    pub OnBeforeLinkTraversal: unsafe extern "system" fn (this: *const nsIXULBrowserWindow, originalTarget: &::nsstring::nsAString, linkURI: *const nsIURI, linkNode: *const nsIDOMNode, isAppTab: bool, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void forceInitialBrowserRemote (in AString aRemoteType); */
    pub ForceInitialBrowserRemote: unsafe extern "system" fn (this: *const nsIXULBrowserWindow, aRemoteType: &::nsstring::nsAString) -> nsresult,

    /* void forceInitialBrowserNonRemote (in mozIDOMWindowProxy openerWindow); */
    pub ForceInitialBrowserNonRemote: unsafe extern "system" fn (this: *const nsIXULBrowserWindow, openerWindow: *const mozIDOMWindowProxy) -> nsresult,

    /* bool shouldLoadURI (in nsIDocShell aDocShell, in nsIURI aURI, in nsIURI aReferrer, in boolean aHasPostData, in nsIPrincipal aTriggeringPrincipal); */
    pub ShouldLoadURI: unsafe extern "system" fn (this: *const nsIXULBrowserWindow, aDocShell: *const nsIDocShell, aURI: *const nsIURI, aReferrer: *const nsIURI, aHasPostData: bool, aTriggeringPrincipal: *const nsIPrincipal, _retval: *mut bool) -> nsresult,

    /* void showTooltip (in long x, in long y, in AString tooltip, in AString direction, in nsIFrameLoaderOwner browser); */
    pub ShowTooltip: unsafe extern "system" fn (this: *const nsIXULBrowserWindow, x: libc::int32_t, y: libc::int32_t, tooltip: &::nsstring::nsAString, direction: &::nsstring::nsAString, browser: *const nsIFrameLoaderOwner) -> nsresult,

    /* void hideTooltip (); */
    pub HideTooltip: unsafe extern "system" fn (this: *const nsIXULBrowserWindow) -> nsresult,

    /* uint32_t getTabCount (); */
    pub GetTabCount: unsafe extern "system" fn (this: *const nsIXULBrowserWindow, _retval: *mut uint32_t) -> nsresult,

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

    /// ```text
    /// /**
    ///    * Sets the status according to JS' version of status.
    ///    */
    /// ```
    ///

    /// `void setJSStatus (in AString status);`
    #[inline]
    pub unsafe fn SetJSStatus(&self, status: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetJSStatus)(self, status)
    }


    /// ```text
    /// /**
    ///    * Tells the object implementing this function what link we are currently
    ///    * over.
    ///    */
    /// ```
    ///

    /// `void setOverLink (in AString link, in nsIDOMElement element);`
    #[inline]
    pub unsafe fn SetOverLink(&self, link: &::nsstring::nsAString, element: *const nsIDOMElement) -> nsresult {
        ((*self.vtable).SetOverLink)(self, link, element)
    }


    /// ```text
    /// /**
    ///    * Determines the appropriate target for a link.
    ///    */
    /// ```
    ///

    /// `AString onBeforeLinkTraversal (in AString originalTarget, in nsIURI linkURI, in nsIDOMNode linkNode, in boolean isAppTab);`
    #[inline]
    pub unsafe fn OnBeforeLinkTraversal(&self, originalTarget: &::nsstring::nsAString, linkURI: *const nsIURI, linkNode: *const nsIDOMNode, isAppTab: bool, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).OnBeforeLinkTraversal)(self, originalTarget, linkURI, linkNode, isAppTab, _retval)
    }


    /// ```text
    /// /**
    ///    * Find the initial browser of the window and set its remote attributes.
    ///    * This can be used to ensure that there is a browser in a new window of the
    ///    * correct type when it first spawns.
    ///    */
    /// ```
    ///

    /// `void forceInitialBrowserRemote (in AString aRemoteType);`
    #[inline]
    pub unsafe fn ForceInitialBrowserRemote(&self, aRemoteType: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).ForceInitialBrowserRemote)(self, aRemoteType)
    }



    /// `void forceInitialBrowserNonRemote (in mozIDOMWindowProxy openerWindow);`
    #[inline]
    pub unsafe fn ForceInitialBrowserNonRemote(&self, openerWindow: *const mozIDOMWindowProxy) -> nsresult {
        ((*self.vtable).ForceInitialBrowserNonRemote)(self, openerWindow)
    }


    /// ```text
    /// /**
    ///    * Determines whether a load should continue.
    ///    *
    ///    * @param aDocShell
    ///    *        The docshell performing the load.
    ///    * @param aURI
    ///    *        The URI being loaded.
    ///    * @param aReferrer
    ///    *        The referrer of the load.
    ///    * @param aHasPostData
    ///    *        True if the load which is being asked about has associated post data
    ///    *        which would be discarded if the load was redirected across process
    ///    *        boundaries.
    ///    * @param aTriggeringPrincipal
    ///    *        The principal that initiated the load of aURI.
    ///    */
    /// ```
    ///

    /// `bool shouldLoadURI (in nsIDocShell aDocShell, in nsIURI aURI, in nsIURI aReferrer, in boolean aHasPostData, in nsIPrincipal aTriggeringPrincipal);`
    #[inline]
    pub unsafe fn ShouldLoadURI(&self, aDocShell: *const nsIDocShell, aURI: *const nsIURI, aReferrer: *const nsIURI, aHasPostData: bool, aTriggeringPrincipal: *const nsIPrincipal, _retval: *mut bool) -> nsresult {
        ((*self.vtable).ShouldLoadURI)(self, aDocShell, aURI, aReferrer, aHasPostData, aTriggeringPrincipal, _retval)
    }


    /// ```text
    /// /**
    ///    * Show/hide a tooltip (when the user mouses over a link, say).
    ///    */
    /// ```
    ///

    /// `void showTooltip (in long x, in long y, in AString tooltip, in AString direction, in nsIFrameLoaderOwner browser);`
    #[inline]
    pub unsafe fn ShowTooltip(&self, x: libc::int32_t, y: libc::int32_t, tooltip: &::nsstring::nsAString, direction: &::nsstring::nsAString, browser: *const nsIFrameLoaderOwner) -> nsresult {
        ((*self.vtable).ShowTooltip)(self, x, y, tooltip, direction, browser)
    }



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


    /// ```text
    /// /**
    ///    * Return the number of tabs in this window.
    ///    */
    /// ```
    ///

    /// `uint32_t getTabCount ();`
    #[inline]
    pub unsafe fn GetTabCount(&self, _retval: *mut uint32_t) -> nsresult {
        ((*self.vtable).GetTabCount)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Navigate the browser to the given history index after restoring the full history
    ///    * from SessionStore. If the browser is currently in GroupedSHistory mode, it will
    ///    * be reverted to a non-grouped history mode. If a process change is required to
    ///    * perform the load, this will also occur.
    ///    */
    /// ```
    ///

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


}