Attachment #36141 for bug #131365




import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.gmf.gmfgraph.Canvas;
import org.eclipse.gmf.gmfgraph.DiagramElement;
import org.eclipse.gmf.gmfgraph.FigureGallery;
import org.eclipse.gmf.gmfgraph.util.RuntimeFQNSwitch;
import org.eclipse.gmf.graphdef.codegen.StandaloneGenerator;

	public static final String OPTION_MAIN_PACKAGE_NAME = SECTION_ID + ".mainPackageName";
	public static final String OPTION_NEEDS_MAP_MODE = SECTION_ID + ".needsMapMode";
	public static final String OPTION_INPUT_RESOURCE_FULL_PATH = SECTION_ID + ".inputResource";
	public static final String OPTION_OUTPUT_GALLERY_FULL_PATH = SECTION_ID + ".outputGallery";
	public static final String OPTION_OUTPUT_DIAGRAM_ELEMENTS_FULL_PATH = SECTION_ID + ".outputDiagramElements";
	
	private TemplateOption myPackageNameOption;
	private FileNameOption myInputPathOption;
	private FileNameOption myOutputGalleryPathOption;
	private FileNameOption myOutputDiagramElementsPathOption;
	private final InputValidationState myCachedInputValidationState;
	private ManifestElement[] myRequiredBundles;
	
	public ConverterSection(){
		setPageCount(THE_ONLY_PAGE_INDEX + 1);
		myPackageNameOption = addOption(OPTION_MAIN_PACKAGE_NAME, "Generate figures package", null, THE_ONLY_PAGE_INDEX);
		myInputPathOption = addFileNameOption(false, OPTION_INPUT_RESOURCE_FULL_PATH, "Input GMFGraph instance", "", THE_ONLY_PAGE_INDEX);
		myOutputGalleryPathOption = addFileNameOption(true, OPTION_OUTPUT_GALLERY_FULL_PATH, "Create Figure Gallery", "", THE_ONLY_PAGE_INDEX);
		myOutputGalleryPathOption.setRequired(false);
		myOutputDiagramElementsPathOption = addFileNameOption(true, OPTION_OUTPUT_DIAGRAM_ELEMENTS_FULL_PATH, "Mirror diagram elements", "", THE_ONLY_PAGE_INDEX);
		myOutputDiagramElementsPathOption.setRequired(false);
		addOption(OPTION_NEEDS_MAP_MODE, "Use IMapMode", false, THE_ONLY_PAGE_INDEX);
		myCachedInputValidationState = new InputValidationState(myOutputGalleryPathOption, myOutputDiagramElementsPathOption);
	}
	
	public void addPages(Wizard wizard) {

		wizard.addPage(page);
		markPagesAdded();
		validateOptions(myPackageNameOption);
		validateOptions(myInputPathOption);
		validateOptions(myOutputGalleryPathOption);
	}

	public IPluginReference[] getDependencies(String schemaVersion) {

	}

	protected void generateFiles(IProgressMonitor monitor) throws CoreException {
		Resource input = loadResource(myInputPathOption.getText());
		FigureGallery[] figures = findFigures(input);
		assert(figures.length > 0);
		StandaloneGenerator.Config config = new StandaloneGeneratorConfigAdapter(this);
		StandaloneGenerator generator = new StandaloneGenerator(figures, config, new RuntimeFQNSwitch());
		generator.setSkipPluginStructure(false);

			readRequiredBundles();
			// XXX readBuildProperties() and use getNewFiles to propagate
			// XXX readPluginProperties(), use ??? 
			if (!generator.getRunStatus().isOK()){
				throw new CoreException(generator.getRunStatus());
			}
			createSeparateResources(generator.getGenerationInfo(), input);
		} catch (InterruptedException e) {
			String message = e.getMessage();
			if (message == null){

			// perhaps, don't need to treat this as error? 
			throw new CoreException(new Status(IStatus.ERROR, MY_PLUGIN_ID, 0, "Failed to read generated manifest.mf", ex));
		} finally {
			input.unload();
		}
		if (!generator.getRunStatus().isOK()){
			throw new CoreException(generator.getRunStatus());
		}
		createFigureGallery(generator.getGenerationInfo());
	}
	
	private void createSeparateResources(StandaloneGenerator.GenerationInfo info, Resource input) throws CoreException {
		if (shouldGenerate(myOutputGalleryPathOption)){
			String figureGalleryPath = myOutputGalleryPathOption.getText();
			ResourceSet separateResourceSet = new ResourceSetImpl();
			StandaloneGalleryConverter converter = new StandaloneGalleryConverter(info);
			
			Resource galleryResource = separateResourceSet.createResource(URI.createFileURI(figureGalleryPath));
			galleryResource.getContents().add(converter.convertFigureGallery());
			
			Resource diagramElementsResource = null;
			if (shouldGenerate(myOutputDiagramElementsPathOption)){
				Canvas mirror = converter.mirrorDiagramElements(Collections.singleton(input));
				if (mirror != null){
					diagramElementsResource = separateResourceSet.createResource(URI.createFileURI(myOutputDiagramElementsPathOption.getText()));
					diagramElementsResource.getContents().add(mirror);
				}
			}
			
			try {
				galleryResource.save(null);
				if (diagramElementsResource != null){
					diagramElementsResource.save(null);
				}
			} catch (IOException e) {
				throw new CoreException(new Status(IStatus.ERROR, MY_PLUGIN_ID, 0, e.getMessage(), e));
						IStatus.ERROR, MY_PLUGIN_ID, 0, e.getMessage(), e
				));
			}
		}
	}
	
	private boolean shouldGenerate(FileNameOption option){
		return option.isEnabled() && !option.isEmpty();
	}
	
	private void readRequiredBundles() throws CoreException, IOException {
		try {
			IFile f = findGeneratedManifest();

	private FigureGallery[] findFigures(Resource resource) {
		return new FigureFinder().findFigures(resource);
	}
	
	public String getPluginActivatorClassFQN(){
		return model instanceof IPluginModel ? ((IPluginModel)model).getPlugin().getClassName() : null;
	}

			//does not affect state
			return;
		}
		if (validateInputPath() && validatePackageName() &&  
			validateOutputOption(myOutputDiagramElementsPathOption) && 
			validateOutputOption(myOutputGalleryPathOption)){   
				resetPageState();
			return;
		}
		if (!validateOutputGalleryPath()){
			return;
		}
		resetPageState();
	}

	public boolean isDependentOnParentWizard() {

	private boolean validateInputPath() {
		if (myInputPathOption.isEmpty()){
			flagMissingRequiredOption(myInputPathOption);
			myOutputDiagramElementsPathOption.setEnabled(false);
			myOutputGalleryPathOption.setEnabled(false);
			return false;
		}
		String path = myInputPathOption.getText();
		myCachedInputValidationState.updateInput(path);
		if (!myCachedInputValidationState.isValid()){
			flagError(myCachedInputValidationState.getErrorMessage());
			getTheOnlyPage().setErrorMessage(myCachedInputValidationState.getErrorMessage());
			return false;
		}
		return true;
	}
	
	private boolean validateOutputOption(FileNameOption option) {
		if (!option.isEnabled()){
			return false;
		}
		if (!validateMirrorDiagramWithoutFigureGallery()){
			return false;
		}
		if (option.isEmpty()){
			//optional -- ok
			return true;
		}
		String path = option.getText();
		return validatePath(path);
	}

	private boolean validateMirrorDiagramWithoutFigureGallery(){
		if (!myOutputDiagramElementsPathOption.isEmpty()){
			if (myOutputGalleryPathOption.isEmpty() || myOutputDiagramElementsPathOption.getText().equals(myOutputGalleryPathOption.getText())){
				flagError("In order to mirror diagram elements you have to generate separate figure gallery");
				return false;
			}
		}
		return true;
	}
	
	private boolean validatePath(String path){
		try {
			return URI.createFileURI(path) != null; 
		} catch (IllegalArgumentException e){
			flagError(MessageFormat.format("Path {0} is invalid", new Object[] {path}));
			getTheOnlyPage().setPageComplete(false);
			getTheOnlyPage().setErrorMessage(message);
			return false;
		}
		return true;
	}
	
	private WizardPage getTheOnlyPage() {
		return getPage(THE_ONLY_PAGE_INDEX);
	}
	
	private void flagError(String message){
		getTheOnlyPage().setPageComplete(false);
		getTheOnlyPage().setErrorMessage(message);
	}
	
	private static Resource loadResource(String path){
		Resource resource = new ResourceSetImpl().createResource(URI.createFileURI(path));
		try {

		}
	}
	
	private static class InputValidationState {
		private String myCachedPath;
		private boolean myCachedIsValid;
		private String myCachedErrorMessage;
		private boolean myHasDiagramElement;
		private boolean myHasFigure;
		private final FileNameOption myDiagramElementsOption;
		private final FileNameOption myGalleryOption;
		
		public InputValidationState(FileNameOption galleryOption, FileNameOption diagramElementsOption){
			myGalleryOption = galleryOption;
			myDiagramElementsOption = diagramElementsOption;
		}
		
		public void updateInput(String path){
			if (myCachedPath == null || !myCachedPath.equals(path)){
				myCachedPath = path;
				validateInputPath(path);
				myGalleryOption.setEnabled(myHasFigure);
				myDiagramElementsOption.setEnabled(myHasDiagramElement);
			}
		}
		
		public boolean isValid(){
			return myHasFigure;
		}
		
		public String getErrorMessage(){
			return myCachedErrorMessage;
		}
		
		private void validateInputPath(String path) {
			myHasDiagramElement = false;
			myHasFigure = false;
				if (next instanceof Figure){
					return true;
				}
			}
			return false;
		}
		
		private boolean validateInputPath(String path) {
			myCachedErrorMessage = null;

			if (path == null || !new File(path).exists()){
				myCachedErrorMessage = MessageFormat.format("Can not find file {0}", new Object[] {path});
				return;
			}
			
			Resource resource = loadResource(path);
			boolean isValid = resource != null && hasAtLeastOneFigure(resource);
			if (resource != null){
				classifyContents(resource);
			}
			
			if (!myHasFigure){
				myCachedErrorMessage = MessageFormat.format("File {0} does not contain any figure definitions", new Object[] {path});
				return false;
			}
			return true;
		}

		private void classifyContents(Resource resource){
			myHasDiagramElement = false;
			myHasFigure = false;
			for (TreeIterator contents = resource.getAllContents(); contents.hasNext();){
				EObject next = (EObject) contents.next();
				if (next instanceof FigureGallery){
					if (!myHasFigure){
						FigureGallery nextGallery = (FigureGallery) next;
						myHasFigure = !nextGallery.getFigures().isEmpty();
					}
					contents.prune();
				}
				if (next instanceof DiagramElement){
					myHasDiagramElement = true;
					contents.prune();
				}
				if (myHasDiagramElement && myHasFigure){
					break;
				}
			}
		}
		
	}
}

Lines 21-26 Link Here

(-)src/org/eclipse/gmf/internal/graphdef/codegen/ui/GeneratePluginAction.java (-28 / +46 lines)
21	import org.eclipse.core.runtime.Status;	21	import org.eclipse.core.runtime.Status;
22	import org.eclipse.core.runtime.jobs.Job;	22	import org.eclipse.core.runtime.jobs.Job;
23	import org.eclipse.emf.common.util.URI;	23	import org.eclipse.emf.common.util.URI;
		24	import org.eclipse.emf.ecore.EObject;
24	import org.eclipse.emf.ecore.resource.Resource;	25	import org.eclipse.emf.ecore.resource.Resource;
25	import org.eclipse.emf.ecore.resource.ResourceSet;	26	import org.eclipse.emf.ecore.resource.ResourceSet;
26	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;	27	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
Lines 67-72 Link Here
67	generator.setSkipPluginStructure(false);	68	generator.setSkipPluginStructure(false);
68		69
69	new Job(action.getText()) {	70	new Job(action.getText()) {
		71	private IContainer myResourcesContainer;
70	{	72	{
71	// setUser(true); FIXME fixed after M5, uncoment when switching to M6	73	// setUser(true); FIXME fixed after M5, uncoment when switching to M6
72	}	74	}
Lines 77-85 Link Here
77	if (!generator.getRunStatus().isOK()) {	79	if (!generator.getRunStatus().isOK()) {
78	return generator.getRunStatus();	80	return generator.getRunStatus();
79	}	81	}
80	IFile galleryFile = decideOnDestinationFile();	82	StandaloneGalleryConverter converter = new StandaloneGalleryConverter(generator.getGenerationInfo());
81	Resource r = rs.createResource(URI.createPlatformResourceURI(galleryFile.getFullPath().toString()));	83
82	return saveNewFigureGallery(r, generator.getGenerationInfo());	84	IStatus result = saveToFile(decideOnDestinationFile("bundled"), converter.convertFigureGallery());
		85	if (result.isOK()){
		86	result = saveToFile(decideOnDestinationFile("mirrored"), converter.mirrorDiagramElements(rs.getResources()));
		87	}
		88	return result;
83	} catch (InterruptedException e) {	89	} catch (InterruptedException e) {
84	return Status.CANCEL_STATUS;	90	return Status.CANCEL_STATUS;
85	} finally {	91	} finally {
Lines 89-123 Link Here
89	}	95	}
90	}	96	}
91		97
92	private IFile decideOnDestinationFile() {	98	private IFile decideOnDestinationFile(String baseName) {
93	StandaloneGenerator.Config config = generator.getGenerationInfo().getConfig();	99	final IPath basePath = new Path(baseName);
94	IProject p = ResourcesPlugin.getWorkspace().getRoot().getProject(config.getPluginID());
95	assert p.exists(); // generator.runStatus.ok makes us believe
96	IContainer fileContainer = p;
97	IFolder modelsFolder = p.getFolder("models");
98	if (!modelsFolder.exists()) {
99	try {
100	modelsFolder.create(true, true, new NullProgressMonitor());
101	fileContainer = modelsFolder;
102	} catch (CoreException ex) {
103	// ignore or log?
104	}
105	}
106	final IPath baseName = new Path("bundled");
107	final String ext = "gmfgraph";	100	final String ext = "gmfgraph";
108	IFile galleryFile = fileContainer.getFile(baseName.addFileExtension(ext));	101	IFile resultFile = getResourcesContainer().getFile(basePath.addFileExtension(ext));
109	for (int i = 1; galleryFile.exists(); i++) {	102	for (int i = 1; resultFile.exists(); i++) {
110	galleryFile = fileContainer.getFile(new Path(baseName.lastSegment() + String.valueOf(i)).addFileExtension(ext));	103	resultFile = getResourcesContainer().getFile(new Path(basePath.lastSegment() + String.valueOf(i)).addFileExtension(ext));
		104	}
		105	return resultFile;
		106	}
		107
		108	private IContainer getResourcesContainer(){
		109	if (myResourcesContainer == null){
		110	IProject p = ResourcesPlugin.getWorkspace().getRoot().getProject(getConfig().getPluginID());
		111	assert p.exists(); // generator.runStatus.ok makes us believe
		112	myResourcesContainer = p;
		113	IFolder modelsFolder = p.getFolder("models");
		114	if (!modelsFolder.exists()) {
		115	try {
		116	modelsFolder.create(true, true, new NullProgressMonitor());
		117	myResourcesContainer = modelsFolder;
		118	} catch (CoreException ex) {
		119	// ignore or log?
		120	}
		121	}
111	}	122	}
112	return galleryFile;	123	return myResourcesContainer;
		124	}
		125
		126	private StandaloneGenerator.Config getConfig(){
		127	return generator.getGenerationInfo().getConfig();
113	}	128	}
114		129
115	private IStatus saveNewFigureGallery(Resource galleryResource, StandaloneGenerator.GenerationInfo info) {	130	private IStatus saveToFile(IFile outputFile, EObject root) {
116	galleryResource.getContents().add(new StandaloneGalleryConverter().convertFigureGallery(info));	131	if (root != null){
117	try {	132	Resource outputResource = rs.createResource(URI.createPlatformResourceURI(outputFile.getFullPath().toString()));
118	galleryResource.save(null);	133	outputResource.getContents().add(root);
119	} catch (IOException e) {	134	try {
120	return new Status(IStatus.ERROR, "org.eclipse.gmf.graphdef.codegen.ui", 0, e.getMessage(), e);	135	outputResource.save(null);
		136	} catch (IOException e) {
		137	return new Status(IStatus.ERROR, "org.eclipse.gmf.graphdef.codegen.ui", 0, e.getMessage(), e);
		138	}
121	}	139	}
122	return Status.OK_STATUS;	140	return Status.OK_STATUS;
123	}	141	}

Lines 12-19 Link Here

(-)src/org/eclipse/gmf/internal/graphdef/codegen/ui/StandaloneGalleryConverter.java (-4 / +69 lines)
12		12
13	package org.eclipse.gmf.internal.graphdef.codegen.ui;	13	package org.eclipse.gmf.internal.graphdef.codegen.ui;
14		14
		15	import java.util.Collection;
15	import java.util.Enumeration;	16	import java.util.Enumeration;
		17	import java.util.HashSet;
		18	import java.util.Iterator;
16		19
		20	import org.eclipse.emf.ecore.EObject;
		21	import org.eclipse.emf.ecore.EReference;
		22	import org.eclipse.emf.ecore.resource.Resource;
		23	import org.eclipse.emf.ecore.util.EcoreUtil;
		24	import org.eclipse.gmf.gmfgraph.Canvas;
17	import org.eclipse.gmf.gmfgraph.ConnectionFigure;	25	import org.eclipse.gmf.gmfgraph.ConnectionFigure;
18	import org.eclipse.gmf.gmfgraph.CustomFigure;	26	import org.eclipse.gmf.gmfgraph.CustomFigure;
19	import org.eclipse.gmf.gmfgraph.DecorationFigure;	27	import org.eclipse.gmf.gmfgraph.DecorationFigure;
Lines 23-42 Link Here
23	import org.eclipse.gmf.graphdef.codegen.StandaloneGenerator;	31	import org.eclipse.gmf.graphdef.codegen.StandaloneGenerator;
24		32
25	public class StandaloneGalleryConverter {	33	public class StandaloneGalleryConverter {
26	public FigureGallery convertFigureGallery(StandaloneGenerator.GenerationInfo generationInfo){	34	private final StandaloneGenerator.GenerationInfo myGenerationInfo;
		35	private final DiagramElementsCopier myDiagramElementsCopier;
		36
		37	public StandaloneGalleryConverter(StandaloneGenerator.GenerationInfo generationInfo){
		38	myGenerationInfo = generationInfo;
		39	myDiagramElementsCopier = new DiagramElementsCopier();
		40	}
		41
		42	public FigureGallery convertFigureGallery(){
27	FigureGallery result = GMFGraphFactory.eINSTANCE.createFigureGallery();	43	FigureGallery result = GMFGraphFactory.eINSTANCE.createFigureGallery();
28	String generatedBundle = generationInfo.getConfig().getPluginID();	44	String generatedBundle = myGenerationInfo.getConfig().getPluginID();
29	result.setImplementationBundle(generatedBundle);	45	result.setImplementationBundle(generatedBundle);
30		46
31	for (Enumeration originalFigures = generationInfo.getProcessedFigures(); originalFigures.hasMoreElements();){	47	for (Enumeration originalFigures = myGenerationInfo.getProcessedFigures(); originalFigures.hasMoreElements();){
32	Figure nextOriginal = (Figure) originalFigures.nextElement();	48	Figure nextOriginal = (Figure) originalFigures.nextElement();
33	String nextConvertedFqn = generationInfo.getGeneratedClassFQN(nextOriginal);	49	String nextConvertedFqn = myGenerationInfo.getGeneratedClassFQN(nextOriginal);
34	CustomFigure custom = createCustomFigure(nextOriginal);	50	CustomFigure custom = createCustomFigure(nextOriginal);
35	custom.setName(nextOriginal.getName());	51	custom.setName(nextOriginal.getName());
36	custom.setBundleName(generatedBundle);	52	custom.setBundleName(generatedBundle);
37	custom.setQualifiedClassName(nextConvertedFqn);	53	custom.setQualifiedClassName(nextConvertedFqn);
38		54
39	result.getFigures().add(custom);	55	result.getFigures().add(custom);
		56	myDiagramElementsCopier.registerSubstitution(nextOriginal, custom);
		57	}
		58	return result;
		59	}
		60
		61	public Canvas mirrorDiagramElements(Collection resources){
		62	Canvas result = null;
		63	for (Iterator it = resources.iterator(); it.hasNext();){
		64	Resource next = (Resource)it.next();
		65	if (!next.getContents().isEmpty()){
		66	EObject root = (EObject) next.getContents().get(0);
		67	if (root instanceof Canvas){
		68	Canvas original = (Canvas)root;
		69	if (result == null){
		70	result = GMFGraphFactory.eINSTANCE.createCanvas();
		71	result.setName(original.getName());
		72	}
		73	Collection children = myDiagramElementsCopier.copyAll(original.getChildren());
		74	Collection compartments = myDiagramElementsCopier.copyAll(original.getCompartments());
		75	Collection labels = myDiagramElementsCopier.copyAll(original.getLabels());
		76	Collection nodes = myDiagramElementsCopier.copyAll(original.getNodes());
		77
		78	result.getChildren().addAll(children);
		79	result.getCompartments().addAll(compartments);
		80	result.getLabels().addAll(labels);
		81	result.getNodes().addAll(nodes);
		82	}
		83	}
		84	}
		85	if (result != null && !result.eContents().isEmpty()){
		86	myDiagramElementsCopier.copyReferences();
40	}	87	}
41	return result;	88	return result;
42	}	89	}
Lines 51-55 Link Here
51	}	98	}
52	return factory.createCustomFigure();	99	return factory.createCustomFigure();
53	}	100	}
		101
		102	private static class DiagramElementsCopier extends EcoreUtil.Copier {
		103	private final HashSet myOriginalFigures = new HashSet();
		104
		105	public void registerSubstitution(Figure original, CustomFigure substituted){
		106	put(original, substituted);
		107	myOriginalFigures.add(original);
		108	}
		109
		110	protected void copyReference(EReference eReference, EObject eObject, EObject copyEObject) {
		111	if (EcoreUtil.isAncestor(myOriginalFigures, eObject)){
		112	//no such features in the CustomFigure's
		113	return;
		114	}
		115	super.copyReference(eReference, eObject, copyEObject);
		116	}
		117
		118	}
54		119
55	}	120	}

Return to bug 131365