je veux faire un JTable non editable (DefaultTableModel)

**billy1992** · 22/03/2017, 15h13

salut tout le monde ,

svp quelqu'un peut m'aider , je veux faire un DefaultTableModel (JTable biensure creer dans JFrame ) non editable ,jai essayer presque tout les methode mais sans resultat

je ne sais ou est le probleme ,quelqu'un peut me proposer une solution merci d'avance.

voici mon code :

par default Jtable a creer sa Object[][]

et moi je travaille avec new Object[] et jai un conflit avec mes methodes declare en bas

merci pour votre aide

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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
import java.awt.Color;
import static java.awt.Color.red;
import java.awt.Component;
import java.awt.Container;
import java.awt.Font;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.EventListener;
import java.util.EventObject;
import javafx.stage.WindowEvent;
import javax.swing.CellEditor;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTable;
import javax.swing.event.CellEditorListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellEditor;
import sun.misc.FormattedFloatingDecimal;
 
/**
 *
 * @author Mr Robot
 */
public class voir_dispo extends javax.swing.JFrame {
 
    Connecter conn=new Connecter();
 
  DefaultTableModel tab_cham=new DefaultTableModel();
 Statement stm_ch;
 ResultSet rs_ch;
DefaultTableCellRenderer df=new DefaultTableCellRenderer();
 Object[]donnee={};
 String[]entete={"num_ch","etat_ch"} ;       
    public voir_dispo() {
 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   initComponents();
 
 
   tab_cham.addColumn("num_ch");
   tab_cham.addColumn("etat_ch");
 
   try {
 
     Statement stm_ch=conn.obtenircnx().createStatement();
     rs_ch=stm_ch.executeQuery("SELECT * FROM `database`.`id_chambre`");
     while(rs_ch.next()){
         if ((rs_ch.getBoolean("etat_ch"))==true){
 
       Object[] donnee={rs_ch.getString("num_ch"),"libre"};  
     tab_cham.addRow(donnee);
         }
        if ((rs_ch.getBoolean("etat_ch"))==false){
            Object[]donnee={rs_ch.getString("num_ch"),"occupe"};
        tab_cham.addRow(donnee);
        }
      jTable1.setModel(tab_cham); }
 
        }catch(Exception e){e.printStackTrace();}
 
     jTable1.setDefaultRenderer(Object.class,new tablecomposantstring());
     //jTable1.setDefaultRenderer(Object.class,new editeurcellule());
    celuleedition celule=new celuleedition();
 
       JTable jTable1 = new JTable(new celledit());
 
    }
       public class celledit extends DefaultTableModel{
 
            public boolean IsCellEditable(int row,int col){
 
 
                return false;  
                }}
 
     class celuleedition extends AbstractTableModel{
public Object[] donnee;
public String [] entete;
 
celuleedition(Object[] donnee,String [] entete){
this.donnee=donnee;
this.entete=entete;}
            public int getRowCount() {
 
           return this.donnee.length;}
 
 
 
            public int getColumnCount() {
 
            return this.entete.length; }
 
            public String getColumnName(int col){
 
          return this.entete[col];}
 
          public Class getColumnClass (int col){
 
          return this.donnee[4].getClass();}
 
            public Object getValueAt(int row, int col) {
 
            return this.donnee[row];}
 
            public boolean isCellEditable (int row,int col){
            if (getValueAt(row,col) instanceof Object)
               return false;
            return false;}
 
 
  }
     class tablecomposantstring extends DefaultTableCellRenderer{
 
        public Component getTableCellRendererComponent(JTable tableau,Object value,boolean isSelected,
                boolean hasFocused,int row,int col){
          Component cell = super.getTableCellRendererComponent(jTable1, value,
                isSelected, hasFocused, row, col);
 
 
           // if (value=="libre"){
 
           //cell.setBackground(Color.ORANGE
          //);
            //}
            if (col==0){
 
            cell.setBackground(Color.RED) ;
             }else
           cell.setBackground(Color.GREEN);
 
            if (value=="libre"){
 
            cell.setBackground(Color.LIGHT_GRAY) ;
             }
       Object o=jTable1.getValueAt(row, col);
       if (o=="occupe"){cell.setBackground(Color.PINK);}
 
 
         return this ;
 
 
 
 
       }
    }@SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {
 
        jPanel1 = new javax.swing.JPanel();
        jScrollPane1 = new javax.swing.JScrollPane();
        jTable1 = new javax.swing.JTable();
 
        setTitle("dispop");
        addWindowListener(new java.awt.event.WindowAdapter() {
            public void windowOpened(java.awt.event.WindowEvent evt) {
                formWindowOpened(evt);
            }
        });
 
        jPanel1.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));
        jPanel1.setName("disponibilite"); // NOI18N
 
        jTable1.setModel(new javax.swing.table.DefaultTableModel(
            new Object [][] {
                {null, null},
                {null, null},
                {null, null}
            },
            new String [] {
                "numero chambre", "etat chambre"
            }
        ));
        jScrollPane1.setViewportView(jTable1);
        if (jTable1.getColumnModel().getColumnCount() > 0) {
            jTable1.getColumnModel().getColumn(0).setHeaderValue("numero chambre");
            jTable1.getColumnModel().getColumn(1).setHeaderValue("etat chambre");
        }
 
        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
        jPanel1.setLayout(jPanel1Layout);
        jPanel1Layout.setHorizontalGroup(
            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel1Layout.createSequentialGroup()
                .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 332, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(0, 68, Short.MAX_VALUE))
        );
        jPanel1Layout.setVerticalGroup(
            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel1Layout.createSequentialGroup()
                .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 275, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(0, 42, Short.MAX_VALUE))
        );
 
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jPanel1, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(0, 0, Short.MAX_VALUE))
        );
 
        pack();
    }// </editor-fold>                        
 
    private void formWindowOpened(java.awt.event.WindowEvent evt) {                                  
 
    }                                 
 public void disp (EventListener ev){
 
 }
    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(voir_dispo.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(voir_dispo.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(voir_dispo.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(voir_dispo.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>
 
        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new voir_dispo().setVisible(true);
 
 
 
            }
        });
    }
 
    // Variables declaration - do not modify                     
    private javax.swing.JPanel jPanel1;
    private javax.swing.JScrollPane jScrollPane1;
    public javax.swing.JTable jTable1;
    // End of variables declaration                   
}

**joel.drigo** · 22/03/2017, 16h06

Salut,

C'est un peu difficile de lire ton code parce que tu as mélangé différents tests que tu as fait, alors on ne sait plus le dernier que tu as fait.

Pour qu'une cellule soit non éditable, il faut que la méthode IsCellEditable du modèle (TableModel) retourne false pour ses coordonnées (index de ligne et de colonne) passées en paramètre. Pour que toutes les cellules soient non éditables, il suffit donc que cette méthode retourne false quelque soit les coordonnées. Inutile de créer 36 modèles.

Le modèle où tu mets tes données est référencé par la variable tab_cham, et c'est le seul dont tu as besoin (supprime le celuleedition celule = new celuleedition(); et la classe celuleedition , le JTable jTable1 = new JTable(new celledit());.

Il suffit d'écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
DefaultTableModel tab_cham = new DefaultTableModel() {
		public boolean isCellEditable(int row, int col) {
			return false;
		};
	};

Ce qui permet de redéfinir à la volée dans une classe anonymé la méthode qui est nécessaire pour ce que tu cherches à faire.

Tu pourrais implémenter ton propre modèle comme tu as tenté de le faire avec celuleedition, mais au vu du code que tu as écrit, pour l'instant, disons que ce que j'ai indiqué juste au-dessus suffira.

**billy1992** · 22/03/2017, 16h27

oui ,c vrai j'ai tout melange le code ,pare ce que je l'ai essaye avec beaucoup de methodes, je vais essaye avec ta methode , a vrai dire tellemnt je l'ai fait avec des requete sa ma melange un dans la tete ,jai utilise le truc new object[] {} ,merci infiniment mon ami pour ton aide

**billy1992** · 22/03/2017, 23h22

Salut,

Comment puisse-je continuer ? ou je vais faire jTable1.setModel(tab_cham);

Une question :

Comment alors faire une cellule non éditable pour ce cas ?
C'est un vecteur je crois :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 if ((rs_ch.getBoolean("etat_ch"))==false){
 
     ===>   tab_cham.addRow(new Object[]{rs_ch.getString("num_ch"),"occupe"});

Pour un tableau simple àa marche, par exemple :
Pour ce cas là, la cellule non éditable je l'ai fais ça marche.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Object[][]donnee={{2,"libre"},{3,"libre"}};

Mais pour le cas en haut ça ne marche pas.

**joel.drigo** · 23/03/2017, 12h45

Envoyé par billy1992

merci bcp ,hwoarang pour ton aide
et comment maintenant je fait appelle a cette methode
(1) DefaultTableModel tab_cham = new celledit();

ou celle ci :
(2) JTable jTable1=new JTable(new *******());
je ne sais pas laquelle la (1) ou (2) ,je vais utilise ou

Oubli celledit(), ton modèle celledit() ne traite que l'aspect "cellules non éditable", mais sans aucune donnée. L'adapter pour que tes données soit affichées, c'est refaire ce que tu as fait avec tab_cham. Autant ne garder que ça qui fonctionne très bien avec la modification que je t'avais indiquée pour rendre toutes les cellules non éditables.

Pour affecter le modèle à la JTable, soit tu le fais effectivement à la construction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

jTable1 = new JTable(tab_cham);

soit tu l'affectes, avec jTable1.setModel(tab_cham);, avec la table créée une fois pour toute (comme tu l'as fait dans ton code initiale). Tu peux même le faire alors que la jtable est déjà affichée pour recharger de nouvelles données, sans fermer la fenêtre.

Envoyé par billy1992

Salut,
Une question :

Comment alors faire une cellule non éditable pour ce cas ?
C'est un vecteur je crois :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 if ((rs_ch.getBoolean("etat_ch"))==false){
 
     ===>   tab_cham.addRow(new Object[]{rs_ch.getString("num_ch"),"occupe"});

Je ne comprends pas la question. Le cas dont tu parles, c'est l'ajout d'une ligne dans la JTable. Je ne vois pas trop le rapport avec la notion de cellule éditable.

Envoyé par billy1992

Pour un tableau simple àa marche, par exemple :
Pour ce cas là, la cellule non éditable je l'ai fais ça marche.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Object[][]donnee={{2,"libre"},{3,"libre"}};

Mais pour le cas en haut ça ne marche pas.

Je comprends encore moins le rapport. Les données mises dans le modèle, quelque soit la façon de le faire, ne change rien à l'éditabilité des cellules, à moins qu'on implémente le modèle pour.

Par exemple, on pourrait faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
new DefaultTableModel() {
 
    public boolean isCellEditable(int row, int col) {
 
                        if ( col==2 ) {
                                    return getValueAt(row, 3)==null; // ici on rend la cellule éditable tant qu'il n'y a pas de valeur dans la cellule 3 de la même ligne (c'est un exemple)
                        }
 
			return false;
		};
 
}

Accessoirement, on peut rendre certaines cellules éditables et d'autres non avec quelque chose comme ça :

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
new DefaultTableModel() {
 
    public boolean isCellEditable(int row, int col) {
 
                        if ( row % 2 == 0 ) {
                              return true; // toutes les lignes paires sont forcément éditables entièrement
                        }
 
                        switch(col) { // seules les colonnes 0, 3 et 25 des lignes impaires sont éditables
                             case 0:
                             case 3:
                             case 25:
                                return true;
                        }
 
			return false;
 
		};
 
}

Ensuite, initialiser le modèle avec des données, ou les ajouter ligne par ligne ne change rien. On peut implémenter un truc comme ça aussi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
new DefaultTableModel() {
 
    public boolean isCellEditable(int row, int col) {
 
                        if ( getRowCount()>10 )  { // toutes les cellules sont éditable jusqu'à ce qu'il y ait plus de 10 lignes dans la JTable
                            return false;
                        }
			return true;
		};
 
}

**billy1992** · 23/03/2017, 19h19

oui je te remercie encore une fois ta compris mon probleme ,

le message que je voulais te transmettre ,quand je declare mon tableau ou un DefaultTableModel avec une taille fixe sa marche la methode (la cellule non editable)

mais avec insertion des donnees a partir d'une base de donnee avec cette instruction(tab_cham.addRow(plus le code ici)) ,desole sa marche pas

je suis vraiment desole pour mes gros probleme ,et mes derangements

mais j'essaye encore de ma part

**joel.drigo** · 23/03/2017, 19h54

Qu'est-ce que tu veux dire par "ça ne marche pas" exactement ? Il n'y a absolument aucune raison pour que l'insertion de lignes modifie le comportement de la méthode isCellEditable(), techniquement je veux dire. Peu importe d'où viennent les données, ça n'a aucune influence. Pas même le fait d'avoir un taille fixe ou pas.

Un exemple qui montre qu'on a beau ajouter des lignes ou changer le nombre de colonnes, elles restent non éditables :

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
public class JTableTest {
 
	private static String[] columns = {"Col 1","Col 2","Col 3"};
 
	public static void main(String[] args) {
 
 
		JTable table = new JTable();
		table.setFocusable(true);
 
		DefaultTableModel model = new DefaultTableModel(columns, 0) {
			public boolean isCellEditable(int row, int col) {
				return false;
			} 
		};
 
		table.setModel(model);
 
		JFrame frame = new JFrame("Test");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		JPanel panel = new JPanel(new BorderLayout());
		panel.add(new JScrollPane(table));
 
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
 
		JButton addRow = new JButton("Ajouter ligne");
		addRow.addActionListener(e-> model.addRow(createData(table.getColumnCount())));
		buttonPanel.add(addRow);
 
		JButton addColumn = new JButton("Ajouter colonne");
		buttonPanel.add(addColumn);
 
		JButton removeColumn = new JButton("Supprimer dernière colonne");
		buttonPanel.add(removeColumn);
 
		addColumn.addActionListener(e-> {
 
			addColumn();
			model.setColumnIdentifiers(columns);
			removeColumn.setEnabled(true);
			fillNewColumns(model,columns.length-1);
 
		}); 
		removeColumn.addActionListener(e-> {
 
			if ( columns.length==0 ) return;
			removeColumn();
			if ( columns.length==0 ) {
				removeColumn.setEnabled(false);
			}
			model.setColumnIdentifiers(columns);
 
		}); 
 
		panel.add(buttonPanel, BorderLayout.SOUTH);
 
		frame.add(panel);
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private static void fillNewColumns(DefaultTableModel model, int col) {
		for(int row = 0; row<model.getRowCount(); row++) {
			model.setValueAt(genValue(), row, col);
		}
	}
 
	private static void removeColumn() {
		int length = columns.length;
		columns = Arrays.copyOf(columns, length-1);
	}
 
	private static void addColumn() {
		int length = columns.length;
		columns = Arrays.copyOf(columns, length+1);
		columns[length] = "Col " + columns.length;
	}
 
	private static Object[] createData(int columnCount) {
		Object[] data = new Object[columnCount];
		for(int i=0; i<data.length; i++) {
			data[i] = genValue();
		}
		return data;
	}
 
	private static Object genValue() { 
		return  ThreadLocalRandom.current().nextInt(-100,100);
	} 
 
}

Il faudrait que tu nous montres ton code actuel pour voir quel est le problème exactement, mais je pense que tu dois affecter un autre modèle à un moment, qui lui ne désactive pas l'édition.

**hwoarang** · 22/03/2017, 16h30

Il y a tellement d'erreurs dans ce code qu'il est difficile de voir laquelle te gene le plus.

Pour répondre à la question, pour rendre une cellule non editable, le plus simple est d'utiliser un TableModel dont la fonction isCellEditable renvoie false.

C'est ce que fait ta classe "celledit" mais de ce que je vois, tu la crées dans une variable locale "JTable jTable1 = new JTable(new celledit());" que tu n'utilises pas (et qui surcharge au passage une variable de classe - probablement parce que tu veux changer ta table mais ce n'est pas comme ca qu'il faut faire).

Mais bon, comme ca, en regardant quelques secondes ton code, ce qui saute aux yeux:
- Tu crées beaucoup de classes qui ne servent a rien "celuleedition celule = new celuleedition();" => pas utilisé. "JTable jTable1 = new JTable(new celledit());" => Pas utilisé.
- Dans la boucle qui parcours ton Resultset, tu changes le model de ta table à chaque enregistrement. Il faut le faire hors de la boucle.

Voila pour ce que j'ai vu d'evident.

Pour finir, il semble que le TableModel que tu utilises soit celui de la variable de classe "DefaultTableModel tab_cham". C'est donc celui la qui devrait renvoyer "false" lors de l'appel a "isCellEditable ". Le plus simple est donc de le changer pour "DefaultTableModel tab_cham = new celledit();" (et noter au passage que Java est sensible à la casse et que, par consequent, celledit devrait redefinir "isCellEditable" et non "IsCellEditable" (pas de majuscule pour la premiere lettre).

EDIT: grilled !

**billy1992** · 22/03/2017, 17h49

merci bcp ,hwoarang pour ton aide
et comment maintenant je fait appelle a cette methode
(1) DefaultTableModel tab_cham = new celledit();

ou celle ci :
(2) JTable jTable1=new JTable(new *******());
je ne sais pas laquelle la (1) ou (2) ,je vais utilise ou

je veux faire un JTable non editable (DefaultTableModel)

Composants Java

Vue hybride

Discussions similaires

Partager

Partager