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


/// `interface nsIXULWindow : 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 nsIXULWindow {
    vtable: *const nsIXULWindowVTable,

    /// 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 nsIXULWindow.
unsafe impl XpCom for nsIXULWindow {
    const IID: nsIID = nsID(0xd6d7a014, 0xe28d, 0x4c9d,
        [0x87, 0x27, 0x1c, 0xf6, 0xd8, 0x70, 0x61, 0x9b]);
}

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

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

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

    /* readonly attribute nsIDocShell docShell; */
    pub GetDocShell: unsafe extern "system" fn (this: *const nsIXULWindow, aDocShell: *mut *const nsIDocShell) -> nsresult,

    /* attribute boolean intrinsicallySized; */
    pub GetIntrinsicallySized: unsafe extern "system" fn (this: *const nsIXULWindow, aIntrinsicallySized: *mut bool) -> nsresult,

    /* attribute boolean intrinsicallySized; */
    pub SetIntrinsicallySized: unsafe extern "system" fn (this: *const nsIXULWindow, aIntrinsicallySized: bool) -> nsresult,

    /* readonly attribute nsIDocShellTreeItem primaryContentShell; */
    pub GetPrimaryContentShell: unsafe extern "system" fn (this: *const nsIXULWindow, aPrimaryContentShell: *mut *const nsIDocShellTreeItem) -> nsresult,

    /* readonly attribute nsITabParent primaryTabParent; */
    pub GetPrimaryTabParent: unsafe extern "system" fn (this: *const nsIXULWindow, aPrimaryTabParent: *mut *const nsITabParent) -> nsresult,

    /* void tabParentAdded (in nsITabParent aTab, in boolean aPrimary); */
    pub TabParentAdded: unsafe extern "system" fn (this: *const nsIXULWindow, aTab: *const nsITabParent, aPrimary: bool) -> nsresult,

    /* void tabParentRemoved (in nsITabParent aTab); */
    pub TabParentRemoved: unsafe extern "system" fn (this: *const nsIXULWindow, aTab: *const nsITabParent) -> nsresult,

    /* [noscript,notxpcom] LiveResizeListenerArray getLiveResizeListeners (); */
    /// Unable to generate binding because `native type nsTArray<RefPtr<mozilla::LiveResizeListener>> is unsupported`
    pub GetLiveResizeListeners: *const ::libc::c_void,

    /* void addChildWindow (in nsIXULWindow aChild); */
    pub AddChildWindow: unsafe extern "system" fn (this: *const nsIXULWindow, aChild: *const nsIXULWindow) -> nsresult,

    /* void removeChildWindow (in nsIXULWindow aChild); */
    pub RemoveChildWindow: unsafe extern "system" fn (this: *const nsIXULWindow, aChild: *const nsIXULWindow) -> nsresult,

    /* void center (in nsIXULWindow aRelative, in boolean aScreen, in boolean aAlert); */
    pub Center: unsafe extern "system" fn (this: *const nsIXULWindow, aRelative: *const nsIXULWindow, aScreen: bool, aAlert: bool) -> nsresult,

    /* void showModal (); */
    pub ShowModal: unsafe extern "system" fn (this: *const nsIXULWindow) -> nsresult,

    /* attribute unsigned long zLevel; */
    pub GetZLevel: unsafe extern "system" fn (this: *const nsIXULWindow, aZLevel: *mut libc::uint32_t) -> nsresult,

    /* attribute unsigned long zLevel; */
    pub SetZLevel: unsafe extern "system" fn (this: *const nsIXULWindow, aZLevel: libc::uint32_t) -> nsresult,

    /* attribute uint32_t chromeFlags; */
    pub GetChromeFlags: unsafe extern "system" fn (this: *const nsIXULWindow, aChromeFlags: *mut uint32_t) -> nsresult,

    /* attribute uint32_t chromeFlags; */
    pub SetChromeFlags: unsafe extern "system" fn (this: *const nsIXULWindow, aChromeFlags: uint32_t) -> nsresult,

    /* void assumeChromeFlagsAreFrozen (); */
    pub AssumeChromeFlagsAreFrozen: unsafe extern "system" fn (this: *const nsIXULWindow) -> nsresult,

    /* nsIXULWindow createNewWindow (in int32_t aChromeFlags, in nsITabParent aOpeningTab, in mozIDOMWindowProxy aOpener, in unsigned long long aNextTabParentId); */
    pub CreateNewWindow: unsafe extern "system" fn (this: *const nsIXULWindow, aChromeFlags: int32_t, aOpeningTab: *const nsITabParent, aOpener: *const mozIDOMWindowProxy, aNextTabParentId: libc::uint64_t, _retval: *mut *const nsIXULWindow) -> nsresult,

    /* attribute nsIXULBrowserWindow XULBrowserWindow; */
    pub GetXULBrowserWindow: unsafe extern "system" fn (this: *const nsIXULWindow, aXULBrowserWindow: *mut *const nsIXULBrowserWindow) -> nsresult,

    /* attribute nsIXULBrowserWindow XULBrowserWindow; */
    pub SetXULBrowserWindow: unsafe extern "system" fn (this: *const nsIXULWindow, aXULBrowserWindow: *const nsIXULBrowserWindow) -> nsresult,

    /* [noscript] void applyChromeFlags (); */
    pub ApplyChromeFlags: unsafe extern "system" fn (this: *const nsIXULWindow) -> nsresult,

    /* [noscript,notxpcom] void sizeShellToWithLimit (in int32_t aDesiredWidth, in int32_t aDesiredHeight, in int32_t shellItemWidth, in int32_t shellItemHeight); */
    pub SizeShellToWithLimit: unsafe extern "system" fn (this: *const nsIXULWindow, aDesiredWidth: int32_t, aDesiredHeight: int32_t, shellItemWidth: int32_t, shellItemHeight: int32_t) -> libc::c_void,

    /* [noscript] readonly attribute unsigned long long nextTabParentId; */
    pub GetNextTabParentId: unsafe extern "system" fn (this: *const nsIXULWindow, aNextTabParentId: *mut libc::uint64_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 nsIXULWindow {

    pub const lowestZ: i64 = 0;


    pub const loweredZ: i64 = 4;


    pub const normalZ: i64 = 5;


    pub const raisedZ: i64 = 6;


    pub const highestZ: i64 = 9;

    /// ```text
    /// /**
    ///    * The docshell owning the XUL for this window.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDocShell docShell;`
    #[inline]
    pub unsafe fn GetDocShell(&self, aDocShell: *mut *const nsIDocShell) -> nsresult {
        ((*self.vtable).GetDocShell)(self, aDocShell)
    }


    /// ```text
    /// /**
    ///    * Indicates if this window is instrinsically sized.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Indicates if this window is instrinsically sized.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * The primary content shell.
    ///    *
    ///    * Note that this is a docshell tree item and therefore can not be assured of
    ///    * what object it is. It could be an editor, a docshell, or a browser object.
    ///    * Or down the road any other object that supports being a DocShellTreeItem
    ///    * Query accordingly to determine the capabilities.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDocShellTreeItem primaryContentShell;`
    #[inline]
    pub unsafe fn GetPrimaryContentShell(&self, aPrimaryContentShell: *mut *const nsIDocShellTreeItem) -> nsresult {
        ((*self.vtable).GetPrimaryContentShell)(self, aPrimaryContentShell)
    }


    /// ```text
    /// /**
    ///    * In multiprocess case we may not have primaryContentShell but
    ///    * primaryTabParent.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsITabParent primaryTabParent;`
    #[inline]
    pub unsafe fn GetPrimaryTabParent(&self, aPrimaryTabParent: *mut *const nsITabParent) -> nsresult {
        ((*self.vtable).GetPrimaryTabParent)(self, aPrimaryTabParent)
    }



    /// `void tabParentAdded (in nsITabParent aTab, in boolean aPrimary);`
    #[inline]
    pub unsafe fn TabParentAdded(&self, aTab: *const nsITabParent, aPrimary: bool) -> nsresult {
        ((*self.vtable).TabParentAdded)(self, aTab, aPrimary)
    }



    /// `void tabParentRemoved (in nsITabParent aTab);`
    #[inline]
    pub unsafe fn TabParentRemoved(&self, aTab: *const nsITabParent) -> nsresult {
        ((*self.vtable).TabParentRemoved)(self, aTab)
    }



    /// `[noscript,notxpcom] LiveResizeListenerArray getLiveResizeListeners ();`
    const _GetLiveResizeListeners: () = ();

    /// ```text
    /// /**
    ///    * Tell this window that it has picked up a child XUL window
    ///    * @param aChild the child window being added
    ///    */
    /// ```
    ///

    /// `void addChildWindow (in nsIXULWindow aChild);`
    #[inline]
    pub unsafe fn AddChildWindow(&self, aChild: *const nsIXULWindow) -> nsresult {
        ((*self.vtable).AddChildWindow)(self, aChild)
    }


    /// ```text
    /// /**
    ///    * Tell this window that it has lost a child XUL window
    ///    * @param aChild the child window being removed
    ///    */
    /// ```
    ///

    /// `void removeChildWindow (in nsIXULWindow aChild);`
    #[inline]
    pub unsafe fn RemoveChildWindow(&self, aChild: *const nsIXULWindow) -> nsresult {
        ((*self.vtable).RemoveChildWindow)(self, aChild)
    }


    /// ```text
    /// /**
    ///    * Move the window to a centered position.
    ///    * @param aRelative If not null, the window relative to which the window is
    ///    *                  moved. See aScreen parameter for details.
    ///    * @param aScreen   PR_TRUE to center the window relative to the screen
    ///    *                  containing aRelative if aRelative is not null. If
    ///    *                  aRelative is null then relative to the screen of the
    ///    *                  opener window if it was initialized by passing it to
    ///    *                  nsWebShellWindow::Initialize. Failing that relative to
    ///    *                  the main screen.
    ///    *                  PR_FALSE to center it relative to aRelative itself.
    ///    * @param aAlert    PR_TRUE to move the window to an alert position,
    ///    *                  generally centered horizontally and 1/3 down from the top.
    ///    */
    /// ```
    ///

    /// `void center (in nsIXULWindow aRelative, in boolean aScreen, in boolean aAlert);`
    #[inline]
    pub unsafe fn Center(&self, aRelative: *const nsIXULWindow, aScreen: bool, aAlert: bool) -> nsresult {
        ((*self.vtable).Center)(self, aRelative, aScreen, aAlert)
    }


    /// ```text
    /// /**
    ///    * Shows the window as a modal window. That is, ensures that it is visible
    ///    * and runs a local event loop, exiting only once the window has been closed.
    ///    */
    /// ```
    ///

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



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



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



    /// `attribute uint32_t chromeFlags;`
    #[inline]
    pub unsafe fn GetChromeFlags(&self, aChromeFlags: *mut uint32_t) -> nsresult {
        ((*self.vtable).GetChromeFlags)(self, aChromeFlags)
    }



    /// `attribute uint32_t chromeFlags;`
    #[inline]
    pub unsafe fn SetChromeFlags(&self, aChromeFlags: uint32_t) -> nsresult {
        ((*self.vtable).SetChromeFlags)(self, aChromeFlags)
    }


    /// ```text
    /// /**
    ///    * Begin assuming |chromeFlags| don't change hereafter, and assert
    ///    * if they do change.  The state change is one-way and idempotent.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Create a new window.
    ///    * @param aChromeFlags see nsIWebBrowserChrome
    ///    * @param aOpeningTab the TabParent that requested this new window be opened.
    ///    *                    Can be left null.
    ///    * @param aOpener The window which is requesting that this new window be opened.
    ///    * @param aNextTabParentId The integer ID of the next tab parent actor to use.
    ///    *        0 means there is no next tab parent actor to use.
    ///    * @return the newly minted window
    ///    */
    /// ```
    ///

    /// `nsIXULWindow createNewWindow (in int32_t aChromeFlags, in nsITabParent aOpeningTab, in mozIDOMWindowProxy aOpener, in unsigned long long aNextTabParentId);`
    #[inline]
    pub unsafe fn CreateNewWindow(&self, aChromeFlags: int32_t, aOpeningTab: *const nsITabParent, aOpener: *const mozIDOMWindowProxy, aNextTabParentId: libc::uint64_t, _retval: *mut *const nsIXULWindow) -> nsresult {
        ((*self.vtable).CreateNewWindow)(self, aChromeFlags, aOpeningTab, aOpener, aNextTabParentId, _retval)
    }



    /// `attribute nsIXULBrowserWindow XULBrowserWindow;`
    #[inline]
    pub unsafe fn GetXULBrowserWindow(&self, aXULBrowserWindow: *mut *const nsIXULBrowserWindow) -> nsresult {
        ((*self.vtable).GetXULBrowserWindow)(self, aXULBrowserWindow)
    }



    /// `attribute nsIXULBrowserWindow XULBrowserWindow;`
    #[inline]
    pub unsafe fn SetXULBrowserWindow(&self, aXULBrowserWindow: *const nsIXULBrowserWindow) -> nsresult {
        ((*self.vtable).SetXULBrowserWindow)(self, aXULBrowserWindow)
    }


    /// ```text
    /// /**
    ///    * Back-door method to force application of chrome flags at a particular
    ///    * time.  Do NOT call this unless you know what you're doing!  In particular,
    ///    * calling this when this XUL window doesn't yet have a document in its
    ///    * docshell could cause problems.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Given the dimensions of some content area held within this
    ///    * XUL window, and assuming that that content area will change
    ///    * its dimensions in linear proportion to the dimensions of this
    ///    * XUL window, changes the size of the XUL window so that the
    ///    * content area reaches a particular size.
    ///    *
    ///    * We need to supply the content area dimensions because sometimes
    ///    * the child's nsDocShellTreeOwner needs to propagate a SizeShellTo
    ///    * call to the parent. But the shellItem argument of the call will
    ///    * not be available on the parent side.
    ///    *
    ///    * Note: this is an internal method, other consumers should never call this.
    ///    *
    ///    * @param aDesiredWidth
    ///    *        The desired width of the content area in device pixels.
    ///    * @param aDesiredHeight
    ///    *        The desired height of the content area in device pixels.
    ///    * @param shellItemWidth
    ///    *        The current width of the content area.
    ///    * @param shellItemHeight
    ///    *        The current height of the content area.
    ///    */
    /// ```
    ///

    /// `[noscript,notxpcom] void sizeShellToWithLimit (in int32_t aDesiredWidth, in int32_t aDesiredHeight, in int32_t shellItemWidth, in int32_t shellItemHeight);`
    #[inline]
    pub unsafe fn SizeShellToWithLimit(&self, aDesiredWidth: int32_t, aDesiredHeight: int32_t, shellItemWidth: int32_t, shellItemHeight: int32_t) -> libc::c_void {
        ((*self.vtable).SizeShellToWithLimit)(self, aDesiredWidth, aDesiredHeight, shellItemWidth, shellItemHeight)
    }


    /// ```text
    /// /**
    ///    * If the window was opened as a content window by script, this will return the
    ///    * integer ID of the next TabParent actor to use.
    ///    */
    /// ```
    ///

    /// `[noscript] readonly attribute unsigned long long nextTabParentId;`
    #[inline]
    pub unsafe fn GetNextTabParentId(&self, aNextTabParentId: *mut libc::uint64_t) -> nsresult {
        ((*self.vtable).GetNextTabParentId)(self, aNextTabParentId)
    }


}