Struct xpcom::interfaces::nsIEditorSpellCheck

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

interface nsIEditorSpellCheck : nsISupports

Methods

impl nsIEditorSpellCheck

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

Cast this nsIEditorSpellCheck to one of its base interfaces.

impl nsIEditorSpellCheck

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

/**
   * Returns true if we can enable spellchecking. If there are no available
   * dictionaries, this will return false.
   */

boolean canSpellCheck ();

pub unsafe fn InitSpellChecker(
    &self,
    editor: *const nsIEditor,
    enableSelectionChecking: bool,
    callback: *const nsIEditorSpellCheckCallback
) -> nsresult

/**
   * Turns on the spell checker for the given editor. enableSelectionChecking
   * set means that we only want to check the current selection in the editor,
   * (this controls the behavior of GetNextMisspelledWord). For spellchecking
   * clients with no modal UI (such as inline spellcheckers), this flag doesn't
   * matter.  Initialization is asynchronous and is not complete until the given
   * callback is called.
   */

void InitSpellChecker (in nsIEditor editor, in boolean enableSelectionChecking, [optional] in nsIEditorSpellCheckCallback callback);

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

/**
   * When interactively spell checking the document, this will return the
   * value of the next word that is misspelled. This also computes the
   * suggestions which you can get by calling GetSuggestedWord.
   *
   * @see nsISpellChecker::GetNextMisspelledWord
   */

AString GetNextMisspelledWord ();

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

/**
   * Used to get suggestions for the last word that was checked and found to
   * be misspelled. The first call will give you the first (best) suggestion.
   * Subsequent calls will iterate through all the suggestions, allowing you
   * to build a list. When there are no more suggestions, an empty string
   * (not a null pointer) will be returned.
   *
   * @see nsISpellChecker::GetSuggestedWord
   */

AString GetSuggestedWord ();

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

/**
   * Check a given word. In spite of the name, this function checks the word
   * you give it, returning true if the word is misspelled. If the word is
   * misspelled, it will compute the suggestions which you can get from
   * GetSuggestedWord().
   *
   * @see nsISpellChecker::CheckCurrentWord
   */

boolean CheckCurrentWord (in AString suggestedWord);

pub unsafe fn ReplaceWord(
    &self,
    misspelledWord: &nsAString,
    replaceWord: &nsAString,
    allOccurrences: bool
) -> nsresult

/**
   * Use when modally checking the document to replace a word.
   *
   * @see nsISpellChecker::CheckCurrentWord
   */

void ReplaceWord (in AString misspelledWord, in AString replaceWord, in boolean allOccurrences);

pub unsafe fn IgnoreWordAllOccurrences(&self, word: &nsAString) -> nsresult

/**
   * @see nsISpellChecker::IgnoreAll
   */

void IgnoreWordAllOccurrences (in AString word);

pub unsafe fn GetPersonalDictionary(&self) -> nsresult

/**
   * Fills an internal list of words added to the personal dictionary. These
   * words can be retrieved using GetPersonalDictionaryWord()
   *
   * @see nsISpellChecker::GetPersonalDictionary
   * @see GetPersonalDictionaryWord
   */

void GetPersonalDictionary ();

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

/**
   * Used after you call GetPersonalDictionary() to iterate through all the
   * words added to the personal dictionary. Will return the empty string when
   * there are no more words.
   */

AString GetPersonalDictionaryWord ();

pub unsafe fn AddWordToDictionary(&self, word: &nsAString) -> nsresult

/**
   * Adds a word to the current personal dictionary.
   *
   * @see nsISpellChecker::AddWordToDictionary
   */

void AddWordToDictionary (in AString word);

pub unsafe fn RemoveWordFromDictionary(&self, word: &nsAString) -> nsresult

/**
   * Removes a word from the current personal dictionary.
   *
   * @see nsISpellChecker::RemoveWordFromPersonalDictionary
   */

void RemoveWordFromDictionary (in AString word);

pub unsafe fn GetDictionaryList(
    &self,
    dictionaryList: *mut *mut *const int16_t,
    count: *mut uint32_t
) -> nsresult

/**
   * Retrieves a list of the currently available dictionaries. The strings will
   * typically be language IDs, like "en-US".
   *
   * @see mozISpellCheckingEngine::GetDictionaryList
   */

void GetDictionaryList ([array, size_is (count)] out wstring dictionaryList, out uint32_t count);

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

/**
   * @see nsISpellChecker::GetCurrentDictionary
   */

AString GetCurrentDictionary ();

pub unsafe fn SetCurrentDictionary(&self, dictionary: &nsAString) -> nsresult

/**
   * @see nsISpellChecker::SetCurrentDictionary
   */

void SetCurrentDictionary (in AString dictionary);

pub unsafe fn UninitSpellChecker(&self) -> nsresult

/**
   * Call this to free up the spell checking object. It will also save the
   * current selected language as the default for future use.
   *
   * If you have called CanSpellCheck but not InitSpellChecker, you can still
   * call this function to clear the cached spell check object, and no
   * preference saving will happen.
   */

void UninitSpellChecker ();

pub unsafe fn SetFilter(&self, filter: *const nsITextServicesFilter) -> nsresult

/**
   * Used to filter the content (for example, to skip blockquotes in email from
   * spellchecking. Call this before calling InitSpellChecker; calling it
   * after initialization will have no effect.
   *
   * @see nsITextServicesDocument::setFilter
   */

void setFilter (in nsITextServicesFilter filter);

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

/**
   * Like CheckCurrentWord, checks the word you give it, returning true if it's
   * misspelled. This is faster than CheckCurrentWord because it does not
   * compute any suggestions.
   *
   * Watch out: this does not clear any suggestions left over from previous
   * calls to CheckCurrentWord, so there may be suggestions, but they will be
   * invalid.
   */

boolean CheckCurrentWordNoSuggest (in AString suggestedWord);

pub unsafe fn UpdateCurrentDictionary(
    &self,
    callback: *const nsIEditorSpellCheckCallback
) -> nsresult

/**
   * Update the dictionary in use to be sure it corresponds to what the editor
   * needs.  The update is asynchronous and is not complete until the given
   * callback is called.
   */

void UpdateCurrentDictionary ([optional] in nsIEditorSpellCheckCallback callback);

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 nsIEditorSpellCheck

const IID: nsIID

IID: nsIID = nsID(2708587103, 58536, 19720, [173, 239, 183, 151, 230, 55, 123, 220])

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 nsIEditorSpellCheck

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIEditorSpellCheck

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.