Eclipse 4.x

Instead of using the Extension Point mechanism, EMF Parsley leverages from DSL and Google Guice Injection.

Because of this, it is very easy to use it with Eclipse 4.x (e4).

First Example Setup

If you followed the steps described in section First Example you will have already what we need to begin. Otherwise the following wizard will bring you to that point.

  1. File -> New... -> Example...
  2. from Category "Emf Parsley Examples", select "Emf Parsley First Example"
  3. press Next and Finish

You will end up with three plug-ins:

As a reminder, in section First Example we reached the point where we launched a second Eclipse instance (but, of course, just defining a product you could have a standalone 3.x application) with a view (called "My Library Tree Form") that allowed to manage the model.

Preparing for a pure e4 Application

What we will do now is starting from the previous step and create an e4 Application (on top of the previous plug-ins) that gets to the same result, but now with a pure e4 Part.

In order to do this we need to export the "org.eclipse.emf.parsley.examples.firstexample" package from the first plug-in.

Create an e4 Application

Now let's create a new, empty, e4 application, e.g. "org.eclipse.emf.parsley.examples.firstexample.application" (you can find details on how to create e4 applications in our tutorials).

Create a Part and ensure that the application starts.

Using a TreeComposite into an e4 Part

In the just created plug-in we need dependencies from the previous plug-ins: so open the org.eclipse.emf.parsley.examples.firstexample.application/MANIFEST.MF file, go to Dependencies tab and add the three previous plug-ins. Add also "org.eclipse.emf.parsley" plug-in. Don't forget to add the previous, and the required plug-ins, also to the Product.

Open the Part java class and make the following changes:

// Use these imports during Organizing Imports operation
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.swt.widgets.Composite;

// The part implements IMenuListener for context menu handling
public class MyEclipse4Part {

    //the EMF Parley composite for showing a tree and a detail form
    private TreeFormComposite treeFormComposite;
    //the EMF Resource
    private Resource resource;
    //URI for EMF Resource
    private URI uri = URI.createFileURI(System.getProperty("user.home")
        + "/MyLibrary.library");

    // Guice injector
    private Injector injector = FirstexampleActivator.getDefault().getInjector();

Modify the @PostConstruct method with this code:

@PostConstruct
public void postConstruct(Composite parent) {

    // The EditingDomain is needed for context menu and drag and drop
    EditingDomain editingDomain = injector.getInstance(EditingDomain.class);

    ResourceLoader resourceLoader = injector.getInstance(ResourceLoader.class);
    //load the resource
    resource = resourceLoader.getResource(editingDomain, uri).getResource();

    TreeFormFactory treeFormFactory = injector.getInstance(TreeFormFactory.class);
    //create the tree-form composite
    treeFormComposite = treeFormFactory.createTreeFormComposite(parent, SWT.BORDER);

    // Guice injected viewer context menu helper
    ViewerContextMenuHelper contextMenuHelper = injector.getInstance(ViewerContextMenuHelper.class);
    // Guice injected viewer drag and drop helper
    ViewerDragAndDropHelper dragAndDropHelper = injector.getInstance(ViewerDragAndDropHelper.class);

    // set context menu and drag and drop
    contextMenuHelper.addViewerContextMenu(treeFormComposite.getViewer(), editingDomain);
    dragAndDropHelper.addDragAndDrop(treeFormComposite.getViewer(), editingDomain);

    //update the composite
    treeFormComposite.update(resource);
}

If you now run the application you will be able to manage the model:

but you will notice that it is not possible to persist the changes to the model.

Adding the dirty state and Save command

In order to allow persisting the model changes we have to add the dirty state handling to the part and the Save command to the application. Let's start with adding the following attribute to the part

@Inject
MDirtyable dirty;

add to @PostConstruct method the following code in order to update the dirty state

editingDomain.getCommandStack().addCommandStackListener(
            new CommandStackListener() {
                public void commandStackChanged(EventObject event) {
                    if (dirty != null)
                        dirty.setDirty(true);
                }
            });

and add the @Persist method, which will be called when the part is saved

@Persist
public void save(MDirtyable dirty) throws IOException {
    resource.save(null);
    if (dirty != null) {
        dirty.setDirty(false);
    }
}

and, in the end, add the Save handler along with the correspondent Command and Menu (you can find how to create handlers, commands and menus in an e4 applications in our tutorials)

import javax.inject.Named;

public class SaveHandler {

    @Execute
    void execute(EPartService partService, @Named(IServiceConstants.ACTIVE_PART) MPart part) {
        partService.savePart(part, false);
    }
}