Last updated on 2014-09-05
Previous Tutorial: Creating a GEF Editor – Part 7: Moving Elements and Direct Editing
In this tutorial we are going to add functionality to delete diagram entities and also to undo and redo editing operations. This is going to be a short tutorial because thankfully most of the functionality that we want to add only has to be configured in the framework.
- Delete functionality is implemented like all other functionality: we have to add a new
Command
to change the model, create a newEditPolicy
(or extend an existing one) which creates theCommand
and install the command in the desiredEditPart
. - First we implement the command, which is fairly simple. In EMF, a model instance that is disconnected from all of the model’s resource is not saved and therefore will get deleted (much like java garbage collection):
package com.vainolo.phd.opm.gef.editor.command; import org.eclipse.gef.commands.Command; import com.vainolo.phd.opm.model.OPMObjectProcessDiagram; import com.vainolo.phd.opm.model.OPMThing; public class OPMThingDeleteCommand extends Command { private OPMThing thing; private OPMObjectProcessDiagram opd; @Override public void execute() { thing.setOpd(null); } @Override public void undo() { thing.setOpd(opd); } public void setThing(OPMThing thing) { this.thing = thing; this.opd = thing.getOpd(); } }
- Request to delete diagram entities in GEF is handled by a
ComponentEditPolicy
:package com.vainolo.phd.opm.gef.editor.policy; import org.eclipse.gef.commands.Command; import org.eclipse.gef.editpolicies.ComponentEditPolicy; import org.eclipse.gef.requests.GroupRequest; import com.vainolo.phd.opm.gef.editor.command.OPMThingDeleteCommand; import com.vainolo.phd.opm.model.OPMThing; public class OPMThingComponentEditPolicy extends ComponentEditPolicy { @Override protected Command createDeleteCommand(GroupRequest deleteRequest) { OPMThingDeleteCommand thingDeleteCommand = new OPMThingDeleteCommand(); thingDeleteCommand.setThing((OPMThing) getHost().getModel()); return thingDeleteCommand; } }
- You could try now to execute your editor and delete a diagram entity… But no matter how hard you press your Del button, nothing will happen. You see, delete actions are not regular actions that are applied to the model, but must be activated from the outside (for example from a menu, toolbar or key press). So we’ll be adding the delete action to the menu and toolbar of the eclipse workbench, and while we are at it we’ll also add undo and redo functionality
- Eclipse editors that want to provide actions to the menus and toolbars must provide a class which implements the
IEditorActionBarContributor
interface. GEF provides us with a basic implementation of this interface for use with our GEF editor, calledActionBarContributor
(the comment in this class says that it is subject to change… but so is everything else in life. It would be nice to know why they think this class is going to change in the future). Since the three operations we are implementing are pretty standard editor operations, the framework also provides us withRetargetAction
classes that can be used in the menus and toolbars.package com.vainolo.phd.opm.gef.editor; import org.eclipse.gef.ui.actions.ActionBarContributor; import org.eclipse.gef.ui.actions.DeleteRetargetAction; import org.eclipse.gef.ui.actions.RedoRetargetAction; import org.eclipse.gef.ui.actions.UndoRetargetAction; import org.eclipse.jface.action.IToolBarManager; import org.eclipse.ui.actions.ActionFactory; public class OPMGraphicalEditorActionBarContributor extends ActionBarContributor { @Override protected void buildActions() { addRetargetAction(new UndoRetargetAction()); addRetargetAction(new RedoRetargetAction()); addRetargetAction(new DeleteRetargetAction()); } @Override public void contributeToToolBar(IToolBarManager toolBarManager) { super.contributeToToolBar(toolBarManager); toolBarManager.add(getAction(ActionFactory.UNDO.getId())); toolBarManager.add(getAction(ActionFactory.REDO.getId())); toolBarManager.add(getAction(ActionFactory.DELETE.getId())); } @Override protected void declareGlobalActionKeys() { // Do nothing. This is an abstract function in the parent class. } }
The
buildActions
initializes the actions that are provided by our editor (and also makes them available in the menus). After they are initialized, we can also add them to the toolbar using thecontributeToToolBar
method. - Last thing we need to do is connect action contributor class we just created to the editor. This is done in the plugin definition file, in the same place we defined the model editor, setting our class as the OPM GEF Editor’s
contributorClass
:
- That’s it. Execute your eclipse project and mode some things around. The Undo action should be available right after you do this. Undo something and now the Redo action should be available. Select a thing and delete it. Works? great!
And to finish, we install the new EditPolicy
in the OPMThingEditPart
:
@Override protected void createEditPolicies() { installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, new OPMThingDirectEditPolicy()); installEditPolicy(EditPolicy.COMPONENT_ROLE, new OPMThingComponentEditPolicy()); }
You can find the final project files here.
As usual, hope you enjoyed this tutorial. Next in line: implementing connections between things in the model. Don’t miss it :-).
Next Tutorial: Creating a GEF Editor – Part 9: Connections
Be First to Comment