package org.eclipse.egf.portfolio.genchain.ecoretools.operation; | |
import java.lang.reflect.InvocationTargetException; | |
import java.util.ArrayList; | |
import java.util.Collection; | |
import java.util.Collections; | |
import java.util.HashSet; | |
import java.util.List; | |
import java.util.Set; | |
import org.eclipse.core.resources.IFolder; | |
import org.eclipse.core.resources.IProject; | |
import org.eclipse.core.resources.ResourcesPlugin; | |
import org.eclipse.core.runtime.CoreException; | |
import org.eclipse.core.runtime.IProgressMonitor; | |
import org.eclipse.core.runtime.NullProgressMonitor; | |
import org.eclipse.core.runtime.SubProgressMonitor; | |
import org.eclipse.egf.portfolio.genchain.ecoretools.command.CreateEdgeCommand; | |
import org.eclipse.egf.portfolio.genchain.ecoretools.command.CreateNodeCommand; | |
import org.eclipse.emf.common.command.Command; | |
import org.eclipse.emf.common.command.CompoundCommand; | |
import org.eclipse.emf.common.util.BasicEList; | |
import org.eclipse.emf.common.util.EList; | |
import org.eclipse.emf.common.util.URI; | |
import org.eclipse.emf.ecore.EObject; | |
import org.eclipse.emf.ecore.EPackage; | |
import org.eclipse.emf.ecore.plugin.EcorePlugin; | |
import org.eclipse.emf.ecore.resource.Resource; | |
import org.eclipse.emf.transaction.RecordingCommand; | |
import org.eclipse.emf.transaction.TransactionalEditingDomain; | |
import org.eclipse.gmf.runtime.notation.Diagram; | |
import org.eclipse.sirius.business.api.componentization.ViewpointRegistry; | |
import org.eclipse.sirius.business.api.dialect.DialectManager; | |
import org.eclipse.sirius.business.api.dialect.command.CreateRepresentationCommand; | |
import org.eclipse.sirius.business.api.modelingproject.ModelingProject; | |
import org.eclipse.sirius.business.api.query.EdgeMappingQuery; | |
import org.eclipse.sirius.business.api.session.CustomDataConstants; | |
import org.eclipse.sirius.business.api.session.DefaultLocalSessionCreationOperation; | |
import org.eclipse.sirius.business.api.session.Session; | |
import org.eclipse.sirius.business.api.session.SessionCreationOperation; | |
import org.eclipse.sirius.common.tools.api.util.Option; | |
import org.eclipse.sirius.diagram.business.api.view.refresh.CanonicalSynchronizer; | |
import org.eclipse.sirius.diagram.business.api.view.refresh.CanonicalSynchronizerFactory; | |
import org.eclipse.sirius.diagram.ui.tools.api.layout.LayoutUtils; | |
import org.eclipse.sirius.ecore.extender.business.api.accessor.ModelAccessor; | |
import org.eclipse.sirius.table.metamodel.table.DTable; | |
import org.eclipse.sirius.tools.api.command.semantic.AddSemanticResourceCommand; | |
import org.eclipse.sirius.ui.business.api.viewpoint.ViewpointSelectionCallback; | |
import org.eclipse.sirius.diagram.internal.refresh.SynchronizeGMFModelCommand; | |
import org.eclipse.sirius.diagram.tools.internal.graphical.edit.DiagramCreationUtil; | |
import org.eclipse.sirius.ui.business.internal.commands.ChangeViewpointSelectionCommand; | |
import org.eclipse.sirius.viewpoint.DDiagram; | |
import org.eclipse.sirius.viewpoint.DRepresentation; | |
import org.eclipse.sirius.viewpoint.DSemanticDiagram; | |
import org.eclipse.sirius.viewpoint.DragAndDropTarget; | |
import org.eclipse.sirius.viewpoint.description.AbstractNodeMapping; | |
import org.eclipse.sirius.viewpoint.description.ContainerMapping; | |
import org.eclipse.sirius.viewpoint.description.DiagramDescription; | |
import org.eclipse.sirius.viewpoint.description.EdgeMapping; | |
import org.eclipse.sirius.viewpoint.description.NodeMapping; | |
import org.eclipse.sirius.viewpoint.description.RepresentationDescription; | |
import org.eclipse.sirius.viewpoint.description.Viewpoint; | |
import org.eclipse.swt.widgets.Display; | |
import org.eclipse.ui.actions.WorkspaceModifyOperation; | |
/** | |
* This operation allows to : | |
* - create a Sirius representation file (aird) | |
* - associate an ecore model to the representation as a semantic resource | |
* - select a set of viewpoint | |
* - create diagrams on ecore {@link EPackage} elements | |
* | |
* @author Boubekeur Zendagui | |
*/ | |
@SuppressWarnings("restriction") | |
public class CreateEcoreTools2RepresentationOperation extends WorkspaceModifyOperation{ | |
/** Sirius representation files extension **/ | |
private final static String _AIRD_FILE_EXTENSION = "aird"; | |
/** Viewpoint and diagrams names **/ | |
protected final static String VIEWPOINT_ECORE_DESIGN = "Design"; | |
protected final static String REPRESENTATION__ENTITIES_DIAGRAM = "Entities"; | |
protected final static String REPRESENTATION__DOCUMENTATION_TABLE = "Classes"; | |
/** List of all representation names to create**/ | |
protected Set<Viewpoint> viewpoints = new HashSet<Viewpoint>(); | |
protected List<RepresentationDescription> representations = new ArrayList<RepresentationDescription>(); | |
/** Representation file information **/ | |
private String representationFileName; | |
private URI representationFileURI; | |
private IProject representationProject; | |
/** {@link URI} of the ecore model **/ | |
private URI ecoreModelURI; | |
/** | |
* Default constructor | |
* @param ecoreURI ecore model URI | |
* @param fileName name of the representation file. If its value is <code> null <code/>, | |
* the representation file will have the same name of the ecore model | |
*/ | |
public CreateEcoreTools2RepresentationOperation(URI ecoreURI, String fileName) { | |
super(); | |
// ecoreModelURI value set must be the first operation | |
this.ecoreModelURI = ecoreURI; | |
// compute representation informations | |
initRepresentationFileInformations(fileName); | |
// Initialize Ecore Tools supported Viewpoint and available representations | |
initViewpointsList(); | |
} | |
private void initRepresentationFileInformations(String fileName){ | |
this.representationFileName = getRepresentationFileName(fileName); | |
this.representationFileURI = getRepresentationUri(fileName); | |
this.representationProject = getRepresentationProject(fileName); | |
} | |
private boolean isFqnFileName(String fileName){ | |
if (fileName != null && !fileName.isEmpty() && fileName.contains("/")) | |
return true; | |
else | |
return false; | |
} | |
@Override | |
protected void execute(IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException { | |
/** Step 1: create representation file and get the session **/ | |
Session session = createRepresentationFile(monitor); | |
/** Step 2: Create diagrams on EPackages**/ | |
if (session != null) | |
{// Create diagrams if session was well created in the previous step | |
DDiagram diagram = createDiagrams(session, monitor); | |
// Create diagram content | |
if (diagram != null) | |
populateEntitiesDiagram(session, diagram); | |
// Layout diagram content | |
arrangeAll(session, diagram); | |
// Save session | |
session.save(Collections.EMPTY_MAP, monitor); | |
} | |
} | |
/** | |
* Create all diagrams for ecore {@link EPackage}. | |
* @param session The {@link Session} opened on the created representation file | |
* @param monitor {@link IProgressMonitor} | |
*/ | |
private DDiagram createDiagrams(final Session session, IProgressMonitor monitor){ | |
DDiagram entitiesDiagram = null; | |
List<EPackage> ecoreEPackages = getEcoreEPackagesFromSession(session); | |
for (EPackage iEPackage : ecoreEPackages) | |
{ | |
Collection<DRepresentation> representations = DialectManager.INSTANCE.getRepresentations(iEPackage, session); | |
if (representations.isEmpty()) | |
{// Create all representation | |
entitiesDiagram = createEntitiesDiagram(iEPackage, session, monitor); | |
createClassesTable(iEPackage, session, monitor); | |
} | |
else | |
{ | |
// Check no existence of "Entities" and "Classes" representations | |
List<String> representationDescriptionNames = new ArrayList<String>(); | |
for (DRepresentation representation : representations) | |
{ | |
if (representation instanceof DDiagram) | |
{ | |
final DDiagram dDiagram = (DDiagram) representation; | |
final RepresentationDescription description = dDiagram.getDescription(); | |
representationDescriptionNames.add(description.getName()); | |
if (dDiagram.getOwnedDiagramElements().isEmpty()) | |
entitiesDiagram = dDiagram; | |
} | |
else | |
{ | |
if (representation instanceof DTable) | |
{ | |
final RepresentationDescription description = ((DTable) representation).getDescription(); | |
representationDescriptionNames.add(description.getName()); | |
} | |
} | |
} | |
if (! representationDescriptionNames.contains(REPRESENTATION__ENTITIES_DIAGRAM)) | |
entitiesDiagram = createEntitiesDiagram(iEPackage, session, monitor); | |
if (! representationDescriptionNames.contains(REPRESENTATION__DOCUMENTATION_TABLE)) | |
createClassesTable(iEPackage, session, monitor); | |
} | |
} | |
return entitiesDiagram; | |
} | |
/** | |
* Allows to arrange all on a given diagram | |
* @param session uses {@link Session} to edit diagrams | |
* @param diagram {@link DDiagram} to arrange | |
*/ | |
private void arrangeAll(final Session session, final DDiagram diagram){ | |
final DiagramCreationUtil util = new DiagramCreationUtil(diagram); | |
Diagram associatedGMFDiagram = null; | |
if (!util.findAssociatedGMFDiagram()) | |
{// If GMF diagram is not initialized, create it | |
util.createNewGMFDiagram(); | |
associatedGMFDiagram = util.getAssociatedGMFDiagram(); | |
if (associatedGMFDiagram != null) | |
session.getServices().putCustomData(CustomDataConstants.GMF_DIAGRAMS, diagram, associatedGMFDiagram); | |
} | |
else | |
{// Get the GMF diagram | |
associatedGMFDiagram = util.getAssociatedGMFDiagram(); | |
} | |
// Synchronize Sirius diagram with GMF diagram | |
final TransactionalEditingDomain domain = session.getTransactionalEditingDomain(); | |
if (associatedGMFDiagram != null) | |
{ | |
final CanonicalSynchronizer canonicalSynchronizer = CanonicalSynchronizerFactory.INSTANCE.createCanonicalSynchronizer(associatedGMFDiagram); | |
Command gmfNotationModelSynchronizationCmd = new SynchronizeGMFModelCommand(domain, canonicalSynchronizer); | |
domain.getCommandStack().execute(gmfNotationModelSynchronizationCmd); | |
} | |
final Diagram associatedGMFDiagram_f = associatedGMFDiagram; | |
// Display.getDefault().syncExec(new Runnable() { | |
// public void run() { | |
// Shell shell = new Shell(Display.getDefault()); | |
// try { | |
// | |
// DiagramEditPart diagramEP = OffscreenEditPartFactory.getInstance().createDiagramEditPart(associatedGMFDiagram_f, shell, null); | |
// | |
// List<Object> hints = new ArrayList<Object>(2); | |
// hints.add(LayoutType.DEFAULT); | |
// hints.add(diagramEP); | |
// IAdaptable layoutHint = new ObjectAdapter(hints); | |
// | |
// @SuppressWarnings("rawtypes") | |
// List layoutNodes = LayoutService.getInstance().getLayoutNodes(diagramEP, associatedGMFDiagram_f.getChildren()); | |
// Runnable layoutRun = LayoutService.getInstance().layoutLayoutNodes(layoutNodes, true, layoutHint); | |
// layoutRun.run(); | |
// | |
//// diagramEP.deactivate(); | |
//// domain.getCommandStack().flush(); | |
// } | |
// finally { | |
//// shell.dispose(); | |
// } | |
// } | |
// }); | |
if (associatedGMFDiagram_f != null) | |
{ | |
final RecordingCommand command = new RecordingCommand(session.getTransactionalEditingDomain()) { | |
@Override | |
protected void doExecute() { | |
LayoutUtils.initializeDiagramLayout(associatedGMFDiagram_f, diagram); | |
} | |
}; | |
Display.getDefault().syncExec(new Runnable() { | |
public void run() { | |
session.getTransactionalEditingDomain().getCommandStack().execute(command); | |
} | |
}); | |
} | |
} | |
/** | |
* Create diagram content | |
* @param session used {@link Session} to edit diagrams | |
* @param diagram {@link DDiagram} to populate with containers, nodes and edges | |
*/ | |
private void populateEntitiesDiagram(final Session session, final DDiagram diagram){ | |
List<EPackage> ecoreEPackagesFromSession = getEcoreEPackagesFromSession(session); | |
for (EPackage ePackage : ecoreEPackagesFromSession) | |
{ | |
populateNodesAndContainers(session, diagram, ePackage); | |
populateEdges(session, diagram, ePackage); | |
} | |
} | |
private void populateEdges(final Session session, final DDiagram diagram, EPackage ePackage){ | |
/** List of diagram description edges mapping**/ | |
final DiagramDescription description = diagram.getDescription(); | |
EList<EdgeMapping> allEdgeMappings = description.getDefaultLayer().getEdgeMappings(); | |
// Create and execute edge creation commands | |
TransactionalEditingDomain transactionalEditingDomain = session.getTransactionalEditingDomain(); | |
for (EdgeMapping edgeMapping : allEdgeMappings) | |
{ | |
boolean useDomainElement = edgeMapping.isUseDomainElement(); | |
if (useDomainElement) | |
{ | |
EdgeMappingQuery edgeMappingQuery = new EdgeMappingQuery(edgeMapping); | |
Collection<EObject> candidates = edgeMappingQuery.evaluateCandidateExpression((DSemanticDiagram)diagram, session.getInterpreter(), (DragAndDropTarget)diagram); | |
for (EObject eObject : candidates) | |
{ | |
CreateEdgeCommand command = new CreateEdgeCommand(session, diagram, edgeMapping, eObject, useDomainElement); | |
transactionalEditingDomain.getCommandStack().execute(command); | |
} | |
} | |
else | |
{ | |
for (EObject semantic : ePackage.eContents()) | |
{ | |
CreateEdgeCommand command = new CreateEdgeCommand(session, diagram, edgeMapping, semantic, useDomainElement); | |
transactionalEditingDomain.getCommandStack().execute(command); | |
} | |
} | |
} | |
transactionalEditingDomain.getCommandStack().flush(); | |
} | |
/** | |
* Create nodes and containers diagram children | |
* @param session used {@link Session} to edit diagrams | |
* @param diagram {@link DDiagram} to populate with nodes and containers | |
* @param ePackage {@link EPackage} | |
*/ | |
private void populateNodesAndContainers(final Session session, final DDiagram diagram, EPackage ePackage) { | |
/** List of diagram description node and container mapping**/ | |
EList<AbstractNodeMapping> abstractNodeMappings = new BasicEList<AbstractNodeMapping>(); | |
final DiagramDescription description = diagram.getDescription(); | |
/** Handle description NodeMppings **/ | |
EList<NodeMapping> nodeMappings = description.getAllNodeMappings(); | |
if (! nodeMappings.isEmpty()) | |
abstractNodeMappings.addAll(nodeMappings); | |
/** Handle description ContainerMppings **/ | |
EList<ContainerMapping> containerMappings = description.getAllContainerMappings(); | |
if (! containerMappings.isEmpty()) | |
abstractNodeMappings.addAll(containerMappings); | |
final ModelAccessor modelAccessor = session.getModelAccessor(); | |
for (final AbstractNodeMapping abstractNodeMapping : abstractNodeMappings) | |
{ | |
final String domainClass = abstractNodeMapping.getDomainClass(); | |
// Handling EPackage content | |
for (final EObject element : ePackage.eContents()) | |
{ | |
if (modelAccessor.eInstanceOf(element, domainClass)) | |
{ | |
CreateNodeCommand command = new CreateNodeCommand(session, diagram, abstractNodeMapping, element); | |
session.getTransactionalEditingDomain().getCommandStack().execute(command); | |
} | |
} | |
} | |
} | |
/** | |
* Create a diagram Representation | |
* @param semantic model element root of the representation to create | |
* @param session {@link Session} used to create the representation | |
* @param monitor {@link IProgressMonitor} to trace representation creation | |
* @return True if the representation is well created, false otherwise | |
*/ | |
private DDiagram createEntitiesDiagram(final EPackage semantic, Session session, IProgressMonitor monitor){ | |
final RepresentationDescription entitiesDiagram = getRepresentationDescription(REPRESENTATION__ENTITIES_DIAGRAM); | |
final String diagramName = semantic.getName() + " entities diagram"; | |
DRepresentation createRepresentation = createRepresentation(semantic, session, entitiesDiagram, diagramName, monitor); | |
return (DDiagram) createRepresentation; | |
} | |
/** | |
* Create a Table representation | |
* @param semantic model element root of the representation to create | |
* @param session {@link Session} used to create the representation | |
* @param monitor {@link IProgressMonitor} to trace representation creation | |
* @return True if the representation is well created, false otherwise | |
*/ | |
private DTable createClassesTable(final EPackage semantic, final Session session, IProgressMonitor monitor){ | |
final RepresentationDescription classesTable = getRepresentationDescription(REPRESENTATION__DOCUMENTATION_TABLE); | |
final String tableName = semantic.getName() + " documentation"; | |
DRepresentation createRepresentation = createRepresentation(semantic, session, classesTable, tableName, monitor); | |
return (DTable) createRepresentation; | |
} | |
/** | |
* Create one representation for a given semantic element in a given session | |
* @param semantic model element root of the representation to create | |
* @param session {@link Session} used to create the representation | |
* @param description {@link RepresentationDescription} used to create the representation | |
* @param name representation name | |
* @param monitor {@link IProgressMonitor} to trace representation creation | |
* @return the created {@link DRepresentation} | |
*/ | |
private DRepresentation createRepresentation(final EObject semantic, final Session session, final RepresentationDescription description, | |
final String name, IProgressMonitor monitor) { | |
CreateRepresentationCommand createRepresentationCommand = new CreateRepresentationCommand(session, description, semantic, name, monitor); | |
session.getTransactionalEditingDomain().getCommandStack().execute(createRepresentationCommand); | |
DRepresentation createdRepresentation = createRepresentationCommand.getCreatedRepresentation(); | |
return createdRepresentation; | |
} | |
/** | |
* | |
* @param representationName the name of sought representation | |
* @return a {@link RepresentationDescription} or null | |
*/ | |
private RepresentationDescription getRepresentationDescription(String representationName){ | |
for (RepresentationDescription representation : representations) | |
{ | |
if (representation.getName().equals(representationName)) | |
return representation; | |
} | |
return null; | |
} | |
/** | |
* @return {@link EPackage} available in the ecore resource | |
*/ | |
private List<EPackage> getEcoreEPackagesFromSession(Session session){ | |
final List<EPackage> result = new ArrayList<EPackage>(); | |
for (Resource resource : session.getSemanticResources()) | |
{ | |
if (resource.getURI().toString().equals(ecoreModelURI.toString())) | |
{ | |
EList<EObject> contents = resource.getContents(); | |
if (contents != null && ! contents.isEmpty()) | |
{ | |
EObject eObject = contents.get(0); | |
if (eObject instanceof EPackage) | |
{ | |
EPackage ePackage = (EPackage) eObject; | |
result.add(ePackage); | |
List<EPackage> subPackages = getSubPackages(ePackage); | |
if (! subPackages.isEmpty()) | |
{ | |
result.addAll(subPackages); | |
} | |
} | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* @param parent the parent {@link EPackage} | |
* @return a {@link List} of sub packages | |
*/ | |
private List<EPackage> getSubPackages(EPackage parent){ | |
final List<EPackage> result = new ArrayList<EPackage>(); | |
EList<EPackage> eSubpackages = parent.getESubpackages(); | |
if (eSubpackages != null && ! eSubpackages.isEmpty()) | |
{ | |
result.addAll(eSubpackages); | |
for (EPackage ePackage : eSubpackages) | |
{ | |
List<EPackage> children = getSubPackages(ePackage); | |
if (! children.isEmpty()) | |
{ | |
result.addAll(children); | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* Create the representation file for the ecore | |
* @param monitor {@link IProgressMonitor} to trace operation | |
*/ | |
private Session createRepresentationFile(IProgressMonitor monitor){ | |
monitor.subTask("create the representation model..."); //$NON-NLS-1$ | |
/** Get the project containing the ecore model**/ | |
IProject project = this.representationProject; /*getRepresentationProject();*/ | |
/** Create the aird file and create a Session **/ | |
final Session session = createAird(project, representationFileURI, monitor); | |
if (session == null) | |
{// Session is not created | |
throw new RuntimeException("Can't create a session for " + representationFileURI.toString()); | |
} | |
else | |
{// Session created with success | |
/** prepare session ressource set for ecore models **/ | |
session.getTransactionalEditingDomain().getResourceSet() | |
.getURIConverter().getURIMap() | |
.putAll(EcorePlugin.computePlatformURIMap()); | |
} | |
// Command to link ecore model to the session | |
AddSemanticResourceCommand addSemanticResourceCommand = new AddSemanticResourceCommand(session, ecoreModelURI, new SubProgressMonitor(monitor, 1)); | |
// Command to select Viewpoint in the current session | |
ChangeViewpointSelectionCommand changeViewpointSelectionCommand = new ChangeViewpointSelectionCommand(session, new ViewpointSelectionCallback(), viewpoints, | |
Collections.<Viewpoint> emptySet(), new SubProgressMonitor(monitor, 1)); | |
// Execute the 2 created commands bellow | |
CompoundCommand compoundCommand = new CompoundCommand("Link resources to representation"); //$NON-NLS-1$ | |
compoundCommand.append(addSemanticResourceCommand); | |
compoundCommand.append(changeViewpointSelectionCommand); | |
session.getTransactionalEditingDomain().getCommandStack().execute(compoundCommand); | |
return session; | |
} | |
/** | |
* Reworked code from org.eclipse.emf.ecoretools.design.wizard.EcoreModelingProjectCreationOperation.createAird(IProject, URI, IProgressMonitor) | |
*/ | |
public static Session createAird(IProject project, URI representationsURI, IProgressMonitor monitor) { | |
Session session = null; | |
// Get the corresponding modeling project | |
Option<ModelingProject> modelingProject = ModelingProject.asModelingProject(project); | |
if (modelingProject.some()) | |
{ // If project is a modeling project, then get it session | |
session = modelingProject.get().getSession(); | |
} | |
else | |
{// Else, create a new session | |
SessionCreationOperation sessionCreationOperation = new DefaultLocalSessionCreationOperation(representationsURI, monitor); | |
try { | |
sessionCreationOperation.execute(); | |
session = sessionCreationOperation.getCreatedSession(); | |
} catch (CoreException e) { | |
throw new RuntimeException("Can't create session for " + representationsURI, e); | |
} | |
} | |
return session; | |
} | |
/** | |
* Compute the representation file {@link URI}. This file will be created near of ecore model | |
* @return the representation file {@link URI} | |
*/ | |
private URI getRepresentationUri(String fileName){ | |
String stringRepresentationURI = ""; | |
if (isFqnFileName(fileName)) | |
{ | |
stringRepresentationURI = fileName; | |
} | |
else | |
{ | |
URI ecoreUriWithoutFileExtension = this.ecoreModelURI.trimFileExtension(); | |
if (ecoreUriWithoutFileExtension != null && ecoreUriWithoutFileExtension.segmentCount() > 1) | |
{ | |
for (int i = 1; i < ecoreUriWithoutFileExtension.segments().length - 1; i++) | |
{ | |
stringRepresentationURI += "/" + ecoreUriWithoutFileExtension.segments()[i]; | |
} | |
stringRepresentationURI += "/" + this.representationFileName; | |
} | |
else | |
{ | |
throw new RuntimeException("Ecore URI is not valid"); | |
} | |
} | |
if (stringRepresentationURI.length() > 0) | |
return URI.createPlatformResourceURI(stringRepresentationURI, true); | |
else | |
throw new RuntimeException("Error on creating representation URI"); | |
} | |
/** | |
* Check if fileName value is valid. If it is not the case, this method return ecore model file name + ".aird" | |
* @param fileName representation file name. This parameter accept <code> null <code/> value | |
* @param ecoreURI {@link URI} of the ecore model | |
* @return a valid representation file name | |
*/ | |
private String getRepresentationFileName(String fileName){ | |
// TODO: implement it | |
if (fileName == null || (fileName != null && fileName.trim().length() <1 )) | |
{ | |
URI ecoreUriWithoutFileExtension = this.ecoreModelURI.trimFileExtension(); | |
if (ecoreUriWithoutFileExtension != null && ecoreUriWithoutFileExtension.segmentCount() > 1) | |
{ | |
String ecoreModelName = ecoreUriWithoutFileExtension.lastSegment(); | |
ecoreModelName += "." +_AIRD_FILE_EXTENSION; | |
return ecoreModelName; | |
} | |
else | |
{ | |
throw new RuntimeException("Ecore file URI is not valid"); | |
} | |
} | |
else | |
{ | |
boolean fqnFileName = isFqnFileName(fileName); | |
if (fqnFileName) | |
{ | |
String[] segments = fileName.split("/"); | |
String lastSegment = segments[segments.length - 1]; | |
if (lastSegment.contains(_AIRD_FILE_EXTENSION)) | |
return lastSegment; | |
else | |
return lastSegment + "." +_AIRD_FILE_EXTENSION; | |
} | |
} | |
return fileName; | |
} | |
/** | |
* @return the {@link IProject} containing the ecore model | |
*/ | |
private IProject getRepresentationProject(String fileName){ | |
String projectName = null; | |
List<String> foldersToCreate = new ArrayList<String>(); | |
if (isFqnFileName(fileName)) | |
{/* The file name provided by user is like: /PluginID/folders/filename.aird | |
* In this case, the project and folder will be created if they are not available */ | |
String[] segments = fileName.split("/"); | |
projectName = segments[0]; | |
// create the list of folders to create | |
for (int i = 1; i < segments.length - 1; i++) | |
{ | |
foldersToCreate.add(segments[i]); | |
} | |
} | |
else | |
{// The file name provided by user is like: filename.aird | |
// FIXME: Check id we use the well segment | |
if (ecoreModelURI.isPlatform()) | |
{// Case of platform URI (Plug-in or Resource URI) | |
projectName = ecoreModelURI.segment(1); | |
} | |
else | |
{// Case of hierarchical URI. Only URI FQN like are handled. | |
projectName = ecoreModelURI.segment(0); | |
} | |
} | |
// Get/create the project from/into the workspace | |
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); | |
NullProgressMonitor NPM = new NullProgressMonitor(); | |
try { | |
if (! project.exists()) | |
{ | |
project.create(NPM); | |
} | |
project.open(NPM); | |
} catch (CoreException e) { | |
throw new RuntimeException("Project with name : " + projectName + " can't be localized", e); | |
} | |
// Create folders if needed | |
if (! foldersToCreate.isEmpty()) | |
{ | |
IFolder currentFolder = null; | |
for (String folderName : foldersToCreate) | |
{ | |
if (currentFolder == null) | |
{// Case of the first iteration, get the folder from the project | |
currentFolder = project.getFolder(folderName); | |
} | |
else | |
{// Case of the other iterations, get the folder from it parent folder | |
currentFolder = currentFolder.getFolder(folderName); | |
} | |
if (! currentFolder.exists()) | |
{ // Create the folder if it is was not created yet. | |
try { | |
currentFolder.create(true, true, NPM); | |
} catch (CoreException e) { | |
throw new RuntimeException("Can't create folder : " + currentFolder , e); | |
} | |
} | |
} | |
} | |
return project; | |
} | |
/** | |
* Initialize Viewpoints list | |
*/ | |
private void initViewpointsList(){ | |
// Step 1: initialize Viewpoint list | |
for (Viewpoint viewpoint : ViewpointRegistry.getInstance().getViewpoints()) | |
{ | |
if (viewpoint.getName().equals(VIEWPOINT_ECORE_DESIGN)) | |
{ | |
viewpoints.add(viewpoint); | |
// At this state of work, we handle only Design viewpoint for ecore model | |
break; | |
} | |
} | |
// Step 2: initialize Representation list | |
if (! viewpoints.isEmpty()) | |
{ | |
for (Viewpoint viewpoint : viewpoints) | |
{ | |
EList<RepresentationDescription> ownedRepresentations = viewpoint.getOwnedRepresentations(); | |
if (ownedRepresentations != null && ! ownedRepresentations.isEmpty()) | |
{ | |
for (RepresentationDescription representationDescription : ownedRepresentations) | |
{ | |
if (representationDescription.getName().equals(REPRESENTATION__ENTITIES_DIAGRAM) | |
|| representationDescription.getName().equals(REPRESENTATION__DOCUMENTATION_TABLE)) | |
{ | |
representations.add(representationDescription); | |
} | |
} | |
} | |
} | |
} | |
} | |
} |