| /*--------------------------------------------------------------------------+ |
| $Id$ |
| | | |
| | Copyright 2005-2010 Technische Universitaet Muenchen | |
| | | |
| | Licensed under the Apache License, Version 2.0 (the "License"); | |
| | you may not use this file except in compliance with the License. | |
| | You may obtain a copy of the License at | |
| | | |
| | http://www.apache.org/licenses/LICENSE-2.0 | |
| | | |
| | Unless required by applicable law or agreed to in writing, software | |
| | distributed under the License is distributed on an "AS IS" BASIS, | |
| | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| | See the License for the specific language governing permissions and | |
| | limitations under the License. | |
| +--------------------------------------------------------------------------*/ |
| package org.eclipse.emf.edapt.migration.ui; |
| |
| import static org.eclipse.emf.edapt.internal.migration.execution.internal.MigratorCommandLineOption.BACKUP; |
| import static org.eclipse.emf.edapt.internal.migration.execution.internal.MigratorCommandLineOption.HISTORY; |
| import static org.eclipse.emf.edapt.internal.migration.execution.internal.MigratorCommandLineOption.MODELS; |
| import static org.eclipse.emf.edapt.internal.migration.execution.internal.MigratorCommandLineOption.SOURCE_RELEASE; |
| import static org.eclipse.emf.edapt.internal.migration.execution.internal.MigratorCommandLineOption.TARGET_RELEASE; |
| import static org.eclipse.emf.edapt.internal.migration.execution.internal.MigratorCommandLineOption.VALIDATION_LEVEL; |
| import static org.eclipse.emf.edapt.internal.migration.execution.internal.MigratorCommandLineOption.VM_ARGUMENTS; |
| import static org.eclipse.emf.edapt.migration.ui.LaunchUtils.getAttribute; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; |
| import org.eclipse.debug.ui.AbstractLaunchConfigurationTab; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.edapt.common.ui.SelectionUtils; |
| import org.eclipse.emf.edapt.history.util.HistoryUtils; |
| import org.eclipse.emf.edapt.internal.common.FileUtils; |
| import org.eclipse.emf.edapt.internal.common.StringUtils; |
| import org.eclipse.emf.edapt.internal.common.URIUtils; |
| import org.eclipse.emf.edapt.internal.migration.execution.ValidationLevel; |
| import org.eclipse.emf.edapt.internal.migration.execution.internal.ClassLoaderFacade; |
| import org.eclipse.emf.edapt.internal.migration.execution.internal.MigratorCommandLineOption; |
| import org.eclipse.emf.edapt.migration.execution.Migrator; |
| import org.eclipse.emf.edapt.spi.history.Release; |
| import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants; |
| import org.eclipse.jface.layout.GridDataFactory; |
| import org.eclipse.jface.viewers.ArrayContentProvider; |
| import org.eclipse.jface.viewers.ComboViewer; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.jface.viewers.ViewerSorter; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| 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.Group; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.dialogs.FilteredResourcesSelectionDialog; |
| |
| /** |
| * Tab to specify the main launch configuration attributes of the migration. |
| * |
| * @author herrmama |
| * @author $Author$ |
| * @version $Rev$ |
| * @levd.rating YELLOW Hash: 3F38CE5FD3EE3E6D990141AF90D7B613 |
| */ |
| class MigrationLaunchConfigurationMainTab extends |
| AbstractLaunchConfigurationTab { |
| |
| /** Text field to edit the path of the history file. */ |
| private Text historyText; |
| |
| /** Table viewer to display the paths of the model files. */ |
| private TableViewer modelViewer; |
| |
| /** Paths of the model files. */ |
| private final List<String> modelURIs = new ArrayList<String>(); |
| |
| /** Check box to toggle automatic detection of the target release. */ |
| private Button sourceReleaseCheck; |
| |
| /** Combo box to select the source release. */ |
| private ComboViewer sourceReleaseCombo; |
| |
| /** Check box to toggle automatic detection of the target release. */ |
| private Button targetReleaseCheck; |
| |
| /** Combo box to select the target release. */ |
| private ComboViewer targetReleaseCombo; |
| |
| /** Combo box to set the validation level. */ |
| private ComboViewer validationCombo; |
| |
| /** Text field to edit the JVM arguments. */ |
| private Text vmArgsText; |
| |
| /** Migrator for current history. */ |
| private Migrator migrator; |
| |
| /** Check box to toggle whether a backup should be made before migration. */ |
| private Button backupCheck; |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void createControl(Composite parent) { |
| final Composite tabControl = new Composite(parent, SWT.NONE); |
| setControl(tabControl); |
| tabControl.setLayout(new GridLayout()); |
| |
| createHistoryGroup(tabControl); |
| createModelGroup(tabControl); |
| createSourceReleaseGroup(tabControl); |
| createTargetReleaseCombo(tabControl); |
| createValidationGroup(tabControl); |
| createBackupGroup(tabControl); |
| createVMArgsGroup(tabControl); |
| } |
| |
| /** Create the group to select the history file. */ |
| private void createHistoryGroup(Composite parent) { |
| final Group historyGroup = createGroupControl(parent, HISTORY, 2); |
| historyText = new Text(historyGroup, SWT.SINGLE | SWT.BORDER); |
| historyText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| historyText.addModifyListener(new HistoryTextModifyListener()); |
| createPushButton(historyGroup, "Browse...", null).addSelectionListener( //$NON-NLS-1$ |
| new BrowseButtonListener()); |
| } |
| |
| /** Create the group to select the model files. */ |
| private void createModelGroup(Composite parent) { |
| final Group modelGroup = createGroupControl(parent, MODELS, 2); |
| modelViewer = new TableViewer(modelGroup, SWT.MULTI | SWT.BORDER); |
| final GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| data.heightHint = 3 * modelViewer.getTable().getItemHeight(); |
| modelViewer.getTable().setLayoutData(data); |
| modelViewer.setContentProvider(new ArrayContentProvider()); |
| modelViewer.setLabelProvider(new LabelProvider()); |
| modelViewer.setInput(modelURIs); |
| |
| final Composite buttonComposite = new Composite(modelGroup, SWT.None); |
| buttonComposite.setLayoutData(new GridData(GridData.FILL_VERTICAL)); |
| final GridLayout layout = new GridLayout(); |
| layout.marginHeight = layout.marginWidth = 0; |
| buttonComposite.setLayout(layout); |
| createPushButton(buttonComposite, "Add...", null).addSelectionListener( //$NON-NLS-1$ |
| new AddButtonListener()); |
| createPushButton(buttonComposite, "Remove", null).addSelectionListener( //$NON-NLS-1$ |
| new RemoveButtonListener()); |
| } |
| |
| /** Create the group to select the source release of the migration. */ |
| private void createSourceReleaseGroup(Composite parent) { |
| final Group releaseGroup = createGroupControl(parent, SOURCE_RELEASE, 2); |
| sourceReleaseCheck = createAutoButton(releaseGroup); |
| sourceReleaseCombo = createReleaseCombo(releaseGroup); |
| sourceReleaseCombo.setContentProvider(new ArrayContentProvider() { |
| @Override |
| public Object[] getElements(Object inputElement) { |
| return getSourceReleases().toArray(); |
| } |
| }); |
| sourceReleaseCheck.addSelectionListener(new ReleaseCheckListener( |
| sourceReleaseCheck, sourceReleaseCombo)); |
| } |
| |
| /** Create the group to select the target release of the migration. */ |
| private void createTargetReleaseCombo(Composite parent) { |
| final Group releaseGroup = createGroupControl(parent, TARGET_RELEASE, 2); |
| targetReleaseCheck = createAutoButton(releaseGroup); |
| targetReleaseCombo = createReleaseCombo(releaseGroup); |
| targetReleaseCombo.setContentProvider(new ArrayContentProvider() { |
| @Override |
| public Object[] getElements(Object inputElement) { |
| return getTargetReleases().toArray(); |
| } |
| }); |
| targetReleaseCheck.addSelectionListener(new ReleaseCheckListener( |
| targetReleaseCheck, targetReleaseCombo)); |
| } |
| |
| /** Create the button to set the automatic detection of a release. */ |
| private Button createAutoButton(Composite parent) { |
| return createCheckButton(parent, "Auto"); //$NON-NLS-1$ |
| } |
| |
| /** Create a combo box to select a release. */ |
| private ComboViewer createReleaseCombo(Composite composite) { |
| final ComboViewer releaseCombo = new ComboViewer(composite); |
| releaseCombo.getCombo().setLayoutData( |
| new GridData(GridData.FILL_HORIZONTAL)); |
| releaseCombo.setLabelProvider(new LabelProvider() { |
| @Override |
| public String getText(Object element) { |
| final Release release = (Release) element; |
| String text = "Release " + release.getNumber(); //$NON-NLS-1$ |
| final String label = release.getLabel(); |
| if (label != null && label.length() > 0) { |
| text += ": " + label; //$NON-NLS-1$ |
| } |
| return text; |
| } |
| }); |
| releaseCombo.setSorter(new ViewerSorter() { |
| @Override |
| public int compare(Viewer viewer, Object e1, Object e2) { |
| final Release r1 = (Release) e1; |
| final Release r2 = (Release) e2; |
| return r1.getNumber() - r2.getNumber(); |
| } |
| }); |
| releaseCombo.addSelectionChangedListener(new ComboListener()); |
| return releaseCombo; |
| } |
| |
| /** Create the group to set the level of the validation. */ |
| private void createValidationGroup(Composite parent) { |
| final Group validationGroup = createGroupControl(parent, VALIDATION_LEVEL, 1); |
| |
| validationCombo = new ComboViewer(validationGroup); |
| validationCombo.getCombo().setLayoutData( |
| new GridData(GridData.FILL_HORIZONTAL)); |
| validationCombo.setContentProvider(new ArrayContentProvider()); |
| validationCombo.setLabelProvider(new LabelProvider() { |
| @Override |
| public String getText(Object element) { |
| final ValidationLevel level = (ValidationLevel) element; |
| return StringUtils.upperCamelCaseToText(level.name()); |
| } |
| }); |
| validationCombo.setInput(ValidationLevel.values()); |
| validationCombo.addSelectionChangedListener(new ComboListener()); |
| } |
| |
| /** Get the source releases to which the models may conform. */ |
| private Set<Release> getSourceReleases() { |
| initMigrator(); |
| if (migrator != null && !modelURIs.isEmpty()) { |
| final IFile file = FileUtils.getFile(modelURIs.get(0)); |
| final URI modelURI = URIUtils.getURI(file); |
| return migrator.getRelease(modelURI); |
| } |
| return Collections.emptySet(); |
| } |
| |
| /** Get the possible target releases. */ |
| private Collection<Release> getTargetReleases() { |
| initMigrator(); |
| if (migrator != null) { |
| return migrator.getReleases(); |
| } |
| return Collections.emptySet(); |
| } |
| |
| /** Initialize the migrator for the current history. */ |
| private void initMigrator() { |
| if (migrator == null) { |
| try { |
| final IFile file = FileUtils.getFile(historyText.getText()); |
| final URI historyURI = URIUtils.getURI(file); |
| migrator = new Migrator(historyURI, new ClassLoaderFacade( |
| Thread.currentThread().getContextClassLoader())); |
| } catch (final Exception e) { |
| // ignore |
| } |
| } |
| } |
| |
| /** |
| * Create the group to set whether a backup should be created before |
| * migration. |
| */ |
| public void createBackupGroup(Composite parent) { |
| final Group group = createGroupControl(parent, BACKUP, 1); |
| backupCheck = createCheckButton(group, |
| "Create a backup of the models before migration"); //$NON-NLS-1$ |
| backupCheck.addSelectionListener(new CheckListener()); |
| } |
| |
| /** |
| * Creates group control that contains controls to edit virtual machine |
| * arguments. |
| */ |
| private void createVMArgsGroup(Composite parent) { |
| vmArgsText = createMultiLineTextGroup(parent, VM_ARGUMENTS); |
| } |
| |
| /** |
| * Creates a group control with a multiline text field and returns the text |
| * field. The created text is setup reasonably for this tab, i.e. required |
| * listeners are registered. |
| */ |
| private Text createMultiLineTextGroup(Composite parent, |
| MigratorCommandLineOption option) { |
| final Group group = createGroupControl(parent, option, 1); |
| final Text text = new Text(group, SWT.MULTI | SWT.WRAP | SWT.BORDER |
| | SWT.V_SCROLL); |
| GridDataFactory.fillDefaults().grab(true, false).hint(SWT.DEFAULT, 40) |
| .applyTo(text); |
| text.addModifyListener(new TextModifyListener()); |
| return text; |
| } |
| |
| /** Creates a group control that serves as container for controls */ |
| private Group createGroupControl(Composite main, |
| MigratorCommandLineOption option, int columns) { |
| final Group group = new Group(main, SWT.NONE); |
| group.setText(StringUtils.upperCamelCaseToText(option.name())); |
| group.setLayout(new GridLayout(columns, false)); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| return group; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public String getName() { |
| return "Main"; //$NON-NLS-1$ |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void initializeFrom(ILaunchConfiguration configuration) { |
| migrator = null; |
| |
| final int sourceReleaseNumber = getAttribute(configuration, |
| SOURCE_RELEASE.id(), -1); |
| sourceReleaseCheck.setSelection(sourceReleaseNumber == -1); |
| final int targetReleaseNumber = getAttribute(configuration, |
| TARGET_RELEASE.id(), -1); |
| targetReleaseCheck.setSelection(targetReleaseNumber == -1); |
| |
| // history |
| historyText.setText(getAttribute(configuration, HISTORY.id(), "")); //$NON-NLS-1$ |
| |
| // models |
| modelURIs.clear(); |
| modelURIs.addAll(getAttribute(configuration, MODELS.id(), |
| Collections.<String> emptyList())); |
| modelViewer.refresh(); |
| |
| // release |
| initializeReleaseCombo(sourceReleaseCheck, sourceReleaseCombo, |
| sourceReleaseNumber, SOURCE_RELEASE); |
| initializeReleaseCombo(targetReleaseCheck, targetReleaseCombo, |
| targetReleaseNumber, TARGET_RELEASE); |
| |
| // validation |
| final String validation = getAttribute(configuration, VALIDATION_LEVEL.id(), |
| ValidationLevel.CUSTOM_MIGRATION.toString()); |
| validationCombo.setSelection(new StructuredSelection(ValidationLevel |
| .valueOf(validation))); |
| |
| // backup |
| final boolean backup = getAttribute(configuration, BACKUP.id(), false); |
| backupCheck.setSelection(backup); |
| |
| // VM arguments |
| vmArgsText.setText(getAttribute(configuration, |
| IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, "")); //$NON-NLS-1$ |
| } |
| |
| /** Initialize the combo viewer to select a release. */ |
| private void initializeReleaseCombo(Button check, ComboViewer combo, |
| int releaseNumber, MigratorCommandLineOption option) { |
| combo.getCombo().setEnabled(!check.getSelection()); |
| if (check.getSelection()) { |
| combo.setSelection(StructuredSelection.EMPTY); |
| } else { |
| combo.setInput(new Object()); |
| if (releaseNumber >= 0) { |
| final Collection<Release> releases = option == SOURCE_RELEASE ? getSourceReleases() |
| : getTargetReleases(); |
| final Release release = HistoryUtils.getRelease(releases, |
| releaseNumber); |
| if (release != null) { |
| combo.setSelection(new StructuredSelection(release)); |
| } |
| } |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void performApply(ILaunchConfigurationWorkingCopy configuration) { |
| // history |
| final String historyFilename = historyText.getText(); |
| configuration.setAttribute(HISTORY.id(), historyFilename); |
| |
| // class path |
| try { |
| final IFile file = FileUtils.getFile(historyFilename); |
| if (file != null) { |
| final IProject project = file.getProject(); |
| configuration.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, |
| project.getName()); |
| } |
| } catch (final IllegalArgumentException e) { |
| // do not set default class path |
| } |
| |
| // models |
| configuration.setAttribute(MODELS.id(), |
| new ArrayList<String>(modelURIs)); |
| |
| // release |
| saveRelease(configuration, sourceReleaseCheck, sourceReleaseCombo, |
| SOURCE_RELEASE); |
| saveRelease(configuration, targetReleaseCheck, targetReleaseCombo, |
| TARGET_RELEASE); |
| |
| // validation |
| final ValidationLevel level = SelectionUtils |
| .getSelectedElement(validationCombo.getSelection(), ValidationLevel.class); |
| configuration.setAttribute(VALIDATION_LEVEL.id(), level.toString()); |
| |
| // backup |
| final boolean backup = backupCheck.getSelection(); |
| configuration.setAttribute(BACKUP.id(), backup); |
| |
| // VM arguments |
| configuration.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, |
| vmArgsText.getText()); |
| } |
| |
| /** Save the value of a release to the launch configuration. */ |
| private void saveRelease(ILaunchConfigurationWorkingCopy configuration, |
| Button check, ComboViewer combo, MigratorCommandLineOption option) { |
| if (check.getSelection()) { |
| configuration.setAttribute(option.id(), -1); |
| } else { |
| final Release release = SelectionUtils.getSelectedElement(combo |
| .getSelection(), Release.class); |
| if (release != null) { |
| configuration.setAttribute(option.id(), release.getNumber()); |
| } |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void setDefaults(ILaunchConfigurationWorkingCopy configuration) { |
| configuration.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, true); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public boolean isValid(ILaunchConfiguration launchConfig) { |
| // history |
| final String historyFilename = historyText.getText(); |
| if (historyFilename.length() == 0) { |
| setErrorMessage("History not specified"); //$NON-NLS-1$ |
| return false; |
| } |
| |
| final IFile historyFile = FileUtils.getFile(historyFilename); |
| if (!historyFile.exists()) { |
| setErrorMessage("History does not exist."); //$NON-NLS-1$ |
| return false; |
| } |
| |
| // models |
| if (modelURIs.isEmpty()) { |
| setErrorMessage("No model specified"); //$NON-NLS-1$ |
| return false; |
| } |
| for (final String modelURI : modelURIs) { |
| final IFile modelFile = FileUtils.getFile(modelURI); |
| if (!modelFile.exists()) { |
| setErrorMessage("Model does not exist."); //$NON-NLS-1$ |
| return false; |
| } |
| } |
| |
| // release |
| if (!isValidRelease(sourceReleaseCheck, sourceReleaseCombo, |
| SOURCE_RELEASE) |
| || !isValidRelease(targetReleaseCheck, targetReleaseCombo, |
| TARGET_RELEASE)) { |
| return false; |
| } |
| |
| setErrorMessage(null); |
| return true; |
| } |
| |
| /** Check whether a release is set. */ |
| private boolean isValidRelease(Button check, ComboViewer combo, |
| MigratorCommandLineOption option) { |
| if (!check.getSelection() |
| && SelectionUtils.getSelectedElement(combo.getSelection(), Object.class) == null) { |
| setErrorMessage(StringUtils.upperCamelCaseToText(option.name()) |
| + " must be set"); //$NON-NLS-1$ |
| return false; |
| } |
| return true; |
| } |
| |
| /** Refresh the combo viewer to select the source release. */ |
| private void refreshSourceReleaseCombo() { |
| refreshReleaseCombo(sourceReleaseCheck, sourceReleaseCombo); |
| } |
| |
| /** Refresh the combo viewer to select the target release. */ |
| private void refreshTargetReleaseCombo() { |
| refreshReleaseCombo(targetReleaseCheck, targetReleaseCombo); |
| } |
| |
| /** |
| * Refresh a release combo viewer, depending on whether it is enabled or |
| * not. |
| */ |
| private void refreshReleaseCombo(Button check, ComboViewer combo) { |
| if (check.getSelection()) { |
| combo.setSelection(StructuredSelection.EMPTY); |
| } else { |
| combo.setInput(new Object()); |
| } |
| } |
| |
| /** Listener that updates the dialog after text fields were modified. */ |
| private class TextModifyListener implements ModifyListener { |
| /** {@inheritDoc} */ |
| @Override |
| public void modifyText(ModifyEvent e) { |
| updateLaunchConfigurationDialog(); |
| } |
| } |
| |
| /** |
| * Listener that updates the dialog after the text field showing the history |
| * is modified. |
| */ |
| private class HistoryTextModifyListener extends TextModifyListener { |
| /** {@inheritDoc} */ |
| @Override |
| public void modifyText(ModifyEvent e) { |
| migrator = null; |
| refreshSourceReleaseCombo(); |
| refreshTargetReleaseCombo(); |
| super.modifyText(e); |
| } |
| } |
| |
| /** |
| * This listener is attached to the browse button and open a file selection |
| * dialog if activated. |
| */ |
| private class BrowseButtonListener extends SelectionAdapter { |
| /** {@inheritDoc} */ |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| final IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace() |
| .getRoot(); |
| final FilteredResourcesSelectionDialog dialog = new FilteredResourcesSelectionDialog( |
| getShell(), false, workspaceRoot, IResource.DEPTH_INFINITE |
| | IResource.FILE); |
| dialog.setInitialPattern("*." + HistoryUtils.HISTORY_FILE_EXTENSION); //$NON-NLS-1$ |
| |
| if (dialog.open() == Window.OK) { |
| final Object result[] = dialog.getResult(); |
| if (result.length == 1) { |
| final IFile resource = (IFile) result[0]; |
| final IPath path = resource.getFullPath(); |
| historyText.setText(path.toString()); |
| migrator = null; |
| refreshSourceReleaseCombo(); |
| refreshTargetReleaseCombo(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * This listener is attached to the add button and open a file selection |
| * dialog if activated. |
| */ |
| private class AddButtonListener extends SelectionAdapter { |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| final IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace() |
| .getRoot(); |
| final FilteredResourcesSelectionDialog dialog = new FilteredResourcesSelectionDialog( |
| getShell(), false, workspaceRoot, IResource.DEPTH_INFINITE |
| | IResource.FILE); |
| dialog.setInitialPattern("*.*"); //$NON-NLS-1$ |
| |
| if (dialog.open() == Window.OK) { |
| final Object result[] = dialog.getResult(); |
| if (result.length == 1) { |
| final IFile resource = (IFile) result[0]; |
| final IPath path = resource.getFullPath(); |
| modelURIs.add(path.toString()); |
| modelViewer.refresh(); |
| if (modelURIs.size() == 1) { |
| refreshSourceReleaseCombo(); |
| } |
| updateLaunchConfigurationDialog(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * This listener is attached to the remove button and removes models if |
| * activated. |
| */ |
| private class RemoveButtonListener extends SelectionAdapter { |
| /** {@inheritDoc} */ |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| final List<String> elements = SelectionUtils |
| .getSelectedElements(modelViewer.getSelection(), String.class); |
| final String modelURI = modelURIs.get(0); |
| modelURIs.removeAll(elements); |
| modelViewer.refresh(); |
| if (elements.contains(modelURI)) { |
| refreshSourceReleaseCombo(); |
| } |
| updateLaunchConfigurationDialog(); |
| } |
| } |
| |
| /** This listener is attached to a check button. */ |
| private class CheckListener extends SelectionAdapter { |
| /** {@inheritDoc} */ |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| updateLaunchConfigurationDialog(); |
| } |
| } |
| |
| /** |
| * This listener is attached to the auto check box and toggles automatic |
| * detection of the release. |
| */ |
| private class ReleaseCheckListener extends CheckListener { |
| |
| /** The check button to activate automatic detection of a release. */ |
| private final Button releaseCheck; |
| |
| /** The combo viewer to select a release. */ |
| private final ComboViewer releaseCombo; |
| |
| /** Constructor. */ |
| public ReleaseCheckListener(Button releaseCheck, |
| ComboViewer releaseCombo) { |
| this.releaseCheck = releaseCheck; |
| this.releaseCombo = releaseCombo; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| releaseCombo.getCombo().setEnabled(!releaseCheck.getSelection()); |
| refreshReleaseCombo(releaseCheck, releaseCombo); |
| super.widgetSelected(e); |
| } |
| } |
| |
| /** |
| * This listener is attached to the combo box and toggles an update of the |
| * configuration dialog. |
| */ |
| private class ComboListener implements ISelectionChangedListener { |
| /** {@inheritDoc} */ |
| @Override |
| public void selectionChanged(SelectionChangedEvent event) { |
| updateLaunchConfigurationDialog(); |
| } |
| } |
| } |