Hi All,

What the table is suppose to do.
- Load information from a database
- put all the values in the first column
- in the second column put combobox (cell editor with numbers 1-12)
- the 3rd column put another combobox for something else
- the 4th column uses checkbox as an edit

The number of rows of the table should be equal to the number of
record from
the database. If not given it default to 20 (poor but ok for this)
The number of columns is 4.

But the table does not show any rows or column when I put it inside a
JScrollPane (Otherwise it works).

Please help,
thanks in advance.
*******************************THE
TABLE*************************************
package com.school.academic.ui;

import java.awt.Dimension;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;

import javax.swing.DefaultCellEditor;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;

import com.jgoodies.looks.plastic.Plastic3DLookAndFeel;

public class SubjectTable extends JTable {
    /**
    * Comment for <code>serialVersionUID</code>
    */
    private static final long serialVersionUID = 1L;

    /** combo for the list of classes */
    protected JComboBox classCombo;

    /** combo for the list of subjects */
    protected JComboBox subjectsCombo;

    /** combo for the list of grade */
    protected JComboBox gradeCombo;

    //
    boolean canResize = false;

    boolean canReorder = false;

    boolean canSelectRow = false;

    boolean canSelectCell = true;

    boolean canSelectColumn = true;

    // the row height of the table
    int rowHeight = 22;

    // the height of the table
    int height = 200;

    // the width of the table
    int width = 300;

    // the size of the table
    Dimension size;

    /**
    * Parameterless constructor. Class the one of the other constructors
to
    * create a table with the a new <code>SubjectTableModel</code>.
    */
    public SubjectTable() {
        this(new SubjectTableModel());
    }

    /**
    * Copy constructor to create the table with the given
    * <code>SubjectTableModel</code>
    *
    * @param tableModel -
    *            the <code>SubjectTableModel</code> with which to
initialise
    *            the table.
    */
    SubjectTable(SubjectTableModel tableModel) {
        setModel(tableModel);
        setupTable();
    }

    /**
    * Function to setup the table's functionality
    */
    private void setupTable() {

        clear();

        // set the row hieght
        this.setRowHeight(this.rowHeight);

        // set the font size to 12
        //TODO this.setFont(Settings.getDefaultFont());

        // disble reordering of columns
        this.getTableHeader().setReorderingAllowed(this.canReorder);

        // disble resing of columns
        this.getTableHeader().setResizingAllowed(this.canResize);

        // enable the horizontal scrollbar
        this.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

        // disable row selection
        setRowSelectionAllowed(this.canSelectRow);

        // disable column selection
        setColumnSelectionAllowed(this.canSelectColumn);

        // enable cell selection
        setCellSelectionEnabled(this.canSelectCell);

        setPreferredScrollableViewportSize(getSize());

        TableColumn columns = null;
        int cols = getColumnCount();
        for (int col = 0; col < cols; col++) {
            columns = getColumnModel().getColumn(col);
            switch (col) {
            case 0:// subject name column
                columns.setPreferredWidth(130);
                break;
            case 1:// grade column
                columns.setPreferredWidth(60);
                break;
            case 2:// class room column
                columns.setPreferredWidth(120);
                break;
            case 3:// select column
                columns.setPreferredWidth(65);
                break;
            } // end switch
        }// end for

        // set up the cell editors
        doGradeColumn();
        doClassColumn();
        //doSubjectColumn();
    }

    /**
    * Function to clear the table selection. This selection is different
to
    * <code>javax.swing.JTable#clearSelection()</code>. It clears the
user
    * input
    *  
    */
    public void clear() {
        for (int row = 0; row < getRowCount(); row++) {
            for (int col = 0; col < getColumnCount(); col++) {
                if (getColumnName(getColumnCount() - 1).equals("Select")) {
                    setValueAt(new Boolean(false), row, getColumnCount() - 1);
                }// if
            }// for col
        }// for row
    }

    /**
    * Function to set the cell renderer for the subjects column. It uses
a
    * combobox as a cell editor in the teacher's subjects table.
    */
    public void doSubjectColumn() {

        TableColumn nameColumn = getColumnModel().getColumn(0);
        nameColumn.setCellEditor(new DefaultCellEditor(getSubjectsCombo()));

        // set up the celll renderer
        DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
        renderer.setToolTipText("Click for drop down list");
        nameColumn.setCellRenderer(renderer);

        // Set up tool tip for the sport column header.
        TableCellRenderer headerRenderer = nameColumn.getHeaderRenderer();
        if (headerRenderer instanceof DefaultTableCellRenderer) {
            ((DefaultTableCellRenderer) headerRenderer)
                    .setToolTipText("Click the Name to see a list of choices");
        }
    }// end doSubjectsColumn----------------------------------------------

    /** Function to set up the grade combo box. */

    public void doGradeColumn() {

        TableColumn gradeColumn = getColumnModel().getColumn(1);
        gradeColumn.setCellEditor(new DefaultCellEditor(getGradeCombo()));

        DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
        renderer.setToolTipText("Click for drop down list");
        gradeColumn.setCellRenderer(renderer);

        // Set up tool tip for the sport column header.
        TableCellRenderer headerRenderer = gradeColumn.getHeaderRenderer();
        if (headerRenderer instanceof DefaultTableCellRenderer) {
            ((DefaultTableCellRenderer) headerRenderer)
                    .setToolTipText("Click the Grade to see a list of choices");
        }

    }// end doGradeColumn-------------------------------------------------

    /**
    * Function to setup the Class room Column of the subjects
    */
    public void doClassColumn() {

        // set the column for the classroom
        TableColumn classColumn = getColumnModel().getColumn(2);
        classColumn.setCellEditor(new DefaultCellEditor(getClassCombo()));

        DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
        renderer.setToolTipText("Click for drop down list");

        classColumn.setCellRenderer(renderer);

        // Set up tool tip for the sport column header.
        TableCellRenderer headerRenderer = classColumn.getHeaderRenderer();
        if (headerRenderer instanceof DefaultTableCellRenderer) {
            ((DefaultTableCellRenderer) headerRenderer)
                    .setToolTipText("Click the Class to see a list of choices");
        }

    }// end doClassColumn--------------------------------------------------

    /**
    * @param dm
    * @param cm
    */
    public SubjectTable(TableModel dm, TableColumnModel cm) {
        super(dm, cm);
        setupTable();
    }

    /**
    * @param dm
    * @param cm
    * @param sm
    */
    public SubjectTable(TableModel dm, TableColumnModel cm,
            ListSelectionModel sm) {
        super(dm, cm, sm);
        setupTable();
    }

    /**
    * @param numRows
    * @param numColumns
    */
    public SubjectTable(int numRows, int numColumns) {
        super(numRows, numColumns);
        setupTable();
    }

    /**
    * @param rowData
    * @param columnNames
    */
    public SubjectTable(Vector rowData, Vector columnNames) {
        super(rowData, columnNames);
        setupTable();
    }

    /**
    * @param rowData
    * @param columnNames
    */
    public SubjectTable(Object[][] rowData, Object[] columnNames) {
        super(rowData, columnNames);
        setupTable();
    }

    /**
    * Function to get the size of the table
    *
    * @return Returns the size.
    */
    public Dimension getSize() {
        if (this.size == null) {
            this.size = new Dimension(this.height, this.width);
        }
        return this.size;
    }

    /**
    *
    * Function to set the size of the table
    *
    * @param dim
    *            The size to set.
    */
    public void setSize(Dimension dim) {
        if (dim != null) {
            this.size = dim;
            return;
        }
    }

    /**
    * Function to create/setup the class room comboBox. If the comboBox
is
    * <code>null</code> a nwew one is created else the functon returns
the
    * function that was returned initially.
    *
    * @return Returns the classCombo.
    */
    private JComboBox getClassCombo() {
        if (this.classCombo == null) {
            this.classCombo = new JComboBox();

            // fill up the class name combo
            ArrayList classRooms = new ArrayList();
            try {
                //TODO classRooms = Settings.getDatabase().getClassRooms();
                for (int i = 0; i < 10; i++) {
                    String string = new String("Class");
                    string += i;
                }
                if (!classRooms.isEmpty()) {
                    classRooms.trimToSize();
                    for (int i = 0; i < classRooms.size(); i++) {
                        this.classCombo.addItem(classRooms.get(i));
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return this.classCombo;
    }

    /**
    * Function to create/setup the subjects comboBox. If the comboBox is
    * <code>null</code> a nwew one is created else the functon returns
the
    * function that was returned initially.
    *
    * @return Returns the subjectsCombo.
    */
    private JComboBox getSubjectsCombo() {
        if (this.subjectsCombo == null) {
            this.subjectsCombo = new JComboBox();
            try {
                ArrayList subjects = loadSubjectsFromDatabase();
                if (!subjects.isEmpty()) {
                    Iterator iterator = subjects.iterator();
                    while (iterator.hasNext()) {
                        // create a new subject instance
                        //TODO Subject subct = new Subject();

                        // typecast to subject
                        //TODO subct = (Subject) iterator.next();
                        String name = (String) iterator.next();

                        // add this subject to the comboBox
                        //TODO this.subjectsCombo.addItem(subct.getName());
                        subjectsCombo.addItem(name);
                    }// end while
                }// end if
                else {
                    JOptionPane.showMessageDialog(SubjectTable.this,
                            "Subjects List Could Not Be Filled");
                    System.out.println("Subjects List Could Not Be Filled");
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return this.subjectsCombo;
    }

    /**
    * Function to load subjects from the <code>Database</code>
    *
    * @return Returns the subjects.
    */
    private ArrayList loadSubjectsFromDatabase() {

        // list of all the subject that the school does
        ArrayList subjects = new ArrayList();
        try {
            //TODO to be removed later on
            for (int i = 0; i < 10; i++) {
                String string = new String("Subject");
                string += i;
                subjects.add(i, string);
            }
            // set the school subjects
            //TODO subjects = Settings.getDatabase().loadAllSubjects();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return subjects;
    }

    /**
    * Function to create/setup the grade comboBox. If the comboBox is
    * <code>null</code> a nwew one is created else the functon returns
the
    * function that was returned initially.
    *
    * @return Returns the gradeCombo.
    */
    private JComboBox getGradeCombo() {
        if (this.gradeCombo == null) {
            this.gradeCombo = new JComboBox();
            // fill with grade 1 to 12
            for (int i = 12; i > 0; i--) {
                this.gradeCombo.addItem(new Integer(i).toString());
            }
        }
        return this.gradeCombo;
    }

    public static void main(String[] args) {
        try {
            UIManager.setLookAndFeel(new Plastic3DLookAndFeel());
            System.out.println("Look and Feel has been set");
        } catch (UnsupportedLookAndFeelException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        SubjectTableModel model = new SubjectTableModel();
        int cols = model.getColumnCount();
        int rows = model.getRowCount();

        Object[][] subjects = new Object[rows][cols];
        for (int row = 0; row < rows; row++) {
                subjects[row][0] = new String("Subjectv ") + row;
        }//for
        model.setSubjectsList(subjects);
       
        SubjectTable ttest = new SubjectTable(model);
        JFrame frame = new JFrame("::Table Example");
       
        JScrollPane scrollPane = new JScrollPane();
        scrollPane.setViewportView(ttest);

        frame.getContentPane().add(scrollPane);
        frame.pack();
        frame.setVisible(true);
    }
}
**************************************END
TABLE******************************

----------------------------THE TABLE
MODEL----------------------------------
/*
* Created on 2005/03/21
*
* SubjectTableModel
*/
package com.school.academic.ui;

import javax.swing.table.AbstractTableModel;

/**
*
* Class extending the <code>AbstractTableModel</code> for use in
creating the
* <code>Subject</code>s table. In addition to the implemented methods
of
* <code>AbstractTableModel</code> The class creates a model that has
initial
* values - the values have their own <code>getter</code> and
* <code>setter</code> methods - but can still be used for values that
a user
* chooses.
* <p>
*
* @author Khusta
*
*/
public class SubjectTableModel extends AbstractTableModel {
   /**
    * Comment for <code>serialVersionUID</code>
    */
   private static final long serialVersionUID = 3257850978324461113L;

   /** Column names for the subjects table */
   String[] columnNames = { "Subject", "Grade", "Class Room",
"Select" };

   /** Array of objects for the subjects table */
   Object[][] subjectsList;

   private int totalRows = 20;
   
   protected int notEditable = 0;

   /**
    * Parameterless constructor.
    */
   public SubjectTableModel() {
       // TODO initialise the list
       // add column to the default table model
       this.subjectsList = new
Object[getTotalRows()][getColumnNames().length];
   }

   /**
    * Copy constructor with the <code>subjectList</code> to set
    *
    * @param subjects
    */
   public SubjectTableModel(Object[][] subjects) {
       this(0, null, subjects, 0);
   }

   /**
    * Copy constructor with the initial number of row for the model
    *
    * @param rows -
    *            the initial rows of the model
    * @param cols -
    *            the initial columns of the model
    * @param subjects -
    *            the initial subjects for the model
    * @param edit - the minimum number of columns that must be
uneditable
    */
   public SubjectTableModel(int rows, String[] cols, Object[][]
subjects, int edit) {
       // set the initial rows
       setTotalRows(rows);

       // set the column names
       setColumnNames(cols);

       // set the subjectlist
       setSubjectsList(subjects);
       
       //set not editable index
       setNotEditable(edit);
   }

   /**
    * Function to get the total number of columns in the table
    *
    * @return int -- the columns in the table
    */
   public int getColumnCount() {
       if (this.subjectsList == null) {
           return 0;
       }
       return getColumnNames().length;
   }

   /**
    * Function to get the total number of rows in the table
    *
    * @return int -- the rows in the table
    */
   public int getRowCount() {
       if (this.subjectsList == null) {
           return 0;
       }
       return this.subjectsList.length;
   }

   /**
    * Function to get the name of a column in the table.
    *
    * @param col --
    *            the column to be named
    * @return String -- the column in the table
    */
   public String getColumnName(int col) {

       if (getColumnNames()[col] != null) {
           return getColumnNames()[col];
       }
       return new String("...");

   }

   /**
    * Function to get the value of the given row.
    *
    * @param row --
    *            the row of the object.
    * @param col --
    *            the col of the object.
    * @return Object -- the value at row, col.
    */
   public Object getValueAt(int row, int col) {
       return getSubjectsList()[row][col];
   }

   /**
    * Function to return the data type of the given column.
    *
    * @param c --
    *            the column whose type must be determined.
    * @return Class -- the type of the object in this col.
    */
   public Class getColumnClass(int c) {
       if (getValueAt(0, c) != null) {
           return getValueAt(0, c).getClass();
       }
       return new String().getClass();

   }

   /**
    * Function to put a value into a table cell.
    *
    * @param value --
    *            the object that will be put.
    * @param row --
    *            the row that the object will be put.
    * @param col --
    *            the col that the object will be put.
    */
   public void setValueAt(Object value, int row, int col) {

       /**
        * TODO: Have a boolean value to determine whether to clear or
to set.
        * if true clear else set.
        */

       if (value != null) {
           if (getSubjectsList()[0][col] instanceof Integer
                   && !(value instanceof Integer)) {

               try {
                   getSubjectsList()[row][col] = new
Integer(value.toString());
                   fireTableCellUpdated(row, col);

               } catch (NumberFormatException e) {
                   /*
                    * JOptionPane .showMessageDialog( this., "The \""
+
                    * getColumnName(col) + "\" column accepts only
values
                    * between 1 - 12");
                    */
                   return;
               }
           }
           System.out.println("Value = " + value.toString());
           System.out.println("Column = " + col + " Row = " + row);

           // column = Grade or column = Select
           switch (col) {
           case 2:
               try {
                   // TODO
                   if (Boolean.getBoolean(value.toString()) == false
                           && getValueAt(row, 0) != null
                           && getValueAt(row, 1) != null
                           && getValueAt(row, 2) != null) {

                       // subjectsList[row][col + 1] = new
Boolean(true);
                       System.out.println("2. false - Updated...");
                       /*
                        * this.subjectListModel.add(row,
                        * this.subjectsList[row][0] + new String(" -
") +
                        * this.subjectsList[row][2]);
                        */

                   }
               } catch (ArrayIndexOutOfBoundsException exception) {
                   exception.printStackTrace();
               }
               break;
           case 3:
               if (Boolean.getBoolean(value.toString()) == false
                       && getValueAt(row, 0) != null
                       && getValueAt(row, 1) != null
                       && getValueAt(row, 2) != null) {

                   System.out.println("3. If - Added...");
                   getSubjectsList()[row][3] = new Boolean(true);
                   /*
                    *
this.subjectListModel.addElement(this.subjectsList[row][0] +
                    * new String(" - ") + this.subjectsList[row][2]);
                    */

                   // subjectListModel.remove(row);
                   fireTableCellUpdated(row, col);
                   fireTableDataChanged();

                   // this.doDeleteSubject();

               } else if (Boolean.getBoolean(value.toString()) ==
true
                       && getValueAt(row, 0) != null
                       && getValueAt(row, 1) != null
                       && getValueAt(row, 2) != null) {

                   setValueAt("", row, col - 1);
                   setValueAt("", row, col - 2);
                   setValueAt("", row, col - 3);

                   System.out.println("3. Else - Cleared...");
                   // this.subjectListModel.remove(row);

               }
               break;
           default:
               break;
           }// end switch
           getSubjectsList()[row][col] = value;
           fireTableCellUpdated(row, col);
           fireTableDataChanged();

       }// end if

   }// end

   /**
    * Function to enable edition for all the columns in the table
    *
    * @param row --
    *            the row that must be enabled.
    * @param col --
    *            the col that must be enabled.
    *
    * @return boolean -- indicate whether this cell is editble or
not.
    */
   public boolean isCellEditable(int row, int col) {
       if (row >= 0
               && (col >= 0 && col <= getNotEditable())) {
           return false;
       }
       return true;
   }

   /**
    * Function to get the column names for the model
    *
    * @return Returns the columnNames.
    */
   public String[] getColumnNames() {
       return this.columnNames;
   }

   /**
    * Function to set the column names for the model
    *
    * @param cols
    *            The columnNames to set.
    */
   public void setColumnNames(String[] cols) {
       // if the column names are null the default columns are used
       if (cols != null) {
           this.columnNames = cols;
       }
   }

   /**
    * Function to get the rows of subjects for the model
    *
    * @return Returns the subjectsList.
    */
   public Object[][] getSubjectsList() {
       if (this.subjectsList == null) {
           this.subjectsList = new
Object[getTotalRows()][getColumnNames().length];
       }
       return this.subjectsList;
   }

   /**
    * Function to set the subjects list for the model
    *
    * @param subjects
    *            The subjectsList to set.
    */
   public void setSubjectsList(Object[][] subjects) {
       // if the subject list is null create a new one
       // using default values
       if (subjects == null) {
           this.subjectsList = new
Object[getTotalRows()][getColumnNames().length];
           return;
       }
       this.subjectsList = subjects;
   }

   /**
    * Function to get the total number of rows for the model. <b>NB:
</b> This
    * is different to <code>
getRowCount()</code>.<code>totalRows</code>
    * is the initial amount of rows that the model must have before
data can be
    * added.
    *
    * @return Returns the totalRows.
    * @see #setTotalRows(int)
    */
   public int getTotalRows() {
       return this.totalRows;
   }

   /**
    * Function to set the total rows for the model.
    *
    * @param rows
    *            The totalRows to set.
    * @see #getTotalRows()
    */
   public void setTotalRows(int rows) {
       // if the rows are less than 0 the defaultRows are used
       // set getTotalRows
       if (rows > 0) {
           this.totalRows = rows;
       }
   }
   /**
    * Function to get the number of columns that is not editble
    * @return Returns the notEditable.
    */
   public int getNotEditable() {
       return this.notEditable;
   }
   /**
    * Function to set the number of columns that is not editable
    * @param notEdit The notEditable to set.
    */
   public void setNotEditable(int notEdit) {
       if (notEdit < 0) {
           notEdit = 0;
       }
       this.notEditable = notEdit;
   }
}
----------------------------END TABLE
MODEL----------------------------------