defaulttablemodel.java

Java banking application with GUI add/delete/update new account partially generic GUI

import javax.swing.table.*;
import java.sql.*;
import java.io.Serializable;
import java.util.Vector;
import java.util.Enumeration;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;

public class DefaultTableModel extends AbstractTableModel {


    protected Vector dataVector;
    protected Vector columnIdentifiers;


    public DefaultTableModel() {
        this(0, 0);

    }

    public DefaultTableModel(int rowCount, int columnCount) {
        this(newVector(columnCount), rowCount);
        addTableModelListener(new TableModelHandler());
    }


    public DefaultTableModel(Vector columnNames, int rowCount) {
        setDataVector(newVector(rowCount), columnNames);
        addTableModelListener(new TableModelHandler());
    }


    public DefaultTableModel(Object[] columnNames, int rowCount) {
        this(convertToVector(columnNames), rowCount);
        addTableModelListener(new TableModelHandler());
	}

    public DefaultTableModel(Vector data, Vector columnNames) {
        setDataVector(data, columnNames);
        addTableModelListener(new TableModelHandler());
	}

    public DefaultTableModel(Object[][] data, Object[] columnNames) {
        setDataVector(data, columnNames);
        addTableModelListener(new TableModelHandler());
	}

    public DefaultTableModel(ResultSet rs) throws SQLException
    {
		ResultSetMetaData rsMeta;
        rsMeta = rs.getMetaData();
        int columnCount = rsMeta.getColumnCount();

		this.columnIdentifiers= new Vector();
        for(int col=1;col<=columnCount;col++)
            this.columnIdentifiers.add(rsMeta.getColumnName(col));

        this.dataVector=new Vector();
        while(rs.next())
        {
            Vector rowData=new Vector();
            for(int col=1;col<=columnCount;col++)
                rowData.add(rs.getObject(col));
            this.dataVector.add(rowData);
        }
        addTableModelListener(new TableModelHandler());
    }

    public String getColumnIdentifier(int index)
    {
		return (String)this.columnIdentifiers.get(index);
	}

	public void setColumnIdentifier(int index,String columnName)
	{
		this.columnIdentifiers.set(index,columnName);
		fireTableStructureChanged();
	}

    public Vector getDataVector() {
        return dataVector;
    }

    private static Vector nonNullVector(Vector v) {
	return (v != null) ? v : new Vector();
    }


    public void setDataVector(Vector dataVector, Vector columnIdentifiers) {
		System.out.println("DefaultTableModel()");
        this.dataVector = nonNullVector(dataVector);
        this.columnIdentifiers = nonNullVector(columnIdentifiers);
	justifyRows(0, getRowCount());
        fireTableStructureChanged();
    }

    private static Vector newVector(int size) {
		System.out.println("DefaultTableModel()");
	Vector v = new Vector(size);
	v.setSize(size);
	return v;
    }

    public void setDataVector(Object[][] dataVector, Object[] columnIdentifiers) {
        setDataVector(convertToVector(dataVector), convertToVector(columnIdentifiers));
    }


    private void justifyRows(int from, int to) {
		dataVector.setSize(getRowCount());

        for (int i = from; i < to; i++) {
	    if (dataVector.elementAt(i) == null) {
		dataVector.setElementAt(new Vector(), i);
	    }
	    ((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
	}
    }

    public void newRowsAdded(TableModelEvent e) {
        justifyRows(e.getFirstRow(), e.getLastRow() + 1);
        fireTableChanged(e);
    }

    public void rowsRemoved(TableModelEvent event) {
        fireTableChanged(event);
    }

    public void setNumRows(int rowCount) {
        int old = getRowCount();
	if (old == rowCount) {
	    return;
	}
	dataVector.setSize(rowCount);
        if (rowCount <= old) {
            fireTableRowsDeleted(rowCount, old-1);
        }
        else {
	    justifyRows(old, rowCount);
            fireTableRowsInserted(old, rowCount-1);
        }
    }


    public void setRowCount(int rowCount) {
	setNumRows(rowCount);
    }

    public void addRow(Vector rowData) {
        insertRow(getRowCount(), rowData);
    }

    public void addRow(Object[] rowData) {
        addRow(convertToVector(rowData));
    }

    public void insertRow(int row, Vector rowData) {
	dataVector.insertElementAt(rowData, row);
	justifyRows(row, row+1);
        fireTableRowsInserted(row, row);
    }

    public void insertRow(int row, Object[] rowData) {
        insertRow(row, convertToVector(rowData));
    }

    private static int gcd(int i, int j) {
	return (j == 0) ? i : gcd(j, i%j);
    }

    private static void rotate(Vector v, int a, int b, int shift) {
	int size = b - a;
	int r = size - shift;
	int g = gcd(size, r);
	for(int i = 0; i < g; i++) {
	    int to = i;
	    Object tmp = v.elementAt(a + to);
	    for(int from = (to + r) % size; from != i; from = (to + r) % size) {
		v.setElementAt(v.elementAt(a + from), a + to);
		to = from;
	    }
	    v.setElementAt(tmp, a + to);
	}
    }


    public void removeRow(int row) {
        dataVector.removeElementAt(row);
  //      fireTableRowsDeleted(row, row);
  	fireTableStructureChanged();
    }

    public void setColumnIdentifiers(Vector columnIdentifiers) {
	setDataVector(dataVector, columnIdentifiers);
    }

    public void setColumnIdentifiers(Object[] newIdentifiers) {
        setColumnIdentifiers(convertToVector(newIdentifiers));
    }

    public void setColumnCount(int columnCount) {
	columnIdentifiers.setSize(columnCount);
	justifyRows(0, getRowCount());
	fireTableStructureChanged();
    }

    public void addColumn(Object columnName) {
        addColumn(columnName, (Vector)null);
    }


    public void addColumn(Object columnName, Vector columnData) {
        columnIdentifiers.addElement(columnName);
	if (columnData != null) {
            int columnSize = columnData.size();
            if (columnSize > getRowCount()) {
	        dataVector.setSize(columnSize);
            }
	    justifyRows(0, getRowCount());
	    int newColumn = getColumnCount() - 1;
	    for(int i = 0; i < columnSize; i++) {
		  Vector row = (Vector)dataVector.elementAt(i);
		  row.setElementAt(columnData.elementAt(i), newColumn);
	    }
	}
        else {
	    justifyRows(0, getRowCount());
        }

        fireTableStructureChanged();
    }

    public void addColumn(Object columnName, Object[] columnData) {
        addColumn(columnName, convertToVector(columnData));
    }

    public int getRowCount() {
        return dataVector.size();
    }

    public int getColumnCount() {
        return columnIdentifiers.size();
    }

    public String getColumnName(int column) {
        Object id = null;
	if (column < columnIdentifiers.size()) {
	    id = columnIdentifiers.elementAt(column);
	}
        return (id == null) ? super.getColumnName(column)
                            : id.toString();
    }

    public boolean isCellEditable(int row, int column) {
		if(column>=1)
			return true;
		else
        	return false;
    }

    public Object getValueAt(int row, int column) {
        Vector rowVector = (Vector)dataVector.elementAt(row);
        return rowVector.elementAt(column);
    }

    public void setValueAt(Object aValue, int row, int column) {
        Vector rowVector = (Vector)dataVector.elementAt(row);
        rowVector.setElementAt(aValue, column);
        fireTableCellUpdated(row, column);
    }

  public Class getColumnClass(int mColIndex)
  {
	int rowIndex = 0;
	Object o = getValueAt(rowIndex, mColIndex);
	if (o == null)
		return Object.class;
	else
		return o.getClass();
	}

    protected static Vector convertToVector(Object[] anArray) {
        if (anArray == null) {
            return null;
	}
        Vector v = new Vector(anArray.length);
        for (int i=0; i < anArray.length; i++) {
            v.addElement(anArray[i]);
        }
        return v;
    }

    protected static Vector convertToVector(Object[][] anArray) {
        if (anArray == null) {
            return null;
	}
        Vector v = new Vector(anArray.length);
        for (int i=0; i < anArray.length; i++) {
            v.addElement(convertToVector(anArray[i]));
        }
        return v;
    }

    private class TableModelHandler implements TableModelListener {
        public void tableChanged(TableModelEvent e) {
//			System.out.println("TableModelHandler");

			if(getColumnCount()>7&&e.getLastRow()!=-1&&e.getColumn()<6)
			{
//				System.out.println(getValueAt(e.getLastRow(),e.getColumn()).toString());
				if(getValueAt(e.getLastRow(),6)==null)
					setValueAt(new Boolean(true),e.getLastRow(),6);
				else if(getValueAt(e.getLastRow(),6).toString().equals("false"))
					setValueAt(new Boolean(true),e.getLastRow(),6);
			}

        }
    }
}