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


/// `interface nsIEditActionListener : nsISupports`
///

/// ```text
/// /**
///  * 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.
///  */
/// ```
///

// 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 nsIEditActionListener {
    vtable: *const nsIEditActionListenerVTable,

    /// 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 nsIEditActionListener.
unsafe impl XpCom for nsIEditActionListener {
    const IID: nsIID = nsID(0xb22907b1, 0xee93, 0x11d2,
        [0x8d, 0x50, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74]);
}

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

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

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

    /* void WillCreateNode (in DOMString aTag, in nsIDOMNode aNextSiblingOfNewNode); */
    pub WillCreateNode: unsafe extern "system" fn (this: *const nsIEditActionListener, aTag: &::nsstring::nsAString, aNextSiblingOfNewNode: *const nsIDOMNode) -> nsresult,

    /* void DidCreateNode (in DOMString aTag, in nsIDOMNode aNewNode, in nsresult aResult); */
    pub DidCreateNode: unsafe extern "system" fn (this: *const nsIEditActionListener, aTag: &::nsstring::nsAString, aNewNode: *const nsIDOMNode, aResult: nsresult) -> nsresult,

    /* void WillInsertNode (in nsIDOMNode aNode, in nsIDOMNode aNextSiblingOfNewNode); */
    pub WillInsertNode: unsafe extern "system" fn (this: *const nsIEditActionListener, aNode: *const nsIDOMNode, aNextSiblingOfNewNode: *const nsIDOMNode) -> nsresult,

    /* void DidInsertNode (in nsIDOMNode aNode, in nsresult aResult); */
    pub DidInsertNode: unsafe extern "system" fn (this: *const nsIEditActionListener, aNode: *const nsIDOMNode, aResult: nsresult) -> nsresult,

    /* void WillDeleteNode (in nsIDOMNode aChild); */
    pub WillDeleteNode: unsafe extern "system" fn (this: *const nsIEditActionListener, aChild: *const nsIDOMNode) -> nsresult,

    /* void DidDeleteNode (in nsIDOMNode aChild, in nsresult aResult); */
    pub DidDeleteNode: unsafe extern "system" fn (this: *const nsIEditActionListener, aChild: *const nsIDOMNode, aResult: nsresult) -> nsresult,

    /* void WillSplitNode (in nsIDOMNode aExistingRightNode, in long aOffset); */
    pub WillSplitNode: unsafe extern "system" fn (this: *const nsIEditActionListener, aExistingRightNode: *const nsIDOMNode, aOffset: libc::int32_t) -> nsresult,

    /* void DidSplitNode (in nsIDOMNode aExistingRightNode, in nsIDOMNode aNewLeftNode); */
    pub DidSplitNode: unsafe extern "system" fn (this: *const nsIEditActionListener, aExistingRightNode: *const nsIDOMNode, aNewLeftNode: *const nsIDOMNode) -> nsresult,

    /* void WillJoinNodes (in nsIDOMNode aLeftNode, in nsIDOMNode aRightNode, in nsIDOMNode aParent); */
    pub WillJoinNodes: unsafe extern "system" fn (this: *const nsIEditActionListener, aLeftNode: *const nsIDOMNode, aRightNode: *const nsIDOMNode, aParent: *const nsIDOMNode) -> nsresult,

    /* void DidJoinNodes (in nsIDOMNode aLeftNode, in nsIDOMNode aRightNode, in nsIDOMNode aParent, in nsresult aResult); */
    pub DidJoinNodes: unsafe extern "system" fn (this: *const nsIEditActionListener, aLeftNode: *const nsIDOMNode, aRightNode: *const nsIDOMNode, aParent: *const nsIDOMNode, aResult: nsresult) -> nsresult,

    /* void WillInsertText (in nsIDOMCharacterData aTextNode, in long aOffset, in DOMString aString); */
    pub WillInsertText: unsafe extern "system" fn (this: *const nsIEditActionListener, aTextNode: *const nsIDOMCharacterData, aOffset: libc::int32_t, aString: &::nsstring::nsAString) -> nsresult,

    /* void DidInsertText (in nsIDOMCharacterData aTextNode, in long aOffset, in DOMString aString, in nsresult aResult); */
    pub DidInsertText: unsafe extern "system" fn (this: *const nsIEditActionListener, aTextNode: *const nsIDOMCharacterData, aOffset: libc::int32_t, aString: &::nsstring::nsAString, aResult: nsresult) -> nsresult,

    /* void WillDeleteText (in nsIDOMCharacterData aTextNode, in long aOffset, in long aLength); */
    pub WillDeleteText: unsafe extern "system" fn (this: *const nsIEditActionListener, aTextNode: *const nsIDOMCharacterData, aOffset: libc::int32_t, aLength: libc::int32_t) -> nsresult,

    /* void DidDeleteText (in nsIDOMCharacterData aTextNode, in long aOffset, in long aLength, in nsresult aResult); */
    pub DidDeleteText: unsafe extern "system" fn (this: *const nsIEditActionListener, aTextNode: *const nsIDOMCharacterData, aOffset: libc::int32_t, aLength: libc::int32_t, aResult: nsresult) -> nsresult,

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

    /* void DidDeleteSelection (in nsISelection aSelection); */
    pub DidDeleteSelection: unsafe extern "system" fn (this: *const nsIEditActionListener, aSelection: *const nsISelection) -> 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 nsIEditActionListener {

    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn WillCreateNode(&self, aTag: &::nsstring::nsAString, aNextSiblingOfNewNode: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).WillCreateNode)(self, aTag, aNextSiblingOfNewNode)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn DidCreateNode(&self, aTag: &::nsstring::nsAString, aNewNode: *const nsIDOMNode, aResult: nsresult) -> nsresult {
        ((*self.vtable).DidCreateNode)(self, aTag, aNewNode, aResult)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn WillInsertNode(&self, aNode: *const nsIDOMNode, aNextSiblingOfNewNode: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).WillInsertNode)(self, aNode, aNextSiblingOfNewNode)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn DidInsertNode(&self, aNode: *const nsIDOMNode, aResult: nsresult) -> nsresult {
        ((*self.vtable).DidInsertNode)(self, aNode, aResult)
    }


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

    /// `void WillDeleteNode (in nsIDOMNode aChild);`
    #[inline]
    pub unsafe fn WillDeleteNode(&self, aChild: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).WillDeleteNode)(self, aChild)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn DidDeleteNode(&self, aChild: *const nsIDOMNode, aResult: nsresult) -> nsresult {
        ((*self.vtable).DidDeleteNode)(self, aChild, aResult)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn WillSplitNode(&self, aExistingRightNode: *const nsIDOMNode, aOffset: libc::int32_t) -> nsresult {
        ((*self.vtable).WillSplitNode)(self, aExistingRightNode, aOffset)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn DidSplitNode(&self, aExistingRightNode: *const nsIDOMNode, aNewLeftNode: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).DidSplitNode)(self, aExistingRightNode, aNewLeftNode)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn WillJoinNodes(&self, aLeftNode: *const nsIDOMNode, aRightNode: *const nsIDOMNode, aParent: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).WillJoinNodes)(self, aLeftNode, aRightNode, aParent)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn DidJoinNodes(&self, aLeftNode: *const nsIDOMNode, aRightNode: *const nsIDOMNode, aParent: *const nsIDOMNode, aResult: nsresult) -> nsresult {
        ((*self.vtable).DidJoinNodes)(self, aLeftNode, aRightNode, aParent, aResult)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn WillInsertText(&self, aTextNode: *const nsIDOMCharacterData, aOffset: libc::int32_t, aString: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).WillInsertText)(self, aTextNode, aOffset, aString)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn DidInsertText(&self, aTextNode: *const nsIDOMCharacterData, aOffset: libc::int32_t, aString: &::nsstring::nsAString, aResult: nsresult) -> nsresult {
        ((*self.vtable).DidInsertText)(self, aTextNode, aOffset, aString, aResult)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn WillDeleteText(&self, aTextNode: *const nsIDOMCharacterData, aOffset: libc::int32_t, aLength: libc::int32_t) -> nsresult {
        ((*self.vtable).WillDeleteText)(self, aTextNode, aOffset, aLength)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn DidDeleteText(&self, aTextNode: *const nsIDOMCharacterData, aOffset: libc::int32_t, aLength: libc::int32_t, aResult: nsresult) -> nsresult {
        ((*self.vtable).DidDeleteText)(self, aTextNode, aOffset, aLength, aResult)
    }


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

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


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

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


}