import com.swabunga.spell.event.StringWordTokenizer; //导入依赖的package包/类
/**
 * get a list of misspelled words from the text
 * @param text
 */
public List<String> getMisspelledWords(String text) {
    StringWordTokenizer texTok = new StringWordTokenizer(text,
            new TeXWordFinder());
    spellChecker.checkSpelling(texTok);
    return misspelledWords;
}
 

import com.swabunga.spell.event.StringWordTokenizer; //导入依赖的package包/类
public void check(IDocument document, IRegion[] regions, SpellingContext context, 
        ISpellingProblemCollector collector, IProgressMonitor monitor) {
    
    if (ignore == null) {
        ignore = new HashSet<String>();
    }

    IProject project = getProject(document);

    String lang = DEFAULT_LANG;
    if (project != null) {
        lang = TexlipseProperties.getProjectProperty(project, TexlipseProperties.LANGUAGE_PROPERTY);
    }
    //Get spellchecker for the correct language
    SpellChecker spellCheck = getSpellChecker(lang);
    if (spellCheck == null) return;
    
    if (collector instanceof TeXSpellingProblemCollector) {
        ((TeXSpellingProblemCollector) collector).setRegions(regions);
    }
    
    try {
        spellCheck.addSpellCheckListener(this);
        for (final IRegion r : regions) {
            errors = new LinkedList<SpellCheckEvent>();
            int roffset = r.getOffset();
            
            //Create a new wordfinder and initialize it
            TexlipseWordFinder wf = new TexlipseWordFinder();
            wf.setIgnoreComments(TexlipsePlugin.getDefault().getPreferenceStore().getBoolean(TexlipseProperties.SPELLCHECKER_IGNORE_COMMENTS));
            wf.setIgnoreMath(TexlipsePlugin.getDefault().getPreferenceStore().getBoolean(TexlipseProperties.SPELLCHECKER_IGNORE_MATH));
            
            spellCheck.checkSpelling(new StringWordTokenizer(
                    document.get(roffset, r.getLength()), wf));
            
            for (SpellCheckEvent error : errors) {
                SpellingProblem p = new TexSpellingProblem(error, roffset, lang);
                collector.accept(p);
            }
        }
        spellCheck.removeSpellCheckListener(this);                
    } catch (BadLocationException e) {
        e.printStackTrace();
    }
}
 

import com.swabunga.spell.event.StringWordTokenizer; //导入依赖的package包/类
/**
 * WARN in case of spellcheck error using property locale.
 */
public int validate(Property property, List<L10nReportItem> reportItems) {
  Locale locale = property.getLocale();
  if (locale == null) {
    // Case of root bundle
    locale = Locale.ENGLISH;
  }
  SpellChecker spellChecker = spellCheckerLocaleRepository.getSpellChecker(locale);

  if (spellChecker != null) {
    ListSpellCheckErrorListener listener = new ListSpellCheckErrorListener(spellChecker);
    spellChecker.addSpellCheckListener(listener);

    String message = property.getMessage();
    spellChecker.checkSpelling(new StringWordTokenizer(message));

    Collection<SpellCheckError> errors = listener.getSpellCheckErrors();

    // The message with errors replaced by suggestions
    String correction = message;

    // Start from last errors, so that error position remains valid
    SpellCheckError[] errs = errors.toArray(new SpellCheckError[errors.size()]);
    for (int i = errs.length - 1; i >= 0; i--) {
      SpellCheckError error = errs[i];
      if (error.getSuggestion() != null) {
        int pos = error.getPosition();
        correction = StringUtils.overlay(correction, error.getSuggestion(), pos, pos + error.getError().length());
      }
    }

    if (errors.size() > 0) {
      StringBuffer sb = new StringBuffer();
      sb.append("Spellcheck error on word(s): ").append(errors.toString()).append(" and locale <").append(locale).append(">.");
      if (correction != null) {
        sb.append(" Suggested correction: [").append(correction).append("]");
      }

      L10nReportItem reportItem = new L10nReportItem(Type.SPELLCHECK, sb.toString(), property, null);
      reportItems.add(reportItem);
      logger.log(reportItem);
    }

    spellChecker.removeSpellCheckListener(listener);
  }
  return 0;
}
 

import com.swabunga.spell.event.StringWordTokenizer; //导入依赖的package包/类
public String spellCorrect(String text) {
    StringWordTokenizer swt = new StringWordTokenizer(text);
    spellChecker.checkSpelling(swt);
    return swt.getContext();
}
 

import com.swabunga.spell.event.StringWordTokenizer; //导入依赖的package包/类
public void checkWords(String bodyText) {
    mMisspelledWords.clear();
    mSuggestions.clear();
    mOriginalText = bodyText;
    jazzySpellCheck.checkSpelling(new StringWordTokenizer(bodyText)); // *asynchronous
}
 

import com.swabunga.spell.event.StringWordTokenizer; //导入依赖的package包/类
public static int misspelled(String text) throws IOException {
    new FeatureGenerator();
    return spellChecker.checkSpelling(new StringWordTokenizer(text));
}
 

import com.swabunga.spell.event.StringWordTokenizer; //导入依赖的package包/类
public void checkSpelling(String string) {
    if (spellCheck != null) {
        this.errors.clear();
        this.spellCheck.checkSpelling(new StringWordTokenizer(string));
    }
}