| /******************************************************************************* |
| * Copyright (c) 2011, 2013 Oracle. All rights reserved. |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License 2.0, which accompanies this distribution |
| * and is available at https://www.eclipse.org/legal/epl-2.0/. |
| * |
| * Contributors: |
| * Oracle - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.jpt.jpa.ui.internal.wizards.conversion.java; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.Iterator; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.content.IContentType; |
| import org.eclipse.core.runtime.jobs.ISchedulingRule; |
| import org.eclipse.jface.dialogs.IMessageProvider; |
| import org.eclipse.jface.dialogs.ProgressMonitorDialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.viewers.ViewerFilter; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.jface.wizard.WizardPage; |
| import org.eclipse.jpt.common.core.internal.utility.WorkspaceRunnableAdapter; |
| import org.eclipse.jpt.common.core.resource.ProjectResourceLocator; |
| import org.eclipse.jpt.common.core.resource.xml.JptXmlResource; |
| import org.eclipse.jpt.common.ui.internal.WorkbenchTools; |
| import org.eclipse.jpt.common.ui.internal.swt.bindings.SWTBindingTools; |
| import org.eclipse.jpt.common.ui.internal.swt.widgets.DisplayTools; |
| import org.eclipse.jpt.common.ui.internal.utility.SynchronousUiCommandContext; |
| import org.eclipse.jpt.common.utility.command.Command; |
| import org.eclipse.jpt.common.utility.internal.ObjectTools; |
| import org.eclipse.jpt.common.utility.internal.StringTools; |
| import org.eclipse.jpt.common.utility.internal.iterator.EmptyIterator; |
| import org.eclipse.jpt.common.utility.internal.model.value.SimplePropertyValueModel; |
| import org.eclipse.jpt.common.utility.model.event.PropertyChangeEvent; |
| import org.eclipse.jpt.common.utility.model.listener.PropertyChangeAdapter; |
| import org.eclipse.jpt.common.utility.model.listener.PropertyChangeListener; |
| import org.eclipse.jpt.common.utility.model.value.PropertyValueModel; |
| import org.eclipse.jpt.jpa.core.JpaProject; |
| import org.eclipse.jpt.jpa.core.JpaProjectManager; |
| import org.eclipse.jpt.jpa.core.JpaStructureNode; |
| import org.eclipse.jpt.jpa.core.context.MappingFile; |
| import org.eclipse.jpt.jpa.core.context.orm.EntityMappings; |
| import org.eclipse.jpt.jpa.core.context.persistence.MappingFileRef; |
| import org.eclipse.jpt.jpa.core.context.persistence.Persistence; |
| import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit; |
| import org.eclipse.jpt.jpa.core.context.persistence.PersistenceXml; |
| import org.eclipse.jpt.jpa.core.resource.ResourceMappingFile; |
| import org.eclipse.jpt.jpa.ui.JptJpaUiMessages; |
| import org.eclipse.jpt.jpa.ui.internal.jface.XmlMappingFileViewerFilter; |
| import org.eclipse.jpt.jpa.ui.internal.plugin.JptJpaUiPlugin; |
| import org.eclipse.jpt.jpa.ui.internal.wizards.SelectMappingFileDialog; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Link; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.ide.IDE; |
| |
| public abstract class JavaMetadataConversionWizardPage |
| extends WizardPage |
| { |
| /** |
| * The JPA project can<em>not</em> be <code>null</code>. |
| */ |
| protected final JpaProject jpaProject; |
| |
| /** |
| * The persistence unit can be <code>null</code>. |
| */ |
| protected final PersistenceUnit persistenceUnit; |
| protected final boolean noConvertibleJavaMetadata; |
| |
| private final SimplePropertyValueModel<String> mappingFileNameModel = new SimplePropertyValueModel<String>(); |
| |
| private static final String PAGE_NAME = "JavaMetadataConversion"; //$NON-NLS-1$ |
| public static final String HELP_CONTEXT_ID = JptJpaUiPlugin.instance().getPluginID() + '.' + PAGE_NAME; |
| |
| |
| protected JavaMetadataConversionWizardPage(JpaProject jpaProject, String title, String description) { |
| super(PAGE_NAME); |
| if (jpaProject == null) { |
| throw new NullPointerException(); |
| } |
| this.jpaProject = jpaProject; |
| this.persistenceUnit = this.buildPersistenceUnit(); |
| this.mappingFileNameModel.setValue(this.buildDefaultMappingFileName()); |
| this.setTitle(title); |
| this.setDescription(description); |
| this.noConvertibleJavaMetadata = this.hasNoConvertibleJavaMetadata(); |
| } |
| |
| /** |
| * Return the JPA project's <em>first</em> persistence unit. |
| */ |
| protected PersistenceUnit buildPersistenceUnit() { |
| PersistenceXml persistenceXml = this.jpaProject.getContextRoot().getPersistenceXml(); |
| if (persistenceXml == null) { |
| return null; |
| } |
| Persistence persistence = persistenceXml.getRoot(); |
| if (persistence == null) { |
| return null; |
| } |
| Iterator<PersistenceUnit> stream = persistence.getPersistenceUnits().iterator(); |
| return stream.hasNext() ? stream.next() : null; |
| } |
| |
| protected String buildDefaultMappingFileName() { |
| IPath path = this.buildDefaultMappingFilePath(); |
| return (path == null) ? null : path.toString(); |
| } |
| |
| protected IPath buildDefaultMappingFilePath() { |
| IPath path = this.getFirstMappingFilePath(); |
| return (path == null) ? this.getDefaultMappingFileRuntimPath() : this.convertToRuntimPath(path); |
| } |
| |
| protected abstract IPath getDefaultMappingFileRuntimPath(); |
| |
| /** |
| * Return the JPA project's <em>first</em> mapping file with the |
| * {@link #getMappingFileContentType() default content type}. |
| */ |
| protected IPath getFirstMappingFilePath() { |
| if (this.persistenceUnit == null) { |
| return null; |
| } |
| for (MappingFileRef ref : this.persistenceUnit.getMappingFileRefs()) { |
| MappingFile mappingFile = ref.getMappingFile(); |
| if (mappingFile != null) { |
| IResource file = mappingFile.getResource(); |
| if (file instanceof IFile) { |
| if (this.jpaProject.getJpaFile((IFile) file).getContentType().isKindOf(this.getMappingFileContentType())) { |
| return file.getFullPath(); |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| protected IContentType getMappingFileContentType() { |
| return ResourceMappingFile.Root.CONTENT_TYPE; |
| } |
| |
| protected IPath convertToRuntimPath(IPath path) { |
| ProjectResourceLocator locator = (ProjectResourceLocator) this.jpaProject.getProject().getAdapter(ProjectResourceLocator.class); |
| return locator.getRuntimePath(path); |
| } |
| |
| |
| // ********** missing metadata warning message ********** |
| |
| protected final boolean hasNoConvertibleJavaMetadata() { |
| return ! this.hasConvertibleJavaMetadata(); |
| } |
| |
| protected final boolean hasConvertibleJavaMetadata() { |
| return (this.persistenceUnit != null) && this.hasConvertibleJavaMetadata_(); |
| } |
| |
| /** |
| * Pre-condition: the {@link #persistenceUnit persistence unit} |
| * is not <code>null</code>. |
| */ |
| protected abstract boolean hasConvertibleJavaMetadata_(); |
| |
| protected abstract String getMissingJavaMetadataWarningMessage(); |
| |
| |
| // ********** UI control ********** |
| |
| public void createControl(Composite parent) { |
| Composite composite = new Composite(parent, SWT.NULL); |
| composite.setLayout(new GridLayout()); |
| |
| Label pageLabel = new Label(composite, SWT.NONE); |
| pageLabel.setText(JptJpaUiMessages.JAVA_METADATA_CONVERSION_WIZARD_PAGE_LABEL); |
| pageLabel.setBounds(3, 230, 150, 12); |
| |
| Control mappingFileControl = this.createMappingFileControl(composite); |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| data.heightHint = 58; |
| data.grabExcessHorizontalSpace = true; |
| mappingFileControl.setLayoutData(data); |
| |
| Text noteTextField = new Text(composite, SWT.READ_ONLY | SWT.MULTI | SWT.WRAP); |
| noteTextField.setText(JptJpaUiMessages.JAVA_METADATA_CONVERSION_WARNING); |
| noteTextField.setFont(new Font(composite.getDisplay(), "Arial", 10, SWT.EMBEDDED)); //$NON-NLS-1$ |
| noteTextField.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, true, 1, 1)); |
| |
| this.setControl(composite); |
| |
| // no need to remove this listener, since we build the model ourselves |
| this.mappingFileNameModel.addPropertyChangeListener(PropertyValueModel.VALUE, this.buildMappingFileNameListener()); |
| this.setPageComplete(this.getRootStructureNodes(this.getOrmXmlResource()).hasNext()); |
| } |
| |
| protected Control createMappingFileControl(Composite parent) { |
| Composite composite = new Composite(parent, SWT.NULL); |
| composite.setLayout(new GridLayout(3, false)); |
| |
| Link link = new Link(composite, SWT.LEFT); |
| link.setText(JptJpaUiMessages.JAVA_METADATA_CONVERSION_WIZARD_PAGE_NEW_MAPPING_FILE_LINK); |
| link.setToolTipText(JptJpaUiMessages.JAVA_METADATA_CONVERSION_WIZARD_PAGE_NEW_MAPPING_FILE_LINK_TOOL_TIP); |
| link.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING)); |
| link.addSelectionListener(this.buildMappingFileLinkListener()); |
| |
| Text nameTextField = new Text(composite, SWT.SEARCH | SWT.SINGLE); |
| GridData gridData = new GridData(GridData.FILL_HORIZONTAL); |
| gridData.grabExcessVerticalSpace = true; |
| gridData.widthHint = 486; |
| gridData.heightHint = 14; |
| gridData.horizontalSpan = 1; |
| gridData.grabExcessHorizontalSpace = true; |
| nameTextField.setLayoutData(gridData); |
| SWTBindingTools.bind(this.mappingFileNameModel, nameTextField); |
| |
| Button browseButton = new Button(composite, SWT.CENTER); |
| browseButton.setToolTipText(JptJpaUiMessages.JAVA_METADATA_CONVERSION_WIZARD_PAGE_MAPPING_FILE_BROWSE_BUTTON_TOOL_TIP); |
| browseButton.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false, 1, 1)); |
| browseButton.setText(JptJpaUiMessages.JAVA_METADATA_CONVERSION_WIZARD_PAGE_MAPPING_FILE_BROWSE_BUTTON); |
| browseButton.addSelectionListener(this.buildMappingFileBrowseButtonListener()); |
| |
| return composite; |
| } |
| |
| |
| // ********** mapping file name listener ********** |
| |
| protected PropertyChangeListener buildMappingFileNameListener() { |
| return new MappingFileNameListener(); |
| } |
| |
| protected class MappingFileNameListener |
| extends PropertyChangeAdapter |
| { |
| @Override |
| public void propertyChanged(PropertyChangeEvent event) { |
| JavaMetadataConversionWizardPage.this.validate(); |
| } |
| } |
| |
| protected void validate() { |
| String errorMessage = this.buildErrorMessage(); |
| this.setErrorMessage(errorMessage); |
| this.setPageComplete(errorMessage == null); |
| } |
| |
| protected String buildErrorMessage() { |
| JptXmlResource ormXmlResource = this.getOrmXmlResource(); |
| if (ormXmlResource == null) { |
| return JptJpaUiMessages.JAVA_METADATA_CONVERSION_MAPPING_FILE_DOES_NOT_EXIST; |
| } |
| String mappingFileVersion = ormXmlResource.getVersion(); |
| String jpaProjectVersion = this.getJpaProjectVersion(); |
| if (ObjectTools.notEquals(mappingFileVersion, jpaProjectVersion)) { |
| return NLS.bind(JptJpaUiMessages.JAVA_METADATA_CONVERSION_MAPPING_FILE_VERSION_IS_INVALID, mappingFileVersion, jpaProjectVersion); |
| } |
| if (this.getEntityMappings(ormXmlResource) == null) { |
| return JptJpaUiMessages.JAVA_METADATA_CONVERSION_MAPPING_FILE_NOT_LISTED_IN_PERSISTENCE_XML; |
| } |
| if (this.noConvertibleJavaMetadata) { |
| this.setMessage(this.getMissingJavaMetadataWarningMessage(), IMessageProvider.WARNING); |
| } |
| return null; |
| } |
| |
| protected EntityMappings getEntityMappings() { |
| return this.getEntityMappings(this.getOrmXmlResource()); |
| } |
| |
| protected EntityMappings getEntityMappings(JptXmlResource ormXmlResource) { |
| return (ormXmlResource == null) ? null : this.getEntityMappings_(ormXmlResource); |
| } |
| |
| /** |
| * Pre-condition: the specified <code>orm.xml</code> resource is |
| * not <code>null</code>. |
| */ |
| protected EntityMappings getEntityMappings_(JptXmlResource ormXmlResource) { |
| Iterator<JpaStructureNode> nodes = this.getRootStructureNodes(ormXmlResource); |
| return nodes.hasNext() ? (EntityMappings) nodes.next() : null; |
| } |
| |
| protected JptXmlResource getOrmXmlResource() { |
| IPath mappingFilePath = this.getMappingFilePath(); |
| return (mappingFilePath == null) ? null : this.jpaProject.getMappingFileXmlResource(mappingFilePath); |
| } |
| |
| protected IPath getMappingFilePath() { |
| String mappingFileName = this.getMappingFileName(); |
| return StringTools.isBlank(mappingFileName) ? null : new Path(mappingFileName); |
| } |
| |
| protected String getMappingFileName() { |
| String mappingFileName = this.mappingFileNameModel.getValue(); |
| return StringTools.isBlank(mappingFileName) ? null : mappingFileName; |
| } |
| |
| protected String getJpaProjectVersion(){ |
| return this.jpaProject.getJpaPlatform().getJpaVersion().getVersion(); |
| } |
| |
| |
| // ********** mapping file link listener ********** |
| |
| protected SelectionListener buildMappingFileLinkListener() { |
| return new MappingFileLinkListener(); |
| } |
| |
| protected class MappingFileLinkListener |
| extends SelectionAdapter |
| { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| JavaMetadataConversionWizardPage.this.mappingFileLinkPressed(); |
| } |
| } |
| |
| protected void mappingFileLinkPressed() { |
| IPath path = this.openNewMappingFileWizard(); |
| if (path != null) { |
| this.mappingFileNameModel.setValue(path.toString()); |
| // revalidate because the mapping file may have been created |
| this.validate(); |
| } |
| } |
| |
| protected abstract IPath openNewMappingFileWizard(); |
| |
| |
| // ********** mapping file browse button listener ********** |
| |
| protected SelectionListener buildMappingFileBrowseButtonListener() { |
| return new MappingFileBrowseButtonListener(); |
| } |
| |
| protected class MappingFileBrowseButtonListener |
| extends SelectionAdapter |
| { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| JavaMetadataConversionWizardPage.this.mappingFileBrowseButtonPressed(); |
| } |
| } |
| |
| protected void mappingFileBrowseButtonPressed() { |
| IProject project = this.jpaProject.getProject(); |
| SelectMappingFileDialog dialog = this.buildSelectMappingFileDialog(); |
| dialog.setTitle(JptJpaUiMessages.SELECT_MAPPING_FILE_DIALOG_TITLE); |
| dialog.setMessage(JptJpaUiMessages.SELECT_MAPPING_FILE_DIALOG_MESSAGE); |
| dialog.addFilter(this.buildSelectMappingFileDialogViewerFilter()); |
| dialog.setInput(project); |
| |
| JptXmlResource resource = this.getOrmXmlResource(); |
| IFile file = (resource == null) ? null : resource.getFile(); |
| if (file != null) { |
| dialog.setInitialSelection(file); |
| } |
| if (dialog.open() == Window.OK) { |
| this.mappingFileNameModel.setValue(dialog.getChosenName()); |
| // revalidate because the mapping file may have been created |
| this.validate(); |
| } |
| } |
| |
| protected abstract SelectMappingFileDialog buildSelectMappingFileDialog(); |
| |
| protected ViewerFilter buildSelectMappingFileDialogViewerFilter() { |
| return new XmlMappingFileViewerFilter(this.jpaProject, this.getMappingFileContentType()); |
| } |
| |
| |
| // ********** finish => conversion ********** |
| |
| protected boolean performFinish() { |
| return this.isOKToConvert() && this.performFinish_(); |
| } |
| |
| protected boolean isOKToConvert() { |
| return this.hasConvertibleJavaMetadata(); |
| } |
| |
| protected boolean performFinish_() { |
| // true=fork; true=cancellable |
| try { |
| this.buildProgressMonitorDialog().run(true, true, this.buildConversionRunnable()); |
| } catch (InvocationTargetException ex) { |
| JptJpaUiPlugin.instance().logError(ex); |
| } catch (InterruptedException ex) { |
| Thread.currentThread().interrupt(); // runnable cancelled |
| } |
| return true; |
| } |
| |
| protected ProgressMonitorDialog buildProgressMonitorDialog() { |
| return new ProgressMonitorDialog(this.getShell()); |
| } |
| |
| protected IRunnableWithProgress buildConversionRunnable() { |
| return new ConversionRunnable(this.getConversionCommandStrategy(), this.getEntityMappings()); |
| } |
| |
| protected abstract ConversionCommand.Strategy getConversionCommandStrategy(); |
| |
| /** |
| * UI runnable |
| */ |
| protected static class ConversionRunnable |
| implements IRunnableWithProgress |
| { |
| protected final ConversionCommand.Strategy conversionCommandStrategy; |
| protected final EntityMappings entityMappings; |
| |
| protected ConversionRunnable(ConversionCommand.Strategy conversionCommandStrategy, EntityMappings entityMappings) { |
| super(); |
| if ((conversionCommandStrategy == null) || (entityMappings == null)) { |
| throw new NullPointerException(); |
| } |
| this.conversionCommandStrategy = conversionCommandStrategy; |
| this.entityMappings = entityMappings; |
| } |
| |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { |
| IWorkspace ws = ResourcesPlugin.getWorkspace(); |
| ISchedulingRule rule = ws.getRuleFactory().modifyRule(ws.getRoot()); |
| try { |
| ws.run(this.buildWorkspaceRunnable(), rule, IWorkspace.AVOID_UPDATE, monitor); |
| } catch (CoreException ex) { |
| if (ex.getStatus().getSeverity() == IStatus.CANCEL) { |
| throw new InterruptedException(); // ??? |
| } |
| throw new InvocationTargetException(ex); |
| } |
| } |
| |
| protected void run_(IProgressMonitor monitor) { |
| JpaProjectManager jpaProjectManager = this.getJpaProjectManager(); |
| if (jpaProjectManager == null) { |
| throw new OperationCanceledException("Missing JPA project manager"); |
| } |
| Command conversionCommand = new ConversionCommand(this.conversionCommandStrategy, this.entityMappings, monitor); |
| try { |
| jpaProjectManager.execute(conversionCommand, SynchronousUiCommandContext.instance()); |
| } catch (InterruptedException ex) { |
| Thread.currentThread().interrupt(); |
| throw new OperationCanceledException(); |
| } |
| } |
| |
| protected IWorkspaceRunnable buildWorkspaceRunnable() { |
| return new WorkspaceRunnable(); |
| } |
| |
| protected JpaProjectManager getJpaProjectManager() { |
| return (JpaProjectManager) this.getWorkspace().getAdapter(JpaProjectManager.class); |
| } |
| |
| protected IWorkspace getWorkspace() { |
| return this.entityMappings.getParent().getXmlResource().getFile().getWorkspace(); |
| } |
| |
| @Override |
| public String toString() { |
| return ObjectTools.toString(this); |
| } |
| |
| /** |
| * Workspace runnable |
| */ |
| protected class WorkspaceRunnable |
| extends WorkspaceRunnableAdapter |
| { |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| ConversionRunnable.this.run_(monitor); |
| } |
| } |
| } |
| |
| |
| /** |
| * Conversion command. |
| * This is dispatched to the JPA project manager. |
| */ |
| protected static class ConversionCommand |
| implements Command |
| { |
| protected final Strategy strategy; |
| protected final EntityMappings entityMappings; |
| protected final IProgressMonitor monitor; |
| |
| protected ConversionCommand(Strategy strategy, EntityMappings entityMappings, IProgressMonitor monitor) { |
| super(); |
| if ((strategy == null) || (entityMappings == null) || (monitor == null)) { |
| throw new NullPointerException(); |
| } |
| this.strategy = strategy; |
| this.entityMappings = entityMappings; |
| this.monitor = monitor; |
| } |
| |
| public void execute() { |
| this.strategy.execute(this.entityMappings, this.monitor); |
| this.getOrmXmlResource().save(); |
| this.saveAllFiles(); |
| this.openEditorOnMappingFile(); |
| } |
| |
| protected JptXmlResource getOrmXmlResource() { |
| return this.entityMappings.getParent().getXmlResource(); |
| } |
| |
| protected void saveAllFiles() { |
| DisplayTools.asyncExec(this.buildSaveAllFilesRunnable()); |
| } |
| |
| protected Runnable buildSaveAllFilesRunnable() { |
| return new SaveFilesRunnable(this.getProject()); |
| } |
| |
| protected IProject getProject() { |
| return this.entityMappings.getJpaProject().getProject(); |
| } |
| |
| protected void openEditorOnMappingFile() { |
| DisplayTools.asyncExec(this.buildOpenEditorOnMappingFileRunnable()); |
| } |
| |
| protected Runnable buildOpenEditorOnMappingFileRunnable() { |
| return new OpenEditorRunnable(this.getOrmXmlResource().getFile()); |
| } |
| |
| @Override |
| public String toString() { |
| return ObjectTools.toString(this, this.entityMappings.getPersistenceUnit()); |
| } |
| |
| public interface Strategy { |
| void execute(EntityMappings entityMappings, IProgressMonitor monitor); |
| } |
| } |
| |
| |
| // ********** save files ********** |
| |
| protected static class SaveFilesRunnable |
| implements Runnable |
| { |
| protected final IResource[] resourceRoots; |
| |
| protected SaveFilesRunnable(IProject project) { |
| super(); |
| if (project == null) { |
| throw new NullPointerException(); |
| } |
| this.resourceRoots = new IResource[] { project }; |
| } |
| |
| public void run() { |
| IDE.saveAllEditors(this.resourceRoots, false); // false=no confirm |
| } |
| |
| @Override |
| public String toString() { |
| return ObjectTools.toString(this, this.resourceRoots[0]); |
| } |
| } |
| |
| |
| // ********** open editor ********** |
| |
| protected static class OpenEditorRunnable |
| implements Runnable |
| { |
| protected final IFile file; |
| |
| protected OpenEditorRunnable(IFile file) { |
| super(); |
| if (file == null) { |
| throw new NullPointerException(); |
| } |
| this.file = file; |
| } |
| |
| public void run() { |
| IWorkbenchPage page = WorkbenchTools.getActivePage(); |
| try { |
| if (page != null) { |
| IDE.openEditor(page, this.file); |
| } |
| } catch (PartInitException ex) { |
| JptJpaUiPlugin.instance().logError(ex); |
| } |
| } |
| |
| @Override |
| public String toString() { |
| return ObjectTools.toString(this, this.file); |
| } |
| } |
| |
| |
| // ********** misc ********** |
| |
| /** |
| * Return the root structure nodes of the given XML resource |
| */ |
| protected Iterator<JpaStructureNode> getRootStructureNodes(JptXmlResource ormXmlResource) { |
| if (ormXmlResource == null) { |
| return EmptyIterator.instance(); |
| } |
| return this.jpaProject.getJpaFile(ormXmlResource.getFile()).getRootStructureNodes().iterator(); |
| } |
| |
| @Override |
| public final void performHelp() { |
| WorkbenchTools.displayHelp(HELP_CONTEXT_ID); |
| } |
| } |