plugins/org.eclipse.gmf.bridge/src/org/eclipse/gmf/internal/bridge/genmodel/DiagramGenModelTransformer.java

/*
 * Copyright (c) 2005, 2010 Borland Software Corporation and others
 * 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Artem Tikhomirov (Borland) - initial API and implementation
 */
package org.eclipse.gmf.internal.bridge.genmodel;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.codegen.ecore.genmodel.GenClass;
import org.eclipse.emf.codegen.ecore.genmodel.GenClassifier;
import org.eclipse.emf.codegen.ecore.genmodel.GenDataType;
import org.eclipse.emf.codegen.ecore.genmodel.GenFeature;
import org.eclipse.emf.codegen.ecore.genmodel.GenModel;
import org.eclipse.emf.codegen.ecore.genmodel.GenPackage;
import org.eclipse.emf.codegen.util.CodeGenUtil;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EEnum;
import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.gmf.codegen.gmfgen.DesignLabelModelFacet;
import org.eclipse.gmf.codegen.gmfgen.ElementType;
import org.eclipse.gmf.codegen.gmfgen.ExpressionLabelModelFacet;
import org.eclipse.gmf.codegen.gmfgen.ExpressionLabelParser;
import org.eclipse.gmf.codegen.gmfgen.ExternalParser;
import org.eclipse.gmf.codegen.gmfgen.FeatureLabelModelFacet;
import org.eclipse.gmf.codegen.gmfgen.FeatureLinkModelFacet;
import org.eclipse.gmf.codegen.gmfgen.GMFGenFactory;
import org.eclipse.gmf.codegen.gmfgen.GenActionFactoryContributionItem;
import org.eclipse.gmf.codegen.gmfgen.GenApplication;
import org.eclipse.gmf.codegen.gmfgen.GenAuditContainer;
import org.eclipse.gmf.codegen.gmfgen.GenAuditContext;
import org.eclipse.gmf.codegen.gmfgen.GenAuditRoot;
import org.eclipse.gmf.codegen.gmfgen.GenAuditRule;
import org.eclipse.gmf.codegen.gmfgen.GenAuditable;
import org.eclipse.gmf.codegen.gmfgen.GenAuditedMetricTarget;
import org.eclipse.gmf.codegen.gmfgen.GenChildContainer;
import org.eclipse.gmf.codegen.gmfgen.GenChildLabelNode;
import org.eclipse.gmf.codegen.gmfgen.GenChildNode;
import org.eclipse.gmf.codegen.gmfgen.GenChildSideAffixedNode;
import org.eclipse.gmf.codegen.gmfgen.GenCommonBase;
import org.eclipse.gmf.codegen.gmfgen.GenCompartment;
import org.eclipse.gmf.codegen.gmfgen.GenConstraint;
import org.eclipse.gmf.codegen.gmfgen.GenContextMenu;
import org.eclipse.gmf.codegen.gmfgen.GenContributionItem;
import org.eclipse.gmf.codegen.gmfgen.GenDiagram;
import org.eclipse.gmf.codegen.gmfgen.GenDiagramElementTarget;
import org.eclipse.gmf.codegen.gmfgen.GenDomainAttributeTarget;
import org.eclipse.gmf.codegen.gmfgen.GenDomainElementTarget;
import org.eclipse.gmf.codegen.gmfgen.GenEditorGenerator;
import org.eclipse.gmf.codegen.gmfgen.GenElementInitializer;
import org.eclipse.gmf.codegen.gmfgen.GenExpressionInterpreter;
import org.eclipse.gmf.codegen.gmfgen.GenExpressionProviderBase;
import org.eclipse.gmf.codegen.gmfgen.GenExpressionProviderContainer;
import org.eclipse.gmf.codegen.gmfgen.GenFeatureInitializer;
import org.eclipse.gmf.codegen.gmfgen.GenFeatureSeqInitializer;
import org.eclipse.gmf.codegen.gmfgen.GenFeatureValueSpec;
import org.eclipse.gmf.codegen.gmfgen.GenGroupMarker;
import org.eclipse.gmf.codegen.gmfgen.GenLanguage;
import org.eclipse.gmf.codegen.gmfgen.GenLink;
import org.eclipse.gmf.codegen.gmfgen.GenLinkConstraints;
import org.eclipse.gmf.codegen.gmfgen.GenLinkLabel;
import org.eclipse.gmf.codegen.gmfgen.GenMeasurable;
import org.eclipse.gmf.codegen.gmfgen.GenMenuManager;
import org.eclipse.gmf.codegen.gmfgen.GenMetricContainer;
import org.eclipse.gmf.codegen.gmfgen.GenMetricRule;
import org.eclipse.gmf.codegen.gmfgen.GenNavigator;
import org.eclipse.gmf.codegen.gmfgen.GenNode;
import org.eclipse.gmf.codegen.gmfgen.GenNodeLabel;
import org.eclipse.gmf.codegen.gmfgen.GenNotationElementTarget;
import org.eclipse.gmf.codegen.gmfgen.GenParserImplementation;
import org.eclipse.gmf.codegen.gmfgen.GenParsers;
import org.eclipse.gmf.codegen.gmfgen.GenPreferencePage;
import org.eclipse.gmf.codegen.gmfgen.GenPropertySheet;
import org.eclipse.gmf.codegen.gmfgen.GenReferenceNewElementSpec;
import org.eclipse.gmf.codegen.gmfgen.GenRuleTarget;
import org.eclipse.gmf.codegen.gmfgen.GenSeparator;
import org.eclipse.gmf.codegen.gmfgen.GenSeverity;
import org.eclipse.gmf.codegen.gmfgen.GenSharedContributionItem;
import org.eclipse.gmf.codegen.gmfgen.GenStandardPreferencePage;
import org.eclipse.gmf.codegen.gmfgen.GenToolBarManager;
import org.eclipse.gmf.codegen.gmfgen.GenTopLevelNode;
import org.eclipse.gmf.codegen.gmfgen.GenVisualEffect;
import org.eclipse.gmf.codegen.gmfgen.LabelModelFacet;
import org.eclipse.gmf.codegen.gmfgen.LabelOffsetAttributes;
import org.eclipse.gmf.codegen.gmfgen.LabelTextAccessMethod;
import org.eclipse.gmf.codegen.gmfgen.LinkLabelAlignment;
import org.eclipse.gmf.codegen.gmfgen.LinkModelFacet;
import org.eclipse.gmf.codegen.gmfgen.MetamodelType;
import org.eclipse.gmf.codegen.gmfgen.OclChoiceParser;
import org.eclipse.gmf.codegen.gmfgen.OpenDiagramBehaviour;
import org.eclipse.gmf.codegen.gmfgen.Palette;
import org.eclipse.gmf.codegen.gmfgen.PredefinedEnumParser;
import org.eclipse.gmf.codegen.gmfgen.PredefinedParser;
import org.eclipse.gmf.codegen.gmfgen.ProviderPriority;
import org.eclipse.gmf.codegen.gmfgen.SpecializationType;
import org.eclipse.gmf.codegen.gmfgen.StandardPreferencePages;
import org.eclipse.gmf.codegen.gmfgen.TypeLinkModelFacet;
import org.eclipse.gmf.codegen.gmfgen.TypeModelFacet;
import org.eclipse.gmf.codegen.gmfgen.ValueExpression;
import org.eclipse.gmf.gmfgraph.Alignment;
import org.eclipse.gmf.gmfgraph.AlignmentFacet;
import org.eclipse.gmf.gmfgraph.ChildAccess;
import org.eclipse.gmf.gmfgraph.Compartment;
import org.eclipse.gmf.gmfgraph.DiagramElement;
import org.eclipse.gmf.gmfgraph.Direction;
import org.eclipse.gmf.gmfgraph.Figure;
import org.eclipse.gmf.gmfgraph.FigureDescriptor;
import org.eclipse.gmf.gmfgraph.FigureRef;
import org.eclipse.gmf.gmfgraph.LabelOffsetFacet;
import org.eclipse.gmf.gmfgraph.Node;
import org.eclipse.gmf.gmfgraph.Pin;
import org.eclipse.gmf.gmfgraph.RealFigure;
import org.eclipse.gmf.gmfgraph.VisualFacet;
import org.eclipse.gmf.internal.bridge.History;
import org.eclipse.gmf.internal.bridge.Knowledge;
import org.eclipse.gmf.internal.bridge.NaiveIdentifierDispenser;
import org.eclipse.gmf.internal.bridge.VisualIdentifierDispenser;
import org.eclipse.gmf.internal.bridge.genmodel.navigator.NavigatorHandler;
import org.eclipse.gmf.internal.bridge.tooldef.PaletteHandler;
import org.eclipse.gmf.internal.codegen.util.Extras;
import org.eclipse.gmf.mappings.AuditContainer;
import org.eclipse.gmf.mappings.AuditRule;
import org.eclipse.gmf.mappings.AuditedMetricTarget;
import org.eclipse.gmf.mappings.CanvasMapping;
import org.eclipse.gmf.mappings.ChildReference;
import org.eclipse.gmf.mappings.CompartmentMapping;
import org.eclipse.gmf.mappings.Constraint;
import org.eclipse.gmf.mappings.DesignLabelMapping;
import org.eclipse.gmf.mappings.DiagramElementTarget;
import org.eclipse.gmf.mappings.DomainAttributeTarget;
import org.eclipse.gmf.mappings.DomainElementTarget;
import org.eclipse.gmf.mappings.ElementInitializer;
import org.eclipse.gmf.mappings.ExpressionLabelMapping;
import org.eclipse.gmf.mappings.FeatureInitializer;
import org.eclipse.gmf.mappings.FeatureLabelMapping;
import org.eclipse.gmf.mappings.FeatureSeqInitializer;
import org.eclipse.gmf.mappings.FeatureValueSpec;
import org.eclipse.gmf.mappings.GMFMapPackage;
import org.eclipse.gmf.mappings.LabelMapping;
import org.eclipse.gmf.mappings.Language;
import org.eclipse.gmf.mappings.LinkConstraints;
import org.eclipse.gmf.mappings.LinkMapping;
import org.eclipse.gmf.mappings.Mapping;
import org.eclipse.gmf.mappings.MappingEntry;
import org.eclipse.gmf.mappings.MetricContainer;
import org.eclipse.gmf.mappings.MetricRule;
import org.eclipse.gmf.mappings.NodeMapping;
import org.eclipse.gmf.mappings.NodeReference;
import org.eclipse.gmf.mappings.NotationElementTarget;
import org.eclipse.gmf.mappings.OclChoiceLabelMapping;
import org.eclipse.gmf.mappings.ReferenceNewElementSpec;
import org.eclipse.gmf.mappings.Severity;
import org.eclipse.gmf.mappings.TopNodeReference;
import org.eclipse.gmf.mappings.VisualEffectMapping;

/**
 * Creates generation model from diagram definition.
 * 
 * @author artem
 */
public class DiagramGenModelTransformer extends MappingTransformer {

	private GenEditorGenerator myGenModel;

	protected GenModelMatcher myGenModelMatch;

	private final DiagramRunTimeModelHelper myDRTHelper;

	private final ViewmapProducer myViewmaps;

	private final VisualIdentifierDispenser myVisualIDs;

	private final boolean rcp;

	private final History myHistory;

	private final Map<GenClass, ElementType> myProcessedTypes = new IdentityHashMap<GenClass, ElementType>(); // GenClass -> MetamodelType

	private final Map<org.eclipse.gmf.mappings.ValueExpression, ValueExpression> myProcessedExpressions;

	private final PaletteHandler myPaletteProcessor;

	private final NavigatorHandler myNavigatorProcessor;

	private final PropertySheetHandler myPropertySheetProcessor;

	private final EcoreGenModelMatcher myEcoreGenModelMatch;

	private ExternalParser myDesignLabelParser;

	private ExternalParser myAuxParser;

	private GenContextMenu myDiagramContextMenu;

	private GenAuditContext myDefaultAuditContext;

	public static class Parameters {

		public final DiagramRunTimeModelHelper diagramModelHelper;

		public final ViewmapProducer viewmaps;

		public final VisualIdentifierDispenser vidDispenser;

		public final boolean rcp;

		public Parameters(DiagramRunTimeModelHelper drtHelper, ViewmapProducer viewmaps, VisualIdentifierDispenser vidDispenser, boolean rcp) {
			diagramModelHelper = drtHelper;
			this.viewmaps = viewmaps;
			this.vidDispenser = vidDispenser;
			this.rcp = rcp;
		}
	}

	public DiagramGenModelTransformer() {
		this(new BasicDiagramRunTimeModelHelper());
	}

	public DiagramGenModelTransformer(DiagramRunTimeModelHelper drtHelper) {
		this(new Parameters(drtHelper, new InnerClassViewmapProducer(), new NaiveIdentifierDispenser(), false));
	}

	public DiagramGenModelTransformer(Parameters opts) {
		this(opts.diagramModelHelper, opts.viewmaps, opts.vidDispenser, opts.rcp);
	}

	private DiagramGenModelTransformer(DiagramRunTimeModelHelper drtHelper, ViewmapProducer viewmaps, VisualIdentifierDispenser visualIdD, boolean rcp) {
		assert drtHelper != null && viewmaps != null;
		myDRTHelper = drtHelper;
		myViewmaps = viewmaps;
		myVisualIDs = visualIdD;
		this.rcp = rcp;
		myHistory = new History();
		myPaletteProcessor = new PaletteHandler();
		myNavigatorProcessor = new NavigatorHandler();
		myPropertySheetProcessor = new PropertySheetHandler();
		myEcoreGenModelMatch = new EcoreGenModelMatcher();
		myProcessedExpressions = new HashMap<org.eclipse.gmf.mappings.ValueExpression, ValueExpression>();
	}

	/**
	 * Optionally set GenModel to match ECore elements against. Should be
	 * invoked prior to {@link MappingTransformer#transform(Mapping)}, otherwise
	 * has no effect. Useful for tests (and other cases) when GenModel is not
	 * known to EMF (and thus can't be obtained using EMF techniques).
	 * 
	 * @param emfGenModel
	 *            EMF GenModel for domain model
	 */
	public void setEMFGenModel(GenModel emfGenModel) {
		myGenModelMatch = new GenModelMatcher(emfGenModel);
	}

	public GenEditorGenerator getResult() {
		return getGenEssence();
	}

	public History getTrace() {
		return myHistory;
	}

	private GenEditorGenerator getGenEssence() {
		if (myGenModel == null) {
			myGenModel = GMFGenFactory.eINSTANCE.createGenEditorGenerator();
		}
		// init editor as well - transformer does not set any property to it, just make sure it's not null
		if (myGenModel.getEditor() == null) {
			myGenModel.setEditor(GMFGenFactory.eINSTANCE.createGenEditorView());
		}
		return myGenModel;
	}

	private GenDiagram getGenDiagram() {
		if (getGenEssence().getDiagram() == null) {
			getGenEssence().setDiagram(GMFGenFactory.eINSTANCE.createGenDiagram());
		}
		return getGenEssence().getDiagram();
	}

	private void initGenPlugin() {
		if (getGenEssence().getPlugin() == null) {
			getGenEssence().setPlugin(GMFGenFactory.eINSTANCE.createGenPlugin());
		}
	}

	private void initGenUpdater() {
		if (getGenEssence().getDiagramUpdater() == null) {
			getGenEssence().setDiagramUpdater(GMFGenFactory.eINSTANCE.createGenDiagramUpdater());
		}

	}

	private GenNavigator genGenNavigator() {
		if (getGenEssence().getNavigator() == null) {
			getGenEssence().setNavigator(GMFGenFactory.eINSTANCE.createGenNavigator());
		}
		return getGenEssence().getNavigator();
	}

	private Palette getGenPalette() {
		Palette p = getGenDiagram().getPalette();
		if (p == null) {
			p = GMFGenFactory.eINSTANCE.createPalette();
			getGenDiagram().setPalette(p);
		}
		return p;
	}

	private GenPropertySheet getPropertySheet() {
		if (getGenEssence().getPropertySheet() == null) {
			getGenEssence().setPropertySheet(GMFGenFactory.eINSTANCE.createGenPropertySheet());
		}
		return getGenEssence().getPropertySheet();
	}

	private GenParsers getGenParsers() {
		// XXX meanwhile, we don't set any attributes to GenParsers (rather delegating to old, deprecated)
		if (getGenEssence().getLabelParsers() == null) {
			getGenEssence().setLabelParsers(GMFGenFactory.eINSTANCE.createGenParsers());
			// unless bug #235113 is fixed, always do ParserService
			getGenEssence().getLabelParsers().setExtensibleViaService(true);
		}
		return getGenEssence().getLabelParsers();
	}

	private GenContextMenu getDiagramContextMenu() {
		if (myDiagramContextMenu == null) {
			myDiagramContextMenu = GMFGenFactory.eINSTANCE.createGenContextMenu();
			myDiagramContextMenu.getContext().add(getGenDiagram());
			getGenEssence().getContextMenus().add(myDiagramContextMenu);
		}
		return myDiagramContextMenu;
	}

	protected void process(CanvasMapping mapping) {
		if (myGenModelMatch == null && mapping.getDomainModel() != null) {
			myGenModelMatch = new GenModelMatcher(mapping.getDomainModel());
		}
		myHistory.purge();
		if (mapping.getPalette() != null) {
			myPaletteProcessor.initialize(getGenPalette());
			myPaletteProcessor.process(mapping.getPalette());
		}
		if (!rcp) {
			myNavigatorProcessor.initialize(getGenDiagram(), genGenNavigator());
		}
		GenPackage primaryPackage = findGenPackage(mapping.getDomainModel());
		getGenEssence().setDomainGenModel(primaryPackage == null ? null : primaryPackage.getGenModel());
		getGenDiagram().setDomainDiagramElement(findGenClass(mapping.getDomainMetaElement()));
		getGenDiagram().setDiagramRunTimeClass(findRunTimeClass(mapping));
		getGenDiagram().setVisualID(myVisualIDs.get(getGenDiagram()));
		getGenDiagram().setViewmap(myViewmaps.create(mapping.getDiagramCanvas()));
		getGenDiagram().setIconProviderPriority(ProviderPriority.LOW_LITERAL); // override ElementTypeIconProvider
		getGenDiagram().setValidationProviderPriority(ProviderPriority.LOW_LITERAL); // otherwise it's not available
		if (getGenDiagram().getDomainDiagramElement() != null) {
			// since diagram is the first entity to process consider it defines metamodel type
			getGenDiagram().setElementType(GMFGenFactory.eINSTANCE.createMetamodelType());
			myProcessedTypes.put(getGenDiagram().getDomainDiagramElement(), getGenDiagram().getElementType());
		} else {
			getGenDiagram().setElementType(GMFGenFactory.eINSTANCE.createNotationType());
		}

		initGenPlugin();
		initGenUpdater();

		myPropertySheetProcessor.initialize(getPropertySheet());
		myPropertySheetProcessor.process(mapping);
		addPreferencePages(getGenDiagram());

		if (rcp) {
			if (getGenEssence().getApplication() == null) {
				GenApplication app = GMFGenFactory.eINSTANCE.createGenApplication();
				addContributions(app);
				getGenEssence().setApplication(app);
			}
		}
		// XXX actually, better do it once whole transformation is complete
		if (getGenDiagram().generateCreateShortcutAction()) {
			getDiagramContextMenu().getItems().add(GMFGenFactory.eINSTANCE.createCreateShortcutAction());
		}
		// XXX ask Vano, if it's reasonable to generate LoadResourceAction only when there are shortcuts?
		getDiagramContextMenu().getItems().add(GMFGenFactory.eINSTANCE.createLoadResourceAction());
	}

	protected void process(TopNodeReference topNode) {
		final NodeMapping nme = topNode.getChild();
		assert nme != null;
		assertNodeMapping(nme);

		GenTopLevelNode genNode = GMFGenFactory.eINSTANCE.createGenTopLevelNode();
		getGenDiagram().getTopLevelNodes().add(genNode);
		genNode.setDiagramRunTimeClass(findRunTimeClass(nme));
		genNode.setModelFacet(createModelFacet(topNode));
		genNode.setVisualID(myVisualIDs.get(genNode));
		genNode.setViewmap(myViewmaps.create(nme.getDiagramNode()));
		setupElementType(genNode);
		myPaletteProcessor.process(nme, genNode);

		processAbstractNode(nme, genNode);
		myHistory.log(nme, genNode);

		if (!rcp) {
			myNavigatorProcessor.process(genNode);
		}
	}

	protected void process(AuditContainer audits) {
		if (audits != null) {
			getGenEssence().setAudits(createGenAuditRoot(audits));
		}
	}

	protected void process(MetricContainer metrics) {
		if (metrics != null) {
			GenMetricContainer genMetricContainer = GMFGenFactory.eINSTANCE.createGenMetricContainer();
			for (MetricRule next : metrics.getMetrics()) {
				genMetricContainer.getMetrics().add(createGenMetric(next));
			}
			getGenEssence().setMetrics(genMetricContainer);
		}
	}

	private void process(ChildReference childNodeRef, GenChildContainer container) {
		final NodeMapping childNodeMapping = childNodeRef.getChild();
		assert childNodeMapping != null;
		assertNodeMapping(childNodeMapping);

		GenChildNode childNode;
		if (!myHistory.isKnownChildNode(childNodeMapping)) {
			childNode = createGenChildNode(childNodeRef);
		} else {
			GenChildNode[] alreadyKnownChildren = myHistory.findChildNodes(childNodeMapping);

			childNode = null;
			for (int i = 0; i < alreadyKnownChildren.length; i++) {
				if (matchChildReferenceFeatures(childNodeRef, alreadyKnownChildren[i])) {
					childNode = alreadyKnownChildren[i];
					break;
				}
			}
			if (childNode == null) { // no match
				childNode = createGenChildNode(childNodeRef);
			}
		}
		if (container instanceof GenCompartment && childNodeMapping.getChildren().size() > 0) {
			// TODO just layout from childNodeMapping.getDiagramNode()
			((GenCompartment) container).setListLayout(false);
		}
		container.getChildNodes().add(childNode);
		if (!rcp) {
			myNavigatorProcessor.process(childNode, container);
		}
	}

	/**
	 * Handle case when second-level ChildReference references existing
	 * nodemapping, but with different containment/children reference.
	 * 
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=129552
	 */
	private static boolean matchChildReferenceFeatures(ChildReference childNodeRef, GenChildNode childNode) {
		final boolean containmentFeatureMatch;
		final boolean childrenFeatureMatch;
		if (childNode.getModelFacet() == null || childNode.getModelFacet().getContainmentMetaFeature() == null) {
			containmentFeatureMatch = (null == childNodeRef.getContainmentFeature());
		} else {
			// seems legal to use '==' because features should came from the same model
			containmentFeatureMatch = childNodeRef.getContainmentFeature() == childNode.getModelFacet().getContainmentMetaFeature().getEcoreFeature();
		}
		if (childNode.getModelFacet() == null || childNode.getModelFacet().getChildMetaFeature() == null) {
			childrenFeatureMatch = (null == childNodeRef.getChildrenFeature());
		} else {
			if (childNodeRef.getChildrenFeature() == null) {
				// likely, childMetaFeature in model facet was derived from containment feature 
				childrenFeatureMatch = childNode.getModelFacet().getChildMetaFeature() == childNode.getModelFacet().getContainmentMetaFeature();
			} else {
				// honest check
				childrenFeatureMatch = childNode.getModelFacet().getChildMetaFeature().getEcoreFeature() == childNodeRef.getChildrenFeature();
			}
		}
		return containmentFeatureMatch && childrenFeatureMatch;
	}

	private GenChildNode createGenChildNode(ChildReference childNodeRef) {
		final NodeMapping childNodeMapping = childNodeRef.getChild();
		final GenChildNode childNode;
		final boolean needCompartmentChildrenLabelProcessing;
		if (Knowledge.isPureLabelNode(childNodeMapping)) {
			LabelMapping soleLabel = childNodeMapping.getLabelMappings().get(0);
			GenChildLabelNode childLabelNode = GMFGenFactory.eINSTANCE.createGenChildLabelNode();
			childLabelNode.setViewmap(myViewmaps.create(soleLabel.getDiagramLabel()));
			childLabelNode.setLabelModelFacet(createLabelModelFacet(soleLabel));
			childLabelNode.setLabelReadOnly(soleLabel.isReadOnly());
			childLabelNode.setLabelElementIcon(soleLabel.getDiagramLabel().isElementIcon());
			childNode = childLabelNode;
			needCompartmentChildrenLabelProcessing = false;
		} else if (childNodeMapping.getDiagramNode().getAffixedParentSide() != Direction.NONE_LITERAL) {
			GenChildSideAffixedNode sideAffixedNode = GMFGenFactory.eINSTANCE.createGenChildSideAffixedNode();
			sideAffixedNode.setViewmap(myViewmaps.create(childNodeMapping.getDiagramNode()));
			String positionConstantName = getAffixedSideAsPositionConstantsName(childNodeMapping.getDiagramNode());
			sideAffixedNode.setPreferredSideName(positionConstantName);
			childNode = sideAffixedNode;
			needCompartmentChildrenLabelProcessing = true;
		} else {
			childNode = GMFGenFactory.eINSTANCE.createGenChildNode();
			childNode.setViewmap(myViewmaps.create(childNodeMapping.getDiagramNode()));
			needCompartmentChildrenLabelProcessing = true;
		}
		myHistory.log(childNodeMapping, childNode);
		getGenDiagram().getChildNodes().add(childNode);

		childNode.setModelFacet(createModelFacet(childNodeRef));

		childNode.setDiagramRunTimeClass(findRunTimeClass(childNodeMapping));
		childNode.setVisualID(myVisualIDs.get(childNode));
		setupElementType(childNode);

		myPaletteProcessor.process(childNodeMapping, childNode);
		if (needCompartmentChildrenLabelProcessing) {
			processAbstractNode(childNodeMapping, childNode);
		}
		return childNode;
	}

	private String getAffixedSideAsPositionConstantsName(Node diagramNode) {
		Direction affixedSide = diagramNode.getAffixedParentSide();
		final String ANY_SIDE = "NONE";
		switch (affixedSide.getValue()) {
		case Direction.NONE:
			throw new IllegalStateException("DiagramNode: " + diagramNode + " is not side-affixed");
		case Direction.EAST:
		case Direction.NORTH:
		case Direction.WEST:
		case Direction.SOUTH:
			return affixedSide.getName();

		case Direction.NSEW:
			return ANY_SIDE;

		default:
			//Runtime does not support this
			return ANY_SIDE;
		}
	}

	private void processAbstractNode(NodeMapping mapping, GenNode genNode) {
		HashMap<CompartmentMapping, GenCompartment> compartments2GenCompartmentsMap = new HashMap<CompartmentMapping, GenCompartment>();
		for (CompartmentMapping compartmentMapping : mapping.getCompartments()) {
			GenCompartment compartmentGen = createGenCompartment(compartmentMapping, genNode);
			compartments2GenCompartmentsMap.put(compartmentMapping, compartmentGen);
		}

		for (ChildReference childNodeRef : mapping.getChildren()) {
			// Currently childNodeMapping should has compartment but we plan to make this reference optional
			CompartmentMapping compartmentMapping = childNodeRef.getCompartment();
			GenChildContainer genChildContainer;
			if (compartmentMapping != null && compartments2GenCompartmentsMap.containsKey(compartmentMapping)) {
				genChildContainer = compartments2GenCompartmentsMap.get(compartmentMapping);
			} else {
				genChildContainer = genNode;
			}
			process(childNodeRef, genChildContainer);
		}
		for (LabelMapping labelMapping : mapping.getLabelMappings()) {
			createNodeLabel(genNode, labelMapping);
		}
		for (CanvasMapping nextRelatedCanvas : mapping.getRelatedDiagrams()) {
			OpenDiagramBehaviour openDiagramPolicy = GMFGenFactory.eINSTANCE.createOpenDiagramBehaviour();
			// ugly check that nodeMapping is related to owning canvasMapping, iow mapping.getCanvasMapping() == nextRelatedCanvas
			if (nextRelatedCanvas.eResource() != mapping.eResource()) {
				// unless we would like to ask user where to take appropriate .gmfgen...
				openDiagramPolicy.setDiagramKind("FIXME put GenEditorGenerator.modelID value here");
				openDiagramPolicy.setEditorID("FIXME put GenEditorView.id value here");
			}
			genNode.getBehaviour().add(openDiagramPolicy);
		}

		createVisualEffects(mapping, genNode, mapping.getDiagramNode());
	}

	private void createVisualEffects(MappingEntry mapping, GenCommonBase genCommon, DiagramElement diagramElement) {
		for (VisualEffectMapping visualEffectMapping : mapping.getVisualEffects()) {
			createVisualEffect(genCommon, visualEffectMapping, diagramElement);
		}
	}

	private GenCompartment createGenCompartment(CompartmentMapping mapping, GenNode genNode) {
		Compartment compartment = mapping.getCompartment();
		assert compartment != null;
		GenCompartment childCompartment = GMFGenFactory.eINSTANCE.createGenCompartment();
		getGenDiagram().getCompartments().add(childCompartment);
		genNode.getCompartments().add(childCompartment);
		childCompartment.setVisualID(myVisualIDs.get(childCompartment));
		childCompartment.setDiagramRunTimeClass(getChildContainerRunTimeClass());
		childCompartment.setViewmap(myViewmaps.create(mapping.getCompartment()));
		childCompartment.setCanCollapse(compartment.isCollapsible());
		childCompartment.setNeedsTitle(compartment.isNeedsTitle());
		childCompartment.setTitle(compartment.getName());

		return childCompartment;
	}

	protected void process(LinkMapping lme) {
		assertLinkMapping(lme);
		GenLink gl = GMFGenFactory.eINSTANCE.createGenLink();
		getGenDiagram().getLinks().add(gl);
		gl.setModelFacet(createModelFacet(lme));
		gl.setVisualID(myVisualIDs.get(gl));
		myPaletteProcessor.process(lme, gl);
		for (LabelMapping labelMapping : lme.getLabelMappings()) {
			createLinkLabel(gl, labelMapping);
		}
		gl.setDiagramRunTimeClass(findRunTimeClass(lme));

		setupElementType(gl);

		gl.setViewmap(myViewmaps.create(lme.getDiagramLink()));

		if (lme.getCreationConstraints() != null) {
			gl.setCreationConstraints(createLinkCreationConstraints(lme.getCreationConstraints()));
		}

		myHistory.log(lme, gl);
		if (!rcp) {
			myNavigatorProcessor.process(gl);
		}

		createVisualEffects(lme, gl, lme.getDiagramLink());
	}

	@Override
	protected void complete() {
		List<String> requiredPlugins = getGenEssence().getPlugin().getRequiredPlugins();
		final String GMF_TOOLING_RUNTIME = "org.eclipse.gmf.tooling.runtime"; //$NON-NLS-1$
		requiredPlugins.add(GMF_TOOLING_RUNTIME);
		requiredPlugins.addAll(Arrays.asList(myViewmaps.dependencies()));
	}

	//	private void process(AppearanceSteward appSteward) {
	//		if (appSteward.getAppearanceStyle() == null) {
	//			return;
	//		}
	//		
	//	}

	private GenNodeLabel createNodeLabel(GenNode node, LabelMapping mapping) {
		GenNodeLabel label;
		if (mapping.getDiagramLabel().isExternal()) {
			label = GMFGenFactory.eINSTANCE.createGenExternalNodeLabel();
		} else {
			label = GMFGenFactory.eINSTANCE.createGenNodeLabel();
		}
		node.getLabels().add(label);
		label.setVisualID(myVisualIDs.get(label));
		label.setDiagramRunTimeClass(findRunTimeClass(mapping));
		label.setViewmap(myViewmaps.create(mapping.getDiagramLabel()));
		label.setModelFacet(createLabelModelFacet(mapping));
		label.setReadOnly(mapping.isReadOnly());
		label.setElementIcon(mapping.getDiagramLabel().isElementIcon());
		return label;
	}

	private void createVisualEffect(GenCommonBase parent, VisualEffectMapping mapping, DiagramElement parentDiagramElement) {
		GenVisualEffect visualEffect = GMFGenFactory.eINSTANCE.createGenVisualEffect();
		parent.getBehaviour().add(visualEffect);

		Pin graphPin = mapping.getDiagramPin();

		String name = graphPin.getName();

		visualEffect.setName(name);
		visualEffect.setPinKind(graphPin.eClass().getName());

		String operationName = graphPin.getOperationName();

		FigureDescriptor graphFigureDescriptor = parentDiagramElement.getFigure();

		if (!hasFigurePin(graphFigureDescriptor.getActualFigure(), graphPin)) {
			for (ChildAccess graphChildAccess : graphFigureDescriptor.getAccessors()) {
				if (hasFigurePin(graphChildAccess.getFigure(), graphPin)) {
					operationName = graphChildAccess.getAccessor() + "()." + operationName;
					break;
				}
			}
		}

		visualEffect.setOperationName(operationName);
		visualEffect.setOperationType(graphPin.getOperationType());
		visualEffect.setOclExpression(mapping.getOclExpression());

		String editPolicyQualifiedClassName = parent.getDiagram().getEditPoliciesPackageName() + '.'//
				+ CodeGenUtil.capName(CodeGenUtil.validJavaIdentifier(name)) + parent.getVisualID() //
				+ "Policy";

		visualEffect.setEditPolicyQualifiedClassName(editPolicyQualifiedClassName);
		visualEffect.setKey(editPolicyQualifiedClassName + ".KEY");
	}

	private boolean hasFigurePin(Figure figure, Pin pin) {
		RealFigure realFigure = (figure instanceof FigureRef) //
		? ((FigureRef) figure).getFigure() //
				: (RealFigure) figure;
		return realFigure.getPins().contains(pin);
	}

	private GenLinkLabel createLinkLabel(GenLink link, LabelMapping mapping) {
		GenLinkLabel label = GMFGenFactory.eINSTANCE.createGenLinkLabel();
		link.getLabels().add(label);
		label.setVisualID(myVisualIDs.get(label));
		label.setDiagramRunTimeClass(findRunTimeClass(mapping));
		label.setViewmap(myViewmaps.create(mapping.getDiagramLabel()));
		label.setModelFacet(createLabelModelFacet(mapping));
		label.setReadOnly(mapping.isReadOnly());
		label.setElementIcon(mapping.getDiagramLabel().isElementIcon());
		if (findVF(mapping.getDiagramLabel(), AlignmentFacet.class) != null) {
			AlignmentFacet af = findVF(mapping.getDiagramLabel(), AlignmentFacet.class);
			label.setAlignment(getLinkLabelAlignment(af.getAlignment()));
		}
		LabelOffsetAttributes loa = GMFGenFactory.eINSTANCE.createLabelOffsetAttributes();
		LabelOffsetFacet lof = findVF(mapping.getDiagramLabel(), LabelOffsetFacet.class);
		if (lof != null) {
			loa.setX(lof.getX());
			loa.setY(lof.getY());
		} else {
			// stack labels under link by default
			int weight = link.getLabels().size() + 1;
			loa.setY(weight * 20);
		}
		label.getViewmap().getAttributes().add(loa);
		return label;
	}

	private static <T extends VisualFacet> T findVF(DiagramElement element, Class<T> facetClass) {
		for (VisualFacet vf : element.getFacets()) {
			if (facetClass.isInstance(vf)) {
				return facetClass.cast(vf);
			}
		}
		return null;
	}

	private LinkLabelAlignment getLinkLabelAlignment(Alignment alignment) {
		switch (alignment.getValue()) {
		case Alignment.BEGINNING:
			return LinkLabelAlignment.SOURCE_LITERAL;
		case Alignment.CENTER:
			return LinkLabelAlignment.MIDDLE_LITERAL;
		case Alignment.END:
			return LinkLabelAlignment.TARGET_LITERAL;
		default:
			throw new IllegalArgumentException("Link doesn't support alignment:" + alignment.getName());
		}
	}

	private LabelModelFacet createLabelModelFacet(LabelMapping mapping) {
		if (mapping instanceof FeatureLabelMapping) {
			FeatureLabelMapping flMapping = (FeatureLabelMapping) mapping;
			FeatureLabelModelFacet modelFacet = GMFGenFactory.eINSTANCE.createFeatureLabelModelFacet();
			for (EAttribute attr : flMapping.getFeatures()) {
				modelFacet.getMetaFeatures().add(findGenFeature(attr));
			}
			for (EAttribute attr : flMapping.getEditableFeatures()) {
				modelFacet.getEditableMetaFeatures().add(findGenFeature(attr));
			}
			modelFacet.setViewPattern(flMapping.getViewPattern());
			modelFacet.setEditorPattern(flMapping.getEditorPattern());
			modelFacet.setEditPattern(flMapping.getEditPattern());
			if (flMapping.eIsSet(GMFMapPackage.eINSTANCE.getFeatureLabelMapping_ViewMethod())) {
				modelFacet.setViewMethod(LabelTextAccessMethod.get(flMapping.getViewMethod().getValue()));
			}
			if (flMapping.eIsSet(GMFMapPackage.eINSTANCE.getFeatureLabelMapping_EditMethod())) {
				modelFacet.setEditMethod(LabelTextAccessMethod.get(flMapping.getEditMethod().getValue()));
			}
			// XXX temp code
			modelFacet.setParser(getOrCreateParser(flMapping));
			// XXX
			return modelFacet;
		}
		if (mapping instanceof OclChoiceLabelMapping) {
			OclChoiceLabelMapping oclMapping = (OclChoiceLabelMapping) mapping;
			FeatureLabelModelFacet modelFacet = GMFGenFactory.eINSTANCE.createFeatureLabelModelFacet();
			GenFeature feature = findGenFeature(oclMapping.getFeature());
			modelFacet.getMetaFeatures().add(feature);
			modelFacet.getEditableMetaFeatures().add(feature);
			modelFacet.setParser(createOclChoiceParser(oclMapping));
			return modelFacet;
		}
		if (mapping instanceof DesignLabelMapping) {
			DesignLabelModelFacet modelFacet = GMFGenFactory.eINSTANCE.createDesignLabelModelFacet();
			modelFacet.setParser(getOrCreateParser((DesignLabelMapping) mapping));
			return modelFacet;
		}
		if (mapping instanceof ExpressionLabelMapping) {
			ExpressionLabelModelFacet modelFacet = GMFGenFactory.eINSTANCE.createExpressionLabelModelFacet();
			ExpressionLabelParser parser = GMFGenFactory.eINSTANCE.createExpressionLabelParser();
			ExpressionLabelMapping elm = (ExpressionLabelMapping) mapping;
			parser.setExpressionContext(findGenClass(elm.getMapEntry().getDomainContext()));
			if (elm.getViewExpression() != null) {
				parser.setViewExpression(createValueExpression(elm.getViewExpression()));
			}
			if (elm.getEditExpression() != null) {
				parser.setEditExpression(createValueExpression(elm.getEditExpression()));
			}
			if (elm.getValidateExpression() != null) {
				parser.setValidateExpression(createGenConstraint(elm.getValidateExpression()));
			}
			modelFacet.setParser(parser);
			getGenParsers().getImplementations().add(parser);
			return modelFacet;
		}
		// create bare instance that points to a ExternalParser
		// this is modification of old contract (though, not breaking change, I believe)
		// that says null modelFacet means use of external parser
		LabelModelFacet modelFacet = GMFGenFactory.eINSTANCE.createLabelModelFacet();
		modelFacet.setParser(getOrCreateParser(mapping));
		return modelFacet;
	}

	private void setupElementType(GenNode genNode) {
		if (genNode.getModelFacet() != null) {
			MetamodelType metamodelType = (MetamodelType) myProcessedTypes.get(genNode.getModelFacet().getMetaClass());
			if (metamodelType == null) {
				// this is the first metaclass encounter; consider metamodel type definition
				genNode.setElementType(GMFGenFactory.eINSTANCE.createMetamodelType());
				myProcessedTypes.put(genNode.getModelFacet().getMetaClass(), genNode.getElementType());
			} else {
				// all subsequent encounters lead to specialization definitions
				SpecializationType specializationType = GMFGenFactory.eINSTANCE.createSpecializationType();
				specializationType.setMetamodelType(metamodelType);
				genNode.setElementType(specializationType);
			}
		} else {
			genNode.setElementType(GMFGenFactory.eINSTANCE.createNotationType());
		}
	}

	private void setupElementType(GenLink gl) {
		if (gl.getModelFacet() != null) {
			if (gl.getModelFacet() instanceof TypeModelFacet) {
				GenClass metaClass = ((TypeModelFacet) gl.getModelFacet()).getMetaClass();
				MetamodelType metamodelType = (MetamodelType) myProcessedTypes.get(metaClass);
				if (metamodelType == null) {
					// this is the first metaclass encounter; consider metamodel type definition
					gl.setElementType(GMFGenFactory.eINSTANCE.createMetamodelType());
					myProcessedTypes.put(metaClass, gl.getElementType());
				} else {
					// all subsequent encounters lead to specialization definitions
					SpecializationType specializationType = GMFGenFactory.eINSTANCE.createSpecializationType();
					specializationType.setMetamodelType(metamodelType);
					gl.setElementType(specializationType);
				}
			} else {
				// ref-based link; specialize null
				SpecializationType specializationType = GMFGenFactory.eINSTANCE.createSpecializationType();
				gl.setElementType(specializationType);
			}
		} else {
			gl.setElementType(GMFGenFactory.eINSTANCE.createNotationType());
		}
	}

	private GenClass findRunTimeClass(NodeMapping nme) {
		return myDRTHelper.get(nme);
	}

	private GenClass findRunTimeClass(LinkMapping lme) {
		return myDRTHelper.get(lme);
	}

	private GenClass findRunTimeClass(CanvasMapping mapping) {
		return myDRTHelper.get(mapping);
	}

	private GenClass getChildContainerRunTimeClass() {
		return myDRTHelper.getChildContainerDefault();
	}

	private GenClass findRunTimeClass(LabelMapping mapping) {
		return myDRTHelper.get(mapping);
	}

	private void assertNodeMapping(NodeMapping mapping) {
		assert mapping.getDiagramNode() != null;
		assert checkLabelMappings(mapping);
	}

	private void assertLinkMapping(LinkMapping linkMapping) {
		assert linkMapping.getDiagramLink() != null;
		if (linkMapping.getDomainMetaElement() != null) {
			assert linkMapping.getLinkMetaFeature() != null;
		}
		assert checkLabelMappings(linkMapping);
	}

	private static boolean checkLabelMappings(MappingEntry entry) {
		for (LabelMapping labelMapping : (Collection<? extends LabelMapping>) entry.getLabelMappings()) {
			if (labelMapping instanceof FeatureLabelMapping) {
				final EClass domainElement = labelMapping.getMapEntry().getDomainContext();
				for (EAttribute attr : (Collection<? extends EAttribute>) ((FeatureLabelMapping) labelMapping).getFeatures()) {
					if (!Extras.isSuperTypeOf(attr.getEContainingClass(), domainElement)) {
						return false;
					}
				}
			}
		}
		return true;
	}

	private GenPackage findGenPackage(EPackage ePackage) {
		if (myGenModelMatch == null) {
			warnNoGenModelMatcher(ePackage);
			return null;
		}
		return myGenModelMatch.findGenPackage(ePackage);
	}

	private GenClass findGenClass(EClass eClass) {
		if (myGenModelMatch == null) {
			warnNoGenModelMatcher(eClass);
			return null;
		}
		return myGenModelMatch.findGenClass(eClass);
	}

	private GenFeature findGenFeature(EStructuralFeature feature) {
		if (myGenModelMatch == null) {
			warnNoGenModelMatcher(feature);
			return null;
		}
		return myGenModelMatch.findGenFeature(feature);
	}

	private void warnNoGenModelMatcher(EModelElement element) {
		// TODO : emit warning
	}

	private TypeModelFacet createModelFacet(NodeReference anm) {
		final NodeMapping nodeMapping = anm.getChild();
		if (nodeMapping.getDomainContext() == null) {
			return null;
		}
		TypeModelFacet typeModelFacet = setupModelFacet(nodeMapping.getDomainContext(), anm.getContainmentFeature(), anm.getChildrenFeature());
		return setupAux(typeModelFacet, nodeMapping.getDomainSpecialization(), nodeMapping.getDomainInitializer());
	}

	private LinkModelFacet createModelFacet(LinkMapping lme) {
		if (lme.getDomainMetaElement() != null) {
			TypeLinkModelFacet mf = GMFGenFactory.eINSTANCE.createTypeLinkModelFacet();
			mf.setMetaClass(findGenClass(lme.getDomainMetaElement()));
			mf.setContainmentMetaFeature(findGenFeature(lme.getContainmentFeature()));
			mf.setChildMetaFeature(mf.getContainmentMetaFeature());
			mf.setSourceMetaFeature(findGenFeature(lme.getSourceMetaFeature()));
			mf.setTargetMetaFeature(findGenFeature(lme.getLinkMetaFeature()));
			setupAux(mf, lme.getDomainSpecialization(), lme.getDomainInitializer());
			return mf;
		} else if (lme.getLinkMetaFeature() != null) {
			FeatureLinkModelFacet mf = GMFGenFactory.eINSTANCE.createFeatureLinkModelFacet();
			mf.setMetaFeature(findGenFeature(lme.getLinkMetaFeature()));
			return mf;
		}
		return null; // notation link
	}

	private GenLinkConstraints createLinkCreationConstraints(LinkConstraints constraints) {
		LinkMapping lme = constraints.getLinkMapping();
		if (lme == null) {
			return null;
		}
		GenLinkConstraints genConstraints = GMFGenFactory.eINSTANCE.createGenLinkConstraints();
		Constraint sourceConstraint = constraints.getSourceEnd();
		if (sourceConstraint != null) {
			genConstraints.setSourceEnd(createGenConstraint(sourceConstraint));
		}
		Constraint targetConstraint = constraints.getTargetEnd();
		if (targetConstraint != null) {
			genConstraints.setTargetEnd(createGenConstraint(targetConstraint));
		}
		return genConstraints;
	}

	private TypeModelFacet setupModelFacet(EClass domainMetaElement, EStructuralFeature containmentFeature, EStructuralFeature childFeature) {
		TypeModelFacet mf = GMFGenFactory.eINSTANCE.createTypeModelFacet();
		mf.setMetaClass(findGenClass(domainMetaElement));
		mf.setContainmentMetaFeature(findGenFeature(containmentFeature));
		mf.setChildMetaFeature(childFeature == null ? mf.getContainmentMetaFeature() : findGenFeature(childFeature));
		return mf;
	}

	/**
	 * @return typeModelFacet argument for convenience
	 */
	private TypeModelFacet setupAux(TypeModelFacet typeModelFacet, Constraint spec, ElementInitializer init) {
		// construct model element selector for domain EClass specializations if any exist
		if (spec != null) {
			typeModelFacet.setModelElementSelector(createGenConstraint(spec));
		}
		if (init != null) {
			typeModelFacet.setModelElementInitializer(createElementInitializer(init));
		}
		return typeModelFacet;
	}

	private GenElementInitializer createElementInitializer(ElementInitializer elementInitializer) {
		if (elementInitializer instanceof FeatureSeqInitializer) {
			FeatureSeqInitializer fsInitializer = (FeatureSeqInitializer) elementInitializer;
			GenFeatureSeqInitializer genFsInitializer = GMFGenFactory.eINSTANCE.createGenFeatureSeqInitializer();
			for (FeatureInitializer next : fsInitializer.getInitializers()) {
				genFsInitializer.getInitializers().add(createGenFeatureInitializer(next));
			}
			if (fsInitializer.eIsSet(GMFMapPackage.eINSTANCE.getFeatureSeqInitializer_ElementClass())) {
				genFsInitializer.setElementClass(findGenClass(fsInitializer.getElementClass()));
			}
			return genFsInitializer;
		}
		return null;
	}

	private GenFeatureInitializer createGenFeatureInitializer(FeatureInitializer featureInitializer) {
		if (featureInitializer instanceof FeatureValueSpec) {
			FeatureValueSpec featureValSpec = (FeatureValueSpec) featureInitializer;
			GenFeatureValueSpec genFeatureValSpec = GMFGenFactory.eINSTANCE.createGenFeatureValueSpec();
			genFeatureValSpec.setFeature(findGenFeature(featureValSpec.getFeature()));
			genFeatureValSpec.setValue(createValueExpression(featureValSpec.getValue()));

			return genFeatureValSpec;
		} else if (featureInitializer instanceof ReferenceNewElementSpec) {
			ReferenceNewElementSpec newElementSpec = (ReferenceNewElementSpec) featureInitializer;
			GenReferenceNewElementSpec genNewElementSpec = GMFGenFactory.eINSTANCE.createGenReferenceNewElementSpec();
			genNewElementSpec.setFeature(findGenFeature(newElementSpec.getFeature()));
			for (FeatureSeqInitializer next : newElementSpec.getNewElementInitializers()) {
				GenFeatureSeqInitializer nextGenFeatureSeqInitializer = (GenFeatureSeqInitializer) createElementInitializer(next);
				genNewElementSpec.getNewElementInitializers().add(nextGenFeatureSeqInitializer);
			}
			return genNewElementSpec;
		}
		assert false : "Unrecognized FeatureInitializer type"; //$NON-NLS-1$
		return null;
	}

	private static GenLanguage detectGenLanguage(Language mapLang) {
		switch (mapLang.getValue()) {
		case Language.OCL:
			return GenLanguage.OCL_LITERAL;
		case Language.JAVA:
			return GenLanguage.JAVA_LITERAL;
		case Language.REGEXP:
			return GenLanguage.REGEXP_LITERAL;
		case Language.NREGEXP:
			return GenLanguage.NREGEXP_LITERAL;
		case Language.LITERAL:
			return GenLanguage.LITERAL_LITERAL;
		default:
			assert false : mapLang;
		}
		return GenLanguage.OCL_LITERAL;
	}

	// may return GenConstraint, based on original expression type
	// XXX perhaps, combining #createValueExpression and #createGenConstraint into a single method makes sense?
	private ValueExpression createValueExpression(org.eclipse.gmf.mappings.ValueExpression valueExpression) {
		if (valueExpression instanceof Constraint) {
			return createGenConstraint((Constraint) valueExpression);
		}
		ValueExpression result = GMFGenFactory.eINSTANCE.createValueExpression();
		result.setBody(valueExpression.getBody());
		return bindToProvider(valueExpression, result);
	}

	private GenConstraint createGenConstraint(Constraint constraint) {
		if (constraint.getBody() == null) {
			return null;
		}
		GenConstraint genConstraint = GMFGenFactory.eINSTANCE.createGenConstraint();
		genConstraint.setBody(constraint.getBody());
		return bindToProvider(constraint, genConstraint);
	}

	private GenAuditRoot createGenAuditRoot(AuditContainer ac) {
		GenAuditRoot root = GMFGenFactory.eINSTANCE.createGenAuditRoot();
		LinkedList<AuditContainer> containers = new LinkedList<AuditContainer>();
		containers.add(ac);
		// parent container to it's path
		final HashMap<AuditContainer, LinkedList<GenAuditContainer>> pathMap = new HashMap<AuditContainer, LinkedList<GenAuditContainer>>();
		do {
			AuditContainer nextChild = containers.removeFirst();
			GenAuditContainer gac = GMFGenFactory.eINSTANCE.createGenAuditContainer();
			gac.setId(nextChild.getId());
			gac.setName(nextChild.getName());
			gac.setDescription(nextChild.getDescription());
			// FIXME setPath
			if (pathMap.containsKey(nextChild.getParentContainer())) {
				gac.getPath().addAll(pathMap.get(nextChild.getParentContainer()));
			}
			gac.getPath().add(gac);
			// collect next level
			if (nextChild.getChildContainers().size() > 0) {
				containers.addAll(nextChild.getChildContainers());
				pathMap.put(nextChild, new LinkedList<GenAuditContainer>(gac.getPath()));
			}
			root.getCategories().add(gac);
			for (AuditRule next : nextChild.getAudits()) {
				final GenAuditRule auditRule = createGenAudit(next);
				auditRule.setCategory(gac);
				root.getRules().add(auditRule);
				// Here's the logic used to be in GMFGen. Basically, all rules with targets != null
				// get a context (emf.validation), which is a scope or set of elements audit is evaluated against.
				// For certain cases, e.g. diagram elements as audit targets, special logic to select these
				// elements should get generated - to filter diagram views by visualID, and hence
				// there's another implementation of IClientSelector and dedicated context.
				if (auditRule.getTarget() instanceof GenDiagramElementTarget) {
					GenDiagramElementTarget gdet = (GenDiagramElementTarget) auditRule.getTarget();
					// Next used to live in GenDiagramElementTargetImpl#getClientContextID()
					//
					// Present approach relies on id matching not to create duplicating contexts,
					// however, smarter way is to match context's target and its elements.
					StringBuilder buf = new StringBuilder("Ctx"); //$NON-NLS-1$
					for (GenCommonBase nextElement : gdet.getElement()) {
						buf.append('_');
						int id = nextElement.getVisualID();
						if (id < 0) {
							buf.append('n');
						}
						buf.append(id);
					}
					String clientContextID = buf.toString();
					GenAuditContext ctx = null;
					for (GenAuditContext x : root.getClientContexts()) {
						if (clientContextID.equals(x.getId())) {
							ctx = x;
							break;
						}
					}
					if (ctx == null) {
						ctx = GMFGenFactory.eINSTANCE.createGenAuditContext();
						ctx.setId(clientContextID);
						root.getClientContexts().add(ctx);
					}
					gdet.setContextSelector(ctx);
				} else if (auditRule.getTarget() != null) {
					if (myDefaultAuditContext == null) {
						myDefaultAuditContext = GMFGenFactory.eINSTANCE.createGenAuditContext();
						root.getClientContexts().add(myDefaultAuditContext);
					}
					auditRule.getTarget().setContextSelector(myDefaultAuditContext);
				}
			}
		} while (!containers.isEmpty());
		return root;
	}

	private GenAuditRule createGenAudit(AuditRule audit) {
		GenAuditRule genAudit = GMFGenFactory.eINSTANCE.createGenAuditRule();
		genAudit.setId(audit.getId());
		genAudit.setName(audit.getName());
		genAudit.setMessage(audit.getMessage());
		genAudit.setDescription(audit.getDescription());
		genAudit.setUseInLiveMode(audit.isUseInLiveMode());

		if (audit.getTarget() != null) {
			GenRuleTarget genTarget = createRuleTarget(audit.getTarget());
			assert genTarget instanceof GenAuditable;
			if (genTarget instanceof GenAuditable) {
				genAudit.setTarget((GenAuditable) genTarget);
			}
		}
		Constraint rule = audit.getRule();
		if (rule != null) {
			genAudit.setRule(createGenConstraint(rule));
		}

		Severity severity = audit.getSeverity();
		GenSeverity genSeverity = null;
		if (severity == Severity.INFO_LITERAL) {
			genSeverity = GenSeverity.INFO_LITERAL;
		} else if (severity == Severity.WARNING_LITERAL) {
			genSeverity = GenSeverity.WARNING_LITERAL;
		} else if (severity == Severity.ERROR_LITERAL) {
			genSeverity = GenSeverity.ERROR_LITERAL;
		}
		if (genSeverity != null) {
			genAudit.setSeverity(genSeverity);
		}
		return genAudit;
	}

	private GenRuleTarget createRuleTarget(EObject ruleTarget) {
		if (ruleTarget instanceof DomainElementTarget) {
			DomainElementTarget domainTarget = (DomainElementTarget) ruleTarget;
			GenDomainElementTarget genDomainTarget = GMFGenFactory.eINSTANCE.createGenDomainElementTarget();
			genDomainTarget.setElement(domainTarget.getElement() != null ? findGenClass(domainTarget.getElement()) : null);
			return genDomainTarget;
		} else if (ruleTarget instanceof NotationElementTarget) {
			NotationElementTarget notationTarget = (NotationElementTarget) ruleTarget;
			GenNotationElementTarget genNotationTarget = GMFGenFactory.eINSTANCE.createGenNotationElementTarget();
			// XXX findGenClass gives GenClass from domain model, is that what's expected here (NotationTarget)?
			genNotationTarget.setElement(notationTarget.getElement() != null ? findGenClass(notationTarget.getElement()) : null);
			return genNotationTarget;

		} else if (ruleTarget instanceof DiagramElementTarget) {
			GenDiagramElementTarget diagramTarget = GMFGenFactory.eINSTANCE.createGenDiagramElementTarget();
			MappingEntry mappingEntry = ((DiagramElementTarget) ruleTarget).getElement();
			if (mappingEntry != null) {
				LinkMapping lm = mappingEntry instanceof LinkMapping ? (LinkMapping) mappingEntry : null;
				GenCommonBase genBase = null;
				if (lm != null) {
					genBase = myHistory.find(lm);
					assert genBase != null;
					boolean isGenBaseNull = genBase == null;
					if (!isGenBaseNull) {
						diagramTarget.getElement().add(genBase);
					}
				} else {
					NodeMapping nm = mappingEntry instanceof NodeMapping ? (NodeMapping) mappingEntry : null;
					// There may be few GenChildNodes corresponding to same mapping entry.					
					// @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=136701					
					genBase = myHistory.findTopNode(nm);
					if (genBase != null) {
						diagramTarget.getElement().add(genBase);
					}
					diagramTarget.getElement().addAll(Arrays.asList(myHistory.findChildNodes(nm)));
				}
			}
			return diagramTarget;
		} else if (ruleTarget instanceof AuditedMetricTarget) {
			GenAuditedMetricTarget genMetricTarget = GMFGenFactory.eINSTANCE.createGenAuditedMetricTarget();
			AuditedMetricTarget metricTarget = (AuditedMetricTarget) ruleTarget;
			if (metricTarget.getMetric() != null) {
				genMetricTarget.setMetric(myHistory.find(metricTarget.getMetric()));
			}
			GenClassifier resultClassifier = myEcoreGenModelMatch.findGenClassifier(EcorePackage.eINSTANCE.getEDoubleObject());
			assert resultClassifier instanceof GenDataType;
			if (resultClassifier instanceof GenDataType) {
				genMetricTarget.setMetricValueContext((GenDataType) resultClassifier);
			}
			return genMetricTarget;
		} else if (ruleTarget instanceof DomainAttributeTarget) {
			DomainAttributeTarget attrTarget = (DomainAttributeTarget) ruleTarget;
			GenDomainAttributeTarget genAttrTarget = GMFGenFactory.eINSTANCE.createGenDomainAttributeTarget();
			if (attrTarget.getAttribute() != null) {
				genAttrTarget.setAttribute(findGenFeature(attrTarget.getAttribute()));
			}
			genAttrTarget.setNullAsError(attrTarget.isNullAsError());
			return genAttrTarget;
		} else {
			assert false : "Unknown rule target type"; //$NON-NLS-1$
		}
		return null;
	}

	private GenMetricRule createGenMetric(MetricRule metric) {
		GenMetricRule genMetric = GMFGenFactory.eINSTANCE.createGenMetricRule();
		genMetric.setKey(metric.getKey());
		genMetric.setName(metric.getName());
		genMetric.setDescription(metric.getDescription());
		genMetric.setLowLimit(metric.getLowLimit());
		genMetric.setHighLimit(metric.getHighLimit());

		if (metric.getRule() != null) {
			genMetric.setRule(createValueExpression(metric.getRule()));
		}

		if (metric.getTarget() != null) {
			GenRuleTarget genTarget = createRuleTarget(metric.getTarget());
			assert genTarget instanceof GenMeasurable;
			if (genTarget instanceof GenMeasurable) {
				genMetric.setTarget((GenMeasurable) genTarget);
			}
		}
		myHistory.log(metric, genMetric);
		return genMetric;
	}

	/**
	 * ValueExpressions may be reused, as such clients should treat second
	 * argument as template and record return value as actual expression.
	 * 
	 * FIXME when ValueExpression in Java language and non-empty body, create
	 * JavaProvider with injectBody set to true. Also respect this condition in
	 * search for existing provider
	 * 
	 * @return actual gmfgen::ValueExpression to reference
	 */
	private <T extends ValueExpression> T bindToProvider(org.eclipse.gmf.mappings.ValueExpression expression, T genExpression) {
		if (myProcessedExpressions.containsKey(expression)) {
			// Note: may have already been bound during transformation of reused node mapping
			@SuppressWarnings("unchecked")
			T reuse = (T) myProcessedExpressions.get(expression);
			return reuse;
		}
		GenLanguage language = detectGenLanguage(expression.getLanguage());
		if (language == null) {
			return genExpression;
		}
		GenExpressionProviderContainer providerContainer = getGenEssence().getExpressionProviders();
		if (providerContainer == null) {
			providerContainer = GMFGenFactory.eINSTANCE.createGenExpressionProviderContainer();
			getGenEssence().setExpressionProviders(providerContainer);
		}
		GenExpressionProviderBase provider = null;
		for (GenExpressionProviderBase nextProvider : providerContainer.getProviders()) {
			if (language.equals(nextProvider.getLanguage())) {
				provider = nextProvider;
				break;
			}
		}
		if (provider == null) {
			provider = createExpressionProvider(language);
			providerContainer.getProviders().add(provider);
		}
		provider.getExpressions().add(genExpression);
		myProcessedExpressions.put(expression, genExpression);
		return genExpression;
	}

	private GenExpressionProviderBase createExpressionProvider(GenLanguage language) {
		switch (language.getValue()) {
		case GenLanguage.JAVA:
			return GMFGenFactory.eINSTANCE.createGenJavaExpressionProvider();
		case GenLanguage.OCL:
		case GenLanguage.REGEXP:
		case GenLanguage.NREGEXP: {
			GenExpressionInterpreter regexpProvider = GMFGenFactory.eINSTANCE.createGenExpressionInterpreter();
			regexpProvider.setLanguage(language);
			return regexpProvider;
		}
		case GenLanguage.LITERAL:
			return GMFGenFactory.eINSTANCE.createGenLiteralExpressionProvider();
		default: {
			assert false : language;
			return GMFGenFactory.eINSTANCE.createGenExpressionInterpreter();
			// fake provider with no language set to fail validation (XXX perhaps, makes sense to add 'unrecognized' language?)
		}
		}
	}

	private void addPreferencePages(GenDiagram diagram) {
		GenPreferencePage general = createStandardPreferencePage(diagram, "general", diagram.getEditorGen().getModelID() + " Diagram", StandardPreferencePages.GENERAL_LITERAL);
		diagram.getPreferencePages().add(general);
		general.getChildren().add(createStandardPreferencePage(diagram, "appearance", "Appearance", StandardPreferencePages.APPEARANCE_LITERAL));
		general.getChildren().add(createStandardPreferencePage(diagram, "connections", "Connections", StandardPreferencePages.CONNECTIONS_LITERAL));
		general.getChildren().add(createStandardPreferencePage(diagram, "printing", "Printing", StandardPreferencePages.PRINTING_LITERAL));
		general.getChildren().add(createStandardPreferencePage(diagram, "rulersAndGrid", "Rulers And Grid", StandardPreferencePages.RULERS_AND_GRID_LITERAL));
	}

	private GenPreferencePage createStandardPreferencePage(GenDiagram diagram, String id, String name, StandardPreferencePages kind) {
		GenStandardPreferencePage page = GMFGenFactory.eINSTANCE.createGenStandardPreferencePage();
		page.setID(diagram.getEditorGen().getPlugin().getID() + '.' + id);
		page.setName(name);
		page.setKind(kind);
		return page;
	}

	private void addContributions(GenApplication application) {
		GenMenuManager mainMenu = GMFGenFactory.eINSTANCE.createGenMenuManager();
		mainMenu.getItems().add(createFileMenu(application.getSharedContributionItems()));
		mainMenu.getItems().add(createEditMenu(application.getSharedContributionItems()));
		mainMenu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS")); //$NON-NLS-1$
		mainMenu.getItems().add(createWindowMenu(application.getSharedContributionItems()));
		mainMenu.getItems().add(createHelpMenu(application.getSharedContributionItems()));
		application.setMainMenu(mainMenu);

		GenToolBarManager mainToolBar = GMFGenFactory.eINSTANCE.createGenToolBarManager();
		mainToolBar.getItems().add(createGroupMarker("\"group.file\"")); //$NON-NLS-1$
		mainToolBar.getItems().add(createFileToolBar(application.getSharedContributionItems()));
		mainToolBar.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS")); //$NON-NLS-1$
		mainToolBar.getItems().add(createGroupMarker("\"group.nav\"")); //$NON-NLS-1$
		mainToolBar.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.GROUP_EDITOR")); //$NON-NLS-1$
		mainToolBar.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.GROUP_HELP")); //$NON-NLS-1$
		mainToolBar.getItems().add(createHelpToolBar(application.getSharedContributionItems()));
		application.setMainToolBar(mainToolBar);
	}

	private GenGroupMarker createGroupMarker(String groupName) {
		GenGroupMarker gm = GMFGenFactory.eINSTANCE.createGenGroupMarker();
		gm.setGroupName(groupName);
		return gm;
	}

	private GenSeparator createSeparator(String groupName) {
		GenSeparator s = GMFGenFactory.eINSTANCE.createGenSeparator();
		s.setGroupName(groupName);
		return s;
	}

	private GenActionFactoryContributionItem createActionFactoryItem(String name) {
		GenActionFactoryContributionItem item = GMFGenFactory.eINSTANCE.createGenActionFactoryContributionItem();
		item.setName(name);
		return item;
	}

	private GenSharedContributionItem createSharedItem(List<GenContributionItem> sharedItems, GenContributionItem actualItem) {
		GenSharedContributionItem sitem = GMFGenFactory.eINSTANCE.createGenSharedContributionItem();
		if (actualItem instanceof GenActionFactoryContributionItem) {
			GenActionFactoryContributionItem afActualItem = (GenActionFactoryContributionItem) actualItem;
			for (GenContributionItem item : sharedItems) {
				if (item instanceof GenActionFactoryContributionItem) {
					GenActionFactoryContributionItem afItem = (GenActionFactoryContributionItem) item;
					if (afItem.getName().equals(afActualItem.getName())) {
						// shared action factory item is already contributed
						sitem.setActualItem(afItem);
						actualItem = null;
						break;
					}
				}
			}
		}
		if (actualItem != null) {
			sitem.setActualItem(actualItem);
			sharedItems.add(actualItem);
		}
		return sitem;
	}

	private GenMenuManager createFileMenu(List<GenContributionItem> sharedItems) {
		GenMenuManager menu = GMFGenFactory.eINSTANCE.createGenMenuManager();
		menu.setID("org.eclipse.ui.IWorkbenchActionConstants.M_FILE"); //$NON-NLS-1$
		menu.setName("&File"); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.FILE_START")); //$NON-NLS-1$
		GenMenuManager newMenu = GMFGenFactory.eINSTANCE.createGenMenuManager();
		newMenu.setID("\"new\""); //$NON-NLS-1$
		newMenu.setName("&New"); //$NON-NLS-1$
		newMenu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS")); //$NON-NLS-1$
		menu.getItems().add(newMenu);
		menu.getItems().add(GMFGenFactory.eINSTANCE.createGenSeparator());
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS")); //$NON-NLS-1$
		menu.getItems().add(GMFGenFactory.eINSTANCE.createGenSeparator());
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("CLOSE"))); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("CLOSE_ALL"))); //$NON-NLS-1$
		menu.getItems().add(GMFGenFactory.eINSTANCE.createGenSeparator());
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("SAVE"))); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("SAVE_AS"))); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("SAVE_ALL"))); //$NON-NLS-1$
		menu.getItems().add(GMFGenFactory.eINSTANCE.createGenSeparator());
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("QUIT"))); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.FILE_END")); //$NON-NLS-1$
		return menu;
	}

	private GenMenuManager createEditMenu(List<GenContributionItem> sharedItems) {
		GenMenuManager menu = GMFGenFactory.eINSTANCE.createGenMenuManager();
		menu.setID("org.eclipse.ui.IWorkbenchActionConstants.M_EDIT"); //$NON-NLS-1$
		menu.setName("&Edit"); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.EDIT_START")); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("UNDO"))); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("REDO"))); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.UNDO_EXT")); //$NON-NLS-1$
		menu.getItems().add(GMFGenFactory.eINSTANCE.createGenSeparator());
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("CUT"))); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("COPY"))); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("PASTE"))); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.CUT_EXT")); //$NON-NLS-1$
		menu.getItems().add(GMFGenFactory.eINSTANCE.createGenSeparator());
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("DELETE"))); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("SELECT_ALL"))); //$NON-NLS-1$
		menu.getItems().add(GMFGenFactory.eINSTANCE.createGenSeparator());
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.ADD_EXT")); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.EDIT_END")); //$NON-NLS-1$
		menu.getItems().add(createSeparator("org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS")); //$NON-NLS-1$
		return menu;
	}

	private GenMenuManager createWindowMenu(List<GenContributionItem> sharedItems) {
		GenMenuManager menu = GMFGenFactory.eINSTANCE.createGenMenuManager();
		menu.setID("org.eclipse.ui.IWorkbenchActionConstants.M_WINDOW"); //$NON-NLS-1$
		menu.setName("&Window"); //$NON-NLS-1$
		menu.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("OPEN_NEW_WINDOW"))); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS")); //$NON-NLS-1$
		// TODO : menu.add(ContributionItemFactory.OPEN_WINDOWS.create(window));
		return menu;
	}

	private GenMenuManager createHelpMenu(List<GenContributionItem> sharedItems) {
		GenMenuManager menu = GMFGenFactory.eINSTANCE.createGenMenuManager();
		menu.setID("org.eclipse.ui.IWorkbenchActionConstants.M_HELP"); //$NON-NLS-1$
		menu.setName("&Help"); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.HELP_START")); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.HELP_END")); //$NON-NLS-1$
		menu.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS")); //$NON-NLS-1$
		return menu;
	}

	private GenToolBarManager createFileToolBar(List<GenContributionItem> sharedItems) {
		GenToolBarManager toolBar = GMFGenFactory.eINSTANCE.createGenToolBarManager();
		toolBar.setID("org.eclipse.ui.IWorkbenchActionConstants.TOOLBAR_FILE"); //$NON-NLS-1$
		toolBar.getItems().add(createSeparator("org.eclipse.ui.IWorkbenchActionConstants.NEW_GROUP")); //$NON-NLS-1$
		toolBar.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.NEW_EXT")); //$NON-NLS-1$
		toolBar.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.SAVE_GROUP")); //$NON-NLS-1$
		toolBar.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("SAVE"))); //$NON-NLS-1$
		toolBar.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.SAVE_EXT")); //$NON-NLS-1$
		toolBar.getItems().add(createSharedItem(sharedItems, createActionFactoryItem("PRINT"))); //$NON-NLS-1$
		toolBar.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.PRINT_EXT")); //$NON-NLS-1$
		toolBar.getItems().add(createSeparator("org.eclipse.ui.IWorkbenchActionConstants.MB_ADDITIONS")); //$NON-NLS-1$
		return toolBar;
	}

	private GenToolBarManager createHelpToolBar(List<GenContributionItem> sharedItems) {
		GenToolBarManager toolBar = GMFGenFactory.eINSTANCE.createGenToolBarManager();
		toolBar.setID("org.eclipse.ui.IWorkbenchActionConstants.TOOLBAR_HELP"); //$NON-NLS-1$
		toolBar.getItems().add(createSeparator("org.eclipse.ui.IWorkbenchActionConstants.GROUP_HELP")); //$NON-NLS-1$
		toolBar.getItems().add(createGroupMarker("org.eclipse.ui.IWorkbenchActionConstants.GROUP_APP")); //$NON-NLS-1$
		return toolBar;
	}

	private GenParserImplementation getOrCreateParser(FeatureLabelMapping flMapping) {
		if (isEnumLabelMapping(flMapping)) {
			return getOrCreateEnumParser(flMapping);
		} else {
			return getOrCreatePredefinedParser(flMapping);
		}
	}
	
	private boolean isEnumLabelMapping(FeatureLabelMapping flMapping) {
		EList<EAttribute> features = flMapping.getFeatures();
		EList<EAttribute> editFeatures = flMapping.getEditableFeatures();
		if (features.size() != 1){
			return false;
		}
		if (editFeatures.size() > features.size()){
			return false;
		}
		if (!editFeatures.isEmpty() && editFeatures.get(0) != features.get(0)) {
			return false;
		}
		return features.get(0).getEType() instanceof EEnum;
	}

	private GenParserImplementation getOrCreateEnumParser(FeatureLabelMapping flMapping) {
		for (GenParserImplementation pi : getGenParsers().getImplementations()) {
			if (pi instanceof PredefinedEnumParser) {
				return (PredefinedEnumParser) pi;
			}
		}
		PredefinedEnumParser result = GMFGenFactory.eINSTANCE.createPredefinedEnumParser();
		getGenParsers().getImplementations().add(result);
		return result;
	}

	private GenParserImplementation createOclChoiceParser(OclChoiceLabelMapping oclMapping) {
		OclChoiceParser result = GMFGenFactory.eINSTANCE.createOclChoiceParser();
		if (oclMapping.getItemsExpression() != null) {
			result.setItemsExpression(createValueExpression(oclMapping.getItemsExpression()));
		}
		if (oclMapping.getShowExpression() != null) {
			result.setShowExpression(createValueExpression(oclMapping.getShowExpression()));
		}
		getGenParsers().getImplementations().add(result);
		return result;
	}

	private GenParserImplementation getOrCreatePredefinedParser(FeatureLabelMapping flMapping) {
		final LabelTextAccessMethod editMethod = LabelTextAccessMethod.get(flMapping.getEditMethod().getValue());
		final LabelTextAccessMethod viewMethod = LabelTextAccessMethod.get(flMapping.getViewMethod().getValue());
		for (GenParserImplementation pi : getGenParsers().getImplementations()) {
			if (pi instanceof PredefinedParser) {
				PredefinedParser pp = (PredefinedParser) pi;
				boolean same = pp.getEditMethod() == editMethod;
				same &= pp.getViewMethod() == viewMethod;
				if (same) {
					return pp;
				}
			}
		}
		PredefinedParser result = GMFGenFactory.eINSTANCE.createPredefinedParser();
		result.setEditMethod(editMethod);
		result.setViewMethod(viewMethod);
		getGenParsers().getImplementations().add(result);
		return result;
	}

	private GenParserImplementation getOrCreateParser(DesignLabelMapping flMapping) {
		if (myDesignLabelParser == null) {
			myDesignLabelParser = GMFGenFactory.eINSTANCE.createExternalParser();
			getGenParsers().getImplementations().add(myDesignLabelParser);
		}
		return myDesignLabelParser;
	}

	private GenParserImplementation getOrCreateParser(LabelMapping flMapping) {
		if (myAuxParser == null) {
			myAuxParser = GMFGenFactory.eINSTANCE.createExternalParser();
			getGenParsers().getImplementations().add(myAuxParser);
		}
		return myAuxParser;
	}
}