/*
* Copyright (c) 2005, 2008 Borland Software Corporation
*
* 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.tests.setup;
import org.eclipse.emf.codegen.ecore.genmodel.GenClass;
import org.eclipse.emf.codegen.ecore.genmodel.GenModel;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
import org.eclipse.gmf.codegen.gmfgen.*;
import org.eclipse.gmf.internal.bridge.NaiveIdentifierDispenser;
import org.eclipse.gmf.internal.bridge.genmodel.BasicDiagramRunTimeModelHelper;
import org.eclipse.gmf.internal.bridge.genmodel.DiagramGenModelTransformer;
import org.eclipse.gmf.internal.bridge.genmodel.GenModelMatcher;
import org.eclipse.gmf.internal.bridge.genmodel.InnerClassViewmapProducer;
import org.eclipse.gmf.internal.bridge.genmodel.RuntimeGenModelAccess;
import org.eclipse.gmf.internal.bridge.genmodel.ViewmapProducer;
import org.eclipse.gmf.internal.bridge.naming.gen.GenNamingMediatorImpl;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.tests.Plugin;
import org.eclipse.gmf.tests.Utils;
/**
* @author artem
*/
public class DiaGenSetup implements DiaGenSource {
private GenDiagram myGenDiagram;
private GenTopLevelNode myNodeA;
private GenLink myLinkC;
private GenLink myLinkD;
private GenNode myNodeB;
private ViewmapProducer myViewmapProducer;
public DiaGenSetup() {
this(new InnerClassViewmapProducer());
}
public DiaGenSetup(ViewmapProducer viewmapProducer) {
myViewmapProducer = viewmapProducer;
}
/**
* @return <code>this</code> for convenience
*/
public DiaGenSetup init(DomainModelSource domainSource) {
final GenModel runtimeModel = getRuntimeGenModel();
assert runtimeModel != null;
final GenModelMatcher gmm = new GenModelMatcher(Utils.createGenModel(domainSource.getModel()));
myGenDiagram = GMFGenFactory.eINSTANCE.createGenDiagram();
GenEditorGenerator genBurden = GMFGenFactory.eINSTANCE.createGenEditorGenerator();
myGenDiagram.setDomainDiagramElement(gmm.findGenClass(domainSource.getDiagramElement()));
genBurden.setDomainGenModel(myGenDiagram.getDomainDiagramElement().getGenModel());
genBurden.setEditor(GMFGenFactory.eINSTANCE.createGenEditorView());
myGenDiagram.setDiagramRunTimeClass(Utils.findGenClass(runtimeModel, NotationPackage.eINSTANCE.getDiagram()));
myGenDiagram.setPalette(createPalette());
myGenDiagram.setViewmap(createDiagramViewmap());
myGenDiagram.setVisualID(99);
MetamodelType dgmmType = GMFGenFactory.eINSTANCE.createMetamodelType();
myGenDiagram.setElementType(dgmmType);
genBurden.setDiagram(myGenDiagram);
genBurden.setPlugin(GMFGenFactory.eINSTANCE.createGenPlugin());
genBurden.setDiagramUpdater(GMFGenFactory.eINSTANCE.createGenDiagramUpdater());
genBurden.setLabelParsers(GMFGenFactory.eINSTANCE.createGenParsers());
myNodeA = GMFGenFactory.eINSTANCE.createGenTopLevelNode();
myNodeA.setDiagramRunTimeClass(Utils.findGenClass(runtimeModel, NotationPackage.eINSTANCE.getNode()));
myNodeA.setModelFacet(createNodeModelFacet(gmm, domainSource.getNodeA()));
myNodeA.setElementType(GMFGenFactory.eINSTANCE.createMetamodelType());
EAttribute editFeature = domainSource.getNodeA().getNameAttr();
if (editFeature != null) {
FeatureLabelModelFacet modelFacet = GMFGenFactory.eINSTANCE.createFeatureLabelModelFacet();
modelFacet.getMetaFeatures().add(gmm.findGenFeature(editFeature));
GenNodeLabel label = GMFGenFactory.eINSTANCE.createGenNodeLabel();
label.setModelFacet(modelFacet);
label.setVisualID(401);
label.setViewmap(createLabelViewmap());
label.setDiagramRunTimeClass(myNodeA.getDiagramRunTimeClass());
myNodeA.getLabels().add(label);
modelFacet.setParser(GMFGenFactory.eINSTANCE.createExternalParser());
genBurden.getLabelParsers().getImplementations().add(modelFacet.getParser());
}
myNodeA.setViewmap(createNodeViewmap());
myNodeA.setVisualID(100);
myLinkC = GMFGenFactory.eINSTANCE.createGenLink();
myLinkC.setDiagramRunTimeClass(Utils.findGenClass(runtimeModel, NotationPackage.eINSTANCE.getEdge()));
myLinkC.setModelFacet(createLinkModelFacet(gmm, domainSource.getLinkAsClass()));
myLinkC.setViewmap(createLinkViewmap());
myLinkC.setVisualID(200);
myLinkC.setElementType(GMFGenFactory.eINSTANCE.createMetamodelType());
// TODO add linkRefOnly
myGenDiagram.getTopLevelNodes().add(myNodeA);
myGenDiagram.getLinks().add(myLinkC);
GenExpressionProviderContainer providerContainer = GMFGenFactory.eINSTANCE.createGenExpressionProviderContainer();
myGenDiagram.getEditorGen().setExpressionProviders(providerContainer);
myGenDiagram.getEditorGen().setAudits(createAudits(providerContainer));
confineInResource();
return this;
}
private static Viewmap createLinkViewmap() {
FigureViewmap v = GMFGenFactory.eINSTANCE.createFigureViewmap();
v.setFigureQualifiedClassName("org.eclipse.gmf.runtime.draw2d.ui.figures.PolylineConnectionEx");
return v;
}
private static Viewmap createNodeViewmap() {
FigureViewmap v = GMFGenFactory.eINSTANCE.createFigureViewmap();
v.setFigureQualifiedClassName("org.eclipse.draw2d.RoundedRectangle");
return v;
}
private static Viewmap createDiagramViewmap() {
FigureViewmap v = GMFGenFactory.eINSTANCE.createFigureViewmap();
v.setFigureQualifiedClassName("org.eclipse.draw2d.FreeformLayer");
return v;
}
private static Viewmap createLabelViewmap() {
FigureViewmap v = GMFGenFactory.eINSTANCE.createFigureViewmap();
v.setFigureQualifiedClassName("org.eclipse.draw2d.Label");
return v;
}
private TypeModelFacet createNodeModelFacet(GenModelMatcher gmm, DomainModelSetup.NodeData node) {
TypeModelFacet mf = GMFGenFactory.eINSTANCE.createTypeModelFacet();
mf.setMetaClass(gmm.findGenClass(node.getEClass()));
mf.setContainmentMetaFeature(gmm.findGenFeature(node.getContainment()));
mf.setChildMetaFeature(mf.getContainmentMetaFeature());
return mf;
}
private TypeLinkModelFacet createLinkModelFacet(final GenModelMatcher gmm, DomainModelSetup.LinkData link) {
TypeLinkModelFacet mf = GMFGenFactory.eINSTANCE.createTypeLinkModelFacet();
mf.setMetaClass(gmm.findGenClass(link.getEClass()));
mf.setContainmentMetaFeature(gmm.findGenFeature(link.getContainment()));
mf.setChildMetaFeature(mf.getContainmentMetaFeature());
mf.setTargetMetaFeature(gmm.findGenFeature(link.getTargetFeature()));
return mf;
}
private GenModel getRuntimeGenModel() {
RuntimeGenModelAccess runtimeAccess = new RuntimeGenModelAccess();
runtimeAccess.ensure();
return runtimeAccess.model();
}
public DiaGenSetup init(MapDefSource mapSource) {
DiagramGenModelTransformer.Parameters opts = new DiagramGenModelTransformer.Parameters(new BasicDiagramRunTimeModelHelper(), myViewmapProducer, new NaiveIdentifierDispenser(), false);
DiagramGenModelTransformer t = new DiagramGenModelTransformer(opts);
t.setEMFGenModel(initGenModel(mapSource.getMapping().getDiagram().getDomainModel()));
t.transform(mapSource.getMapping());
new GenNamingMediatorImpl().traverse(t.getResult());
myGenDiagram = t.getResult().getDiagram();
myNodeA = t.getTrace().findTopNode(mapSource.getNodeA());
myNodeB = mapSource.getNodeB() == null ? null : t.getTrace().findTopNode(mapSource.getNodeB());
myLinkC = t.getTrace().find(mapSource.getClassLink());
myLinkD = t.getTrace().find(mapSource.getReferenceLink());
if (mapSource instanceof MapSetup) {
initSpecific((MapSetup) mapSource);
}
assert myNodeA != null;
assert myLinkC != null;
assert myLinkD != null;
confineInResource();
return this;
}
private void initSpecific(MapSetup setup) {
for (GenLink nextLink : myGenDiagram.getLinks()) {
if (nextLink == myLinkC || nextLink == myLinkD) {
continue;
}
if (nextLink.getModelFacet() instanceof TypeLinkModelFacet) {
TypeLinkModelFacet modelFacet = (TypeLinkModelFacet) nextLink.getModelFacet();
nextLink.setIncomingCreationAllowed(true);
if (isSelfLink(modelFacet) || modelFacet.getContainmentMetaFeature().getEcoreFeature().getUpperBound() > 1) {
nextLink.setOutgoingCreationAllowed(true);
} else {
nextLink.setOutgoingCreationAllowed(false);
}
} else if (nextLink.getModelFacet() instanceof FeatureLinkModelFacet) {
FeatureLinkModelFacet modelFacet = (FeatureLinkModelFacet) nextLink.getModelFacet();
nextLink.setIncomingCreationAllowed(true);
if (isSelfLink(modelFacet) || modelFacet.getMetaFeature().getEcoreFeature().getUpperBound() > 1) {
nextLink.setOutgoingCreationAllowed(true);
} else {
nextLink.setOutgoingCreationAllowed(false);
}
}
}
}
private boolean isSelfLink(FeatureLinkModelFacet modelFacet) {
return modelFacet.getMetaFeature().getTypeGenClass() == modelFacet.getMetaFeature().getGenClass();
}
private boolean isSelfLink(TypeLinkModelFacet modelFacet) {
return modelFacet.getTargetMetaFeature().getTypeGenClass() == modelFacet.getContainmentMetaFeature().getGenClass();
}
protected GenModel initGenModel(EPackage domainModel) {
return Utils.createGenModel(domainModel);
}
private void confineInResource() {
new ResourceImpl(URI.createURI("uri://org.eclipse.gmf/tests/DiaGenSetup")).getContents().add(myGenDiagram.getEditorGen());
}
public final GenDiagram getGenDiagram() {
return myGenDiagram;
}
public final GenNode getNodeA() {
return myNodeA;
}
public final GenNode getNodeB() {
return myNodeB;
}
public final GenLink getLinkC() {
return myLinkC;
}
public GenLink getLinkD() {
return myLinkD;
}
private GenAuditRoot createAudits(GenExpressionProviderContainer providerContainer) {
GenClass classA = getNodeA().getDomainMetaClass();
assert getLinkC().getModelFacet() instanceof TypeLinkModelFacet : "Expecting link with class"; //$NON-NLS-1$
GenClass classC = ((TypeLinkModelFacet)getLinkC().getModelFacet()).getMetaClass();
GenAuditRoot root = GMFGenFactory.eINSTANCE.createGenAuditRoot();
GenAuditContainer topCat = createAuditContainer(Plugin.getPluginID() + ".category1" + System.currentTimeMillis()); //$NON-NLS-1$
root.getCategories().add(topCat);
topCat.getPath().add(topCat);
// create set of allways satisfied constraints
topCat.getAudits().add(createAudit("constraint.id1", "true", classA, GenSeverity.ERROR_LITERAL, false)); //$NON-NLS-1$ //$NON-NLS-2$
topCat.getAudits().add(createAudit("constraint.id2", "10 > 0", classC, GenSeverity.WARNING_LITERAL, false)); //$NON-NLS-1$ //$NON-NLS-2$
root.getRules().addAll(topCat.getAudits());
GenAuditContainer subCat = createAuditContainer("category2"); //$NON-NLS-1$
root.getCategories().add(subCat);
subCat.getPath().add(topCat);
subCat.getPath().add(subCat);
subCat.getAudits().add(createAudit("constraint.id3", "''<>'Foo'", classA, GenSeverity.INFO_LITERAL, false)); //$NON-NLS-1$ //$NON-NLS-2$
root.getRules().addAll(subCat.getAudits());
GenExpressionInterpreter provider = GMFGenFactory.eINSTANCE.createGenExpressionInterpreter();
provider.setLanguage(GenLanguage.OCL_LITERAL);
providerContainer.getProviders().add(provider);
for (GenAuditRule a : root.getRules()) {
provider.getExpressions().add(a.getRule());
}
return root;
}
private GenAuditRule createAudit(String id, String ruleBody, GenClass target, GenSeverity severity, boolean isLiveMode) {
GenAuditRule audit = GMFGenFactory.eINSTANCE.createGenAuditRule();
audit.setId(id);
audit.setName("Name of" + id); //$NON-NLS-1$
GenDomainElementTarget ruleTarget = GMFGenFactory.eINSTANCE.createGenDomainElementTarget();
ruleTarget.setElement(target);
audit.setTarget(ruleTarget);
GenConstraint rule = GMFGenFactory.eINSTANCE.createGenConstraint();
rule.setBody(ruleBody);
audit.setRule(rule);
audit.setSeverity(severity);
audit.setUseInLiveMode(isLiveMode);
return audit;
}
private GenAuditContainer createAuditContainer(String id) {
GenAuditContainer container = GMFGenFactory.eINSTANCE.createGenAuditContainer();
container.setId(id);
container.setName("Name of " + id); //$NON-NLS-1$
container.setDescription("Description of " + id); //$NON-NLS-1$
return container;
}
// Empty palette, unless we'd like to test it
private Palette createPalette() {
return null;
// Palette rv = GMFGenFactory.eINSTANCE.createPalette();
// ToolGroup tg = GMFGenFactory.eINSTANCE.createToolGroup();
// tg.setTitleKey("fake-group");
// tg.setCreateMethodName("createFakeGroup");
// rv.getGroups().add(tg); // to satisfy [+] restriction
// return rv;
}
}