Jump to: navigation, search

STP/BPMN Component/STP BPMN Presentation Hands on tutorial

< STP‎ | BPMN Component
Revision as of 17:47, 3 March 2007 by Atoulme.intalio.com (Talk | contribs) (Adding a property tab to see your annotation)

This tutorial is presented as part of the STP BPMN Presentation at EclipseCon 2007.


In this section, we are going to begin to play with the modeler and try to extend its use.

We want to add a participant to our shapes. A participant represents a person with a name and a role.

Adding a property tab to see your annotation

The easiest way to add a participant to your shape is to create a property tab to represent it and enable us to enter his name and his role.

In the plugin.xml, we define a new property tab named "Participants". We add one section to the tab.

The contributor for the new tab, it defines a new category

        <propertyCategory category="Participants"/>

The definition of the tab itself

   <extension point="org.eclipse.ui.views.properties.tabbed.propertyTabs">
     <propertyTabs contributorId="org.eclipse.gmf.runtime.diagram.ui.properties">

The definition of the section inside the property tab

   <extension point="org.eclipse.ui.views.properties.tabbed.propertySections">
     <propertySections contributorId="org.eclipse.gmf.runtime.diagram.ui.properties">
           <input type="org.eclipse.stp.bpmn.Activity"/>
           <input type="java.lang.Object"/>

Now we are going to code the tab itself.

A tab is an instance of AbstractPropertySection.

Create a class in org.eclipse.stp.samples.eclipsecon2007.participant.properties as ParticipantPropertySection.

Two methods are important there :

the property tab UI is defined in createPartControl, and the input management in setInput. We need to implement those two methods.

Let's create a first version of createPartControl, with two text fields:

       * Creates the UI of the section.
       public void createControls(Composite parent, 
               TabbedPropertySheetPage aTabbedPropertySheetPage) {
               super.createControls(parent, aTabbedPropertySheetPage);
               GridLayout layout = new GridLayout(2, false);
               GridData gd = new GridData(SWT.FILL);
               gd.minimumWidth = 500;
               gd.widthHint = 500;
               getWidgetFactory().createCLabel(parent, "Name");
               nameText = getWidgetFactory().createText(parent, "");
               getWidgetFactory().createCLabel(parent, "Role");
               roleText = getWidgetFactory().createText(parent, "");

Now let's handle the data.

       * Manages the input.
       public void setInput(IWorkbenchPart part, ISelection selection) {
               super.setInput(part, selection);
               if(selection instanceof IStructuredSelection) {
                       Object unknownInput = 
                              ((IStructuredSelection) selection).getFirstElement();
                       if (unknownInput instanceof IGraphicalEditPart && 
                               (((IGraphicalEditPart) unknownInput).
                                       resolveSemanticElement() != null)) {
                                unknownInput = ((IGraphicalEditPart) unknownInput).resolveSemanticElement();
                       if (unknownInput instanceof Activity) {
                                       Activity elt = (Activity) unknownInput;
                                       EAnnotation ea = elt.getEAnnotation(ParticipantConstants.PARTICIPANT_ANNOTATION);
                                       if (ea != null) {
                                               nameText.setText((String) ea.getDetails().get(ParticipantConstants.PARTICIPANT_NAME));
                                               roleText.setText((String) ea.getDetails().get(ParticipantConstants.PARTICIPANT_ROLE));
                                       activity = (Activity) elt;
               activity = null;

We now have a working section. Hopefully.

We need to make sure that the changes in the text fields are reflected in the EAnnotation. To do this, we need to add a ModifyListener on the text fields. Plus we need to create a command or use an existing one to do the job of modifying the resource in a transaction. We choose to create our own command, we could also have used a chain of commands with EMF.

        * Utility class that finds the files and the editing domain easily,
        * Abstractas the doExecuteWithResult method needs to be implemented.
        * @author <a href="mailto:hmalphettes@intalio.com">Hugues Malphettes</a>
        * @author <a href="mailto:atoulme@intalio.com">Antoine Toulmé</a>
        * @author <a href="http://www.intalio.com">© Intalio, Inc.</a>
       private abstract class ModifyParticipantEAnnotationCommand extends AbstractTransactionalCommand {
       public ModifyParticipantEAnnotationCommand(Activity ann, String label) {
                super((TransactionalEditingDomain) AdapterFactoryEditingDomain.getEditingDomainFor(ann), label, getWorkspaceFiles(ann));

We implement our text listener directly in the class.

        * Tracks the change occuring on the text field.
        * @author <a href="http://www.intalio.com">Hugues Malphettes</a>
        * @author <a href="http://www.intalio.com">Antoine Toulmé</a>
        * @author <a href="http://www.intalio.com">© Intalio, Inc.</a>
      private class ModifyParticipantInformation implements ModifyListener {
               private String key;
               private Text field;
               public ModifyParticipantInformation(String k, Text field) {
                       key = k;
                       this.field = field;
               public void modifyText(ModifyEvent e) {
                       if (activity == null) { // the value was just initialized
                       ModifyParticipantEAnnotationCommand command = 
                               new ModifyParticipantEAnnotationCommand(activity, "Modifying participant") {
                               protected CommandResult doExecuteWithResult(IProgressMonitor arg0, IAdaptable arg1) throws ExecutionException {
                                       EAnnotation annotation  = activity.getEAnnotation(ParticipantConstants.PARTICIPANT_ANNOTATION);
                                       if (annotation == null) {
                                               annotation = EcoreFactory.eINSTANCE.createEAnnotation();
                                               annotation.getDetails().put(ParticipantConstants.PARTICIPANT_NAME, "");
                                               annotation.getDetails().put(ParticipantConstants.PARTICIPANT_ROLE, "");
                                       annotation.getDetails().put(key, field.getText());
                                       return CommandResult.newOKCommandResult();
                               try {
                                       command.execute(new NullProgressMonitor(), null);
                               } catch (ExecutionException exception) {
                                       STPEclipseConPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, STPEclipseConPlugin.PLUGIN_ID, IStatus.ERROR, exception.getMessage(), exception));

The trick is to create the EAnnotation if it doesn't exist yet.

The logical next step is to add the listener to the text fields as we initialize them in the createPartControl method.

nameText.addModifyListener(new ModifyParticipantInformation(ParticipantConstants.PARTICIPANT_NAME, nameText));
roleText.addModifyListener(new ModifyParticipantInformation(ParticipantConstants.PARTICIPANT_ROLE, roleText));

Adding a drop action