IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Composants Java Discussion :

JTable : problème de casts


Sujet :

Composants Java

  1. #1
    Invité
    Invité(e)
    Par défaut JTable : problème de casts
    Bonjour à tous,

    J'ai un problème un peu perturbant, voilà le code, je vous expliquerais en dessous le problème que je rencontre (lisez le code avant histoire que je ne vous influence pas).

    Member.java :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
     
    public class Member
    {
        private int id;
        private String firstname;
        private String lastname;
     
        public Member()
        {
        }
     
        public Member(int id, String firstname, String lastname)
        {
            this.id = id;
            this.firstname = firstname;
            this.lastname = lastname;
        }
     
        public int getId()
        {
            return this.id;
        }
     
        public Member setId(int id)
        {
            this.id = id;
            return this;
        }
     
        public String getFirstname()
        {
            return this.firstname;
        }
     
        public Member setFirstname(String firstname)
        {
            this.firstname = firstname;
            return this;
        }
     
        public String getLastname()
        {
            return this.lastname;
        }
     
        public Member setLastname(String lastname)
        {
            this.lastname = lastname;
            return this;
        }
    }
    MemberTable.java :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
     
    import java.awt.GridBagConstraints;
    import java.awt.GridBagLayout;
    import java.awt.Insets;
     
    import javax.swing.JButton;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
     
    public class MemberTable extends JPanel
    {
        // Buttons
        protected JButton action_add = new JButton("Ajouter");
        protected JButton action_delete = new JButton("Supprimer");
     
        // Titles
        protected JLabel title_top = new JLabel("Membres");
     
        // Content
        protected AbstractTable<Member> gui_content = new AbstractTable<Member>();
        protected MemberModelTable content;
     
         public MemberTable()
         {
            this.setLayout(new GridBagLayout());
            content = new MemberModelTable(this.gui_content);
     
            // Listeners
            this.action_add.addActionListener(new AddTableListener<Member>(this.gui_content));
            this.action_delete.addActionListener(new DeleteTableListener<Member>(this.gui_content));
            new CellListenerTable(this.gui_content.getContent(), new UpdateTableListener<Member>(this.gui_content));
     
            // GUI construction
            this.add(this.title_top, new GridBagConstraints(0,0,2,1, 0, 0, GridBagConstraints.LINE_START, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
            this.add(this.gui_content, new GridBagConstraints(0,1,2,1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
            this.add(this.action_add, new GridBagConstraints(0,2,1,1, 1, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
            this.add(this.action_delete, new GridBagConstraints(1,2,1,1, 1, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
        }
     }
    MemberModelTable.java :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
     
    import java.util.ArrayList;
     
    public class MemberModelTable extends AbstractModelTable<Member>
    {
     
        public MemberModelTable(AbstractTable<Member> content)
        {
            super(content, new ArrayList<String>(), new ArrayList<Member>());
            this.headers.add("Prénom");
            this.headers.add("Nom");
            this.content.setModel(this);
            this.content.getContent().getColumnModel().getColumn(0).setCellEditor(new TextColumnEditor());
            this.content.getContent().getColumnModel().getColumn(1).setCellEditor(new TextColumnEditor());
        }
     
        public Object getValueAt(int rowIndex, int columnIndex)
        {
            switch (columnIndex)
            {
                case 0:
                    return this.lines.get(rowIndex).getFirstname();
                case 1:
                    return this.lines.get(rowIndex).getLastname();
                default:
                    return "";
            }
        }
     
        public void setValueAt(Object aVal, int rowIndex, int columnIndex)
        {
            if (rowIndex < 0)
                return;
     
            switch (columnIndex)
            {
                case 0:
                    this.lines.get(rowIndex).setFirstname(aVal.toString());
                    break;
                case 1:
                    this.lines.get(rowIndex).setLastname(aVal.toString());
                    break;
                default:
                    break;
            }
        }
     
        @Override
        public Class getColumnClass(int columnIndex)
        {
            return Object.class;
        }
     
        @Override
        public Member getModel(int line, int column)
        {
            return null;
        }
     
        @Override
        public Member getModel(int line)
        {
            return this.lines.get(line);
        }
     
        public boolean isCellEditable(int row, int column)
        {
           return true;
        }
     
        @Override
        public MemberModelTable newLine()
        {
            this.lines.add(new Member());
            return this;
        }
     
        @Override
        public int getNextRequiredColumn(int row)
        {
            Member c = this.getModel(row);
            if (c != null)
            {
                if (c.getFirstname() == null || c.getFirstname().length() == 0)
                    return 0;
     
                if (c.getLastname() == null || c.getLastname().length() == 0)
                    return 1;
            }
     
            return -1;
        }
     
        @Override
        public void save(int row)
        {
        }
    }
    AbstractTable.java :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
     
     
    import java.awt.Dimension;
     
    import javax.swing.JScrollPane;
    import javax.swing.JTable;
    import javax.swing.table.AbstractTableModel;
     
    public class AbstractTable extends JScrollPane
    {
        private AbstractModelTable<N> model;
        private JTable content;
        public AbstractTable()
        {
            super();
        }
     
        public AbstractTable<N> setModel(AbstractModelTable<N> model)
        {
            this.model = model;
            this.content = new JTable(this.model);
            this.content.setRowHeight(28);
            this.setViewportView(this.content);
            return this;
        }
     
        public AbstractModelTable<N> getModel()
        {
            return this.model;
        }
     
        public JTable getContent()
        {
            return this.content;
        }
    }
    AbstractModelTable :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
     
     
     
    import java.util.List;
     
    import javax.swing.event.TableModelListener;
    import javax.swing.table.AbstractTableModel;
     
     
    public abstract class AbstractModelTable<N> extends AbstractTableModel
    {
        protected AbstractTable<N> content;
        protected List<N> lines;
        protected List<String> headers;
     
        public AbstractModelTable(AbstractTable<N> content, List<String> headers, List<N> lines)
        {
            super();
            this.content = content;
            this.lines = lines;
            this.headers = headers;
        }
     
        public int getRowCount()
        {
            return lines.size();
        }
     
        public int getColumnCount()
        {
            return headers.size();
        }
     
        public String getColumnName(int columnIndex)
        {
            return headers.get(columnIndex);
        }
     
        public Object getValueAt(int rowIndex, int columnIndex)
        {
            return lines.get(rowIndex);
        }
     
        public AbstractModelTable<N> setLines(List<N> lines)
        {
            this.lines = lines;
            this.fireTableDataChanged();
            return this;
        }
     
        public List<N> getLines()
        {
            return this.lines;
        }
     
        public void removeRow(int row)
        {
            this.lines.remove(row);
     
        }
     
        public AbstractTable<N> getContent()
        {
            return content;
        }
     
        public abstract AbstractModelTable<N> newLine();
     
        public abstract N getModel(int line, int column);
        public abstract N getModel(int line);
        public abstract int getNextRequiredColumn(int row);
        public abstract void save(int row);
    }

    AddTableListener :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
     
    import java.awt.Component;
    import java.awt.Cursor;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.util.List;
     
    /**
     * @author gdifolco
     *
     */
    public class AddTableListener<N> extends AbstractTableListener implements ActionListener
    {
        public AddTableListener(AbstractTable<N> obs)
        {
            super(obs);
        }
     
        @Override
        public void actionPerformed(ActionEvent e)
        {
            this.obs.getModel().newLine().fireTableDataChanged();
            int sel = this.obs.getModel().getNextRequiredColumn(this.obs.getModel().getLines().size() - 1);
     
            if (sel == -1)
                sel = 0;
     
            if (this.obs.getContent().editCellAt(this.obs.getModel().getLines().size() - 1, sel))
                this.obs.getContent().getEditorComponent().requestFocus();
            else if (this.obs.getContent().editCellAt(this.obs.getModel().getLines().size() - 1, sel))
                this.obs.getContent().getEditorComponent().requestFocus();
     
        }
    }
    DeleteTableListener :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
     
     
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
     
     
    public class DeleteTableListener extends AbstractTableListener implements ActionListener
    {
        public DeleteTableListener(AbstractTable obs)
        {
            super(obs);
        }
     
        @Override
        public void actionPerformed(ActionEvent e)
        {
            int[] rows = this.obs.getContent().getSelectedRows();
            for (int i = rows.length - 1; i >= 0; --i)
              this.obs.getModel().removeRow(rows[i]);
     
            this.obs.getModel().fireTableDataChanged();
     
            if (rows.length > 0)
            {
                Integer nb_lines = this.obs.getModel().getLines().size();
                if (nb_lines > 0)
                {
                    if (rows[0] < nb_lines)
                        this.obs.getContent().getSelectionModel().addSelectionInterval(rows[0], rows[0]);
                    else
                        this.obs.getContent().getSelectionModel().addSelectionInterval(nb_lines-1, nb_lines-1);
                }
            }
        }
    }

    AbstractTableListener :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    public class AbstractTableListener
    {
     
        protected AbstractTable obs;
        public AbstractTableListener(AbstractTable obs)
        {
            this.obs = obs;
        }
    }
    UpdateTableListener :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
     
    import java.awt.Component;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.beans.PropertyChangeListener;
     
    import javax.swing.AbstractCellEditor;
    import javax.swing.Action;
    import javax.swing.DefaultCellEditor;
    import javax.swing.JTable;
    import javax.swing.JTextField;
    import javax.swing.event.CellEditorListener;
    import javax.swing.event.ChangeEvent;
    import javax.swing.event.TableModelEvent;
    import javax.swing.event.TableModelListener;
    import javax.swing.table.TableCellEditor;
     
    public class UpdateTableListener<N> extends AbstractTableListener implements Action
    {
        protected boolean enabled;
        public UpdateTableListener(AbstractTable<N> obs)
        {
            super(obs);
            this.enabled = true;
        }
     
        @Override
        public void actionPerformed(ActionEvent e)
        {
            CellListenerTable tcl = (CellListenerTable)e.getSource();
            this.obs.getModel().setValueAt(tcl.getNewValue(), tcl.getRow(), tcl.getColumn());
            int sel = this.obs.getModel().getNextRequiredColumn(tcl.getRow());
     
            if (sel == -1)
                this.obs.getModel().save(tcl.getRow());
            else
                this.obs.getContent().editCellAt(tcl.getRow(), sel);
        }
     
        @Override
        public void addPropertyChangeListener(PropertyChangeListener arg0)
        {
            // TODO Auto-generated method stub
        }
     
        @Override
        public Object getValue(String arg0)
        {
            // TODO Auto-generated method stub
            return null;
        }
     
        @Override
        public boolean isEnabled()
        {
            return this.enabled;
        }
     
        @Override
        public void putValue(String arg0, Object arg1)
        {
            // TODO Auto-generated method stub
     
        }
     
        @Override
        public void removePropertyChangeListener(PropertyChangeListener arg0)
        {
            // TODO Auto-generated method stub
     
        }
     
        @Override
        public void setEnabled(boolean arg0)
        {
            this.enabled = arg0;
     
        }
     
    }

    CellListenerTable :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
     
    import java.awt.event.*;
    import javax.swing.*;
    import java.beans.*;
     
    /*
     *  This class listens for changes made to the data in the table via the
     *  TableCellEditor. When editing is started, the value of the cell is saved
     *  When editing is stopped the new value is saved. When the oold and new
     *  values are different, then the provided Action is invoked.
     *
     *  The source of the Action is a TableCellListener instance.
     */
    public class CellListenerTable implements PropertyChangeListener, Runnable
    {
        private JTable table;
        private Action action;
     
        private int row;
        private int column;
        private Object oldValue;
        private Object newValue;
     
        /**
         *  Create a TableCellListener.
         *
         *  @param table   the table to be monitored for data changes
         *  @param action  the Action to invoke when cell data is changed
         */
        public CellListenerTable(JTable table, Action action)
        {
            this.table = table;
            this.action = action;
            this.table.addPropertyChangeListener( this );
        }
     
        /**
         *  Create a TableCellListener with a copy of all the data relevant to
         *  the change of data for a given cell.
         *
         *  @param row  the row of the changed cell
         *  @param column  the column of the changed cell
         *  @param oldValue  the old data of the changed cell
         *  @param newValue  the new data of the changed cell
         */
        private CellListenerTable(JTable table, int row, int column, Object oldValue, Object newValue)
        {
            this.table = table;
            this.row = row;
            this.column = column;
            this.oldValue = oldValue;
            this.newValue = newValue;
        }
     
        /**
         *  Get the column that was last edited
         *
         *  @return the column that was edited
         */
        public int getColumn()
        {
            return column;
        }
     
        /**
         *  Get the new value in the cell
         *
         *  @return the new value in the cell
         */
        public Object getNewValue()
        {
            return newValue;
        }
     
        /**
         *  Get the old value of the cell
         *
         *  @return the old value of the cell
         */
        public Object getOldValue()
        {
            return oldValue;
        }
     
        /**
         *  Get the row that was last edited
         *
         *  @return the row that was edited
         */
        public int getRow()
        {
            return row;
        }
     
        /**
         *  Get the table of the cell that was changed
         *
         *  @return the table of the cell that was changed
         */
        public JTable getTable()
        {
            return table;
        }
    //
    //  Implement the PropertyChangeListener interface
    //
        @Override
        public void propertyChange(PropertyChangeEvent e)
        {
            //  A cell has started/stopped editing
     
            if ("tableCellEditor".equals(e.getPropertyName()))
            {
                if (table.isEditing())
                    processEditingStarted();
                else
                    processEditingStopped();
            }
        }
     
        /*
         *  Save information of the cell about to be edited
         */
        private void processEditingStarted()
        {
            //  The invokeLater is necessary because the editing row and editing
            //  column of the table have not been set when the "tableCellEditor"
            //  PropertyChangeEvent is fired.
            //  This results in the "run" method being invoked
     
            SwingUtilities.invokeLater( this );
        }
        /*
         *  See above.
         */
        @Override
        public void run()
        {
            row = table.convertRowIndexToModel( table.getEditingRow() );
            column = table.convertColumnIndexToModel( table.getEditingColumn() );
            oldValue = table.getModel().getValueAt(row, column);
            newValue = null;
        }
     
        /*
         *  Update the Cell history when necessary
         */
        private void processEditingStopped()
        {
            newValue = table.getModel().getValueAt(row, column);
     
            //  The data has changed, invoke the supplied Action
     
            if (newValue != null && !newValue.equals(oldValue))
            {
                //  Make a copy of the data in case another cell starts editing
                //  while processing this change
     
                CellListenerTable tcl = new CellListenerTable(
                    getTable(), getRow(), getColumn(), getOldValue(), getNewValue());
     
                ActionEvent event = new ActionEvent(
                    tcl,
                    ActionEvent.ACTION_PERFORMED,
                    "");
                action.actionPerformed(event);
            }
        }
    }

    TextColumnEditor :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
     
    import javax.swing.DefaultCellEditor;
    import javax.swing.JTextField;
     
    public class TextColumnEditor extends DefaultCellEditor
    {
     
        public TextColumnEditor()
        {
            super(new JTextField());
        }
     
        public boolean stopCellEditing()
        {
            String v = this.getCellEditorValue().toString();
            if(v == null || v.length() == 0)
            {
                this.fireEditingCanceled();
                return false;
            }
            return super.stopCellEditing();
        }
    }
    Bref, ça me donne une belle table avec deux colonnes, le hic c'est que ma première colonne est modifiable (c'est à dire que le setValueAt du TableModel est appelé correctement), mais lorsqu'il s'agit de ma seconde colonne, setValueAt a -1 en tant que rowIndex et columnIndex. Le gros soucis c'est que ça vient du CellEditor, même si je désactive l'appel à fire* et le return false j'ai le soucis, en gros dès que j'appelle (ou pour être précis dès que je tente un instruction (de type test)) j'ai le problème...

    Ca me rend fou, avez-vous déjà eu ce problème ? avez vous une idée du soucis ? ais-je fait quelque chose de mal ?

    Pour votre aide,
    Par avance,
    Merci.

  2. #2
    Invité
    Invité(e)
    Par défaut
    Bonjour,

    Il y a quelque-chose de "marrant" : soit j'ai le droit à la validation soit au positionnement du curseur, mais pas les deux :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
     
    public class UpdateTableListener // ...
    {
        // ...
     
        @Override
        public void actionPerformed(ActionEvent e)
        {
            CellListenerTableGui tcl = (CellListenerTableGui)e.getSource();
            this.obs.getModel().setValueAt(tcl.getNewValue(), tcl.getRow(), tcl.getColumn());
            int sel = this.obs.getModel().getNextRequiredColumn(tcl.getRow());
     
            System.out.println(sel);
            if (sel == -1)
                this.obs.getModel().save(tcl.getRow());
            /*else if (this.obs.getContent().editCellAt(tcl.getRow(), sel))
                this.obs.getContent().getEditorComponent().requestFocus();
            else if (this.obs.getContent().editCellAt(tcl.getRow(), sel))
                this.obs.getContent().getEditorComponent().requestFocus();*/
        }
    }
     
    // Et
    public class TextColumnEditorGui extends DefaultCellEditor
    {
     
        public TextColumnEditorGui()
        {
            super(new JTextField());
        }
     
        public boolean stopCellEditing()
        {
            Object v = this.getCellEditorValue();
            if(v == null || v.toString().length() == 0)
            {
                this.fireEditingCanceled();
                return false;
            }
            return super.stopCellEditing();
        }
    }
    Ou
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
     
    public class UpdateTableListener // ...
    {
        // ...
     
        @Override
        public void actionPerformed(ActionEvent e)
        {
            CellListenerTableGui tcl = (CellListenerTableGui)e.getSource();
            this.obs.getModel().setValueAt(tcl.getNewValue(), tcl.getRow(), tcl.getColumn());
            int sel = this.obs.getModel().getNextRequiredColumn(tcl.getRow());
     
            System.out.println(sel);
            if (sel == -1)
                this.obs.getModel().save(tcl.getRow());
            else if (this.obs.getContent().editCellAt(tcl.getRow(), sel))
                this.obs.getContent().getEditorComponent().requestFocus();
            else if (this.obs.getContent().editCellAt(tcl.getRow(), sel))
                this.obs.getContent().getEditorComponent().requestFocus();
        }
    }
     
    // Et
    public class TextColumnEditorGui extends DefaultCellEditor
    {
     
        public TextColumnEditorGui()
        {
            super(new JTextField());
        }
     
        public boolean stopCellEditing()
        {
            /*Object v = this.getCellEditorValue();
            if(v == null || v.toString().length() == 0)
            {
                this.fireEditingCanceled();
                return false;
            }*/
            return super.stopCellEditing();
        }
    }
    Je pense qu'il y a un soucis dans l'ordre des évènements :/

    Pour votre aide,
    Par avance,
    Merci.

Discussions similaires

  1. problème de cast!
    Par LaseLiep dans le forum Langage
    Réponses: 3
    Dernier message: 03/06/2005, 09h30
  2. [JTable] problème après suppression d'une ligne
    Par fredo3500 dans le forum Composants
    Réponses: 7
    Dernier message: 17/03/2005, 10h01
  3. Problème de cast/serialization/externalization ?
    Par Linlin dans le forum CORBA
    Réponses: 1
    Dernier message: 06/12/2004, 16h46
  4. [JTable] Problème d'affichage des données
    Par ddams dans le forum Composants
    Réponses: 2
    Dernier message: 15/09/2004, 17h07
  5. [C#] Problème de casting de @IDENTITY
    Par bilb0t dans le forum Accès aux données
    Réponses: 7
    Dernier message: 03/09/2004, 09h42

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo