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


/// `interface nsIOpenURIInFrameParams : nsISupports`
///


// 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 nsIOpenURIInFrameParams {
    vtable: *const nsIOpenURIInFrameParamsVTable,

    /// 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 nsIOpenURIInFrameParams.
unsafe impl XpCom for nsIOpenURIInFrameParams {
    const IID: nsIID = nsID(0xe774db14, 0x79ac, 0x4156,
        [0xa7, 0xa3, 0xaa, 0x3f, 0xd0, 0xa2, 0x2c, 0x10]);
}

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

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

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

    /* attribute DOMString referrer; */
    pub GetReferrer: unsafe extern "system" fn (this: *const nsIOpenURIInFrameParams, aReferrer: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute DOMString referrer; */
    pub SetReferrer: unsafe extern "system" fn (this: *const nsIOpenURIInFrameParams, aReferrer: &::nsstring::nsAString) -> nsresult,

    /* attribute unsigned long referrerPolicy; */
    pub GetReferrerPolicy: unsafe extern "system" fn (this: *const nsIOpenURIInFrameParams, aReferrerPolicy: *mut libc::uint32_t) -> nsresult,

    /* attribute unsigned long referrerPolicy; */
    pub SetReferrerPolicy: unsafe extern "system" fn (this: *const nsIOpenURIInFrameParams, aReferrerPolicy: libc::uint32_t) -> nsresult,

    /* readonly attribute boolean isPrivate; */
    pub GetIsPrivate: unsafe extern "system" fn (this: *const nsIOpenURIInFrameParams, aIsPrivate: *mut bool) -> nsresult,

    /* attribute nsIPrincipal triggeringPrincipal; */
    pub GetTriggeringPrincipal: unsafe extern "system" fn (this: *const nsIOpenURIInFrameParams, aTriggeringPrincipal: *mut *const nsIPrincipal) -> nsresult,

    /* attribute nsIPrincipal triggeringPrincipal; */
    pub SetTriggeringPrincipal: unsafe extern "system" fn (this: *const nsIOpenURIInFrameParams, aTriggeringPrincipal: *const nsIPrincipal) -> nsresult,

    /* readonly attribute nsIFrameLoaderOwner openerBrowser; */
    pub GetOpenerBrowser: unsafe extern "system" fn (this: *const nsIOpenURIInFrameParams, aOpenerBrowser: *mut *const nsIFrameLoaderOwner) -> nsresult,

    /* [implicit_jscontext] readonly attribute jsval openerOriginAttributes; */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetOpenerOriginAttributes: *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 nsIOpenURIInFrameParams {


    /// `attribute DOMString referrer;`
    #[inline]
    pub unsafe fn GetReferrer(&self, aReferrer: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetReferrer)(self, aReferrer)
    }



    /// `attribute DOMString referrer;`
    #[inline]
    pub unsafe fn SetReferrer(&self, aReferrer: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetReferrer)(self, aReferrer)
    }



    /// `attribute unsigned long referrerPolicy;`
    #[inline]
    pub unsafe fn GetReferrerPolicy(&self, aReferrerPolicy: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetReferrerPolicy)(self, aReferrerPolicy)
    }



    /// `attribute unsigned long referrerPolicy;`
    #[inline]
    pub unsafe fn SetReferrerPolicy(&self, aReferrerPolicy: libc::uint32_t) -> nsresult {
        ((*self.vtable).SetReferrerPolicy)(self, aReferrerPolicy)
    }



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



    /// `attribute nsIPrincipal triggeringPrincipal;`
    #[inline]
    pub unsafe fn GetTriggeringPrincipal(&self, aTriggeringPrincipal: *mut *const nsIPrincipal) -> nsresult {
        ((*self.vtable).GetTriggeringPrincipal)(self, aTriggeringPrincipal)
    }



    /// `attribute nsIPrincipal triggeringPrincipal;`
    #[inline]
    pub unsafe fn SetTriggeringPrincipal(&self, aTriggeringPrincipal: *const nsIPrincipal) -> nsresult {
        ((*self.vtable).SetTriggeringPrincipal)(self, aTriggeringPrincipal)
    }



    /// `readonly attribute nsIFrameLoaderOwner openerBrowser;`
    #[inline]
    pub unsafe fn GetOpenerBrowser(&self, aOpenerBrowser: *mut *const nsIFrameLoaderOwner) -> nsresult {
        ((*self.vtable).GetOpenerBrowser)(self, aOpenerBrowser)
    }



    /// `[implicit_jscontext] readonly attribute jsval openerOriginAttributes;`
    const _GetOpenerOriginAttributes: () = ();

}


/// `interface nsIBrowserDOMWindow : nsISupports`
///

/// ```text
/// /**
///  * The C++ source has access to the browser script source through
///  * nsIBrowserDOMWindow. It is intended to be attached to the chrome DOMWindow
///  * of a toplevel browser window (a XUL window). A DOMWindow that does not
///  * happen to be a browser chrome window will simply have no access to any such
///  * interface.
///  */
/// ```
///

// 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 nsIBrowserDOMWindow {
    vtable: *const nsIBrowserDOMWindowVTable,

    /// 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 nsIBrowserDOMWindow.
unsafe impl XpCom for nsIBrowserDOMWindow {
    const IID: nsIID = nsID(0x2a9bb880, 0x5d73, 0x40f3,
        [0x81, 0x52, 0xc6, 0x0c, 0x8d, 0x13, 0x7a, 0x14]);
}

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

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

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

    /* mozIDOMWindowProxy createContentWindow (in nsIURI aURI, in mozIDOMWindowProxy aOpener, in short aWhere, in long aFlags, in nsIPrincipal aTriggeringPrincipal); */
    pub CreateContentWindow: unsafe extern "system" fn (this: *const nsIBrowserDOMWindow, aURI: *const nsIURI, aOpener: *const mozIDOMWindowProxy, aWhere: libc::int16_t, aFlags: libc::int32_t, aTriggeringPrincipal: *const nsIPrincipal, _retval: *mut *const mozIDOMWindowProxy) -> nsresult,

    /* nsIFrameLoaderOwner createContentWindowInFrame (in nsIURI aURI, in nsIOpenURIInFrameParams params, in short aWhere, in long aFlags, in unsigned long long aNextTabParentId, in AString aName); */
    pub CreateContentWindowInFrame: unsafe extern "system" fn (this: *const nsIBrowserDOMWindow, aURI: *const nsIURI, params: *const nsIOpenURIInFrameParams, aWhere: libc::int16_t, aFlags: libc::int32_t, aNextTabParentId: libc::uint64_t, aName: &::nsstring::nsAString, _retval: *mut *const nsIFrameLoaderOwner) -> nsresult,

    /* mozIDOMWindowProxy openURI (in nsIURI aURI, in mozIDOMWindowProxy aOpener, in short aWhere, in long aFlags, in nsIPrincipal aTriggeringPrincipal); */
    pub OpenURI: unsafe extern "system" fn (this: *const nsIBrowserDOMWindow, aURI: *const nsIURI, aOpener: *const mozIDOMWindowProxy, aWhere: libc::int16_t, aFlags: libc::int32_t, aTriggeringPrincipal: *const nsIPrincipal, _retval: *mut *const mozIDOMWindowProxy) -> nsresult,

    /* nsIFrameLoaderOwner openURIInFrame (in nsIURI aURI, in nsIOpenURIInFrameParams params, in short aWhere, in long aFlags, in unsigned long long aNextTabParentId, in AString aName); */
    pub OpenURIInFrame: unsafe extern "system" fn (this: *const nsIBrowserDOMWindow, aURI: *const nsIURI, params: *const nsIOpenURIInFrameParams, aWhere: libc::int16_t, aFlags: libc::int32_t, aNextTabParentId: libc::uint64_t, aName: &::nsstring::nsAString, _retval: *mut *const nsIFrameLoaderOwner) -> nsresult,

    /* boolean isTabContentWindow (in nsIDOMWindow aWindow); */
    pub IsTabContentWindow: unsafe extern "system" fn (this: *const nsIBrowserDOMWindow, aWindow: *const nsIDOMWindow, _retval: *mut bool) -> nsresult,

    /* boolean canClose (); */
    pub CanClose: unsafe extern "system" fn (this: *const nsIBrowserDOMWindow, _retval: *mut bool) -> 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 nsIBrowserDOMWindow {
    /// ```text
    /// /**
    ///    * Values for createContentWindow's and openURI's aWhere parameter.
    ///    */
    /// /**
    ///    * Do whatever the default is based on application state, user preferences,
    ///    * and the value of the aContext parameter to openURI.
    ///    */
    /// ```
    ///

    pub const OPEN_DEFAULTWINDOW: i64 = 0;

    /// ```text
    /// /**
    ///    * Open in the "current window".  If aOpener is provided, this should be the
    ///    * top window in aOpener's window hierarchy, but exact behavior is
    ///    * application-dependent.  If aOpener is not provided, it's up to the
    ///    * application to decide what constitutes a "current window".
    ///    */
    /// ```
    ///

    pub const OPEN_CURRENTWINDOW: i64 = 1;

    /// ```text
    /// /**
    ///    * Open in a new window.
    ///    */
    /// ```
    ///

    pub const OPEN_NEWWINDOW: i64 = 2;

    /// ```text
    /// /**
    ///    * Open in a new content tab in the toplevel browser window corresponding to
    ///    * this nsIBrowserDOMWindow.
    ///    */
    /// ```
    ///

    pub const OPEN_NEWTAB: i64 = 3;

    /// ```text
    /// /**
    ///    * Open in an existing content tab based on the URI. If a match can't be
    ///    * found, revert to OPEN_NEWTAB behavior.
    ///    */
    /// ```
    ///

    pub const OPEN_SWITCHTAB: i64 = 4;

    /// ```text
    /// /**
    ///    * Values for createContentWindow's and openURI's aFlags parameter.
    ///    * This is a bitflags field.
    ///    *
    ///    * The 0x1 bit decides the behavior of OPEN_DEFAULTWINDOW, and the 0x4 bit
    ///    * controls whether or not to set the window.opener property on the newly
    ///    * opened window.
    ///    *
    ///    * NOTE: The 0x2 bit is ignored for backwards compatibility with addons, as
    ///    * OPEN_NEW used to have the value 2. The values 0 and 2 are treated
    ///    * the same way internally.
    ///    */
    /// /**
    ///    * Internal open new window.
    ///    */
    /// ```
    ///

    pub const OPEN_NEW: i64 = 0;

    /// ```text
    /// /**
    ///    * External link (load request from another application, xremote, etc).
    ///    */
    /// ```
    ///

    pub const OPEN_EXTERNAL: i64 = 1;

    /// ```text
    /// /**
    ///    * Don't set the window.opener property on the window which is being opened.
    ///    */
    /// ```
    ///

    pub const OPEN_NO_OPENER: i64 = 4;

    /// ```text
    /// /**
    ///    * Create the content window for the given URI.
    ///
    ///    * @param aURI the URI to be opened in the window (can be null).
    ///    * @param aWhere see possible values described above.
    ///    * @param aOpener window requesting the creation (can be null).
    ///    * @param aFlags flags which control the behavior of the load. The
    ///    *               OPEN_EXTERNAL/OPEN_NEW flag is only used when
    ///    *               aWhere == OPEN_DEFAULTWINDOW.
    ///    * @param aTriggeringPrincipal the principal that would trigger the potential
    ///    *        load of aURI.
    ///    * @return the window into which the URI would have been opened.
    ///   */
    /// ```
    ///

    /// `mozIDOMWindowProxy createContentWindow (in nsIURI aURI, in mozIDOMWindowProxy aOpener, in short aWhere, in long aFlags, in nsIPrincipal aTriggeringPrincipal);`
    #[inline]
    pub unsafe fn CreateContentWindow(&self, aURI: *const nsIURI, aOpener: *const mozIDOMWindowProxy, aWhere: libc::int16_t, aFlags: libc::int32_t, aTriggeringPrincipal: *const nsIPrincipal, _retval: *mut *const mozIDOMWindowProxy) -> nsresult {
        ((*self.vtable).CreateContentWindow)(self, aURI, aOpener, aWhere, aFlags, aTriggeringPrincipal, _retval)
    }


    /// ```text
    /// /**
    ///    * As above, but return the nsIFrameLoaderOwner for the new window.
    ///    *
    ///    * Additional Parameters:
    ///    * @param aNextTabParentId The TabParent to associate the window with.
    ///    * @param aName The name to give the window opened in the new tab.
    ///    * @return The nsIFrameLoaderOwner for the newly opened window.
    ///    */
    /// ```
    ///

    /// `nsIFrameLoaderOwner createContentWindowInFrame (in nsIURI aURI, in nsIOpenURIInFrameParams params, in short aWhere, in long aFlags, in unsigned long long aNextTabParentId, in AString aName);`
    #[inline]
    pub unsafe fn CreateContentWindowInFrame(&self, aURI: *const nsIURI, params: *const nsIOpenURIInFrameParams, aWhere: libc::int16_t, aFlags: libc::int32_t, aNextTabParentId: libc::uint64_t, aName: &::nsstring::nsAString, _retval: *mut *const nsIFrameLoaderOwner) -> nsresult {
        ((*self.vtable).CreateContentWindowInFrame)(self, aURI, params, aWhere, aFlags, aNextTabParentId, aName, _retval)
    }


    /// ```text
    /// /**
    ///    * Load a URI.
    ///
    ///    * @param aURI the URI to open. null is not allowed. To create the window
    ///    *        without loading the URI, use createContentWindow instead.
    ///    * @param aWhere see possible values described above.
    ///    * @param aOpener window requesting the open (can be null).
    ///    * @param aFlags flags which control the behavior of the load. The
    ///    *               OPEN_EXTERNAL/OPEN_NEW flag is only used when
    ///    *               aWhere == OPEN_DEFAULTWINDOW.
    ///    * @param aTriggeringPrincipal the principal that triggered the load of aURI.
    ///    * @return the window into which the URI was opened.
    ///   */
    /// ```
    ///

    /// `mozIDOMWindowProxy openURI (in nsIURI aURI, in mozIDOMWindowProxy aOpener, in short aWhere, in long aFlags, in nsIPrincipal aTriggeringPrincipal);`
    #[inline]
    pub unsafe fn OpenURI(&self, aURI: *const nsIURI, aOpener: *const mozIDOMWindowProxy, aWhere: libc::int16_t, aFlags: libc::int32_t, aTriggeringPrincipal: *const nsIPrincipal, _retval: *mut *const mozIDOMWindowProxy) -> nsresult {
        ((*self.vtable).OpenURI)(self, aURI, aOpener, aWhere, aFlags, aTriggeringPrincipal, _retval)
    }


    /// ```text
    /// /**
    ///    * As above, but return the nsIFrameLoaderOwner for the new window.
    ///    *
    ///    * Additional Parameters:
    ///    * @param aNextTabParentId The TabParent to associate the window with.
    ///    * @param aName The name to give the window opened in the new tab.
    ///    * @return The nsIFrameLoaderOwner for the newly opened window.
    ///    // XXXbz is this the right API?
    ///    // See bug 537428
    ///    */
    /// ```
    ///

    /// `nsIFrameLoaderOwner openURIInFrame (in nsIURI aURI, in nsIOpenURIInFrameParams params, in short aWhere, in long aFlags, in unsigned long long aNextTabParentId, in AString aName);`
    #[inline]
    pub unsafe fn OpenURIInFrame(&self, aURI: *const nsIURI, params: *const nsIOpenURIInFrameParams, aWhere: libc::int16_t, aFlags: libc::int32_t, aNextTabParentId: libc::uint64_t, aName: &::nsstring::nsAString, _retval: *mut *const nsIFrameLoaderOwner) -> nsresult {
        ((*self.vtable).OpenURIInFrame)(self, aURI, params, aWhere, aFlags, aNextTabParentId, aName, _retval)
    }


    /// ```text
    /// /**
    ///    * @param  aWindow the window to test.
    ///    * @return whether the window is the main content window for any
    ///    *         currently open tab in this toplevel browser window.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This function is responsible for calling
    ///    * nsIContentViewer::PermitUnload on each frame in the window. It
    ///    * returns true if closing the window is allowed. See canClose() in
    ///    * BrowserUtils.jsm for a simple implementation of this method.
    ///    */
    /// ```
    ///

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


}