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


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

    /// 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 nsIEditorMailSupport.
unsafe impl XpCom for nsIEditorMailSupport {
    const IID: nsIID = nsID(0xfdf23301, 0x4a94, 0x11d3,
        [0x9c, 0xe4, 0x99, 0x60, 0x49, 0x6c, 0x41, 0xbc]);
}

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

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

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

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

    /* nsIDOMNode insertAsQuotation (in AString aQuotedText); */
    pub InsertAsQuotation: unsafe extern "system" fn (this: *const nsIEditorMailSupport, aQuotedText: &::nsstring::nsAString, _retval: *mut *const nsIDOMNode) -> nsresult,

    /* void insertTextWithQuotations (in DOMString aStringToInsert); */
    pub InsertTextWithQuotations: unsafe extern "system" fn (this: *const nsIEditorMailSupport, aStringToInsert: &::nsstring::nsAString) -> nsresult,

    /* void pasteAsCitedQuotation (in AString aCitation, in long aSelectionType); */
    pub PasteAsCitedQuotation: unsafe extern "system" fn (this: *const nsIEditorMailSupport, aCitation: &::nsstring::nsAString, aSelectionType: libc::int32_t) -> nsresult,

    /* nsIDOMNode insertAsCitedQuotation (in AString aQuotedText, in AString aCitation, in boolean aInsertHTML); */
    pub InsertAsCitedQuotation: unsafe extern "system" fn (this: *const nsIEditorMailSupport, aQuotedText: &::nsstring::nsAString, aCitation: &::nsstring::nsAString, aInsertHTML: bool, _retval: *mut *const nsIDOMNode) -> nsresult,

    /* void rewrap (in boolean aRespectNewlines); */
    pub Rewrap: unsafe extern "system" fn (this: *const nsIEditorMailSupport, aRespectNewlines: bool) -> nsresult,

    /* void stripCites (); */
    pub StripCites: unsafe extern "system" fn (this: *const nsIEditorMailSupport) -> nsresult,

    /* nsIArray getEmbeddedObjects (); */
    pub GetEmbeddedObjects: unsafe extern "system" fn (this: *const nsIEditorMailSupport, _retval: *mut *const nsIArray) -> 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 nsIEditorMailSupport {

    /// ```text
    /// /** Paste the text in the OS clipboard at the cursor position,
    ///     * as a quotation (whose representation is dependant on the editor type),
    ///     * replacing the selected text (if any).
    ///     * @param aSelectionType Text or html?
    ///     */
    /// ```
    ///

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


    /// ```text
    /// /** Insert a string as quoted text
    ///     * (whose representation is dependant on the editor type),
    ///     * replacing the selected text (if any).
    ///     * @param aQuotedText  The actual text to be quoted
    ///     * @return             The node which was inserted
    ///     */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Inserts a plaintext string at the current location,
    ///    * with special processing for lines beginning with ">",
    ///    * which will be treated as mail quotes and inserted
    ///    * as plaintext quoted blocks.
    ///    * If the selection is not collapsed, the selection is deleted
    ///    * and the insertion takes place at the resulting collapsed selection.
    ///    *
    ///    * @param aString   the string to be inserted
    ///    */
    /// ```
    ///

    /// `void insertTextWithQuotations (in DOMString aStringToInsert);`
    #[inline]
    pub unsafe fn InsertTextWithQuotations(&self, aStringToInsert: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).InsertTextWithQuotations)(self, aStringToInsert)
    }


    /// ```text
    /// /** Paste a string as quoted text,
    ///     * whose representation is dependant on the editor type,
    ///     * replacing the selected text (if any)
    ///     * @param aCitation    The "mid" URL of the source message
    ///     * @param aSelectionType Text or html?
    ///     */
    /// ```
    ///

    /// `void pasteAsCitedQuotation (in AString aCitation, in long aSelectionType);`
    #[inline]
    pub unsafe fn PasteAsCitedQuotation(&self, aCitation: &::nsstring::nsAString, aSelectionType: libc::int32_t) -> nsresult {
        ((*self.vtable).PasteAsCitedQuotation)(self, aCitation, aSelectionType)
    }


    /// ```text
    /// /** Insert a string as quoted text
    ///     * (whose representation is dependant on the editor type),
    ///     * replacing the selected text (if any),
    ///     * including, if possible, a "cite" attribute.
    ///     * @param aQuotedText  The actual text to be quoted
    ///     * @param aCitation    The "mid" URL of the source message
    ///     * @param aInsertHTML  Insert as html?  (vs plaintext)
    ///     * @return             The node which was inserted
    ///     */
    /// ```
    ///

    /// `nsIDOMNode insertAsCitedQuotation (in AString aQuotedText, in AString aCitation, in boolean aInsertHTML);`
    #[inline]
    pub unsafe fn InsertAsCitedQuotation(&self, aQuotedText: &::nsstring::nsAString, aCitation: &::nsstring::nsAString, aInsertHTML: bool, _retval: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).InsertAsCitedQuotation)(self, aQuotedText, aCitation, aInsertHTML, _retval)
    }


    /// ```text
    /// /**
    ///    * Rewrap the selected part of the document, re-quoting if necessary.
    ///    * @param aRespectNewlines  Try to maintain newlines in the original?
    ///    */
    /// ```
    ///

    /// `void rewrap (in boolean aRespectNewlines);`
    #[inline]
    pub unsafe fn Rewrap(&self, aRespectNewlines: bool) -> nsresult {
        ((*self.vtable).Rewrap)(self, aRespectNewlines)
    }


    /// ```text
    /// /**
    ///    * Strip any citations in the selected part of the document.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Get a list of IMG and OBJECT tags in the current document.
    ///    */
    /// ```
    ///

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


}