Fenêtre pour sélectionner un dossier

Version imprimable

13/05/2013, 16h33
Leniouns

Fenêtre pour sélectionner un dossier

Bonjour à tous,

J'aimerai savoir comment faire avec SWT pour que lorsque l'on clique sur un bouton une fenêtre apparait pour ensuite pouvoir sélectionner un dossier.

J'ai trouvé ça sur le forum :
http://www.developpez.net/forums/d16...er-repertoire/

Cependant j'ai un problème, j'ai créé une classe à part pour mes écouteurs. Je ne sais donc pas comment récupérer mon bouton et je ne peux également pas utiliser shell.

Je vous remercie de votre aide, je suis débutant.

Cordialement,

Leniouns

Salut,

tu enregistre bien un écouteur sur ton bouton, genre :

Code:

1
2
3
4
5
6
7
8
9
10
11
button.addSelectionListener(new SelectionListener() {
 
	public void widgetSelected(SelectionEvent e) {
					...
			}
 
	public void widgetDefaultSelected(SelectionEvent e) {
				....
	}
 
});

l'évenement te permet de connaitre la source de l'évenement, donc le bouton, donc obtenir son shell

Code:

((Button)e.widget).getShell()

donc tu peux faire :

Code:

DirectoryDialog directoryDialog = new DirectoryDialog(((Button)e.widget).getShell());

Pour récupérer le dossier sélectionné et le traiter, tout dépend ce que tu cherches à faire au juste. Soit tu le fais en direct :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
button.addSelectionListener(new SelectionListener() {
 
			public void widgetSelected(SelectionEvent e) {
					DirectoryDialog directoryDialog = new DirectoryDialog(((Button)e.widget).getShell());
					/*directoryDialog.setText(title);
					directoryDialog.setMessage(dialogMessage);
					if (defaultDirectory != null && defaultDirectory.isDirectory()) {
						directoryDialog.setFilterPath(defaultDirectory.getAbsolutePath());
					}*/
					String path = directoryDialog.open();
					if (path != null) {
						File file = new File(path);
						// la tu fais ce que tu veux du dossier sélectionné
 
					} 
			}
 
			public void widgetDefaultSelected(SelectionEvent e) {
				// TODO Auto-generated method stub
 
			}
 
		});

sinon il te faudra mettre une référence à un "handler" lorsque tu créés l'événement

exemple simplifié :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public class DirectoryHandler {
 
    private File directory;
    public void setDirectory(File directory) {
        this.directory=directory;
    }
 
    public File getDirectory() {
         return directory;
    }
 
}

ta variable DirectoryHandler directoryHandler doit être accessible depuis le code de traitement du dossier sélectionné et du code de sélection du dossier (notre évenement de bouton), par exemple en static (pas beau, mais bon, au moins ça marche quelque soit la structure complète de ton code, que je connais pas pour le coup)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
button.addSelectionListener(new SelectionListener() {
 
			public void widgetSelected(SelectionEvent e) {
					DirectoryDialog directoryDialog = new DirectoryDialog(((Button)e.widget).getShell());
					/*directoryDialog.setText(title);
					directoryDialog.setMessage(dialogMessage);
					if (defaultDirectory != null && defaultDirectory.isDirectory()) {
						directoryDialog.setFilterPath(defaultDirectory.getAbsolutePath());
					}*/
					String path = directoryDialog.open();
					if (path != null) {
						File file = new File(path);
						directoryHandler.setDirectory(file);
					} 
			}
 
			public void widgetDefaultSelected(SelectionEvent e) {
				// TODO Auto-generated method stub
 
			}
 
		});

14/05/2013, 09h26
Leniouns
Bonjour.

Tout d'abord merci pour ton aide.

En fait j'enregistre bien un écouteur sur mon bouton mais par contre je traite les évènements dans une classe externe pour ne pas surcharger la classe de ma vue.

Ainsi :
Code:

1 2 3 4 5 6 7 8 public void widgetSelected(SelectionEvent e) { ... } public void widgetDefaultSelected(SelectionEvent e) { .... }
se trouve dans une autre classe implémentant SelectionListener. Ma question est donc dans cette classe comment récupérer les éléments graphiques de la vue ?

Je vous remercie de votre aide :D

Salut,

du manière ou d'une autre il faut une référence sur les éléments graphiques dont tu veux récupérer des informations et sur ceux dont tu veux changer l'état.

si ta vue (si tu parles bien d'un composant graphique, genre shell, composite, etc...) est celle qui contient ton bouton, tu pourrais remonter à ta vue en utilisant la méthode getParent() de ton bouton (récupéré) dans ton évenement.

personnellement je n'aime pas ce genre de solution : elle est lourde, verbeuse, plutôt lente et récupérer le bon élément graphique oblige des tests un peu pourri du genre instanceof Shell, ou pire.

lorsque je dois faire ce genre de chose, j'utilise personnellement un controlleur. Une classe chargé de référencer les composants graphiques censés pouvoir communiquer entre eux. L'implémentation du controlleur peut être métier, ce qui permet pas la suite de changer facilement l'interfacage entre les composants voire d'utiliser ces composants dans différents contextes graphiques.

Ensuite quand tu créées ton évenement, tu passes ton controlleur à ton évenement dans le constructeur.

Le handler dont je parlais précédemment est une forme de controlleur.

Par exemple, le controlleur pourrait être être basée sur une interface :
Code:

1 2 3 public interface IDirectoryView { void updateView(File directory); }
Ensuite tu fais un truc dans le genre par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public class TableDirectoryViewer implements IDirectoryViewer { public void TableDirectoryViewer(Composite parent, int style) { table = new Table(parent, style); .... } public void updateViewer(File directory) { ... mise à jour du contenu de la table avec les fichiers du dossier par exemple } }
pour ton écouteur, tu peux faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public void DirectorySelectionListener implements SelectionListener { public DirectorySelectionListener(IDirectoryView view) { this.view=view; } public void widgetSelected(SelectionEvent e) { ... this.view.updateView(directory); } public void widgetDefaultSelected(SelectionEvent e) { .... } }
A un moment donné tu vas bien créer tous tes composants graphiques dans un code commun qui pourra passer la référence de ton controlleur à ton écouteur

Si tu veux encore moins de couplage, tu peux faire un controlleur sous la forme :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class DirectoryViewController implements IDirectoryView { private IDirectoryView view; // on peut utiliser un constructeur à la place de ce mutateur pour un couplage fort non mutable public void setView(IDirectoryView view) { this.view=view; } public void updateView(File directory) { this.view.updateView(directory); } }
tu peux créer ton controlleur dans le code commun,

Code:

controller=new DirectoryViewController();

le transmettre au code qui créé ton bouton, donc à ton écouteur :

Code:

button.addSelectionListener(new DirectorySelectionListener(controller));

puis à ton code créant ta vue :
Code:

1 2 ...view = createView(); controller.setView(view)
tu peux bien sur faire un controlleur adapté directement à ton composant graphique si tu veux, par exemple si ta vue est une table :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class TableController implements IDirectoryView { private Table view; public void setView(Table view) { this.view=view; } public void updateView(File directory) { .. mise à jour de la table } }
si tu fais de cette classe une abstraction, on peut imaginer :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public abstract class AbstractDirectoryTableController implements IDirectoryView { private Table view; public void setView(Table view) { this.view=view; } public void updateView(File directory) { ... data = getData(directory); .. mise à jour de la table avec les data } protected ... getData(File directory) ; }
et faire par exemple
Code:

1 2 3 4 5 6 7 8 9 10 11 public class DirectoryContentTableController extends AbstractDirectoryTableController { protected ... getData(File directory) { ... = firectory.listFiles(); ... return ...; } }
etc...

Merci de ton aide.

Alors voilà ce que j'ai fait, je ne suis pas sûr que ce soit la bonne méthode. Je n'ai pas utilisé de contrôleur.

J'ai une classe pour mon interface graphique :

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
package com.eclipse.rcp.app1.view;
 
import com.eclipse.rcp.app1.controller.DirectorySelectionListener;
 
public class Parametrage extends ViewPart {
 
	public Parametrage() {
		// TODO Auto-generated constructor stub
	}
 
	@Override
	public void createPartControl(Composite parent) {
		createEtape1(parent);
 
	}
 
	@Override
	public void setFocus() {
		// TODO Auto-generated method stub
 
	}
 
	public void createEtape1(Composite parent){
 
		GridLayout lieuAffaire = new GridLayout(3,false);
		parent.setLayout(lieuAffaire);
		lieuAffaire.marginLeft = 300;
 
		Label labelTitre = new Label(parent,SWT.NONE);
		labelTitre.setText("Sélection du lieu de l'affaire et des matrices de test");
		labelTitre.setFont(new Font(null,"Arial",18,0));
		GridData titreGD = new GridData(GridData.FILL_HORIZONTAL);
		titreGD.horizontalSpan = 3;
		titreGD.heightHint = 70;
		titreGD.horizontalIndent = -45;
		titreGD.verticalIndent = 20;
		labelTitre.setLayoutData(titreGD);
 
		Label labelLieu = new Label(parent, SWT.NONE);
		labelLieu.setText("Lieu de l'affaire : ");
		labelLieu.setFont(new Font(null,"Arial",13,0));
		Text textLieu = new Text(parent, SWT.BORDER);
		textLieu.setText("Chemin de l'affaire");
		textLieu.setFont(new Font(null,"Arial",13,0));
		GridData affaireGD = new GridData(GridData.CENTER);
		affaireGD.widthHint = 220;
		textLieu.setLayoutData(affaireGD);
		Button btnLieuAffaire = new Button(parent, SWT.NONE);
		btnLieuAffaire.setText("...");
		btnLieuAffaire.addSelectionListener(new DirectorySelectionListener(textLieu));

Et une classe pour le traitement de mon bouton.

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
 
package com.eclipse.rcp.app1.controller;
 
public class DirectorySelectionListener implements SelectionListener {
 
	final IWorkbench workbench = PlatformUI.getWorkbench();
	final Display display = workbench.getDisplay();
    Shell shell = new Shell (display);
 
	private Text textLieu;
 
    public DirectorySelectionListener(Text textLieu){
    	this.textLieu = textLieu;
    }
	@Override
	public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent evt) {
		// TODO Auto-generated method stub
 
	}
 
	@Override
	public void widgetSelected(org.eclipse.swt.events.SelectionEvent evt) {
		// TODO Auto-generated method stub
		DirectoryDialog leDialogue = new DirectoryDialog(shell, SWT.OPEN);
		leDialogue.setText("Choix du répertoire");
		try
		{
			textLieu.setText(leDialogue.open());
		}
		catch (IllegalArgumentException e) {}
 
	}
}

Bon ça marche mais j'ai l'impression que ma méthode n'est pas très bonne.

14/05/2013, 11h28
joel.drigo
Oui c'est une façon de faire aussi, peu extensible, mais elle a le mérite d'être simple. ça dépend si tu fais un petit programme pour toi, ou si tu fais une application industriel avec tes composants réutilisables.

toutefois, il y a une chose qu'il vaut mieux faire :
Code:

1 2 3 4 String dir=lleDialogue.open(); if ( dir!=null ) { dialoguetextLieu.setText(dir); }
c'est une bonne habitude à prendre plutôt que d'utiliser des try catch pour récupérer des exceptions : une habitude pour la clarté du code déjà mais également pour les performances à l'exécution, et c'est plus propre de mon point de vue.

quand tu sais que tu vas faire un truc qui va planter, ne le fais pas, plutôt que de le faire en catchant l'exception,
14/05/2013, 13h38
Leniouns

Disons qu'il s'agit d'une application industrielle. Mais étant débutant je ne sais pas trop comment faire.

Et sinon j'ai une autre question. Dans mon cas je met en paramètre le Text que je modifierai par la suite. Par contre il y a-t-il un moyen de récupérer le boutons qui reçoit l'évènement sans le mettre en paramètre ?

Edit : J'ai trouvé comment faire pour récupérer l'objet déclenchant l'évènement. Il faut utiliser evt.getSource().

Par contre comment faire ensuite pour savoir qu'il s'agit du bouton Btn1 par exemple et non du bouton Btn2 ?

En fait je me demanse tou simplement comment je dois faire si en cliquant sur un bouton plusieurs éléments de l'interface changent ? Dois-je mettre tous les éléments de l'interface dans une sorte de liste que je mettrai en paramètre de mon écouteur ? Pour ensuite pouvoir traiter n'importe quel de mes éléments ?

Merci de votre aide.