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


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

    /// 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 nsIDOMEventTarget.
unsafe impl XpCom for nsIDOMEventTarget {
    const IID: nsIID = nsID(0x9a78ac3c, 0x9507, 0x4d00,
        [0xb2, 0xd6, 0x10, 0xb5, 0x08, 0xd2, 0xec, 0x31]);
}

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

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

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

    /* [optional_argc] void addEventListener (in DOMString type, in nsIDOMEventListener listener, [optional] in boolean useCapture, [optional] in boolean wantsUntrusted); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub AddEventListener: *const ::libc::c_void,

    /* [noscript,optional_argc] void addSystemEventListener (in DOMString type, in nsIDOMEventListener listener, [optional] in boolean aUseCapture, [optional] in boolean aWantsUntrusted); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub AddSystemEventListener: *const ::libc::c_void,

    /* void removeEventListener (in DOMString type, in nsIDOMEventListener listener, [optional] in boolean useCapture); */
    pub RemoveEventListener: unsafe extern "system" fn (this: *const nsIDOMEventTarget, type_: &::nsstring::nsAString, listener: *const nsIDOMEventListener, useCapture: bool) -> nsresult,

    /* [noscript] void removeSystemEventListener (in DOMString type, in nsIDOMEventListener listener, [optional] in boolean aUseCapture); */
    pub RemoveSystemEventListener: unsafe extern "system" fn (this: *const nsIDOMEventTarget, type_: &::nsstring::nsAString, listener: *const nsIDOMEventListener, aUseCapture: bool) -> nsresult,

    /* boolean dispatchEvent (in nsIDOMEvent evt) raises (DOMException); */
    pub DispatchEvent: unsafe extern "system" fn (this: *const nsIDOMEventTarget, evt: *const nsIDOMEvent, _retval: *mut bool) -> nsresult,

    /* [nostdcall,notxpcom] EventTargetPtr GetTargetForDOMEvent (); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub GetTargetForDOMEvent: *const ::libc::c_void,

    /* [nostdcall,notxpcom] EventTargetPtr GetTargetForEventTargetChain (); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub GetTargetForEventTargetChain: *const ::libc::c_void,

    /* [noscript,nostdcall] void GetEventTargetParent (in EventChainPreVisitorRef aVisitor); */
    /// Unable to generate binding because `native type mozilla::EventChainPreVisitor is unsupported`
    pub GetEventTargetParent: *const ::libc::c_void,

    /* [noscript,nostdcall] void WillHandleEvent (in EventChainPostVisitorRef aVisitor); */
    /// Unable to generate binding because `native type mozilla::EventChainPostVisitor is unsupported`
    pub WillHandleEvent: *const ::libc::c_void,

    /* [noscript,nostdcall] void PostHandleEvent (in EventChainPostVisitorRef aVisitor); */
    /// Unable to generate binding because `native type mozilla::EventChainPostVisitor is unsupported`
    pub PostHandleEvent: *const ::libc::c_void,

    /* [nostdcall,notxpcom] nsIScriptContext GetContextForEventHandlers (out nsresult aRv); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub GetContextForEventHandlers: *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 nsIDOMEventTarget {

    /// ```text
    /// /**
    ///    * This method allows the registration of event listeners on the event target.
    ///    * If an EventListener is added to an EventTarget while it is processing an
    ///    * event, it will not be triggered by the current actions but may be
    ///    * triggered during a later stage of event flow, such as the bubbling phase.
    ///    *
    ///    * If multiple identical EventListeners are registered on the same
    ///    * EventTarget with the same parameters the duplicate instances are
    ///    * discarded. They do not cause the EventListener to be called twice
    ///    * and since they are discarded they do not need to be removed with the
    ///    * removeEventListener method.
    ///    *
    ///    * @param   type The event type for which the user is registering
    ///    * @param   listener The listener parameter takes an interface
    ///    *                   implemented by the user which contains the methods
    ///    *                   to be called when the event occurs.
    ///    * @param   useCapture If true, useCapture indicates that the user
    ///    *                     wishes to initiate capture. After initiating
    ///    *                     capture, all events of the specified type will be
    ///    *                     dispatched to the registered EventListener before
    ///    *                     being dispatched to any EventTargets beneath them
    ///    *                     in the tree. Events which are bubbling upward
    ///    *                     through the tree will not trigger an
    ///    *                     EventListener designated to use capture.
    ///    * @param   wantsUntrusted If false, the listener will not receive any
    ///    *                         untrusted events (see above), if true, the
    ///    *                         listener will receive events whether or not
    ///    *                         they're trusted
    ///    */
    /// ```
    ///

    /// `[optional_argc] void addEventListener (in DOMString type, in nsIDOMEventListener listener, [optional] in boolean useCapture, [optional] in boolean wantsUntrusted);`
    const _AddEventListener: () = ();

    /// ```text
    /// /**
    ///    * addSystemEventListener() adds an event listener of aType to the system
    ///    * group.  Typically, core code should use system group for listening to
    ///    * content (i.e., non-chrome) element's events.  If core code uses
    ///    * nsIDOMEventTarget::AddEventListener for a content node, it means
    ///    * that the listener cannot listen the event when web content calls
    ///    * stopPropagation() of the event.
    ///    *
    ///    * @param aType            An event name you're going to handle.
    ///    * @param aListener        An event listener.
    ///    * @param aUseCapture      TRUE if you want to listen the event in capturing
    ///    *                         phase.  Otherwise, FALSE.
    ///    * @param aWantsUntrusted  TRUE if you want to handle untrusted events.
    ///    *                         Otherwise, FALSE.
    ///    * @return                 NS_OK if succeed.  Otherwise, NS_ERROR_*.
    ///    */
    /// ```
    ///

    /// `[noscript,optional_argc] void addSystemEventListener (in DOMString type, in nsIDOMEventListener listener, [optional] in boolean aUseCapture, [optional] in boolean aWantsUntrusted);`
    const _AddSystemEventListener: () = ();

    /// ```text
    /// /**
    ///    * This method allows the removal of event listeners from the event
    ///    * target. If an EventListener is removed from an EventTarget while it
    ///    * is processing an event, it will not be triggered by the current actions.
    ///    * EventListeners can never be invoked after being removed.
    ///    * Calling removeEventListener with arguments which do not identify any
    ///    * currently registered EventListener on the EventTarget has no effect.
    ///    *
    ///    * @param   type Specifies the event type of the EventListener being
    ///    *               removed.
    ///    * @param   listener The EventListener parameter indicates the
    ///    *                   EventListener to be removed.
    ///    * @param   useCapture Specifies whether the EventListener being
    ///    *                     removed was registered as a capturing listener or
    ///    *                     not. If a listener was registered twice, one with
    ///    *                     capture and one without, each must be removed
    ///    *                     separately. Removal of a capturing listener does
    ///    *                     not affect a non-capturing version of the same
    ///    *                     listener, and vice versa.
    ///    */
    /// ```
    ///

    /// `void removeEventListener (in DOMString type, in nsIDOMEventListener listener, [optional] in boolean useCapture);`
    #[inline]
    pub unsafe fn RemoveEventListener(&self, type_: &::nsstring::nsAString, listener: *const nsIDOMEventListener, useCapture: bool) -> nsresult {
        ((*self.vtable).RemoveEventListener)(self, type_, listener, useCapture)
    }


    /// ```text
    /// /**
    ///    * removeSystemEventListener() should be used if you have used
    ///    * addSystemEventListener().
    ///    */
    /// ```
    ///

    /// `[noscript] void removeSystemEventListener (in DOMString type, in nsIDOMEventListener listener, [optional] in boolean aUseCapture);`
    #[inline]
    pub unsafe fn RemoveSystemEventListener(&self, type_: &::nsstring::nsAString, listener: *const nsIDOMEventListener, aUseCapture: bool) -> nsresult {
        ((*self.vtable).RemoveSystemEventListener)(self, type_, listener, aUseCapture)
    }


    /// ```text
    /// /**
    ///    * This method allows the dispatch of events into the implementations
    ///    * event model. Events dispatched in this manner will have the same
    ///    * capturing and bubbling behavior as events dispatched directly by the
    ///    * implementation. The target of the event is the EventTarget on which
    ///    * dispatchEvent is called.
    ///    *
    ///    * @param   evt Specifies the event type, behavior, and contextual
    ///    *              information to be used in processing the event.
    ///    * @return  Indicates whether any of the listeners which handled the
    ///    *          event called preventDefault. If preventDefault was called
    ///    *          the value is false, else the value is true.
    ///    * @throws  INVALID_STATE_ERR: Raised if the Event's type was
    ///    *              not specified by initializing the event before
    ///    *              dispatchEvent was called. Specification of the Event's
    ///    *              type as null or an empty string will also trigger this
    ///    *              exception.
    ///    */
    /// ```
    ///

    /// `boolean dispatchEvent (in nsIDOMEvent evt) raises (DOMException);`
    #[inline]
    pub unsafe fn DispatchEvent(&self, evt: *const nsIDOMEvent, _retval: *mut bool) -> nsresult {
        ((*self.vtable).DispatchEvent)(self, evt, _retval)
    }


    /// ```text
    /// /**
    ///    * Returns the nsIDOMEventTarget object which should be used as the target
    ///    * of DOMEvents.
    ///    * Usually |this| is returned, but for example global object returns
    ///    * the outer object.
    ///    */
    /// ```
    ///

    /// `[nostdcall,notxpcom] EventTargetPtr GetTargetForDOMEvent ();`
    const _GetTargetForDOMEvent: () = ();

    /// ```text
    /// /**
    ///    * Returns the nsIDOMEventTarget object which should be used as the target
    ///    * of the event and when constructing event target chain.
    ///    * Usually |this| is returned, but for example global object returns
    ///    * the inner object.
    ///    */
    /// ```
    ///

    /// `[nostdcall,notxpcom] EventTargetPtr GetTargetForEventTargetChain ();`
    const _GetTargetForEventTargetChain: () = ();

    /// ```text
    /// /**
    ///    * Called before the capture phase of the event flow.
    ///    * This is used to create the event target chain and implementations
    ///    * should set the necessary members of EventChainPreVisitor.
    ///    * At least aVisitor.mCanHandle must be set,
    ///    * usually also aVisitor.mParentTarget if mCanHandle is PR_TRUE.
    ///    * First one tells that this object can handle the aVisitor.mEvent event and
    ///    * the latter one is the possible parent object for the event target chain.
    ///    * @see EventDispatcher.h for more documentation about aVisitor.
    ///    *
    ///    * @param aVisitor the visitor object which is used to create the
    ///    *                 event target chain for event dispatching.
    ///    *
    ///    * @note Only EventDispatcher should call this method.
    ///    */
    /// ```
    ///

    /// `[noscript,nostdcall] void GetEventTargetParent (in EventChainPreVisitorRef aVisitor);`
    const _GetEventTargetParent: () = ();

    /// ```text
    /// /**
    ///    * Called before the capture phase of the event flow and after event target
    ///    * chain creation. This is used to handle those stuffs must be executed before
    ///    * dispatch event to DOM
    ///    */
    /// /**
    ///    * If EventChainPreVisitor.mWantsWillHandleEvent is set PR_TRUE,
    ///    * called just before possible event handlers on this object will be called.
    ///    */
    /// ```
    ///

    /// `[noscript,nostdcall] void WillHandleEvent (in EventChainPostVisitorRef aVisitor);`
    const _WillHandleEvent: () = ();

    /// ```text
    /// /**
    ///    * Called after the bubble phase of the system event group.
    ///    * The default handling of the event should happen here.
    ///    * @param aVisitor the visitor object which is used during post handling.
    ///    *
    ///    * @see EventDispatcher.h for documentation about aVisitor.
    ///    * @note Only EventDispatcher should call this method.
    ///    */
    /// ```
    ///

    /// `[noscript,nostdcall] void PostHandleEvent (in EventChainPostVisitorRef aVisitor);`
    const _PostHandleEvent: () = ();

    /// ```text
    /// /**
    ///    * Get the script context in which the event handlers should be run.
    ///    * May return null.
    ///    * @note Caller *must* check the value of aRv.
    ///    */
    /// ```
    ///

    /// `[nostdcall,notxpcom] nsIScriptContext GetContextForEventHandlers (out nsresult aRv);`
    const _GetContextForEventHandlers: () = ();

}