Jazzy example source code file (JSpellChecker.java)

This example Jazzy source code file (JSpellChecker.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Jazzy tags/keywords

hashtable, integer, integer, interruptedexception, io, ioexception, jspellchecker, jspellchecklistener, jspellchecklistener, spellchecker, spellchecker, string, string, stringtokenizer, stringwordtokenizer, util

The Jazzy JSpellChecker.java source code

/*
Jazzy - a Java library for Spell Checking
Copyright (C) 2001 Mindaugas Idzelis
Full text of license can be found in LICENSE.txt

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
import com.swabunga.spell.engine.Configuration;
import com.swabunga.spell.engine.SpellDictionaryHashMap;
import com.swabunga.spell.event.SpellCheckEvent;
import com.swabunga.spell.event.SpellCheckListener;
import com.swabunga.spell.event.SpellChecker;
import com.swabunga.spell.event.StringWordTokenizer;

import java.applet.Applet;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

public class JSpellChecker extends Applet {

  private class JSpellCheckListener extends Thread implements SpellCheckListener {
    private JSpellCheckListener(StringWordTokenizer tokens) {
      log(this.hashCode() + ": JSpellCheckListener.init");
      this.tokens = tokens;
    }

    public synchronized void spellingError(SpellCheckEvent event) {
      log(this.hashCode() + ": JSpellCheckListener.spellingError");
      JSpellChecker.this.event = event;
      synchronized (JSpellChecker.this) {
        JSpellChecker.this.notifyAll();
      }
      try {
        this.wait();
      } catch (InterruptedException e) {
      }
    }

    public boolean done() {
      return done;
    }

    public void run() {
      log(this.hashCode() + ": JSpellCheckListener.run");
      done = false;
      checker.checkSpelling(this.tokens);
      done = true;
      synchronized (JSpellChecker.this) {
        JSpellChecker.this.notifyAll();
      }
    }

    private boolean done;
    private StringWordTokenizer tokens;
  }

  public JSpellChecker() {
    initialized = false;
  }

  public void init() {
    log(this.hashCode() + ": JSpellChecker.init");
    String dictionary = getParameter("dictionary");
    checker = new SpellChecker();
    for (StringTokenizer strtok = new StringTokenizer(dictionary, " ;:"); strtok.hasMoreElements();) {
      InputStream is = getClass().getResourceAsStream(strtok.nextToken());
      try {
        checker.addDictionary(new SpellDictionaryHashMap(new InputStreamReader(is)));
      } catch (IOException ex) {
        ex.printStackTrace();
      }
    }
    initialized = true;
  }

  public void setText(String text) {
    log(this.hashCode() + ": JSpellChecker.setText(" + text + ")");
    if (!initialized) throw new java.lang.IllegalStateException("Spellchecker is loading.");
    checker.removeSpellCheckListener(listener);
    tokens = new StringWordTokenizer(text);
    listener = new JSpellCheckListener(tokens);
    checker.addSpellCheckListener(listener);
    checker.reset();
  }

  public void setOptions(int options) {
    //System.out.println("in " + getClass().getName() + ".setOptions(" + Integer.toBinaryString(options) + ")");
    Configuration config = checker.getConfiguration();
    for (int i = 1; i <= 0x20000; i = i << 1) {
      String key = (String) configmap.get(new Integer(i));
      if (key != null) config.setBoolean(key, (options & i) > 0);
    }
  }

  public synchronized boolean check() {
    if (!listener.isAlive()) {
      listener.start();
      try {
        wait();
      } catch (InterruptedException e) {
      }
      return listener.done();
    }
    synchronized (listener) {
      listener.notifyAll();
    }
    try {
      wait();
    } catch (InterruptedException e) {
    }
    return listener.done();
  }

  private String getSuggestionList(List suggestions) {
    String s = "";
    for (Iterator i = suggestions.iterator(); i.hasNext();) {
      com.swabunga.spell.engine.Word element = (com.swabunga.spell.engine.Word) i.next();
      s += element.getWord() + "|";

    }
//        for (int i = 0; i < suggestions.size(); i ++) {
//      s += ((com.swabunga.spell.engine.Word)suggestions.elementAt(i)).getWord() + "|";
//    }
    return s;
  }

  public String getSuggestions() {
    return getSuggestionList(event.getSuggestions());
  }

  public String getSuggestions(String word) {
    return getSuggestionList(checker.getSuggestions(word, 0));
  }

  public String getMisspelledWord() {
    if (event != null)
      return event.getInvalidWord();
    return null;
  }

  public int getCursorPosition() {
    if (event != null)
      return event.getWordContextPosition();
    return 0;
  }

  public void changeWord(String word, boolean all) {
    if (event != null) {
      if (word == null) word = "";
      event.replaceWord(word, all);
    }
  }

  public void ignoreWord(boolean all) {
    if (event != null) {
      event.ignoreWord(all);
    }
  }

//  private String getText(){
//    if (tokens != null)
//      return tokens.getFinalText();
//    return null;
//  }

  protected static void log(String s) {
    System.out.println(s);
  }

  private boolean initialized;
  protected SpellCheckEvent event;
  protected SpellChecker checker;
  private StringWordTokenizer tokens;
  private JSpellCheckListener listener;

//  private static final int CASE_SENSITIVE          = 1;
  private static final int IGNORE_ALL_CAPS_WORD = 2;
  private static final int IGNORE_CAPPED_WORD = 4;
  private static final int IGNORE_MIXED_CASE = 8;
  private static final int IGNORE_MIXED_DIGITS = 16;
//  private static final int IGNORE_NON_ALPHA_WORD   = 32;
  private static final int REPORT_DOUBLED_WORD = 64;
//  private static final int REPORT_MIXED_CASE       = 128;
//  private static final int REPORT_MIXED_DIGITS     = 256;
//  private static final int REPORT_SPELLING         = 512;
//  private static final int REPORT_UNCAPPED         = 1024;
//  private static final int SPLIT_CONTRACTED_WORDS  = 2048;
//  private static final int SPLIT_HYPHENATED_WORDS  = 4096;
//  private static final int SPLIT_WORDS             = 8192;
//  private static final int STRIP_POSSESSIVES       = 16384;
//  private static final int SUGGEST_SPLIT_WORDS     = 32768;
  private static final int IGNORE_DOMAIN_NAMES = 0x10000;
//  private static final int ALLOW_ACCENTED_CAPS     = 0x20000;

  private static Hashtable configmap;

  static {
    configmap = new Hashtable();
    configmap.put(new Integer(IGNORE_MIXED_DIGITS), Configuration.SPELL_IGNOREDIGITWORDS);
    configmap.put(new Integer(IGNORE_DOMAIN_NAMES), Configuration.SPELL_IGNOREINTERNETADDRESSES);
    configmap.put(new Integer(IGNORE_MIXED_CASE), Configuration.SPELL_IGNOREMIXEDCASE);
    configmap.put(new Integer(REPORT_DOUBLED_WORD), Configuration.SPELL_IGNOREMULTIPLEWORDS);
    configmap.put(new Integer(IGNORE_CAPPED_WORD), Configuration.SPELL_IGNORESENTENCECAPITALIZATION);
    configmap.put(new Integer(IGNORE_ALL_CAPS_WORD), Configuration.SPELL_IGNOREUPPERCASE);
  }
}