Afficher une feuille excel à partir d'une ligne spécifique

Version imprimable

Voir 40 message(s) de cette discussion en une page

01/04/2016, 10h40
joel.drigo
Citation:

Envoyé par nadong94

:) Tout d'abord, quand je test un fichier qui n'a pas "dbs" il me fait toujours plusieurs fois le même message,

Je suppose que c'est dans le cas où tu as plusieurs sheets qui ne contiennent pas le mot "dbs". Dans ce cas, il faut revoir complètement la structure de ton programme. C'est toujours et encore le même problème : si tu as une boucle et que tu fais quelque chose dans la boucle, ça le fait plusieurs fois. Pour que ça ne le fasse pas plusieurs fois, il faut le faire en dehors de la boucle.
Maintenant, le problème est que dans un classeur avec plusieurs feuilles de calculs, tu as
1. le cas où toutes les feuilles ont au moins une fois le mot : tous les sheets sont affichables
2. le cas où certaines feuilles ont le mot et pas d'autres : certains sheets sont affichables
3. le cas où aucune feuille a le mot : le classeur n'est pas affichable
Or la boucle traite des sheets, pas un classeur : donc tu ne pas traiter le cas 3 dans la boucle dont chaque itération traite une feuille de calcul.

Il faut donc mettre en place quelque chose dans ce genre :
Code:

1 2 3 4 5 faire demander fichier ok = créerEtAfficherClasseurt(fichier) tant que pas ok
Ensuite, il y a différents moyens de remonter à l'appelant une information qui permet de déterminer si on est dans le cas ok ou pas ok. Mais ça dépend ce que renvoie la méthode à la base et le nombre de valeurs qu'on veut retourner (les cas qu'on veut pouvoir distinguer). Le plus simple est que OK soit booléen : le classeur est affichable ou pas. On n'a pas la raison pour laquelle il ne l'est pas (parce qu'on n'a pas envie de la gérer, ou parce qu'il n'y a qu'une seule raison possible qu'il ne soit pas affichable).
Comme la méthode retourne une JTable, tu peux comme je te l'avais déjà indiqué, retourner null quand "dbs" n'est pas trouvé. Ainsi, l'appelant sait que le sheet n'est pas affichable. Si au moins un sheet est affichable, l'appelant peut retourner true et sinon false à son appelant : ainsi ce dernier peut réagir au fait qu'aucun onglet n'a été affiché en demandant l'ouverture d'un nouveau fichier.

Je crois il manque un truc.
Voici, si dbs manque dans une seule des sheet alors return null, puis une méthodes pour vérifier :

Code:

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
 
public static createJTableWithExcel(....) {
	/*......*/
		if (index >= 0) {
			// we found lines : are recovered
			Object[][] result = Arrays.copyOf(recorvery, index); // index corresponds to the number of rows found
			table.setModel(new DefaultTableModel(result, header));
 
		} else {
			//if we don't found "dbs"
			return null;
		}
		table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
		return table;
	}
 
	public boolean viewTables(File file) {
		Component c = this.createJTabbed(file);
 
		if (c.equals(null)) {
			return false;
		} else {
			return true;
		}
	}

Et l'appelant :

Code:

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
 
private void btnLoad_click() 
{
	JFileChooser fc = new FileChooser();
	boolean ok = false;
	//Open the dialog box
	int returnVal = fc.showOpenDialog(null);
	if (returnVal == JFileChooser.APPROVE_OPTION) {
		//if you validate
		IhmConverter.getHDMT().removeAll();
		Component tabHDMT = IhmConverter.getHDMT();
		//Loading...
		try {
			tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
			ok = utiMethods.viewTables(fc.getSelectedFile());
			do {
				if (ok == false) {
					JOptionPane
							.showMessageDialog(null,
									Final.getMsgDBS(),Final.getMsgDBSTitle(),JOptionPane.WARNING_MESSAGE);	
					//Re-Open the dialog box
					fc.showOpenDialog(null);
				}
			} while (ok != true); 
			} finally {
				//when is wait off
				tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			}
	} else if (returnVal == JFileChooser.CANCEL_OPTION) {
		//if you cancel do nothing	
	}
}

Bon, déjà, ton code est partiel : je ne peux pas savoir si c'est des erreurs de copier/coller ou si c'est vraiment ton code qui est dans cet état.

Par exemple, dans public static createJTableWithExcel(....) {, manque le type de retour de la méthode, donc ça ne compile pas.

Sinon, oui, il manque un niveau :
Code:

1 2 3 4 5 6 7 8 9 public boolean viewTables(File file) { Component c = this.createJTabbed(file); if (c.equals(null)) { return false; } else { return true; } }
un sheet sans "dbs" et createJTableWithExcel retourne null pour celui-ci. Est-ce que createJTabbed qui créé un classeur et non une feuille (sheet) retourne bien null quand il n'y a aucun onglet ? Je ne peux pas le savoir : je n'ai pas le code.

Ensuite, ça :
if (c.equals(null)) {Jamais !

Déjà

c'est soit faux : si tu peux appeler la méthode, c'est que c n'est pas null, donc pas égale à null...
si c est null, alors NullPointerException !

Pour comparer une référence, on utilise toujours l'identité : if ( c==null )Ensuite, il manque manifestement quelque chose pour changer la valeur de ok dans cette boucle :
Code:

1 2 3 4 5 6 7 8 do { if (ok == false) { JOptionPane.showMessageDialog(null, Final.getMsgDBS(),Final.getMsgDBSTitle(),JOptionPane.WARNING_MESSAGE); //Re-Open the dialog box fc.showOpenDialog(null); } } while (ok != true);
Ensuite, non obstant le fait que c'est plus simple d'écrire

if ( ok ) que if ( ok==true )
if ( !ok ) que if ( ok==false )

pourquoi écrire un coup if ( ok==false), et un autre if ( ok!=true ), alors que ces expressions sont équivalentes. Plus simple, lisible, direct, concis sera ton code, plus facile sera sa compréhension et son débogage...
Code:

1 2 3 4 5 6 7 8 do { if ( !ok ) { JOptionPane.showMessageDialog(null, Final.getMsgDBS(),Final.getMsgDBSTitle(),JOptionPane.WARNING_MESSAGE); //Re-Open the dialog box fc.showOpenDialog(null); } } while ( !ok );
On voit tout de suite que les 2 tests sont les mêmes, donc qu'un while irait tout aussi bien, mais en plus concis (et une seule condition). Du coup, le fait que ok ne change pas dans la boucle me semble immédiatement plus évident :
Code:

1 2 3 4 5 6 7 while ( !ok ) { JOptionPane.showMessageDialog(null, Final.getMsgDBS(),Final.getMsgDBSTitle(),JOptionPane.WARNING_MESSAGE); //Re-Open the dialog box fc.showOpenDialog(null); }

Voici donc la méthode appelant :

Code:

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
 
private void btnLoad_click() 
	{
		JFileChooser fc = new FileChooser();
		boolean ok = false;
		//Open the dialog box
		int returnVal = fc.showOpenDialog(null);
		if (returnVal == JFileChooser.APPROVE_OPTION) {
			//if you validate
			IhmConverter.getHDMT().removeAll();
			Component tabHDMT = IhmConverter.getHDMT();
			//Loading...
			try {
				tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
				ok = utiMethods.viewTables(fc.getSelectedFile());
				while (!ok) {
					if (ok == false) {
						JOptionPane
								.showMessageDialog(null,
										Final.getMsgDBS(),Final.getMsgDBSTitle(),JOptionPane.WARNING_MESSAGE);	
						//re-start the application
						Windows.loadApplication();
						//Re-Open the dialog box
						fc.showOpenDialog(null);
					}
				} 
				} finally {
					//when is wait off
					tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
				}
		} else if (returnVal == JFileChooser.CANCEL_OPTION) {
			//if you cancel do nothing	
		}

et les 4 méthodes principale :

Code:

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
 
public JTabbedPane createJTabbed(File file) {
		// Celui-ci est l'onglet principal, c'est à lui que les sous-onglets
		// reviennent
		final JTabbedPane tabbedPrincipal = IhmConverter.getHDMT();
 
		// try {
		// on récupère ses sous-onglets grâce à la méthode createTabPanel
		List<JPanel> lstPanel = createTabPanel(file);
		if (lstPanel != null) {
			// on ajoute les sous-onglets à l'onglet principal au fur et à
			// mesure
			for (JPanel panel : lstPanel) {
				// panel.setName(sheet.getSheetName());
				tabbedPrincipal.add(panel.getName(), panel);
 
				// puis on les ajoutes
				tabbedPrincipal.add(panel);
			}
			// wb.close();
			/*
			 * } catch (IOException e) { e.printStackTrace(); }
			 */
			// maintenant qu'il est rempli de sous onglet je met un changeListener
			tabbedPrincipal.addChangeListener(new Changes(tabbedPrincipal));
			// tabbedPrincipal.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
 
			return tabbedPrincipal;
		}
		return null;
	}
 
	/**
         * Create a tab panel by excel feel
         * 
         * @param fileName
         * @param excelFile
         * @return panel list
         */
	public List<JPanel> createTabPanel(File file) {
		JTable spreadsheet = null;
		// celui-ci est un sous-onglet auquel on va ajouter à l'onglet principal
		JPanel panel = null;
		// celui-ci va récupérer la list de tous les sous-onglets
		List<JPanel> lstPanel = new ArrayList<JPanel>();
		int nbFeuilles = 0;
 
		try {
			// Zip bomb detected! The file would exceed the max. ratio of
			// compressed file size to the size of the expanded data.
			// This may indicate that the file is used to inflate memory usage
			// and thus could pose a security risk.
			// You can adjust this limit via ZipSecureFile.setMinInflateRatio()
			// if you need to work with files which exceed this limit. Counter:
			// 827392, cis.counter: 8192, ratio: 0.009900990099009901Limits:
			// MIN_INFLATE_RATIO: 0.01
			final Double ratio = 0.009900990099009901;
			ZipSecureFile.setMinInflateRatio(ratio);
 
			wb = WorkbookFactory.create(file);
 
			nbFeuilles = wb.getNumberOfSheets();
			for (int i = 0; i < nbFeuilles; i++) {
				sheet = wb.getSheetAt(i);
				// Create one spreadsheet by excel feel
				spreadsheet = createJTableWithExcel(sheet);
				if (spreadsheet != null) {
					spreadsheet.setEnabled(false);
					spreadsheet.setFont(Final.getFont());
					spreadsheet.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
					JScrollPane elevator = new JScrollPane(spreadsheet,
							JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
							JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
					elevator.getViewport().setBackground(Color.WHITE);
 
					// Create a tab by excel feel number
					panel = new JPanel();
					panel.setLayout(new BorderLayout());
					// TitledBorder
					panel.setBorder(BorderFactory.createTitledBorder(sheet
							.getSheetName()));
					panel.setName(sheet.getSheetName());
					panel.setBackground(Color.LIGHT_GRAY);
					// on lui ajoute un ascenseur
					panel.add(elevator, BorderLayout.CENTER);
 
					lstPanel.add(panel);
				}
				return null;
			}
			wb.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (EncryptedDocumentException e) {
			e.printStackTrace();
		} catch (InvalidFormatException e) {
			e.printStackTrace();
		}
		return lstPanel;
	}
 
	/**
         * Create a JTable depending on the file and the entry sheet number
         * 
         * @param file
         * @param numSheet
         * @return the table
         */
	public JTable createJTableWithExcel(Sheet sheet) {
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];
 
		// table header
		String[] header = new String[nbColumns];
 
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);
			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "dbs"
					cell = row.getCell((short) columnContent);
					final Object value = contentCell(cell);
					obj[rowContent][columnContent] = value;
				}
			}
		}
 
		// recovery of adequate lines
		final Object[][] recorvery = new Object[nbRows][nbColumns];
		int index = -1; // indicates the index of the next line to recover,
						// except of -1
		for (int i = 0; i < nbRows; i++) {
			if (i == 0) { // the first line: the headers
				// Recovering the headers
				for (int j = 0; j < nbColumns; j++) {
					header[j] = String.valueOf(obj[i][j]);
				}
			} else {
				if (index < 0) { // we found nothing, so we are searching
					for (int j = 0; j < nbColumns; j++) {
						if ("dbs".equals(obj[i][j])) { // we found a line that
														// contains "dbs"
							index = 0;
							break; // needn't to search in this line
						}
					}
				}
 
				if (index >= 0) { // we found a line that contained "dbs", then copy
					// copy the lines after the first that contains "dbs" including this one
					for (int j = 0; j < nbColumns; j++) { // copy the full line
						recorvery[index][j] = obj[i][j];
					}
					index++; // we advance in the recovery table
				}
 
			}
 
		}
 
		if (index >= 0) {
			// we found lines : are recovered
			Object[][] result = Arrays.copyOf(recorvery, index); // index corresponds to the number of rows found
			table.setModel(new DefaultTableModel(result, header));
 
		} else {
			//if we don't found "dbs"
			return null;
		}
		table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
		return table;
	}
 
	public boolean viewTables(File file) {
		Component c = this.createJTabbed(file);
 
		if (c == null) {
			return false;
		} else {
			return true;
		}
	}

Je pense qu'avec tous ces return null ça doit être brouillon. Je peux sans-doute faire mieux, j'ai peut-être zappé un truc ou deux.

Citation:

Envoyé par nadong94

Je pense qu'avec tous ces return null ça doit être brouillon. Je peux sans-doute faire mieux, j'ai peut-être zappé un truc ou deux.

Déjà, tu peux retourner une liste vide au lieu de null : si la liste de panels est vide, c'est qu'il n'y a aucun sheet affichable.

Ensuite, dans le code suivant, ça ne va du tout : tu retournes null systématiquement (au premier sheet, qu'il soit affichable ou pas) : donc tu n'auras jamais rien qui s'affiche. Avant de poster le code, tu pourrais juste tester, non. Ensuite, même si tu fais un else, ça va poser un problème : dès le premier sheet non affichable, la création complète du classeur sera abandonnée : avec une liste vide au lieu de null, il te suffit d'ajouter à la liste les sheets non null et juste de tester isEmpty() sur la liste de panels dans l'appelant, et au moins, si le premier sheet n'a pas "dbs" mais que tu as 10 sheet avec "dbs" dedans après, ils s'affichent.
Code:

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 for (int i = 0; i < nbFeuilles; i++) { sheet = wb.getSheetAt(i); // Create one spreadsheet by excel feel spreadsheet = createJTableWithExcel(sheet); if (spreadsheet != null) { spreadsheet.setEnabled(false); spreadsheet.setFont(Final.getFont()); spreadsheet.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS); JScrollPane elevator = new JScrollPane(spreadsheet, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); elevator.getViewport().setBackground(Color.WHITE); // Create a tab by excel feel number panel = new JPanel(); panel.setLayout(new BorderLayout()); // TitledBorder panel.setBorder(BorderFactory.createTitledBorder(sheet .getSheetName())); panel.setName(sheet.getSheetName()); panel.setBackground(Color.LIGHT_GRAY); // on lui ajoute un ascenseur panel.add(elevator, BorderLayout.CENTER); lstPanel.add(panel); } return null; }
Enfin, cette boucle, comme avant, soit n'est pas exécutée, soit boucle à l'infinie.
Code:

1 2 3 4 5 6 7 8 9 10 11 while (!ok) { if (ok == false) { JOptionPane .showMessageDialog(null, Final.getMsgDBS(),Final.getMsgDBSTitle(),JOptionPane.WARNING_MESSAGE); //re-start the application Windows.loadApplication(); //Re-Open the dialog box fc.showOpenDialog(null); } }
Par ailleurs, je ne sais pas trop ce que fait Windows.loadApplication(), mais ce n'est jamais très bon de redémarrer l'application en plein milieu du code (tu peux avoir des états transitoires non fermés, des composants ouverts qu'il faudrait fermer, etc.)

Pas bien simple. tout d'abord :

La Première méthode :

Code:

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
 
public JTabbedPane createJTabbed(File file) {
	// Celui-ci est l'onglet principal, c'est à lui que les sous-onglets
	// reviennent
	final JTabbedPane tabbedPrincipal = IhmConverter.getHDMT();
 
	// try {
	// on récupère ses sous-onglets grâce à la méthode createTabPanel
	List<JPanel> lstPanel = createTabPanel(file);
	if (!lstPanel.isEmpty()) {
		// on ajoute les sous-onglets à l'onglet principal au fur et à
		// mesure
		for (JPanel panel : lstPanel) {
			// panel.setName(sheet.getSheetName());
			tabbedPrincipal.add(panel.getName(), panel);
 
			// puis on les ajoutes
			tabbedPrincipal.add(panel);
		}
		// wb.close();
		/*
		 * } catch (IOException e) { e.printStackTrace(); }
		 */
		// maintenant qu'il est rempli de sous onglet je met un changeListener
		tabbedPrincipal.addChangeListener(new Changes(tabbedPrincipal));
		// tabbedPrincipal.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
 
		return tabbedPrincipal;
	}
	return tabbedPrincipal;
}

Et La deuxième méthode, mais :

Code:

spreadsheet = createJTableWithExcel(sheet);

retourne null s'il n'y a pas "dbs"
Donc comment est-ce que la méthode 2 (celle qui retourne une liste de panel) doit retourner un liste vide ou rempli,
alors que spreadsheet qui récupère le retour qui est null ? Je n'ai pas du comprendre un truc :(
pour le moment j'ai seulement enlever le return null :

Code:

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
 
public List<JPanel> createTabPanel(File file) {
		JTable spreadsheet = null;
		// celui-ci est un sous-onglet auquel on va ajouter à l'onglet principal
		JPanel panel = null;
		// celui-ci va récupérer la list de tous les sous-onglets
		List<JPanel> lstPanel = new ArrayList<JPanel>();
		int nbFeuilles = 0;
 
		try {
			// Zip bomb detected! The file would exceed the max. ratio of
			// compressed file size to the size of the expanded data.
			// This may indicate that the file is used to inflate memory usage
			// and thus could pose a security risk.
			// You can adjust this limit via ZipSecureFile.setMinInflateRatio()
			// if you need to work with files which exceed this limit. Counter:
			// 827392, cis.counter: 8192, ratio: 0.009900990099009901Limits:
			// MIN_INFLATE_RATIO: 0.01
			final Double ratio = 0.009900990099009901;
			ZipSecureFile.setMinInflateRatio(ratio);
 
			wb = WorkbookFactory.create(file);
 
			nbFeuilles = wb.getNumberOfSheets();
			for (int i = 0; i < nbFeuilles; i++) {
				sheet = wb.getSheetAt(i);
				// Create one spreadsheet by excel feel
				spreadsheet = createJTableWithExcel(sheet);
				spreadsheet.setEnabled(false);
				spreadsheet.setFont(Final.getFont());
				spreadsheet.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
				JScrollPane elevator = new JScrollPane(spreadsheet,
						JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
						JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
				elevator.getViewport().setBackground(Color.WHITE);
 
				// Create a tab by excel feel number
				panel = new JPanel();
				panel.setLayout(new BorderLayout());
				// TitledBorder
				panel.setBorder(BorderFactory.createTitledBorder(sheet
						.getSheetName()));
				panel.setName(sheet.getSheetName());
				panel.setBackground(Color.LIGHT_GRAY);
				// on lui ajoute un ascenseur
				panel.add(elevator, BorderLayout.CENTER);
 
				lstPanel.add(panel);
			}
			wb.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (EncryptedDocumentException e) {
			e.printStackTrace();
		} catch (InvalidFormatException e) {
			e.printStackTrace();
		}
		return lstPanel;
	}

Merci encore...

et la méthode appelant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
try {
	tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
	ok = utiMethods.viewTables(fc.getSelectedFile());
	while (!ok) {
		JOptionPane
				.showMessageDialog(null,
						Final.getMsgDBS(),Final.getMsgDBSTitle(),JOptionPane.WARNING_MESSAGE);	
		//Re-Open the dialog box
		fc.showOpenDialog(null);
		ok = utiMethods.viewTables(fc.getSelectedFile());
	}
		utiMethods.createJTabbed(fc.getSelectedFile());
	} finally {
	/*........*/

En version simplifiée :

Tu as une méthode qui prend un sheet en entrée et qui créé un JTable. Cette méthode retourne null s'il n'y a pas "dbs" dedans. Appelons la sheetToJTable(). Celle-là, elle est ok, normalement, donc je ne détaille pas encore une fois.

Tu as une méthode qui prend un Workbook en entrée, parcourt les sheets de ce woorkbook, et pour chacun d'eux appelle la précédente : elle place les JTable dans un JPanel, qu'elle stocke dans une liste

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
List<JPanel> createPanels(Workbook workbook) {
 
     List<JPanel> list 
 
     pour chaque sheet de workbook
 
           JTable jtable = sheetToJTable( sheet ) // retourne null donc si pas de sheet affichable (ie pas de "dbs")
 
 
           si jtable n'est pas null // on affiche les jtable (les null on ignore simplement)
 
              JPanel panel = ...
 
 
             list.add( panel );
 
           fin si
 
     fin pour
 
     return list
 
}

Tu as une méthode qui crééer un JTabbedPAne avec une liste de panel :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
JTabbedPane createTabbedPane(File file) {
 
         Workbook workbook = ouvrir file
 
         List<JPAnel> panels = createPanels(workbook);
 
         if ( panels.isEmpty() ) { // la liste est vide = pas de sheet affichable = pas d'onglets = pas de tabbedpane
              return null;
         }
         else {
 
              JTabbedPane pane = ...
 
              return pane;
 
         }
 
 
}

Tu as une méthode qui te permet de choisir un fichier et de l'afficher...

Code:

1
2
3
4
5
6
7
8
9
10
 
 
faire {
 
   fichier = JFileChooser.choisir fichier
   si fichier!=null alors
       tabbedpane = createTabbedPane(fichier)
   fin si
 
} tant que (fichier!=null && tabbedpane ==null) // soit tant qu'un fichier est choisi et pas de tabbedpane créé

Salut,

Un petit NPE sur la première methode.
le wb = WorkbookFactory.create(file);
Pourtant il ne s'instancie pas le Workbook.

Code:

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
 
public JTabbedPane createJTabbed(File file) {
		// Celui-ci est l'onglet principal, c'est à lui que les sous-onglets
		// reviennent
		final JTabbedPane tabbedPrincipal = IhmConverter.getHDMT();
		try {
			wb = WorkbookFactory.create(file);
			// on récupère ses sous-onglets grâce à la méthode createPanels
			List<JPanel> lstPanel = createPanels(wb);
			if (lstPanel.isEmpty()) {
				return null;
			} else {
				// on ajoute les sous-onglets à l'onglet principal au fur et à mesure
				for (JPanel panel : lstPanel) {
					// panel.setName(sheet.getSheetName());
					tabbedPrincipal.add(panel.getName(), panel);
 
					// puis on les ajoutes
					tabbedPrincipal.add(panel);
				}
				// maintenant qu'il est rempli de sous onglet je met un changeListener
				tabbedPrincipal.addChangeListener(new Changes(tabbedPrincipal));
			}
			wb.close();
		} catch (IOException e) { 
			e.printStackTrace(); 
		} catch (EncryptedDocumentException e) {
			e.printStackTrace();
		} catch (InvalidFormatException e) {
			e.printStackTrace();
		}
		return tabbedPrincipal;
	}
 
	/**
         * Create a tab panel by excel feel
         * 
         * @param fileName
         * @param excelFile
         * @return panel list
         */
	private List<JPanel> createPanels(Workbook workbook) {
		JTable spreadsheet = null;
		// celui-ci est un sous-onglet auquel on va ajouter à l'onglet principal
		JPanel panel = null;
		// celui-ci va récupérer la list de tous les sous-onglets
		List<JPanel> lstPanel = new ArrayList<JPanel>();
		int nbFeuilles = 0;
 
		try {
			// Zip bomb detected! The file would exceed the max. ratio of
			// compressed file size to the size of the expanded data.
			// This may indicate that the file is used to inflate memory usage
			// and thus could pose a security risk.
			// You can adjust this limit via ZipSecureFile.setMinInflateRatio()
			// if you need to work with files which exceed this limit. Counter:
			// 827392, cis.counter: 8192, ratio: 0.009900990099009901Limits:
			// MIN_INFLATE_RATIO: 0.01
			final Double ratio = 0.009900990099009901;
			ZipSecureFile.setMinInflateRatio(ratio);
 
			nbFeuilles = workbook.getNumberOfSheets();
			for (int i = 0; i < nbFeuilles; i++) {
				sheet = workbook.getSheetAt(i);
				// Create one spreadsheet by excel feel
				spreadsheet = sheetToJTable(sheet);
				if (spreadsheet != null) {				 
					spreadsheet.setEnabled(false);
					spreadsheet.setFont(Final.getFont());
					spreadsheet.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
					JScrollPane elevator = new JScrollPane(spreadsheet,
							JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
							JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
					elevator.getViewport().setBackground(Color.WHITE);
 
					// Create a tab by excel feel number
					panel = new JPanel();
					panel.setLayout(new BorderLayout());
					// TitledBorder
					panel.setBorder(BorderFactory.createTitledBorder(sheet
							.getSheetName()));
					panel.setName(sheet.getSheetName());
					panel.setBackground(Color.LIGHT_GRAY);
					// on lui ajoute un ascenseur
					panel.add(elevator, BorderLayout.CENTER);
 
					lstPanel.add(panel);
				}
			}
			workbook.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (EncryptedDocumentException e) {
			e.printStackTrace();
		}
		return lstPanel;
	}
 
	/**
         * Create a JTable depending on the file and the entry sheet number
         * 
         * @param file
         * @param numSheet
         * @return the table
         */
	private JTable sheetToJTable(Sheet sheet) {
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];
 
		// table header
		String[] header = new String[nbColumns];
 
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);
			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "dbs"
					cell = row.getCell((short) columnContent);
					final Object value = contentCell(cell);
					obj[rowContent][columnContent] = value;
				}
			}
		}
 
		// recovery of adequate lines
		final Object[][] recorvery = new Object[nbRows][nbColumns];
		int index = -1; // indicates the index of the next line to recover,
						// except of -1
		for (int i = 0; i < nbRows; i++) {
			if (i == 0) { // the first line: the headers
				// Recovering the headers
				for (int j = 0; j < nbColumns; j++) {
					header[j] = String.valueOf(obj[i][j]);
				}
			} else {
				if (index < 0) { // we found nothing, so we are searching
					for (int j = 0; j < nbColumns; j++) {
						if ("dbs".equals(obj[i][j])) { // we found a line that
														// contains "dbs"
							index = 0;
							break; // needn't to search in this line
						}
					}
				}
 
				if (index >= 0) { // we found a line that contained "dbs", then copy
					// copy the lines after the first that contains "dbs" including this one
					for (int j = 0; j < nbColumns; j++) { // copy the full line
						recorvery[index][j] = obj[i][j];
					}
					index++; // we advance in the recovery table
				}
 
			}
 
		}
 
		if (index >= 0) {
			// we found lines : are recovered
			Object[][] result = Arrays.copyOf(recorvery, index); // index corresponds to the number of rows found
			table.setModel(new DefaultTableModel(result, header));
 
		} else {
			//if we don't found "dbs"
			return null;
		}
		table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
		return table;
	}

04/04/2016, 10h23
joel.drigo

Une NPE survient lorsque la référence sur laquelle on invoque une méthode est null.

J'ai mis une variable pour le fc.getSelectedFile() plutôt que de l'utiliser directement.
Maintenant qu'il n'y a plus d'erreur et que je choisi un fichier qui n'a pas dbs il ne respecte pas le do while, car il ferme la boite de dialogue et m'affiche un onglet avec un jtable vide..

Code:

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
 
private void btnLoad_click() 
{
	JFileChooser fc = new FileChooser();
	Component file;
	//Open the dialog box
	int returnVal = fc.showOpenDialog(null);
	if (returnVal == JFileChooser.APPROVE_OPTION) {
		//if you validate
		IhmConverter.getHDMT().removeAll();
		Component tabHDMT = IhmConverter.getHDMT();
		//Loading...
		try {
			tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
			do {	 
				file = utiMethods.createJTabbed(fc.getSelectedFile());
				if (file != null) {
				       tabHDMT = utiMethods.createJTabbed(fc.getSelectedFile());
				} 
			} while (file != null && tabHDMT == null);
			} finally {
			//when is wait off
			tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
		}
	} else if (returnVal == JFileChooser.CANCEL_OPTION) {
		//if you cancel do nothing	
	}
}

Et quand je fais un System.out.println("fc.getSelectedFile() : "+ fc.getSelectedFile() +"\n, file : "+ file +"\n, tabHDMT : "+ tabHDMT);

Code:

1
2
3
4
 
fc.getSelectedFile() : E:\2014-2016\CRP\CRDV\crdv_formation\Informatique\Bureautique\Microsoft\Excel\Application\xlac_200_kosmos.xlsx
, file : null
, tabHDMT : TABBED.TabHDMT[,2,25,568x19,layout=javax.swing.plaf.metal.MetalTabbedPaneUI$TabbedPaneLayout,alignmentX=0.0,alignmentY=0.0,border=javax.swing.border.TitledBorder@1a01e8a,flags=16777576,maximumSize=,minimumSize=,preferredSize=java.awt.Dimension[width=0,height=0],haveRegistered=false,tabPlacement=TOP]

Code:

1 2 3 4 5 6 7 do { file = utiMethods.createJTabbed(fc.getSelectedFile()); if (file != null) { tabHDMT = utiMethods.createJTabbed(fc.getSelectedFile()); } } while (file != null && tabHDMT == null);
Il n'y aucune réouverture du JFileChooser dans cette boucle... et le fait qu'on appelle 2 fois la méthodes createJTabbed, avec le même paramètre est un signe évident qu'il y a quelque chose de pas normal.

:arrow: (avec des commentaires en plus dans mon algorithme)
Citation:
Envoyé par joel.drigo
Code:

1 2 3 4 5 6 7 8 9 10 faire { fichier = JFileChooser.choisir fichier // on choisi un fichier (si pas de fichier choisi alors fichier est null) si fichier!=null alors // si un fichier est choisi tabbedpane = createTabbedPane(fichier) // on créé le tabbedpane correspondant à ce fichier fin si } tant que (fichier!=null && tabbedpane ==null) // soit tant qu'un fichier est choisi et pas de tabbedpane correspondant créé
On dirait qu'à chaque fois que tu modifies quelque chose dans ton code, tu modifies trop de trucs... (il n'y aucune raison de faire le choix du fichier en dehors de la boucle ci-dessus).

Ce test bogue :

Code:

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
 
private void btnLoad_click() 
	{
		JFileChooser fc = new FileChooser();
		Component tabHDMT = IhmConverter.getHDMT();
		File selectdFile;
		//load a file
		int load = fc.showOpenDialog(null);
		//if (load == JFileChooser.APPROVE_OPTION) {
			//if you validate
			//IhmConverter.getHDMT().removeAll();
			//Loading...
			try {
				tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
				do {	 
					//choose a file
					selectdFile = fc.getSelectedFile();	
					if (selectdFile != null) {
						//create the tabs
						tabHDMT = utiMethods.createJTabbed(fc.getSelectedFile());
					}
				} while (selectdFile != null && tabHDMT == null);
				} finally {
					//when is wait off
					tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
				}
		/*} else if (load == JFileChooser.CANCEL_OPTION) {
			//if you cancel do nothing	
		}*/
	}

Citation:

Envoyé par nadong94

Ce test bogue :

C'est à dire ? Quel test ? Que veut dire "bogue" précisément (Exception, fait ceci, fait pas cela...) ?

Sinon selectdFile = fc.getSelectedFile(); n'a jamais consisté en un choix de fichier. C'est juste la récupération de la dernière valeur sélectionné dans le JFileChooser.

Choisir un fichier c'est toute la procédure : ouverture d'un dialogue, configuration du dialogue (non obligatoire, mais c'est mieux), test de la réponse...
Code:

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 public File choisirFichier() { JFileChooser fc = new JFileChooser(); fc.setDialogTitle("Choisir un fichier Excel"); fc.setFileSelectionMode(JFileChooser.FILES_ONLY); fc.setMultiSelectionEnabled(false); fc.setAcceptAllFileFilterUsed(false); final FileFilter fileFilter = new FileFilter() { @Override public String getDescription() { return "Fichier excel (xls;xlsx)"; } @Override public boolean accept(File f) { return f.getName().matches(".*\\.xls[x]?$"); } }; fc.setFileFilter(fileFilter); if ( fc.showOpenDialog(null) == JFileChooser.APPROVE_OPTION ) { final File file = fc.getSelectedFile(); return file.exists()&&fileFilter.accept(file)?file:null; } return null; }

Ça va beaucoup mieux.
La méthodes appelant :

Code:

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
 
private void btnLoad_click() 
	{
		FileChooser fc = new FileChooser();
		Component tabHDMT = IhmConverter.getHDMT();
		File selectedFile;
		//load a file
		int load = fc.showOpenDialog(null);
		if (load == JFileChooser.APPROVE_OPTION) {
			//Loading...
			try {
				tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
				do {	 
					//choose a file
					selectedFile = fc.fileChooser();
					if (selectedFile != null) {
						//create the tabs
						tabHDMT = utiMethods.createJTabbed(fc.getSelectedFile());
					}
				} while (selectedFile != null && tabHDMT == null);
				} finally {
					//when is wait off
					tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
				}
		} else if (load == JFileChooser.CANCEL_OPTION) {
			//if you cancel do nothing	
		}
	}

et pour la méthodes choisir un fichier est-ce que ça change quelque chose si je retourne seulement un file ?
Je t'ai mis ma classe complète, la méthode est tout à la fin.

Code:

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
 
package BROWSE;
 
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.util.Locale;
 
import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.filechooser.FileFilter;
import javax.swing.filechooser.FileNameExtensionFilter;
 
/**
 * My perso JFileChooser
 * 
 * @author t0163126
 */
public class FileChooser extends JFileChooser {
 
	private static final long serialVersionUID = 1L;
 
	private final FileFilter filterExcel;
	private final String description;
	private final String xls;
	private final String xlsx;
	private File curDir;
 
	/**
         * constructor
         */
	public FileChooser() {
		// Change the JVM local in english
		Locale myLocale = Locale.ENGLISH;
		Locale.setDefault(myLocale);
		// Change the LookAndFeel :
		UIManager.getDefaults().setDefaultLocale(myLocale);
		// Change the new components
		JComponent.setDefaultLocale(myLocale);
 
		//The title dialog
		UIManager.put("FileChooser.openDialogTitleText", "I'm here : ");
		// change title
		this.curDir = this.getCurrentDirectory();
		this.setDialogTitle("" + this.curDir.getAbsolutePath());
 
		this.addPropertyChangeListener(new PropertyChangeListener() {
			public void propertyChange(PropertyChangeEvent evt) {
				if (JFileChooser.DIRECTORY_CHANGED_PROPERTY.equals(evt.getPropertyName())) {
					File curDir = getCurrentDirectory();
 
					setDialogTitle("" + curDir.getAbsolutePath());
				}
			}
		});
		// The look In label
		UIManager.put("FileChooser.lookInLabelText", "Look In :");
		// The file name label
		UIManager.put("FileChooser.fileNameLabelText", "File name :");
		// The file of type label
		UIManager.put("FileChooser.filesOfTypeLabelText", "File type :");
		// The open button
		UIManager.put("FileChooser.openButtonText", "Load it");
		//The open button tool tip
		UIManager.put("FileChooser.openButtonToolTipText", "Load selected file");
		// The cancel button
		UIManager.put("FileChooser.cancelButtonText", "Cancel");
		//The cancel button tool tip
		UIManager.put("FileChooser.cancelButtonToolTipText","Cancel");
		//The file name header button
		UIManager.put("FileChooser.fileNameHeaderText","File name");
		//The up folder button
		UIManager.put("FileChooser.upFolderToolTipText", "Up one level");
		//The desktop button tool tip
		UIManager.put("FileChooser.homeFolderToolTipText","Desktop");
		//The new folder button tool tip
		UIManager.put("FileChooser.newFolderToolTipText","Create new folder");
		//The list button tool tip
		UIManager.put("FileChooser.listViewButtonToolTipText","List");
		//The new folder button
		UIManager.put("FileChooser.newFolderButtonText","Create new folder");
		//The rename file button
		UIManager.put("FileChooser.renameFileButtonText", "Rename file");
		//The delete file button
		UIManager.put("FileChooser.deleteFileButtonText", "Delete file");
		//The details view button tool tip
		UIManager.put("FileChooser.detailsViewButtonToolTipText", "Details");
		//The size header
		UIManager.put("FileChooser.fileSizeHeaderText","Size : ");
		//The date header
		UIManager.put("FileChooser.fileDateHeaderText", "Date modified : ");
 
		/*
		//Set icons for the JFileChooser
		UIManager.put("FileView.directoryIcon", new ImageIcon(MyFileView.class.getResource("img/folder.png")));
		UIManager.put("FileChooser.homeFolderIcon", new ImageIcon(MyFileView.class.getResource("img/user-home.png")));
		UIManager.put("FileView.computerIcon", new ImageIcon(MyFileView.class.getResource("img/computer.png")));
		UIManager.put("FIleView.floppyDriveIcon", new ImageIcon(MyFileView.class.getResource("img/media-floppy.png")));
		UIManager.put("FileView.hardDriveIcon", new ImageIcon(MyFileView.class.getResource("img/drive-harddisk.png")));
		UIManager.put("FileView.fileIcon", new ImageIcon(MyFileView.class.getResource("img/file.png")));
		UIManager.put("FileChooser.upFolderIcon", new ImageIcon(MyFileView.class.getResource("img/go.png")));
		UIManager.put("FileChooser.newFolderIcon", new ImageIcon(MyFileView.class.getResource("img/folder-new.png")));
		UIManager.put("FileView.fileIcon", new ImageIcon(MyFileView.class.getResource("img/file.png")));
		UIManager.put("FileChooser.listViewIcon", new ImageIcon(MyFileView.class.getResource("img/listIcon.png")));
		UIManager.put("FileChooser.detailsViewIcon", new ImageIcon(MyFileView.class.getResource("img/details.png")));
		 */
		//Update UI
		SwingUtilities.updateComponentTreeUI(this);
 
		// Window explorer
		this.setCurrentDirectory(new File("/"));
		this.changeToParentDirectory();
 
		//Add the filter to the JFileChooser
		this.description = "Excel File (.xls, .xlsx)";
		this.xls = "xls";
		this.xlsx = "xlsx";
 
		this.filterExcel = new FileNameExtensionFilter(this.description,
				this.xls, this.xlsx);
		this.addChoosableFileFilter(filterExcel);
	}
 
	/**
         * choose a file
         * @return the file
         */
	public File fileChooser() {
		JFileChooser fc = new FileChooser();
 
		if ( fc.showOpenDialog(null) == JFileChooser.APPROVE_OPTION ) {
			final File file = fc.getSelectedFile();
			return file;//file.exists()&&fileFilter.accept(file)?file:null;
		}
		return null;
	}
}

04/04/2016, 17h07
joel.drigo

Citation:

Envoyé par nadong94

et pour la méthodes choisir un fichier est-ce que ça change quelque chose si je retourne seulement un file ?

Oui tu peux, mais dans la mesure où on peut taper n'importe quoi (y compris un fichier qui n'existe pas, qui ne respecte pas le filtre (donc pas un fichier excel)...) dans le champ du JFileChooser, tu auras une erreur de lecture plus tard. C'est comme pour le filtre, tu peux le virer et permettre à l'utilisateur de choisir un jpeg, une dll ou ce qu'il lui chante comme type de fichier, et planter à l'ouverture du Workbook. Mais c'est toujours mieux d'éviter à l'utilisateur de taper n'importe quoi, et de réagir aux cas d'erreur au plus tôt, que de planter plus tard, genre quand l'UI est déjà à moitié construite.

Avec le code précédent j'ai une ouverture pour rien car je commence par ouvrir et je rentre dans la boucle recommence l'action plus le traitement, donc j'ai changer la méthode comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 private void btnLoad_click() { FileChooser fc = new FileChooser(); Component tabHDMT = IhmConverter.getHDMT(); File selectedFile; //load a file int load = fc.showOpenDialog(null); //Loading... try { tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); do { //choose a file selectedFile = fc.fileChooser(); if (selectedFile != null) { //create the tabs tabHDMT = utiMethods.createJTabbed(fc.getSelectedFile()); } } while (selectedFile != null && tabHDMT == null); } finally { //when is wait off tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)); } }
Et avec ceux code il se passe trois chose :
1 ► quand je choisi le bon fichier il refait un tour de boucle en demandant de sélectionner un fichier comme si que le premier choix été le mauvais. Alors qu'il n'a même pas chargé le temps habituel, comme si qu'il n'y avait aucun traitement puis dans le deuxième tour je ré-sélectionne le bon fichier et là ça marche.
2 ► quand je sélectionne deux fois le mauvais fichier, il ne veut plus rien savoir. Donc à la troisième, quatrième ou plus boucles si je sélectionne le bon fichier il ré-boucle.
3 ► quand je suis sous le fileChooser de ma méthode choisir un fichier "fileChooser()" et que je fais échappe, j'ai un problème NPE avec le curseur de la sourie dans le finally

04/04/2016, 18h14
joel.drigo

Citation:

Envoyé par nadong94

1 ► quand je choisi le bon fichier il refait un tour de boucle en demandant de sélectionner un fichier comme si que le premier choix été le mauvais. Alors qu'il n'a même pas chargé le temps habituel, comme si qu'il n'y avait aucun traitement puis dans le deuxième tour je ré-sélectionne le bon fichier et là ça marche.
2 ► quand je sélectionne deux fois le mauvais fichier, il ne veut plus rien savoir. Donc à la troisième, quatrième ou plus boucles si je sélectionne le bon fichier il ré-boucle.

Parce que tu t'obstines à conserver du code qui n'est pas nécessaire, vu que je t'ai dit de faire différemment (faire différemment sous entend remplacer, pas ajouter).
Comme ça

Code:

Component tabHDMT = IhmConverter.getHDMT();

comment ça se fait qu'on est dans une méthode censée créer tabHDMT et qu'on va chercher un tabHDMT ? Si on le créé, c'est qu'il n'existe pas : alors on va chercher quoi avant qu'il n'existe ?

ou ça

Code:

int load = fc.showOpenDialog(null);

Normal que le JFileChooser s'ouvre et que ça ne fait rien après le choix : le choix de ce JFileChooser n'est pas exploité : c'est normal d'ailleurs, parce que le seul qui est nécessaire, c'est celui qui est dans la boucle.

Citation:

Envoyé par nadong94

3 ► quand je suis sous le fileChooser de ma méthode choisir un fichier "fileChooser()" et que je fais échappe, j'ai un problème NPE avec le curseur de la souris dans le finally

C'est parce que tu gères le curseur sur un composant qu'on est censé créé dans cette méthode (voir ci-avant) et qu'en plus il y a des cas où ce composant ne sera pas créé (pas d'onglet avec "dbs" dedans) : donc tu ne peux pas utiliser ce composant justement parce qu'il n'est pas censé exister avant qu'on le créé, et qu'il est même ne censer jamais exister si on choisi un fichier qui ne peut pas être affiché. Prend simplement son conteneur à la place (d'autant plus que tu en a besoin pour ajouter le JTabbedPane créé).

Citation:

Envoyé par joel.drigo

Comme ça

Code:

Component tabHDMT = IhmConverter.getHDMT();

comment ça se fait qu'on est dans une méthode censée créer tabHDMT et qu'on va chercher un tabHDMT ? Si on le créé, c'est qu'il n'existe pas : alors on va chercher quoi avant qu'il n'existe ?

C'est parce que tu gères le curseur sur un composant qu'on est censé créé dans cette méthode (voir ci-avant) et qu'en plus il y a des cas où ce composant ne sera pas créé (pas d'onglet avec "dbs" dedans) : donc tu ne peux pas utiliser ce composant justement parce qu'il n'est pas censé exister avant qu'on le créé, et qu'il est même ne censer jamais exister si on choisi un fichier qui ne peut pas être affiché. Prend simplement son conteneur à la place (d'autant plus que tu en a besoin pour ajouter le JTabbedPane créé).

En fait, ce n'est pas tabHDMT que l'on crée mais ses sous onglets. C'est-pourquoi j'ai mis le curseur sur lui. Je ne veux pas que le deuxième onglet principale qui est tabNEMO soit dépendant du premier onglet, d'ailleurs le curseur est valide qu'à l'intérieur de l'onglet en question, que se soit l'un ou l'autre.

Mais comme tu l'as dis il faudrait que le curseur ne change pas si je ne choisi pas de fichier valide ou que je fasse échappe.

Pour le reste il agis correctement.

Je tante autre chose mais NPE sur le curseur :
Code:

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 private void btnLoad_click() { FileChooser fc = new FileChooser(); Component tabHDMT = IhmConverter.getHDMT(); File selectedFile; int i = 0; do { //DBS message after the first selection if (i > 0) { JOptionPane .showMessageDialog(null, Final.getMsgDBS(), Final.getMsgDBSTitle(), JOptionPane.WARNING_MESSAGE); } // choose a file selectedFile = fc.fileChooser(); if (selectedFile != null) { //try { // Loading... tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); // create the tabs tabHDMT = utiMethods.createJTabbed(selectedFile); /*} finally { // when is wait off tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)); }*/ } i++; } while (selectedFile != null && tabHDMT == null); }

Citation:

Envoyé par nadong94

En fait, ce n'est pas tabHDMT que l'on crée mais ses sous onglets.

Dans ce cas, ta méthode createJTabbedPane, qui devrait s'appeller populateJTabbedPane ne devrait pas retourner un JTabbedPane, mais un boolean, pour dire ça été rempli, ou pas (return false au lieu de return null, et return true au lieu de return tabbedPrincipal.

Et la boucle devient tout simplement :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 private void btnLoad_click() { FileChooser fc = new FileChooser(); Component tabHDMT = IhmConverter.getHDMT(); File selectedFile; try { tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); boolean filled=false; do { //choose a file selectedFile = fc.fileChooser(); if (selectedFile != null) { //create the tabs filled = utiMethods.createJTabbed(fc.getSelectedFile()); } } while (selectedFile != null && !filled); } finally { //when is wait off tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)); } }

Ahh voilà qui est parfait.

Merci beaucoup :) :) :)

Méthode appelant :

Code:

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
 
private void btnLoad_click() {
	FileChooser fc = new FileChooser();
	Component tabHDMT = IhmConverter.getHDMT();
	File selectedFile;
	try {
		tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
		boolean filled = false;
		int i = 0;
		do {
			// DBS message after the first selection
			if (i > 0) {
				JOptionPane
						.showConfirmDialog(null, Final.getMsgDBS(),
								Final.getMsgDBSTitle(),
								JOptionPane.WARNING_MESSAGE);
			}
			// choose a file
			selectedFile = fc.fileChooser();
			if (selectedFile != null) {
				// create the tabs
				filled = utiMethods.populateJTabbedPane(selectedFile);
			}
			i++;
		} while (selectedFile != null && !filled);
	} finally {
		// when is wait off
		tabHDMT.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
	}
}

Et maintenant la classe complète sans les imports UtilityMethods :

Code:

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
 
package EVENT;
 
/**
 * Some utility methods for the application
 * 
 * @author t0163126
 */
public class UtilityMethods {
	private Workbook wb;
	private Sheet sheet;
	private Cell cell;
	private Row row;
 
	// Constructor
	public UtilityMethods() {
	}
 
	/**
         * Create tabs based on file and panel
         * 
         * @param tabPanel
         * @param file
         * @return
         */
 
	public boolean populateJTabbedPane(File file) {
		// Celui-ci est l'onglet principal, c'est à lui que les sous-onglets
		// reviennent
		final JTabbedPane tabbedPrincipal = IhmConverter.getHDMT();
		try {
			wb = WorkbookFactory.create(file);
			// on récupère ses sous-onglets grâce à la méthode createPanels
			List<JPanel> lstPanel = createPanels(wb);
			if (lstPanel.isEmpty()) {
				return false;
			} else {
				// on ajoute les sous-onglets à l'onglet principal au fur et à mesure
				for (JPanel panel : lstPanel) {
					// panel.setName(sheet.getSheetName());
					tabbedPrincipal.add(panel.getName(), panel);
 
					// puis on les ajoutes
					tabbedPrincipal.add(panel);
				}
				// maintenant qu'il est rempli de sous onglet je met un changeListener
				tabbedPrincipal.addChangeListener(new Changes(tabbedPrincipal));
			}
			wb.close();
		} catch (IOException e) { 
			e.printStackTrace(); 
		} catch (EncryptedDocumentException e) {
			e.printStackTrace();
		} catch (InvalidFormatException e) {
			e.printStackTrace();
		}
		return true;
	}
 
	/**
         * Create a tab panel by excel feel
         * 
         * @param fileName
         * @param excelFile
         * @return panel list
         */
	private List<JPanel> createPanels(Workbook workbook) {
		JTable spreadsheet = null;
		// celui-ci est un sous-onglet auquel on va ajouter à l'onglet principal
		JPanel panel = null;
		// celui-ci va récupérer la list de tous les sous-onglets
		List<JPanel> lstPanel = new ArrayList<JPanel>();
		int nbFeuilles = 0;
 
		try {
			// Zip bomb detected! The file would exceed the max. ratio of
			// compressed file size to the size of the expanded data.
			// This may indicate that the file is used to inflate memory usage
			// and thus could pose a security risk.
			// You can adjust this limit via ZipSecureFile.setMinInflateRatio()
			// if you need to work with files which exceed this limit. Counter:
			// 827392, cis.counter: 8192, ratio: 0.009900990099009901Limits:
			// MIN_INFLATE_RATIO: 0.01
			final Double ratio = 0.009900990099009901;
			ZipSecureFile.setMinInflateRatio(ratio);
 
			nbFeuilles = workbook.getNumberOfSheets();
			for (int i = 0; i < nbFeuilles; i++) {
				sheet = workbook.getSheetAt(i);
				// Create one spreadsheet by excel feel
				spreadsheet = sheetToJTable(sheet);
				if (spreadsheet != null) {				 
					spreadsheet.setEnabled(false);
					spreadsheet.setFont(Final.getFont());
					spreadsheet.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
					JScrollPane elevator = new JScrollPane(spreadsheet,
							JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
							JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
					elevator.getViewport().setBackground(Color.WHITE);
 
					// Create a tab by excel feel number
					panel = new JPanel();
					panel.setLayout(new BorderLayout());
					// TitledBorder
					panel.setBorder(BorderFactory.createTitledBorder(sheet
							.getSheetName()));
					panel.setName(sheet.getSheetName());
					panel.setBackground(Color.LIGHT_GRAY);
					// on lui ajoute un ascenseur
					panel.add(elevator, BorderLayout.CENTER);
 
					lstPanel.add(panel);
				}
			}
			workbook.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (EncryptedDocumentException e) {
			e.printStackTrace();
		}
		return lstPanel;
	}
 
	/**
         * Create a JTable depending on the file and the entry sheet number
         * 
         * @param file
         * @param numSheet
         * @return the table
         */
	private JTable sheetToJTable(Sheet sheet) {
		// Create new table
		JTable table = new JTable();
		// Reading the excel file
		// Count the line number
		int nbRows = sheet.getLastRowNum();
		// Count the column number
		int nbColumns = numberMaxColumn(sheet);
		// Create new object array
		Object[][] obj = new Object[nbRows][nbColumns];
 
		// table header
		String[] header = new String[nbColumns];
 
		// Browsing the sheet and retrieves the lines one by one
		for (int rowContent = 0; rowContent < nbRows; rowContent++) {
			row = sheet.getRow(rowContent);
			// Browsing the line and retrieves the columns
			if (row != null) {
				for (int columnContent = 0; columnContent < nbColumns; columnContent++) {
					// Retrieves the cell and this value but begging at "dbs"
					cell = row.getCell((short) columnContent);
					final Object value = contentCell(cell);
					obj[rowContent][columnContent] = value;
				}
			}
		}
 
		// recovery of adequate lines
		final Object[][] recorvery = new Object[nbRows][nbColumns];
		int index = -1; // indicates the index of the next line to recover,
						// except of -1
		for (int i = 0; i < nbRows; i++) {
			if (i == 0) { // the first line: the headers
				// Recovering the headers
				for (int j = 0; j < nbColumns; j++) {
					header[j] = String.valueOf(obj[i][j]);
				}
			} else {
				if (index < 0) { // we found nothing, so we are searching
					for (int j = 0; j < nbColumns; j++) {
						if ("dbs".equals(obj[i][j])) { // we found a line that
														// contains "dbs"
							index = 0;
							break; // needn't to search in this line
						}
					}
				}
 
				if (index >= 0) { // we found a line that contained "dbs", then copy
					// copy the lines after the first that contains "dbs" including this one
					for (int j = 0; j < nbColumns; j++) { // copy the full line
						recorvery[index][j] = obj[i][j];
					}
					index++; // we advance in the recovery table
				}
 
			}
 
		}
 
		if (index >= 0) {
			// we found lines : are recovered
			Object[][] result = Arrays.copyOf(recorvery, index); // index corresponds to the number of rows found
			table.setModel(new DefaultTableModel(result, header));
 
		} else {
			//if we don't found "dbs"
			return null;
		}
		table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
		return table;
	}
 
	/**
         * The cell can contain different type of value that should be specifically
         * recovered
         * 
         * @param cell
         * @return
         */
	private Object contentCell(Cell c) {
		Object value = null;
 
		if (c == null) {
			value = "";
		} else if (c.getCellType() == Cell.CELL_TYPE_BOOLEAN) {
			value = c.getBooleanCellValue();
		} else if (c.getCellType() == Cell.CELL_TYPE_ERROR) {
			value = c.getErrorCellValue();
		} else if (c.getCellType() == Cell.CELL_TYPE_FORMULA) {
			value = c.getCellFormula();
		} else if (c.getCellType() == Cell.CELL_TYPE_NUMERIC) {
			value = c.getNumericCellValue();
		} else if (c.getCellType() == Cell.CELL_TYPE_STRING) {
			value = c.getStringCellValue();
		}
		return value;
	}
 
	/**
         * Retrieves the maximum number of column. If a line has 2 empty boxes at
         * the end , they are not taken into account. So to retrieve the number of
         * columns to initialize our table we must browse all lines
         * 
         * @param sheet
         * @return
         */
	private int numberMaxColumn(Sheet st) {
		int r = st.getLastRowNum();
		int max = 0;
		int s = 0;
		while (s < r) {
			if (st.getRow(s) != null) {
				int c = st.getRow(s).getLastCellNum();
				if (c > max) {
					max = c;
				}
			}
			s++;
		}
		return max + 1;
	}
}

Voir 40 message(s) de cette discussion en une page