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


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

    /// 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 nsIDOMUIEvent.
unsafe impl XpCom for nsIDOMUIEvent {
    const IID: nsIID = nsID(0x85ae52eb, 0x37fa, 0x4fd9,
        [0xa2, 0xe6, 0xc7, 0xd0, 0xf2, 0xa5, 0x21, 0xb3]);
}

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

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

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

    /* readonly attribute mozIDOMWindowProxy view; */
    pub GetView: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aView: *mut *const mozIDOMWindowProxy) -> nsresult,

    /* readonly attribute long detail; */
    pub GetDetail: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aDetail: *mut libc::int32_t) -> nsresult,

    /* void initUIEvent (in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in mozIDOMWindow viewArg, in long detailArg); */
    pub InitUIEvent: unsafe extern "system" fn (this: *const nsIDOMUIEvent, typeArg: &::nsstring::nsAString, canBubbleArg: bool, cancelableArg: bool, viewArg: *const mozIDOMWindow, detailArg: libc::int32_t) -> nsresult,

    /* readonly attribute long layerX; */
    pub GetLayerX: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aLayerX: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long layerY; */
    pub GetLayerY: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aLayerY: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long pageX; */
    pub GetPageX: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aPageX: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long pageY; */
    pub GetPageY: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aPageY: *mut libc::int32_t) -> nsresult,

    /* readonly attribute unsigned long which; */
    pub GetWhich: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aWhich: *mut libc::uint32_t) -> nsresult,

    /* readonly attribute nsIDOMNode rangeParent; */
    pub GetRangeParent: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aRangeParent: *mut *const nsIDOMNode) -> nsresult,

    /* readonly attribute long rangeOffset; */
    pub GetRangeOffset: unsafe extern "system" fn (this: *const nsIDOMUIEvent, aRangeOffset: *mut libc::int32_t) -> nsresult,

    /* [nostdcall,notxpcom] EventPtr AsEvent (); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub AsEvent: *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 nsIDOMUIEvent {

    pub const SCROLL_PAGE_UP: i64 = -32768;


    pub const SCROLL_PAGE_DOWN: i64 = 32768;


    /// `readonly attribute mozIDOMWindowProxy view;`
    #[inline]
    pub unsafe fn GetView(&self, aView: *mut *const mozIDOMWindowProxy) -> nsresult {
        ((*self.vtable).GetView)(self, aView)
    }



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



    /// `void initUIEvent (in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in mozIDOMWindow viewArg, in long detailArg);`
    #[inline]
    pub unsafe fn InitUIEvent(&self, typeArg: &::nsstring::nsAString, canBubbleArg: bool, cancelableArg: bool, viewArg: *const mozIDOMWindow, detailArg: libc::int32_t) -> nsresult {
        ((*self.vtable).InitUIEvent)(self, typeArg, canBubbleArg, cancelableArg, viewArg, detailArg)
    }



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



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



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



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



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



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



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



    /// `[nostdcall,notxpcom] EventPtr AsEvent ();`
    const _AsEvent: () = ();

}