Newsgroup: it.comp.java
Titolo: Agenda JAVA!!!Ricompensa!

Mi serve urgentemente una agenda stile:
Nome:
Cognome:
Telefono:
E-Mail:
.............con funzione di ricerca. Se qualcuno avesse il sorgente
Java da mandarmi,
mi farebbe un grosso favore. Posso RICOMPENSARE!!!!!!!!!!!!!!!!!!!



Guarda che non siamo il CEPU (he he.. ;-)
Ciao,
 P.
+++ Boing Boom Tschak

 wrote in message 390DAA67...@luna.it...



Ti spedisco queste classi che avevo buttato giů velocemente tempo fa,
scopiazzando codice di esempi vari, per leggere i contatti esportati da
Outlook (non potevo installare Outlook su quella macchina).
Ambiente JDeveloper 3.0 (si tira giů da 
technet.oracle.com
 e sono 200
MB ;-), ma dovrebbe andare bene anche JBuilder (in effetti avevo
cominciato con quello).
Prova a vedere se ti va bene come punto di partenza.
Ciao
Stefano Ferroni
stefano...@hotmail.com
==================================================================
ContattiApp.java
------------------------ CUT HERE --------------------------------
import java.awt.*;
public class ContattiApp {
  boolean packFrame = false;
  // Construct the application
  public ContattiApp() {
    ContattiFrame frame = new ContattiFrame();
    //Pack frames that have useful preferred size info, e.g. from their
layout
    //Validate frames that have preset sizes
    if (packFrame)
      frame.pack();
    else
      frame.validate();
    // Center the frame
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    Dimension frameSize = frame.getPreferredSize();
    if (frameSize.height > screenSize.height)
      frameSize.height = screenSize.height;
    if (frameSize.width > screenSize.width)
      frameSize.width = screenSize.width;
    frame.setLocation((screenSize.width - frameSize.width) / 2,
(screenSize.height - frameSize.height) / 2);
    frame.setVisible(true);
  }
  // Main method
  static public void main(String[] args) {
    new ContattiApp();
  }
}
-------------------------- END -----------------------------------
==================================================================
ContattiFrame.java
------------------------ CUT HERE --------------------------------
import java.awt.*;
import java.awt.event.*;
import borland.jbcl.control.*;
import borland.jbcl.layout.*;
import java.sql.*;
import javax.swing.*;
import com.sun.java.swing.*;
/**
 * Class ContattiFrame
 *
 *
 * @author
 * @version %I%, %G%
 */
public class ContattiFrame extends DecoratedFrame
{
    private static boolean DEBUG = false;
    static String      url           = "jdbc:odbc:contatti";
    BorderLayout       borderLayout1 = new BorderLayout();
    BevelPanel         panel1        = new BevelPanel();
    XYLayout           xYLayout1     = new XYLayout();
    MenuBar            menuBar1      = new MenuBar();
    Menu               menuFile      = new Menu();
    MenuItem           menuFileExit  = new MenuItem();
    Menu               menuHelp      = new Menu();
    MenuItem           menuHelpAbout = new MenuItem();
    JTextField         jTextField1 = new JTextField();
    JLabel             jLabel1     = new JLabel();
    TableSorter        sorter      = new TableSorter();
    JTable             jTable1     = new JTable(sorter);
    JDBCAdapter        dataBase;
    JScrollPane        jScrollPane2 = new JScrollPane();
    Connection         con;
    //------------------------------------------------------------------
-
    // checkFarWarning
    // Checks far and displays warnings. Returns true if a warning
    // existed
    //------------------------------------------------------------------
-
    private boolean checkForWarning(java.sql.SQLWarning warn)
            throws SQLException
    {
        boolean rc = false;
        // If a SQLWarning object was given, display the
        // warning messages. Note that there could be
        // multiple warnings chained together
        if (warn != null)
        {
            System.out.println("\n *** Warning ***\n");
            rc = true;
            while (warn != null)
            {
                System.out.println("SQLState: " + warn.getSQLState());
                System.out.println("Message: " + warn.getMessage());
                System.out.println("Vendor: " + warn.getErrorCode());
                System.out.println("");
                warn = warn.getNextWarning();
            }
        }
        return rc;
    }
    // -----------------------------------------------------------------
-- Il dispResultSet Il Displays alI columns and rows in the given
result set Il-----------------------------------------------------------
--------
    // Construct the frame
    /**
     * Constructor ContattiFrame
     *
     *
     */
    public ContattiFrame()
    {
        try
        {
            jbInit();
            dataBase =
                new JDBCAdapter
(url, "sun.jdbc.odbc.JdbcOdbcDriver", "", "");
            sorter.setModel(dataBase);
            DatabaseMetaData dma = con.getMetaData();
            System.out.println("Url" + dma.getURL());
            System.out.println("Driver" + dma.getDriverName());
            System.out.println("Version" + dma.getDriverVersion());
            System.out.println("");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    // Component initialization
    private void jbInit() throws Exception
    {
        this.setLayout(borderLayout1);
        this.setTitle("Ricerca contatti");
        menuFile.setLabel("File");
        menuFileExit.setLabel("Exit");
        jTextField1.addKeyListener(new java.awt.event.KeyAdapter()
        {
            public void keyReleased(KeyEvent e)
            {
                jTextField1_keyReleased(e);
            }
        });
        jLabel1.setText("Cognome");
        menuFileExit.addActionListener(new
ContattiFrame_menuFileExit_ActionAdapter(this));
        menuFile.add(menuFileExit);
        menuHelp.setLabel("Help");
        menuHelpAbout.setLabel("About");
        menuHelpAbout.addActionListener(new
ContattiFrame_menuHelpAbout_ActionAdapter(this));
        this.setMenuBar(menuBar1);
        this.setSize(new Dimension(595, 305));
        panel1.setLayout(xYLayout1);
        menuHelp.add(menuHelpAbout);
        menuBar1.add(menuFile);
        menuBar1.add(menuHelp);
        this.add(panel1, BorderLayout.CENTER);
        panel1.add(jTextField1, new XYConstraints(115, 39, 172, -1));
        panel1.add(jLabel1, new XYConstraints(30, 42, -1, -1));
        panel1.add(jTable1, new XYConstraints(11, 72, -1, -1));
        jScrollPane2 = JTable.createScrollPaneForTable(jTable1);
        jTable1.addMouseListener(new java.awt.event.MouseAdapter()
            {
                public void mouseClicked(MouseEvent e)
                {
                    jTable1_mouseClicked(e);
                }
            });
        panel1.add(jScrollPane2, new XYConstraints(30, 92, 525, 173));
    }
    //File | Exit action performed
    /**
     * Method fileExit_actionPerformed
     *
     *
     * @param e
     *
     */
    public void fileExit_actionPerformed(ActionEvent e)
    {
        System.exit(0);
    }
    //Help | About action performed
    /**
     * Method helpAbout_actionPerformed
     *
     *
     * @param e
     *
     */
    public void helpAbout_actionPerformed(ActionEvent e) {}
    /**
     * Method jTextField1_keyReleased
     *
     *
     * @param e
     *
     */
    void jTextField1_keyReleased(KeyEvent e)
    {
        String query =
            "SELECT nome, cognome, ufficio, abitazione, cellulare  from
contatti where cognome like '"
            + jTextField1.getText() + "%' order by cognome";
        //String query = "SELECT * from contatti";
        if (DEBUG)
        {
            System.out.println(query);
        }
        dataBase.executeQuery(query);
    }
    /**
     * Class ContattiFrame_menuFileExit_ActionAdapter
     *
     *
     * @author
     * @version %I%, %G%
     */
    class ContattiFrame_menuFileExit_ActionAdapter implements
ActionListener
    {
        ContattiFrame adaptee;
        /**
         * Constructor ContattiFrame_menuFileExit_ActionAdapter
         *
         *
         * @param adaptee
         *
         */
        ContattiFrame_menuFileExit_ActionAdapter(ContattiFrame adaptee)
        {
            this.adaptee = adaptee;
        }
        /**
         * Method actionPerformed
         *
         *
         * @param e
         *
         */
        public void actionPerformed(ActionEvent e)
        {
            adaptee.fileExit_actionPerformed(e);
        }
    }
    /**
     * Class ContattiFrame_menuHelpAbout_ActionAdapter
     *
     *
     * @author
     * @version %I%, %G%
     */
    class ContattiFrame_menuHelpAbout_ActionAdapter implements
ActionListener
    {
        ContattiFrame adaptee;
        /**
         * Constructor ContattiFrame_menuHelpAbout_ActionAdapter
         *
         *
         * @param adaptee
         *
         */
        ContattiFrame_menuHelpAbout_ActionAdapter(ContattiFrame adaptee)
        {
            this.adaptee = adaptee;
        }
        /**
         * Method actionPerformed
         *
         *
         * @param e
         *
         */
        public void actionPerformed(ActionEvent e)
        {
            adaptee.helpAbout_actionPerformed(e);
        }
    }
    /**
     * Method jTable1_mouseClicked
     *
     *
     * @param e
     *
     */
    void jTable1_mouseClicked(MouseEvent e)
    {
        if (DEBUG)
        {
            System.out.println("" + e.getPoint() + "|"
                           + jTable1.rowAtPoint(e.getPoint()) + "|"
                           + jTable1.columnAtPoint(e.getPoint()));
        }
    }
}
-------------------------- END -----------------------------------
==================================================================
JDBCAdapter.java
------------------------ CUT HERE --------------------------------
/*
 * @(#)JDBCAdapter.java	1.6 98/02/10
 *
 * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
THE
 * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 *
 */
/**
 * An adaptor, transforming the JDBC interface to the TableModel
interface.
 *
 * @version 1.20 09/25/97
 * @author Philip Milne
 */
// package welcome;
import java.util.Vector;
import java.sql.*;
import javax.swing.table.AbstractTableModel;
import javax.swing.event.TableModelEvent;
public class JDBCAdapter extends AbstractTableModel {
    Connection          connection;
    Statement           statement;
    ResultSet           resultSet;
    String[]            columnNames = {};
    Class[]             columnTpyes = {};
    Vector		rows = new Vector();
    ResultSetMetaData   metaData;
    public JDBCAdapter(String url, String driverName,
                       String user, String passwd) {
        try {
            Class.forName(driverName);
            System.out.println("Opening db connection");
            connection = DriverManager.getConnection(url, user, passwd);
            statement = connection.createStatement();
        }
        catch (ClassNotFoundException ex) {
            System.err.println("Cannot find the database driver
classes.");
            System.err.println(ex);
        }
        catch (SQLException ex) {
            System.err.println("Cannot connect to this database.");
            System.err.println(ex);
        }
     }
    public void executeQuery(String query) {
        if (connection == null || statement == null) {
            System.err.println("There is no database to execute the
query.");
            return;
        }
        try {
            resultSet = statement.executeQuery(query);
            metaData = resultSet.getMetaData();
            int numberOfColumns =  metaData.getColumnCount();
            columnNames = new String[numberOfColumns];
            // Get the column names and cache them.
            // Then we can close the connection.
            for(int column = 0; column < numberOfColumns; column++) {
                columnNames[column] = metaData.getColumnLabel(column+1);
            }
            // Get all rows.
            rows = new Vector();
            while (resultSet.next()) {
                Vector newRow = new Vector();
                for (int i = 1; i <= getColumnCount(); i++) {
	            newRow.addElement(resultSet.getObject(i));
                }
                rows.addElement(newRow);
            }
            //  close(); Need to copy the metaData, bug in jdbc:odbc
driver.
            fireTableChanged(null); // Tell the listeners a new table
has arrived.
        }
        catch (SQLException ex) {
            System.err.println(ex);
        }
    }
    public void close() throws SQLException {
        System.out.println("Closing db connection");
        resultSet.close();
        statement.close();
        connection.close();
    }
    protected void finalize() throws Throwable {
        close();
        super.finalize();
    }
    ////////////////////////////////////////////////////////////////////
//////
    //
    //             Implementation of the TableModel Interface
    //
    ////////////////////////////////////////////////////////////////////
//////
    // MetaData
    public String getColumnName(int column) {
        if (columnNames[column] != null) {
            return columnNames[column];
        } else {
            return "";
        }
    }
    public Class getColumnClass(int column) {
        int type;
        try {
            type = metaData.getColumnType(column+1);
        }
        catch (SQLException e) {
            return super.getColumnClass(column);
        }
        switch(type) {
        case Types.CHAR:
        case Types.VARCHAR:
        case Types.LONGVARCHAR:
            return String.class;
        case Types.BIT:
            return Boolean.class;
        case Types.TINYINT:
        case Types.SMALLINT:
        case Types.INTEGER:
            return Integer.class;
        case Types.BIGINT:
            return Long.class;
        case Types.FLOAT:
        case Types.DOUBLE:
            return Double.class;
        case Types.DATE:
            return java.sql.Date.class;
        default:
            return Object.class;
        }
    }
    public boolean isCellEditable(int row, int column) {
        try {
            return metaData.isWritable(column+1);
        }
        catch (SQLException e) {
            return false;
        }
    }
    public int getColumnCount() {
        return columnNames.length;
    }
    // Data methods
    public int getRowCount() {
        return rows.size();
    }
    public Object getValueAt(int aRow, int aColumn) {
        Vector row = (Vector)rows.elementAt(aRow);
        return row.elementAt(aColumn);
    }
    public String dbRepresentation(int column, Object value) {
        int type;
        if (value == null) {
            return "null";
        }
        try {
            type = metaData.getColumnType(column+1);
        }
        catch (SQLException e) {
            return value.toString();
        }
        switch(type) {
        case Types.INTEGER:
        case Types.DOUBLE:
        case Types.FLOAT:
            return value.toString();
        case Types.BIT:
            return ((Boolean)value).booleanValue() ? "1" : "0";
        case Types.DATE:
            return value.toString(); // This will need some conversion.
        default:
            return "\""+value.toString()+"\"";
        }
    }
    public void setValueAt(Object value, int row, int column) {
        try {
            String tableName = metaData.getTableName(column+1);
            // Some of the drivers seem buggy, tableName should not be
null.
            if (tableName == null) {
                System.out.println("Table name returned null.");
            }
            String columnName = getColumnName(column);
            String query =
                "update "+tableName+
                " set "+columnName+" = "+dbRepresentation(column, value)
+
                " where ";
            // We don't have a model of the schema so we don't know the
            // primary keys or which columns to lock on. To demonstrate
            // that editing is possible, we'll just lock on everything.
            for(int col = 0; col<getColumnCount(); col++) {
                String colName = getColumnName(col);
                if (colName.equals("")) {
                    continue;
                }
                if (col != 0) {
                    query = query + " and ";
                }
                query = query + colName +" = "+
                    dbRepresentation(col, getValueAt(row, col));
            }
            System.out.println(query);
            System.out.println("Not sending update to database");
            // statement.executeQuery(query);
        }
        catch (SQLException e) {
            //     e.printStackTrace();
            System.err.println("Update failed");
        }
        Vector dataRow = (Vector)rows.elementAt(row);
        dataRow.setElementAt(value, column);
    }
}
-------------------------- END -----------------------------------
==================================================================
TableMap.java
------------------------ CUT HERE --------------------------------
/*
 * @(#)TableMap.java	1.4 97/12/17
 *
 * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
THE
 * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 *
 */
/**
 * In a chain of data manipulators some behaviour is common. TableMap
 * provides most of this behavour and can be subclassed by filters
 * that only need to override a handful of specific methods. TableMap
 * implements TableModel by routing all requests to its model, and
 * TableModelListener by routing all events to its listeners. Inserting
 * a TableMap which has not been subclassed into a chain of table
filters
 * should have no effect.
 *
 * @version 1.4 12/17/97
 * @author Philip Milne */
// package welcome;
import javax.swing.table.*;
import javax.swing.event.TableModelListener;
import javax.swing.event.TableModelEvent;
public class TableMap extends AbstractTableModel implements
TableModelListener
{
    protected TableModel model;
    public TableModel  getModel() {
        return model;
    }
    public void  setModel(TableModel model) {
        this.model = model;
        model.addTableModelListener(this);
    }
    // By default, Implement TableModel by forwarding all messages
    // to the model.
    public Object getValueAt(int aRow, int aColumn) {
        return model.getValueAt(aRow, aColumn);
    }
    public void setValueAt(Object aValue, int aRow, int aColumn) {
        model.setValueAt(aValue, aRow, aColumn);
    }
    public int getRowCount() {
        return (model == null) ? 0 : model.getRowCount();
    }
    public int getColumnCount() {
        return (model == null) ? 0 : model.getColumnCount();
    }
    public String getColumnName(int aColumn) {
        return model.getColumnName(aColumn);
    }
    public Class getColumnClass(int aColumn) {
        return model.getColumnClass(aColumn);
    }
    public boolean isCellEditable(int row, int column) {
         return model.isCellEditable(row, column);
    }
//
// Implementation of the TableModelListener interface,
//
    // By default forward all events to all the listeners.
    public void tableChanged(TableModelEvent e) {
        fireTableChanged(e);
    }
}
-------------------------- END -----------------------------------
==================================================================
TableSorter.java
------------------------ CUT HERE --------------------------------
/*
 * @(#)TableSorter.java	1.5 97/12/17
 *
 * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
THE
 * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 *
 */
/**
 * A sorter for TableModels. The sorter has a model (conforming to
TableModel)
 * and itself implements TableModel. TableSorter does not store or copy
 * the data in the TableModel, instead it maintains an array of
 * integers which it keeps the same size as the number of rows in its
 * model. When the model changes it notifies the sorter that something
 * has changed eg. "rowsAdded" so that its internal array of integers
 * can be reallocated. As requests are made of the sorter (like
 * getValueAt(row, col) it redirects them to its model via the mapping
 * array. That way the TableSorter appears to hold another copy of the
table
 * with the rows in a different order. The sorting algorthm used is
stable
 * which means that it does not move around rows when its comparison
 * function returns 0 to denote that they are equivalent.
 *
 * @version 1.5 12/17/97
 * @author Philip Milne
 */
// package welcome;
import java.util.*;
import javax.swing.table.TableModel;
import javax.swing.event.TableModelEvent;
// Imports for picking up mouse events from the JTable.
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.InputEvent;
import javax.swing.JTable;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
public class TableSorter extends TableMap
{
    int             indexes[];
    Vector          sortingColumns = new Vector();
    boolean         ascending = true;
    int compares;
    public TableSorter()
    {
        indexes = new int[0]; // For consistency.
    }
    public TableSorter(TableModel model)
    {
        setModel(model);
    }
    public void setModel(TableModel model) {
        super.setModel(model);
        reallocateIndexes();
    }
    public int compareRowsByColumn(int row1, int row2, int column)
    {
        Class type = model.getColumnClass(column);
        TableModel data = model;
        // Check for nulls
        Object o1 = data.getValueAt(row1, column);
        Object o2 = data.getValueAt(row2, column);
        // If both values are null return 0
        if (o1 == null && o2 == null) {
            return 0;
        }
        else if (o1 == null) { // Define null less than everything.
            return -1;
        }
        else if (o2 == null) {
            return 1;
        }
/* We copy all returned values from the getValue call in case
an optimised model is reusing one object to return many values.
The Number subclasses in the JDK are immutable and so will not be used
in
this way but other subclasses of Number might want to do this to save
space and avoid unnecessary heap allocation.
*/
        if (type.getSuperclass() == java.lang.Number.class)
            {
                Number n1 = (Number)data.getValueAt(row1, column);
                double d1 = n1.doubleValue();
                Number n2 = (Number)data.getValueAt(row2, column);
                double d2 = n2.doubleValue();
                if (d1 < d2)
                    return -1;
                else if (d1 > d2)
                    return 1;
                else
                    return 0;
            }
        else if (type == java.util.Date.class)
            {
                Date d1 = (Date)data.getValueAt(row1, column);
                long n1 = d1.getTime();
                Date d2 = (Date)data.getValueAt(row2, column);
                long n2 = d2.getTime();
                if (n1 < n2)
                    return -1;
                else if (n1 > n2)
                    return 1;
                else return 0;
            }
        else if (type == String.class)
            {
                String s1 = (String)data.getValueAt(row1, column);
                String s2    = (String)data.getValueAt(row2, column);
                int result = s1.compareTo(s2);
                if (result < 0)
                    return -1;
                else if (result > 0)
                    return 1;
                else return 0;
            }
        else if (type == Boolean.class)
            {
                Boolean bool1 = (Boolean)data.getValueAt(row1, column);
                boolean b1 = bool1.booleanValue();
                Boolean bool2 = (Boolean)data.getValueAt(row2, column);
                boolean b2 = bool2.booleanValue();
                if (b1 == b2)
                    return 0;
                else if (b1) // Define false < true
                    return 1;
                else
                    return -1;
            }
        else
            {
                Object v1 = data.getValueAt(row1, column);
                String s1 = v1.toString();
                Object v2 = data.getValueAt(row2, column);
                String s2 = v2.toString();
                int result = s1.compareTo(s2);
                if (result < 0)
                    return -1;
                else if (result > 0)
                    return 1;
                else return 0;
            }
    }
    public int compare(int row1, int row2)
    {
        compares++;
        for(int level = 0; level < sortingColumns.size(); level++)
            {
                Integer column = (Integer)sortingColumns.elementAt
(level);
                int result = compareRowsByColumn(row1, row2,
column.intValue());
                if (result != 0)
                    return ascending ? result : -result;
            }
        return 0;
    }
    public void  reallocateIndexes()
    {
        int rowCount = model.getRowCount();
        // Set up a new array of indexes with the right number of
elements
        // for the new data model.
        indexes = new int[rowCount];
        // Initialise with the identity mapping.
        for(int row = 0; row < rowCount; row++)
            indexes[row] = row;
    }
    public void tableChanged(TableModelEvent e)
    {
	System.out.println("Sorter: tableChanged");
        reallocateIndexes();
        super.tableChanged(e);
    }
    public void checkModel()
    {
        if (indexes.length != model.getRowCount()) {
            System.err.println("Sorter not informed of a change in
model.");
        }
    }
    public void  sort(Object sender)
    {
        checkModel();
        compares = 0;
        // n2sort();
        // qsort(0, indexes.length-1);
        shuttlesort((int[])indexes.clone(), indexes, 0, indexes.length);
        System.out.println("Compares: "+compares);
    }
    public void n2sort() {
        for(int i = 0; i < getRowCount(); i++) {
            for(int j = i+1; j < getRowCount(); j++) {
                if (compare(indexes[i], indexes[j]) == -1) {
                    swap(i, j);
                }
            }
        }
    }
    // This is a home-grown implementation which we have not had time
    // to research - it may perform poorly in some circumstances. It
    // requires twice the space of an in-place algorithm and makes
    // NlogN assigments shuttling the values between the two
    // arrays. The number of compares appears to vary between N-1 and
    // NlogN depending on the initial order but the main reason for
    // using it here is that, unlike qsort, it is stable.
    public void shuttlesort(int from[], int to[], int low, int high) {
        if (high - low < 2) {
            return;
        }
        int middle = (low + high)/2;
        shuttlesort(to, from, low, middle);
        shuttlesort(to, from, middle, high);
        int p = low;
        int q = middle;
        /* This is an optional short-cut; at each recursive call,
        check to see if the elements in this subset are already
        ordered.  If so, no further comparisons are needed; the
        sub-array can just be copied.  The array must be copied rather
        than assigned otherwise sister calls in the recursion might
        get out of sinc.  When the number of elements is three they
        are partitioned so that the first set, [low, mid), has one
        element and and the second, [mid, high), has two. We skip the
        optimisation when the number of elements is three or less as
        the first compare in the normal merge will produce the same
        sequence of steps. This optimisation seems to be worthwhile
        for partially ordered lists but some analysis is needed to
        find out how the performance drops to Nlog(N) as the initial
        order diminishes - it may drop very quickly.  */
        if (high - low >= 4 && compare(from[middle-1], from[middle]) <=
0) {
            for (int i = low; i < high; i++) {
                to[i] = from[i];
            }
            return;
        }
        // A normal merge.
        for(int i = low; i < high; i++) {
            if (q >= high || (p < middle && compare(from[p], from[q])
<= 0)) {
                to[i] = from[p++];
            }
            else {
                to[i] = from[q++];
            }
        }
    }
    public void swap(int i, int j) {
        int tmp = indexes[i];
        indexes[i] = indexes[j];
        indexes[j] = tmp;
    }
    // The mapping only affects the contents of the data rows.
    // Pass all requests to these rows through the mapping
array: "indexes".
    public Object getValueAt(int aRow, int aColumn)
    {
        checkModel();
        return model.getValueAt(indexes[aRow], aColumn);
    }
    public void setValueAt(Object aValue, int aRow, int aColumn)
    {
        checkModel();
        model.setValueAt(aValue, indexes[aRow], aColumn);
    }
    public void sortByColumn(int column) {
        sortByColumn(column, true);
    }
    public void sortByColumn(int column, boolean ascending) {
        this.ascending = ascending;
        sortingColumns.removeAllElements();
        sortingColumns.addElement(new Integer(column));
        sort(this);
        super.tableChanged(new TableModelEvent(this));
    }
    // There is no-where else to put this.
    // Add a mouse listener to the Table to trigger a table sort
    // when a column heading is clicked in the JTable.
    public void addMouseListenerToHeaderInTable(JTable table) {
        final TableSorter sorter = this;
        final JTable tableView = table;
        tableView.setColumnSelectionAllowed(false);
        MouseAdapter listMouseListener = new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                TableColumnModel columnModel = tableView.getColumnModel
();
                int viewColumn = columnModel.getColumnIndexAtX(e.getX
());
                int column = tableView.convertColumnIndexToModel
(viewColumn);
                if(e.getClickCount() == 1 && column != -1) {
                    System.out.println("Sorting ...");
                    int shiftPressed = e.getModifiers()
&InputEvent.SHIFT_MASK;
                    boolean ascending = (shiftPressed == 0);
                    sorter.sortByColumn(column, ascending);
                }
             }
         };
        JTableHeader th = tableView.getTableHeader();
        th.addMouseListener(listMouseListener);
    }
}
-------------------------- END -----------------------------------
==================================================================
TrovaContatti.java
------------------------ CUT HERE --------------------------------
//package welcome;
import java.awt.*;
public class TrovaContatti {
  boolean packFrame = false;
  // Construct the application
  public TrovaContatti() {
    WelcomeFrame frame = new WelcomeFrame();
    //Pack frames that have useful preferred size info, e.g. from their
layout
    //Validate frames that have preset sizes
    if (packFrame)
      frame.pack();
    else
      frame.validate();
    // Center the frame
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    Dimension frameSize = frame.getPreferredSize();
    if (frameSize.height > screenSize.height)
      frameSize.height = screenSize.height;
    if (frameSize.width > screenSize.width)
      frameSize.width = screenSize.width;
    frame.setLocation((screenSize.width - frameSize.width) / 2,
(screenSize.height - frameSize.height) / 2);
    frame.setVisible(true);
  }
  // Main method
  static public void main(String[] args) {
    new WelcomeFrame();
  }
}
-------------------------- END -----------------------------------
Sent via Deja.com 
http://www.deja.com/
Before you buy.