public void addListaProdutos(List lista) {
	SQLiteDatabase db = dh.getWritableDatabase();
 
	db.beginTransaction();
 
	for (Produto produto : lista) {
		ContentValues values = getProdutoValues(produto);
		db.insert(getNomeTabela(), null, values);
	}
 
	db.setTransactionSuccessful();
	db.endTransaction();
	db.close();
}

package br.com.oslunaticos.util;
 
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.swing.table.AbstractTableModel;
 
/**
 *
 * @author Eduardo Folly
 */
public class GenericResultSetModel extends AbstractTableModel {
 
    private List lista = new ArrayList();
    private String[] colunas;
 
    public GenericResultSetModel(ResultSet rs) throws SQLException {
        ResultSetMetaData rsmd = rs.getMetaData();
 
        int cols = rsmd.getColumnCount();
 
        int[] tipos = new int[cols];
        colunas = new String[cols];
 
        for (int c = 1; c <= cols; c++) {
            tipos[c - 1] = rsmd.getColumnType(c);
            colunas[c - 1] = rsmd.getColumnName(c);
        }
 
        while (rs.next()) {
            Object[] objs = new Object[cols];
 
            for (int c = 1; c <= cols; c++) {
                int tipo = tipos[c - 1];
 
                if (tipo == java.sql.Types.VARCHAR) {
                    objs[c - 1] = rs.getString(c);
                } else if (tipo == java.sql.Types.FLOAT) {
                    objs[c - 1] = rs.getFloat(c);
                } else {
                    objs[c - 1] = rs.getObject(c);
                }
            }
 
            lista.add(objs);
        }
    }
 
    @Override
    public int getRowCount() {
        return lista.size();
    }
 
    @Override
    public int getColumnCount() {
        return colunas.length;
    }
 
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        Object[] row = lista.get(rowIndex);
        return row[columnIndex];
    }
 
    @Override
    public String getColumnName(int column) {
        return colunas[column];
    }
}

package br.com.oslunaticos;
 
import com.stibocatalog.hunspell.Hunspell.Dictionary;
import java.awt.Color;
import javax.swing.text.JTextComponent;
 
/**
 *
 * @author Eduardo Folly
 */
public class Spellcheck {
 
    private final UnderlineHighlighter high;
    private final Dictionary dictionary;
    private final JTextComponent textComponent;
 
    public Spellcheck(JTextComponent textComponent, Dictionary dictionary) {
        this.textComponent = textComponent;
 
        // Dicionário
        this.dictionary = dictionary;
 
        // Marcador
        high = new UnderlineHighlighter(Color.red);
        textComponent.setHighlighter(high);
 
        // Document Listener
        SpellcheckDocumentListener sdl = new SpellcheckDocumentListener(this);
        textComponent.getDocument().addDocumentListener(sdl);
 
        // Mouse Adapter
        SpellcheckMouseAdapter sma = new SpellcheckMouseAdapter(this);
        textComponent.addMouseListener(sma);
    }
 
    public Dictionary getDictionary() {
        return dictionary;
    }
 
    public String getText() {
        return textComponent.getText();
    }
 
    public UnderlineHighlighter getHighlighter() {
        return high;
    }
 
    public JTextComponent getTextComponent() {
        return textComponent;
    }
}

package br.com.oslunaticos;
 
import java.awt.*;
import javax.swing.text.*;
 
/**
 *
 * @author Eduardo Folly
 */
public class UnderlineHighlighter extends DefaultHighlighter {
 
    private Highlighter.HighlightPainter painter;
 
    /*
     *
     */
    public UnderlineHighlighter() {
        this(Color.red);
    }
 
    /*
     *
     */
    public UnderlineHighlighter(Color color) {
        painter = new UnderlineHighlightPainter(color);
    }
 
    /*
     *
     */
    public Object addHighlight(int p0, int p1) throws BadLocationException {
        return super.addHighlight(p0, p1, painter);
    }
 
    /*
     *
     */
    @Override
    public void setDrawsLayeredHighlights(boolean newValue) {
        if (!newValue) {
            throw new IllegalArgumentException(
                    "Só é possível desenhar em camadas de destaque.");
        }
        super.setDrawsLayeredHighlights(newValue);
    }
 
    /*
     *
     */
    public static class UnderlineHighlightPainter extends LayeredHighlighter.LayerPainter {
 
        protected Color color;
 
        /*
         *
         */
        public UnderlineHighlightPainter(Color color) {
            this.color = color;
        }
 
        /*
         *
         */
        @Override
        public Shape paintLayer(Graphics g, int p0, int p1, Shape viewBounds, JTextComponent editor, View view) {
            g.setColor(color);
 
            Rectangle alloc;
            if (p0 == view.getStartOffset() && p1 == view.getEndOffset()) {
                if (viewBounds instanceof Rectangle) {
                    alloc = (Rectangle) viewBounds;
                } else {
                    alloc = viewBounds.getBounds();
                }
            } else {
                try {
                    Shape shape = view.modelToView(p0, Position.Bias.Forward, p1, Position.Bias.Backward, viewBounds);
                    if (shape instanceof Rectangle) {
                        alloc = (Rectangle) shape;
                    } else {
                        alloc = shape.getBounds();
                    }
                } catch (BadLocationException e) {
                    return null;
                }
            }
 
            FontMetrics fm = editor.getFontMetrics(editor.getFont());
 
            int baseline = alloc.y + alloc.height - fm.getDescent() + 1;
 
            for (int i = alloc.x; i < alloc.x + alloc.width; i += 2) {
                if (i % 4 == 0) {
                    g.drawLine(i, baseline, i + 1, baseline);
                } else {
                    g.drawLine(i, baseline + 1, i + 1, baseline + 1);
                }
            }
            return alloc;
        }
 
        /*
         *
         */
        @Override
        public void paint(Graphics g, int p0, int p1, Shape bounds, JTextComponent c) {
            //throw new UnsupportedOperationException("Not supported yet.");
        }
    }
}

package br.com.oslunaticos;
 
import com.stibocatalog.hunspell.Hunspell;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.BadLocationException;
 
/**
 *
 * @author Eduardo Folly
 */
public class SpellcheckDocumentListener implements DocumentListener {
 
    private int ativa = 2;
    private int cont = 0;
    private Thread t;
    private Spellcheck spellcheck;
 
    /*
     *
     */
    public SpellcheckDocumentListener(Spellcheck spellcheck) {
        this.spellcheck = spellcheck;
    }
 
    /*
     *
     */
    @Override
    public void insertUpdate(DocumentEvent e) {
        ativa(e);
    }
 
    /*
     *
     */
    @Override
    public void removeUpdate(DocumentEvent e) {
        ativa(e);
    }
 
    /*
     *
     */
    @Override
    public void changedUpdate(DocumentEvent e) {
        ativa(e);
    }
 
    /*
     *
     */
    private void ativa(DocumentEvent e) {
        cont = 0;
        if (t == null) {
            t = new Thread(new Ativador());
            t.start();
        } else {
            if (t.getState().equals(Thread.State.TERMINATED)) {
                t = new Thread(new Ativador());
                t.start();
            }
        }
    }
 
    /*
     *
     */
    private class Ativador implements Runnable {
 
        /*
         *
         */
        @Override
        public void run() {
            while (cont < ativa) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {
                }
                cont++;
            }
            UnderlineHighlighter high = spellcheck.getHighlighter();
            high.removeAllHighlights();
 
            String texto = "";
 
            try {
                texto = spellcheck.getText();
            } catch (Exception ex) {
            }
 
            if (texto.trim().isEmpty()) {
                return;
            }
 
            Hunspell.Dictionary d = spellcheck.getDictionary();
 
            texto = Palavra.clearWord(texto);
 
            SpellcheckSplit ss = new SpellcheckSplit(texto);
            while (ss.hasMoreTokens()) {
                Palavra p = ss.nextToken();
 
                String word = p.getPalavra();
 
                if (d.misspelled(word)) {
                    try {
                        high.addHighlight(p.getIni(), p.getFim());
                    } catch (BadLocationException ex) {
                    }
                }
            }
        }
    }
}

package br.com.oslunaticos;
 
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Iterator;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.text.JTextComponent;
 
/**
 *
 * @author Eduardo Folly
 */
public class SpellcheckMouseAdapter extends MouseAdapter {
 
    private Spellcheck spellcheck;
 
    public SpellcheckMouseAdapter(Spellcheck spellcheck) {
        this.spellcheck = spellcheck;
    }
 
    @Override
    public void mousePressed(MouseEvent e) {
        positionCaret(e);
    }
 
    @Override
    public void mouseReleased(MouseEvent e) {
        positionCaret(e);
    }
 
    private void positionCaret(MouseEvent e) {
        if (e.isPopupTrigger()) {
 
            JPopupMenu popup = new JPopupMenu();
            final JTextComponent text = spellcheck.getTextComponent();
 
            Point p = new Point(e.getX(), e.getY());
            int i = text.getUI().viewToModel(text, p);
            text.getCaret().setDot(i);
 
            try {
                int count = i - 1;
                String c;
 
                try {
                    do {
                        count--;
                        c = text.getText(count, 1);
                    } while (!c.trim().isEmpty());
                } catch (Exception ex) {
                    count = -1;
                }
 
                final int ini = count + 1;
 
                count = i;
                try {
                    do {
                        count++;
                        c = text.getText(count, 1);
                    } while (!c.trim().isEmpty());
                } catch (Exception ex) {
                    return;
                }
 
                int fim = count;
 
                final String wordIni = text.getText(ini, fim - ini);
                final String word = Palavra.clearWord(wordIni).trim();
 
                if (spellcheck.getDictionary().misspelled(word)) {
                    popup.removeAll();
 
                    JMenuItem menuItem = new JMenuItem("Sugestões:");
                    menuItem.setEnabled(false);
                    popup.add(menuItem);
 
                    Iterator itr =
                            spellcheck.getDictionary().suggest(word).iterator();
 
                    while (itr.hasNext()) {
                        String sugest = itr.next();
                        menuItem = new JMenuItem(sugest);
                        menuItem.addActionListener(new ActionListener() {
 
                            @Override
                            public void actionPerformed(ActionEvent e) {
 
                                char pri = word.charAt(0);
                                int count = 0;
                                while (pri != wordIni.charAt(count)) {
                                    count++;
                                }
 
                                JMenuItem menuItem = (JMenuItem) e.getSource();
 
                                substitui(text, ini + count, word, menuItem.getText());
                            }
                        });
                        popup.add(menuItem);
                    }
 
                    if (popup.getComponentCount() < 2) {
                        popup.removeAll();
                        menuItem = new JMenuItem("Sem sugestões.");
                        menuItem.setEnabled(false);
                        popup.add(menuItem);
                    }
 
                    popup.show(e.getComponent(), e.getX(), e.getY());
                }
 
            } catch (Exception ex) {
            }
        }
    }
 
    /*
     *
     */
    private void substitui(JTextComponent text, int ini, String de, String para) {
        try {
            text.getDocument().remove(ini, de.length());
            text.getDocument().insertString(ini, para, null);
        } catch (Exception e) {
        }
    }
}

package br.com.oslunaticos;
 
import java.util.Enumeration;
import java.util.NoSuchElementException;
 
/**
*
* @author Eduardo Folly
*
* Fork de StringTokenizer
*/
public class SpellcheckSplit implements Enumeration<Object> {
 
    private int currentPosition;
    private int newPosition;
    private int maxPosition;
    private String str;
    private String delimiters;
    private boolean retDelims;
    private boolean delimsChanged;
    private int maxDelimCodePoint;
    private boolean hasSurrogates = false;
    private int[] delimiterCodePoints;
 
    /*
     *
     */
    public SpellcheckSplit(String str) {
        currentPosition = 0;
        newPosition = -1;
        delimsChanged = false;
        this.str = str;
        maxPosition = str.length();
        delimiters = " \t\n\r\f";
        retDelims = false;
        setMaxDelimCodePoint();
    }
 
    /*
     *
     */
    private void setMaxDelimCodePoint() {
        if (delimiters == null) {
            maxDelimCodePoint = 0;
            return;
        }
 
        int m = 0;
        int c;
        int count = 0;
        for (int i = 0; i < delimiters.length(); i += Character.charCount(c)) {
            c = delimiters.charAt(i);
            if (c >= Character.MIN_HIGH_SURROGATE && c <= Character.MAX_LOW_SURROGATE) {
                c = delimiters.codePointAt(i);
                hasSurrogates = true;
            }
            if (m < c) {
                m = c;
            }
            count++;
        }
        maxDelimCodePoint = m;
 
        if (hasSurrogates) {
            delimiterCodePoints = new int[count];
            for (int i = 0, j = 0; i < count; i++, j += Character.charCount(c)) {
                c = delimiters.codePointAt(j);
                delimiterCodePoints[i] = c;
            }
        }
    }
 
    /*
     *
     */
    private int skipDelimiters(int startPos) {
        if (delimiters == null) {
            throw new NullPointerException();
        }
 
        int position = startPos;
        while (!retDelims && position < maxPosition) {
            if (!hasSurrogates) {
                char c = str.charAt(position);
                if ((c > maxDelimCodePoint) || (delimiters.indexOf(c) < 0)) {
                    break;
                }
                position++;
            } else {
                int c = str.codePointAt(position);
                if ((c > maxDelimCodePoint) || !isDelimiter(c)) {
                    break;
                }
                position += Character.charCount(c);
            }
        }
        return position;
    }
 
    /*
     *
     */
    private int scanToken(int startPos) {
        int position = startPos;
        while (position < maxPosition) {
            if (!hasSurrogates) {
                char c = str.charAt(position);
                if ((c <= maxDelimCodePoint) && (delimiters.indexOf(c) >= 0)) {
                    break;
                }
                position++;
            } else {
                int c = str.codePointAt(position);
                if ((c <= maxDelimCodePoint) && isDelimiter(c)) {
                    break;
                }
                position += Character.charCount(c);
            }
        }
        if (retDelims && (startPos == position)) {
            if (!hasSurrogates) {
                char c = str.charAt(position);
                if ((c <= maxDelimCodePoint) && (delimiters.indexOf(c) >= 0)) {
                    position++;
                }
            } else {
                int c = str.codePointAt(position);
                if ((c <= maxDelimCodePoint) && isDelimiter(c)) {
                    position += Character.charCount(c);
                }
            }
        }
        return position;
    }
 
    /*
     *
     */
    private boolean isDelimiter(int codePoint) {
        for (int i = 0; i < delimiterCodePoints.length; i++) {
            if (delimiterCodePoints[i] == codePoint) {
                return true;
            }
        }
        return false;
    }
 
    /*
     *
     */
    public boolean hasMoreTokens() {
        newPosition = skipDelimiters(currentPosition);
        return (newPosition < maxPosition);
    }
 
    /*
     *
     */
    public Palavra nextToken() {
        currentPosition = (newPosition >= 0 && !delimsChanged)
        ? newPosition : skipDelimiters(currentPosition);
 
        delimsChanged = false;
        newPosition = -1;
 
        if (currentPosition >= maxPosition) {
            throw new NoSuchElementException();
        }
        int start = currentPosition;
        currentPosition = scanToken(currentPosition);
 
        String texto = str.substring(start, currentPosition);
        Palavra palavra = new Palavra(start, currentPosition, texto);
 
        return palavra;
    }
 
    /*
     *
     */
    @Override
    public boolean hasMoreElements() {
        return hasMoreTokens();
    }
 
    /*
     *
     */
    @Override
    public Object nextElement() {
        return nextToken();
    }
 
    /*
     *
     */
    public int countTokens() {
        int count = 0;
        int currpos = currentPosition;
        while (currpos < maxPosition) {
            currpos = skipDelimiters(currpos);
            if (currpos >= maxPosition) {
                break;
            }
            currpos = scanToken(currpos);
            count++;
       }
       return count;
    }
}

package br.com.oslunaticos;
 
/**
 *
 * @author Eduardo Folly
 */
public class Palavra {
 
    int ini;
    int fim;
    String palavra;
 
    public Palavra(int ini, int fim, String palavra) {
        this.ini = ini;
        this.fim = fim;
        this.palavra = palavra;
    }
 
    public int getFim() {
        return fim;
    }
 
    public void setFim(int fim) {
        this.fim = fim;
    }
 
    public int getIni() {
        return ini;
    }
 
    public void setIni(int ini) {
        this.ini = ini;
    }
 
    public String getPalavra() {
        return palavra;
    }
 
    public void setPalavra(String palavra) {
        this.palavra = palavra;
    }
 
    @Override
    public String toString() {
        return "Palavra{" + "ini=" + ini + ", fim=" + fim + ", palavra=" + palavra + '}';
    }
 
    /*
     *
     */
    public static String clearWord(String text) {
        String troca = "!@#$%&*()_+=,.;:/?[]{}<>\\–";
        for (int i = 0; i < troca.length(); i++) {
            char c = troca.charAt(i);
            text = text.replace(c, ' ');
        }
 
        text = text.replaceAll(" - ", "   ");
 
        return text;
    }
}

Dictionary dictionary = null;
 
String dir = System.getProperty("user.dir");
dir = dir + File.separator + "dict" + File.separator + "pt_BR";
try {
    dictionary = Hunspell.getInstance().getDictionary(dir);
} catch (Exception ex) {
    ex.printStackTrace();
}

new Spellcheck(jTextArea1, dictionary);
new Spellcheck(jTextPane1, dictionary);
new Spellcheck(jEditorPane1, dictionary);
new Spellcheck(jTextField1, dictionary);
new Spellcheck(jFormattedTextField1, dictionary);
new Spellcheck(jPasswordField1, dictionary);

package testprocessing;
 
import processing.core.PApplet;
 
/**
*
* @author Eduardo Folly
*/
public class TestProcessing extends PApplet {
 
    /*
     *
     */
    @Override
    public void setup() {
        size(640, 480);
    }
 
   /*
    *
    */
    @Override
    public void draw() {
        background(0);
        rectMode(CENTER);
        fill(0xFFFFAA99);
        rect(mouseX, mouseY, 100, 100);
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        PApplet.main(new String[] { "testprocessing.TestProcessing" });
    }
}

package sigaws.ws;
 
import java.io.ByteArrayOutputStream;
import java.util.Collections;
import java.util.Set;
import javax.xml.namespace.QName;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPMessage;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.ws.handler.MessageContext;
import javax.xml.ws.handler.soap.SOAPHandler;
import javax.xml.ws.handler.soap.SOAPMessageContext;
 
/**
 *
 * @author Eduardo Folly
 */
public class SigaHandler implements SOAPHandler {
 
    @Override
    public boolean handleMessage(SOAPMessageContext messageContext) {
        boolean outbound = (Boolean) messageContext.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);
 
        if (outbound) {
            try {
                SOAPMessage msg = messageContext.getMessage();
 
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                msg.writeTo(baos);
                String teste = baos.toString(getMessageEncoding(msg));
                teste = teste.replaceAll("S:", "soap:");
                teste = teste.replaceAll("S=", "soap=");
 
                Source src = new StreamSource(new java.io.StringReader(teste));
                msg.getSOAPPart().setContent(src);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return true;
    }
 
    @Override
    public Set getHeaders() {
        return Collections.EMPTY_SET;
    }
 
    @Override
    public boolean handleFault(SOAPMessageContext messageContext) {
        return true;
    }
 
    @Override
    public void close(MessageContext context) {
    }
 
    private String getMessageEncoding(SOAPMessage msg) throws SOAPException {
        String encoding = "utf-8";
        if (msg.getProperty(SOAPMessage.CHARACTER_SET_ENCODING) != null) {
            encoding = msg.getProperty(SOAPMessage.CHARACTER_SET_ENCODING).toString();
        }
        return encoding;
    }
}