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


/// `interface nsIWebBrowser : nsISupports`
///

/// ```text
/// /**
///  * The nsIWebBrowser interface is implemented by web browser objects.
///  * Embedders use this interface during initialisation to associate
///  * the new web browser instance with the embedders chrome and
///  * to register any listeners. The interface may also be used at runtime
///  * to obtain the content DOM window and from that the rest of the DOM.
///  */
/// ```
///

// 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 nsIWebBrowser {
    vtable: *const nsIWebBrowserVTable,

    /// 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 nsIWebBrowser.
unsafe impl XpCom for nsIWebBrowser {
    const IID: nsIID = nsID(0x4052b6da, 0x4faa, 0x4646,
        [0xb3, 0xa1, 0x7e, 0x16, 0xa0, 0x1c, 0x2d, 0xc2]);
}

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

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

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

    /* void addWebBrowserListener (in nsIWeakReference aListener, in nsIIDRef aIID); */
    pub AddWebBrowserListener: unsafe extern "system" fn (this: *const nsIWebBrowser, aListener: *const nsIWeakReference, aIID: &nsIID) -> nsresult,

    /* void removeWebBrowserListener (in nsIWeakReference aListener, in nsIIDRef aIID); */
    pub RemoveWebBrowserListener: unsafe extern "system" fn (this: *const nsIWebBrowser, aListener: *const nsIWeakReference, aIID: &nsIID) -> nsresult,

    /* attribute nsIWebBrowserChrome containerWindow; */
    pub GetContainerWindow: unsafe extern "system" fn (this: *const nsIWebBrowser, aContainerWindow: *mut *const nsIWebBrowserChrome) -> nsresult,

    /* attribute nsIWebBrowserChrome containerWindow; */
    pub SetContainerWindow: unsafe extern "system" fn (this: *const nsIWebBrowser, aContainerWindow: *const nsIWebBrowserChrome) -> nsresult,

    /* attribute nsIURIContentListener parentURIContentListener; */
    pub GetParentURIContentListener: unsafe extern "system" fn (this: *const nsIWebBrowser, aParentURIContentListener: *mut *const nsIURIContentListener) -> nsresult,

    /* attribute nsIURIContentListener parentURIContentListener; */
    pub SetParentURIContentListener: unsafe extern "system" fn (this: *const nsIWebBrowser, aParentURIContentListener: *const nsIURIContentListener) -> nsresult,

    /* readonly attribute mozIDOMWindowProxy contentDOMWindow; */
    pub GetContentDOMWindow: unsafe extern "system" fn (this: *const nsIWebBrowser, aContentDOMWindow: *mut *const mozIDOMWindowProxy) -> nsresult,

    /* attribute boolean isActive; */
    pub GetIsActive: unsafe extern "system" fn (this: *const nsIWebBrowser, aIsActive: *mut bool) -> nsresult,

    /* attribute boolean isActive; */
    pub SetIsActive: unsafe extern "system" fn (this: *const nsIWebBrowser, aIsActive: bool) -> nsresult,

    /* [binaryname(SetOriginAttributes),noscript,nostdcall,notxpcom] void binarySetOriginAttributes (in const_OriginAttributesRef aOriginAttrs); */
    /// Unable to generate binding because `native type const mozilla::OriginAttributes is unsupported`
    pub SetOriginAttributes: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIWebBrowser {

    /// ```text
    /// /**
    ///      * Registers a listener of the type specified by the iid to receive
    ///      * callbacks. The browser stores a weak reference to the listener
    ///      * to avoid any circular dependencies.
    ///      * Typically this method will be called to register an object
    ///      * to receive <CODE>nsIWebProgressListener</CODE> or
    ///      * <CODE>nsISHistoryListener</CODE> notifications in which case the
    ///      * the IID is that of the interface.
    ///      *
    ///      * @param aListener The listener to be added.
    ///      * @param aIID      The IID of the interface that will be called
    ///      *                  on the listener as appropriate.
    ///      * @return          <CODE>NS_OK</CODE> for successful registration;
    ///      *                  <CODE>NS_ERROR_INVALID_ARG</CODE> if aIID is not
    ///      *                  supposed to be registered using this method;
    ///      *                  <CODE>NS_ERROR_FAILURE</CODE> either aListener did not
    ///      *                  expose the interface specified by the IID, or some
    ///      *                  other internal error occurred.
    ///      *
    ///      * @see removeWebBrowserListener
    ///      * @see nsIWeakReference
    ///      * @see nsIWebProgressListener
    ///      * @see nsISHistoryListener
    ///      *
    ///      * @return <CODE>NS_OK</CODE>, listener was successfully added;
    ///      *         <CODE>NS_ERROR_INVALID_ARG</CODE>, one of the arguments was
    ///      *         invalid or the object did not implement the interface
    ///      *         specified by the IID.
    ///      */
    /// ```
    ///

    /// `void addWebBrowserListener (in nsIWeakReference aListener, in nsIIDRef aIID);`
    #[inline]
    pub unsafe fn AddWebBrowserListener(&self, aListener: *const nsIWeakReference, aIID: &nsIID) -> nsresult {
        ((*self.vtable).AddWebBrowserListener)(self, aListener, aIID)
    }


    /// ```text
    /// /**
    ///      * Removes a previously registered listener.
    ///      *
    ///      * @param aListener The listener to be removed.
    ///      * @param aIID      The IID of the interface on the listener that will
    ///      *                  no longer be called.
    ///      *
    ///      * @return <CODE>NS_OK</CODE>, listener was successfully removed;
    ///      *         <CODE>NS_ERROR_INVALID_ARG</CODE> arguments was invalid or
    ///      *         the object did not implement the interface specified by the IID.
    ///      *
    ///      * @see addWebBrowserListener
    ///      * @see nsIWeakReference
    ///      */
    /// ```
    ///

    /// `void removeWebBrowserListener (in nsIWeakReference aListener, in nsIIDRef aIID);`
    #[inline]
    pub unsafe fn RemoveWebBrowserListener(&self, aListener: *const nsIWeakReference, aIID: &nsIID) -> nsresult {
        ((*self.vtable).RemoveWebBrowserListener)(self, aListener, aIID)
    }


    /// ```text
    /// /**
    ///      * The chrome object associated with the browser instance. The embedder
    ///      * must create one chrome object for <I>each</I> browser object
    ///      * that is instantiated. The embedder must associate the two by setting
    ///      * this property to point to the chrome object before creating the browser
    ///      * window via the browser's <CODE>nsIBaseWindow</CODE> interface.
    ///      *
    ///      * The chrome object must also implement <CODE>nsIEmbeddingSiteWindow</CODE>.
    ///      *
    ///      * The chrome may optionally implement <CODE>nsIInterfaceRequestor</CODE>,
    ///      * <CODE>nsIWebBrowserChromeFocus</CODE>,
    ///      * <CODE>nsIContextMenuListener</CODE> and
    ///      * <CODE>nsITooltipListener</CODE> to receive additional notifications
    ///      * from the browser object.
    ///      *
    ///      * The chrome object may optionally implement <CODE>nsIWebProgressListener</CODE>
    ///      * instead of explicitly calling <CODE>addWebBrowserListener</CODE> and
    ///      * <CODE>removeWebBrowserListener</CODE> to register a progress listener
    ///      * object. If the implementation does this, it must also implement
    ///      * <CODE>nsIWeakReference</CODE>.
    ///      *
    ///      * @note The implementation should not refcount the supplied chrome
    ///      *       object; it should assume that a non <CODE>nullptr</CODE> value is
    ///      *       always valid. The embedder must explicitly set this value back
    ///      *       to nullptr if the chrome object is destroyed before the browser
    ///      *       object.
    ///      *
    ///      * @see nsIBaseWindow
    ///      * @see nsIWebBrowserChrome
    ///      * @see nsIEmbeddingSiteWindow
    ///      * @see nsIInterfaceRequestor
    ///      * @see nsIWebBrowserChromeFocus
    ///      * @see nsIContextMenuListener
    ///      * @see nsITooltipListener
    ///      * @see nsIWeakReference
    ///      * @see nsIWebProgressListener
    ///      */
    /// ```
    ///

    /// `attribute nsIWebBrowserChrome containerWindow;`
    #[inline]
    pub unsafe fn GetContainerWindow(&self, aContainerWindow: *mut *const nsIWebBrowserChrome) -> nsresult {
        ((*self.vtable).GetContainerWindow)(self, aContainerWindow)
    }


    /// ```text
    /// /**
    ///      * The chrome object associated with the browser instance. The embedder
    ///      * must create one chrome object for <I>each</I> browser object
    ///      * that is instantiated. The embedder must associate the two by setting
    ///      * this property to point to the chrome object before creating the browser
    ///      * window via the browser's <CODE>nsIBaseWindow</CODE> interface.
    ///      *
    ///      * The chrome object must also implement <CODE>nsIEmbeddingSiteWindow</CODE>.
    ///      *
    ///      * The chrome may optionally implement <CODE>nsIInterfaceRequestor</CODE>,
    ///      * <CODE>nsIWebBrowserChromeFocus</CODE>,
    ///      * <CODE>nsIContextMenuListener</CODE> and
    ///      * <CODE>nsITooltipListener</CODE> to receive additional notifications
    ///      * from the browser object.
    ///      *
    ///      * The chrome object may optionally implement <CODE>nsIWebProgressListener</CODE>
    ///      * instead of explicitly calling <CODE>addWebBrowserListener</CODE> and
    ///      * <CODE>removeWebBrowserListener</CODE> to register a progress listener
    ///      * object. If the implementation does this, it must also implement
    ///      * <CODE>nsIWeakReference</CODE>.
    ///      *
    ///      * @note The implementation should not refcount the supplied chrome
    ///      *       object; it should assume that a non <CODE>nullptr</CODE> value is
    ///      *       always valid. The embedder must explicitly set this value back
    ///      *       to nullptr if the chrome object is destroyed before the browser
    ///      *       object.
    ///      *
    ///      * @see nsIBaseWindow
    ///      * @see nsIWebBrowserChrome
    ///      * @see nsIEmbeddingSiteWindow
    ///      * @see nsIInterfaceRequestor
    ///      * @see nsIWebBrowserChromeFocus
    ///      * @see nsIContextMenuListener
    ///      * @see nsITooltipListener
    ///      * @see nsIWeakReference
    ///      * @see nsIWebProgressListener
    ///      */
    /// ```
    ///

    /// `attribute nsIWebBrowserChrome containerWindow;`
    #[inline]
    pub unsafe fn SetContainerWindow(&self, aContainerWindow: *const nsIWebBrowserChrome) -> nsresult {
        ((*self.vtable).SetContainerWindow)(self, aContainerWindow)
    }


    /// ```text
    /// /**
    ///      * URI content listener parent. The embedder may set this property to
    ///      * their own implementation if they intend to override or prevent
    ///      * how certain kinds of content are loaded.
    ///      *
    ///      * @note If this attribute is set to an object that implements
    ///      *       nsISupportsWeakReference, the implementation should get the
    ///      *       nsIWeakReference and hold that.  Otherwise, the implementation
    ///      *       should not refcount this interface; it should assume that a non
    ///      *       null value is always valid.  In that case, the embedder should
    ///      *       explicitly set this value back to null if the parent content
    ///      *       listener is destroyed before the browser object.
    ///      *
    ///      * @see nsIURIContentListener
    ///      */
    /// ```
    ///

    /// `attribute nsIURIContentListener parentURIContentListener;`
    #[inline]
    pub unsafe fn GetParentURIContentListener(&self, aParentURIContentListener: *mut *const nsIURIContentListener) -> nsresult {
        ((*self.vtable).GetParentURIContentListener)(self, aParentURIContentListener)
    }


    /// ```text
    /// /**
    ///      * URI content listener parent. The embedder may set this property to
    ///      * their own implementation if they intend to override or prevent
    ///      * how certain kinds of content are loaded.
    ///      *
    ///      * @note If this attribute is set to an object that implements
    ///      *       nsISupportsWeakReference, the implementation should get the
    ///      *       nsIWeakReference and hold that.  Otherwise, the implementation
    ///      *       should not refcount this interface; it should assume that a non
    ///      *       null value is always valid.  In that case, the embedder should
    ///      *       explicitly set this value back to null if the parent content
    ///      *       listener is destroyed before the browser object.
    ///      *
    ///      * @see nsIURIContentListener
    ///      */
    /// ```
    ///

    /// `attribute nsIURIContentListener parentURIContentListener;`
    #[inline]
    pub unsafe fn SetParentURIContentListener(&self, aParentURIContentListener: *const nsIURIContentListener) -> nsresult {
        ((*self.vtable).SetParentURIContentListener)(self, aParentURIContentListener)
    }


    /// ```text
    /// /**
    ///      * The top-level DOM window. The embedder may walk the entire
    ///      * DOM starting from this value.
    ///      *
    ///      * @see nsIDOMWindow
    ///      */
    /// ```
    ///

    /// `readonly attribute mozIDOMWindowProxy contentDOMWindow;`
    #[inline]
    pub unsafe fn GetContentDOMWindow(&self, aContentDOMWindow: *mut *const mozIDOMWindowProxy) -> nsresult {
        ((*self.vtable).GetContentDOMWindow)(self, aContentDOMWindow)
    }


    /// ```text
    /// /**
    ///      * Whether this web browser is active. Active means that it's visible
    ///      * enough that we want to avoid certain optimizations like discarding
    ///      * decoded image data and throttling the refresh driver. In Firefox,
    ///      * this corresponds to the visible tab.
    ///      *
    ///      * Defaults to true. For optimal performance, set it to false when
    ///      * appropriate.
    ///      */
    /// ```
    ///

    /// `attribute boolean isActive;`
    #[inline]
    pub unsafe fn GetIsActive(&self, aIsActive: *mut bool) -> nsresult {
        ((*self.vtable).GetIsActive)(self, aIsActive)
    }


    /// ```text
    /// /**
    ///      * Whether this web browser is active. Active means that it's visible
    ///      * enough that we want to avoid certain optimizations like discarding
    ///      * decoded image data and throttling the refresh driver. In Firefox,
    ///      * this corresponds to the visible tab.
    ///      *
    ///      * Defaults to true. For optimal performance, set it to false when
    ///      * appropriate.
    ///      */
    /// ```
    ///

    /// `attribute boolean isActive;`
    #[inline]
    pub unsafe fn SetIsActive(&self, aIsActive: bool) -> nsresult {
        ((*self.vtable).SetIsActive)(self, aIsActive)
    }


    /// ```text
    /// /**
    ///      * Set Origin Attributes on the nsIWebBrowser.
    ///      * The Origin Attributes will be passed to the docshell once it has been
    ///      * created
    ///      */
    /// ```
    ///

    /// `[binaryname(SetOriginAttributes),noscript,nostdcall,notxpcom] void binarySetOriginAttributes (in const_OriginAttributesRef aOriginAttrs);`
    const _SetOriginAttributes: () = ();

}