Struct xpcom::interfaces::nsIEditActionListener

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

interface nsIEditActionListener : nsISupports

/**
 * A generic editor action listener interface.
 * <P>
 * nsIEditActionListener is the interface used by applications wishing to be notified
 * when the editor modifies the DOM tree.
 *
 * Note:  this is the wrong class to implement if you are interested in generic
 * change notifications.  For generic notifications, you should implement
 * nsIDocumentObserver.
 */

Methods

impl nsIEditActionListener

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

Cast this nsIEditActionListener to one of its base interfaces.

impl nsIEditActionListener

pub unsafe fn WillCreateNode(
    &self,
    aTag: &nsAString,
    aNextSiblingOfNewNode: *const nsIDOMNode
) -> nsresult

/**
   * Called before the editor creates a node.
   * @param aTag                    The tag name of the DOM Node to create.
   * @param aNextSiblingOfNewNode   The node which will be next sibling of
   *                                new node.  If the new node will be appended,
   *                                this is null.
   */

void WillCreateNode (in DOMString aTag, in nsIDOMNode aNextSiblingOfNewNode);

pub unsafe fn DidCreateNode(
    &self,
    aTag: &nsAString,
    aNewNode: *const nsIDOMNode,
    aResult: nsresult
) -> nsresult

/**
   * Called after the editor creates a node.
   * @param aTag      The tag name of the DOM Node to create.
   * @param aNewNode  The DOM Node that was created.
   * @param aResult   The result of the create node operation.
   */

void DidCreateNode (in DOMString aTag, in nsIDOMNode aNewNode, in nsresult aResult);

pub unsafe fn WillInsertNode(
    &self,
    aNode: *const nsIDOMNode,
    aNextSiblingOfNewNode: *const nsIDOMNode
) -> nsresult

/**
   * Called before the editor inserts a node.
   * @param aNode                   The DOM Node to insert.
   * @param aNextSiblingOfNewNode   The node which will be next sibling of
   *                                new node.  If the new node will be appended,
   *                                this is null.
   */

void WillInsertNode (in nsIDOMNode aNode, in nsIDOMNode aNextSiblingOfNewNode);

pub unsafe fn DidInsertNode(
    &self,
    aNode: *const nsIDOMNode,
    aResult: nsresult
) -> nsresult

/**
   * Called after the editor inserts a node.
   * @param aNode     The DOM Node to insert.
   * @param aResult   The result of the insert node operation.
   */

void DidInsertNode (in nsIDOMNode aNode, in nsresult aResult);

pub unsafe fn WillDeleteNode(&self, aChild: *const nsIDOMNode) -> nsresult

/**
   * Called before the editor deletes a node.
   * @param aChild    The node to delete
   */

void WillDeleteNode (in nsIDOMNode aChild);

pub unsafe fn DidDeleteNode(
    &self,
    aChild: *const nsIDOMNode,
    aResult: nsresult
) -> nsresult

/**
   * Called after the editor deletes a node.
   * @param aChild    The node to delete
   * @param aResult   The result of the delete node operation.
   */

void DidDeleteNode (in nsIDOMNode aChild, in nsresult aResult);

pub unsafe fn WillSplitNode(
    &self,
    aExistingRightNode: *const nsIDOMNode,
    aOffset: int32_t
) -> nsresult

/**
   * Called before the editor splits a node.
   * @param aExistingRightNode   the node to split.  It will become the new node's next sibling.
   * @param aOffset              the offset of aExistingRightNode's content|children to do the split at
   * @param aNewLeftNode         [OUT] the new node resulting from the split, becomes aExistingRightNode's previous sibling.
   */

void WillSplitNode (in nsIDOMNode aExistingRightNode, in long aOffset);

pub unsafe fn DidSplitNode(
    &self,
    aExistingRightNode: *const nsIDOMNode,
    aNewLeftNode: *const nsIDOMNode
) -> nsresult

/**
   * Called after the editor splits a node.
   * @param aExistingRightNode   The node which was split.  It will become the
   *                             next sibling of the new left node.
   * @param aNewLeftNode         The new node resulting from the split, becomes
   *                             the previous sibling of aExistingRightNode.
   */

void DidSplitNode (in nsIDOMNode aExistingRightNode, in nsIDOMNode aNewLeftNode);

pub unsafe fn WillJoinNodes(
    &self,
    aLeftNode: *const nsIDOMNode,
    aRightNode: *const nsIDOMNode,
    aParent: *const nsIDOMNode
) -> nsresult

/**
   * Called before the editor joins 2 nodes.
   * @param aLeftNode   This node will be merged into the right node
   * @param aRightNode  The node that will be merged into.
   *                    There is no requirement that the two nodes be of
   *                    the same type.
   * @param aParent     The parent of aRightNode
   */

void WillJoinNodes (in nsIDOMNode aLeftNode, in nsIDOMNode aRightNode, in nsIDOMNode aParent);

pub unsafe fn DidJoinNodes(
    &self,
    aLeftNode: *const nsIDOMNode,
    aRightNode: *const nsIDOMNode,
    aParent: *const nsIDOMNode,
    aResult: nsresult
) -> nsresult

/**
   * Called after the editor joins 2 nodes.
   * @param aLeftNode   This node will be merged into the right node
   * @param aRightNode  The node that will be merged into.
   *                    There is no requirement that the two nodes be of
   *                    the same type.
   * @param aParent     The parent of aRightNode
   * @param aResult     The result of the join operation.
   */

void DidJoinNodes (in nsIDOMNode aLeftNode, in nsIDOMNode aRightNode, in nsIDOMNode aParent, in nsresult aResult);

pub unsafe fn WillInsertText(
    &self,
    aTextNode: *const nsIDOMCharacterData,
    aOffset: int32_t,
    aString: &nsAString
) -> nsresult

/**
   * Called before the editor inserts text.
   * @param aTextNode   This node getting inserted text
   * @param aOffset     The offset in aTextNode to insert at.
   * @param aString     The string that gets inserted.
   */

void WillInsertText (in nsIDOMCharacterData aTextNode, in long aOffset, in DOMString aString);

pub unsafe fn DidInsertText(
    &self,
    aTextNode: *const nsIDOMCharacterData,
    aOffset: int32_t,
    aString: &nsAString,
    aResult: nsresult
) -> nsresult

/**
   * Called after the editor inserts text.
   * @param aTextNode   This node getting inserted text
   * @param aOffset     The offset in aTextNode to insert at.
   * @param aString     The string that gets inserted.
   * @param aResult     The result of the insert text operation.
   */

void DidInsertText (in nsIDOMCharacterData aTextNode, in long aOffset, in DOMString aString, in nsresult aResult);

pub unsafe fn WillDeleteText(
    &self,
    aTextNode: *const nsIDOMCharacterData,
    aOffset: int32_t,
    aLength: int32_t
) -> nsresult

/**
   * Called before the editor deletes text.
   * @param aTextNode   This node getting text deleted
   * @param aOffset     The offset in aTextNode to delete at.
   * @param aLength     The amount of text to delete.
   */

void WillDeleteText (in nsIDOMCharacterData aTextNode, in long aOffset, in long aLength);

pub unsafe fn DidDeleteText(
    &self,
    aTextNode: *const nsIDOMCharacterData,
    aOffset: int32_t,
    aLength: int32_t,
    aResult: nsresult
) -> nsresult

/**
   * Called before the editor deletes text.
   * @param aTextNode   This node getting text deleted
   * @param aOffset     The offset in aTextNode to delete at.
   * @param aLength     The amount of text to delete.
   * @param aResult     The result of the delete text operation.
   */

void DidDeleteText (in nsIDOMCharacterData aTextNode, in long aOffset, in long aLength, in nsresult aResult);

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

/**
   * Called before the editor deletes the selection.
   * @param aSelection   The selection to be deleted
   */

void WillDeleteSelection (in nsISelection aSelection);

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

/**
   * Called after the editor deletes the selection.
   * @param aSelection   The selection, after deletion
   */

void DidDeleteSelection (in nsISelection aSelection);

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 nsIEditActionListener

const IID: nsIID

IID: nsIID = nsID(2989033393, 61075, 4562, [141, 80, 0, 0, 100, 101, 115, 116])

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 nsIEditActionListener

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIEditActionListener

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.