In this topic we will see a method to build a cutsom figure with specific edge anchor zones.

We will build a diagram editor allowing to draw operators such as plus and minus. We'll connect them to input entries and output results.

An operator has two inputs and one output. The input may be connected to an entry (that the user may modify), or a result (which is read only). The output can only be connected to a result.

Our aim is to be able to anchor the diagram edges on the graphical representations of ou operator inputs and output. To do that, we will use specific model objects (OperatorInput and OperatorOutput) that will be contained in our operators (containment association). Their graphical representations will be “manually” positionned in a container rectangle (this rectangle will also receive the other graphical items that helps to represent the operator).

Full code is availabale through :

• SVN : https://gmfsamples.svn.sourceforge.net/svnroot/gmfsamples/Math/tags/tuto5-step4-final-diagram
• direct download : https://sourceforge.net/projects/gmfsamples/files/20091121/tuto5-step4-final-diagram.zip/download

Full code is also available for several intermediate steps of this tutorial through :

• SVN :
  • https://gmfsamples.svn.sourceforge.net/svnroot/gmfsamples/Math/tags/tuto5-step1-model-created
  • https://gmfsamples.svn.sourceforge.net/svnroot/gmfsamples/Math/tags/tuto5-step1-basic-diagram
  • https://gmfsamples.svn.sourceforge.net/svnroot/gmfsamples/Math/tags/tuto5-step1-intermediate-diagram
• direct download :
  • https://sourceforge.net/projects/gmfsamples/files/20091121/tuto5-step1-model-created.zip/download
  • https://sourceforge.net/projects/gmfsamples/files/20091121/tuto5-step1-basic-diagram.zip/download
  • https://sourceforge.net/projects/gmfsamples/files/20091121/tuto5-step1-intermediate-diagram.zip/download

This tutorial has been built with :

• Eclipse 3.5.1
• Graphical Modeling Framework SDK 2.2.1
• Eclipse Modeling Framework 2.5.0

Known bugs and fixes :

• This tutorial doesn't show how to avoid compartment deletion : see this page to see how to fix it
• This tutorial doesn't show how to ensure that compartment nodes that are automatically added (ie. operator output and inputs) are persisted : see this page to see how to fix it

We will build our model with the annotated java interfaces method.

• Create a new GMF Project named Math
• Create a new Java package jfb.examples.gmf.math
• Create the following java interfaces in this package :

package jfb.examples.gmf.math;
 
/**
 * @model
 */
public interface OperatorInput {
 
	/**
	 * @model
	 */
	public Operator getOperator();
 
	/**
	 * @model
	 */
	public Number getNumber();
 
}

package jfb.examples.gmf.math;
 
/**
 * @model
 */
public interface OperatorOutput {
 
	/**
	 * @model
	 */
	public Operator getOperator();
 
	/**
	 * @model
	 */
	public Result getResult();
 
}

package jfb.examples.gmf.math;
 
import java.util.List;
 
/**
 * @model abstract="true"
 */
public interface Operator {
 
	/**
	 * @model containment="true"
	 */
	public List<OperatorInput> getInputs();
 
	/**
	 * @model containment="true"
	 */
	public OperatorOutput getOutput();
 
}

package jfb.examples.gmf.math;
 
/**
 * @model
 */
public interface MinusOperator extends Operator {
 
}

package jfb.examples.gmf.math;
 
/**
 * @model
 */
public interface PlusOperator extends Operator {
 
}

package jfb.examples.gmf.math;
 
import java.util.List;
 
/**
 * @model abstract="true"
 */
public interface Number {
 
	/**
	 * @model
	 */
	public List<OperatorInput> getOperatorInputs();
 
}

package jfb.examples.gmf.math;
 
/**
 * @model
 */
public interface Entry extends Number {
 
}

package jfb.examples.gmf.math;
 
/**
 * @model
 */
public interface Result extends Number {
 
	/**
	 * @model
	 */
	public OperatorOutput getOperatorOutput();
 
}

package jfb.examples.gmf.math;
 
import java.util.List;
 
/**
 * @model
 */
public interface MathDiagram {
 
	/**
	 * @model containment="true"
	 */
	public List<Operator> getOperators();
 
	/**
	 * @model containment="true"
	 */
	public List<Entry> getEntries();
 
	/**
	 * @model containment="true"
	 */
	public List<Result> getResults();
 
}

• Create a new EMF Generator model named math.genmodel in the model folder (see tutorial #1 for an example).
• Choose Annotated Java as Model Importer and jfb.example.gmf.math in the packages list.
• Open the math.ecore file
• Select the operatorInputs : OperatorInput (child node of Number) and set the EOpposite property to number : Number (wich belongs to the OperatorInput element).
• If you check the number : Number (child node of OperatorInput), the EOpposite property should be set to operatorInputs : OperatorInput.
• Repeat this operation with the result : Result child node of OperatorOutput and the operatorOutput : OperatorOutput child node of Result.
• Repeat this operation with the inputs : OperatorInput child node of Operator and the operator : Operator child node of OperatorInput.
• Repeat this operation with the inputs : OperatorOutput child node of Operator and the operator : Operator child node of OperatorOutput.
• Set the Lower Bound and Upper Bound of the inputs : OperatorInput node in the property view to 2 (child node of the Operator element).
• Save the file
• Generate the model classes and configure the GMF dashboard view (see tutorial #1 for more details on these steps)

• Open the math.genmodel file
• Right click the root element of the model, and select Generate Model Code
• Right click the root element of the model, and select Generate Edit Code
• Right click the root element of the model, and select Generate Editor Code

We need 6 creation tools :

• one for the plus operators
• one for the minus operators
• one for the entries
• one for the results
• one for the “entry/result to operator” edge
• one for the “operator to result” edge

Procedure :

• In the dashboard, click on the Derive label which is on the left of the Tooling Def Model rectangle
• Select the filename math.gmftool in the folder model
• Select the diagram element MathDiagram and click Next
• In the Nodes column, select (and select only) : Entry, Minusoperator, PlusOperator, Result
• In the Connections column, select (and select only) : Entry.operatorInputs, OperatorOutput.result
• Click Finish
• You should get this :

• Reorder the tools (add a new tool group, rename it and drag'n'drop the items) like this :

Procedure :

• In the dashboard, click on the Derive label which is on the left of the Graphical Def Model rectangle.
• Set the filename to math.gmfgraph in the model folder
• Select the diagram element MathDiagram and click Next
• In the Nodes column, select (and select only) : Entry, Minusoperator, OperatorInput, OperatorOutput, PlusOperator, Result
• In the Connections column, select (and select only) : Entry.operatorInputs, OperatorOutput.result, Result.operatorInputs
• In the Label column, select : Entry.value, Result.value
• Click Finish
• Open the math.gmfgraph file
• Under the Rectangle MinusOperatorFigure node (which is under the Figure Descriptor MinusOperatorFigure) :
  • Add a Boder Layout
  • Add a Rectangle named MinusOperatorCompartmentFigure
  • Under the last node (Rectangle MinusOperatorCompartmentFigure), add a Border Layout Data (with Alignment = CENTER)
• Under the Figure Descriptor MinusOperatorFigure node, add a Child access and select Rectangle MinusOperatorCompartmentFigure for its figure (in the properties view)
• Yout should get this result :

• Repeat the same operations for the Plus operator :

• Under the Canvas math node, add two Compartment nodes
• For the first :
  • set its name to MinusOperatorFigureCompartment
  • select Figure Descriptor MinusOperatorFigure for its figure and Child Access getFigureMinusOperatorCompartmentFigure for its accessor
• For the second
  • set its name to PlusOperatorFigureCompartment
  • select Figure Descriptor PlusOperatorFigure for its figure and Child Access getFigurePlusOperatorCompartmentFigure for its accessor
• Under the Figure Descriptor ResultFigure, change the Rectangle ResultFigure into an Ellispe ResultFigure (it is possible to open the math.gmfmap with a text editor and replace the string Rectangle by Ellipse in the node <actualFigure xsi:type=“gmfgraph:Rectangle” name=“ResultFigure”>
• Save the file.

• In the dashboard, click on the Combine label
• Select the math.gmfmap filename in the model folder
• Select the diagram element MathDiagram and click Next
• Click Next on the Select Diagram Palette page
• Click Next on the Select Diagram Canvas page
• Move OperatorOutput (<OperatorOutputResult: output) and OperatorInput (<EntryOperatorInputs: inputs) form the links zone to the nodes zone (right to left) on the Mapping page like this :

• Click Finish
• Open the math.gmfmap file
• Under the Node Mapping <Result/Result> add a Feature Label Mapping and set its properties :
  • Feature to display=Number.value:EDouble
  • Diagram Label=Diagram Label ResultValue
  • Read Only=true
• Under the Node Mapping <Entry/Entry> add a Feature Label Mapping and set its properties :
  • Feature to display=Number.value:EDouble
  • Diagram Label=Diagram Label EntryValue
  • Read Only=false
• Under the Node Mapping <MinusOperator/MinusOperator> node (which is under Top Node Reference <operators:MinusOperator/MinusOperator>) :
  • Add a new Compartment Mapping and select Compartment MinusOperatorFigureCompartment (MinusoperatorFigure) in the properties view
  • Add a new Child Reference and set its properties like this :
    • Compartment=Compartment Mapping <MinusOperatorFigureCompartment>
    • Containment feature=Operator.inputs:OperatorInput
    • Reference Child = (empty)
  • Drag and drop the node Node Mapping <OperatorInput/OperatorInput> under this Child Reference node
  • Delete the Top Node Reference <inputs:OperatorInput/OperatorInput> under which was the node that has just been moved
  • Add a new Child Reference and set its properties like this :
    • Compartment=Compartment Mapping <MinusOperatorFigureCompartment>
    • Containment feature=Operator.outut:OperatorOutput
    • Reference Child = (empty)
  • Drag and drop the node Node Mapping <OperatorOutput/OperatorOutput> under this Child Reference node
  • Delete the Top Node Reference <output:OperatorOutput/OperatorOutput> under which was the node that has just been moved
• Under the Node Mapping <PlusOperator/PlusOperator> node (which is under Top Node Reference <operators:PlusOperator/PlusOperator>) :
  • Add a new Compartment Mapping and select Compartment PlusOperatorFigureCompartment (PlusoperatorFigure) in the properties view
  • Add a new Child Reference and set its properties like this :
    • Compartment=Compartment Mapping <PlusOperatorFigureCompartment>
    • Containment feature=Operator.inputs:OperatorInput
    • Reference Child = Node mapping <OperatorInput/>
  • Add a new Child Reference and set its properties like this :
    • Compartment=Compartment Mapping <PlusOperatorFigureCompartment>
    • Containment feature=Operator.outut:OperatorOutput
    • Reference Child = Node mapping <OperatorOutput/>
• Correct the diagram nodes and tool mappings :
  • For Node Mapping <Result/Result> :
    • Diagram Node=Node Result (ResultFigure)
    • Tool=Creation Tool Result
  • For Node Mapping <Entry/Entry> :
    • Diagram Node=Node Entry (EntryFigure)
    • Tool=Creation Tool Entry
  • For Node Mapping <MinusOperator/MinusOperator> :
    • Diagram Node=Node MinusOperator (MinusOperatorFigure)
    • Tool=Creation Tool MinusOperator
  • For Node Mapping <PlusOperator/PlusOperator> :
    • Diagram Node=Node PlusOperator (PlusOperatorFigure)
    • Tool=Creation Tool PlusOperator
  • For Node Mapping <OperatorOutput/> :
    • Diagram Node=Node OperatorOutput (OperatorOutputFigure)
    • Tool= (empty !)
  • For Node Mapping <OperatorInput/> :
    • Diagram Node=Node OperatorInput (OperatorInputFigure)
    • Tool= (empty !)
• Correct the diagram links and tool mappings :
  • For Link Mapping <{Number.operatorInputs:OperatorInput}/EntryOperatorInput> :
    • Target Feature=Number.operatorInputs:OperatorInput
    • Diagram Link=Connection EntryOperatorInput
    • Tool=Creation Tool Entry/Result to operator input
  • For Link Mapping <{Result.operatorOutput:OperatorOutput}/OperatorOutputResult> :
    • Target Feature=OperatorOutput.result:Result
    • Diagram Link=Connection OperatorOutputResult
    • Tool=Creation Tool Operator output to result

• Click on the Transform label of the dashboard
• A file named math.gmfgen should be created automatically
• Open this file, and check that teh List layout property is set to true in the properties view for the following compartment nodes :
  • Gen Compartment MinuOperatorMinusOperatorFigureCompartmentEditPart
  • Gen Compartment PluOperatorPlusOperatorFigureCompartmentEditPart
• Click on the Generate diagram editor label of the dashboard
• In order to have two inputs and one output in every operator instance, we will modify the generated classes
• Open the /Math.diagram/src/jfb/examples/gmf/math/diagram/edit/commands/MinusOperatorCreateCommand.java file, edit the doExecuteWithResult(IProgressMonitor, IAdaptable) method and modify it like this (do not forget to add the 'NOT' mention after @generated) :

	/**
	 * @generated NOT
	 */
	protected CommandResult doExecuteWithResult(IProgressMonitor monitor,
			IAdaptable info) throws ExecutionException {
		MinusOperator newElement = MathFactory.eINSTANCE.createMinusOperator();
 
		// Adds both operator inputs
		newElement.getInputs().add(MathFactory.eINSTANCE.createOperatorInput());
		newElement.getInputs().add(MathFactory.eINSTANCE.createOperatorInput());
 
		// Adds the operator output
		newElement.setOutput(MathFactory.eINSTANCE.createOperatorOutput());
 
		MathDiagram owner = (MathDiagram) getElementToEdit();
		owner.getOperators().add(newElement);
 
		doConfigure(newElement, monitor, info);
 
		((CreateElementRequest) getRequest()).setNewElement(newElement);
		return CommandResult.newOKCommandResult(newElement);
	}

• Repeat this operation with the /Math.diagram/src/jfb/examples/gmf/math/diagram/edit/commands/PlusOperatorCreateCommand.java file.
• Edit the file /Math.diagram/src/jfb/examples/gmf/math/diagram/preferences/DiagramConnectionsPreferencePage.java and add this to set the default edge routing mode to rectilinear :

	public static void initDefaults(IPreferenceStore preferenceStore) {
		preferenceStore.setDefault(IPreferenceConstants.PREF_LINE_STYLE,
			Routing.RECTILINEAR);
	}

• If you start eclipse at this point (see gmf_tutorial1 for more details about starting an eclipse instance with your new diagram editor) you should get a basic diagram editor like this :

A this point, it is not possible to distinguish plus operators from minus operators, and their graphical representations are not very pleasant ! We will customize our graphical representations in the next steps.

In this part, we will customize the graphical representation of our operators to get something like this :

• Create a new package jfb.examples.gmf.math.diagram.edit.parts.custom
• In this package create a class named PlusRoundedRectangle which will extend org.eclipse.draw2d.RoundedRectangle
• In this class, we will override the paintFigure method in order to represent the plus sign :

package jfb.examples.gmf.math.diagram.edit.parts.custom;
 
import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.RoundedRectangle;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
 
public class PlusRoundedRectangle extends RoundedRectangle {
 
	public PlusRoundedRectangle() {
		super();
		setLineWidth(2);
	}
 
	public void paintFigure(Graphics graphics) {
		super.paintFigure(graphics);
		graphics.setForegroundColor(ColorConstants.black);
		graphics.setForegroundColor(ColorConstants.black);
		graphics.setLineStyle(Graphics.LINE_SOLID);
		graphics.setLineWidth(3);
		Rectangle r = getBounds();
		// vertical line
		graphics.drawLine(
				new Point(r.x + r.width / 2, r.y + r.height * 0.2),
				new Point(r.x + r.width / 2, r.y + r.height * 0.8));
		// horizontal line
		graphics.drawLine(
				new Point(r.x + r.width * 0.2, r.y + r.height / 2),
				new Point(r.x + r.width * 0.8, r.y + r.height / 2));
	};
 
}

• Create a second class named MinusRoundedRectangle the same way :

package jfb.examples.gmf.math.diagram.edit.parts.custom;
 
import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.RoundedRectangle;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
 
public class MinusRoundedRectangle extends RoundedRectangle {
 
	public MinusRoundedRectangle() {
		super();
		setLineWidth(2);
	}
 
	public void paintFigure(Graphics graphics) {
		super.paintFigure(graphics);
		graphics.setForegroundColor(ColorConstants.black);
		graphics.setForegroundColor(ColorConstants.black);
		graphics.setLineStyle(Graphics.LINE_SOLID);
		graphics.setLineWidth(3);
		Rectangle r = getBounds();
		// horizontal line
		graphics.drawLine(
				new Point(r.x + r.width * 0.2, r.y + r.height / 2),
				new Point(r.x + r.width * 0.8, r.y + r.height / 2));
	};
 
}

* Now we add our rounded rectangles to the graphical representations of our operators. To do that, edit the /Math.diagram/src/jfb/examples/gmf/math/diagram/edit/parts/MinusOperatorMinusOperatorFigureCompartmentEditPart.java file and modify the createFigure method :

	/**
	 * @generated NOT
	 */
	public IFigure createFigure() {
		ResizableCompartmentFigure result = (ResizableCompartmentFigure) super
				.createFigure();
		result.setTitleVisibility(false);
 
		// Setup for a XYLayout
		IFigure contentPane = result.getContentPane();
		contentPane.setLayoutManager(new XYLayout());
 
		// Delete content pane insets
		Insets is = contentPane.getInsets();
		is.top = 0;
		is.bottom = 0;
		is.left = 0;
		is.right = 0;
 
		// Setup graphical elements
		MinusRoundedRectangle roundedRectangle = new MinusRoundedRectangle();
		contentPane.add(roundedRectangle);
 
		// Add the resize events listener
		result.addFigureListener(new OperatorCompartmentFigureListener(this, roundedRectangle));
 
		return result;
	}

• Do it again for the plus operator with PlusOperatorPlusOperatorFigureCompartmentEditPart.java :

	/**
	 * @generated NOT
	 */
	public IFigure createFigure() {
		ResizableCompartmentFigure result = (ResizableCompartmentFigure) super
				.createFigure();
		result.setTitleVisibility(false);
 
		// Setup for a XYLayout
		IFigure contentPane = result.getContentPane();
		contentPane.setLayoutManager(new XYLayout());
 
		// Delete content pane insets
		Insets is = contentPane.getInsets();
		is.top = 0;
		is.bottom = 0;
		is.left = 0;
		is.right = 0;
 
		// Setup graphical elements
		PlusRoundedRectangle roundedRectangle = new PlusRoundedRectangle();
		contentPane.add(roundedRectangle);
 
		// Add the resize events listener
		result.addFigureListener(new OperatorCompartmentFigureListener(this, roundedRectangle));
 
		return result;
	}

• Now we will create a component that will listen to figure resize events (the missing component that implies compilation problems). In the previous package, we create a class named OperatorCompartmentFigureListener. This component will resize the rounded rectangle and the operator inputs and output :

package jfb.examples.gmf.math.diagram.edit.parts.custom;
 
import java.util.List;
 
import jfb.examples.gmf.math.diagram.edit.parts.OperatorInputEditPart;
import jfb.examples.gmf.math.diagram.edit.parts.OperatorOutputEditPart;
 
import org.eclipse.draw2d.FigureListener;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.RoundedRectangle;
import org.eclipse.draw2d.geometry.Insets;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.editparts.AbstractEditPart;
import org.eclipse.gef.editparts.AbstractGraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ListCompartmentEditPart;
import org.eclipse.gmf.runtime.diagram.ui.figures.ResizableCompartmentFigure;
 
public class OperatorCompartmentFigureListener implements FigureListener {
 
	private ListCompartmentEditPart compartmentEditPart = null;
	private RoundedRectangle roundedRectangle = null;
 
	public static final double MARGIN = 20; // The margin to apply before drawing our operator
	public static final double R = 50; // The base length
	public static final double REF_W = 2 * MARGIN + R * 6; // Reference width
	public static final double REF_H = 2 * MARGIN + R * 5; // Reference height
 
	public OperatorCompartmentFigureListener(ListCompartmentEditPart compartmentEditPart, RoundedRectangle roundedRectangle) {
		this.compartmentEditPart = compartmentEditPart;
		this.roundedRectangle = roundedRectangle;
	}
 
	@Override
	public void figureMoved(IFigure f) {
		ResizableCompartmentFigure figure = (ResizableCompartmentFigure) f;
		if (figure.getSize().width != 0) {
			IFigure contentPane = figure.getContentPane();
			Insets is = figure.getInsets();
			// Determine the scale to apply
			double xScale = ((double) figure.getSize().width - is.left - is.right) / REF_W;
			double yScale = ((double) figure.getSize().height - is.top - is.bottom) / REF_H;
 
			// Set the constraints (bounds) for the rounded rectangle
			Rectangle constraint = new Rectangle(
					(int) ((MARGIN + R) * xScale),
					(int) ((MARGIN) * yScale), 
					(int) (R * 4 * xScale),
					(int) (R * 5 * yScale));
			contentPane.setConstraint(roundedRectangle, constraint);
 
			// Set the constraints for the input and output nodes
			List<AbstractEditPart> childs = compartmentEditPart.getChildren();
			boolean firstInputProcessed = false;
			for (AbstractEditPart child : childs) {
				if (child instanceof AbstractGraphicalEditPart) {
					AbstractGraphicalEditPart gEditPart = (AbstractGraphicalEditPart) child;
					// Operator output ?
					if (gEditPart instanceof OperatorOutputEditPart) {
						constraint = new Rectangle(
								(int) ((REF_W - MARGIN - R) * xScale),
								(int) ((REF_H - R) / 2 * yScale),
								(int) (R * xScale), 
								(int) (R * yScale));
						contentPane.setConstraint(gEditPart.getFigure(), constraint);
					}
					// Operator input ?
					else if (gEditPart instanceof OperatorInputEditPart) {
						constraint = new Rectangle(
								(int) (MARGIN * xScale),
								!firstInputProcessed ? (int) ((MARGIN + R) * yScale) : (int) ((MARGIN + R * 3) * yScale),
								(int) (R * xScale), 
								(int) (R * yScale));
						contentPane.setConstraint(gEditPart.getFigure(), constraint);
						firstInputProcessed = true; // This boolean heps to know if we process the first or the seconde operator input
					}
				}
			}
		}
	}
 
}

• Reorganize the imports in the classes in which there were compilation problems (MinusOperatorMinusOperatorFigureCompartmentEditPart and PlusOperatorPlusOperatorFigureCompartmentEditPart)
• If you start eclipse at this point you should get a diagram editor like this :

Before we add a feature that computes automatically the operations, we have to deal with a potential problem : at this point, it is possible to create cycles in our diagram :

If we let it uncorrected, it will imply infinite loops when trying to set the operator's result value.

To deal with it, we will add a contraint to our diagram that will detect the cycles.

These are the steps to follow :

• Open math.gmfmap
• Under the Mapping node, add an Audit Container node, and set its Name and Id to MathAuditContainer in the properties view.
• Under this node, add an Audit Rule node and set its properties :
  • Id = CycleDetectorRule
  • Message = A cycle has been detected
  • Name = CycleDetectorRule
  • Severity = ERROR
  • Use In Live Mode = false
• Under this node :
  • Add a Diagram Element Target node and set its Element property to Link Mapping <{OperatorOutput.result:Result}> (we want the error icon to appear on the links between the operators and their results)
  • Add a Constraint node and set its properties to :
    • Body = CycleDetectorConstraint
    • Language = java

• Save the file
• Click on the Transform label of the dashboard
• Open math.gmfgen
• Select the Gen Diagram MathDiagrameditPart node and modify its properties in order to activate the validation decorators in the diagram :
  • Validation decorators = true
  • Validation Enabled = true
• Save the file
• Click on the Generate diagram editor label of the dashboard

At this point a java skeleton has been generated that must be customized with the constraint specific java code. Before we implement the constraint, we will create a utility class that will contain the cycle detection code.

• In the Math.diagram project, create a new package named jfb.examples.gmf.math.diagram.util.
• In this package, create a java class named CycleDetectionHelper and copy/paste this code :

package jfb.examples.gmf.math.diagram.util;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import jfb.examples.gmf.math.OperatorInput;
import jfb.examples.gmf.math.Result;
import org.eclipse.emf.common.util.EList;
 
public class CycleDetectionHelper {
 
	/**
	 * Navigate through the model from one result to detect if there is a cycle. 
	 * @param fromResult the result from which the navigation starts.
	 * @return a boolean indicating if a cycle has been detected.
	 */
	public static boolean cycleDetected(Result fromResult) {
		List<Result> processedResults = new ArrayList<Result>();
		processedResults.add(fromResult);
		return cycleDetected(processedResults, fromResult);
	}
 
	/**
	 * Navigate through the model from one result to detect if there is a cycle. 
	 * @param processedResults result already processed during this navigation.
	 * @param result the result to process.
	 * @return a boolean indicating if a cycle has been detected.
	 */
	private static boolean cycleDetected(List<Result> processedResults, Result result) {
		System.out.println("cycleDetected(" + processedResults + ", " + result + ")");
		EList<OperatorInput> inputs = result.getOperatorInputs();
		boolean cycleDetected = false;
		for (Iterator<OperatorInput> it = inputs.iterator(); it.hasNext()
				&& !cycleDetected;) {
			OperatorInput operatorInput = it.next();
			cycleDetected = cycleDetected(processedResults, operatorInput);
		}
		return cycleDetected;
 
	}
 
	/**
	 * Navigate through the model from one result to detect if there is a cycle. 
	 * @param processedResults result already processed during this navigation.
	 * @param input the input to examine.
	 * @return a boolean indicating if a cycle has been detected.
	 */
	private static boolean cycleDetected(List<Result> processedResults, OperatorInput input) {
		System.out.println("cycleDetected(" + processedResults + ", " + input + ")");
		boolean cycleDetected = false;
		if (input != null) {
			Result nextResult = input.getOperator().getOutput().getResult();
			if (nextResult != null) {
				// A cycle is detected if we meet once again the first result in the stack 
				cycleDetected = processedResults.get(0) == nextResult;
				// If no cycle is detected at this point, we proceed with the next result
				if (!cycleDetected) {
					// but only if we haven't already met this result (which would mean that 
					// our diagram contains a cycle but for a different result from the
					// one on which we are working for this time, ie. processedResults.get(0)).
					if (!processedResults.contains(nextResult)) {
						processedResults.add(nextResult);
						cycleDetected = cycleDetected(processedResults, nextResult);
					}
				}
			}
		}
		return cycleDetected;
	}
 
}

Now we can implement the constraint :

• Open /Math.diagram/src/jfb/examples/gmf/math/diagram/providers/MathValidationProvider.java
• Goto to the validate method of the Adapter1 inner class and modify it like this (do not forget to add NOT after @generated) :

/**
 * @generated NOT
 */
public IStatus validate(IValidationContext ctx) {
	Edge edge = (Edge) ctx.getTarget();
	Result result = (Result) edge.getTarget().getElement();
	boolean cycleDetected = CycleDetectionHelper.cycleDetected(result);
	return cycleDetected ? ctx.createFailureStatus(edge) : ctx.createSuccessStatus();
}

As we want validation to be performed whenever our diagram is saved, we must add the following line in the doSaveDocument(IProgressMonitor monitor, Object element, IDocument document, boolean overwrite) method of our MathDocumentProvider class (located in the jfb.examples.gmf.math.diagram.part package) :

ValidateAction.runValidation((View) document.getContent());

If you start eclipse, modify you diagram and save it, you should get this result (an error icon appears on all the operator output to result links of the cycle) :

Now that we are able to detect cycles, we can add a feature that will compute automatically the operations.

To do that, we will listen to the model change notifications, and more precisely :

• Entry value changes
• Result value changes
• Number to OperatorInput connections
• OperatorOutput to Result connections

With GMF, model changes notification are easy to handle. It is possible to simply override the EditParts handleNotificationEvent(Notification notification) methods.

Before we add these handles, we first add a utility class that will help use to compute our operations :

• In the jfb.examples.gmf.math.diagram.edit.parts.custom package, add a class named AutomaticComputationHelper and paste this code :

package jfb.examples.gmf.math.diagram.edit.parts.custom;
 
import jfb.examples.gmf.math.Number;
import jfb.examples.gmf.math.Operator;
import jfb.examples.gmf.math.OperatorInput;
import jfb.examples.gmf.math.PlusOperator;
import jfb.examples.gmf.math.Result;
import jfb.examples.gmf.math.diagram.util.CycleDetectionHelper;
 
import org.eclipse.emf.common.util.EList;
 
public class AutomaticComputationHelper {
 
	public static void numberValueChanged(Number number) {
		EList<OperatorInput> inputs = number.getOperatorInputs();
		for (OperatorInput operatorInput : inputs) {
			Operator op = operatorInput.getOperator();
			updateOperatorResult(op);
		}
	}
 
	public static void operatorOutputToResultConnectionChanged(Result result) {
		if (result.getOperatorOutput() == null) {
			result.setValue(0);
		}
		else {
			updateOperatorResult(result.getOperatorOutput().getOperator());
		}
	}
 
	public static void updateOperatorResult(Operator operator) {
		Result result = operator.getOutput().getResult();
		if (result!=null) {
			// If there is a cycle...
			if (CycleDetectionHelper.cycleDetected(result)) {
				result.setValue(0);
			}
			else {
				Number in1 = operator.getInputs().get(0).getNumber();
				Number in2 = operator.getInputs().get(1).getNumber();
				double _in1 = in1 != null ? in1.getValue() : 0;
				double _in2 = in2 != null ? in2.getValue() : 0;
				result.setValue(operator instanceof PlusOperator ? _in1 + _in2 : _in1 - _in2);
			}
		}
	}
 
}

Now we will add code to handle the model changes. “Entry value changes” will be handled in EntryEditPart :

• Open /Math.diagram/src/jfb/examples/gmf/math/diagram/edit/parts/EntryEditPart.java
• Add the following overriding method :

protected void handleNotificationEvent(Notification notification) {
	super.handleNotificationEvent(notification);
	System.out.println("entry.handleNotificationEvent(" + notification + ")");
	if (notification.getNotifier() instanceof Entry) {
		if (notification.getFeature() instanceof EAttribute) {
			String attrName = ((EAttribute) notification.getFeature()).getName();
			if ("value".equals(attrName)) {
				AutomaticComputationHelper.numberValueChanged((Number) notification.getNotifier());
			}
		}
	}
}

“Number to OperatorInput connections” will be handled in OperatorInputEditPart :

• Open /Math.diagram/src/jfb/examples/gmf/math/diagram/edit/parts/OperatorInputEditPart.java
• Add the following overriding method :

protected void handleNotificationEvent(Notification notification) {
	super.handleNotificationEvent(notification);
	if (notification.getNotifier() instanceof OperatorInput) {
		if (notification.getFeature() instanceof EReference) {
			String refName = ((EReference) notification.getFeature()).getName();
			if ("number".equals(refName)) {
				AutomaticComputationHelper.updateOperatorResult(((OperatorInput) notification.getNotifier()).getOperator());
			}
		}
	}
}

“Result value changes” and “OperatorOutput to Result connections” will be handled in ResultEditPart :

• Open /Math.diagram/src/jfb/examples/gmf/math/diagram/edit/parts/ResultEditPart.java
• Add the following overriding method :

protected void handleNotificationEvent(Notification notification) {
	super.handleNotificationEvent(notification);
	if (notification.getNotifier() instanceof Result) {
		if (notification.getFeature() instanceof EAttribute) {
			String attrName = ((EAttribute) notification.getFeature()).getName();
			if ("value".equals(attrName)) {
				AutomaticComputationHelper.numberValueChanged((Number) notification.getNotifier());
			}
		}
		else if (notification.getFeature() instanceof EReference) {
			String refName = ((EReference) notification.getFeature()).getName();
			if ("operatorOutput".equals(refName)) {
				AutomaticComputationHelper.operatorOutputToResultConnectionChanged((Result) notification.getNotifier());
			}
		}
	}
}

If you start eclipse, you should now get a “full featured” operator diagram editor !

I hope that this material will be helpful for you. If you want to support it, your help is welcome :