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


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

    /// 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 nsIHTMLEditor.
unsafe impl XpCom for nsIHTMLEditor {
    const IID: nsIID = nsID(0x87ee993e, 0x985f, 0x4a43,
        [0xa9, 0x74, 0x0d, 0x95, 0x12, 0xda, 0x2f, 0xb0]);
}

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

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

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

    /* void setInlineProperty (in AString aProperty, in AString aAttribute, in AString aValue); */
    pub SetInlineProperty: unsafe extern "system" fn (this: *const nsIHTMLEditor, aProperty: &::nsstring::nsAString, aAttribute: &::nsstring::nsAString, aValue: &::nsstring::nsAString) -> nsresult,

    /* void getInlineProperty (in AString aProperty, in AString aAttribute, in AString aValue, out boolean aFirst, out boolean aAny, out boolean aAll); */
    pub GetInlineProperty: unsafe extern "system" fn (this: *const nsIHTMLEditor, aProperty: &::nsstring::nsAString, aAttribute: &::nsstring::nsAString, aValue: &::nsstring::nsAString, aFirst: *mut bool, aAny: *mut bool, aAll: *mut bool) -> nsresult,

    /* AString getInlinePropertyWithAttrValue (in AString aProperty, in AString aAttribute, in AString aValue, out boolean aFirst, out boolean aAny, out boolean aAll); */
    pub GetInlinePropertyWithAttrValue: unsafe extern "system" fn (this: *const nsIHTMLEditor, aProperty: &::nsstring::nsAString, aAttribute: &::nsstring::nsAString, aValue: &::nsstring::nsAString, aFirst: *mut bool, aAny: *mut bool, aAll: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void removeAllInlineProperties (); */
    pub RemoveAllInlineProperties: unsafe extern "system" fn (this: *const nsIHTMLEditor) -> nsresult,

    /* void removeInlineProperty (in AString aProperty, in AString aAttribute); */
    pub RemoveInlineProperty: unsafe extern "system" fn (this: *const nsIHTMLEditor, aProperty: &::nsstring::nsAString, aAttribute: &::nsstring::nsAString) -> nsresult,

    /* void increaseFontSize (); */
    pub IncreaseFontSize: unsafe extern "system" fn (this: *const nsIHTMLEditor) -> nsresult,

    /* void decreaseFontSize (); */
    pub DecreaseFontSize: unsafe extern "system" fn (this: *const nsIHTMLEditor) -> nsresult,

    /* boolean nodeIsBlock (in nsIDOMNode node); */
    pub NodeIsBlock: unsafe extern "system" fn (this: *const nsIHTMLEditor, node: *const nsIDOMNode, _retval: *mut bool) -> nsresult,

    /* void insertHTML (in AString aInputString); */
    pub InsertHTML: unsafe extern "system" fn (this: *const nsIHTMLEditor, aInputString: &::nsstring::nsAString) -> nsresult,

    /* void pasteNoFormatting (in long aSelectionType); */
    pub PasteNoFormatting: unsafe extern "system" fn (this: *const nsIHTMLEditor, aSelectionType: libc::int32_t) -> nsresult,

    /* void rebuildDocumentFromSource (in AString aSourceString); */
    pub RebuildDocumentFromSource: unsafe extern "system" fn (this: *const nsIHTMLEditor, aSourceString: &::nsstring::nsAString) -> nsresult,

    /* void insertHTMLWithContext (in AString aInputString, in AString aContextStr, in AString aInfoStr, in AString aFlavor, in nsIDOMDocument aSourceDoc, in nsIDOMNode aDestinationNode, in long aDestinationOffset, in boolean aDeleteSelection); */
    pub InsertHTMLWithContext: unsafe extern "system" fn (this: *const nsIHTMLEditor, aInputString: &::nsstring::nsAString, aContextStr: &::nsstring::nsAString, aInfoStr: &::nsstring::nsAString, aFlavor: &::nsstring::nsAString, aSourceDoc: *const nsIDOMDocument, aDestinationNode: *const nsIDOMNode, aDestinationOffset: libc::int32_t, aDeleteSelection: bool) -> nsresult,

    /* void insertElementAtSelection (in nsIDOMElement aElement, in boolean aDeleteSelection); */
    pub InsertElementAtSelection: unsafe extern "system" fn (this: *const nsIHTMLEditor, aElement: *const nsIDOMElement, aDeleteSelection: bool) -> nsresult,

    /* void updateBaseURL (); */
    pub UpdateBaseURL: unsafe extern "system" fn (this: *const nsIHTMLEditor) -> nsresult,

    /* void selectElement (in nsIDOMElement aElement); */
    pub SelectElement: unsafe extern "system" fn (this: *const nsIHTMLEditor, aElement: *const nsIDOMElement) -> nsresult,

    /* void setCaretAfterElement (in nsIDOMElement aElement); */
    pub SetCaretAfterElement: unsafe extern "system" fn (this: *const nsIHTMLEditor, aElement: *const nsIDOMElement) -> nsresult,

    /* void setParagraphFormat (in AString aParagraphFormat); */
    pub SetParagraphFormat: unsafe extern "system" fn (this: *const nsIHTMLEditor, aParagraphFormat: &::nsstring::nsAString) -> nsresult,

    /* AString getParagraphState (out boolean aMixed); */
    pub GetParagraphState: unsafe extern "system" fn (this: *const nsIHTMLEditor, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* AString getFontFaceState (out boolean aMixed); */
    pub GetFontFaceState: unsafe extern "system" fn (this: *const nsIHTMLEditor, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* AString getFontColorState (out boolean aMixed); */
    pub GetFontColorState: unsafe extern "system" fn (this: *const nsIHTMLEditor, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* AString getBackgroundColorState (out boolean aMixed); */
    pub GetBackgroundColorState: unsafe extern "system" fn (this: *const nsIHTMLEditor, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* AString getHighlightColorState (out boolean aMixed); */
    pub GetHighlightColorState: unsafe extern "system" fn (this: *const nsIHTMLEditor, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void getListState (out boolean aMixed, out boolean aOL, out boolean aUL, out boolean aDL); */
    pub GetListState: unsafe extern "system" fn (this: *const nsIHTMLEditor, aMixed: *mut bool, aOL: *mut bool, aUL: *mut bool, aDL: *mut bool) -> nsresult,

    /* void getListItemState (out boolean aMixed, out boolean aLI, out boolean aDT, out boolean aDD); */
    pub GetListItemState: unsafe extern "system" fn (this: *const nsIHTMLEditor, aMixed: *mut bool, aLI: *mut bool, aDT: *mut bool, aDD: *mut bool) -> nsresult,

    /* void getAlignment (out boolean aMixed, out short aAlign); */
    pub GetAlignment: unsafe extern "system" fn (this: *const nsIHTMLEditor, aMixed: *mut bool, aAlign: *mut libc::int16_t) -> nsresult,

    /* void getIndentState (out boolean aCanIndent, out boolean aCanOutdent); */
    pub GetIndentState: unsafe extern "system" fn (this: *const nsIHTMLEditor, aCanIndent: *mut bool, aCanOutdent: *mut bool) -> nsresult,

    /* void makeOrChangeList (in AString aListType, in boolean entireList, in AString aBulletType); */
    pub MakeOrChangeList: unsafe extern "system" fn (this: *const nsIHTMLEditor, aListType: &::nsstring::nsAString, entireList: bool, aBulletType: &::nsstring::nsAString) -> nsresult,

    /* void removeList (in AString aListType); */
    pub RemoveList: unsafe extern "system" fn (this: *const nsIHTMLEditor, aListType: &::nsstring::nsAString) -> nsresult,

    /* void indent (in AString aIndent); */
    pub Indent: unsafe extern "system" fn (this: *const nsIHTMLEditor, aIndent: &::nsstring::nsAString) -> nsresult,

    /* void align (in AString aAlign); */
    pub Align: unsafe extern "system" fn (this: *const nsIHTMLEditor, aAlign: &::nsstring::nsAString) -> nsresult,

    /* nsIDOMElement getElementOrParentByTagName (in AString aTagName, in nsIDOMNode aNode); */
    pub GetElementOrParentByTagName: unsafe extern "system" fn (this: *const nsIHTMLEditor, aTagName: &::nsstring::nsAString, aNode: *const nsIDOMNode, _retval: *mut *const nsIDOMElement) -> nsresult,

    /* nsIDOMElement getSelectedElement (in AString aTagName); */
    pub GetSelectedElement: unsafe extern "system" fn (this: *const nsIHTMLEditor, aTagName: &::nsstring::nsAString, _retval: *mut *const nsIDOMElement) -> nsresult,

    /* AString getHeadContentsAsHTML (); */
    pub GetHeadContentsAsHTML: unsafe extern "system" fn (this: *const nsIHTMLEditor, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void replaceHeadContentsWithHTML (in AString aSourceToInsert); */
    pub ReplaceHeadContentsWithHTML: unsafe extern "system" fn (this: *const nsIHTMLEditor, aSourceToInsert: &::nsstring::nsAString) -> nsresult,

    /* nsIDOMElement createElementWithDefaults (in AString aTagName); */
    pub CreateElementWithDefaults: unsafe extern "system" fn (this: *const nsIHTMLEditor, aTagName: &::nsstring::nsAString, _retval: *mut *const nsIDOMElement) -> nsresult,

    /* void insertLinkAroundSelection (in nsIDOMElement aAnchorElement); */
    pub InsertLinkAroundSelection: unsafe extern "system" fn (this: *const nsIHTMLEditor, aAnchorElement: *const nsIDOMElement) -> nsresult,

    /* void setBackgroundColor (in AString aColor); */
    pub SetBackgroundColor: unsafe extern "system" fn (this: *const nsIHTMLEditor, aColor: &::nsstring::nsAString) -> nsresult,

    /* void setBodyAttribute (in AString aAttr, in AString aValue); */
    pub SetBodyAttribute: unsafe extern "system" fn (this: *const nsIHTMLEditor, aAttr: &::nsstring::nsAString, aValue: &::nsstring::nsAString) -> nsresult,

    /* nsIArray getLinkedObjects (); */
    pub GetLinkedObjects: unsafe extern "system" fn (this: *const nsIHTMLEditor, _retval: *mut *const nsIArray) -> nsresult,

    /* attribute boolean isCSSEnabled; */
    pub GetIsCSSEnabled: unsafe extern "system" fn (this: *const nsIHTMLEditor, aIsCSSEnabled: *mut bool) -> nsresult,

    /* attribute boolean isCSSEnabled; */
    pub SetIsCSSEnabled: unsafe extern "system" fn (this: *const nsIHTMLEditor, aIsCSSEnabled: bool) -> nsresult,

    /* nsIDOMElement getSelectionContainer (); */
    pub GetSelectionContainer: unsafe extern "system" fn (this: *const nsIHTMLEditor, _retval: *mut *const nsIDOMElement) -> nsresult,

    /* void checkSelectionStateForAnonymousButtons (in nsISelection aSelection); */
    pub CheckSelectionStateForAnonymousButtons: unsafe extern "system" fn (this: *const nsIHTMLEditor, aSelection: *const nsISelection) -> nsresult,

    /* boolean isAnonymousElement (in nsIDOMElement aElement); */
    pub IsAnonymousElement: unsafe extern "system" fn (this: *const nsIHTMLEditor, aElement: *const nsIDOMElement, _retval: *mut bool) -> nsresult,

    /* attribute boolean returnInParagraphCreatesNewParagraph; */
    pub GetReturnInParagraphCreatesNewParagraph: unsafe extern "system" fn (this: *const nsIHTMLEditor, aReturnInParagraphCreatesNewParagraph: *mut bool) -> nsresult,

    /* attribute boolean returnInParagraphCreatesNewParagraph; */
    pub SetReturnInParagraphCreatesNewParagraph: unsafe extern "system" fn (this: *const nsIHTMLEditor, aReturnInParagraphCreatesNewParagraph: bool) -> nsresult,

    /* [noscript,notxpcom] Element GetActiveEditingHost (); */
    /// Unable to generate binding because `native type mozilla::dom::Element is unsupported`
    pub GetActiveEditingHost: *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 nsIHTMLEditor {

    pub const eLeft: i64 = 0;


    pub const eCenter: i64 = 1;


    pub const eRight: i64 = 2;


    pub const eJustify: i64 = 3;

    /// ```text
    /// /**
    ///    * SetInlineProperty() sets the aggregate properties on the current selection
    ///    *
    ///    * @param aProperty   the property to set on the selection
    ///    * @param aAttribute  the attribute of the property, if applicable.
    ///    *                    May be null.
    ///    *                    Example: aProperty="font", aAttribute="color"
    ///    * @param aValue      if aAttribute is not null, the value of the attribute.
    ///    *                    May be null.
    ///    *                    Example: aProperty="font", aAttribute="color",
    ///    *                             aValue="0x00FFFF"
    ///    */
    /// ```
    ///

    /// `void setInlineProperty (in AString aProperty, in AString aAttribute, in AString aValue);`
    #[inline]
    pub unsafe fn SetInlineProperty(&self, aProperty: &::nsstring::nsAString, aAttribute: &::nsstring::nsAString, aValue: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetInlineProperty)(self, aProperty, aAttribute, aValue)
    }


    /// ```text
    /// /**
    ///    * getInlineProperty() gets aggregate properties of the current selection.
    ///    * All object in the current selection are scanned and their attributes are
    ///    * represented in a list of Property object.
    ///    *
    ///    * @param aProperty   the property to get on the selection
    ///    * @param aAttribute  the attribute of the property, if applicable.
    ///    *                    May be null.
    ///    *                    Example: aProperty="font", aAttribute="color"
    ///    * @param aValue      if aAttribute is not null, the value of the attribute.
    ///    *                    May be null.
    ///    *                    Example: aProperty="font", aAttribute="color",
    ///    *                             aValue="0x00FFFF"
    ///    * @param aFirst      [OUT] PR_TRUE if the first text node in the
    ///    *                          selection has the property
    ///    * @param aAny        [OUT] PR_TRUE if any of the text nodes in the
    ///    *                          selection have the property
    ///    * @param aAll        [OUT] PR_TRUE if all of the text nodes in the
    ///    *                          selection have the property
    ///    */
    /// ```
    ///

    /// `void getInlineProperty (in AString aProperty, in AString aAttribute, in AString aValue, out boolean aFirst, out boolean aAny, out boolean aAll);`
    #[inline]
    pub unsafe fn GetInlineProperty(&self, aProperty: &::nsstring::nsAString, aAttribute: &::nsstring::nsAString, aValue: &::nsstring::nsAString, aFirst: *mut bool, aAny: *mut bool, aAll: *mut bool) -> nsresult {
        ((*self.vtable).GetInlineProperty)(self, aProperty, aAttribute, aValue, aFirst, aAny, aAll)
    }



    /// `AString getInlinePropertyWithAttrValue (in AString aProperty, in AString aAttribute, in AString aValue, out boolean aFirst, out boolean aAny, out boolean aAll);`
    #[inline]
    pub unsafe fn GetInlinePropertyWithAttrValue(&self, aProperty: &::nsstring::nsAString, aAttribute: &::nsstring::nsAString, aValue: &::nsstring::nsAString, aFirst: *mut bool, aAny: *mut bool, aAll: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetInlinePropertyWithAttrValue)(self, aProperty, aAttribute, aValue, aFirst, aAny, aAll, _retval)
    }


    /// ```text
    /// /**
    ///    * removeAllInlineProperties() deletes all the inline properties from all
    ///    * text in the current selection.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * removeInlineProperty() deletes the properties from all text in the current
    ///    * selection.  If aProperty is not set on the selection, nothing is done.
    ///    *
    ///    * @param aProperty   the property to remove from the selection
    ///    *                    All atoms are for normal HTML tags (e.g.:
        ///    *                    nsIEditorProperty::font) except when you want to
    ///    *                    remove just links and not named anchors.
    ///    *                    For that, use nsIEditorProperty::href
    ///    * @param aAttribute  the attribute of the property, if applicable.
    ///    *                    May be null.
    ///    *                    Example: aProperty=nsIEditorProptery::font,
    ///    *                    aAttribute="color"
    ///    *                    nsIEditProperty::allAttributes is special.
    ///    *                    It indicates that all content-based text properties
    ///    *                    are to be removed from the selection.
    ///    */
    /// ```
    ///

    /// `void removeInlineProperty (in AString aProperty, in AString aAttribute);`
    #[inline]
    pub unsafe fn RemoveInlineProperty(&self, aProperty: &::nsstring::nsAString, aAttribute: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).RemoveInlineProperty)(self, aProperty, aAttribute)
    }


    /// ```text
    /// /**
    ///    *  Increase font size for text in selection by 1 HTML unit
    ///    *  All existing text is scanned for existing <FONT SIZE> attributes
    ///    *  so they will be incremented instead of inserting new <FONT> tag
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  Decrease font size for text in selection by 1 HTML unit
    ///    *  All existing text is scanned for existing <FONT SIZE> attributes
    ///    *  so they will be decreased instead of inserting new <FONT> tag
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Tests if a node is a BLOCK element according the the HTML 4.0 DTD.
    ///    *   This does NOT consider CSS effect on display type
    ///    *
    ///    * @param aNode      the node to test
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Insert some HTML source at the current location
    ///    *
    ///    * @param aInputString   the string to be inserted
    ///    */
    /// ```
    ///

    /// `void insertHTML (in AString aInputString);`
    #[inline]
    pub unsafe fn InsertHTML(&self, aInputString: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).InsertHTML)(self, aInputString)
    }


    /// ```text
    /// /**
    ///     * Paste the text in the OS clipboard at the cursor position, replacing
    ///     * the selected text (if any), but strip out any HTML styles and formatting
    ///     */
    /// ```
    ///

    /// `void pasteNoFormatting (in long aSelectionType);`
    #[inline]
    pub unsafe fn PasteNoFormatting(&self, aSelectionType: libc::int32_t) -> nsresult {
        ((*self.vtable).PasteNoFormatting)(self, aSelectionType)
    }


    /// ```text
    /// /**
    ///    *  Rebuild the entire document from source HTML
    ///    *  Needed to be able to edit HEAD and other outside-of-BODY content
    ///    *
    ///    *  @param aSourceString   HTML source string of the entire new document
    ///    */
    /// ```
    ///

    /// `void rebuildDocumentFromSource (in AString aSourceString);`
    #[inline]
    pub unsafe fn RebuildDocumentFromSource(&self, aSourceString: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).RebuildDocumentFromSource)(self, aSourceString)
    }


    /// ```text
    /// /**
    ///    * Insert some HTML source, interpreting
    ///    * the string argument according to the given context.
    ///    *
    ///    * @param aInputString   the string to be inserted
    ///    * @param aContextStr    Context of insertion
    ///    * @param aInfoStr       Related info to aInputString
    ///    * @param aFlavor        Transferable flavor, can be ""
    ///    * @param aSourceDoc          document where input was dragged from (may be null)
    ///    * @param aDestinationNode    location for insertion (such as when dropped)
    ///    * @param aDestinationOffset  used with aDestNode to determine insert location
    ///    * @param aDeleteSelection    used with aDestNode during drag&drop
    ///    * @param aCollapseSelection  used with aDestNode during drag&drop
    ///    */
    /// ```
    ///

    /// `void insertHTMLWithContext (in AString aInputString, in AString aContextStr, in AString aInfoStr, in AString aFlavor, in nsIDOMDocument aSourceDoc, in nsIDOMNode aDestinationNode, in long aDestinationOffset, in boolean aDeleteSelection);`
    #[inline]
    pub unsafe fn InsertHTMLWithContext(&self, aInputString: &::nsstring::nsAString, aContextStr: &::nsstring::nsAString, aInfoStr: &::nsstring::nsAString, aFlavor: &::nsstring::nsAString, aSourceDoc: *const nsIDOMDocument, aDestinationNode: *const nsIDOMNode, aDestinationOffset: libc::int32_t, aDeleteSelection: bool) -> nsresult {
        ((*self.vtable).InsertHTMLWithContext)(self, aInputString, aContextStr, aInfoStr, aFlavor, aSourceDoc, aDestinationNode, aDestinationOffset, aDeleteSelection)
    }


    /// ```text
    /// /**
    ///     * Insert an element, which may have child nodes, at the selection
    ///     * Used primarily to insert a new element for various insert element dialogs,
    ///     *   but it enforces the HTML 4.0 DTD "CanContain" rules, so it should
    ///     *   be useful for other elements.
    ///     *
    ///     * @param aElement           The element to insert
    ///     * @param aDeleteSelection   Delete the selection before inserting
    ///     *     If aDeleteSelection is PR_FALSE, then the element is inserted
    ///     *     after the end of the selection for all element except
    ///     *     Named Anchors, which insert before the selection
    ///     */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *   Set the BaseURL for the document to the current URL
    ///    *     but only if the page doesn't have a <base> tag
    ///    *   This should be done after the document URL has changed,
    ///    *     such as after saving a file
    ///    *   This is used as base for relativizing link and image urls
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///     * Set the selection at the suppled element
    ///     *
    ///     * @param aElement   An element in the document
    ///     */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///     * Create a collapsed selection just after aElement
    ///     *
    ///     * XXX could we parameterize SelectElement(before/select/after>?
        ///     *
        ///     * The selection is set to parent-of-aElement with an
        ///     *   offset 1 greater than aElement's offset
        ///     *   but it enforces the HTML 4.0 DTD "CanContain" rules, so it should
        ///     *   be useful for other elements.
        ///     *
        ///     * @param aElement  An element in the document
        ///     */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * SetParagraphFormat       Insert a block paragraph tag around selection
        ///    * @param aParagraphFormat  "p", "h1" to "h6", "address", "pre", or "blockquote"
        ///    */
        /// ```
        ///

        /// `void setParagraphFormat (in AString aParagraphFormat);`
        #[inline]
        pub unsafe fn SetParagraphFormat(&self, aParagraphFormat: &::nsstring::nsAString) -> nsresult {
            ((*self.vtable).SetParagraphFormat)(self, aParagraphFormat)
        }


        /// ```text
        /// /**
        ///    * getParagraphState returns what block tag paragraph format is in
        ///    * the selection.
        ///    * @param aMixed     True if there is more than one format
        ///    * @return           Name of block tag. "" is returned for none.
        ///    */
        /// ```
        ///

        /// `AString getParagraphState (out boolean aMixed);`
        #[inline]
        pub unsafe fn GetParagraphState(&self, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult {
            ((*self.vtable).GetParagraphState)(self, aMixed, _retval)
        }


        /// ```text
        /// /**
        ///    * getFontFaceState returns what font face is in the selection.
        ///    * @param aMixed    True if there is more than one font face
        ///    * @return          Name of face.  Note: "tt" is returned for
        ///    *                  tt tag.  "" is returned for none.
        ///    */
        /// ```
        ///

        /// `AString getFontFaceState (out boolean aMixed);`
        #[inline]
        pub unsafe fn GetFontFaceState(&self, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult {
            ((*self.vtable).GetFontFaceState)(self, aMixed, _retval)
        }


        /// ```text
        /// /**
        ///    * getFontColorState returns what font face is in the selection.
        ///    * @param aMixed     True if there is more than one font color
        ///    * @return           Color string. "" is returned for none.
        ///    */
        /// ```
        ///

        /// `AString getFontColorState (out boolean aMixed);`
        #[inline]
        pub unsafe fn GetFontColorState(&self, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult {
            ((*self.vtable).GetFontColorState)(self, aMixed, _retval)
        }


        /// ```text
        /// /**
        ///    * getFontColorState returns what font face is in the selection.
        ///    * @param aMixed     True if there is more than one font color
        ///    * @return           Color string. "" is returned for none.
        ///    */
        /// ```
        ///

        /// `AString getBackgroundColorState (out boolean aMixed);`
        #[inline]
        pub unsafe fn GetBackgroundColorState(&self, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult {
            ((*self.vtable).GetBackgroundColorState)(self, aMixed, _retval)
        }


        /// ```text
        /// /**
        ///    * getHighlightColorState returns what the highlight color of the selection.
        ///    * @param aMixed     True if there is more than one font color
        ///    * @return           Color string. "" is returned for none.
        ///    */
        /// ```
        ///

        /// `AString getHighlightColorState (out boolean aMixed);`
        #[inline]
        pub unsafe fn GetHighlightColorState(&self, aMixed: *mut bool, _retval: &mut ::nsstring::nsAString) -> nsresult {
            ((*self.vtable).GetHighlightColorState)(self, aMixed, _retval)
        }


        /// ```text
        /// /**
        ///    * getListState returns what list type is in the selection.
        ///    * @param aMixed    True if there is more than one type of list, or
        ///    *                  if there is some list and non-list
        ///    * @param aOL       The company that employs me.  No, really, it's
        ///    *                  true if an "ol" list is selected.
        ///    * @param aUL       true if an "ul" list is selected.
        ///    * @param aDL       true if a "dl" list is selected.
        ///    */
        /// ```
        ///

        /// `void getListState (out boolean aMixed, out boolean aOL, out boolean aUL, out boolean aDL);`
        #[inline]
        pub unsafe fn GetListState(&self, aMixed: *mut bool, aOL: *mut bool, aUL: *mut bool, aDL: *mut bool) -> nsresult {
            ((*self.vtable).GetListState)(self, aMixed, aOL, aUL, aDL)
        }


        /// ```text
        /// /**
        ///    * getListItemState returns what list item type is in the selection.
        ///    * @param aMixed    True if there is more than one type of list item, or
        ///    *                  if there is some list and non-list
        ///    * @param aLI       true if "li" list items are selected.
        ///    * @param aDT       true if "dt" list items are selected.
        ///    * @param aDD       true if "dd" list items are selected.
        ///    */
        /// ```
        ///

        /// `void getListItemState (out boolean aMixed, out boolean aLI, out boolean aDT, out boolean aDD);`
        #[inline]
        pub unsafe fn GetListItemState(&self, aMixed: *mut bool, aLI: *mut bool, aDT: *mut bool, aDD: *mut bool) -> nsresult {
            ((*self.vtable).GetListItemState)(self, aMixed, aLI, aDT, aDD)
        }


        /// ```text
        /// /**
        ///    * getAlignment     returns what alignment is in the selection.
        ///    * @param aMixed    True if there is more than one type of list item, or
        ///    *                  if there is some list and non-list
        ///    * @param aAlign    enum value for first encountered alignment
        ///    *                  (left/center/right)
        ///    */
        /// ```
        ///

        /// `void getAlignment (out boolean aMixed, out short aAlign);`
        #[inline]
        pub unsafe fn GetAlignment(&self, aMixed: *mut bool, aAlign: *mut libc::int16_t) -> nsresult {
            ((*self.vtable).GetAlignment)(self, aMixed, aAlign)
        }


        /// ```text
        /// /**
        ///    * Document me!
        ///    *
        ///    */
        /// ```
        ///

        /// `void getIndentState (out boolean aCanIndent, out boolean aCanOutdent);`
        #[inline]
        pub unsafe fn GetIndentState(&self, aCanIndent: *mut bool, aCanOutdent: *mut bool) -> nsresult {
            ((*self.vtable).GetIndentState)(self, aCanIndent, aCanOutdent)
        }


        /// ```text
        /// /**
        ///    * Document me!
        ///    *
        ///    */
        /// ```
        ///

        /// `void makeOrChangeList (in AString aListType, in boolean entireList, in AString aBulletType);`
        #[inline]
        pub unsafe fn MakeOrChangeList(&self, aListType: &::nsstring::nsAString, entireList: bool, aBulletType: &::nsstring::nsAString) -> nsresult {
            ((*self.vtable).MakeOrChangeList)(self, aListType, entireList, aBulletType)
        }


        /// ```text
        /// /**
        ///    * Document me!
        ///    *
        ///    */
        /// ```
        ///

        /// `void removeList (in AString aListType);`
        #[inline]
        pub unsafe fn RemoveList(&self, aListType: &::nsstring::nsAString) -> nsresult {
            ((*self.vtable).RemoveList)(self, aListType)
        }


        /// ```text
        /// /**
        ///    * Document me!
        ///    *
        ///    */
        /// ```
        ///

        /// `void indent (in AString aIndent);`
        #[inline]
        pub unsafe fn Indent(&self, aIndent: &::nsstring::nsAString) -> nsresult {
            ((*self.vtable).Indent)(self, aIndent)
        }


        /// ```text
        /// /**
        ///    * Document me!
        ///    *
        ///    */
        /// ```
        ///

        /// `void align (in AString aAlign);`
        #[inline]
        pub unsafe fn Align(&self, aAlign: &::nsstring::nsAString) -> nsresult {
            ((*self.vtable).Align)(self, aAlign)
        }


        /// ```text
        /// /**
        ///    * Return the input node or a parent matching the given aTagName,
        ///    *   starting the search at the supplied node.
        ///    * An example of use is for testing if a node is in a table cell
        ///    *   given a selection anchor node.
        ///    *
        ///    * @param aTagName  The HTML tagname
        ///    *  Special input values:
        ///    *    Use "href" to get a link node
        ///    *      (an "A" tag with the "href" attribute set)
        ///    *    Use "anchor" or "namedanchor" to get a named anchor node
        ///    *      (an "A" tag with the "name" attribute set)
        ///    *    Use "list" to get an OL, UL, or DL list node
        ///    *    Use "td" to get either a TD or TH cell node
        ///    *
        ///    * @param aNode    The node in the document to start the search.
        ///    *     If it is null, the anchor node of the current selection is used.
        ///    * @return         NS_EDITOR_ELEMENT_NOT_FOUND if an element is not found
        ///    *                 (passes NS_SUCCEEDED macro)
        ///    */
        /// ```
        ///

        /// `nsIDOMElement getElementOrParentByTagName (in AString aTagName, in nsIDOMNode aNode);`
        #[inline]
        pub unsafe fn GetElementOrParentByTagName(&self, aTagName: &::nsstring::nsAString, aNode: *const nsIDOMNode, _retval: *mut *const nsIDOMElement) -> nsresult {
            ((*self.vtable).GetElementOrParentByTagName)(self, aTagName, aNode, _retval)
        }


        /// ```text
        /// /**
        ///    * Return an element only if it is the only node selected,
        ///    *    such as an image, horizontal rule, etc.
        ///    * The exception is a link, which is more like a text attribute:
        ///    *    The Anchor tag is returned if the selection is within the textnode(s)
        ///    *    that are children of the "A" node.
        ///    *    This could be a collapsed selection, i.e., a caret
        ///    *    within the link text.
        ///    *
        ///    * @param aTagName  The HTML tagname or and empty string
        ///    *       to get any element (but only if it is the only element selected)
        ///    *    Special input values for Links and Named anchors:
        ///    *    Use "href" to get a link node
        ///    *      (an "A" tag with the "href" attribute set)
        ///    *    Use "anchor" or "namedanchor" to get a named anchor node
        ///    *      (an "A" tag with the "name" attribute set)
        ///    * @return          NS_EDITOR_ELEMENT_NOT_FOUND if an element is not found
        ///    *                  (passes NS_SUCCEEDED macro)
        ///    */
        /// ```
        ///

        /// `nsIDOMElement getSelectedElement (in AString aTagName);`
        #[inline]
        pub unsafe fn GetSelectedElement(&self, aTagName: &::nsstring::nsAString, _retval: *mut *const nsIDOMElement) -> nsresult {
            ((*self.vtable).GetSelectedElement)(self, aTagName, _retval)
        }


        /// ```text
        /// /**
        ///    * Output the contents of the <HEAD> section as text/HTML format
        ///    */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * Replace all children of <HEAD> with string of HTML source
        ///    */
        /// ```
        ///

        /// `void replaceHeadContentsWithHTML (in AString aSourceToInsert);`
        #[inline]
        pub unsafe fn ReplaceHeadContentsWithHTML(&self, aSourceToInsert: &::nsstring::nsAString) -> nsresult {
            ((*self.vtable).ReplaceHeadContentsWithHTML)(self, aSourceToInsert)
        }


        /// ```text
        /// /**
        ///    * Return a new element with default attribute values
        ///    *
        ///    * This does not rely on the selection, and is not sensitive to context.
        ///    *
        ///    * Used primarily to supply new element for various insert element dialogs
        ///    *  (Image, Link, NamedAnchor, Table, and HorizontalRule
            ///    *   are the only returned elements as of 7/25/99)
        ///    *
        ///    * @param aTagName  The HTML tagname
        ///    *    Special input values for Links and Named anchors:
        ///    *    Use "href" to get a link node
        ///    *      (an "A" tag with the "href" attribute set)
        ///    *    Use "anchor" or "namedanchor" to get a named anchor node
        ///    *      (an "A" tag with the "name" attribute set)
        ///    * @return          The new element created.
        ///    */
        /// ```
        ///

        /// `nsIDOMElement createElementWithDefaults (in AString aTagName);`
        #[inline]
        pub unsafe fn CreateElementWithDefaults(&self, aTagName: &::nsstring::nsAString, _retval: *mut *const nsIDOMElement) -> nsresult {
            ((*self.vtable).CreateElementWithDefaults)(self, aTagName, _retval)
        }


        /// ```text
        /// /**
        ///    * Insert an link element as the parent of the current selection
        ///    *
        ///    * @param aElement   An "A" element with a non-empty "href" attribute
        ///    */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * Set the value of the "bgcolor" attribute on the document's <body> element
        ///    *
        ///    * @param aColor  The HTML color string, such as "#ffccff" or "yellow"
        ///    */
        /// ```
        ///

        /// `void setBackgroundColor (in AString aColor);`
        #[inline]
        pub unsafe fn SetBackgroundColor(&self, aColor: &::nsstring::nsAString) -> nsresult {
            ((*self.vtable).SetBackgroundColor)(self, aColor)
        }


        /// ```text
        /// /**
        ///    * Set an attribute on the document's <body> element
        ///    *    such as text, link, background colors
        ///    *
        ///    * 8/31/00 THIS ISN'T BEING USED? SHOULD WE DROP IT?
        ///    *
        ///    * @param aAttr   The attribute to be set
        ///    * @param aValue  The value of the attribute
        ///    */
        /// ```
        ///

        /// `void setBodyAttribute (in AString aAttr, in AString aValue);`
        #[inline]
        pub unsafe fn SetBodyAttribute(&self, aAttr: &::nsstring::nsAString, aValue: &::nsstring::nsAString) -> nsresult {
            ((*self.vtable).SetBodyAttribute)(self, aAttr, aValue)
        }


        /// ```text
        /// /**
        ///    * Find all the nodes in the document which contain references
        ///    * to outside URIs (e.g. a href, img src, script src, etc.)
        ///    * The objects in the array will be type nsIURIRefObject.
        ///    *
        ///    * @return aNodeList    the linked nodes found
        ///    */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * A boolean which is true is the HTMLEditor has been instantiated
        ///    * with CSS knowledge and if the CSS pref is currently checked
        ///    *
        ///    * @return    true if CSS handled and enabled
        ///    */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * A boolean which is true is the HTMLEditor has been instantiated
        ///    * with CSS knowledge and if the CSS pref is currently checked
        ///    *
        ///    * @return    true if CSS handled and enabled
        ///    */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * returns the deepest container of the selection
        ///    * @return a DOM Element
        ///    */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * Checks if the anonymous nodes created by the HTML editor have to be
        ///    * refreshed or hidden depending on a possible new state of the selection
        ///    * @param aSelection [IN] a selection
        ///    */
        /// ```
        ///

        /// `void checkSelectionStateForAnonymousButtons (in nsISelection aSelection);`
        #[inline]
        pub unsafe fn CheckSelectionStateForAnonymousButtons(&self, aSelection: *const nsISelection) -> nsresult {
            ((*self.vtable).CheckSelectionStateForAnonymousButtons)(self, aSelection)
        }



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


        /// ```text
        /// /**
        ///    * A boolean indicating if a return key pressed in a paragraph creates
        ///    * another paragraph or just inserts a <br> at the caret
        ///    *
        ///    * @return    true if CR in a paragraph creates a new paragraph
        ///    */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * A boolean indicating if a return key pressed in a paragraph creates
        ///    * another paragraph or just inserts a <br> at the caret
        ///    *
        ///    * @return    true if CR in a paragraph creates a new paragraph
        ///    */
        /// ```
        ///

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


        /// ```text
        /// /**
        ///    * Get an active editor's editing host in DOM window.  If this editor isn't
        ///    * active in the DOM window, this returns NULL.
        ///    */
        /// ```
        ///

        /// `[noscript,notxpcom] Element GetActiveEditingHost ();`
        const _GetActiveEditingHost: () = ();

    }