Discussion :

[BiM]

Bonjour,

Je voudrais pouvoir fermer automatiquement le ou les éditeurs ouverts pour un fichier quand je fais une action sur celui-ci.

J'explique...
J'ai une vue dans laquelle j'appuie sur laquelle je sélectionne un fichier et j'appuie sur le bouton Fermer. Je veux alors que tous les éditeurs ouverts pour ce fichier se ferment.

Comment feriez-vous ?

J'ai plusieurs solutions en tête :

• Scanner toutes les Window, Page, EditorReference :
  

  Code Java :

  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
  IWorkbenchWindow windows[] = PlatformUI.getWorkbench().getWorkbenchWindows();
  for (IWorkbenchWindow window : windows)
  {
  	IWorkbenchPage pages[] = window.getPages();
  	for (IWorkbenchPage page : pages)
  	{
  		IEditorReference references[] = page.getEditorReferences();
  		for (IEditorReference reference : references)
  		{
  			IEditorInput editor = reference.getEditorInput();
  			String monChemin = null;
   
  			if (editor instanceof MonEditeur1)
  			{
  				monChemin = // Première méthode de récupération
  			}
  			else if (editor instanceof MonEditeur2)
  			{
  				monChemin = // Deuxième méthode de récupération
  			}
  			else
  			{
  				monChemin = editor.getName();
  			}
   
  			if (monChemin.equals(monFichier.getAbsolutePath()))
  			{
  				//Fermeture de l'éditeur
  			}
  		}
  	}
  }

• Passer par un contrôleur qui stockerait une Map<String, List<Editeur>> où la clef est le chemin complet du fichier. Editeur reste un type à définir : IEditorInput, IEditorReference, autre ?

Il y a très très (enfin je l'espère) probablement une solution plus simple.

PS : A noter que j'ai extrêmement simplifié le problème.

[BiM]

En attendant que quelqu'un m'apporte une meilleure solution, j'ai opté pour la deuxième solution. Seulement, je ne sais pas si je doit créer une action close sur mon éditeur et quelle action je dois appeler du style monEditeur.close() sauf que j'aimerais que la sauvegarde s'effectue si l'utilisateur est d'accord et bien sûr et surtout j'aimerais connaître le type sur lequel je dois faire cette action (IEditorInput, IEditorPart, mon implémentation ou héritage d'éditeur de AbstractTextEditor par exemple, autre chose ?).

[Gueritarish]

Salut BiM,

Alors malheureusement, j'ai pas de "meilleure" solution à t'apporter . Un autre développeur Eclipse passera sûrement corriger la tienne (si elle en a besoin). Par contre, pour ce qui est de la sauvegarde de ton Editeur, là, je peux t'aider (ouf.. l'honneur est sauf).
Donc, à mon sens, tu n'as pas besoin de créer d'action close puisqu'Eclipse gère ça très bien tout seul. Par contre, si tu veux proposer la sauvegarde à ton utilisateur, tu peux faire implémenter l'interface ISaveablePart2 à ton Editor. Cette interface définit 2 méthodes :

• isSaveOnCloseNeeded qui te permet de définir si la sauvegarde est nécessaire à la fermeture de l'Editor.

• promptToSaveOnClose qui te permet de définir la manière dont l'utilisateur sera "informé" de la fermeture de l'Editor (tu peux donc définir une boite de dialogue différente de celle proposé).

Voilà, à+
Gueritarish

[BiM]

Merci Gueri mais en fait j'ai trouvé la solution que je vais poster d'ailleurs...

Pour expliquer un peu le contexte, j'ai une vue (que j'ai faite) dans laquelle mes fichiers sont listés (d'une manière un peu particulière). Il y a des boutons activés ou non selon le fichier sélectionné. Si j'appuie sur un bouton, cela effectue une action ou plusieurs sur mon fichier (effacer, envoyer un fichier à un serveur etc.).

Pour certaines de ces actions (par exemple supprimer), je dois d'abord fermer l'éditeur puis supprimer mon fichier (et deux trois autres trucs dont on se fiche pour cette question). Pour une autre, je dois ouvrir le fichier. Et encore pour une autre, je dois fermer puis réouvrir le fichier (parce qu'il a été effacé puis rechargé sous un autre nom entre temps).

Bon bref, j'ai deux types d'éditeurs, un éditeur dérivé d'AbstractTextEditor et un autre d'un éditeur multipage de BIRT. Leur premier héritage/interface en commun est IEditorPart.

Problème, IEditorPart n'a pas de méthode close() définie et mes deux éditeurs ont chacun leur méthode close(boolean).

J'ai donc créé une interface qui est implémentée par les deux classes qui oblige à redéfinir la méthode close() (on l'appelera IPersoEditor) :

Code Java :

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

1
2
3
4
5
6
7
8
9
10
/**
 * Interface permettant de définir une méthode close() pour les deux éditeurs.
 * 
 * @author BiM
 *
 */
public interface IDesignerEditor
{	
	public void close(Boolean save);
}

Donc chacun de mes éditeurs implémente cette interface, voici un exemple simplifié :

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
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.texteditor.AbstractTextEditor;
 
public class SimpleEditor extends AbstractTextEditor implements IPersoEditor
{
	private String filename = null;
 
	private IPartListener listener = new IPartListener()
	{
		public void partActivated(IWorkbenchPart arg0) {}
 
		public void partBroughtToTop(IWorkbenchPart arg0) {}
 
		public void partClosed(IWorkbenchPart part)
		{
			closeActions(part);
		}
 
		public void partDeactivated(IWorkbenchPart arg0) {}
 
		public void partOpened(IWorkbenchPart part)
		{
			openActions(part);
		}
	};
 
	/* ... */
 
	@Override
	public void init(IEditorSite site, IEditorInput input) throws PartInitException
	{
		super.init(site, input);
 
		filename = ((PersoEditorInput)input).getFileName();
		getSite().getPage().addPartListener(listener);
	}
 
	private void openActions(IWorkbenchPart part)
	{
		if (part.equals(this))
		{
			PersoController.addEditor(filename, this);
		}
	}
 
	private void closeActions(IWorkbenchPart part)
	{
		if (part.equals(this))
		{
			PersoController.removeEditor(filename, this);
			getSite().getPage().removePartListener(listener);
		}
	}
 
	public void close(Boolean save)
	{
		getSite().getPage().closeEditor(this, save.booleanValue());
	}
}

Dans la méthode init(), je récupère le nom du fichier et le stocke puis je met un Listener sur les événements du WorkbenchPart. Je m'occupe particulièrement de l'événement d'ouverture et de fermeture :

• Ouverture : Ajout de l'éditeur au contrôleur avec le nom de fichier
• Fermeture : Suppression de l'éditeur au contrôleur

J'ai également redéfini close(boolean) à laquelle je n'ai volontairement pas appelé directement la méthode close(boolean) du parent. Cette méthode passe la fermeture de l'éditeur en mode asynchrone ce qui a pour conséquence que je ne peux pas directement réouvrir un éditeur pour le même fichier juste derrière.

Maintenant, vous allez me dire "C'est bien d'avoir passé tes éditeurs au contrôleur, mais comment as-tu fait côté contrôleur ?".

Code Java :

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
import java.io.File;
import java.util.ArrayList;
import java.util.List;
 
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
 
public final class PersoController
{
	private static Map<String, List<IPersoEditor>> editeurs = new HashMap<String, List<IPersoEditor>>();
 
	public void open(File file)
	{
		IEditorInput input = new PersoEditorInput(file);
		IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
 
		try
		{
			page.openEditor(input, SimpleEditor.ID);
		}
		catch (PartInitException e)
		{
			e.printStackTrace();
		}
	}
 
	public void transform(File file)
	{
		Boolean isOpen = closeEditors(file.getName(), Boolean.TRUE);
 
		effacer(file);
		file = recharger(file);
		sauvegarde(file);
 
		if (isOpen)
		{
			open(file);
		}
	}
 
	public void effacer(File file)
	{
		closeEditors(file.getName(), Boolean.FALSE);
		file.delete();
	}
 
	public static void addEditor(String fileName, IPersoEditor editor)
	{
		List<IPersoEditor> liste = editeurs.get(fileName);
		if (liste == null)
		{
			liste = new ArrayList<IPersoEditor>();
		}
		liste.add(editor);
		editeurs.put(fileName, liste);
	}
 
	public static void removeEditor(String fileName, IPersoEditor editor)
	{
		List<IPersoEditor> liste = editeurs.get(fileName);
		if (liste != null)
		{
			liste.remove(editor);
			editeurs.put(fileName, liste);
		}
	}
 
	public static Boolean closeEditors(String fileName, Boolean save)
	{
		List<IPersoEditor> liste = editeurs.remove(fileName);
 
		if (liste == null || liste.isEmpty())
		{
			return Boolean.FALSE;
		}
 
		for (IPersoEditor editor : liste)
		{
			editor.close(save);
		}
 
		return Boolean.TRUE;
	}
 
	/* ... Quelques autres méthodes... */
}

En gros, on a ici une méthode pour ajouter des éléments dans la Map d'éditeurs et de même pour retirer. Puis une méthode qui permet de fermer tous les éditeurs liés à un fichier.

Ensuite on a quelques méthodes qui permettent d'ouvrir, ou supprimer un fichier ainsi qu'une transformation qui correspond à fermeture des éditeurs, transformation du fichier puis réouverture d'un éditeur s'il y en avait d'ouverts.

Voilà, si vous avez des questions, n'hésitez pas !

Précision : J'explique quand même à quoi correspond le booléen au niveau du close() parce que ce n'est pas clair dans la JavaDoc. S'il est à VRAI, alors Eclipse demande si on veut sauvegarder les fichiers non sauvegardés. S'il est à faux, il ferme l'éditeur sans sauvegarder.