Struct xpcom::interfaces::nsIHTMLEditor

#[repr(C)]
pub struct nsIHTMLEditor { /* fields omitted */ }

interface nsIHTMLEditor : nsISupports

Methods

impl nsIHTMLEditor

pub fn coerce<T: nsIHTMLEditorCoerce>(&self) -> &T

Cast this nsIHTMLEditor to one of its base interfaces.

impl nsIHTMLEditor

pub const eLeft: i64

eLeft: i64 = 0

pub const eCenter: i64

eCenter: i64 = 1

pub const eRight: i64

eRight: i64 = 2

pub const eJustify: i64

eJustify: i64 = 3

pub unsafe fn SetInlineProperty(
    &self,
    aProperty: &nsAString,
    aAttribute: &nsAString,
    aValue: &nsAString
) -> nsresult

/**
   * 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);

pub unsafe fn GetInlineProperty(
    &self,
    aProperty: &nsAString,
    aAttribute: &nsAString,
    aValue: &nsAString,
    aFirst: *mut bool,
    aAny: *mut bool,
    aAll: *mut bool
) -> nsresult

/**
   * 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);

pub unsafe fn GetInlinePropertyWithAttrValue(
    &self,
    aProperty: &nsAString,
    aAttribute: &nsAString,
    aValue: &nsAString,
    aFirst: *mut bool,
    aAny: *mut bool,
    aAll: *mut bool,
    _retval: &mut nsAString
) -> nsresult

AString getInlinePropertyWithAttrValue (in AString aProperty, in AString aAttribute, in AString aValue, out boolean aFirst, out boolean aAny, out boolean aAll);

pub unsafe fn RemoveAllInlineProperties(&self) -> nsresult

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

void removeAllInlineProperties ();

pub unsafe fn RemoveInlineProperty(
    &self,
    aProperty: &nsAString,
    aAttribute: &nsAString
) -> nsresult

/**
   * 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);

pub unsafe fn IncreaseFontSize(&self) -> nsresult

/**
   *  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 ();

pub unsafe fn DecreaseFontSize(&self) -> nsresult

/**
   *  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 ();

pub unsafe fn NodeIsBlock(
    &self,
    node: *const nsIDOMNode,
    _retval: *mut bool
) -> nsresult

/**
   * 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);

pub unsafe fn InsertHTML(&self, aInputString: &nsAString) -> nsresult

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

void insertHTML (in AString aInputString);

pub unsafe fn PasteNoFormatting(&self, aSelectionType: int32_t) -> nsresult

/**
    * 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);

pub unsafe fn RebuildDocumentFromSource(
    &self,
    aSourceString: &nsAString
) -> nsresult

/**
   *  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);

pub unsafe fn InsertHTMLWithContext(
    &self,
    aInputString: &nsAString,
    aContextStr: &nsAString,
    aInfoStr: &nsAString,
    aFlavor: &nsAString,
    aSourceDoc: *const nsIDOMDocument,
    aDestinationNode: *const nsIDOMNode,
    aDestinationOffset: int32_t,
    aDeleteSelection: bool
) -> nsresult

/**
   * 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);

pub unsafe fn InsertElementAtSelection(
    &self,
    aElement: *const nsIDOMElement,
    aDeleteSelection: bool
) -> nsresult

/**
    * 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);

pub unsafe fn UpdateBaseURL(&self) -> nsresult

/**
   *   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 ();

pub unsafe fn SelectElement(&self, aElement: *const nsIDOMElement) -> nsresult

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

void selectElement (in nsIDOMElement aElement);

pub unsafe fn SetCaretAfterElement(
    &self,
    aElement: *const nsIDOMElement
) -> nsresult

/**
    * 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);

pub unsafe fn SetParagraphFormat(
    &self,
    aParagraphFormat: &nsAString
) -> nsresult

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

void setParagraphFormat (in AString aParagraphFormat);

pub unsafe fn GetParagraphState(
    &self,
    aMixed: *mut bool,
    _retval: &mut nsAString
) -> nsresult

/**
   * 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);

pub unsafe fn GetFontFaceState(
    &self,
    aMixed: *mut bool,
    _retval: &mut nsAString
) -> nsresult

/**
   * 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);

pub unsafe fn GetFontColorState(
    &self,
    aMixed: *mut bool,
    _retval: &mut nsAString
) -> nsresult

/**
   * 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);

pub unsafe fn GetBackgroundColorState(
    &self,
    aMixed: *mut bool,
    _retval: &mut nsAString
) -> nsresult

/**
   * 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);

pub unsafe fn GetHighlightColorState(
    &self,
    aMixed: *mut bool,
    _retval: &mut nsAString
) -> nsresult

/**
   * 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);

pub unsafe fn GetListState(
    &self,
    aMixed: *mut bool,
    aOL: *mut bool,
    aUL: *mut bool,
    aDL: *mut bool
) -> nsresult

/**
   * 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);

pub unsafe fn GetListItemState(
    &self,
    aMixed: *mut bool,
    aLI: *mut bool,
    aDT: *mut bool,
    aDD: *mut bool
) -> nsresult

/**
   * 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);

pub unsafe fn GetAlignment(
    &self,
    aMixed: *mut bool,
    aAlign: *mut int16_t
) -> nsresult

/**
   * 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);

pub unsafe fn GetIndentState(
    &self,
    aCanIndent: *mut bool,
    aCanOutdent: *mut bool
) -> nsresult

/**
   * Document me!
   *
   */

void getIndentState (out boolean aCanIndent, out boolean aCanOutdent);

pub unsafe fn MakeOrChangeList(
    &self,
    aListType: &nsAString,
    entireList: bool,
    aBulletType: &nsAString
) -> nsresult

/**
   * Document me!
   *
   */

void makeOrChangeList (in AString aListType, in boolean entireList, in AString aBulletType);

pub unsafe fn RemoveList(&self, aListType: &nsAString) -> nsresult

/**
   * Document me!
   *
   */

void removeList (in AString aListType);

pub unsafe fn Indent(&self, aIndent: &nsAString) -> nsresult

/**
   * Document me!
   *
   */

void indent (in AString aIndent);

pub unsafe fn Align(&self, aAlign: &nsAString) -> nsresult

/**
   * Document me!
   *
   */

void align (in AString aAlign);

pub unsafe fn GetElementOrParentByTagName(
    &self,
    aTagName: &nsAString,
    aNode: *const nsIDOMNode,
    _retval: *mut *const nsIDOMElement
) -> nsresult

/**
   * 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);

pub unsafe fn GetSelectedElement(
    &self,
    aTagName: &nsAString,
    _retval: *mut *const nsIDOMElement
) -> nsresult

/**
   * 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);

pub unsafe fn GetHeadContentsAsHTML(&self, _retval: &mut nsAString) -> nsresult

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

AString getHeadContentsAsHTML ();

pub unsafe fn ReplaceHeadContentsWithHTML(
    &self,
    aSourceToInsert: &nsAString
) -> nsresult

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

void replaceHeadContentsWithHTML (in AString aSourceToInsert);

pub unsafe fn CreateElementWithDefaults(
    &self,
    aTagName: &nsAString,
    _retval: *mut *const nsIDOMElement
) -> nsresult

/**
   * 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);

pub unsafe fn InsertLinkAroundSelection(
    &self,
    aAnchorElement: *const nsIDOMElement
) -> nsresult

/**
   * 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);

pub unsafe fn SetBackgroundColor(&self, aColor: &nsAString) -> nsresult

/**
   * 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);

pub unsafe fn SetBodyAttribute(
    &self,
    aAttr: &nsAString,
    aValue: &nsAString
) -> nsresult

/**
   * 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);

pub unsafe fn GetLinkedObjects(&self, _retval: *mut *const nsIArray) -> nsresult

/**
   * 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 ();

pub unsafe fn GetIsCSSEnabled(&self, aIsCSSEnabled: *mut bool) -> nsresult

/**
   * 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;

pub unsafe fn SetIsCSSEnabled(&self, aIsCSSEnabled: bool) -> nsresult

/**
   * 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;

pub unsafe fn GetSelectionContainer(
    &self,
    _retval: *mut *const nsIDOMElement
) -> nsresult

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

nsIDOMElement getSelectionContainer ();

pub unsafe fn CheckSelectionStateForAnonymousButtons(
    &self,
    aSelection: *const nsISelection
) -> nsresult

/**
   * 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);

pub unsafe fn IsAnonymousElement(
    &self,
    aElement: *const nsIDOMElement,
    _retval: *mut bool
) -> nsresult

boolean isAnonymousElement (in nsIDOMElement aElement);

pub unsafe fn GetReturnInParagraphCreatesNewParagraph(
    &self,
    aReturnInParagraphCreatesNewParagraph: *mut bool
) -> nsresult

/**
   * 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;

pub unsafe fn SetReturnInParagraphCreatesNewParagraph(
    &self,
    aReturnInParagraphCreatesNewParagraph: bool
) -> nsresult

/**
   * 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;

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIHTMLEditor

const IID: nsIID

IID: nsIID = nsID(2280560958, 39007, 19011, [169, 116, 13, 149, 18, 218, 47, 176])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIHTMLEditor

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIHTMLEditor

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.