/******************************************************************************* | |
* Copyright (c) 2008 The University of York. | |
* This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License 2.0 | |
* which is available at https://www.eclipse.org/legal/epl-2.0/ | |
* | |
* Contributors: | |
* Dimitrios Kolovos - initial API and implementation | |
******************************************************************************/ | |
package org.eclipse.epsilon.emf.dt; | |
import java.io.ByteArrayInputStream; | |
import java.io.InputStream; | |
import java.lang.reflect.InvocationTargetException; | |
import org.eclipse.core.resources.IFile; | |
import org.eclipse.core.resources.IResource; | |
import org.eclipse.core.resources.ResourcesPlugin; | |
import org.eclipse.core.runtime.CoreException; | |
import org.eclipse.core.runtime.IProgressMonitor; | |
import org.eclipse.core.runtime.IStatus; | |
import org.eclipse.core.runtime.Path; | |
import org.eclipse.core.runtime.Status; | |
import org.eclipse.emf.common.util.URI; | |
import org.eclipse.epsilon.common.dt.util.LogUtil; | |
import org.eclipse.epsilon.common.util.StringProperties; | |
import org.eclipse.epsilon.emc.emf.EmfModel; | |
import org.eclipse.epsilon.eol.exceptions.models.EolModelLoadingException; | |
import org.eclipse.epsilon.eol.models.Model; | |
import org.eclipse.jface.dialogs.MessageDialog; | |
import org.eclipse.jface.operation.IRunnableWithProgress; | |
import org.eclipse.jface.viewers.ISelection; | |
import org.eclipse.jface.viewers.IStructuredSelection; | |
import org.eclipse.jface.wizard.Wizard; | |
import org.eclipse.ui.INewWizard; | |
import org.eclipse.ui.IWorkbench; | |
import org.eclipse.ui.IWorkbenchPage; | |
import org.eclipse.ui.IWorkbenchWizard; | |
import org.eclipse.ui.PartInitException; | |
import org.eclipse.ui.PlatformUI; | |
import org.eclipse.ui.ide.IDE; | |
/** | |
* This is a sample new wizard. Its role is to create a new file | |
* resource in the provided container. If the container resource | |
* (a folder or a project) is selected in the workspace | |
* when the wizard is opened, it will accept it as the target | |
* container. The wizard creates one file with the extension | |
* "ecore". If a sample multi-page editor (also available | |
* as a template) is registered for the same extension, it will | |
* be able to open it. | |
*/ | |
public class NewEmfModelWizard extends Wizard implements INewWizard { | |
protected NewEmfModelWizardPage page; | |
protected ISelection selection; | |
/** | |
* Constructor for NewEmfModelWizard. | |
*/ | |
public NewEmfModelWizard() { | |
super(); | |
setNeedsProgressMonitor(true); | |
} | |
/** | |
* Adding the page to the wizard. | |
*/ | |
@Override | |
public void addPages() { | |
setWindowTitle("New EMF Model"); | |
page = new NewEmfModelWizardPage(selection,null,null,"EMF",null); | |
addPage(page); | |
} | |
/** | |
* This method is called when 'Finish' button is pressed in | |
* the wizard. We will create an operation and run it | |
* using wizard as execution context. | |
*/ | |
@Override | |
public boolean performFinish() { | |
final String containerName = page.getContainerName(); | |
final String fileName = page.getFileName(); | |
final String rootClass = page.getRootClass(); | |
final String metamodelUri = page.getMetaModelUri(); | |
IRunnableWithProgress op = monitor -> { | |
try { | |
doFinish(containerName, fileName, metamodelUri, rootClass, monitor); | |
} catch (CoreException e) { | |
throw new InvocationTargetException(e); | |
} finally { | |
monitor.done(); | |
} | |
}; | |
try { | |
getContainer().run(true, false, op); | |
} catch (InterruptedException e) { | |
return false; | |
} catch (InvocationTargetException e) { | |
Throwable realException = e.getTargetException(); | |
MessageDialog.openError(getShell(), "Error", realException.getMessage()); | |
return false; | |
} | |
return true; | |
} | |
/** | |
* The worker method. It will find the container, create the | |
* file if missing or just replace its contents, and open | |
* the editor on the newly created file. | |
*/ | |
private void doFinish( | |
String containerName, | |
String fileName, | |
String metamodelUri, | |
String rootClass, | |
IProgressMonitor monitor) | |
throws CoreException { | |
EmfModel model = new EmfModel(); | |
StringProperties properties = new StringProperties(); | |
properties.put(EmfModel.PROPERTY_MODEL_URI, URI.createPlatformResourceURI(containerName + "/" + fileName, true)); | |
properties.put(EmfModel.PROPERTY_METAMODEL_URI, metamodelUri); | |
properties.put(Model.PROPERTY_READONLOAD, false); | |
try { | |
model.load(properties); | |
} catch (EolModelLoadingException e) { | |
LogUtil.log(e); | |
} | |
try { | |
model.createInstance(rootClass); | |
} | |
catch (Exception ex){ | |
LogUtil.log(ex); | |
} | |
model.store(); | |
model.dispose(); | |
ResourcesPlugin.getWorkspace().getRoot().refreshLocal(IResource.DEPTH_INFINITE,null); | |
final IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(containerName + "/" + fileName)); | |
// Open the new model for editing | |
getShell().getDisplay().asyncExec(() -> { | |
IWorkbenchPage page = | |
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); | |
try { | |
IDE.openEditor(page, file, true); | |
} catch (PartInitException e) { | |
LogUtil.log(e); | |
} | |
}); | |
//PlatformUI.getWorkbench().getActiveWorkbenchWindow() | |
/* | |
// create a sample file | |
monitor.beginTask("Creating " + fileName, 2); | |
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); | |
IResource resource = root.findMember(new Path(containerName)); | |
if (!resource.exists() || !(resource instanceof IContainer)) { | |
throwCoreException("Container \"" + containerName + "\" does not exist."); | |
} | |
IContainer container = (IContainer) resource; | |
final IFile file = container.getFile(new Path(fileName)); | |
try { | |
InputStream stream = openContentStream(); | |
if (file.exists()) { | |
file.setContents(stream, true, true, monitor); | |
} else { | |
file.create(stream, true, monitor); | |
} | |
stream.close(); | |
} catch (IOException e) { | |
} | |
monitor.worked(1); | |
monitor.setTaskName("Opening file for editing..."); | |
getShell().getDisplay().asyncExec(new Runnable() { | |
public void run() { | |
IWorkbenchPage page = | |
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); | |
try { | |
IDE.openEditor(page, file, true); | |
} catch (PartInitException e) { | |
} | |
} | |
}); | |
monitor.worked(1); | |
*/ | |
} | |
/** | |
* We will initialize file contents with a sample text. | |
*/ | |
protected InputStream openContentStream() { | |
String contents = | |
"This is the initial file contents for *.ecore file that should be word-sorted in the Preview page of the multi-page editor"; | |
return new ByteArrayInputStream(contents.getBytes()); | |
} | |
protected void throwCoreException(String message) throws CoreException { | |
IStatus status = | |
new Status(IStatus.ERROR, "org.eclipse.epsilon.perspective", IStatus.OK, message, null); | |
throw new CoreException(status); | |
} | |
/** | |
* We will accept the selection in the workbench to see if | |
* we can initialize from it. | |
* @see IWorkbenchWizard#init(IWorkbench, IStructuredSelection) | |
*/ | |
@Override | |
public void init(IWorkbench workbench, IStructuredSelection selection) { | |
this.selection = selection; | |
} | |
} |