[Preferences] Sauvegarde automatique des préférences sur une vue

Bonjour,

je travaille depuis peu sur le développement de plugin Eclipse.
Là, je bosse sur une vue qui affiche une Table et je dois y ajouter des fonctionnalités (déplacement colonne, redimensionnement, etc.) et je souhaite sauvegarder automatiquement la configuration de cette table afin de la réouvrir avec cette même configuration ultérieurement.

J'essaye de m'inspirer de ce qui est fait avec les vues "Errors" et "Errors log", mais là je bloque sur la manière dont il est possible de sauvegarder les préférences de l'utilisateur sur l'organisation de sa table. Je pense stocker les infos dans un fichier de préférences au format XML, mais je ne sais pas où se stockent ce genre d'infos et quel structure adopter.

Si quelqu'un peut m'aiguiller vers des tuto ou des exemples...
Merci d'avance

Je ne connais pas particulièrement de tuto, mais il faut que tu cherches dans la direction du "preference store" d'Eclipse. La plateforme se charge déjà de conserver les préférences, ne réinvente pas la roue. Il te faudra ajouter une page de préférence (c'est un point d'extension particulier) pour ton plugin.

J'ai trouvé un vieux tuto, cependant il doit être dépassé, mais ça peut t'aider quand même.

http://www.eclipse.org/articles/Arti...references.htm

ok, merci, je vais lire ça tout de suite.;)

1. Tu crée une classe pour initialiser tes préférences. Cette classe étend AbstractPreferenceInitializer.

Code:

1
2
3
4
5
6
7
8
 
public class PreferenceInitializer extends AbstractPreferenceInitializer {
 
	public void initializeDefaultPreferences() {
		IPreferenceStore store = Activator.getDefault().getPreferenceStore();
 
		store.setDefault(key,
				value);

2. Cette ligne te permet de récupérer ton IPreferenceStore pour ton plugin :

Code:

1
2
 
IPreferenceStore store = Activator.getDefault().getPreferenceStore();

3. Tu crée ta page de préférence. Une solution simple consiste à étendre FieldEditorPreferencePage.

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
 
public class DataPreferenceView extends FieldEditorPreferencePage
		implements IWorkbenchPreferencePage {
 
	/**
         * ID of the view.
         */
	public static final String ID = "Pref.Data";
 
	public DataPreferenceView() {
		super(GRID);
		// Tu initialise le IPreferenceStore pour ta vue.
setPreferenceStore(Activator.getDefault().getPreferenceStore());
		setDescription("le titre de ta page de préférence");
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see fr.cnes.fop.util.FieldEditorPreferencePage#createFieldEditors()
	 */
	@Override
	protected void createFieldEditors() {
		// Tu crée des champs dans ta page préférence. Ici un champ pour récupérer un Directory.
addField(new DirectoryFieldEditor(
				key,
				"Label:", getFieldEditorParent()));
	}

4. Tu utilise IPrefrenceStore pour faire des get et des set de tes préférences stockées.

Je fais remonter ce post car j'ai vaguement le même problème.

Je voudrais pouvoir sauvegarder toutes mes configurations comme fait eclipse avec le workspace... (les branches de mes arbres ouvertes, les largeurs de tableau, leur ordre, la dernière perspective ouverte...)

Le problème c'est que je viens de passer la matinée à essayer de comprendre comment ça marche et je n'y arrive toujours pas...

le code ci dessus permet-il de tout sauvegarder ? et si oui, serait-il possible de mettre un exemple un peu plus complet SVP car en fait je n'ai pas bien saisit comment configurer tout ça.

merci

le meilleurs moyen n'est-il pas de gerer tout ceci dans un fichier XML ?

Sinon, j'ai vu qu'il existait une interface IMemento... mais je ne trouve rien pour son implémentation... :(

tu trouveras des infos dans ce tuto :
http://www.eclipse.org/articles/view...wArticle2.html
et en particulier les méthodes :
public void init(IViewSite site,IMemento memento) throws PartInitException;
public void saveState(IMemento memento);

merci

Dès que j'aurais réussi à faire ce que je veux, je posterais une réponse

Problème résolu

Donc pour tout sauvegarder j'utilise bien en fait les préférences. c a d l'interface IPreferenceStore.

Comment je j'utilise ?

Exemple sur une table :

il s'agit d'un TableViewer par defaut pour mettre des tableaux dans un editeur

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
255
256
257
258
259
260
261
262
263
264
265
266
 
public abstract class TableViewerForEditors extends Composite{
 
	private Table tab;
	protected TableViewer tbv;
 
	private ListenerControl leListenerControlTac;
	private ListenerSelection leListenerSelectionTac;
 
	protected IPreferenceStore lesPrefs;
 
	/**
         * @param parent
         * @param style
         * @param input
         */
	public TableViewerForEditors(Composite parent, int style, Object input) {
		super(parent,style);
		this.setLayout(new FillLayout());
		leListenerControlTac = new ListenerControl(this);
		leListenerSelectionTac = new ListenerSelection(this);
 
		createTable();
 
		tbv = new TableViewer(tab);
 
		createColumns();
 
		configureViewer();
 
		tbv.setInput(input);
 
 
		miseEnForme(lesPrefs);
 
		//Ajout des listeners
		for(TableColumn tac : tab.getColumns()){				
			tac.addSelectionListener(this.leListenerSelectionTac);
			tac.addControlListener(this.leListenerControlTac);
		}
 
 
		if (lesPrefs != null){
			String nomClasse = getClass().getSimpleName();
			String temoin = lesPrefs.getString(nomClasse + PreferencesCst.TEMOIN);
			String sortKey = nomClasse+ PreferencesCst.SEP_POINT;
			sortKey += PreferencesCst.SORT;
			//Mise en place des tailles par défaut
			if (!temoin.equalsIgnoreCase(PreferencesCst.OK)){
				for(TableColumn tac : tab.getColumns()){
					tac.setWidth(tac.getWidth());					
				}
				String nomColonne = tab.getSortColumn().getText();
				lesPrefs.setValue(sortKey, nomColonne);
				//Mise en place de la colonne trié
			}else{
				String nomColonne = lesPrefs.getString(sortKey);
				for(TableColumn tac : tab.getColumns()){
					if (tac.getText().equalsIgnoreCase(nomColonne)){
						tab.setSortColumn(tac);
					}
				}
			}
 
		}
	}
 
	/**
         * @param lesPrefs
         * Méthode permettant d'appliquer la dernière mise en forme de la vue
         */
	protected void miseEnForme(IPreferenceStore lesPrefs){
		if (lesPrefs != null){
			String nomClasse = getClass().getSimpleName();
			String temoin = lesPrefs.getString(nomClasse + PreferencesCst.TEMOIN);
			if (temoin.equalsIgnoreCase(PreferencesCst.OK)){
				int place = 0;
				int size = 0;
				String param = PreferencesCst.EMPTY;
				String paramPlace = PreferencesCst.EMPTY;
				String paramSize = PreferencesCst.EMPTY;
				int[] order = new int[tab.getColumnCount()];
				int i = 0;
				//Mise en place de l'ordre des colonnes
				for(TableColumn tac : tab.getColumns()){
					param = nomClasse + PreferencesCst.SEP_POINT;
					param += tac.getText();
					paramPlace = param 
								+ PreferencesCst.SEP_POINT
								+ PreferencesCst.PLACE;
					paramSize = param 
								+ PreferencesCst.SEP_POINT
								+ PreferencesCst.SIZE;
					place = lesPrefs.getInt(paramPlace);
					order[i] = place;
					size = lesPrefs.getInt(paramSize);
					tac.setWidth(size);
					i++;
				}
				tab.setColumnOrder(order);				
			}
		}
	}
 
	/**
         * Méthode créant la table
         */
	private void createTable(){
		tab = new Table(this, SWT.NONE);
//	 	GridData gridData = new GridData(GridData.FILL_BOTH);
//		gridData.grabExcessVerticalSpace = true;
//		tab.setLayoutData(gridData);				
		tab.setLinesVisible(true);
		tab.setHeaderVisible(true);
	}
 
	/**
         * <p>Méthode servant à créer toutes les colonnes de la table.</p><br>
         * 
         * <p>à implémenter dans toute classe héritant de TableViewerForEditors.</p>
         */
	protected  abstract void createColumns();
 
	/**
         * <p>Méthode servant à instancier le content, le label ainsi que 
         * le fichier de préférences.</p> <br>
         * 
         * <p>à implémenter dans toute classe héritant de TableViewerForEditors.</p>
         */
	protected abstract void configureViewer();
 
	/** 
         * @param text
         * @param tooltip
         * @param style
         * @param sorter
         * @param initialDirection
         * @param keepDirection
         * @param autoPack
         * 
         * <p> Sert à créer une colonne dans la table</p><br>
         * @return
         */
	public TableSortSelectionListener createTableColumn(
			String text, 
			String tooltip,
			int style,
			AbstractInvertableTableSorter sorter, 
			int initialDirection,
			boolean keepDirection,
			boolean autoPack)
	{
		return createTableColumn(text, tooltip, style, sorter, initialDirection, keepDirection, autoPack, 50);
	}
 
	/**
         * @param text
         * @param tooltip
         * @param style
         * @param sorter
         * @param initialDirection
         * @param keepDirection
         * @param autoPack
         * @param width
         * 
         * <p> Sert à créer une colonne dans la table</p><br>
         * @return
         */
	public TableSortSelectionListener createTableColumn(
			String text, 
			String tooltip,
			int style,
			AbstractInvertableTableSorter sorter, 
			int initialDirection,
			boolean keepDirection,
			boolean autoPack,
			int width)
	{
		TableColumn column = new TableColumn(this.tab, style);
		column.setText(text);
		column.setToolTipText(tooltip);
		column.setResizable(true);
		column.setMoveable(true);
		column.setWidth(width);
		return new TableSortSelectionListener(this.tbv, column, sorter,initialDirection, keepDirection, autoPack);
	}
 
	/**
         * @param text
         * @param tooltip
         * @param style
         * 
         * <p> Sert à créer une colonne dans la table</p><br>
         * @return
         */
	public TableColumn createTableColumn( 
			String text, 
			String tooltip,
			int style)
	{		
		return createTableColumn(text,tooltip,style,50);
	}
 
	/**
         * @param text
         * @param tooltip
         * @param style
         * @param width
         * 
         * <p> Sert à créer une colonne dans la table</p><br>
         * @return
         */
	public TableColumn createTableColumn( 
			String text, 
			String tooltip,
			int style,
			int width)
	{
		TableColumn column = new TableColumn(tab, style);
		column.setText(text);
		column.setToolTipText(tooltip);
		column.setWidth(width);
		TableSorter sorter2 = new TableSorter(tbv.getTable().indexOf(column));
		@SuppressWarnings("unused")
		TableSortSelectionListener sortListener =  new TableSortSelectionListener(tbv, column, sorter2,SWT.UP, false, true);
		return column;
	}
 
	/**
         * @return
         */
	public Table getTab() {
		return tab;
	}
 
	/**
         * @param tab
         */
	public void setTab(Table tab) {
		this.tab = tab;
	}
 
	/**
         * @return
         */
	public TableViewer getTbv() {
		return tbv;
	}
 
	/**
         * @param tbv
         */
	public void setTbv(TableViewer tbv) {
		this.tbv = tbv;
	}
 
	/**
         * @return
         */
	public IPreferenceStore getLesPrefs() {
		return lesPrefs;
	}
 
 
 
}

PreferencesCst.java :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
public abstract class PreferencesCst {
 
	public static String TEMOIN = "temoin";
	public static String OK = "OK";
	public static String EMPTY = "";
	public static String SEP_POINT = ".";
	public static String PLACE = "place";
	public static String SIZE = "size";
	public static String SORT = "sort";
 
}

ListenerSelection.java :

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
 
//ListenerDefault est une super classe dans laquelle on a juste un paramètre
//l'objet contenant le listener
public class ListenerSelection extends ListenerDefault implements
		SelectionListener {
 
 
	public ListenerSelection(Object lAppelant) {
		super(lAppelant);
	}
 
	/* (non-Javadoc)
	 * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
	 */
	public void widgetDefaultSelected(SelectionEvent e) {		
		if(getLAppelant() instanceof TableViewerForEditors){
			TableViewerForEditors laVue = (TableViewerForEditors)getLAppelant();
			if (laVue.getLesPrefs() != null){
				String nomClasse = getLAppelant().getClass().getSimpleName(); 
				laVue.getLesPrefs().setValue(nomClasse + PreferencesCst.TEMOIN, PreferencesCst.OK);
				TableColumn tac = (TableColumn)e.getSource();
				String param = nomClasse + PreferencesCst.SEP_POINT;
				param += PreferencesCst.SORT;
				laVue.getLesPrefs().setValue(param, tac.getText());
			}
		}
 
	}
 
	/* (non-Javadoc)
	 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
	 */
	public void widgetSelected(SelectionEvent e) {
                    if(getLAppelant() instanceof TableViewerForEditors){
			TableViewerForEditors laVue = (TableViewerForEditors)getLAppelant();
			if (laVue.getLesPrefs() != null){
				String nomClasse = getLAppelant().getClass().getSimpleName();
				laVue.getLesPrefs().setValue(nomClasse + PreferencesCst.TEMOIN, PreferencesCst.OK);
				STableColumn tac = (STableColumn)e.getSource();
				String param = nomClasse+ PreferencesCst.SEP_POINT;
				String paramSort = param + PreferencesCst.SORT;
				laVue.getLesPrefs().setValue(paramSort, tac.getText());
			}
		}
	}
 
}

ListenerControl.java :

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
 
public class ListenerControl extends ListenerDefault implements
		ControlListener {
 
	public ListenerControl(Object lAppelant) {
		super(lAppelant);
	}
 
	/* (non-Javadoc)
	 * @see org.eclipse.swt.events.ControlListener#controlMoved(org.eclipse.swt.events.ControlEvent)
	 */
	public void controlMoved(ControlEvent e) {
		if (super.getLAppelant() instanceof TableViewerForEditors){
			TableViewerForEditors laVue = (TableViewerForEditors)getLAppelant();
			if (laVue.getLesPrefs() != null){
				String nomClasse = getLAppelant().getClass().getSimpleName();
				laVue.getLesPrefs().setValue(nomClasse + PreferencesCst.TEMOIN, PreferencesCst.OK);
				STableColumn tac = (TableColumn)e.getSource();
				String param = PreferencesCst.EMPTY; 
				int i = 0;
				for(int order : tac.getParent().getColumnOrder()){
					param = nomClasse + PreferencesCst.SEP_POINT;
					param += tac.getParent().getColumn(i).getText()+PreferencesCst.SEP_POINT;
					param += PreferencesCst.PLACE;
					laVue.getLesPrefs().setValue(param, order);					
				i++;
				}
			}
 
 
		}
	}
 
	/* (non-Javadoc)
	 * @see org.eclipse.swt.events.ControlListener#controlResized(org.eclipse.swt.events.ControlEvent)
	 */
	public void controlResized(ControlEvent e) {
		if (super.getLAppelant() instanceof TableViewerForEditors){
			TableViewerForEditors laVue = (TableViewerForEditors)getLAppelant();
			if (laVue.getLesPrefs() != null){
				String nomClasse = getLAppelant().getClass().getSimpleName();
				laVue.getLesPrefs().setValue(nomClasse + PreferencesCst.TEMOIN, PreferencesCst.OK);
				TableColumn tac = (TableColumn)e.getSource();
				String param = nomClasse + PreferencesCst.SEP_POINT;
				param += tac.getText()+PreferencesCst.SEP_POINT;
				param += PreferencesCst.SIZE;
				laVue.getLesPrefs().setValue(param, tac.getWidth());
			}
		}
	}
 
}

Maintenant, voici comment s'implémente un objet TableViewerForEditors

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 class MonTableViewer extends TableViewerForEditors {
 
	public MonTableViewer(Composite parent, int style, Object input) {
		super(parent, style, input);
	}
 
 
	@Override
	protected void createColumns() {
		createTableColumn("col1", "col1",SWT.LEFT, new MonSorter("col1"), SWT.UP, true, true).chooseColumnForSorting();		
		createTableColumn("col2", "col2", SWT.LEFT, new MonSorter("col2"), SWT.UP, false, true);
		createTableColumn("col3", "col3", SWT.LEFT, new MonSorter("col3"), SWT.UP, false, true);
                createTableColumn("col4", "col4", SWT.LEFT, new MonSorter("col4"), SWT.UP, false, true);
                createTableColumn("col5", "col5", SWT.LEFT, new MonSorter("col5"), SWT.UP, false, true);
	}
 
	@Override
	protected void configureViewer() {
		lesPrefs = MonActivator.getDefault().getPreferenceStore();
		tbv.setContentProvider(new MonContentProvider());
	 	tbv.setLabelProvider(new MonLabelProvider());
	}
 
}

il suffit juste ensuite de d'instancier un objet MonTableViewer dans éditeur pour que ça marche.

Pour la sauvegarde des préférences au niveau de la perspective, il faut aller dans les classes suivantes :

ApplicationWorkbenchWindowAdvisor.java

il faut ajouter la méthode suivante

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
 
/* (non-Javadoc)
     * @see org.eclipse.ui.application.WorkbenchWindowAdvisor#preWindowShellClose()
     */
    @SuppressWarnings("finally")
	@Override
    public boolean preWindowShellClose() {
    	try{
    		String idPerspective = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getPerspective().getId();
    		PlatformUI.getPreferenceStore().setValue("LastPerspective", idPerspective);
    		IWorkbenchWindow[] lesWindows = PlatformUI.getWorkbench().getWorkbenchWindows();
    		int i = 0;
    		for (IWorkbenchWindow leWorkbench : lesWindows){
    			i++;
    			IWorkbenchPage[] lesPages = leWorkbench.getPages();
    			for (IWorkbenchPage laPage : lesPages){
    				i++;
    				laPage.savePerspective();
    			}
    		}
    	}catch (Exception e){
    		e.printStackTrace();
    	}finally{
    		return super.preWindowShellClose();
    	}
    }

dans la classe suivante : ApplicationWorkbenchAdvisor.java

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public class ApplicationWorkbenchAdvisor extends WorkbenchAdvisor {
 
	private static String PERSPECTIVE_ID = "chemin.perspective";
 
 
    public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
        return new ApplicationWorkbenchWindowAdvisor(configurer);
    }
 
	public String getInitialWindowPerspectiveId() {
 
		String laPerspectivePreference = PlatformUI.getPreferenceStore().getString("LastPerspective");		
		if (!(laPerspectivePreference == null)&&!("".equals(laPerspectivePreference))){
			perspectiveID = laPerspectivePreference;
		}
		//return PERSPECTIVE_ID;
		return perspectiveID;
	}
}

Voilà, je crois avoir tout ajouter :)

Après pour sauvegarder ce qu'on veut, il faut utiliser le fichier de préférence comme ci dessus

Pourquoi tu sauvegardes tout dans un IPreferenceStore ?

IPreferenceStore sert à sauvegarder les préférences utilisateurs.
Tu vas utiliser un IPreferenceStore et une page de préférence pour initialiser des valeurs par défaut pour ton plugin et permettre à l'utilisateur de les modifiers ( par ex : des thèmes ).

Pour une sauvegarde rapide de ton workbench.
Dans ta classe, ApplicationWorkbenchAdvisor tu override initialize :
Code:

1 2 3 4 5 6 public void initialize(IWorkbenchConfigurer configurer) { // TODO Auto-generated method stub configurer.setSaveAndRestore(true); super.initialize(configurer); }
Pour une sauvegarde plus complexe le IMemento devrait pouvoir te venir en aide.

Désolé, par rapport à ma prédécente réponse, j'ai répondu à ton post en t'envoyant sur un tuto vers IMemento car c'était ta demande.

le configurer.setSaveAndRestore(true) devrait répondre plus simplement à ton besoin. Je ne sais pas à partir de quelle version d'Eclipse c'est apparu.