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


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

    /// 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 nsIDOMDataTransfer.
unsafe impl XpCom for nsIDOMDataTransfer {
    const IID: nsIID = nsID(0x655078bf, 0x1675, 0x4aa0,
        [0xa4, 0x8d, 0xa1, 0x33, 0xe8, 0x64, 0xce, 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 nsIDOMDataTransfer {
    #[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 nsIDOMDataTransfer.
// 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 nsIDOMDataTransferCoerce {
    /// Cheaply cast a value of this type from a `nsIDOMDataTransfer`.
    fn coerce_from(v: &nsIDOMDataTransfer) -> &Self;
}

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

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

    /* attribute DOMString dropEffect; */
    pub GetDropEffect: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aDropEffect: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute DOMString dropEffect; */
    pub SetDropEffect: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aDropEffect: &::nsstring::nsAString) -> nsresult,

    /* attribute DOMString effectAllowed; */
    pub GetEffectAllowed: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aEffectAllowed: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute DOMString effectAllowed; */
    pub SetEffectAllowed: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aEffectAllowed: &::nsstring::nsAString) -> nsresult,

    /* readonly attribute nsIDOMFileList files; */
    pub GetFiles: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aFiles: *mut *const nsIDOMFileList) -> nsresult,

    /* void setDragImage (in nsIDOMElement image, in long x, in long y); */
    pub SetDragImage: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, image: *const nsIDOMElement, x: libc::int32_t, y: libc::int32_t) -> nsresult,

    /* void addElement (in nsIDOMElement element); */
    pub AddElement: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, element: *const nsIDOMElement) -> nsresult,

    /* readonly attribute unsigned long mozItemCount; */
    pub GetMozItemCount: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aMozItemCount: *mut libc::uint32_t) -> nsresult,

    /* attribute DOMString mozCursor; */
    pub GetMozCursor: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aMozCursor: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute DOMString mozCursor; */
    pub SetMozCursor: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aMozCursor: &::nsstring::nsAString) -> nsresult,

    /* readonly attribute boolean mozUserCancelled; */
    pub GetMozUserCancelled: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aMozUserCancelled: *mut bool) -> nsresult,

    /* readonly attribute nsIDOMNode mozSourceNode; */
    pub GetMozSourceNode: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aMozSourceNode: *mut *const nsIDOMNode) -> nsresult,

    /* [noscript] attribute unsigned long dropEffectInt; */
    pub GetDropEffectInt: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aDropEffectInt: *mut libc::uint32_t) -> nsresult,

    /* [noscript] attribute unsigned long dropEffectInt; */
    pub SetDropEffectInt: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aDropEffectInt: libc::uint32_t) -> nsresult,

    /* [noscript] attribute unsigned long effectAllowedInt; */
    pub GetEffectAllowedInt: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aEffectAllowedInt: *mut libc::uint32_t) -> nsresult,

    /* [noscript] attribute unsigned long effectAllowedInt; */
    pub SetEffectAllowedInt: unsafe extern "system" fn (this: *const nsIDOMDataTransfer, aEffectAllowedInt: 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 nsIDOMDataTransfer {

    /// ```text
    /// /**
    ///    * The actual effect that will be used, and should always be one of the
    ///    * possible values of effectAllowed.
    ///    *
    ///    * For dragstart, drag and dragleave events, the dropEffect is initialized
    ///    * to none. Any value assigned to the dropEffect will be set, but the value
    ///    * isn't used for anything.
    ///    *
    ///    * For the dragenter and dragover events, the dropEffect will be initialized
    ///    * based on what action the user is requesting. How this is determined is
    ///    * platform specific, but typically the user can press modifier keys to
    ///    * adjust which action is desired. Within an event handler for the dragenter
    ///    * and dragover events, the dropEffect should be modified if the action the
    ///    * user is requesting is not the one that is desired.
    ///    *
    ///    * For the drop and dragend events, the dropEffect will be initialized to
    ///    * the action that was desired, which will be the value that the dropEffect
    ///    * had after the last dragenter or dragover event.
    ///    *
    ///    * Possible values:
    ///    *  copy - a copy of the source item is made at the new location
    ///    *  move - an item is moved to a new location
    ///    *  link - a link is established to the source at the new location
    ///    *  none - the item may not be dropped
    ///    *
    ///    * Assigning any other value has no effect and retains the old value.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * The actual effect that will be used, and should always be one of the
    ///    * possible values of effectAllowed.
    ///    *
    ///    * For dragstart, drag and dragleave events, the dropEffect is initialized
    ///    * to none. Any value assigned to the dropEffect will be set, but the value
    ///    * isn't used for anything.
    ///    *
    ///    * For the dragenter and dragover events, the dropEffect will be initialized
    ///    * based on what action the user is requesting. How this is determined is
    ///    * platform specific, but typically the user can press modifier keys to
    ///    * adjust which action is desired. Within an event handler for the dragenter
    ///    * and dragover events, the dropEffect should be modified if the action the
    ///    * user is requesting is not the one that is desired.
    ///    *
    ///    * For the drop and dragend events, the dropEffect will be initialized to
    ///    * the action that was desired, which will be the value that the dropEffect
    ///    * had after the last dragenter or dragover event.
    ///    *
    ///    * Possible values:
    ///    *  copy - a copy of the source item is made at the new location
    ///    *  move - an item is moved to a new location
    ///    *  link - a link is established to the source at the new location
    ///    *  none - the item may not be dropped
    ///    *
    ///    * Assigning any other value has no effect and retains the old value.
    ///    */
    /// ```
    ///

    /// `attribute DOMString dropEffect;`
    #[inline]
    pub unsafe fn SetDropEffect(&self, aDropEffect: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetDropEffect)(self, aDropEffect)
    }



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



    /// `attribute DOMString effectAllowed;`
    #[inline]
    pub unsafe fn SetEffectAllowed(&self, aEffectAllowed: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetEffectAllowed)(self, aEffectAllowed)
    }


    /// ```text
    /// /**
    ///    * Holds a list of all the local files available on this data transfer.
    ///    * A dataTransfer containing no files will return an empty list, and an
    ///    * invalid index access on the resulting file list will return null.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIDOMFileList files;`
    #[inline]
    pub unsafe fn GetFiles(&self, aFiles: *mut *const nsIDOMFileList) -> nsresult {
        ((*self.vtable).GetFiles)(self, aFiles)
    }


    /// ```text
    /// /**
    ///    * Set the image to be used for dragging if a custom one is desired. Most of
    ///    * the time, this would not be set, as a default image is created from the
    ///    * node that was dragged.
    ///    *
    ///    * If the node is an HTML img element, an HTML canvas element or a XUL image
    ///    * element, the image data is used. Otherwise, image should be a visible
    ///    * node and the drag image will be created from this. If image is null, any
    ///    * custom drag image is cleared and the default is used instead.
    ///    *
    ///    * The coordinates specify the offset into the image where the mouse cursor
    ///    * should be. To center the image for instance, use values that are half the
    ///    * width and height.
    ///    *
    ///    * @param image a node to use
    ///    * @param x the horizontal offset
    ///    * @param y the vertical offset
    ///    * @throws NO_MODIFICATION_ALLOWED_ERR if the item cannot be modified
    ///    */
    /// ```
    ///

    /// `void setDragImage (in nsIDOMElement image, in long x, in long y);`
    #[inline]
    pub unsafe fn SetDragImage(&self, image: *const nsIDOMElement, x: libc::int32_t, y: libc::int32_t) -> nsresult {
        ((*self.vtable).SetDragImage)(self, image, x, y)
    }



    /// `void addElement (in nsIDOMElement element);`
    #[inline]
    pub unsafe fn AddElement(&self, element: *const nsIDOMElement) -> nsresult {
        ((*self.vtable).AddElement)(self, element)
    }


    /// ```text
    /// /**
    ///    * The number of items being dragged.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Sets the drag cursor state. Primarily used to control the cursor during
    ///    * tab drags, but could be expanded to other uses. XXX Currently implemented
    ///    * on Win32 only.
    ///    *
    ///    * Possible values:
    ///    *  auto - use default system behavior.
    ///    *  default - set the cursor to an arrow during the drag operation.
    ///    *
    ///    * Values other than 'default' are indentical to setting mozCursor to
    ///    * 'auto'.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Sets the drag cursor state. Primarily used to control the cursor during
    ///    * tab drags, but could be expanded to other uses. XXX Currently implemented
    ///    * on Win32 only.
    ///    *
    ///    * Possible values:
    ///    *  auto - use default system behavior.
    ///    *  default - set the cursor to an arrow during the drag operation.
    ///    *
    ///    * Values other than 'default' are indentical to setting mozCursor to
    ///    * 'auto'.
    ///    */
    /// ```
    ///

    /// `attribute DOMString mozCursor;`
    #[inline]
    pub unsafe fn SetMozCursor(&self, aMozCursor: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetMozCursor)(self, aMozCursor)
    }


    /// ```text
    /// /**
    ///    * Will be true when the user has cancelled the drag (typically by pressing
        ///    * Escape) and when the drag has been cancelled unexpectedly.  This will be
    ///    * false otherwise, including when the drop has been rejected by its target.
    ///    * This property is only relevant for the dragend event.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * The node that the mouse was pressed over to begin the drag. For external
    ///    * drags, or if the caller cannot access this node, this will be null.
    ///    */
    /// ```
    ///

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



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



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



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



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


}