| /******************************************************************************* |
| * Copyright (c) 2000, 2014 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Mohamed Hussein (Mentor Graphics) - Added getWarningMessage (Bug 386673) |
| *******************************************************************************/ |
| package org.eclipse.debug.internal.ui.launchConfigurations; |
| |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IFile; |
| 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.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| import org.eclipse.debug.core.ILaunchConfigurationType; |
| import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; |
| import org.eclipse.debug.core.ILaunchDelegate; |
| import org.eclipse.debug.core.ILaunchManager; |
| import org.eclipse.debug.internal.core.IInternalDebugCoreConstants; |
| import org.eclipse.debug.internal.core.LaunchConfigurationWorkingCopy; |
| import org.eclipse.debug.internal.core.LaunchManager; |
| import org.eclipse.debug.internal.ui.DebugUIPlugin; |
| import org.eclipse.debug.internal.ui.IInternalDebugUIConstants; |
| import org.eclipse.debug.internal.ui.SWTFactory; |
| import org.eclipse.debug.ui.DebugUITools; |
| import org.eclipse.debug.ui.ILaunchConfigurationDialog; |
| import org.eclipse.debug.ui.ILaunchConfigurationTab; |
| import org.eclipse.debug.ui.ILaunchConfigurationTab2; |
| import org.eclipse.debug.ui.ILaunchConfigurationTabGroup; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.resource.ColorRegistry; |
| import org.eclipse.jface.resource.JFaceResources; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.custom.CTabFolder; |
| import org.eclipse.swt.custom.CTabItem; |
| import org.eclipse.swt.custom.ScrolledComposite; |
| import org.eclipse.swt.custom.StackLayout; |
| import org.eclipse.swt.custom.ViewForm; |
| 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.graphics.Color; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.Image; |
| 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.Shell; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IWorkbenchPreferenceConstants; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.progress.WorkbenchJob; |
| |
| import com.ibm.icu.text.MessageFormat; |
| |
| /** |
| * A viewer that displays tabs for a launch configuration, with apply and revert |
| * buttons. |
| */ |
| public class LaunchConfigurationTabGroupViewer { |
| |
| /** |
| * Containing launch dialog |
| */ |
| private ILaunchConfigurationDialog fDialog; |
| |
| /** |
| * The launch configuration (original) being edited |
| */ |
| private ILaunchConfiguration fOriginal; |
| |
| /** |
| * The working copy of the original |
| */ |
| private ILaunchConfigurationWorkingCopy fWorkingCopy; |
| |
| /** |
| * This view's control, which contains a composite area of controls |
| */ |
| private Composite fViewerControl; |
| |
| /** |
| * Name text widget |
| */ |
| private Text fNameWidget; |
| |
| /** |
| * Composite containing the launch config tab widgets |
| */ |
| private Composite fGroupComposite; |
| |
| /** |
| * Tab folder |
| */ |
| private CTabFolder fTabFolder; |
| |
| /** |
| * The current tab group being displayed |
| */ |
| private ILaunchConfigurationTabGroup fTabGroup; |
| |
| /** |
| * Index of the active tab |
| */ |
| private int fCurrentTabIndex = -1; |
| |
| /** |
| * Apply & Revert buttons |
| */ |
| private Button fApplyButton; |
| private Button fRevertButton; |
| |
| /** |
| * Whether tabs are currently being disposed or initialized |
| */ |
| private boolean fDisposingTabs = false; |
| private boolean fInitializingTabs = false; |
| |
| /** |
| * The description of the currently selected launch configuration or |
| * launch configuration type or <code>null</code> if none. |
| */ |
| private String fDescription = null; |
| |
| /** |
| * A place holder for switching between the tabs for a config and the getting started tab |
| * @since 3.2 |
| */ |
| private Composite fTabPlaceHolder = null; |
| |
| /** |
| * A link to allow users to select a valid set of launch options for the specified mode |
| * @since 3.3 |
| */ |
| private Link fOptionsLink = null; |
| |
| /** |
| * A label to indicate that the user needs to select an a launcher. |
| * @since 3.5 |
| */ |
| private Label fOptionsErrorLabel = null; |
| |
| /** |
| * A new composite replacing the perspectives tab |
| * @since 3.2 |
| */ |
| private Composite fGettingStarted = null; |
| |
| private ViewForm fViewform; |
| |
| /** |
| * Job to update the dialog after a delay. |
| */ |
| private Job fRefreshJob; |
| |
| /** |
| * Constructs a viewer in the given composite, contained by the given |
| * launch configuration dialog. |
| * |
| * @param parent composite containing this viewer |
| * @param dialog containing launch configuration dialog |
| */ |
| public LaunchConfigurationTabGroupViewer(Composite parent, ILaunchConfigurationDialog dialog) { |
| super(); |
| fDialog = dialog; |
| createControl(parent); |
| } |
| |
| /** |
| * Cleanup |
| */ |
| public void dispose() { |
| disposeTabGroup(); |
| } |
| |
| /** |
| * Dispose the active tab group, if any. |
| */ |
| protected void disposeTabGroup() { |
| if (fTabGroup != null) { |
| fTabGroup.dispose(); |
| fTabGroup = null; |
| } |
| } |
| |
| /** |
| * Creates this viewer's control This area displays the name of the launch |
| * configuration currently being edited, as well as a tab folder of tabs |
| * that are applicable to the launch configuration. |
| * @param parent the parent {@link Composite} |
| * |
| */ |
| private void createControl(Composite parent) { |
| fViewerControl = parent; |
| fViewform = new ViewForm(parent, SWT.FLAT | SWT.BORDER); |
| GridLayout layout = new GridLayout(1, false); |
| layout.horizontalSpacing = 0; |
| layout.verticalSpacing = 0; |
| fViewform.setLayout(layout); |
| GridData gd = new GridData(GridData.FILL_BOTH); |
| fViewform.setLayoutData(gd); |
| fViewform.setTopLeft(null); |
| |
| Composite mainComp = SWTFactory.createComposite(fViewform, fViewform.getFont(), 1, 1, 1, 0, 0); |
| fViewform.setContent(mainComp); |
| |
| fTabPlaceHolder = SWTFactory.createComposite(mainComp, 1, 1, GridData.FILL_BOTH); |
| fTabPlaceHolder.setLayout(new StackLayout()); |
| fGettingStarted = SWTFactory.createComposite(fTabPlaceHolder, 1, 1, GridData.FILL_BOTH); |
| |
| createGettingStarted(fGettingStarted); |
| |
| fGroupComposite = SWTFactory.createComposite(fTabPlaceHolder, fTabPlaceHolder.getFont(), 2, 2, GridData.FILL_BOTH, 5, 5); |
| SWTFactory.createLabel(fGroupComposite, LaunchConfigurationsMessages.LaunchConfigurationDialog__Name__16, 1); |
| |
| fNameWidget = new Text(fGroupComposite, SWT.SINGLE | SWT.BORDER); |
| fNameWidget.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| fNameWidget.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| if(!fInitializingTabs) { |
| handleNameModified(); |
| } |
| } |
| } |
| ); |
| |
| createTabFolder(fGroupComposite); |
| |
| Composite blComp = SWTFactory.createComposite(mainComp, mainComp.getFont(), 2, 1, GridData.FILL_HORIZONTAL); |
| Composite linkComp = SWTFactory.createComposite(blComp, blComp.getFont(), 2, 1, GridData.FILL_HORIZONTAL); |
| |
| //a link for launch options |
| fOptionsErrorLabel = new Label(linkComp, SWT.NONE); |
| gd = new GridData(); |
| fOptionsErrorLabel.setLayoutData(gd); |
| |
| fOptionsLink = new Link(linkComp, SWT.WRAP); |
| fOptionsLink.setFont(linkComp.getFont()); |
| gd = new GridData(SWT.LEFT); |
| gd.grabExcessHorizontalSpace = true; |
| fOptionsLink.setLayoutData(gd); |
| fOptionsLink.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| //collect the options available |
| try { |
| if(!canLaunchWithModes()) { |
| SelectLaunchModesDialog sld = new SelectLaunchModesDialog(getShell(), |
| getLaunchConfigurationDialog().getMode(), getWorkingCopy()); |
| if(sld.open() == IDialogConstants.OK_ID) { |
| //set the options to the config |
| Object[] res = sld.getResult(); |
| if(res != null) { |
| @SuppressWarnings("unchecked") |
| Set<String> modes = (Set<String>) res[0]; |
| modes.remove(getLaunchConfigurationDialog().getMode()); |
| ILaunchConfigurationWorkingCopy wc = getWorkingCopy(); |
| wc.setModes(modes); |
| refreshStatus(); |
| } |
| } |
| } |
| else if(hasMultipleDelegates()) { |
| SelectLaunchersDialog sldd = new SelectLaunchersDialog(getShell(), |
| getWorkingCopy().getType().getDelegates(getCurrentModeSet()), |
| getWorkingCopy(), |
| getLaunchConfigurationDialog().getMode()); |
| if(sldd.open() == IDialogConstants.OK_ID) { |
| displayInstanceTabs(true); |
| refreshStatus(); |
| } |
| } |
| } catch (CoreException ex) {} |
| } |
| }); |
| fOptionsLink.setVisible(false); |
| |
| Composite buttonComp = SWTFactory.createComposite(blComp, 2, 1, GridData.HORIZONTAL_ALIGN_END); |
| fApplyButton = SWTFactory.createPushButton(buttonComp, LaunchConfigurationsMessages.LaunchConfigurationDialog__Apply_17, null,GridData.HORIZONTAL_ALIGN_END); |
| fApplyButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent evt) { |
| handleApplyPressed(); |
| } |
| }); |
| |
| fRevertButton = SWTFactory.createPushButton(buttonComp, LaunchConfigurationsMessages.LaunchConfigurationDialog_Revert_2, null, GridData.HORIZONTAL_ALIGN_END); |
| fRevertButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent evt) { |
| handleRevertPressed(); |
| } |
| }); |
| Dialog.applyDialogFont(parent); |
| } |
| |
| /** |
| * Creates some help text for the tab group launch types |
| * @param parent the parent composite |
| * @since 3.2 |
| */ |
| private void createGettingStarted(Composite parent) { |
| Font font = parent.getFont(); |
| GridData gd = null; |
| int width = parent.getBounds().width - 30; |
| SWTFactory.createWrapLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_1, 1, width); |
| SWTFactory.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_2, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_NEW_CONFIG), 1, width); |
| SWTFactory.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_6, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_DUPLICATE_CONFIG), 1, width); |
| SWTFactory.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_4, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_DELETE_CONFIG), 1, width); |
| SWTFactory.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_8, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_FILTER_CONFIGS), 1, width); |
| SWTFactory.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_3, DebugUITools.getImage(IInternalDebugUIConstants.IMG_OVR_TRANSPARENT), 1, width); |
| |
| SWTFactory.createHorizontalSpacer(parent, 2); |
| Link link = new Link(parent, SWT.LEFT | SWT.WRAP); |
| link.setText(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_5); |
| link.setFont(font); |
| gd = new GridData(GridData.FILL_HORIZONTAL); |
| gd.widthHint = width; |
| link.setLayoutData(gd); |
| link.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| SWTFactory.showPreferencePage("org.eclipse.debug.ui.PerspectivePreferencePage"); //$NON-NLS-1$ |
| } |
| }); |
| } |
| |
| /** |
| * Creates the tab folder for displaying config instances |
| * @param parent the parent {@link Composite} |
| */ |
| private void createTabFolder(Composite parent) { |
| if (fTabFolder == null) { |
| ColorRegistry reg = JFaceResources.getColorRegistry(); |
| Color c1 = reg.get("org.eclipse.ui.workbench.ACTIVE_TAB_BG_START"), //$NON-NLS-1$ |
| c2 = reg.get("org.eclipse.ui.workbench.ACTIVE_TAB_BG_END"); //$NON-NLS-1$ |
| fTabFolder = new CTabFolder(parent, SWT.NO_REDRAW_RESIZE | SWT.FLAT); |
| fTabFolder.setSelectionBackground(new Color[] {c1, c2}, new int[] {100}, true); |
| fTabFolder.setSelectionForeground(reg.get("org.eclipse.ui.workbench.ACTIVE_TAB_TEXT_COLOR")); //$NON-NLS-1$ |
| fTabFolder.setSimple(PlatformUI.getPreferenceStore().getBoolean(IWorkbenchPreferenceConstants.SHOW_TRADITIONAL_STYLE_TABS)); |
| fTabFolder.setBorderVisible(true); |
| GridData gd = new GridData(GridData.FILL_BOTH); |
| gd.horizontalSpan = 2; |
| fTabFolder.setLayoutData(gd); |
| fTabFolder.setFont(parent.getFont()); |
| fTabFolder.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent event) { |
| if (!fInitializingTabs) { |
| handleTabSelected(); |
| refresh(); |
| } |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Returns the apply button |
| * @return the 'Apply' button |
| */ |
| protected Button getApplyButton() { |
| return fApplyButton; |
| } |
| |
| /** |
| * Returns the revert button |
| * @return the 'Revert' button |
| */ |
| protected Button getRevertButton() { |
| return fRevertButton; |
| } |
| |
| /** |
| * Sets the current name |
| * @param name the new name to set |
| */ |
| public void setName(String name) { |
| if (getWorkingCopy() != null) { |
| if (name == null) { |
| fNameWidget.setText(IInternalDebugCoreConstants.EMPTY_STRING); |
| } |
| else { |
| fNameWidget.setText(name.trim()); |
| } |
| refreshStatus(); |
| } |
| } |
| |
| /** |
| * @return the backing viewer control |
| */ |
| public Control getControl() { |
| return fViewerControl; |
| } |
| |
| /** |
| * Returns the shell this viewer is contained in. |
| * @return the current dialog shell |
| */ |
| private Shell getShell() { |
| return getControl().getShell(); |
| } |
| |
| /** |
| * Returns the current input to the viewer. Input will |
| * be one of {@link ILaunchConfiguration} or {@link ILaunchConfigurationType} |
| * |
| * @return returns the current input |
| */ |
| public Object getInput() { |
| return getConfiguration(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.Viewer#refresh() |
| */ |
| public void refresh() { |
| if (fInitializingTabs) { |
| return; |
| } |
| ILaunchConfigurationTab[] tabs = getTabs(); |
| if (tabs != null) { |
| // update the working copy from the active tab |
| boolean newwc = !getWorkingCopy().isDirty(); |
| ILaunchConfigurationTab tab = getActiveTab(); |
| if (tab != null) { |
| tab.performApply(getWorkingCopy()); |
| } |
| if((fOriginal instanceof ILaunchConfigurationWorkingCopy) && newwc) { |
| try { |
| ILaunchConfigurationWorkingCopy copy = getWorkingCopy(); |
| if(copy != null) { |
| copy.doSave(); |
| } |
| } |
| catch (CoreException e) {DebugUIPlugin.log(e);} |
| } |
| updateButtons(); |
| // update error ticks |
| CTabItem item = null; |
| boolean error = false; |
| Image image = null; |
| for (int i = 0; i < tabs.length; i++) { |
| item = fTabFolder.getItem(i); |
| image = tabs[i].getImage(); |
| item.setImage(image); |
| if(!tabs[i].isValid(getWorkingCopy())) { |
| error = tabs[i].getErrorMessage() != null; |
| if(error) { |
| item.setImage(DebugUIPlugin.getDefault().getLaunchConfigurationManager().getErrorTabImage(tabs[i])); |
| } |
| } |
| } |
| showLink(); |
| getLaunchConfigurationDialog().updateMessage(); |
| } |
| } |
| |
| /** |
| * Shows the link for either multiple launch delegates or bad launch mode combinations |
| * |
| * @since 3.3 |
| */ |
| private void showLink() { |
| String text = null; |
| if(!canLaunchWithModes()) { |
| text = LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_13; |
| } |
| else if(hasMultipleDelegates()) { |
| ILaunchDelegate delegate = getPreferredDelegate(); |
| if(delegate != null) { |
| String name = delegate.getName(); |
| if(name == null) { |
| text = LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_15; |
| } |
| else { |
| text = MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_16, new Object[] { name }); |
| } |
| } |
| else { |
| text = LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_17; |
| } |
| } |
| if(text != null) { |
| fOptionsLink.setText(text); |
| } |
| fOptionsLink.setVisible(!canLaunchWithModes() || hasMultipleDelegates()); |
| if (hasDuplicateDelegates()) { |
| fOptionsErrorLabel.setImage(JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_ERROR)); |
| } else { |
| fOptionsErrorLabel.setImage(null); |
| } |
| fViewform.layout(true, true); |
| } |
| |
| /** |
| * Returns the preferred launch delegate for the current launch configuration and mode set |
| * @return the preferred launch delegate |
| * |
| * @since 3.3 |
| */ |
| protected ILaunchDelegate getPreferredDelegate() { |
| ILaunchDelegate preferred = null; |
| ILaunchConfigurationWorkingCopy config = getWorkingCopy(); |
| if(config != null) { |
| try { |
| Set<String> modes = getCurrentModeSet(); |
| preferred = config.getPreferredDelegate(modes); |
| if(preferred == null) { |
| preferred = config.getType().getPreferredDelegate(modes); |
| } |
| } |
| catch(CoreException ce) {DebugUIPlugin.log(ce);} |
| } |
| return preferred; |
| } |
| |
| /** |
| * Returns the listing of modes for the current config |
| * @return the listing of modes for the current config |
| * @since 3.3 |
| */ |
| private Set<String> getCurrentModeSet() { |
| Set<String> set = new HashSet<String>(); |
| ILaunchConfigurationWorkingCopy config = getWorkingCopy(); |
| if(config != null) { |
| try { |
| set.addAll(config.getModes()); |
| set.add(getLaunchConfigurationDialog().getMode()); |
| } |
| catch(CoreException ce) {DebugUIPlugin.log(ce);} |
| } |
| return set; |
| } |
| |
| /** |
| * @return returns the configuration input |
| * |
| * @since 3.6 |
| */ |
| ILaunchConfiguration getConfiguration() { |
| if(fOriginal == null) { |
| return getWorkingCopy(); |
| } |
| return fOriginal; |
| } |
| |
| /** |
| * updates the button states |
| */ |
| private void updateButtons() { |
| boolean isDirty = isDirty(); |
| fApplyButton.setEnabled(isDirty && canSave()); |
| fRevertButton.setEnabled(isDirty); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.Viewer#setInput(java.lang.Object) |
| */ |
| public void setInput(final Object input) { |
| if(DebugUIPlugin.getStandardDisplay().getThread().equals(Thread.currentThread())) { |
| setInput0(input); |
| } |
| else { |
| DebugUIPlugin.getStandardDisplay().syncExec(new Runnable() { |
| @Override |
| public void run() { |
| setInput0(input); |
| } |
| }); |
| } |
| |
| } |
| /** |
| * Sets the input to the tab group viewer |
| * @param input the new input |
| * @since 3.3 |
| */ |
| private void setInput0(Object input) { |
| if (input == null) { |
| if (getConfiguration() == null) { |
| return; |
| } |
| inputChanged(input); |
| } else { |
| if (!input.equals(getConfiguration())) { |
| inputChanged(input); |
| } |
| } |
| } |
| |
| /** |
| * The input has changed to the given object, possibly <code>null</code>. |
| * |
| * @param input the new input, possibly <code>null</code> |
| */ |
| protected void inputChanged(Object input) { |
| final Object finput = input; |
| Runnable r = new Runnable() { |
| @Override |
| public void run() { |
| try { |
| fViewform.setRedraw(false); |
| if (finput instanceof ILaunchConfiguration) { |
| ILaunchConfiguration configuration = (ILaunchConfiguration)finput; |
| boolean refreshtabs = !delegatesEqual(fWorkingCopy, configuration); |
| fOriginal = configuration; |
| fWorkingCopy = configuration.getWorkingCopy(); |
| displayInstanceTabs(refreshtabs); |
| } else if (finput instanceof ILaunchConfigurationType) { |
| fDescription = getDescription((ILaunchConfigurationType)finput); |
| setNoInput(); |
| } else { |
| setNoInput(); |
| } |
| } catch (CoreException ce) { |
| errorDialog(ce); |
| setNoInput(); |
| } |
| finally { |
| refreshStatus(); |
| fViewform.setRedraw(true); |
| } |
| } |
| }; |
| BusyIndicator.showWhile(getShell().getDisplay(), r); |
| } |
| |
| /** |
| * Sets the tab group viewer to have no input, this is the case when null is passed as an input type |
| * Setting no input is equivalent to resetting all items, clearing any messages and showing the 'getting started' pane |
| * @since 3.2 |
| */ |
| private void setNoInput() { |
| fOriginal = null; |
| fWorkingCopy = null; |
| disposeExistingTabs(); |
| updateButtons(); |
| updateVisibleControls(false); |
| ILaunchConfigurationDialog lcd = getLaunchConfigurationDialog(); |
| if(lcd instanceof LaunchConfigurationsDialog) { |
| if(((LaunchConfigurationsDialog)lcd).isTreeSelectionEmpty()) { |
| fDescription = IInternalDebugCoreConstants.EMPTY_STRING; |
| } |
| } |
| } |
| |
| /** |
| * Returns if the two configurations are using the same <code>ILaunchDelegate</code> or not |
| * @param config1 the config to compare to |
| * @param config2 the config to compare |
| * @return true if the configurations are using the same <code>ILaunchDelegate</code> or false if they are not |
| * @since 3.3 |
| */ |
| protected boolean delegatesEqual(ILaunchConfiguration config1, ILaunchConfiguration config2) { |
| try { |
| if(config1 == null || config2 == null) { |
| return false; |
| } |
| if (config1.getType().equals(config2.getType())) { |
| Set<String> modes = getCurrentModeSet(); |
| ILaunchDelegate d1 = config1.getPreferredDelegate(modes); |
| if(d1 == null) { |
| d1 = config1.getType().getPreferredDelegate(modes); |
| } |
| ILaunchDelegate d2 = config2.getPreferredDelegate(modes); |
| if(d2 == null) { |
| d2 = config2.getType().getPreferredDelegate(modes); |
| } |
| if (d1 == null) { |
| return d2 == null; |
| } else { |
| return d1.equals(d2); |
| } |
| } |
| } |
| catch(CoreException ce) {DebugUIPlugin.log(ce);} |
| return false; |
| } |
| |
| /** |
| * Updates the visibility of controls based on the status provided |
| * @param visible the visibility status to be applied to the controls |
| */ |
| private void updateVisibleControls(boolean visible) { |
| fApplyButton.setVisible(visible); |
| fRevertButton.setVisible(visible); |
| fOptionsLink.setVisible(visible); |
| if(visible) { |
| ((StackLayout)fTabPlaceHolder.getLayout()).topControl = fGroupComposite; |
| } |
| else { |
| ((StackLayout)fTabPlaceHolder.getLayout()).topControl = fGettingStarted; |
| } |
| fTabPlaceHolder.layout(true, true); |
| } |
| |
| /** |
| * sets the current widget focus to the 'Name' widget |
| */ |
| protected void setFocusOnName() { |
| fNameWidget.setFocus(); |
| } |
| |
| /** |
| * Displays tabs for the current working copy |
| * @param redrawTabs if the tabs should be redrawn |
| */ |
| protected void displayInstanceTabs(boolean redrawTabs) { |
| // Turn on initializing flag to ignore message updates |
| fInitializingTabs = true; |
| ILaunchConfigurationType type = null; |
| try { |
| type = getWorkingCopy().getType(); |
| } |
| catch (CoreException e) { |
| errorDialog(e); |
| fInitializingTabs = false; |
| return; |
| } |
| if(redrawTabs) { |
| showInstanceTabsFor(type); |
| } |
| // show the name area |
| updateVisibleControls(true); |
| |
| // Retrieve the current tab group. If there is none, clean up and leave |
| ILaunchConfigurationTabGroup tabGroup = getTabGroup(); |
| if (tabGroup == null) { |
| IStatus status = new Status(IStatus.ERROR, DebugUIPlugin.getUniqueIdentifier(), 0, MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_No_tabs_defined_for_launch_configuration_type__0__1, new Object[] { type.getName() }), null); |
| CoreException e = new CoreException(status); |
| errorDialog(e); |
| fInitializingTabs = false; |
| return; |
| } |
| |
| // Update the tabs with the new working copy |
| tabGroup.initializeFrom(getWorkingCopy()); |
| |
| // Update the name field |
| fNameWidget.setText(getWorkingCopy().getName()); |
| |
| fCurrentTabIndex = fTabFolder.getSelectionIndex(); |
| |
| // Turn off initializing flag to update message |
| fInitializingTabs = false; |
| |
| if (!fViewform.isVisible()) { |
| fViewform.setVisible(true); |
| } |
| } |
| |
| /** |
| * Populate the tabs in the configuration edit area to be appropriate to the current |
| * launch configuration type. |
| * @param configType the type to show tabs for |
| */ |
| private void showInstanceTabsFor(ILaunchConfigurationType configType) { |
| // try to keep on same tab |
| Class<? extends ILaunchConfigurationTab> tabKind = null; |
| if (getActiveTab() != null) { |
| tabKind = getActiveTab().getClass(); |
| } |
| // Build the new tabs |
| ILaunchConfigurationTabGroup group = null; |
| try { |
| group = createGroup(); |
| } catch (CoreException ce) { |
| DebugUIPlugin.errorDialog(getShell(), LaunchConfigurationsMessages.LaunchConfigurationDialog_Error_19, LaunchConfigurationsMessages.LaunchConfigurationDialog_Exception_occurred_creating_launch_configuration_tabs_27,ce); // |
| return; |
| } |
| disposeExistingTabs(); |
| fTabGroup = group; |
| ILaunchConfigurationTab[] tabs = getTabs(); |
| CTabItem tab = null; |
| String name = IInternalDebugCoreConstants.EMPTY_STRING; |
| Control control = null; |
| for (int i = 0; i < tabs.length; i++) { |
| tab = new CTabItem(fTabFolder, SWT.BORDER); |
| name = tabs[i].getName(); |
| if (name == null) { |
| name = LaunchConfigurationsMessages.LaunchConfigurationDialog_unspecified_28; |
| } |
| tab.setText(name); |
| tab.setImage(tabs[i].getImage()); |
| ScrolledComposite sc = new ScrolledComposite(tab.getParent(), SWT.V_SCROLL | SWT.H_SCROLL); |
| sc.setFont(tab.getParent().getFont()); |
| sc.setExpandHorizontal(true); |
| sc.setExpandVertical(true); |
| sc.setShowFocusedControl(true); |
| tabs[i].createControl(sc); |
| control = tabs[i].getControl(); |
| if (control != null) { |
| sc.setContent(control); |
| sc.setMinSize(control.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| tab.setControl(control.getParent()); |
| } |
| } |
| //set the default tab as the first one |
| if (tabs.length > 0) { |
| setActiveTab(tabs[0]); |
| } |
| // select same tab as before, if possible |
| for (int i = 0; i < tabs.length; i++) { |
| if (tabs[i].getClass().equals(tabKind)) { |
| setActiveTab(tabs[i]); |
| break; |
| } |
| } |
| fDescription = getDescription(configType); |
| } |
| |
| /** |
| * Returns the description of the given configuration type |
| * in the current mode or <code>null</code> if none. |
| * |
| * @param configType the config type |
| * @return the description of the given configuration type or <code>null</code> |
| */ |
| private String getDescription(ILaunchConfigurationType configType) { |
| String description = null; |
| if(configType != null) { |
| String mode = fDialog.getMode(); |
| description = LaunchConfigurationPresentationManager.getDefault().getDescription(configType, mode); |
| } |
| if (description == null) { |
| description = IInternalDebugCoreConstants.EMPTY_STRING; |
| } |
| return description; |
| } |
| |
| /** |
| * Returns tab group for the given type of launch configuration. |
| * Tabs are initialized to be contained in this dialog. |
| * @return the new {@link ILaunchConfigurationTabGroup} |
| * |
| * @exception CoreException if unable to instantiate a tab group |
| */ |
| protected ILaunchConfigurationTabGroup createGroup() throws CoreException { |
| // Use a final Object array to store the tab group and any exception that |
| // results from the Runnable |
| final Object[] finalArray = new Object[2]; |
| Runnable runnable = new Runnable() { |
| @Override |
| public void run() { |
| ILaunchConfigurationTabGroup tabGroup = null; |
| try { |
| tabGroup = LaunchConfigurationPresentationManager.getDefault().getTabGroup(getWorkingCopy(), getLaunchConfigurationDialog().getMode()); |
| finalArray[0] = tabGroup; |
| } catch (CoreException ce) { |
| finalArray[1] = ce; |
| return; |
| } |
| tabGroup.createTabs(getLaunchConfigurationDialog(), getLaunchConfigurationDialog().getMode()); |
| ILaunchConfigurationTab[] tabs = tabGroup.getTabs(); |
| for (int i = 0; i < tabs.length; i++) { |
| tabs[i].setLaunchConfigurationDialog(getLaunchConfigurationDialog()); |
| } |
| } |
| }; |
| |
| // Creating the tabs can result in plug-in loading, so we show the busy cursor |
| BusyIndicator.showWhile(getControl().getDisplay(), runnable); |
| |
| // Re-throw any CoreException if there was one |
| if (finalArray[1] != null) { |
| throw (CoreException)finalArray[1]; |
| } |
| |
| // Otherwise return the tab group |
| return (ILaunchConfigurationTabGroup)finalArray[0]; |
| } |
| |
| /** |
| * Returns the tabs currently being displayed, or |
| * <code>null</code> if none. |
| * |
| * @return currently displayed tabs, or <code>null</code> |
| */ |
| public ILaunchConfigurationTab[] getTabs() { |
| if (getTabGroup() != null) { |
| return getTabGroup().getTabs(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the currently active <code>ILaunchConfigurationTab</code> |
| * being displayed, or <code>null</code> if there is none. |
| * |
| * @return currently active <code>ILaunchConfigurationTab</code>, or <code>null</code>. |
| */ |
| public ILaunchConfigurationTab getActiveTab() { |
| ILaunchConfigurationTab[] tabs = getTabs(); |
| if (fTabFolder != null && tabs != null) { |
| int pageIndex = fTabFolder.getSelectionIndex(); |
| if (pageIndex >= 0) { |
| return tabs[pageIndex]; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns whether the launch configuration being edited is dirty (i.e. |
| * needs saving) |
| * |
| * @return whether the launch configuration being edited needs saving |
| */ |
| public boolean isDirty() { |
| ILaunchConfigurationWorkingCopy workingCopy = getWorkingCopy(); |
| if (workingCopy == null) { |
| return false; |
| } |
| if(workingCopy.getParent() != null) { |
| return !workingCopy.getParent().contentsEqual(workingCopy); |
| } |
| // Working copy hasn't been saved |
| if (workingCopy.getOriginal() == null) { |
| return true; |
| } |
| return fOriginal != null && !fOriginal.contentsEqual(workingCopy); |
| } |
| |
| /** |
| * Returns the job to update the launch configuration dialog. |
| * |
| * @return update job |
| */ |
| private Job getUpdateJob() { |
| if (fRefreshJob == null) { |
| fRefreshJob = createUpdateJob(); |
| fRefreshJob.setSystem(true); |
| } |
| return fRefreshJob; |
| } |
| |
| /** |
| * Schedules the update job to run for this tab based on this tab's delay. |
| * |
| * @since 3.6 |
| */ |
| protected void scheduleUpdateJob() { |
| Job job = getUpdateJob(); |
| job.cancel(); // cancel existing job |
| job.schedule(getUpdateJobDelay()); |
| } |
| |
| /** |
| * Return the time delay that should be used when scheduling the |
| * update job. Subclasses may override. |
| * |
| * @return a time delay in milliseconds before the job should run |
| * @since 3.6 |
| */ |
| protected long getUpdateJobDelay() { |
| return 200; |
| } |
| |
| /** |
| * Creates and returns a job used to update the launch configuration dialog |
| * for this tab. Subclasses may override. |
| * |
| * @return job to update the launch dialog for this tab |
| * @since 3.6 |
| */ |
| protected Job createUpdateJob() { |
| return new WorkbenchJob(getControl().getDisplay(), "Update LCD") { //$NON-NLS-1$ |
| @Override |
| public IStatus runInUIThread(IProgressMonitor monitor) { |
| if (!getControl().isDisposed()) { |
| refreshStatus(); |
| } |
| return Status.OK_STATUS; |
| } |
| @Override |
| public boolean shouldRun() { |
| return !getControl().isDisposed(); |
| } |
| }; |
| } |
| |
| /** |
| * Update apply & revert buttons, as well as buttons and message on the |
| * launch config dialog. |
| */ |
| protected void refreshStatus() { |
| if (!fInitializingTabs) { |
| LaunchConfigurationsDialog lcd = (LaunchConfigurationsDialog) getLaunchConfigurationDialog(); |
| lcd.refreshStatus(); |
| } |
| } |
| |
| /** |
| * Returns the containing launch dialog |
| * @return the current {@link ILaunchConfigurationDialog} |
| */ |
| protected ILaunchConfigurationDialog getLaunchConfigurationDialog() { |
| return fDialog; |
| } |
| |
| /** |
| * Returns the original launch configuration being edited, possibly |
| * <code>null</code>. |
| * |
| * @return ILaunchConfiguration |
| */ |
| protected ILaunchConfiguration getOriginal() { |
| return fOriginal; |
| } |
| |
| /** |
| * Returns the working copy used to edit the original, possibly |
| * <code>null</code>. |
| * @return the backing {@link ILaunchConfigurationWorkingCopy} |
| */ |
| protected ILaunchConfigurationWorkingCopy getWorkingCopy() { |
| return fWorkingCopy; |
| } |
| |
| /** |
| * Return whether the current configuration can be saved. |
| * <p> |
| * Note this is NOT the same thing as the config simply being valid. It |
| * is possible to save a config that does not validate. This method |
| * determines whether the config can be saved without causing a serious |
| * error. For example, a shared config that has no specified location would |
| * cause this method to return <code>false</code>. |
| * </p> |
| * @return if the dialog can save in its current state |
| */ |
| public boolean canSave() { |
| if (fInitializingTabs) { |
| return false; |
| } |
| // First make sure that name doesn't prevent saving the config |
| try { |
| verifyName(); |
| } catch (CoreException ce) { |
| return false; |
| } |
| |
| // Next, make sure none of the tabs object to saving the config |
| ILaunchConfigurationTab[] tabs = getTabs(); |
| if (tabs == null) { |
| return false; |
| } |
| for (int i = 0; i < tabs.length; i++) { |
| if (!tabs[i].canSave()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * @return if the dialog can launch in its current state |
| */ |
| public boolean canLaunch() { |
| if(fInitializingTabs) { |
| return false; |
| } |
| if (getWorkingCopy() == null) { |
| return false; |
| } |
| try { |
| verifyName(); |
| } catch (CoreException e) { |
| return false; |
| } |
| |
| ILaunchConfigurationTab[] tabs = getTabs(); |
| if (tabs == null) { |
| return false; |
| } |
| for (int i = 0; i < tabs.length; i++) { |
| if (!tabs[i].isValid(getWorkingCopy())) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Determines if the tab groups that is currently visible can launch with the currently selected |
| * set of options. |
| * |
| * @return true if the dialog can launch with the given set of modes, false otherwise |
| * |
| * @since 3.3 |
| */ |
| public boolean canLaunchWithModes() { |
| if(fInitializingTabs) { |
| return false; |
| } |
| //check if selected options exist and that the selected combination can be launched |
| try { |
| ILaunchConfigurationWorkingCopy wc = getWorkingCopy(); |
| if(wc != null) { |
| return wc.getType().supportsModeCombination(getCurrentModeSet()); |
| } |
| } catch (CoreException e) { |
| } |
| return true; |
| } |
| |
| /** |
| * Returns if the type currently showing in the tab group viewer has duplicate launch delegates for the given set of modes. |
| * |
| * The given set of modes comprises the current mode that the launch dialog was opened in as well as any modes that have been set on the launch |
| * configuration. |
| * @return the true if there are duplicates, false otherwise |
| * |
| * @since 3.3 |
| */ |
| public boolean hasDuplicateDelegates() { |
| if(fInitializingTabs) { |
| return false; |
| } |
| ILaunchConfiguration config = getWorkingCopy(); |
| if(config != null) { |
| if(hasMultipleDelegates()) { |
| return getPreferredDelegate() == null; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Determines if the currently showing launch configuration has multiple launch delegates for the same mode set, but does not care |
| * if there has been a default selected yet or not |
| * @return true if the current launch configuration has multiple launch delegates, false otherwise |
| */ |
| private boolean hasMultipleDelegates() { |
| ILaunchConfiguration config = getWorkingCopy(); |
| if(config != null) { |
| try { |
| Set<String> modes = getCurrentModeSet(); |
| ILaunchDelegate[] delegates = LaunchConfigurationManager.filterLaunchDelegates(config.getType(), modes); |
| return delegates.length > 1; |
| } |
| catch (CoreException ce) {DebugUIPlugin.log(ce);} |
| } |
| return false; |
| } |
| |
| /** |
| * Returns the current error message or <code>null</code> if none. |
| * @return the error message for the tab |
| */ |
| public String getErrorMesssage() { |
| if (fInitializingTabs) { |
| return null; |
| } |
| |
| if (getWorkingCopy() == null) { |
| return null; |
| } |
| try { |
| verifyName(); |
| } catch (CoreException ce) { |
| return ce.getStatus().getMessage(); |
| } |
| |
| if(hasDuplicateDelegates()) { |
| return LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_18; |
| } |
| |
| String message = null; |
| ILaunchConfigurationTab activeTab = getActiveTab(); |
| if (activeTab == null) { |
| return null; |
| } |
| message = activeTab.getErrorMessage(); |
| if (message != null) { |
| return message; |
| } |
| |
| ILaunchConfigurationTab[] allTabs = getTabs(); |
| for (int i = 0; i < allTabs.length; i++) { |
| ILaunchConfigurationTab tab = allTabs[i]; |
| if (tab == activeTab) { |
| continue; |
| } |
| message = tab.getErrorMessage(); |
| if (message != null) { |
| StringBuffer temp= new StringBuffer(); |
| temp.append('['); |
| temp.append(DebugUIPlugin.removeAccelerators(tab.getName())); |
| temp.append("]: "); //$NON-NLS-1$ |
| temp.append(message); |
| return temp.toString(); |
| } |
| } |
| if(!canLaunchWithModes()) { |
| Set<String> modes = getCurrentModeSet(); |
| List<String> names = LaunchConfigurationPresentationManager.getDefault().getLaunchModeNames(modes); |
| return MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_14, new Object[] { names.toString() }); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the current message or <code>null</code> if none. |
| * @return Returns an appropriate message for display to user. The message returned will be: |
| * The message defined by the visible tab, |
| * or The tab group description for the particular launch mode, |
| * or The generic tab group description, |
| * or <code>null</code> if no message is defined |
| */ |
| public String getMessage() { |
| if (fInitializingTabs) { |
| return null; |
| } |
| |
| String message = fDescription; |
| |
| ILaunchConfigurationTab tab = getActiveTab(); |
| if (tab != null) { |
| String tabMessage = tab.getMessage(); |
| if (tabMessage != null) { |
| message = tabMessage; |
| } |
| } |
| |
| return message; |
| } |
| |
| /** |
| * Returns the current warning message or <code>null</code> if none. |
| * @return Returns an appropriate warning message for display to user. The message returned will be: |
| * The warning message defined by the visible tab |
| * or <code>null</code> if no message is defined |
| */ |
| public String getWarningMessage() { |
| if (fInitializingTabs) { |
| return null; |
| } |
| |
| String message = null; |
| |
| ILaunchConfigurationTab tab = getActiveTab(); |
| if (tab instanceof ILaunchConfigurationTab2) { |
| String tabMessage = ((ILaunchConfigurationTab2)tab).getWarningMessage(); |
| if (tabMessage != null) { |
| message = tabMessage; |
| } |
| } |
| |
| return message; |
| } |
| |
| /** |
| * Verify that the launch configuration name is valid. |
| * @throws CoreException if a name conflict occurs |
| */ |
| protected void verifyName() throws CoreException { |
| if (fNameWidget.isVisible()) { |
| ILaunchManager mgr = DebugPlugin.getDefault().getLaunchManager(); |
| String currentName = fNameWidget.getText().trim(); |
| |
| // If there is no name, complain |
| if (currentName.length() < 1) { |
| throw new CoreException(new Status(IStatus.ERROR, |
| DebugUIPlugin.getUniqueIdentifier(), |
| 0, |
| LaunchConfigurationsMessages.LaunchConfigurationDialog_Name_required_for_launch_configuration_11, |
| null)); |
| } |
| try { |
| mgr.isValidLaunchConfigurationName(currentName); |
| } |
| catch(IllegalArgumentException iae) { |
| throw new CoreException(new Status(IStatus.ERROR, |
| DebugUIPlugin.getUniqueIdentifier(), |
| 0, |
| iae.getMessage(), |
| null)); |
| } |
| // Otherwise, if there's already a config with the same name, complain |
| if (fOriginal != null && !fOriginal.getName().equals(currentName)) { |
| Set<String> reservednames = ((LaunchConfigurationsDialog) getLaunchConfigurationDialog()).getReservedNameSet(); |
| if (mgr.isExistingLaunchConfigurationName(currentName) || (reservednames != null ? reservednames.contains(currentName) : false)) { |
| ILaunchConfiguration config = ((LaunchManager)mgr).findLaunchConfiguration(currentName); |
| //config cannot be null at this location since the manager knows the name conflicts |
| throw new CoreException(new Status(IStatus.ERROR, |
| DebugUIPlugin.getUniqueIdentifier(), |
| 0, |
| NLS.bind(LaunchConfigurationsMessages.LaunchConfigurationDialog_Launch_configuration_already_exists_with_this_name_12, config.getType().getName()), |
| null)); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Remove the existing tabs that are showing |
| */ |
| private void disposeExistingTabs() { |
| fDisposingTabs = true; |
| fTabFolder.dispose(); |
| fTabFolder = null; |
| createTabFolder(fGroupComposite); |
| disposeTabGroup(); |
| fDisposingTabs = false; |
| } |
| |
| /** |
| * Returns the current tab group |
| * |
| * @return the current tab group, or <code>null</code> if none |
| */ |
| public ILaunchConfigurationTabGroup getTabGroup() { |
| return fTabGroup; |
| } |
| |
| /** |
| * Notification that a tab has been selected |
| * |
| * Disallow tab changing when the current tab is invalid. |
| * Update the config from the tab being left, and refresh |
| * the tab being entered. |
| */ |
| protected void handleTabSelected() { |
| if (fDisposingTabs || fInitializingTabs) { |
| return; |
| } |
| ILaunchConfigurationTab[] tabs = getTabs(); |
| if (fCurrentTabIndex == fTabFolder.getSelectionIndex() || tabs == null || tabs.length == 0 || fCurrentTabIndex > (tabs.length - 1)) { |
| return; |
| } |
| if (fCurrentTabIndex != -1) { |
| ILaunchConfigurationTab tab = tabs[fCurrentTabIndex]; |
| ILaunchConfigurationWorkingCopy wc = getWorkingCopy(); |
| if (wc != null) { |
| tab.deactivated(wc); |
| getActiveTab().activated(wc); |
| } |
| } |
| fCurrentTabIndex = fTabFolder.getSelectionIndex(); |
| } |
| |
| /** |
| * Notification the name field has been modified |
| */ |
| protected void handleNameModified() { |
| getWorkingCopy().rename(fNameWidget.getText().trim()); |
| scheduleUpdateJob(); |
| } |
| |
| /** |
| * Notification that the 'Apply' button has been pressed. |
| * |
| * @return the saved launch configuration or <code>null</code> if not saved |
| */ |
| protected ILaunchConfiguration handleApplyPressed() { |
| if(fOriginal != null && fOriginal.isReadOnly()) { |
| IStatus status = ResourcesPlugin.getWorkspace().validateEdit(new IFile[] {fOriginal.getFile()}, fViewerControl.getShell()); |
| if(!status.isOK()) { |
| return null; |
| } |
| } |
| Exception exception = null; |
| final ILaunchConfiguration[] saved = new ILaunchConfiguration[1]; |
| try { |
| // update launch config |
| fInitializingTabs = true; |
| // trim name |
| String trimmed = fNameWidget.getText().trim(); |
| fNameWidget.setText(trimmed); |
| if(fWorkingCopy == null) { |
| fWorkingCopy = fOriginal.getWorkingCopy(); |
| } |
| fWorkingCopy.rename(trimmed); |
| getTabGroup().performApply(fWorkingCopy); |
| if (isDirty()) { |
| if(!fWorkingCopy.isLocal()) { |
| IRunnableWithProgress runnable = new IRunnableWithProgress() { |
| @Override |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { |
| try { |
| saved[0] = ((LaunchConfigurationWorkingCopy)fWorkingCopy).doSave(monitor); |
| } |
| catch (CoreException e) {DebugUIPlugin.log(e);} |
| } |
| }; |
| getLaunchConfigurationDialog().run(true, false, runnable); |
| } |
| else { |
| saved[0] = fWorkingCopy.doSave(); |
| } |
| } |
| updateButtons(); |
| fInitializingTabs = false; |
| } |
| catch (CoreException e) {exception = e;} |
| catch (InvocationTargetException e) {exception = e;} |
| catch (InterruptedException e) {exception = e;} |
| if(exception != null) { |
| DebugUIPlugin.errorDialog(getShell(), LaunchConfigurationsMessages.LaunchConfigurationDialog_Launch_Configuration_Error_46, LaunchConfigurationsMessages.LaunchConfigurationDialog_Exception_occurred_while_saving_launch_configuration_47, exception); // |
| return null; |
| } else { |
| return saved[0]; |
| } |
| } |
| |
| /** |
| * Notification that the 'Revert' button has been pressed |
| */ |
| protected void handleRevertPressed() { |
| try { |
| if(fTabGroup != null) { |
| fTabGroup.initializeFrom(fOriginal); |
| fNameWidget.setText(fOriginal.getName()); |
| fWorkingCopy = fOriginal.getWorkingCopy(); |
| refreshStatus(); |
| } |
| } |
| catch (CoreException e) {DebugUIPlugin.log(e);} |
| } |
| |
| /** |
| * Show an error dialog on the given exception. |
| * |
| * @param exception the exception to display |
| */ |
| protected void errorDialog(CoreException exception) { |
| ErrorDialog.openError(getShell(), null, null, exception.getStatus()); |
| } |
| |
| /** |
| * Sets the displayed tab to the given tab. Has no effect if the specified |
| * tab is not one of the tabs being displayed in the dialog currently. |
| * |
| * @param tab the tab to display/activate |
| */ |
| public void setActiveTab(ILaunchConfigurationTab tab) { |
| ILaunchConfigurationTab[] tabs = getTabs(); |
| if(tabs != null) { |
| for (int i = 0; i < tabs.length; i++) { |
| if (tabs[i].getClass().equals(tab.getClass())) { |
| setActiveTab(i); |
| return; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Sets the displayed tab to the tab with the given index. Has no effect if |
| * the specified index is not within the limits of the tabs returned by |
| * <code>getTabs()</code>. |
| * |
| * @param index the index of the tab to display |
| */ |
| public void setActiveTab(int index) { |
| ILaunchConfigurationTab[] tabs = getTabs(); |
| if (index >= 0 && index < tabs.length) { |
| fTabFolder.setSelection(index); |
| handleTabSelected(); |
| } |
| } |
| |
| } |