Eclipse Archive

Saving the workbench on exit.

2010-12-09T11:29:00.000-08:00

This is was one big thing on my To Do list. Finally I implemented it into TutoGEF. I had two people asking about it also. So here we go. The procedure will not hurt a bit. We have to change a few things here and there in the already existing code but nothing mind blowing. We start out in MyGraphicalEditor by overriding the methods setInput() and doSave():

    @Override
    public void doSave(final IProgressMonitor progressMonitor) {
        editorSaving = true;
        final File file = ((MyEditorInput) getEditorInput()).getFile();
        if (file != null) {
            WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
                public void execute(final IProgressMonitor monitor) {
                    try {
                        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
                        ObjectOutputStream out = new ObjectOutputStream(outStream);
                        out.writeObject(getModel());
                        FileOutputStream fos = new FileOutputStream (file);
                        fos.write(outStream.toByteArray());
                        fos.close();
                        out.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };
            try {
                new ProgressMonitorDialog(getSite().getWorkbenchWindow()
                        .getShell()).run(false, true, op);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        editorSaving = false;
    }

We are using the ObjectOutputStream to save our model (Enterprise) to a file. The path to the file is held in the MyEditorInput class which we are going to update later on. The saving part is done.

Next we are going to load the model right back once TutoGEF is started. We do so by putting our loading routine into setInput():

    @Override
    protected void setInput(IEditorInput input) {
        super.setInput(input);

        File file = ((MyEditorInput) input).getFile();
        if (file != null && file.exists()) {
            try {
                FileInputStream is = new FileInputStream(file);
                ObjectInputStream ois = new ObjectInputStream(is);
                setModel((Enterprise) ois.readObject());
                ois.close();
            } catch (Exception e) {
                e.printStackTrace();
            }

            if (!editorSaving) {
                if (getGraphicalViewer() != null) {
                    getGraphicalViewer().setContents(getModel());
                }
            }
        }
    }

Again we are retrieving the file from MyEditorInput and use the ObjectInputStream to recreate our model which is then passed to the Viewer to its work.

Up next is the MyEditorInput class. We need to extend it with the ability to hold a File:

public class MyEditorInput implements IEditorInput {

// ...
private File file = null;

// ...

First the file needs to be created. I chose the path to the current workspace of TutoGEF and the name passed to the MyEditorInput constructor as the file's location:

// ...

    public MyEditorInput(String name) {
        this.name = name;
        file = new File(ResourcesPlugin.getWorkspace().getRoot().getRawLocation() + "/" + name + ".session.saved");
    }

// ...

Do not forget the getter method:

public File getFile() {
return file;
}

The big work is done. Now there a few left over alterations left in order for the ObjectOutput- and ObjectInputStream to work properly.

In our model we need to update the Node, NodePropertySource and Connection classes to implement Serializable:

public class Node  implements IAdaptable, Serializable { 

// ...

public class NodePropertySource implements IPropertySource, Serializable {

// ...

public class Connection implements Serializable {

// ...

The last step is to remove the org.eclipse.swt.graphics.Color property from the Service model. It is not serializable and will throw an error on saving the workbench. We will keep the ability to save the Color but through 3 Integers rather than the Color class:

    ~~//private Color color;~~
    private int red;
    private int green;
    private int blue;

This forces us to update a few more methods in this class. I removed the createRandomColor() method and added the following to the constructor:

// ...

    public Service() {

        //this.color = createRandomColor();

        red = (new Double(Math.random() * 128)).intValue() + 128;

        green = (new Double(Math.random() * 128)).intValue() + 128;

        blue = (new Double(Math.random() * 128)).intValue() + 128;

    }

// ...

The getter and setter methods are also being altered:

    public void setColor(int red, int blue, int green) {

        this.red = red;

        this.green = green;

        this.blue = blue;

        //Color oldColor = this.color;

        //this.color = color;

        //getListeners().firePropertyChange(PROPERTY_COLOR, oldColor, color);

        getListeners().firePropertyChange(PROPERTY_COLOR, null, null);

    }

    public Color getColor() {
        ~~//return color;~~
        return new Color(null,red,green,blue);
    }

Last but not least we will update the clone() routine:

@Override
public Object clone() throws CloneNotSupportedException {

        // ...

//srv.setColor(color);
srv.setColor(red,green,blue);

        // ...

}

And that was it!

Now we are able to load and save the current state of the Editor. Next time you fire up TutoGEF all Editparts appear in the same position and color like they were when you closed it.

Here you can find the updated TutoGEF project.

Update July 8th 2011:

An alternativ to removing the org.eclipse.swt.graphics.Color from Service model is to declare it transient instead.

private transient Color color;

This way the ObjectStream ignores the Color class and keeps on doing its work. This way of course we would lose the color information.

Adding GEF Connections

2010-01-17T08:02:00.000-08:00

Of course this means for us we are doing yet another extension to TutoGEF. Our goal is to visualize various interactions between our Services in our Enterprise. The Enterprise is into engineering and has therefor multiple worksteps in its project management. We will add 3 kinds of GEF Connections:

deliver design connection
deliver resources connection
distribute work packages connection

Those will be displayed on the screen as an arrow. First we will create the Connection class in our model package ...

Let us create the Connection class. It should look somewhat like the following:




package tutogef.model;

public class Connection {
    
    public static final int CONNECTION_DESIGN = 1;
    public static final int CONNECTION_RESOURCES = 2;
    public static final int CONNECTION_WORKPACKAGES = 3;
    
    private int connectionType;
    
    protected Node sourceNode;
    protected Node targetNode;
    
    public Connection(Node sourceNode, Node targetNode, int connectionType) {
        this.sourceNode = sourceNode;
        this.targetNode = targetNode;
        this.connectionType = connectionType;
    }

    public Node getSourceNode() {
        return sourceNode;
    }
    
    public Node getTargetNode() {
        return targetNode;
    }

    public void connect() {
        sourceNode.addConnections(this);
        targetNode.addConnections(this);
    }
    
    public void disconnect() {
        sourceNode.removeConnection(this);
        targetNode.removeConnection(this);
    }
    
    public void reconnect(Node sourceNode, Node targetNode) {
        if (sourceNode == null || targetNode == null || sourceNode == targetNode) {
            throw new IllegalArgumentException();
        }
        disconnect();
        this.sourceNode = sourceNode;
        this.targetNode = targetNode;
        connect();
    }

    public void setConnectionType(int connectionType) {
        this.connectionType = connectionType;
    }

    public int getConnectionType() {
        return connectionType;
    }
}

In tutogef.model.Node we have to add the ability to hold connections by adding two Lists and two more events for our PropertyChangeListener to act up on:

public class Node implements IAdaptable {  

    // ...

    private List sourceConnections;

    private List targetConnections;

    // ...

    public static final String SOURCE_CONNECTION = "SourceConnectionAdded";
    public static final String TARGET_CONNECTION = "TargetConnectionAdded";
    // ...
    public Node {
        //...
        this.sourceConnections = new ArrayList();
        this.targetConnections = new ArrayList();
        //...
    }

and in order to add or remove connections:
      // ...

    public boolean addConnections (Connection conn) {
        if (conn.getSourceNode() == this) {
            if (!sourceConnections.contains(conn)) {
                if (sourceConnections.add(conn)) {
                    getListeners().firePropertyChange(SOURCE_CONNECTION, null, conn);
                    return true;
                }
                return false;
            }
        }
        else if (conn.getTargetNode() == this) {
            if (!targetConnections.contains(conn)) {
                if (targetConnections.add(conn)) {
                    getListeners().firePropertyChange(TARGET_CONNECTION, null, conn);
                    return true;
                }
                return false;
            }
        }
        return false;
    }

    public boolean removeConnection(Connection conn) {
        if (conn.getSourceNode() == this) {
            if (sourceConnections.contains(conn)) {
                if (sourceConnections.remove(conn)) {
                    getListeners().firePropertyChange(SOURCE_CONNECTION, null, conn);
                    return true;
                }
                return false;
            }
        }
        else if (conn.getTargetNode() == this) {
            if (targetConnections.contains(conn)) {
                if (targetConnections.remove(conn)) {
                    getListeners().firePropertyChange(TARGET_CONNECTION, null, conn);
                    return true;
                }
                return false;
            }
        }
        return false;
    }

// ...

    public List getSourceConnectionsArray() {
        return this.sourceConnections;
    }

    public List getTargetConnectionsArray() {
        return this.targetConnections;
    }
}

Next we will create the corresponding ConnectionPart to our Connection model. As for all Parts before, we will start with an abstract class called AppAbstractConnectionEditPart in tutogef.part:

package tutogef.part;

import org.eclipse.draw2d.IFigure;
import org.eclipse.gef.editparts.AbstractConnectionEditPart;

public abstract class AppAbstractConnectionEditPart extends AbstractConnectionEditPart {
    @Override
    protected IFigure createFigure() {
        // TODO Auto-generated method stub
        return super.createFigure();
    }

    public void activate() {
        super.activate();
    }

    public void deactivate() {
        super.deactivate();
    }

    @Override
    protected void createEditPolicies() {}
}

Now in ConnectionPart which extends the class we just created we also create the figure which is displayed in the Editor later on. Note that there is no need to create a separate ConnectionFigure. That has already been done for us by the draw2d package. Also we set different styles and labels the different connection types.

package tutogef.part;

import org.eclipse.draw2d.ColorConstants;

import org.eclipse.draw2d.IFigure;

import org.eclipse.draw2d.Label;

import org.eclipse.draw2d.MidpointLocator;

import org.eclipse.draw2d.PolygonDecoration;

import org.eclipse.draw2d.PolylineConnection;

import org.eclipse.gef.EditPolicy;

import org.eclipse.gef.editpolicies.ConnectionEndpointEditPolicy; 

import org.eclipse.swt.SWT;

import tutogef.model.Connection;

import tutogef.editpolicy.AppConnectionDeleteEditPolicy; 

public class ConnectionPart extends AppAbstractConnectionEditPart {

    protected IFigure createFigure() {

        PolylineConnection connection = (PolylineConnection) super.createFigure();

        connection.setLineWidth(2);

        PolygonDecoration decoration = new PolygonDecoration();

        decoration.setTemplate(PolygonDecoration.TRIANGLE_TIP);

        connection.setTargetDecoration(decoration);

        Label label = new Label();

        switch (((Connection) getModel()).getConnectionType()) {

            case 1:

                label.setText("deliver design"); 

                connection.setLineStyle(SWT.LINE_DASH);

                label.setBackgroundColor(ColorConstants.green);

                break;

            case 2:

                label.setText("deliver resources");

                connection.setLineStyle(SWT.LINE_DOT);

                break;

            case 3:

                label.setText("distribute work packages");

                connection.setLineStyle(SWT.LINE_SOLID);

                label.setBackgroundColor(ColorConstants.green);

                break;

            default: return null;

        }

        label.setOpaque( true );

        connection.add(label, new MidpointLocator(connection, 0));

        return connection;

    }

    @Override

    protected void createEditPolicies() {

        installEditPolicy(EditPolicy.CONNECTION_ROLE, new AppConnectionDeleteEditPolicy());

        installEditPolicy(EditPolicy.CONNECTION_ENDPOINTS_ROLE, new ConnectionEndpointEditPolicy());

    }

}

As we can see there are two new EditPolicies alone in this class. In ServicePart is another one coming up. Lets create them in tutogef.edpolicy and start with AppConnectionDeleteEditPolicy. It is almost self explanatory. It gives our Connection the ability to be removed and invokes the ConnectionDeleteCommand to cleanly do so:

package tutogef.editpolicy;

import org.eclipse.gef.commands.Command;
import org.eclipse.gef.editpolicies.ConnectionEditPolicy;
import org.eclipse.gef.requests.GroupRequest;

public class AppConnectionDeleteEditPolicy extends ConnectionEditPolicy {

    @Override
    protected Command getDeleteCommand(GroupRequest arg0) {
       ConnectionDeleteCommand command = new ConnectionDeleteCommand();
       command.setLink(getHost().getModel());
       return command;
    }
}

The ConnectionDeleteCommand looks like this:

package tutogef.model.command;

import org.eclipse.gef.commands.Command;
import tutogef.model.Connection;

public class ConnectionDeleteCommand extends Command {

    private Connection conn;

    public void setLink(Object model) {
       this.conn = (Connection)model;
    }

    @Override
    public boolean canExecute() {
       if (conn == null)
           return false;
       return true;
    }

    @Override
    public void execute() {
       conn.disconnect();
    }

    @Override
    public boolean canUndo() {
       if (conn == null)
           return false;
       return true;
    }

    @Override
    public void undo() {
       conn.connect();
    }
}

In order to enable the ability to connect our Services with arrows we have to add the AppConnectionPolicy in tutogef.part.ServicePart, tell ServicePart to react on fired Events when a Connection was added and two very important methods called getModelSourceConnections and getModelTargetConnections:

    // ...

    @Override
    protected void createEditPolicies() {
// ...
        installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, new AppConnectionPolicy());

    }
// ...
    public List getModelSourceConnections() {
        return ((Service)getModel()).getSourceConnectionsArray();
    }

    public List getModelTargetConnections() {
        return ((Service)getModel()).getTargetConnectionsArray();
    }

    @Override
    public void propertyChange(PropertyChangeEvent evt) {

    // ...
if (evt.getPropertyName().equals(Node.SOURCE_CONNECTION)) refreshSourceConnections();
        if (evt.getPropertyName().equals(Node.TARGET_CONNECTION)) refreshTargetConnections();

    }
    // ...

The AppConnectionPolicy starts the requests to connect source and target. A reconnection is handles separately:

package tutogef.part;

import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPolicy;
import org.eclipse.gef.Request;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy;
import org.eclipse.gef.requests.CreateConnectionRequest;
import org.eclipse.gef.requests.ReconnectRequest;

import tutogef.model.Connection;
import tutogef.model.Node;
import tutogef.model.command.ConnectionCreateCommand;
import tutogef.model.command.ConnectionReconnectCommand;

public class AppConnectionPolicy extends GraphicalNodeEditPolicy {

    @Override
    protected Command getConnectionCompleteCommand(CreateConnectionRequest request) {
        ConnectionCreateCommand cmd = (ConnectionCreateCommand)request.getStartCommand();
        Node targetNode = (Node)getHost().getModel();
        cmd.setTargetNode(targetNode);
        return cmd;
    }

    @Override
    protected Command getConnectionCreateCommand(CreateConnectionRequest request) {
        ConnectionCreateCommand cmd = new ConnectionCreateCommand();
        Node sourceNode = (Node)getHost().getModel();
        cmd.setConnectionType(Integer.parseInt(request.getNewObjectType().toString()));
        cmd.setSourceNode(sourceNode);
        request.setStartCommand(cmd);
        return cmd;
    }

    @Override
    protected Command getReconnectSourceCommand(ReconnectRequest request) {
        Connection conn = (Connection)request.getConnectionEditPart().getModel();
        Node sourceNode = (Node)getHost().getModel();
        ConnectionReconnectCommand cmd = new ConnectionReconnectCommand(conn);
        cmd.setNewSourceNode(sourceNode);
        return cmd;
    }

    @Override
    protected Command getReconnectTargetCommand(ReconnectRequest request) {
        Connection conn = (Connection)request.getConnectionEditPart().getModel();
        Node targetNode = (Node)getHost().getModel();
        ConnectionReconnectCommand cmd = new ConnectionReconnectCommand(conn);
        cmd.setNewTargetNode(targetNode);
        return cmd;
    }
}

The Commands for connecting and reconnecting the nodes are very straight forward. We create them in tutogef.model.command starting with the ConnectionCreateCommand:

package tutogef.model.command;

import org.eclipse.gef.commands.Command;

import tutogef.model.Connection;
import tutogef.model.Node;

public class ConnectionCreateCommand extends Command {

    private Node sourceNode, targetNode;
    private Connection conn;
    private int connectionType;

    public void setSourceNode(Node sourceNode) {
        this.sourceNode = sourceNode;
    }

    public void setTargetNode(Node targetNode) {
        this.targetNode = targetNode;
    }

    @Override
    public boolean canExecute() {
        if (sourceNode == null || targetNode == null)
            return false;
        else if (sourceNode.equals(targetNode))
            return false;
        return true;
    }

    @Override
    public void execute() {
        conn = new Connection(sourceNode, targetNode, connectionType);
        conn.connect();
    }

    @Override
    public boolean canUndo() {
        if (sourceNode == null || targetNode == null || conn == null)
            return false;
        return true;
    }

    @Override
    public void undo() {
        conn.disconnect();
    }

    public void setConnectionType(int connectionType) {
        this.connectionType = connectionType;
    }

    public int getConnectionType() {
        return connectionType;
    }
}

The ConnectionReconnectCommand:

package tutogef.model.command;

import org.eclipse.gef.commands.Command;

import tutogef.model.Connection;
import tutogef.model.Node;

public class ConnectionReconnectCommand extends Command {

    private Connection conn;
    private Node oldSourceNode;
    private Node oldTargetNode;
    private Node newSourceNode;
    private Node newTargetNode;

    public ConnectionReconnectCommand(Connection conn) {
        if (conn == null) {
            throw new IllegalArgumentException();
        }
        this.conn = conn;
        this.oldSourceNode = conn.getSourceNode();
        this.oldTargetNode = conn.getTargetNode();
    }

    public boolean canExecute() {
        if (newSourceNode != null) {
            return checkSourceReconnection();
        } else if (newTargetNode != null) {
            return checkTargetReconnection();
        }
        return false;
    }

    private boolean checkSourceReconnection() {
        if (newSourceNode == null)
            return false;
        else if (newSourceNode.equals(oldTargetNode))
            return false;
        else if (!newSourceNode.getClass().equals(oldTargetNode.getClass()))
            return false;
        return true;
    }

    private boolean checkTargetReconnection() {
        if (newTargetNode == null)
            return false;
        else if (oldSourceNode.equals(newTargetNode))
            return false;
        else if (!oldSourceNode.getClass().equals(newTargetNode.getClass()))
            return false;
        return true;
    }

    public void setNewSourceNode(Node sourceNode) {
        if (sourceNode == null) {
            throw new IllegalArgumentException();
        }
        this.newSourceNode = sourceNode;
        this.newTargetNode = null;
    }

    public void setNewTargetNode(Node targetNode) {
        if (targetNode == null) {
            throw new IllegalArgumentException();
        }
        this.newSourceNode = null;
        this.newTargetNode = targetNode;
    }

    public void execute() {
        if (newSourceNode != null) {
            conn.reconnect(newSourceNode, oldTargetNode);
        } else if (newTargetNode != null) {
            conn.reconnect(oldSourceNode, newTargetNode);
        } else {
            throw new IllegalStateException("Should not happen");
        }
    }

    public void undo() {
        conn.reconnect(oldSourceNode,oldTargetNode);
    }
}

There are two things left to do in tutogef.part. First thing is the ServiceParts ability to 'dock' an arrow. For that purpose we implement NodeEditPart to get the so called Anchors:

public class ServicePart extends AppAbstractEditPart implements NodeEditPart{

// ...

   @Override

    public ConnectionAnchor getSourceConnectionAnchor(

            ConnectionEditPart connection) {

       return new ChopboxAnchor(getFigure());

    }

    @Override

    public ConnectionAnchor getSourceConnectionAnchor(Request request) {

        return new ChopboxAnchor(getFigure());

    }

    @Override

    public ConnectionAnchor getTargetConnectionAnchor(

            ConnectionEditPart connection) {

        return new ChopboxAnchor(getFigure());

    }

    @Override

    public ConnectionAnchor getTargetConnectionAnchor(Request request) {

        return new ChopboxAnchor(getFigure());

    }

// ...

}

We are using the easiest method of getting our ServiceParts connected using the ChopboxAnchor. It simply calculates the shortest path from the border to the center of the figure and returns that point. For now we are not considering overlapping anchors.

Also we have to the routine which calculates our connection paths. In EnterprisePart we have to edit createFigure:

public class EnterprisePart extends AppAbstractEditPart {

    @Override

    protected IFigure createFigure() {

    //...

        ConnectionLayer connLayer = (ConnectionLayer)getLayer(LayerConstants.CONNECTION_LAYER);

        connLayer.setAntialias(SWT.ON);

        connLayer.setConnectionRouter(new ShortestPathConnectionRouter(figure));

    //...

}

}

We are almost done now! The AppEditPartFactory is not aware of the Connection model and ConnectionPart (yet):

public class AppEditPartFactory implements EditPartFactory {

    @Override

    public EditPart createEditPart(EditPart context, Object model) {

    EditPart part; 

    // ...

    else if (model instanceof Connection) {

            part = new ConnectionPart();

        }

    // ...

}

Last class we are creating is the ConnectionCreationFactory. Within this Factory we set what kind of connection we want to be created. The rest looks just like the NodeCreationFactory:

package tutogef.model;

import org.eclipse.gef.requests.CreationFactory;

public class ConnectionCreationFactory implements CreationFactory {

    private int connectionType;

    public ConnectionCreationFactory(int connectionType) {
        this.connectionType = connectionType;
    }

    @Override
    public Object getNewObject() {
        return null;
    }

    @Override
    public Object getObjectType() {
        return connectionType;
    }
}

Final step is to add the 3 new tools to our toolbar in tutogef.MyGraphicalEditor. The tool entry uses the just created factory to start the process of connecting two elements with an arrow:

//...
    @Override
    protected PaletteRoot getPaletteRoot() {
        // ...

        PaletteDrawer connectionElements = new PaletteDrawer("Connecting Elements");
        root.add(connectionElements);

        connectionElements.add(new ConnectionCreationToolEntry("deliver design","Create Connections",
                new ConnectionCreationFactory(Connection.CONNECTION_DESIGN),
                null,
                null));

        connectionElements.add(new ConnectionCreationToolEntry("deliver resources","Create Connections",
                new ConnectionCreationFactory(Connection.CONNECTION_RESOURCES),
                null,
                null));
        connectionElements.add(new ConnectionCreationToolEntry("distribute work packages","Link Layers",
                new ConnectionCreationFactory(Connection.CONNECTION_WORKPACKAGES),
                null,
                null));
        // ...

    }

Now the time has come to try our new feature. Fire up TutoGEF!

Here is the extended TutoGEF project.

Using GraphicalEditorWithFlyoutPalette

2009-10-07T10:50:00.000-07:00

I personally prefer the FlyoutPalette over the one we implemented in TutoGEF. In order to use it we have to do some minor changes to our code:

In tutogef.MyGraphicalEditor change:

public class MyGraphicalEditor extends GraphicalEditorWithPalette

to:

public class MyGraphicalEditor extends GraphicalEditorWithFlyoutPalette

Also remove the methode initializePaletteViewer()

To get our DragSourceListener we just removed back we need to Override another methode:

@Override

protected PaletteViewerProvider createPaletteViewerProvider() {

    return new PaletteViewerProvider(getEditDomain()) {

        protected void configurePaletteViewer(PaletteViewer viewer) {

            super.configurePaletteViewer(viewer);

            viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer))

And we are set to enjoy the new Palette!

Here is the update to TutoGEF.

TutoGEF First Extension

2009-10-05T12:05:00.000-07:00

All future howtos presuppose Eclipse and GEF in the Version 3.5 or higher and Java 1.6 or higher.

For everyone working through the TutoGEF document and have advanced to Part 10 Property Sheet - first thing to do is adding org.eclipse.ui.views to your Required Plug-ins in your dependencies tab of your project. Only then you are able to use IPropertySource in your imports!

When using a ComboBoxPropertyDescription (in tutogef.NodePropertySource) it is important to know that the getting and setting of the values from and to that ComboBox is done with indexes of the passed array of possible values.

Extending our example TutoGEF we edit our Employe to contain another value - each person now can be part of a department.

public class Employe extends Node { 

    // ...

    public static final String PROPERTY_DEPARTMENT = "EmployeDepartment";

    public static final String[] DEPARTMENTS = {"Human Resources", "Finances", "Marketing", "Engineering"}; 

    // ...

    private String department; 

    // ...

    public void setPrenom(String prenom) {

        String oldPrenom = this.prenom;

        this.prenom = prenom;

        getListeners().firePropertyChange(PROPERTY_FIRSTNAME, oldPrenom, prenom);

    }

    public void setDepartment(int index) {

        String oldDepartment = department; 

        if (index > -1 && index < DEPARTMENTS.length) {

            department = DEPARTMENTS[index];

            getListeners().firePropertyChange(PROPERTY_DEPARTMENT, oldDepartment, department);

        }

    }

    public String getDepartment() {

        return department;

    }

    // ...

}

In order to display the new data we change our figure and add a new Label in EmployeFigure:

public class EmployeFigure extends Figure {

    // ...

    private Label labelDepartment = new Label();

    // ...

    public static final int EMPLOYE_FIGURE_DEFHEIGHT = 60;

    public EmployeFigure() {

        // ...

        add(labelName, ToolbarLayout.ALIGN_CENTER); 

        labelDepartment.setForegroundColor(ColorConstants.black);

        // ...

}

    public void setDepartment(String department) {

        labelDepartment.setText(department);

    }

    // ...

}

We just added new Listeners to the Employe's setPrenom and setDepartment methodes. In the EmployePart we react on them and update the figure.

public class EmployePart extends AppAbstractEditPart {

    protected void refreshVisuals() {

        // ... 

        figure.setDepartment(model.getDepartment());

        // ... 

}

    public void propertyChange(PropertyChangeEvent evt) {

        if (evt.getPropertyName().equals(Employe.PROPERTY_DEPARTMENT)) refreshVisuals();

        if (evt.getPropertyName().equals(Employe.PROPERTY_FIRSTNAME)) refreshVisuals(); 

}

}

The final step is to add the new department property to the PropertySheetPage. In order to do so we add a few lines in NodePropertySource. In the IPropertyDescriptor[] method we add the ComboBoxPropertyDescriptor. It is very important that it uses an array (Employe.DEPARTMENTS in our case) to handle the data. We need to use indexes of that array to set and get the departments(see methods getPropertyValue and setPropertyValue).

public class NodePropertySource implements IPropertySource {

    public IPropertyDescriptor[] getPropertyDescriptors() {

        // ...

        else if (node instanceof Employe) {

            properties.add(new TextPropertyDescriptor(Employe.PROPERTY_FIRSTNAME, "Prenom"));

            properties.add(new ComboBoxPropertyDescriptor(Employe.PROPERTY_DEPARTMENT, "Department", Employe.DEPARTMENTS));

        }

       // ... 

}

    public Object getPropertyValue(Object id) {

        // ...

        if (id.equals(Employe.PROPERTY_DEPARTMENT)) {

            String department = (((Employe)node).getDepartment());

            for (int i=0; i

                if (Employe.DEPARTMENTS[i].equals(department)) {

                    return i;

                }

            }

            return -1;

        }

        //...

}

    public void setPropertyValue(Object id, Object value) {

        // ...

        else if (id.equals(Employe.PROPERTY_FIRSTNAME)) {

            try {

                ((Employe)node).setPrenom((String)value);

            }

            catch (NumberFormatException e) { }

        }

        else if (id.equals(Employe.PROPERTY_DEPARTMENT)) {

            try {

                Integer index = Integer.parseInt(value.toString());

                ((Employe)node).setDepartment(index);

            }

            catch (NumberFormatException e) { }

        }

        // ... 

}

}

Feel free to change each employe's department value in MyGraphicalEditor#createEnterprise so you have a default value on startup.

Here the updated TutoGEF project.

TutoGEF Project

2009-10-02T01:19:00.000-07:00

Here is the promised zip containing the TutoGEF Project as described in the GEF Tutorial Document.

In order to use it:

open Eclipse
choose File > Import
in the Import Wizard choose General > Existing Projects into Workspace
use Select Archive file and browse for TutoGEF.zip
Click finish and you are set to go!

GEF Basics

2009-09-29T11:43:00.000-07:00

In order to get started with GEF this pdf document is very helpful. It describes step by step how to create a project with the basic GEF functionalities showing screenshots of the application and all the code that is necessary. I recommend working through it before asking any questions. For those who want to save some time I will prepare a zip file containing the TutoGEF project.

At this point I want to thank Jean-Charles Mammana, Romain Meson and Jonathan Gramain for their work.

Additional Resources: