Struct xpcom::interfaces::nsITXTToHTMLConv

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

interface nsITXTToHTMLConv : nsIStreamConverter

Methods

impl nsITXTToHTMLConv

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

Cast this nsITXTToHTMLConv to one of its base interfaces.

impl nsITXTToHTMLConv

pub unsafe fn SetTitle(&self, text: *const int16_t) -> nsresult

/**
   * @param text: Title to set for the HTML document.  Only applicable if
   *              preFormatHTML(true) is called.
   * @result      The given title will be used to form an HTML document
   *              from the plain text document.
   */

void setTitle (in wstring text);

pub unsafe fn PreFormatHTML(&self, value: bool) -> nsresult

/**
   * @param value: true to use an HTML header and footer on the document,
   *               false to omit it.
   * @result       The document will use a header and footer if value is
   *               true.
   */

void preFormatHTML (in boolean value);

Methods from Deref<Target = nsIStreamConverter>

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

Cast this nsIStreamConverter to one of its base interfaces.

pub unsafe fn Convert(
    &self,
    aFromStream: *const nsIInputStream,
    aFromType: *const c_char,
    aToType: *const c_char,
    aCtxt: *const nsISupports,
    _retval: *mut *const nsIInputStream
) -> nsresult

/**
     * <b>SYNCRONOUS VERSION</b>
     * Converts a stream of one type, to a stream of another type.
     *
     * Use this method when you have a stream you want to convert.
     *
     * @param aFromStream   The stream representing the original/raw data.
     * @param aFromType     The MIME type of aFromStream.
     * @param aToType       The MIME type of the returned stream.
     * @param aCtxt         Either an opaque context, or a converter specific context
     *                      (implementation specific).
     * @return              The converted stream. NOTE: The returned stream may not
     *                      already be converted. An efficient stream converter
     *                      implementation will converter data on demand rather than
     *                      buffering the converted data until it is used.
     */

nsIInputStream convert (in nsIInputStream aFromStream, in string aFromType, in string aToType, in nsISupports aCtxt);

pub unsafe fn AsyncConvertData(
    &self,
    aFromType: *const c_char,
    aToType: *const c_char,
    aListener: *const nsIStreamListener,
    aCtxt: *const nsISupports
) -> nsresult

/**
     * <b>ASYNCRONOUS VERSION</b>
     * Converts data arriving via the converter's nsIStreamListener::OnDataAvailable()
     * method from one type to another, pushing the converted data out to the caller
     * via aListener::OnDataAvailable().
     *
     * Use this method when you want to proxy (and convert) nsIStreamListener callbacks
     * asynchronously.
     *
     * @param aFromType     The MIME type of the original/raw data.
     * @param aToType       The MIME type of the converted data.
     * @param aListener     The listener who receives the converted data.
     * @param aCtxt         Either an opaque context, or a converter specific context
     *                      (implementation specific).
     */

void asyncConvertData (in string aFromType, in string aToType, in nsIStreamListener aListener, in nsISupports aCtxt);

Trait Implementations

impl XpCom for nsITXTToHTMLConv

const IID: nsIID

IID: nsIID = nsID(2469615094, 7634, 4530, [169, 176, 211, 53, 185, 227, 89, 131])

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 nsITXTToHTMLConv

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsITXTToHTMLConv

type Target = nsIStreamConverter

The resulting type after dereferencing.

fn deref(&self) -> &nsIStreamConverter

Dereferences the value.