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


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

    /// 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 nsIDragService.
unsafe impl XpCom for nsIDragService {
    const IID: nsIID = nsID(0xebd6b3a2, 0xaf16, 0x43af,
        [0xa6, 0x98, 0x30, 0x91, 0xa0, 0x87, 0xdd, 0x62]);
}

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

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

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

    /* void invokeDragSession (in nsIDOMNode aDOMNode, in nsIArray aTransferables, in nsIScriptableRegion aRegion, in unsigned long aActionType, [optional] in nsContentPolicyType aContentPolicyType); */
    pub InvokeDragSession: unsafe extern "system" fn (this: *const nsIDragService, aDOMNode: *const nsIDOMNode, aTransferables: *const nsIArray, aRegion: *const nsIScriptableRegion, aActionType: libc::uint32_t, aContentPolicyType: nsContentPolicyType) -> nsresult,

    /* void invokeDragSessionWithImage (in nsIDOMNode aDOMNode, in nsIArray aTransferableArray, in nsIScriptableRegion aRegion, in unsigned long aActionType, in nsIDOMNode aImage, in long aImageX, in long aImageY, in nsIDOMDragEvent aDragEvent, in nsIDOMDataTransfer aDataTransfer); */
    pub InvokeDragSessionWithImage: unsafe extern "system" fn (this: *const nsIDragService, aDOMNode: *const nsIDOMNode, aTransferableArray: *const nsIArray, aRegion: *const nsIScriptableRegion, aActionType: libc::uint32_t, aImage: *const nsIDOMNode, aImageX: libc::int32_t, aImageY: libc::int32_t, aDragEvent: *const nsIDOMDragEvent, aDataTransfer: *const nsIDOMDataTransfer) -> nsresult,

    /* void invokeDragSessionWithSelection (in nsISelection aSelection, in nsIArray aTransferableArray, in unsigned long aActionType, in nsIDOMDragEvent aDragEvent, in nsIDOMDataTransfer aDataTransfer); */
    pub InvokeDragSessionWithSelection: unsafe extern "system" fn (this: *const nsIDragService, aSelection: *const nsISelection, aTransferableArray: *const nsIArray, aActionType: libc::uint32_t, aDragEvent: *const nsIDOMDragEvent, aDataTransfer: *const nsIDOMDataTransfer) -> nsresult,

    /* nsIDragSession getCurrentSession (); */
    pub GetCurrentSession: unsafe extern "system" fn (this: *const nsIDragService, _retval: *mut *const nsIDragSession) -> nsresult,

    /* void startDragSession (); */
    pub StartDragSession: unsafe extern "system" fn (this: *const nsIDragService) -> nsresult,

    /* void endDragSession (in boolean aDoneDrag, [optional] in unsigned long aKeyModifiers); */
    pub EndDragSession: unsafe extern "system" fn (this: *const nsIDragService, aDoneDrag: bool, aKeyModifiers: libc::uint32_t) -> nsresult,

    /* [noscript] void fireDragEventAtSource (in EventMessage aEventMessage, in unsigned long aKeyModifiers); */
    /// Unable to generate binding because `native type mozilla::EventMessage is unsupported`
    pub FireDragEventAtSource: *const ::libc::c_void,

    /* void suppress (); */
    pub Suppress: unsafe extern "system" fn (this: *const nsIDragService) -> nsresult,

    /* void unsuppress (); */
    pub Unsuppress: unsafe extern "system" fn (this: *const nsIDragService) -> nsresult,

    /* [noscript] void dragMoved (in long aX, in long aY); */
    pub DragMoved: unsafe extern "system" fn (this: *const nsIDragService, aX: libc::int32_t, aY: libc::int32_t) -> nsresult,

    /* [nostdcall,notxpcom] boolean maybeAddChildProcess (in ContentParentPtr aChild); */
    /// Unable to generate binding because `native type mozilla::dom::ContentParent is unsupported`
    pub MaybeAddChildProcess: *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 nsIDragService {

    pub const DRAGDROP_ACTION_NONE: i64 = 0;


    pub const DRAGDROP_ACTION_COPY: i64 = 1;


    pub const DRAGDROP_ACTION_MOVE: i64 = 2;


    pub const DRAGDROP_ACTION_LINK: i64 = 4;


    pub const DRAGDROP_ACTION_UNINITIALIZED: i64 = 64;

    /// ```text
    /// /**
    ///     * Starts a modal drag session with an array of transaferables.
    ///     *
    ///     * Note: This method is deprecated for non-native code.
    ///     *
    ///     * @param  aTransferables - an array of transferables to be dragged
    ///     * @param  aRegion - a region containing rectangles for cursor feedback,
    ///     *            in window coordinates.
    ///     * @param  aActionType - specified which of copy/move/link are allowed
    ///     * @param  aContentPolicyType - the contentPolicyType that will be
    ///     *           passed to the loadInfo when creating a new channel
    ///     *           (defaults to TYPE_OTHER)
    ///     */
    /// ```
    ///

    /// `void invokeDragSession (in nsIDOMNode aDOMNode, in nsIArray aTransferables, in nsIScriptableRegion aRegion, in unsigned long aActionType, [optional] in nsContentPolicyType aContentPolicyType);`
    #[inline]
    pub unsafe fn InvokeDragSession(&self, aDOMNode: *const nsIDOMNode, aTransferables: *const nsIArray, aRegion: *const nsIScriptableRegion, aActionType: libc::uint32_t, aContentPolicyType: nsContentPolicyType) -> nsresult {
        ((*self.vtable).InvokeDragSession)(self, aDOMNode, aTransferables, aRegion, aActionType, aContentPolicyType)
    }


    /// ```text
    /// /**
    ///    * Starts a modal drag session using an image. The first four arguments are
    ///    * the same as invokeDragSession.
    ///    *
    ///    * Note: This method is deprecated for non-native code.
    ///    *
    ///    * A custom image may be specified using the aImage argument. If this is
    ///    * supplied, the aImageX and aImageY arguments specify the offset within
    ///    * the image where the cursor would be positioned. That is, when the image
    ///    * is drawn, it is offset up and left the amount so that the cursor appears
    ///    * at that location within the image.
    ///    *
    ///    * If aImage is null, aImageX and aImageY are not used and the image is instead
    ///    * determined from the source node aDOMNode, and the offset calculated so that
    ///    * the initial location for the image appears in the same screen position as
    ///    * where the element is located. The node must be within a document.
    ///    *
    ///    * Currently, supported images are all DOM nodes. If this is an HTML <image> or
    ///    * <canvas>, the drag image is taken from the image data. If the element is in
    ///    * a document, it will be rendered at its displayed size, othewise, it will be
    ///    * rendered at its real size. For other types of elements, the element is
    ///    * rendered into an offscreen buffer in the same manner as it is currently
    ///    * displayed. The document selection is hidden while drawing.
    ///    *
    ///    * The aDragEvent must be supplied as the current screen coordinates of the
    ///    * event are needed to calculate the image location.
    ///    */
    /// ```
    ///

    /// `void invokeDragSessionWithImage (in nsIDOMNode aDOMNode, in nsIArray aTransferableArray, in nsIScriptableRegion aRegion, in unsigned long aActionType, in nsIDOMNode aImage, in long aImageX, in long aImageY, in nsIDOMDragEvent aDragEvent, in nsIDOMDataTransfer aDataTransfer);`
    #[inline]
    pub unsafe fn InvokeDragSessionWithImage(&self, aDOMNode: *const nsIDOMNode, aTransferableArray: *const nsIArray, aRegion: *const nsIScriptableRegion, aActionType: libc::uint32_t, aImage: *const nsIDOMNode, aImageX: libc::int32_t, aImageY: libc::int32_t, aDragEvent: *const nsIDOMDragEvent, aDataTransfer: *const nsIDOMDataTransfer) -> nsresult {
        ((*self.vtable).InvokeDragSessionWithImage)(self, aDOMNode, aTransferableArray, aRegion, aActionType, aImage, aImageX, aImageY, aDragEvent, aDataTransfer)
    }


    /// ```text
    /// /**
    ///    * Start a modal drag session using the selection as the drag image.
    ///    * The aDragEvent must be supplied as the current screen coordinates of the
    ///    * event are needed to calculate the image location.
    ///    *
    ///    * Note: This method is deprecated for non-native code.
    ///    */
    /// ```
    ///

    /// `void invokeDragSessionWithSelection (in nsISelection aSelection, in nsIArray aTransferableArray, in unsigned long aActionType, in nsIDOMDragEvent aDragEvent, in nsIDOMDataTransfer aDataTransfer);`
    #[inline]
    pub unsafe fn InvokeDragSessionWithSelection(&self, aSelection: *const nsISelection, aTransferableArray: *const nsIArray, aActionType: libc::uint32_t, aDragEvent: *const nsIDOMDragEvent, aDataTransfer: *const nsIDOMDataTransfer) -> nsresult {
        ((*self.vtable).InvokeDragSessionWithSelection)(self, aSelection, aTransferableArray, aActionType, aDragEvent, aDataTransfer)
    }


    /// ```text
    /// /**
    ///     * Returns the current Drag Session
    ///     */
    /// ```
    ///

    /// `nsIDragSession getCurrentSession ();`
    #[inline]
    pub unsafe fn GetCurrentSession(&self, _retval: *mut *const nsIDragSession) -> nsresult {
        ((*self.vtable).GetCurrentSession)(self, _retval)
    }


    /// ```text
    /// /**
    ///     * Tells the Drag Service to start a drag session. This is called when
    ///     * an external drag occurs
    ///     */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///     * Tells the Drag Service to end a drag session. This is called when
    ///     * an external drag occurs
    ///     *
    ///     * If aDoneDrag is true, the drag has finished, otherwise the drag has
    ///     * just left the window.
    ///     */
    /// ```
    ///

    /// `void endDragSession (in boolean aDoneDrag, [optional] in unsigned long aKeyModifiers);`
    #[inline]
    pub unsafe fn EndDragSession(&self, aDoneDrag: bool, aKeyModifiers: libc::uint32_t) -> nsresult {
        ((*self.vtable).EndDragSession)(self, aDoneDrag, aKeyModifiers)
    }


    /// ```text
    /// /**
    ///    * Fire a drag event at the source of the drag
    ///    */
    /// ```
    ///

    /// `[noscript] void fireDragEventAtSource (in EventMessage aEventMessage, in unsigned long aKeyModifiers);`
    const _FireDragEventAtSource: () = ();

    /// ```text
    /// /**
    ///    * Increase/decrease dragging suppress level by one.
    ///    * If level is greater than one, dragging is disabled.
    ///    */
    /// ```
    ///

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



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


    /// ```text
    /// /**
    ///     * aX and aY are in LayoutDevice pixels.
    ///     */
    /// ```
    ///

    /// `[noscript] void dragMoved (in long aX, in long aY);`
    #[inline]
    pub unsafe fn DragMoved(&self, aX: libc::int32_t, aY: libc::int32_t) -> nsresult {
        ((*self.vtable).DragMoved)(self, aX, aY)
    }



    /// `[nostdcall,notxpcom] boolean maybeAddChildProcess (in ContentParentPtr aChild);`
    const _MaybeAddChildProcess: () = ();

}