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


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

    /// 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 inIDOMUtils.
unsafe impl XpCom for inIDOMUtils {
    const IID: nsIID = nsID(0x362e98c3, 0x82c2, 0x4ad8,
        [0x8d, 0xcb, 0x00, 0xe8, 0xe4, 0xea, 0xb4, 0x97]);
}

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

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

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

    /* void getAllStyleSheets (in nsIDOMDocument aDoc, [optional] out unsigned long aLength, [array, size_is (aLength), retval] out nsISupports aSheets); */
    pub GetAllStyleSheets: unsafe extern "system" fn (this: *const inIDOMUtils, aDoc: *const nsIDOMDocument, aLength: *mut libc::uint32_t, aSheets: *mut *mut *const nsISupports) -> nsresult,

    /* nsIArrayExtensions getCSSStyleRules (in nsIDOMElement aElement, [optional] in DOMString aPseudo); */
    pub GetCSSStyleRules: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement, aPseudo: &::nsstring::nsAString, _retval: *mut *const nsIArrayExtensions) -> nsresult,

    /* unsigned long getRuleLine (in nsIDOMCSSRule aRule); */
    pub GetRuleLine: unsafe extern "system" fn (this: *const inIDOMUtils, aRule: *const nsIDOMCSSRule, _retval: *mut libc::uint32_t) -> nsresult,

    /* unsigned long getRuleColumn (in nsIDOMCSSRule aRule); */
    pub GetRuleColumn: unsafe extern "system" fn (this: *const inIDOMUtils, aRule: *const nsIDOMCSSRule, _retval: *mut libc::uint32_t) -> nsresult,

    /* unsigned long getRelativeRuleLine (in nsIDOMCSSRule aRule); */
    pub GetRelativeRuleLine: unsafe extern "system" fn (this: *const inIDOMUtils, aRule: *const nsIDOMCSSRule, _retval: *mut libc::uint32_t) -> nsresult,

    /* [implicit_jscontext] jsval getCSSLexer (in DOMString aText); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub GetCSSLexer: *const ::libc::c_void,

    /* unsigned long getSelectorCount (in nsIDOMCSSStyleRule aRule); */
    pub GetSelectorCount: unsafe extern "system" fn (this: *const inIDOMUtils, aRule: *const nsIDOMCSSStyleRule, _retval: *mut libc::uint32_t) -> nsresult,

    /* AString getSelectorText (in nsIDOMCSSStyleRule aRule, in unsigned long aSelectorIndex); */
    pub GetSelectorText: unsafe extern "system" fn (this: *const inIDOMUtils, aRule: *const nsIDOMCSSStyleRule, aSelectorIndex: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* unsigned long long getSpecificity (in nsIDOMCSSStyleRule aRule, in unsigned long aSelectorIndex); */
    pub GetSpecificity: unsafe extern "system" fn (this: *const inIDOMUtils, aRule: *const nsIDOMCSSStyleRule, aSelectorIndex: libc::uint32_t, _retval: *mut libc::uint64_t) -> nsresult,

    /* bool selectorMatchesElement (in nsIDOMElement aElement, in nsIDOMCSSStyleRule aRule, in unsigned long aSelectorIndex, [optional] in DOMString aPseudo); */
    pub SelectorMatchesElement: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement, aRule: *const nsIDOMCSSStyleRule, aSelectorIndex: libc::uint32_t, aPseudo: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* bool isInheritedProperty (in AString aPropertyName); */
    pub IsInheritedProperty: unsafe extern "system" fn (this: *const inIDOMUtils, aPropertyName: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* void getCSSPropertyNames ([optional] in unsigned long aFlags, [optional] out unsigned long aCount, [array, size_is (aCount), retval] out wstring aProps); */
    pub GetCSSPropertyNames: unsafe extern "system" fn (this: *const inIDOMUtils, aFlags: libc::uint32_t, aCount: *mut libc::uint32_t, aProps: *mut *mut *const libc::int16_t) -> nsresult,

    /* void getCSSValuesForProperty (in AString aProperty, [optional] out unsigned long aLength, [array, size_is (aLength), retval] out wstring aValues); */
    pub GetCSSValuesForProperty: unsafe extern "system" fn (this: *const inIDOMUtils, aProperty: &::nsstring::nsAString, aLength: *mut libc::uint32_t, aValues: *mut *mut *const libc::int16_t) -> nsresult,

    /* [implicit_jscontext] jsval colorNameToRGB (in DOMString aColorName); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub ColorNameToRGB: *const ::libc::c_void,

    /* AString rgbToColorName (in octet aR, in octet aG, in octet aB); */
    pub RgbToColorName: unsafe extern "system" fn (this: *const inIDOMUtils, aR: libc::uint8_t, aG: libc::uint8_t, aB: libc::uint8_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* [implicit_jscontext] jsval colorToRGBA (in DOMString aColorString); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub ColorToRGBA: *const ::libc::c_void,

    /* bool isValidCSSColor (in AString aColorString); */
    pub IsValidCSSColor: unsafe extern "system" fn (this: *const inIDOMUtils, aColorString: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* void getSubpropertiesForCSSProperty (in AString aProperty, [optional] out unsigned long aLength, [array, size_is (aLength), retval] out wstring aValues); */
    pub GetSubpropertiesForCSSProperty: unsafe extern "system" fn (this: *const inIDOMUtils, aProperty: &::nsstring::nsAString, aLength: *mut libc::uint32_t, aValues: *mut *mut *const libc::int16_t) -> nsresult,

    /* bool cssPropertyIsShorthand (in AString aProperty); */
    pub CssPropertyIsShorthand: unsafe extern "system" fn (this: *const inIDOMUtils, aProperty: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* bool cssPropertySupportsType (in AString aProperty, in unsigned long type); */
    pub CssPropertySupportsType: unsafe extern "system" fn (this: *const inIDOMUtils, aProperty: &::nsstring::nsAString, type_: libc::uint32_t, _retval: *mut bool) -> nsresult,

    /* boolean isIgnorableWhitespace (in nsIDOMCharacterData aDataNode); */
    pub IsIgnorableWhitespace: unsafe extern "system" fn (this: *const inIDOMUtils, aDataNode: *const nsIDOMCharacterData, _retval: *mut bool) -> nsresult,

    /* nsIDOMNode getParentForNode (in nsIDOMNode aNode, in boolean aShowingAnonymousContent); */
    pub GetParentForNode: unsafe extern "system" fn (this: *const inIDOMUtils, aNode: *const nsIDOMNode, aShowingAnonymousContent: bool, _retval: *mut *const nsIDOMNode) -> nsresult,

    /* nsIDOMNodeList getChildrenForNode (in nsIDOMNode aNode, in boolean aShowingAnonymousContent); */
    pub GetChildrenForNode: unsafe extern "system" fn (this: *const inIDOMUtils, aNode: *const nsIDOMNode, aShowingAnonymousContent: bool, _retval: *mut *const nsIDOMNodeList) -> nsresult,

    /* nsIArray getBindingURLs (in nsIDOMElement aElement); */
    pub GetBindingURLs: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement, _retval: *mut *const nsIArray) -> nsresult,

    /* unsigned long long getContentState (in nsIDOMElement aElement); */
    pub GetContentState: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement, _retval: *mut libc::uint64_t) -> nsresult,

    /* bool setContentState (in nsIDOMElement aElement, in unsigned long long aState); */
    pub SetContentState: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement, aState: libc::uint64_t, _retval: *mut bool) -> nsresult,

    /* bool removeContentState (in nsIDOMElement aElement, in unsigned long long aState, [optional] in bool aClearActiveDocument); */
    pub RemoveContentState: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement, aState: libc::uint64_t, aClearActiveDocument: bool, _retval: *mut bool) -> nsresult,

    /* nsIDOMFontFaceList getUsedFontFaces (in nsIDOMRange aRange); */
    pub GetUsedFontFaces: unsafe extern "system" fn (this: *const inIDOMUtils, aRange: *const nsIDOMRange, _retval: *mut *const nsIDOMFontFaceList) -> nsresult,

    /* void getCSSPseudoElementNames ([optional] out unsigned long aCount, [array, size_is (aCount), retval] out wstring aNames); */
    pub GetCSSPseudoElementNames: unsafe extern "system" fn (this: *const inIDOMUtils, aCount: *mut libc::uint32_t, aNames: *mut *mut *const libc::int16_t) -> nsresult,

    /* [optional_argc] void addPseudoClassLock (in nsIDOMElement aElement, in DOMString aPseudoClass, [optional] in boolean aEnabled); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub AddPseudoClassLock: *const ::libc::c_void,

    /* void removePseudoClassLock (in nsIDOMElement aElement, in DOMString aPseudoClass); */
    pub RemovePseudoClassLock: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement, aPseudoClass: &::nsstring::nsAString) -> nsresult,

    /* bool hasPseudoClassLock (in nsIDOMElement aElement, in DOMString aPseudoClass); */
    pub HasPseudoClassLock: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement, aPseudoClass: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* void clearPseudoClassLocks (in nsIDOMElement aElement); */
    pub ClearPseudoClassLocks: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement) -> nsresult,

    /* void parseStyleSheet (in nsIDOMCSSStyleSheet aSheet, in DOMString aInput); */
    pub ParseStyleSheet: unsafe extern "system" fn (this: *const inIDOMUtils, aSheet: *const nsIDOMCSSStyleSheet, aInput: &::nsstring::nsAString) -> nsresult,

    /* void scrollElementIntoView (in nsIDOMElement aElement); */
    pub ScrollElementIntoView: unsafe extern "system" fn (this: *const inIDOMUtils, aElement: *const nsIDOMElement) -> 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 inIDOMUtils {

    pub const EXCLUDE_SHORTHANDS: i64 = 1;


    pub const INCLUDE_ALIASES: i64 = 2;


    pub const TYPE_LENGTH: i64 = 0;


    pub const TYPE_PERCENTAGE: i64 = 1;


    pub const TYPE_COLOR: i64 = 2;


    pub const TYPE_URL: i64 = 3;


    pub const TYPE_ANGLE: i64 = 4;


    pub const TYPE_FREQUENCY: i64 = 5;


    pub const TYPE_TIME: i64 = 6;


    pub const TYPE_GRADIENT: i64 = 7;


    pub const TYPE_TIMING_FUNCTION: i64 = 8;


    pub const TYPE_IMAGE_RECT: i64 = 9;


    pub const TYPE_NUMBER: i64 = 10;


    /// `void getAllStyleSheets (in nsIDOMDocument aDoc, [optional] out unsigned long aLength, [array, size_is (aLength), retval] out nsISupports aSheets);`
    #[inline]
    pub unsafe fn GetAllStyleSheets(&self, aDoc: *const nsIDOMDocument, aLength: *mut libc::uint32_t, aSheets: *mut *mut *const nsISupports) -> nsresult {
        ((*self.vtable).GetAllStyleSheets)(self, aDoc, aLength, aSheets)
    }



    /// `nsIArrayExtensions getCSSStyleRules (in nsIDOMElement aElement, [optional] in DOMString aPseudo);`
    #[inline]
    pub unsafe fn GetCSSStyleRules(&self, aElement: *const nsIDOMElement, aPseudo: &::nsstring::nsAString, _retval: *mut *const nsIArrayExtensions) -> nsresult {
        ((*self.vtable).GetCSSStyleRules)(self, aElement, aPseudo, _retval)
    }


    /// ```text
    /// /**
    ///    * Get the line number of a rule.
    ///    *
    ///    * @param nsIDOMCSSRule aRule The rule.
    ///    * @return The rule's line number.  Line numbers are 1-based.
    ///    */
    /// ```
    ///

    /// `unsigned long getRuleLine (in nsIDOMCSSRule aRule);`
    #[inline]
    pub unsafe fn GetRuleLine(&self, aRule: *const nsIDOMCSSRule, _retval: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetRuleLine)(self, aRule, _retval)
    }


    /// ```text
    /// /**
    ///    * Get the column number of a rule.
    ///    *
    ///    * @param nsIDOMCSSRule aRule The rule.
    ///    * @return The rule's column number.  Column numbers are 1-based.
    ///    */
    /// ```
    ///

    /// `unsigned long getRuleColumn (in nsIDOMCSSRule aRule);`
    #[inline]
    pub unsafe fn GetRuleColumn(&self, aRule: *const nsIDOMCSSRule, _retval: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetRuleColumn)(self, aRule, _retval)
    }


    /// ```text
    /// /**
    ///    * Like getRuleLine, but if the rule is in a <style> element,
    ///    * returns a line number relative to the start of the element.
    ///    *
    ///    * @param nsIDOMCSSRule aRule the rule to examine
    ///    * @return the line number of the rule, possibly relative to the
    ///    *         <style> element
    ///    */
    /// ```
    ///

    /// `unsigned long getRelativeRuleLine (in nsIDOMCSSRule aRule);`
    #[inline]
    pub unsafe fn GetRelativeRuleLine(&self, aRule: *const nsIDOMCSSRule, _retval: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetRelativeRuleLine)(self, aRule, _retval)
    }



    /// `[implicit_jscontext] jsval getCSSLexer (in DOMString aText);`
    const _GetCSSLexer: () = ();


    /// `unsigned long getSelectorCount (in nsIDOMCSSStyleRule aRule);`
    #[inline]
    pub unsafe fn GetSelectorCount(&self, aRule: *const nsIDOMCSSStyleRule, _retval: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetSelectorCount)(self, aRule, _retval)
    }



    /// `AString getSelectorText (in nsIDOMCSSStyleRule aRule, in unsigned long aSelectorIndex);`
    #[inline]
    pub unsafe fn GetSelectorText(&self, aRule: *const nsIDOMCSSStyleRule, aSelectorIndex: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetSelectorText)(self, aRule, aSelectorIndex, _retval)
    }



    /// `unsigned long long getSpecificity (in nsIDOMCSSStyleRule aRule, in unsigned long aSelectorIndex);`
    #[inline]
    pub unsafe fn GetSpecificity(&self, aRule: *const nsIDOMCSSStyleRule, aSelectorIndex: libc::uint32_t, _retval: *mut libc::uint64_t) -> nsresult {
        ((*self.vtable).GetSpecificity)(self, aRule, aSelectorIndex, _retval)
    }



    /// `bool selectorMatchesElement (in nsIDOMElement aElement, in nsIDOMCSSStyleRule aRule, in unsigned long aSelectorIndex, [optional] in DOMString aPseudo);`
    #[inline]
    pub unsafe fn SelectorMatchesElement(&self, aElement: *const nsIDOMElement, aRule: *const nsIDOMCSSStyleRule, aSelectorIndex: libc::uint32_t, aPseudo: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).SelectorMatchesElement)(self, aElement, aRule, aSelectorIndex, aPseudo, _retval)
    }



    /// `bool isInheritedProperty (in AString aPropertyName);`
    #[inline]
    pub unsafe fn IsInheritedProperty(&self, aPropertyName: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsInheritedProperty)(self, aPropertyName, _retval)
    }



    /// `void getCSSPropertyNames ([optional] in unsigned long aFlags, [optional] out unsigned long aCount, [array, size_is (aCount), retval] out wstring aProps);`
    #[inline]
    pub unsafe fn GetCSSPropertyNames(&self, aFlags: libc::uint32_t, aCount: *mut libc::uint32_t, aProps: *mut *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).GetCSSPropertyNames)(self, aFlags, aCount, aProps)
    }



    /// `void getCSSValuesForProperty (in AString aProperty, [optional] out unsigned long aLength, [array, size_is (aLength), retval] out wstring aValues);`
    #[inline]
    pub unsafe fn GetCSSValuesForProperty(&self, aProperty: &::nsstring::nsAString, aLength: *mut libc::uint32_t, aValues: *mut *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).GetCSSValuesForProperty)(self, aProperty, aLength, aValues)
    }



    /// `[implicit_jscontext] jsval colorNameToRGB (in DOMString aColorName);`
    const _ColorNameToRGB: () = ();


    /// `AString rgbToColorName (in octet aR, in octet aG, in octet aB);`
    #[inline]
    pub unsafe fn RgbToColorName(&self, aR: libc::uint8_t, aG: libc::uint8_t, aB: libc::uint8_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).RgbToColorName)(self, aR, aG, aB, _retval)
    }



    /// `[implicit_jscontext] jsval colorToRGBA (in DOMString aColorString);`
    const _ColorToRGBA: () = ();


    /// `bool isValidCSSColor (in AString aColorString);`
    #[inline]
    pub unsafe fn IsValidCSSColor(&self, aColorString: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsValidCSSColor)(self, aColorString, _retval)
    }



    /// `void getSubpropertiesForCSSProperty (in AString aProperty, [optional] out unsigned long aLength, [array, size_is (aLength), retval] out wstring aValues);`
    #[inline]
    pub unsafe fn GetSubpropertiesForCSSProperty(&self, aProperty: &::nsstring::nsAString, aLength: *mut libc::uint32_t, aValues: *mut *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).GetSubpropertiesForCSSProperty)(self, aProperty, aLength, aValues)
    }



    /// `bool cssPropertyIsShorthand (in AString aProperty);`
    #[inline]
    pub unsafe fn CssPropertyIsShorthand(&self, aProperty: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).CssPropertyIsShorthand)(self, aProperty, _retval)
    }



    /// `bool cssPropertySupportsType (in AString aProperty, in unsigned long type);`
    #[inline]
    pub unsafe fn CssPropertySupportsType(&self, aProperty: &::nsstring::nsAString, type_: libc::uint32_t, _retval: *mut bool) -> nsresult {
        ((*self.vtable).CssPropertySupportsType)(self, aProperty, type_, _retval)
    }



    /// `boolean isIgnorableWhitespace (in nsIDOMCharacterData aDataNode);`
    #[inline]
    pub unsafe fn IsIgnorableWhitespace(&self, aDataNode: *const nsIDOMCharacterData, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsIgnorableWhitespace)(self, aDataNode, _retval)
    }



    /// `nsIDOMNode getParentForNode (in nsIDOMNode aNode, in boolean aShowingAnonymousContent);`
    #[inline]
    pub unsafe fn GetParentForNode(&self, aNode: *const nsIDOMNode, aShowingAnonymousContent: bool, _retval: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).GetParentForNode)(self, aNode, aShowingAnonymousContent, _retval)
    }



    /// `nsIDOMNodeList getChildrenForNode (in nsIDOMNode aNode, in boolean aShowingAnonymousContent);`
    #[inline]
    pub unsafe fn GetChildrenForNode(&self, aNode: *const nsIDOMNode, aShowingAnonymousContent: bool, _retval: *mut *const nsIDOMNodeList) -> nsresult {
        ((*self.vtable).GetChildrenForNode)(self, aNode, aShowingAnonymousContent, _retval)
    }



    /// `nsIArray getBindingURLs (in nsIDOMElement aElement);`
    #[inline]
    pub unsafe fn GetBindingURLs(&self, aElement: *const nsIDOMElement, _retval: *mut *const nsIArray) -> nsresult {
        ((*self.vtable).GetBindingURLs)(self, aElement, _retval)
    }



    /// `unsigned long long getContentState (in nsIDOMElement aElement);`
    #[inline]
    pub unsafe fn GetContentState(&self, aElement: *const nsIDOMElement, _retval: *mut libc::uint64_t) -> nsresult {
        ((*self.vtable).GetContentState)(self, aElement, _retval)
    }


    /// ```text
    /// /**
    ///    * Setting and removing content state on an element. Both these functions
    ///    * calling EventStateManager::SetContentState internally, the difference is
    ///    * that for the remove case we simply pass in nullptr for the element.
    ///    * Use them accordingly.
    ///    *
    ///    * When removing the active state, you may optionally also clear the active
    ///    * document as well by setting aClearActiveDocument
    ///    *
    ///    * @return Returns true if the state was set successfully. See more details
    ///    * in EventStateManager.h SetContentState.
    ///    */
    /// ```
    ///

    /// `bool setContentState (in nsIDOMElement aElement, in unsigned long long aState);`
    #[inline]
    pub unsafe fn SetContentState(&self, aElement: *const nsIDOMElement, aState: libc::uint64_t, _retval: *mut bool) -> nsresult {
        ((*self.vtable).SetContentState)(self, aElement, aState, _retval)
    }



    /// `bool removeContentState (in nsIDOMElement aElement, in unsigned long long aState, [optional] in bool aClearActiveDocument);`
    #[inline]
    pub unsafe fn RemoveContentState(&self, aElement: *const nsIDOMElement, aState: libc::uint64_t, aClearActiveDocument: bool, _retval: *mut bool) -> nsresult {
        ((*self.vtable).RemoveContentState)(self, aElement, aState, aClearActiveDocument, _retval)
    }



    /// `nsIDOMFontFaceList getUsedFontFaces (in nsIDOMRange aRange);`
    #[inline]
    pub unsafe fn GetUsedFontFaces(&self, aRange: *const nsIDOMRange, _retval: *mut *const nsIDOMFontFaceList) -> nsresult {
        ((*self.vtable).GetUsedFontFaces)(self, aRange, _retval)
    }


    /// ```text
    /// /**
    ///    * Get the names of all the supported pseudo-elements.
    ///    * Pseudo-elements which are only accepted in UA style sheets are
    ///    * not included.
    ///    *
    ///    * @param {unsigned long} aCount the number of items returned
    ///    * @param {wstring[]} aNames the names
    ///    */
    /// ```
    ///

    /// `void getCSSPseudoElementNames ([optional] out unsigned long aCount, [array, size_is (aCount), retval] out wstring aNames);`
    #[inline]
    pub unsafe fn GetCSSPseudoElementNames(&self, aCount: *mut libc::uint32_t, aNames: *mut *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).GetCSSPseudoElementNames)(self, aCount, aNames)
    }



    /// `[optional_argc] void addPseudoClassLock (in nsIDOMElement aElement, in DOMString aPseudoClass, [optional] in boolean aEnabled);`
    const _AddPseudoClassLock: () = ();


    /// `void removePseudoClassLock (in nsIDOMElement aElement, in DOMString aPseudoClass);`
    #[inline]
    pub unsafe fn RemovePseudoClassLock(&self, aElement: *const nsIDOMElement, aPseudoClass: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).RemovePseudoClassLock)(self, aElement, aPseudoClass)
    }



    /// `bool hasPseudoClassLock (in nsIDOMElement aElement, in DOMString aPseudoClass);`
    #[inline]
    pub unsafe fn HasPseudoClassLock(&self, aElement: *const nsIDOMElement, aPseudoClass: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).HasPseudoClassLock)(self, aElement, aPseudoClass, _retval)
    }



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


    /// ```text
    /// /**
    ///    * Parse CSS and update the style sheet in place.
    ///    *
    ///    * @param DOMCSSStyleSheet aSheet
    ///    * @param DOMString aInput
    ///    *        The new source string for the style sheet.
    ///    */
    /// ```
    ///

    /// `void parseStyleSheet (in nsIDOMCSSStyleSheet aSheet, in DOMString aInput);`
    #[inline]
    pub unsafe fn ParseStyleSheet(&self, aSheet: *const nsIDOMCSSStyleSheet, aInput: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).ParseStyleSheet)(self, aSheet, aInput)
    }


    /// ```text
    /// /**
    ///    * Scroll an element completely into view, if possible.
    ///    * This is similar to ensureElementIsVisible but for all ancestors.
    ///    *
    ///    * @param DOMElement aElement
    ///    */
    /// ```
    ///

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


}