JTable shows previous data

[Suman Mummaneni]

Hi guys,
I have problem with my JTable. I have JDialog. which has a JList a JTable and a Ok, Cancle and Help buttons. I am using custom renderes and editor for the JTable. The JTable gets loaded with different models based on the selection on the JList. But the problem is when the user hits the cancel button and invokes the dialog again and selects the previous menu entry then it displays the old value.
Code for the JDialog

    
 

 
import java.awt.Frame;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Component;
import java.awt.Insets;
import java.awt.Color;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
 
import javax.swing.JPanel;
import javax.swing.JTable;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.ListSelectionModel;
import javax.swing.AbstractCellEditor;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JLabel;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.ListSelectionEvent;
import javax.swing.border.TitledBorder;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.DefaultTableCellRenderer;
 
import java.util.EventObject;
 
import java.io.File;
 
import com.agp.edt.util.EdtDialog;
 
import com.agp.edt.model.EdtPopupMenuItem;
 

class PopupMenuItemsDialog extends EdtDialog implements ListSelectionListener
{
    private JTable attributesTable;
    private JList menuList;
    private EdtPopupMenuItem [] menuItems;
 
    /**
     * Constructs a modal dialog with the specified title, owner dialog, and common buttons.
     *
     * @param owner   the Dialog from which the dialog is displayed
     * @param title   the String to display in the dialog's title bar
     */
    PopupMenuItemsDialog(Frame owner, String title, EdtPopupMenuItem [] menuItem )
    {
        super(owner, title,  OK_CANCEL);
        setHelp( "10039" );
        this.menuItems = menuItem;
        initWidgets( menuItems );
        pack();
        setLocationRelativeTo(owner);
    }
 
    private void initWidgets( EdtPopupMenuItem [] menuItems )
    {
        JPanel menuItemsPanel = new JPanel(new BorderLayout());
        menuItemsPanel.setBorder( new TitledBorder( EdtPropertyEditorString.getString( "MENUTITEMLIST" ) ) );
        Object [] listModel = new Object [ menuItems.length ];
        for( int i=0;i<menuItems.length;i++ )
        {
            listModel[i]=menuItems[i].getText();
        }
        menuList = new JList( listModel );
        menuList.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
        JScrollPane listScrollPane = new JScrollPane(menuList);
        menuList.addListSelectionListener( this );
        menuItemsPanel.add(listScrollPane,BorderLayout.CENTER );
        JPanel attributesPanel = new JPanel(new BorderLayout());
        attributesPanel.setBorder( new TitledBorder( EdtPropertyEditorString.getString( "ATRIBUTESPANELTITLE" ) ) );
        attributesTable = new JTable( );
        JScrollPane attributesScrollPanel = new JScrollPane(attributesTable);
        attributesTable.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
        attributesScrollPanel.setPreferredSize( new Dimension( 250,90 ) );
        attributesPanel.add(attributesScrollPanel,BorderLayout.CENTER );
        contentPanel.setLayout( new BorderLayout() );
        contentPanel.add(menuItemsPanel,BorderLayout.NORTH );
        contentPanel.add(attributesPanel,BorderLayout.SOUTH );
    }
 
    public void valueChanged( ListSelectionEvent e)
    {
        //Create the model and then set the model to the table.
        if( !e.getValueIsAdjusting() )
        {
            int index = menuList.getSelectedIndex();
            if(index>=0)
            {
                BrowseEditor cellEditor = new BrowseEditor( this );
                BrowseRendere cellRenderer = new BrowseRendere();
                AttributesModel model = new AttributesModel( menuItems[ index ] );
                attributesTable.setModel( model );
                attributesTable.setDefaultRenderer( attributesTable.getColumnClass(1), cellRenderer );
                attributesTable.setDefaultEditor( attributesTable.getColumnClass(1), cellEditor );
            }
        }
    }
 
    public void doOkAction()
    {
        super.doOkAction();
    }
 
    public void doCancelAction()
    {
        super.doCancelAction();
    }
 
    EdtPopupMenuItem[] getEdtPopupMenuItems()
    {
        return menuItems;
    }
}
 
class AttributesModel extends AbstractTableModel
{
    private static final String [] columnHeader = {EdtPropertyEditorString.getString("STATIC_POPUP_ATTRIB"),
                                                   EdtPropertyEditorString.getString("STATIC_POPUP_VALUE")};
    private static final String [] commonCells =  {EdtPropertyEditorString.getString("STATIC_POPUP_CELL_1"),
                                                   EdtPropertyEditorString.getString("STATIC_POPUP_CELL_2"),
                                                   EdtPropertyEditorString.getString("STATIC_POPUP_CELL_3")};
    private static final String [] varibleCells = {EdtPropertyEditorString.getString("STATIC_POPUP_CELL_4"),
                                                   EdtPropertyEditorString.getString("STATIC_POPUP_CELL_3_1"),
                                                   EdtPropertyEditorString.getString("STATIC_POPUP_CELL_6"),
                                                   EdtPropertyEditorString.getString("STATIC_POPUP_CELL_2_1"),
                                                   EdtPropertyEditorString.getString("STATIC_POPUP_CELL_2_2"),
                                                   EdtPropertyEditorString.getString("STATIC_POPUP_CELL_2_3")};
 
    private EdtPopupMenuItem menuItem;
    private boolean modified = false;
    /**
     * Consturctor for the Table Model.
     * @param menuItem Object that has to be displayed in the table.
     */
    AttributesModel(EdtPopupMenuItem menuItem )
    {
        if( menuItem !=null )
            this.menuItem = menuItem;
        else
            throw new IllegalStateException();
    }
 

    public String getColumnName( int column )
    {
        return columnHeader[ column ];
    }
 
    public int getColumnCount()
    {
        return columnHeader.length;
    }
 
    public Object getValueAt(int rowIndex, int columnIndex)
    {
        switch( menuItem.getType() )
        {
            case EdtPopupMenuItem.MENU_URL:
                return getValueURL(rowIndex,columnIndex);
 
            case EdtPopupMenuItem.MENU_DOC:
                return getValueDOC(rowIndex,columnIndex);
 
            case EdtPopupMenuItem.MENU_PGM:
                return getValuePGM(rowIndex,columnIndex);
        }
        return null;
    }
 
    /**
     * <P>Helper method that will be called by the getValueAt method for the
     * URL type documents.</P>
     * @param rowIndex
     * @param columnIndex
     * @return the data for the current cell.
     */
    private Object getValueURL( int rowIndex,int columnIndex )
    {
        switch( columnIndex )
        {
            case 0:
                switch( rowIndex )
                {
                    case 0:
                        return commonCells[ 0 ];
                    case 1:
                        return commonCells[ 1 ];
                    case 2:
                        return commonCells[ 2 ];
                    case 3:
                        return varibleCells[ 0 ];
                    default:
                        return null;
                }
           case 1:
                switch( rowIndex )
                {
                    case 0:
                        return menuItem.getText();
                    case 1:
                        return varibleCells[ 3 ];
                    case 2:
                        return menuItem.getActionCommand();
                    case 3:
                        return menuItem.getActionParameter();
                    default:
                        return null;
                }
            default:
                return null;
        }
    }
 
    /**
     * <P>Helper method that will be called by the getValueAt method for the
     * Local documents.</P>
     * @param rowIndex
     * @param columnIndex
     * @return the data for the current cell.
     */
    private Object getValueDOC( int rowIndex,int columnIndex )
    {
        switch( columnIndex )
        {
            case 0:
                switch( rowIndex )
                {
                    case 0:
                        return commonCells[ 0 ];
                    case 1:
                        return commonCells[ 1 ];
                    case 2:
                        return commonCells[ 2 ];
                    default:
                        return null;
                }
           case 1:
                switch( rowIndex )
                {
                    case 0:
                        return menuItem.getText();
                    case 1:
                        return varibleCells[ 4 ];
                    case 2:
                        return menuItem.getActionCommand();
                    default:
                        return null;
                }
            default:
                return null;
        }
    }
 
    /**
     * <P>Helper method that will be called by the getValueAt method for the
     *  Local Programs type.</P>
     * @param rowIndex
     * @param columnIndex
     * @return the data for the current cell.
     */
    private Object getValuePGM( int rowIndex,int columnIndex )
    {
        switch( columnIndex )
        {
            case 0:
                switch( rowIndex )
                {
                    case 0:
                        return commonCells[ 0 ];
                    case 1:
                        return commonCells[ 1 ];
                    case 2:
                        return varibleCells[ 1 ];
                    case 3:
                        return varibleCells[ 2 ];
                    default:
                        return null;
                }
           case 1:
                switch( rowIndex )
                {
                    case 0:
                        return menuItem.getText();
                    case 1:
                        return varibleCells[ 5 ];
                    case 2:
                        return menuItem.getActionCommand();
                    case 3:
                        return menuItem.getActionParameter();
                    default:
                        return null;
                }
            default:
                return null;
        }
    }
 
    /**
     * <P>Specifies which cells can be edited by the user.</P>
     * @param row
     * @param column
     * @return true if the cell is editable otherwise returns false.
     */
    public boolean isCellEditable(int row, int column )
    {
        return !(column == 0 || row == 0 || row == 1);
    }
 
    public int getRowCount()
    {
        switch( menuItem.getType() )
        {
            case EdtPopupMenuItem.MENU_DOC:
                return 3;
 
            case EdtPopupMenuItem.MENU_PGM:
                return 4;
 
            case EdtPopupMenuItem.MENU_URL:
                return 4;
 
            default:
                return -1;
        }
    }
 
    /**
     * <P>This method will be called by the Editor when new values is shown.</P>
     * @param value the value tha has be set to the model.
     * @param rowIndex of the cell
     * @param columnIndex of the cell
     */
    public void setValueAt( Object value, int rowIndex, int columnIndex )
    {
        //Set the values of the
        if( rowIndex == 2 && columnIndex == 1 )
        {
            menuItem.setActionCommand( value.toString() );
            modified = true;
            
        }
        else if ( rowIndex == 3 && columnIndex == 1 )
        {
            menuItem.setActionParameter( value.toString() );
            modified = true;
        }
    }
 
    /**
     * An utility method to know if the table cells are modfied.
     * @return
     */
    public boolean isModified()
    {
        return modified;
    }
 
    /**
     * <P>A utility method to reterive the current menutItem object of the model.</P>
     * @return EdtPopupMenuItem
     */
    EdtPopupMenuItem getMenuItem()
    {
        return menuItem;
    }
}
 

/**
 * The renderer class that defines how the component in the table cell
 * are painted.
 */
final class BrowseRendere extends JLabel implements TableCellRenderer
{
    /**
     * Constructor setup the inital parameters for the cell label
     */
    BrowseRendere()
    {
        setOpaque( true );
    }
 
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
                                                   boolean hasFocus, int row, int column)
    {
        setText( ( value!=null ) ? value.toString() : "" );        
        if( !table.isCellEditable(row,column) )
        {
            DefaultTableCellRenderer c = new DefaultTableCellRenderer();
            c.setText( ((value!=null)?value.toString():"") );
            Color myGray = new Color(236,233,216);
            c.setBackground( myGray );
            c.setForeground( Color.BLACK );
            return c;
        }
        else
        {
            setEnabled( true );
            setBackground( Color.WHITE );
            setOpaque( true );
            return this;
        }
    }
}
 

/**
 * The editor class that will define how the data in the cell has be shown and
 * what components will be used for that.
 */
final class BrowseEditor extends AbstractCellEditor implements TableCellEditor, ActionListener
{
    //Editor component that has to be displayed in the table cell
    private JTextField textPart;
    private JButton browseButton;
    private EdtDialog parent;
    private AttributesModel model;
    private int currentRow =-1;
    private Object value;
    private TextButtonCell component;
 
    /**
     * Constructor that initilizes the Editor component
     * @param owner the parent dialog on which the JTable is present.
     */
    BrowseEditor( EdtDialog owner )
    {
        this.parent = owner;
        textPart = new JTextField();
        JTextField text = new JTextField();
        browseButton = new JButton("...");
        browseButton.setOpaque( false );
        browseButton.setMargin( new Insets( 1, 1, 1, 1 ) );
        browseButton.addActionListener( this );
        component = new TextButtonCell(text, browseButton );
    }
 
    public boolean shouldSelectCell( EventObject obj)
    {
        return true;
    }
 
    /**
     * This method returns the value of the table cell. This will also
     * check if the size of the text in the cell is greater than 128 charcters
     * if so it will set the initilize the cell to a zero lenght string.
     * @return an <code>Object</code> that contains the value of the cell.
     */
    public Object getCellEditorValue()
    {
        String editorText;
        if( model.getMenuItem().getType() == EdtPopupMenuItem.MENU_URL )
        {
            editorText = textPart.getText();
        }
        else
        {
            editorText = component.getText();
        }
 
        if( !EdtDevicePropertyEditorPanel.validateLength( editorText, EdtDevicePropertyEditorPanel.MESSAGE_LENGTH ) )
        {
                EdtDialog.showMessageDialog(parent, EdtPropertyEditorString.getString( "VALID_MSG" ),
                        EdtPropertyEditorString.getString( "MSG_TITLE" ),
                        EdtDialog.ERROR_MESSAGE);
                return "";
        }
        else
        {
            if( currentRow == 2 & model.getMenuItem().getType()!=EdtPopupMenuItem.MENU_URL)
            {
                return component.getText();
            }
            else
            {
                return textPart.getText();
            }
        }
    }
 
    /**
     * <P>The method that will return the <code>JComponent</code> that will be used in the
     * table cell. This method will be called by the JTable to use that component in the
     * table cell.</P>
     * @param table the JTable that is calling this method.
     * @param value the current value in that cell of the JTable.
     * @param isSelected if the cell has to rendered seperately.
     * @param row the row value of the cell.
     * @param column the column value of the cell.
     * @return <code>JComponent</code> that will be used in the table cell.
     */
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column)
    {
        this.model = (AttributesModel)table.getModel();
        this.currentRow = row;
        this.value = value;
        if( row == 2 && column == 1 && model.getMenuItem().getType() != EdtPopupMenuItem.MENU_URL )
        {
            component.setText( ( (value!=null)? value.toString() : "" ) );
            return component;
        }
        else
        {
            textPart.setText( ( (value!=null)? value.toString() : "" ) );
            return textPart;
        }
    }
 
    /**
     * Implementation of the method in <code> ActionListener</code> interface.
     * @param e the acion event that is generated by the component on which the event occured.
     */
    public void actionPerformed( ActionEvent e )
    {
        int retValue = -1;
        //Initilize the file chooser.
        JFileChooser fileChooser = new JFileChooser( ".\\networks\\" );
        fileChooser.setDialogType( JFileChooser.OPEN_DIALOG );
        fileChooser.setFileSelectionMode( JFileChooser.FILES_AND_DIRECTORIES );
        fileChooser.setFileFilter( fileChooser.getAcceptAllFileFilter() );
        fileChooser.setMultiSelectionEnabled( false );
        fileChooser.setAcceptAllFileFilterUsed( true );
        if( e.getSource() == browseButton )
        {
            textPart.setText( (value != null)? value.toString() : "" );
            retValue = fileChooser.showOpenDialog( parent );
            fireEditingStopped();
        }
        //Set the file name if the user choosen
        if( retValue == JFileChooser.APPROVE_OPTION )
        {
            File selection = fileChooser.getSelectedFile();
            component.setText( selection.getPath() );
            if( model!=null )
            {
                model.setValueAt( component.getText(), 2, 1 );
            } 
        }
    }
}
 

/**
 * The panel component that will be used in the table cell that will
 * include a button and a text field.
 */
class TextButtonCell extends JPanel {
 
    JTextField text;
    TextButtonCell( JTextField textField,JButton button )
    {
        text = textField;
        setLayout( new BorderLayout() );
        add( text, BorderLayout.CENTER );
        add( button, BorderLayout.LINE_END );
    }
 
    void setText( String data )
    {
        text.setText( data );
    }
 
    String getText()
    {
        return text.getText();
    }
}

The invocation of this dialog is done here.

    
    SwingUtilities.invokeLater( new Runnable() {
                    public void run() {
                        PopupMenuItemsDialog dlg = new PopupMenuItemsDialog(rootFrame,
                               EdtPropertyEditorString.getString( "POPUPMENUDLGTITLE" ),menuItems);
                        dlg.setVisible( true );
                        if( dlg.getDismissOption() == EdtDialog.OK_OPTION )
                        {
                            try {
                                deviceIterator.setPopupMenuItems( dlg.getEdtPopupMenuItems() );
                            }
                            catch( IOException e )
                            {
                                EdtDialog.showMessageDialog(rootFrame, e.getMessage()
                                        , EdtPropertyExceptionString.getString("SERVER_TITLE"), EdtDialog.ERROR_MESSAGE);
                            }
                            finally
                            {
                                setCursor( null );
                            }
 
                        }
                        dlg.dispose();
                        dlg = null;
                }
                });

thanks in advance.

[Craig Wood]

I stubbed–in the missing classes and got your code running. I am unable to replicate the
situation you described. Each time the dialog opens the list has the items in it and the
table is blank. Selecting any list item loads the table with four rows: the rows with
index of zero and 2 in the right–hand column show the selected list item every time.
Clicking either of the OK or Cancel buttons does not seem to alter the result. I am not
able to get a previously–selected or wrong value in the table.