[RCP] LabelRetargetAction & opération undo/redo

**pingoui** · 01/08/2010, 11h42

Bonjour,
j'ai une vue avec des opérations undo/redo qui fonctionnent.

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
64
65
66
67
68
69
70
71
72
 
	public class ZoneExplorerTreeView extends ViewPart {
	/**
         * Les actions annuler et refaire
         */
	private UndoActionHandler undoAction;
	private RedoActionHandler redoAction;
 
	/**
         * Le contexte d'annulation privé pour l'explorateur de zone
         */
	private IUndoContext undoContext ;
 
	/**
         * Cette méthode est appelé lors de la création de la vue 
         * et permet d'initialiser celle-ci
         */
	@Override
	public void createPartControl(Composite parent) {
 
                 //......
 
		//Création des commandes d'undo/redo
		createGlobalActionHandlers();
		//Création du menu contextuel
		hookContextMenu();
	}
 
	/**
         * Création des commandes d'undo/redo
         */
	private void createGlobalActionHandlers() {
		undoContext = PlatformUI.getWorkbench().getOperationSupport().getUndoContext();
		// set up action handlers that operate on the current context
		undoAction = new UndoActionHandler(this.getSite(), undoContext);
		redoAction = new RedoActionHandler(this.getSite(), undoContext);
 
		IActionBars actionBars = getViewSite().getActionBars();
		actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(),
				undoAction);
 
		actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(),
				redoAction);
 
	}
 
	/**
         * Ajoute le menu contextuel ‡ la vue
         */
	private void hookContextMenu() {
		MenuManager menuMgr = new MenuManager("#PopupMenu");
		menuMgr.setRemoveAllWhenShown(true);
		menuMgr.addMenuListener(new IMenuListener() {
			public void menuAboutToShow(IMenuManager manager) {
				ZoneExplorerTreeView.this.fillContextMenu(manager);
			}
		});
		Menu menu = menuMgr.createContextMenu(treeViewer.getControl());
		treeViewer.getControl().setMenu(menu);
		getSite().registerContextMenu(menuMgr, treeViewer);
	}
 
	/**
         * Ajoute les actions undo et redo au menu contextuel.
         */
	private void fillContextMenu(IMenuManager manager) {
		manager.add(undoAction);
		manager.add(redoAction);
		manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
	}
....
}

Les labels des actions undo/redo du menu contextuel se mettent à jour parfaitement.

J'ai ajouté les undo/redo au menu principal et au menu contextuel de ma vue

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
 
   <extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="menu:org.eclipse.ui.main.menu">
         <menu
               label="Edition">
            <command
                  commandId="org.eclipse.ui.edit.undo"
                  icon="icons/undo.gif"
                  label="Undo"
                  style="push">
            </command>
            <command
                  commandId="org.eclipse.ui.edit.redo"
                  icon="icons/redo.gif"
                  label="Redo"
                  style="push">
            </command>
         </menu>
      </menuContribution>
      <menuContribution
            locationURI="popup:org.pegase.ui.views.zoneExplorerTreeView">
         <command
               commandId="org.eclipse.ui.edit.undo"
               icon="icons/undo.gif"
               label="Undo"
               style="push">
         </command>
         <command
               commandId="org.eclipse.ui.edit.redo"
               icon="icons/redo.gif"
               label="Redo"
               style="push">
         </command>
      </menuContribution>
   </extension>

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
 
public class ApplicationActionBarAdvisor extends ActionBarAdvisor {
	public ApplicationActionBarAdvisor(IActionBarConfigurer configurer) {
		super(configurer);
	}
 
	@Override
	protected void makeActions(final IWorkbenchWindow window) {
		IWorkbenchAction undoAction = ActionFactory.UNDO.create(window);
		register(undoAction);
		IWorkbenchAction redoAction = ActionFactory.REDO.create(window);
		register(redoAction);
	}
 
	protected void fillMenuBar(IMenuManager menuBar) {
 
	}
}

Les commandes ajoutées via les extensions fonctionnent mais les labels ne sont pas mis à jours suivant l'opération à annuler/refaire
Voir la pièce jointe. En Haut, les menu ajoutés directement dans ma vue.
En bas, (icônes verts) les menu ajoutés via les extensions

D'avance merci pour votre aide.

**Gueritarish** · 19/08/2010, 14h35

Salut pingoui,

Problème épineux que tu soulèves là. Parce qu'en fait, si tu regardes bien, c'est l'action (OperationHistoryActionHandler) qui s'occupe de "changer" son texte dans sa méthode update()...
Donc, j'ai regardé une solution de Lars Voegel qui consiste à définir les commandes au runtime. Mais en fait, ça revient au même

Par contre, une solution serait de passer par un menu dynamique et d'appliquer cette "déclaration" de commande au runtime. Je m'explique:
- Tout d'abord, tu définis un menu dynamique dans ton plugin.xml:

Code XML :

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

1
2
3
4
5
6
7
8
9
10
<extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="menu:file?after=additions">
         <dynamic
               class="test.MyContributionItem"
               id="test.edit.contribution.items">
         </dynamic>
      </menuContribution>
   </extension>

- Ensuite, dans la classe utilisée pour obtenir les éléments dynamiques du menu, tu ajoutes tes commandes:

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
package test;
 
import org.eclipse.core.commands.operations.DefaultOperationHistory;
import org.eclipse.core.commands.operations.IOperationHistory;
import org.eclipse.core.commands.operations.IUndoableOperation;
import org.eclipse.core.commands.operations.OperationHistoryFactory;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.swt.SWT;
import org.eclipse.ui.actions.CompoundContributionItem;
import org.eclipse.ui.menus.CommandContributionItem;
import org.eclipse.ui.menus.CommandContributionItemParameter;
import org.eclipse.ui.menus.IWorkbenchContribution;
import org.eclipse.ui.services.IServiceLocator;
 
public class MyContributionItem extends CompoundContributionItem implements
		IWorkbenchContribution {
 
	private IServiceLocator serviceLocator;
 
	public MyContributionItem() {
	}
 
	public MyContributionItem(String id) {
		super(id);
	}
 
	@Override
	protected IContributionItem[] getContributionItems() {
		IOperationHistory operationHistory = OperationHistoryFactory
				.getOperationHistory();
		IUndoableOperation[] undoHistory = operationHistory
				.getUndoHistory(DefaultOperationHistory.GLOBAL_UNDO_CONTEXT);
		String undoLabel = "";
		if (undoHistory != null && undoHistory.length > 0) {
			IUndoableOperation iUndoableOperation = undoHistory[undoHistory.length - 1];
			if (iUndoableOperation != null) {
				undoLabel = iUndoableOperation.getLabel();
			}
		}
		CommandContributionItemParameter undoCommandParameter = new CommandContributionItemParameter(
				serviceLocator, "", "org.eclipse.ui.edit.undo", SWT.PUSH);
		undoCommandParameter.label = "Undo changes " + undoLabel;
		CommandContributionItem undoCommandItem = new CommandContributionItem(
				undoCommandParameter);
		undoCommandItem.setVisible(true);
 
		String redoLabel = "";
		IUndoableOperation[] redoHistory = operationHistory
				.getRedoHistory(DefaultOperationHistory.GLOBAL_UNDO_CONTEXT);
		if (redoHistory != null && redoHistory.length > 0) {
			IUndoableOperation iUndoableOperation = redoHistory[redoHistory.length - 1];
			if (iUndoableOperation != null) {
				redoLabel = iUndoableOperation.getLabel();
			}
		}
		CommandContributionItemParameter redoCommandParameter = new CommandContributionItemParameter(
				serviceLocator, "", "org.eclipse.ui.edit.redo", SWT.PUSH);
		redoCommandParameter.label = "Redo changes " + redoLabel;
		CommandContributionItem redoCommandItem = new CommandContributionItem(
				redoCommandParameter);
		redoCommandItem.setVisible(true);
 
		return new IContributionItem[] { undoCommandItem, redoCommandItem };
	}
 
	/**
         * {@inheritDoc}
         */
	public void initialize(IServiceLocator aServiceLocator) {
		serviceLocator = aServiceLocator;
	}
 
}

Alors, cette classe MyContributionItem hérites de CompoundContributionItem pour le caractère dynamique de l'item (elle te permet d'accéder à la méthode getContributionItems()) et implémente l'interface IWorkbenchContribution pour pouvoir accéder au IServiceLocator (qui est nécessaire dans la déclaration de commande au runtime).

Bon, je suis pas exactement sûr que c'est ce que les ténors d'Eclipse aurait fait, mais comme on dit, faute de grives, on mange des merles

Voilà, si tu as des questions, n'hésite pas. A+
Gueritarish