001: /*
002: * SalomeTMF is a Test Management Framework
003: * Copyright (C) 2005 France Telecom R&D
004: *
005: * This library is free software; you can redistribute it and/or
006: * modify it under the terms of the GNU Lesser General Public
007: * License as published by the Free Software Foundation; either
008: * version 2 of the License, or (at your option) any later version.
009: *
010: * This library is distributed in the hope that it will be useful,
011: * but WITHOUT ANY WARRANTY; without even the implied warranty of
012: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
013: * Lesser General Public License for more details.
014: *
015: * You should have received a copy of the GNU Lesser General Public
016: * License along with this library; if not, write to the Free Software
017: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
018: *
019: * @author Mikael MARCHE, Fayçal SOUGRATI, Vincent PAUTRET
020: *
021: * Contact: mikael.marche@rd.francetelecom.com
022: */
023:
024: package org.objectweb.salome_tmf.ihm.models;
025:
026: import java.util.ArrayList;
027: import java.util.Vector;
028:
029: import javax.swing.table.AbstractTableModel;
030:
031: /**
032: * Classe qui repr?sente le mod?le d'un table
033: */
034: public class MyTableModel extends AbstractTableModel {
035:
036: /**
037: * Mode debug
038: */
039: private boolean DEBUG = false;
040:
041: /**
042: * Liste des noms de colonnes
043: */
044: private ArrayList columnIdentifiers;
045:
046: /**
047: * Listes des donn?es
048: */
049: public ArrayList dataArrayList;
050:
051: /******************************************************************************/
052: /** CONSTRUCTEUR ***/
053: /******************************************************************************/
054:
055: /**
056: * Constructeur du mod?le de table
057: */
058: public MyTableModel() {
059: columnIdentifiers = new ArrayList();
060: dataArrayList = new ArrayList();
061: } // Fin du constructeur MyTableModel/0
062:
063: /******************************************************************************/
064: /** METHODES PUBLIQUES ***/
065: /******************************************************************************/
066:
067: /**
068: * Retourne le nombre de colonnes
069: */
070: public int getColumnCount() {
071: return columnIdentifiers.size();
072: } // Fin de la m?thode getColumnCount/0
073:
074: /**
075: * Retourne le nombre de lignes
076: */
077: public int getRowCount() {
078: if (getColumnCount() == 0) {
079: return 0;
080: } else {
081: return ((ArrayList) dataArrayList.get(0)).size();
082: }
083: } // Fin de la m?thode getRowCount/0
084:
085: /**
086: * Retourne le nom de la colonne dont l'indice est pass? en param?tre.
087: * @param col indice de la colonne
088: * @return le nom de la colonne
089: */
090: public String getColumnName(int col) {
091: return (String) columnIdentifiers.get(col);
092: } // Fin de la m?thode getColumnName/1
093:
094: /**
095: * R?cup?re la valeur de la table ? un num?ro de ligne et un num?ro de
096: * colonne donn?s
097: * @param row le num?ro de ligne
098: * @param col le num?ro de colonne
099: * @return l'objet de la table
100: */
101: public Object getValueAt(int row, int col) {
102: try {
103: return ((ArrayList) dataArrayList.get(col)).get(row);
104: } catch (IndexOutOfBoundsException ie) {
105: return null;
106: }
107:
108: } // Fin de la m?thode getValueAt/2
109:
110: /**
111: * JTable utilise cette m?thode pour d?terminer le renderer pour
112: * chaque cellule. Si la valeur de la cellule on consid?re qu'il
113: * s'agit d'une String
114: * @param c la colonne choisie
115: * @return la classe des cellules de la colonne
116: */
117: public Class getColumnClass(int c) {
118: if (getValueAt(0, c) == null) {
119: return String.class;
120: }
121: return getValueAt(0, c).getClass();
122: } // Fin de la m?thode getColumnClass/1
123:
124: /**
125: * Rend vrai si les cellules de la table sont ?ditables
126: * @return toujours faux
127: */
128: public boolean isCellEditable(int row, int col) {
129: return false;
130: } // Fin de la m?thode isCellEditable/2
131:
132: /**
133: * Permet de modifier un objet dans la table
134: * @param value le nouvel objet? ins?rer
135: * @param row la ligne de modification
136: * @param col la colonne de modification
137: */
138: public void setValueAt(Object value, int row, int col) {
139: if (DEBUG) {
140: System.out.println("Valeur ? " + row + "," + col + " = "
141: + value + " (une instance de " + value.getClass()
142: + ")");
143: }
144:
145: ((ArrayList) dataArrayList.get(col)).set(row, value);
146: fireTableCellUpdated(row, col);
147:
148: if (DEBUG) {
149: System.out.println("Nouvelle valeur de la donn?e :");
150: printDebugData();
151: }
152: } // Fin de la m?thode setValue/3
153:
154: /**
155: * Permet d'ajouter un objet dans la table
156: * @param value l'objet ? ajouter
157: * @param row la ligne o? ajouter
158: * @param col la colonne o? ajouter
159: */
160: public void addValueAt(Object value, int row, int col) {
161: if (DEBUG) {
162: System.out.println("Valeur ? " + row + "," + col + " = "
163: + value + " (une instance de " + value.getClass()
164: + ")");
165: }
166:
167: ((ArrayList) dataArrayList.get(col)).add(row, value);
168: fireTableCellUpdated(row, col);
169: } // Fin de la m?thode addValueAt/3
170:
171: /**
172: * M?thode qui affiche sur la sortie standard, l'ensemble des donn?es de la
173: * table
174: */
175: public void printDebugData() {
176: int numRows = getRowCount();
177: int numCols = getColumnCount();
178:
179: for (int i = 0; i < numRows; i++) {
180: System.out.print(" ligne " + i + ":");
181: for (int j = 0; j < numCols; j++) {
182: System.out.print(" "
183: + ((ArrayList) dataArrayList.get(j)).get(i));
184: }
185: System.out.println();
186: }
187: } // Fin de la m?thode printDebugData/0
188:
189: /**
190: * Mutateur des donn?es de la table
191: * @param data les donn?es
192: */
193: public void setData(ArrayList data) {
194: dataArrayList = data;
195: fireTableStructureChanged();
196: } // Fin de la m?thode setData/1
197:
198: /**
199: * M?thode qui ajoute une colonne
200: */
201: public void addColumn() {
202: dataArrayList.add(new ArrayList());
203: } // Fin de la m?thode addColumn/0
204:
205: /**
206: * M?thode qui ajoute un nom de colonne
207: * @param name un nom de colonne
208: */
209: public void addColumnName(String name) {
210: columnIdentifiers.add(name);
211: } // Fin de la m?thode addColumnName/1
212:
213: /**
214: * Retourne l'ensemble des donn?es de la table
215: * @return l'ensemble des donn?es de la table
216: */
217: public ArrayList getData() {
218: return dataArrayList;
219: } // Fin de la m?thode getData/0
220:
221: /**
222: * M?thode qui retourne toutes les donn?es sur une ligne de la table dont
223: * l'indice est pass? en param?tre.
224: * @param index num?ro de la colonne
225: * @return une liste contenant les valeurs des diff?rentes colonnes de la
226: * ligne en question
227: */
228: public ArrayList getData(int index) {
229: ArrayList result = new ArrayList();
230: for (int i = 0; i < getColumnCount(); i++) {
231: result.add(getValueAt(index, i));
232: }
233: return result;
234: } // Fin de la m?thode getData/1
235:
236: /**
237: * Ajoute une colonne avec son nom
238: * @param name le nom de la colonne
239: */
240: public void addColumnNameAndColumn(String name) {
241: addColumnName(name);
242: addColumn();
243: // justifyRows(0, getRowCount());
244: fireTableStructureChanged();
245: } // Fin de la m?thode addColumnNameAndColumn/1
246:
247: /**
248: * Permet d'ajouter une liste de donn?es dans la table. La liste fournie en
249: * param?tre doit avoir une taille inf?rieure ou ?gale au nombre de colonnes.
250: * Le premier ?l?ment de la liste est mis dans la premi?re colonne et ainsi
251: * de suite.
252: * @param list une liste de donn?es
253: */
254: public void addRow(ArrayList list) {
255: if (list.size() <= getColumnCount()) {
256: int ligneIndex = getRowCount();
257: for (int i = 0; i < list.size(); i++) {
258: addValueAt(list.get(i), ligneIndex, i);
259: }
260: fireTableStructureChanged();
261: }
262: } // Fin de la m?thode addData/1
263:
264: /**
265: * Permet d'ajouter une liste de donn?es dans la table. La liste fournie en
266: * param?tre doit avoir une taille inf?rieure ou ?gale au nombre de colonnes.
267: * Le premier ?l?ment de la liste est mis dans la premi?re colonne et ainsi
268: * de suite.
269: * @param list une liste de donn?es
270: */
271: public void addDataColumn(Vector vector, int columnIndex) {
272:
273: for (int i = 0; i < vector.size(); i++) {
274: if (vector.get(i) != null) {
275: addValueAt(vector.get(i).toString(), i, columnIndex);
276: } else {
277: addValueAt("", i, columnIndex);
278: }
279: }
280: fireTableStructureChanged();
281: } // Fin de la m?thode addData/1
282:
283: /**
284: * M?thode qui modifie une ligne de la table
285: * @param list la liste des nouvelles valeurs
286: * @param row la ligne ? modifier
287: */
288: public void modifyData(ArrayList list, int row) {
289: if (list.size() <= getColumnCount()) {
290: for (int i = 0; i < list.size(); i++) {
291: setValueAt(list.get(i), row, i);
292: }
293: //fireTableStructureChanged();
294: }
295: } // Fin de la m?thode modifyData/2
296:
297: /**
298: * M?thode qui supprime toute une ligne
299: * @param row l'indice de la ligne
300: */
301: private void removeRow(int row) {
302: for (int j = 0; j < getColumnCount(); j++) {
303: if (row < ((ArrayList) dataArrayList.get(j)).size()) {
304: ((ArrayList) dataArrayList.get(j)).remove(row);
305: }
306: }
307: } // Fin de la m?thode removeRow/1
308:
309: /**
310: * M?thode qui supprime une ligne de la table
311: * @param row indice de la ligne
312: */
313: public void removeData(int row) {
314: removeRow(row);
315: fireTableStructureChanged();
316: } // Fin de la m?thode removeData/1
317:
318: /**
319: * M?thode qui nettoie toute la table
320: */
321: public void clearTable() {
322: int nbRow = getRowCount();
323: for (int i = 0; i < nbRow; i++) {
324: removeRow(0);
325: }
326: fireTableStructureChanged();
327: } // Fin de la m?thode clearTable/0
328:
329: /**
330: * Recherche la ligne o? le nom pass? en param?tre correspond au nom de la
331: * colonne 0, -1 si aucune correspondance.
332: * @param name
333: * @return
334: */
335: public int findRow(String name) {
336: for (int i = 0; i < getRowCount(); i++) {
337: if (getValueAt(i, 0).equals(name)) {
338: return i;
339: }
340: }
341: return -1;
342: }
343:
344: /**
345: * Supprime la ligne dont l'?l?ment de la colonne 0 correspond ? la cha?ne
346: * pass?e en param?tre.
347: * @param key
348: */
349: public void removeRow(String key) {
350: for (int i = 0; i < getRowCount(); i++) {
351: if (getValueAt(i, 0).equals(key)) {
352: removeData(i);
353: break;
354: }
355: }
356: }
357: } // Fin de la classe MyTableModel
|