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


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

    /// 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 nsIDOMHTMLMediaElement.
unsafe impl XpCom for nsIDOMHTMLMediaElement {
    const IID: nsIID = nsID(0xc041d76c, 0x15ce, 0x47ad,
        [0xb6, 0x1d, 0xe8, 0x75, 0x5a, 0x6d, 0xb6, 0x38]);
}

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

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

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

    /* attribute DOMString src; */
    pub GetSrc: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aSrc: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute DOMString src; */
    pub SetSrc: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aSrc: &::nsstring::nsAString) -> nsresult,

    /* readonly attribute DOMString currentSrc; */
    pub GetCurrentSrc: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aCurrentSrc: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute unsigned short networkState; */
    pub GetNetworkState: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aNetworkState: *mut libc::uint16_t) -> nsresult,

    /* attribute DOMString preload; */
    pub GetPreload: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aPreload: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute DOMString preload; */
    pub SetPreload: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aPreload: &::nsstring::nsAString) -> nsresult,

    /* readonly attribute nsIDOMTimeRanges buffered; */
    pub GetBuffered: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aBuffered: *mut *const nsIDOMTimeRanges) -> nsresult,

    /* void load (); */
    pub Load: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement) -> nsresult,

    /* DOMString canPlayType (in DOMString type); */
    pub CanPlayType: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, type_: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute unsigned short readyState; */
    pub GetReadyState: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aReadyState: *mut libc::uint16_t) -> nsresult,

    /* readonly attribute boolean seeking; */
    pub GetSeeking: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aSeeking: *mut bool) -> nsresult,

    /* attribute double currentTime; */
    pub GetCurrentTime: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aCurrentTime: *mut libc::c_double) -> nsresult,

    /* attribute double currentTime; */
    pub SetCurrentTime: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aCurrentTime: libc::c_double) -> nsresult,

    /* readonly attribute double duration; */
    pub GetDuration: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aDuration: *mut libc::c_double) -> nsresult,

    /* readonly attribute boolean paused; */
    pub GetPaused: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aPaused: *mut bool) -> nsresult,

    /* attribute double defaultPlaybackRate; */
    pub GetDefaultPlaybackRate: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aDefaultPlaybackRate: *mut libc::c_double) -> nsresult,

    /* attribute double defaultPlaybackRate; */
    pub SetDefaultPlaybackRate: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aDefaultPlaybackRate: libc::c_double) -> nsresult,

    /* attribute double playbackRate; */
    pub GetPlaybackRate: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aPlaybackRate: *mut libc::c_double) -> nsresult,

    /* attribute double playbackRate; */
    pub SetPlaybackRate: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aPlaybackRate: libc::c_double) -> nsresult,

    /* attribute boolean mozPreservesPitch; */
    pub GetMozPreservesPitch: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aMozPreservesPitch: *mut bool) -> nsresult,

    /* attribute boolean mozPreservesPitch; */
    pub SetMozPreservesPitch: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aMozPreservesPitch: bool) -> nsresult,

    /* readonly attribute nsIDOMTimeRanges played; */
    pub GetPlayed: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aPlayed: *mut *const nsIDOMTimeRanges) -> nsresult,

    /* readonly attribute nsIDOMTimeRanges seekable; */
    pub GetSeekable: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aSeekable: *mut *const nsIDOMTimeRanges) -> nsresult,

    /* readonly attribute boolean ended; */
    pub GetEnded: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aEnded: *mut bool) -> nsresult,

    /* attribute boolean autoplay; */
    pub GetAutoplay: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aAutoplay: *mut bool) -> nsresult,

    /* attribute boolean autoplay; */
    pub SetAutoplay: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aAutoplay: bool) -> nsresult,

    /* attribute boolean loop; */
    pub GetLoop: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aLoop: *mut bool) -> nsresult,

    /* attribute boolean loop; */
    pub SetLoop: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aLoop: bool) -> nsresult,

    /* void pause (); */
    pub Pause: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement) -> nsresult,

    /* attribute boolean controls; */
    pub GetControls: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aControls: *mut bool) -> nsresult,

    /* attribute boolean controls; */
    pub SetControls: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aControls: bool) -> nsresult,

    /* attribute double volume; */
    pub GetVolume: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aVolume: *mut libc::c_double) -> nsresult,

    /* attribute double volume; */
    pub SetVolume: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aVolume: libc::c_double) -> nsresult,

    /* attribute boolean muted; */
    pub GetMuted: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aMuted: *mut bool) -> nsresult,

    /* attribute boolean muted; */
    pub SetMuted: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aMuted: bool) -> nsresult,

    /* attribute boolean defaultMuted; */
    pub GetDefaultMuted: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aDefaultMuted: *mut bool) -> nsresult,

    /* attribute boolean defaultMuted; */
    pub SetDefaultMuted: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aDefaultMuted: bool) -> nsresult,

    /* readonly attribute boolean mozAudioCaptured; */
    pub GetMozAudioCaptured: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aMozAudioCaptured: *mut bool) -> nsresult,

    /* [implicit_jscontext] jsval mozGetMetadata (); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub MozGetMetadata: *const ::libc::c_void,

    /* readonly attribute double mozFragmentEnd; */
    pub GetMozFragmentEnd: unsafe extern "system" fn (this: *const nsIDOMHTMLMediaElement, aMozFragmentEnd: *mut libc::c_double) -> nsresult,

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

    /* [noscript,notxpcom] void onVisibilityChange (in Visibility aNewVisibility); */
    /// Unable to generate binding because `native type mozilla::Visibility is unsupported`
    pub OnVisibilityChange: *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 nsIDOMHTMLMediaElement {

    pub const NETWORK_EMPTY: i64 = 0;


    pub const NETWORK_IDLE: i64 = 1;


    pub const NETWORK_LOADING: i64 = 2;


    pub const NETWORK_NO_SOURCE: i64 = 3;


    pub const HAVE_NOTHING: i64 = 0;


    pub const HAVE_METADATA: i64 = 1;


    pub const HAVE_CURRENT_DATA: i64 = 2;


    pub const HAVE_FUTURE_DATA: i64 = 3;


    pub const HAVE_ENOUGH_DATA: i64 = 4;


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



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



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



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



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



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



    /// `readonly attribute nsIDOMTimeRanges buffered;`
    #[inline]
    pub unsafe fn GetBuffered(&self, aBuffered: *mut *const nsIDOMTimeRanges) -> nsresult {
        ((*self.vtable).GetBuffered)(self, aBuffered)
    }



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



    /// `DOMString canPlayType (in DOMString type);`
    #[inline]
    pub unsafe fn CanPlayType(&self, type_: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).CanPlayType)(self, type_, _retval)
    }



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



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



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



    /// `attribute double currentTime;`
    #[inline]
    pub unsafe fn SetCurrentTime(&self, aCurrentTime: libc::c_double) -> nsresult {
        ((*self.vtable).SetCurrentTime)(self, aCurrentTime)
    }



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



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



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



    /// `attribute double defaultPlaybackRate;`
    #[inline]
    pub unsafe fn SetDefaultPlaybackRate(&self, aDefaultPlaybackRate: libc::c_double) -> nsresult {
        ((*self.vtable).SetDefaultPlaybackRate)(self, aDefaultPlaybackRate)
    }



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



    /// `attribute double playbackRate;`
    #[inline]
    pub unsafe fn SetPlaybackRate(&self, aPlaybackRate: libc::c_double) -> nsresult {
        ((*self.vtable).SetPlaybackRate)(self, aPlaybackRate)
    }



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



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



    /// `readonly attribute nsIDOMTimeRanges played;`
    #[inline]
    pub unsafe fn GetPlayed(&self, aPlayed: *mut *const nsIDOMTimeRanges) -> nsresult {
        ((*self.vtable).GetPlayed)(self, aPlayed)
    }



    /// `readonly attribute nsIDOMTimeRanges seekable;`
    #[inline]
    pub unsafe fn GetSeekable(&self, aSeekable: *mut *const nsIDOMTimeRanges) -> nsresult {
        ((*self.vtable).GetSeekable)(self, aSeekable)
    }



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



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



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



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



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



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



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



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



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



    /// `attribute double volume;`
    #[inline]
    pub unsafe fn SetVolume(&self, aVolume: libc::c_double) -> nsresult {
        ((*self.vtable).SetVolume)(self, aVolume)
    }



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



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



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



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



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



    /// `[implicit_jscontext] jsval mozGetMetadata ();`
    const _MozGetMetadata: () = ();


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



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


    /// ```text
    /// /**
    ///    * Called by layout to announce when the frame associated with this content
    ///    * has changed its visibility state.
    ///    *
    ///    * @param aOldVisibility    The previous visibility state.
    ///    * @param aNewVisibility    The new visibility state.
    ///    */
    /// ```
    ///

    /// `[noscript,notxpcom] void onVisibilityChange (in Visibility aNewVisibility);`
    const _OnVisibilityChange: () = ();

}