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


/// `interface nsIDOMXULDocument : nsIDOMDocument`
///


// 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 nsIDOMXULDocument {
    vtable: *const nsIDOMXULDocumentVTable,

    /// 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 nsIDOMXULDocument.
unsafe impl XpCom for nsIDOMXULDocument {
    const IID: nsIID = nsID(0x7790d4c3, 0xe8f0, 0x4e29,
        [0x98, 0x87, 0xd6, 0x83, 0xed, 0x2b, 0x2a, 0x44]);
}

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

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

impl nsIDOMXULDocument {
    /// Cast this `nsIDOMXULDocument` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIDOMXULDocumentCoerce>(&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 nsIDOMXULDocument {
    type Target = nsIDOMDocument;
    #[inline]
    fn deref(&self) -> &nsIDOMDocument {
        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: nsIDOMDocumentCoerce> nsIDOMXULDocumentCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIDOMXULDocument) -> &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 nsIDOMXULDocument
// 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 nsIDOMXULDocumentVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIDOMDocumentVTable,

    /* attribute nsIDOMNode popupNode; */
    pub GetPopupNode: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aPopupNode: *mut *const nsIDOMNode) -> nsresult,

    /* attribute nsIDOMNode popupNode; */
    pub SetPopupNode: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aPopupNode: *const nsIDOMNode) -> nsresult,

    /* readonly attribute nsIDOMNode popupRangeParent; */
    pub GetPopupRangeParent: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aPopupRangeParent: *mut *const nsIDOMNode) -> nsresult,

    /* readonly attribute long popupRangeOffset; */
    pub GetPopupRangeOffset: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aPopupRangeOffset: *mut libc::int32_t) -> nsresult,

    /* attribute nsIDOMNode tooltipNode; */
    pub GetTooltipNode: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aTooltipNode: *mut *const nsIDOMNode) -> nsresult,

    /* attribute nsIDOMNode tooltipNode; */
    pub SetTooltipNode: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aTooltipNode: *const nsIDOMNode) -> nsresult,

    /* readonly attribute nsIDOMXULCommandDispatcher commandDispatcher; */
    pub GetCommandDispatcher: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aCommandDispatcher: *mut *const nsIDOMXULCommandDispatcher) -> nsresult,

    /* readonly attribute long width; */
    pub GetWidth: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aWidth: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long height; */
    pub GetHeight: unsafe extern "system" fn (this: *const nsIDOMXULDocument, aHeight: *mut libc::int32_t) -> nsresult,

    /* nsIDOMNodeList getElementsByAttribute (in DOMString name, in DOMString value); */
    pub GetElementsByAttribute: unsafe extern "system" fn (this: *const nsIDOMXULDocument, name: &::nsstring::nsAString, value: &::nsstring::nsAString, _retval: *mut *const nsIDOMNodeList) -> nsresult,

    /* nsIDOMNodeList getElementsByAttributeNS (in DOMString namespaceURI, in DOMString name, in DOMString value); */
    pub GetElementsByAttributeNS: unsafe extern "system" fn (this: *const nsIDOMXULDocument, namespaceURI: &::nsstring::nsAString, name: &::nsstring::nsAString, value: &::nsstring::nsAString, _retval: *mut *const nsIDOMNodeList) -> nsresult,

    /* void addBroadcastListenerFor (in nsIDOMElement broadcaster, in nsIDOMElement observer, in DOMString attr); */
    pub AddBroadcastListenerFor: unsafe extern "system" fn (this: *const nsIDOMXULDocument, broadcaster: *const nsIDOMElement, observer: *const nsIDOMElement, attr: &::nsstring::nsAString) -> nsresult,

    /* void removeBroadcastListenerFor (in nsIDOMElement broadcaster, in nsIDOMElement observer, in DOMString attr); */
    pub RemoveBroadcastListenerFor: unsafe extern "system" fn (this: *const nsIDOMXULDocument, broadcaster: *const nsIDOMElement, observer: *const nsIDOMElement, attr: &::nsstring::nsAString) -> nsresult,

    /* void persist (in DOMString id, in DOMString attr); */
    pub Persist: unsafe extern "system" fn (this: *const nsIDOMXULDocument, id: &::nsstring::nsAString, attr: &::nsstring::nsAString) -> nsresult,

    /* nsIBoxObject getBoxObjectFor (in nsIDOMElement elt); */
    pub GetBoxObjectFor: unsafe extern "system" fn (this: *const nsIDOMXULDocument, elt: *const nsIDOMElement, _retval: *mut *const nsIBoxObject) -> nsresult,

    /* void loadOverlay (in DOMString url, in nsIObserver aObserver); */
    pub LoadOverlay: unsafe extern "system" fn (this: *const nsIDOMXULDocument, url: &::nsstring::nsAString, aObserver: *const nsIObserver) -> 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 nsIDOMXULDocument {


    /// `attribute nsIDOMNode popupNode;`
    #[inline]
    pub unsafe fn GetPopupNode(&self, aPopupNode: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).GetPopupNode)(self, aPopupNode)
    }



    /// `attribute nsIDOMNode popupNode;`
    #[inline]
    pub unsafe fn SetPopupNode(&self, aPopupNode: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).SetPopupNode)(self, aPopupNode)
    }


    /// ```text
    /// /**
    ///    * These attributes correspond to trustedGetPopupNode().rangeOffset and
    ///    * rangeParent. They will help you find where in the DOM the popup is
    ///    * happening. Can be accessed from chrome only, and only during a popup
    ///    * event. Accessing any other time will be an error.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDOMNode popupRangeParent;`
    #[inline]
    pub unsafe fn GetPopupRangeParent(&self, aPopupRangeParent: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).GetPopupRangeParent)(self, aPopupRangeParent)
    }



    /// `readonly attribute long popupRangeOffset;`
    #[inline]
    pub unsafe fn GetPopupRangeOffset(&self, aPopupRangeOffset: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetPopupRangeOffset)(self, aPopupRangeOffset)
    }



    /// `attribute nsIDOMNode tooltipNode;`
    #[inline]
    pub unsafe fn GetTooltipNode(&self, aTooltipNode: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).GetTooltipNode)(self, aTooltipNode)
    }



    /// `attribute nsIDOMNode tooltipNode;`
    #[inline]
    pub unsafe fn SetTooltipNode(&self, aTooltipNode: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).SetTooltipNode)(self, aTooltipNode)
    }



    /// `readonly attribute nsIDOMXULCommandDispatcher commandDispatcher;`
    #[inline]
    pub unsafe fn GetCommandDispatcher(&self, aCommandDispatcher: *mut *const nsIDOMXULCommandDispatcher) -> nsresult {
        ((*self.vtable).GetCommandDispatcher)(self, aCommandDispatcher)
    }



    /// `readonly attribute long width;`
    #[inline]
    pub unsafe fn GetWidth(&self, aWidth: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetWidth)(self, aWidth)
    }



    /// `readonly attribute long height;`
    #[inline]
    pub unsafe fn GetHeight(&self, aHeight: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetHeight)(self, aHeight)
    }



    /// `nsIDOMNodeList getElementsByAttribute (in DOMString name, in DOMString value);`
    #[inline]
    pub unsafe fn GetElementsByAttribute(&self, name: &::nsstring::nsAString, value: &::nsstring::nsAString, _retval: *mut *const nsIDOMNodeList) -> nsresult {
        ((*self.vtable).GetElementsByAttribute)(self, name, value, _retval)
    }



    /// `nsIDOMNodeList getElementsByAttributeNS (in DOMString namespaceURI, in DOMString name, in DOMString value);`
    #[inline]
    pub unsafe fn GetElementsByAttributeNS(&self, namespaceURI: &::nsstring::nsAString, name: &::nsstring::nsAString, value: &::nsstring::nsAString, _retval: *mut *const nsIDOMNodeList) -> nsresult {
        ((*self.vtable).GetElementsByAttributeNS)(self, namespaceURI, name, value, _retval)
    }



    /// `void addBroadcastListenerFor (in nsIDOMElement broadcaster, in nsIDOMElement observer, in DOMString attr);`
    #[inline]
    pub unsafe fn AddBroadcastListenerFor(&self, broadcaster: *const nsIDOMElement, observer: *const nsIDOMElement, attr: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).AddBroadcastListenerFor)(self, broadcaster, observer, attr)
    }



    /// `void removeBroadcastListenerFor (in nsIDOMElement broadcaster, in nsIDOMElement observer, in DOMString attr);`
    #[inline]
    pub unsafe fn RemoveBroadcastListenerFor(&self, broadcaster: *const nsIDOMElement, observer: *const nsIDOMElement, attr: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).RemoveBroadcastListenerFor)(self, broadcaster, observer, attr)
    }



    /// `void persist (in DOMString id, in DOMString attr);`
    #[inline]
    pub unsafe fn Persist(&self, id: &::nsstring::nsAString, attr: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).Persist)(self, id, attr)
    }



    /// `nsIBoxObject getBoxObjectFor (in nsIDOMElement elt);`
    #[inline]
    pub unsafe fn GetBoxObjectFor(&self, elt: *const nsIDOMElement, _retval: *mut *const nsIBoxObject) -> nsresult {
        ((*self.vtable).GetBoxObjectFor)(self, elt, _retval)
    }


    /// ```text
    /// /**
    ///    * Loads a XUL overlay and merges it with the current document, notifying an
    ///    * observer when the merge is complete.
    ///    * @param   url
    ///    *          The URL of the overlay to load and merge
    ///    * @param   observer
    ///    *          An object implementing nsIObserver that will be notified with a
    ///    *          message of topic "xul-overlay-merged" when the merge is complete.
    ///    *          The subject parameter of |observe| will QI to a nsIURI - the URI
    ///    *          of the merged overlay. This parameter is optional and may be null.
    ///    *
    ///    * NOTICE:  In the 2.0 timeframe this API will change such that the
    ///    *          implementation will fire a DOMXULOverlayMerged event upon merge
    ///    *          completion rather than notifying an observer. Do not rely on this
    ///    *          API's behavior _not_ to change because it will!
    ///    *          - Ben Goodger (8/23/2005)
    ///    */
    /// ```
    ///

    /// `void loadOverlay (in DOMString url, in nsIObserver aObserver);`
    #[inline]
    pub unsafe fn LoadOverlay(&self, url: &::nsstring::nsAString, aObserver: *const nsIObserver) -> nsresult {
        ((*self.vtable).LoadOverlay)(self, url, aObserver)
    }


}