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


/// `interface nsIDOMSimpleGestureEvent : nsIDOMMouseEvent`
///

/// ```text
/// /**
///  * The nsIDOMSimpleGestureEvent interface is the datatype for all
///  * Mozilla-specific simple gesture events in the Document Object Model.
///  *
///  * The following events are generated:
///  *
///  * MozSwipeGestureMayStart - Generated when the user starts a horizontal
///  * swipe across the input device, but before we know whether the user
///  * is actually scrolling past a scroll edge.
///  * This event asks two questions:  Should a swipe really be started, and
///  * in which directions should the user be able to swipe?  The first
///  * question is answered by event listeners by calling or not calling
///  * preventDefault() on the event.  Since a swipe swallows all scroll
///  * events, the default action of the swipe start event is *not* to
///  * start a swipe. Call preventDefault() if you want a swipe to be
///  * started. Doing so won't necessarily result in a swipe being started,
///  * it only communicates an intention. Once Gecko determines whether a
///  * swipe should actually be started, it will send a MozSwipeGestureStart
///  * event.
///  * The second question (swipe-able directions) is answered in the
///  * allowedDirections field.
///  *
///  * MozSwipeGestureStart - This event signals the start of a swipe.
///  * It guarantees a future MozSwipeGestureEnd event that will signal
///  * the end of a swipe animation.
///  *
///  * MozSwipeGestureUpdate - Generated periodically while the user is
///  * continuing a horizontal swipe gesture.  The "delta" value represents
///  * the current absolute gesture amount.  This event may even be sent
///  * after a MozSwipeGesture event fired in order to allow for fluid
///  * completion of a swipe animation.  The direction value is meaningless
///  * on swipe update events.
///  *
///  * MozSwipeGestureEnd - Generated when the swipe animation is completed.
///  *
///  * MozSwipeGesture - Generated when the user releases a swipe across
///  * across the input device.  This event signals that the actual swipe
///  * operation is complete, even though the animation might not be finished
///  * yet.  This event can be sent without accompanying start / update / end
///  * events, and it can also be handled on its own if the consumer doesn't
///  * want to handle swipe animation events.
///  * Only the direction value has any significance, the delta value is
///  * meaningless.
///  *
///  * MozMagnifyGestureStart - Generated when the user begins the magnify
///  * ("pinch") gesture.  The "delta" value represents the initial
///  * movement.
///  *
///  * MozMagnifyGestureUpdate - Generated periodically while the user is
///  * continuing the magnify ("pinch") gesture.  The "delta" value
///  * represents the movement since the last MozMagnifyGestureStart or
///  * MozMagnifyGestureUpdate event.
///  *
///  * MozMagnifyGesture - Generated when the user has completed the
///  * magnify ("pinch") gesture.  If you only want to receive a single
///  * event when the magnify gesture is complete, you only need to hook
///  * this event and can safely ignore the MozMagnifyGestureStart and the
///  * MozMagnifyGestureUpdate events. The "delta" value is the cumulative
///  * amount represented by the user's gesture.
///  *
///  * MozRotateGestureStart - Generated when the user begins the rotation
///  * gesture.  The "delta" value represents the initial rotation.
///  *
///  * MozRotateGestureUpdate - Generated periodically while the user is
///  * continuing the rotation gesture.  The "delta" value represents the
///  * rotation since the last MozRotateGestureStart or
///  * MozRotateGestureUpdate event.
///  *
///  * MozRotateGesture - Generated when the user has completed the
///  * rotation gesture.  If you only want to receive a single event when
///  * the rotation gesture is complete, you only need to hook this event
///  * and can safely ignore the MozRotateGestureStart and the
///  * MozRotateGestureUpdate events.  The "delta" value is the cumulative
///  * amount of rotation represented by the user's gesture.
///  *
///  * MozTapGesture - Generated when the user executes a two finger
///  * tap gesture on the input device. Client coordinates contain the
///  * center point of the tap.
///  * (XXX On OS X, only Lion (10.7) and up)
///  *
///  * MozPressTapGesture - Generated when the user executes a press
///  * and tap two finger gesture (first finger down, second finger down,
    ///  * second finger up, first finger up) on the input device.
///  * Client coordinates contain the center pivot point of the action.
///  * (XXX Not implemented on Mac)
///  *
///  * MozEdgeUIGesture - Generated when the user swipes the display to
///  * invoke edge ui.
///  * (XXX Win8 only)
///  *
///  * Default behavior:
///  *
///  * Some operating systems support default behaviors for gesture events
///  * when they are not handled by the application. Consumers should
///  * use event.preventDefault() to prevent default behavior when
///  * consuming events.
///  */
/// ```
///

// 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 nsIDOMSimpleGestureEvent {
    vtable: *const nsIDOMSimpleGestureEventVTable,

    /// 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 nsIDOMSimpleGestureEvent.
unsafe impl XpCom for nsIDOMSimpleGestureEvent {
    const IID: nsIID = nsID(0xc397f9a2, 0x4266, 0x4291,
        [0xb2, 0x82, 0x3e, 0xfd, 0x6d, 0x7a, 0xfc, 0x57]);
}

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

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

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

    /* attribute unsigned long allowedDirections; */
    pub GetAllowedDirections: unsafe extern "system" fn (this: *const nsIDOMSimpleGestureEvent, aAllowedDirections: *mut libc::uint32_t) -> nsresult,

    /* attribute unsigned long allowedDirections; */
    pub SetAllowedDirections: unsafe extern "system" fn (this: *const nsIDOMSimpleGestureEvent, aAllowedDirections: libc::uint32_t) -> nsresult,

    /* readonly attribute unsigned long direction; */
    pub GetDirection: unsafe extern "system" fn (this: *const nsIDOMSimpleGestureEvent, aDirection: *mut libc::uint32_t) -> nsresult,

    /* readonly attribute double delta; */
    pub GetDelta: unsafe extern "system" fn (this: *const nsIDOMSimpleGestureEvent, aDelta: *mut libc::c_double) -> nsresult,

    /* readonly attribute unsigned long clickCount; */
    pub GetClickCount: unsafe extern "system" fn (this: *const nsIDOMSimpleGestureEvent, aClickCount: *mut libc::uint32_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 nsIDOMSimpleGestureEvent {

    pub const DIRECTION_UP: i64 = 1;


    pub const DIRECTION_DOWN: i64 = 2;


    pub const DIRECTION_LEFT: i64 = 4;


    pub const DIRECTION_RIGHT: i64 = 8;


    pub const ROTATION_COUNTERCLOCKWISE: i64 = 1;


    pub const ROTATION_CLOCKWISE: i64 = 2;


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



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



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



    /// `readonly attribute double delta;`
    #[inline]
    pub unsafe fn GetDelta(&self, aDelta: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetDelta)(self, aDelta)
    }



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


}