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


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

    /// 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 nsIDOMEvent.
unsafe impl XpCom for nsIDOMEvent {
    const IID: nsIID = nsID(0xf58daacf, 0x4d1a, 0x4002,
        [0x8f, 0xd7, 0x06, 0xb6, 0x14, 0xdf, 0xbc, 0xf6]);
}

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

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

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

    /* readonly attribute DOMString type; */
    pub GetType: unsafe extern "system" fn (this: *const nsIDOMEvent, aType: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute nsIDOMEventTarget target; */
    pub GetTarget: unsafe extern "system" fn (this: *const nsIDOMEvent, aTarget: *mut *const nsIDOMEventTarget) -> nsresult,

    /* readonly attribute nsIDOMEventTarget currentTarget; */
    pub GetCurrentTarget: unsafe extern "system" fn (this: *const nsIDOMEvent, aCurrentTarget: *mut *const nsIDOMEventTarget) -> nsresult,

    /* readonly attribute unsigned short eventPhase; */
    pub GetEventPhase: unsafe extern "system" fn (this: *const nsIDOMEvent, aEventPhase: *mut libc::uint16_t) -> nsresult,

    /* readonly attribute boolean bubbles; */
    pub GetBubbles: unsafe extern "system" fn (this: *const nsIDOMEvent, aBubbles: *mut bool) -> nsresult,

    /* readonly attribute boolean cancelable; */
    pub GetCancelable: unsafe extern "system" fn (this: *const nsIDOMEvent, aCancelable: *mut bool) -> nsresult,

    /* readonly attribute DOMTimeStamp timeStamp; */
    pub GetTimeStamp: unsafe extern "system" fn (this: *const nsIDOMEvent, aTimeStamp: *mut DOMTimeStamp) -> nsresult,

    /* void stopPropagation (); */
    pub StopPropagation: unsafe extern "system" fn (this: *const nsIDOMEvent) -> nsresult,

    /* void preventDefault (); */
    pub PreventDefault: unsafe extern "system" fn (this: *const nsIDOMEvent) -> nsresult,

    /* [nostdcall,notxpcom] void initEvent (in DOMString eventTypeArg, in boolean canBubbleArg, in boolean cancelableArg); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub InitEvent: *const ::libc::c_void,

    /* readonly attribute boolean defaultPrevented; */
    pub GetDefaultPrevented: unsafe extern "system" fn (this: *const nsIDOMEvent, aDefaultPrevented: *mut bool) -> nsresult,

    /* void stopImmediatePropagation (); */
    pub StopImmediatePropagation: unsafe extern "system" fn (this: *const nsIDOMEvent) -> nsresult,

    /* readonly attribute nsIDOMEventTarget originalTarget; */
    pub GetOriginalTarget: unsafe extern "system" fn (this: *const nsIDOMEvent, aOriginalTarget: *mut *const nsIDOMEventTarget) -> nsresult,

    /* readonly attribute nsIDOMEventTarget explicitOriginalTarget; */
    pub GetExplicitOriginalTarget: unsafe extern "system" fn (this: *const nsIDOMEvent, aExplicitOriginalTarget: *mut *const nsIDOMEventTarget) -> nsresult,

    /* readonly attribute boolean isTrusted; */
    pub GetIsTrusted: unsafe extern "system" fn (this: *const nsIDOMEvent, aIsTrusted: *mut bool) -> nsresult,

    /* attribute boolean cancelBubble; */
    pub GetCancelBubble: unsafe extern "system" fn (this: *const nsIDOMEvent, aCancelBubble: *mut bool) -> nsresult,

    /* attribute boolean cancelBubble; */
    pub SetCancelBubble: unsafe extern "system" fn (this: *const nsIDOMEvent, aCancelBubble: bool) -> nsresult,

    /* [noscript] void duplicatePrivateData (); */
    pub DuplicatePrivateData: unsafe extern "system" fn (this: *const nsIDOMEvent) -> nsresult,

    /* [noscript] void setTarget (in nsIDOMEventTarget aTarget); */
    pub SetTarget: unsafe extern "system" fn (this: *const nsIDOMEvent, aTarget: *const nsIDOMEventTarget) -> nsresult,

    /* [notxpcom] boolean IsDispatchStopped (); */
    pub IsDispatchStopped: unsafe extern "system" fn (this: *const nsIDOMEvent) -> bool,

    /* [notxpcom] WidgetEvent WidgetEventPtr (); */
    /// Unable to generate binding because `native type mozilla::WidgetEvent is unsupported`
    pub WidgetEventPtr: *const ::libc::c_void,

    /* [noscript,notxpcom] void SetTrusted (in boolean aTrusted); */
    pub SetTrusted: unsafe extern "system" fn (this: *const nsIDOMEvent, aTrusted: bool) -> libc::c_void,

    /* [notxpcom] void Serialize (in IPCMessagePtr aMsg, in boolean aSerializeInterfaceType); */
    /// Unable to generate binding because `native type IPC::Message is unsupported`
    pub Serialize: *const ::libc::c_void,

    /* [notxpcom] boolean Deserialize (in ConstIPCMessagePtr aMsg, in PickleIterator aIter); */
    /// Unable to generate binding because `native type const IPC::Message is unsupported`
    pub Deserialize: *const ::libc::c_void,

    /* [noscript,notxpcom] void SetOwner (in EventTargetPtr aOwner); */
    /// Unable to generate binding because `native type mozilla::dom::EventTarget is unsupported`
    pub SetOwner: *const ::libc::c_void,

    /* [notxpcom] DOMEventPtr InternalDOMEvent (); */
    /// Unable to generate binding because `native type mozilla::dom::Event is unsupported`
    pub InternalDOMEvent: *const ::libc::c_void,

    /* [noscript] void stopCrossProcessForwarding (); */
    pub StopCrossProcessForwarding: unsafe extern "system" fn (this: *const nsIDOMEvent) -> 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 nsIDOMEvent {
    /// ```text
    /// /**
    ///  * The nsIDOMEvent interface is the primary datatype for all events in
    ///  * the Document Object Model.
    ///  *
    ///  * For more information on this interface please see
    ///  * http://dev.w3.org/2006/webapi/DOM-Level-3-Events/html/DOM3-Events.html and
    ///  * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html
    ///  */
    /// /**
    ///    * The event isn't being dispatched.
    ///    */
    /// ```
    ///

    pub const NONE: i64 = 0;

    /// ```text
    /// /**
    ///    * The current event phase is the capturing phase.
    ///    */
    /// ```
    ///

    pub const CAPTURING_PHASE: i64 = 1;

    /// ```text
    /// /**
    ///    * The event is currently being evaluated at the target EventTarget.
    ///    */
    /// ```
    ///

    pub const AT_TARGET: i64 = 2;

    /// ```text
    /// /**
    ///    * The current event phase is the bubbling phase.
    ///    */
    /// ```
    ///

    pub const BUBBLING_PHASE: i64 = 3;


    pub const ALT_MASK: i64 = 1;


    pub const CONTROL_MASK: i64 = 2;


    pub const SHIFT_MASK: i64 = 4;


    pub const META_MASK: i64 = 8;

    /// ```text
    /// /**
    ///    * The name of the event (case-insensitive). The name must be an XML
    ///    * name.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Used to indicate the EventTarget to which the event was originally
    ///    * dispatched.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDOMEventTarget target;`
    #[inline]
    pub unsafe fn GetTarget(&self, aTarget: *mut *const nsIDOMEventTarget) -> nsresult {
        ((*self.vtable).GetTarget)(self, aTarget)
    }


    /// ```text
    /// /**
    ///    * Used to indicate the EventTarget whose EventListeners are currently
    ///    * being processed. This is particularly useful during capturing and
    ///    * bubbling.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDOMEventTarget currentTarget;`
    #[inline]
    pub unsafe fn GetCurrentTarget(&self, aCurrentTarget: *mut *const nsIDOMEventTarget) -> nsresult {
        ((*self.vtable).GetCurrentTarget)(self, aCurrentTarget)
    }


    /// ```text
    /// /**
    ///    * Used to indicate which phase of event flow is currently being
    ///    * evaluated.
    ///    */
    /// ```
    ///

    /// `readonly attribute unsigned short eventPhase;`
    #[inline]
    pub unsafe fn GetEventPhase(&self, aEventPhase: *mut libc::uint16_t) -> nsresult {
        ((*self.vtable).GetEventPhase)(self, aEventPhase)
    }


    /// ```text
    /// /**
    ///    * Used to indicate whether or not an event is a bubbling event. If the
    ///    * event can bubble the value is true, else the value is false.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Used to indicate whether or not an event can have its default action
    ///    * prevented. If the default action can be prevented the value is true,
    ///    * else the value is false.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Used to specify the time (in milliseconds relative to the epoch) at
    ///    * which the event was created. Due to the fact that some systems may
    ///    * not provide this information the value of timeStamp may be not
    ///    * available for all events. When not available, a value of 0 will be
    ///    * returned. Examples of epoch time are the time of the system start or
    ///    * 0:0:0 UTC 1st January 1970.
    ///    */
    /// ```
    ///

    /// `readonly attribute DOMTimeStamp timeStamp;`
    #[inline]
    pub unsafe fn GetTimeStamp(&self, aTimeStamp: *mut DOMTimeStamp) -> nsresult {
        ((*self.vtable).GetTimeStamp)(self, aTimeStamp)
    }


    /// ```text
    /// /**
    ///    * The stopPropagation method is used prevent further propagation of an
    ///    * event during event flow. If this method is called by any
    ///    * EventListener the event will cease propagating through the tree. The
    ///    * event will complete dispatch to all listeners on the current
    ///    * EventTarget before event flow stops. This method may be used during
    ///    * any stage of event flow.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * If an event is cancelable, the preventDefault method is used to
    ///    * signify that the event is to be canceled, meaning any default action
    ///    * normally taken by the implementation as a result of the event will
    ///    * not occur. If, during any stage of event flow, the preventDefault
    ///    * method is called the event is canceled. Any default action associated
    ///    * with the event will not occur. Calling this method for a
    ///    * non-cancelable event has no effect. Once preventDefault has been
    ///    * called it will remain in effect throughout the remainder of the
    ///    * event's propagation. This method may be used during any stage of
    ///    * event flow.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * The initEvent method is used to initialize the value of an Event
    ///    * created through the DocumentEvent interface. This method may only be
    ///    * called before the Event has been dispatched via the dispatchEvent
    ///    * method, though it may be called multiple times during that phase if
    ///    * necessary. If called multiple times the final invocation takes
    ///    * precedence. If called from a subclass of Event interface only the
    ///    * values specified in the initEvent method are modified, all other
    ///    * attributes are left unchanged.
    ///    *
    ///    * @param   eventTypeArg Specifies the event type. This type may be
    ///    *                       any event type currently defined in this
    ///    *                       specification or a new event type.. The string
    ///    *                       must be an XML name.
    ///    *                       Any new event type must not begin with any
    ///    *                       upper, lower, or mixed case version of the
    ///    *                       string "DOM". This prefix is reserved for
    ///    *                       future DOM event sets. It is also strongly
    ///    *                       recommended that third parties adding their
    ///    *                       own events use their own prefix to avoid
    ///    *                       confusion and lessen the probability of
    ///    *                       conflicts with other new events.
    ///    * @param   canBubbleArg Specifies whether or not the event can bubble.
    ///    * @param   cancelableArg Specifies whether or not the event's default
    ///    *                        action can be prevented.
    ///    */
    /// ```
    ///

    /// `[nostdcall,notxpcom] void initEvent (in DOMString eventTypeArg, in boolean canBubbleArg, in boolean cancelableArg);`
    const _InitEvent: () = ();

    /// ```text
    /// /**
    ///    * Used to indicate whether preventDefault() has been called for this event.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Prevents other event listeners from being triggered and,
    ///    * unlike Event.stopPropagation() its effect is immediate.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /** The original target of the event, before any retargetings. */
    /// ```
    ///

    /// `readonly attribute nsIDOMEventTarget originalTarget;`
    #[inline]
    pub unsafe fn GetOriginalTarget(&self, aOriginalTarget: *mut *const nsIDOMEventTarget) -> nsresult {
        ((*self.vtable).GetOriginalTarget)(self, aOriginalTarget)
    }


    /// ```text
    /// /**
    ///    * The explicit original target of the event.  If the event was retargeted
    ///    * for some reason other than an anonymous boundary crossing, this will be set
    ///    * to the target before the retargeting occurs.  For example, mouse events
    ///    * are retargeted to their parent node when they happen over text nodes (bug
        ///    * 185889), and in that case .target will show the parent and
    ///    * .explicitOriginalTarget will show the text node.
    ///    * .explicitOriginalTarget differs from .originalTarget in that it will never
    ///    * contain anonymous content.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDOMEventTarget explicitOriginalTarget;`
    #[inline]
    pub unsafe fn GetExplicitOriginalTarget(&self, aExplicitOriginalTarget: *mut *const nsIDOMEventTarget) -> nsresult {
        ((*self.vtable).GetExplicitOriginalTarget)(self, aExplicitOriginalTarget)
    }



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



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



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



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



    /// `[noscript] void setTarget (in nsIDOMEventTarget aTarget);`
    #[inline]
    pub unsafe fn SetTarget(&self, aTarget: *const nsIDOMEventTarget) -> nsresult {
        ((*self.vtable).SetTarget)(self, aTarget)
    }



    /// `[notxpcom] boolean IsDispatchStopped ();`
    #[inline]
    pub unsafe fn IsDispatchStopped(&self, ) -> bool {
        ((*self.vtable).IsDispatchStopped)(self, )
    }



    /// `[notxpcom] WidgetEvent WidgetEventPtr ();`
    const _WidgetEventPtr: () = ();


    /// `[noscript,notxpcom] void SetTrusted (in boolean aTrusted);`
    #[inline]
    pub unsafe fn SetTrusted(&self, aTrusted: bool) -> libc::c_void {
        ((*self.vtable).SetTrusted)(self, aTrusted)
    }



    /// `[notxpcom] void Serialize (in IPCMessagePtr aMsg, in boolean aSerializeInterfaceType);`
    const _Serialize: () = ();


    /// `[notxpcom] boolean Deserialize (in ConstIPCMessagePtr aMsg, in PickleIterator aIter);`
    const _Deserialize: () = ();


    /// `[noscript,notxpcom] void SetOwner (in EventTargetPtr aOwner);`
    const _SetOwner: () = ();


    /// `[notxpcom] DOMEventPtr InternalDOMEvent ();`
    const _InternalDOMEvent: () = ();


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


}