package org.eclipse.dltk.javascript.internal.debug.ui.launchConfigurations;
/*******************************************************************************
* Copyright (c) 2000, 2006 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
*******************************************************************************/
import java.io.IOException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IContainer;
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.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsMessages;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchGroupExtension;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchHistory;
import org.eclipse.debug.ui.AbstractLaunchConfigurationTab;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.ILaunchGroup;
import org.eclipse.debug.ui.StringVariableSelectionDialog;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.environment.EnvironmentManager;
import org.eclipse.dltk.core.environment.IExecutionEnvironment;
import org.eclipse.dltk.core.environment.IFileHandle;
import org.eclipse.dltk.debug.ui.messages.DLTKLaunchConfigurationsMessages;
import org.eclipse.dltk.internal.ui.util.SWTUtil;
import org.eclipse.dltk.javascript.launching.JavaScriptLaunchingPlugin;
import org.eclipse.dltk.launching.ScriptLaunchConfigurationConstants;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.Viewer;
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.events.SelectionListener;
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.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchEncoding;
import org.eclipse.ui.dialogs.ContainerSelectionDialog;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.ide.IDEEncoding;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.ui.views.navigator.ResourceSorter;
/**
* Launch configuration tab used to specify the location a launch configuration
* is stored in, whether it should appear in the favorites list, and perspective
* switching behavior for an associated launch.
* <p>
* Clients may instantiate this class. This class is not intended to be
* subclassed.
* </p>
*
*
*/
public class JavaScriptCommonTab extends AbstractLaunchConfigurationTab {
/**
* Provides a persistable dialog for selecting the shared project location
*/
class SharedLocationSelectionDialog extends ContainerSelectionDialog {
private final String SETTINGS_ID = IDebugUIConstants.PLUGIN_ID
+ ".SHARED_LAUNCH_CONFIGURATON_DIALOG"; //$NON-NLS-1$
public SharedLocationSelectionDialog(Shell parentShell,
IContainer initialRoot, boolean allowNewContainerName,
String message) {
super(parentShell, initialRoot, allowNewContainerName, message);
}
protected IDialogSettings getDialogBoundsSettings() {
IDialogSettings settings = DebugUIPlugin.getDefault()
.getDialogSettings();
IDialogSettings section = settings.getSection(SETTINGS_ID);
if (section == null) {
section = settings.addNewSection(SETTINGS_ID);
}
return section;
}
}
private static final String EMPTY_STRING = ""; //$NON-NLS-1$
// Local/shared UI widgets
private Button fLocalRadioButton;
private Button fSharedRadioButton;
private Text fSharedLocationText;
private Button fSharedLocationButton;
private Button fLaunchInBackgroundButton;
private Button fDefaultEncodingButton;
private Button fAltEncodingButton;
private Combo fEncodingCombo;
private Button fConsoleOutput;
private Button fFileOutput;
private Button fFileBrowse;
private Text fFileText;
private Button fVariables;
private Button fAppend;
private Button fWorkspaceBrowse;
private Button fUseDltkRadio;
private Button fNotUseDltkRatio;
/**
* Check box list for specifying favorites
*/
private CheckboxTableViewer fFavoritesTable;
/**
* Modify listener that simply updates the owning launch configuration
* dialog.
*/
private ModifyListener fBasicModifyListener = new ModifyListener() {
public void modifyText(ModifyEvent evt) {
updateLaunchConfigurationDialog();
}
};
/*
* (non-Javadoc)
*
* @see
* org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse
* .swt.widgets.Composite)
*/
public void createControl(Composite parent) {
Composite comp = new Composite(parent, SWT.NONE);
setControl(comp);
PlatformUI
.getWorkbench()
.getHelpSystem()
.setHelp(
getControl(),
IDebugHelpContextIds.LAUNCH_CONFIGURATION_DIALOG_COMMON_TAB);
comp.setLayout(new GridLayout(2, true));
comp.setFont(parent.getFont());
createSharedConfigComponent(comp);
createFavoritesComponent(comp);
createEncodingComponent(comp);
createOutputCaptureComponent(comp);
createLaunchInBackgroundComponent(comp);
}
/**
* Creates the favorites control
*
* @param parent
* the parent composite to add this one to
*
*/
private void createFavoritesComponent(Composite parent) {
Group favComp = SWTUtil
.createGroup(
parent,
LaunchConfigurationsMessages.CommonTab_Display_in_favorites_menu__10,
1, 1, GridData.FILL_BOTH);
fFavoritesTable = CheckboxTableViewer.newCheckList(favComp, SWT.CHECK
| SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION);
Control table = fFavoritesTable.getControl();
GridData gd = new GridData(GridData.FILL_BOTH);
table.setLayoutData(gd);
table.setFont(parent.getFont());
fFavoritesTable.setContentProvider(new FavoritesContentProvider());
fFavoritesTable.setLabelProvider(new FavoritesLabelProvider());
fFavoritesTable.addCheckStateListener(new ICheckStateListener() {
public void checkStateChanged(CheckStateChangedEvent event) {
updateLaunchConfigurationDialog();
}
});
}
/**
* Creates the shared config component
*
* @param parent
* the parent composite to add this component to
*
*/
private void createSharedConfigComponent(Composite parent) {
Group group = SWTUtil.createGroup(parent,
LaunchConfigurationsMessages.CommonTab_0, 3, 2,
GridData.FILL_HORIZONTAL);
fLocalRadioButton = createRadioButton(group,
LaunchConfigurationsMessages.CommonTab_L_ocal_3);
GridData gd = new GridData();
gd.horizontalSpan = 3;
fLocalRadioButton.setLayoutData(gd);
fSharedRadioButton = createRadioButton(group,
LaunchConfigurationsMessages.CommonTab_S_hared_4);
fSharedRadioButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent evt) {
handleSharedRadioButtonSelected();
}
});
fSharedLocationText = SWTUtil.createSingleText(group, 1);
fSharedLocationText.addModifyListener(fBasicModifyListener);
fSharedLocationButton = createPushButton(group,
LaunchConfigurationsMessages.CommonTab__Browse_6, null);
fSharedLocationButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent evt) {
handleSharedLocationButtonSelected();
}
});
fLocalRadioButton.setSelection(true);
setSharedEnabled(false);
}
/**
* Creates the component set for the capture output composite
*
* @param parent
* the parent to add this component to
*/
private void test() {
}
private void createOutputCaptureComponent(Composite parent) {
Group group = SWTUtil.createGroup(parent, "Input and Output", 1, 2,
GridData.FILL_HORIZONTAL);
fUseDltkRadio = createRadioButton(group, "Use DLTK Input and Output");
fUseDltkRadio.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
updateLaunchConfigurationDialog();
}
});
fNotUseDltkRatio = createRadioButton(group,
"Use Standard Input and Output");
fNotUseDltkRatio.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
updateLaunchConfigurationDialog();
}
});
Group standardGroup = SWTUtil.createGroup(group, "", 5, 2,
GridData.FILL_HORIZONTAL);
fConsoleOutput = createCheckButton(standardGroup,
LaunchConfigurationsMessages.CommonTab_5);
GridData gd = new GridData(SWT.BEGINNING, SWT.NORMAL, true, false);
gd.horizontalSpan = 5;
fConsoleOutput.setLayoutData(gd);
fConsoleOutput.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
updateLaunchConfigurationDialog();
}
});
fFileOutput = createCheckButton(standardGroup,
LaunchConfigurationsMessages.CommonTab_6);
fFileOutput.setLayoutData(new GridData(SWT.BEGINNING, SWT.NORMAL,
false, false));
fFileOutput.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
enableOuputCaptureWidgets(fFileOutput.getSelection());
updateLaunchConfigurationDialog();
}
});
fFileText = SWTUtil.createSingleText(standardGroup, 4);
fFileText.addModifyListener(fBasicModifyListener);
SWTUtil.createLabel(standardGroup, EMPTY_STRING, 2);
fWorkspaceBrowse = createPushButton(standardGroup,
LaunchConfigurationsMessages.CommonTab_12, null);
fWorkspaceBrowse.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(
getShell(), new WorkbenchLabelProvider(),
new WorkbenchContentProvider());
dialog.setTitle(LaunchConfigurationsMessages.CommonTab_13);
dialog.setMessage(LaunchConfigurationsMessages.CommonTab_14);
dialog.setInput(ResourcesPlugin.getWorkspace().getRoot());
dialog.setSorter(new ResourceSorter(ResourceSorter.NAME));
if (dialog.open() == IDialogConstants.OK_ID) {
IResource resource = (IResource) dialog.getFirstResult();
String arg = resource.getFullPath().toString();
String fileLoc = VariablesPlugin.getDefault()
.getStringVariableManager()
.generateVariableExpression("workspace_loc", arg); //$NON-NLS-1$
fFileText.setText(fileLoc);
}
}
});
fFileBrowse = createPushButton(standardGroup,
LaunchConfigurationsMessages.CommonTab_7, null);
fFileBrowse.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
String filePath = fFileText.getText();
FileDialog dialog = new FileDialog(getShell(), SWT.SAVE);
filePath = dialog.open();
if (filePath != null) {
fFileText.setText(filePath);
}
}
});
fVariables = createPushButton(standardGroup,
LaunchConfigurationsMessages.CommonTab_9, null);
fVariables.addSelectionListener(new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
StringVariableSelectionDialog dialog = new StringVariableSelectionDialog(
getShell());
dialog.open();
String variable = dialog.getVariableExpression();
if (variable != null) {
fFileText.insert(variable);
}
}
public void widgetDefaultSelected(SelectionEvent e) {
}
});
fAppend = createCheckButton(standardGroup,
LaunchConfigurationsMessages.CommonTab_11);
gd = new GridData(SWT.LEFT, SWT.TOP, true, false);
gd.horizontalSpan = 4;
fAppend.setLayoutData(gd);
fAppend.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
updateLaunchConfigurationDialog();
}
});
}
/**
* Enables or disables the output capture widgets based on the the specified
* enablement
*
* @param enable
* if the output capture widgets should be enabled or not
*
*/
private void enableOuputCaptureWidgets(boolean enable) {
fFileText.setEnabled(enable);
fFileBrowse.setEnabled(enable);
fWorkspaceBrowse.setEnabled(enable);
fVariables.setEnabled(enable);
fAppend.setEnabled(enable);
}
/**
* Creates the encoding component
*
* @param parent
* the parent to add this composite to
*/
private void createEncodingComponent(Composite parent) {
List allEncodings = IDEEncoding.getIDEEncodings();
String defaultEncoding = WorkbenchEncoding
.getWorkbenchDefaultEncoding();
Group group = SWTUtil.createGroup(parent,
LaunchConfigurationsMessages.CommonTab_1, 2, 1,
GridData.FILL_BOTH);
fDefaultEncodingButton = createRadioButton(group, MessageFormat.format(
LaunchConfigurationsMessages.CommonTab_2,
new String[] { defaultEncoding }));
GridData gd = new GridData(SWT.BEGINNING, SWT.NORMAL, true, false);
gd.horizontalSpan = 2;
fDefaultEncodingButton.setLayoutData(gd);
fAltEncodingButton = createRadioButton(group,
LaunchConfigurationsMessages.CommonTab_3);
fAltEncodingButton.setLayoutData(new GridData(
GridData.HORIZONTAL_ALIGN_BEGINNING));
fEncodingCombo = new Combo(group, SWT.READ_ONLY);
fEncodingCombo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
fEncodingCombo.setFont(parent.getFont());
String[] encodingArray = (String[]) allEncodings.toArray(new String[0]);
fEncodingCombo.setItems(encodingArray);
if (encodingArray.length > 0) {
fEncodingCombo.select(0);
}
SelectionListener listener = new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
updateLaunchConfigurationDialog();
fEncodingCombo
.setEnabled(fAltEncodingButton.getSelection() == true);
}
};
fAltEncodingButton.addSelectionListener(listener);
fDefaultEncodingButton.addSelectionListener(listener);
fEncodingCombo.addSelectionListener(listener);
}
/**
* Creates the controls needed to edit the launch in background attribute of
* an external tool
*
* @param parent
* the composite to create the controls in
*/
protected void createLaunchInBackgroundComponent(Composite parent) {
fLaunchInBackgroundButton = createCheckButton(parent,
LaunchConfigurationsMessages.CommonTab_10);
GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
data.horizontalSpan = 2;
fLaunchInBackgroundButton.setLayoutData(data);
fLaunchInBackgroundButton.setFont(parent.getFont());
fLaunchInBackgroundButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
updateLaunchConfigurationDialog();
}
});
}
/**
* handles the shared radio button being selected
*/
private void handleSharedRadioButtonSelected() {
setSharedEnabled(isShared());
updateLaunchConfigurationDialog();
}
/**
* Sets the widgets for specifying that a launch configuration is to be
* shared to the enable value
*
* @param enable
* the enabled value for
*/
private void setSharedEnabled(boolean enable) {
fSharedLocationText.setEnabled(enable);
fSharedLocationButton.setEnabled(enable);
}
private String getDefaultSharedConfigLocation(ILaunchConfiguration config) {
String path = EMPTY_STRING;
try {
IResource[] res = config.getMappedResources();
if (res != null) {
IProject proj;
for (int i = 0; i < res.length; i++) {
proj = res[i].getProject();
if (proj.isAccessible()) {
return proj.getFullPath().toOSString();
}
}
}
} catch (CoreException e) {
DebugUIPlugin.log(e);
}
return path;
}
/**
* if the shared radio button is selected, indicating that the launch
* configuration is to be shared
*
* @return true if the radio button is selected, false otherwise
*/
private boolean isShared() {
return fSharedRadioButton.getSelection();
}
/**
* Handles the shared location button being selected
*/
private void handleSharedLocationButtonSelected() {
String currentContainerString = fSharedLocationText.getText();
IContainer currentContainer = getContainer(currentContainerString);
SharedLocationSelectionDialog dialog = new SharedLocationSelectionDialog(
getShell(),
currentContainer,
false,
LaunchConfigurationsMessages.CommonTab_Select_a_location_for_the_launch_configuration_13);
dialog.showClosedProjects(false);
dialog.open();
Object[] results = dialog.getResult();
if ((results != null) && (results.length > 0)
&& (results[0] instanceof IPath)) {
IPath path = (IPath) results[0];
String containerName = path.toOSString();
fSharedLocationText.setText(containerName);
}
}
/**
* gets the container form the specified path
*
* @param path
* the path to get the container from
* @return the container for the specified path or null if one cannot be
* determined
*/
private IContainer getContainer(String path) {
Path containerPath = new Path(path);
return (IContainer) getWorkspaceRoot().findMember(containerPath);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.debug.ui.ILaunchConfigurationTab#initializeFrom(org.eclipse
* .debug.core.ILaunchConfiguration)
*/
public void initializeFrom(ILaunchConfiguration configuration) {
boolean isShared = !configuration.isLocal();
fSharedRadioButton.setSelection(isShared);
fLocalRadioButton.setSelection(!isShared);
setSharedEnabled(isShared);
fSharedLocationText
.setText(getDefaultSharedConfigLocation(configuration));
if (isShared) {
String containerName = EMPTY_STRING;
IFile file = configuration.getFile();
if (file != null) {
IContainer parent = file.getParent();
if (parent != null) {
containerName = parent.getFullPath().toOSString();
}
}
fSharedLocationText.setText(containerName);
}
updateFavoritesFromConfig(configuration);
updateLaunchInBackground(configuration);
updateEncoding(configuration);
updateConsoleOutput(configuration);
}
/**
* Updates the console output form the local configuration
*
* @param configuration
* the local configuration
*/
private void updateConsoleOutput(ILaunchConfiguration configuration) {
boolean outputToConsole = true;
String outputFile = null;
boolean append = false;
boolean dltkOutput = false;
try {
dltkOutput = configuration
.getAttribute(
ScriptLaunchConfigurationConstants.ATTR_USE_INTERACTIVE_CONSOLE,
false);
outputToConsole = configuration.getAttribute(
IDebugUIConstants.ATTR_CAPTURE_IN_CONSOLE, true);
outputFile = configuration.getAttribute(
IDebugUIConstants.ATTR_CAPTURE_IN_FILE, (String) null);
append = configuration.getAttribute(
IDebugUIConstants.ATTR_APPEND_TO_FILE, false);
} catch (CoreException e) {
}
fUseDltkRadio.setSelection(dltkOutput);
fNotUseDltkRatio.setSelection(!dltkOutput);
fConsoleOutput.setSelection(outputToConsole);
fAppend.setSelection(append);
boolean haveOutputFile = outputFile != null;
if (haveOutputFile) {
fFileText.setText(outputFile);
}
fFileOutput.setSelection(haveOutputFile);
enableOuputCaptureWidgets(haveOutputFile);
}
/**
* Updates the launch on background check button
*
* @param configuration
* the local launch configuration
*/
protected void updateLaunchInBackground(ILaunchConfiguration configuration) {
fLaunchInBackgroundButton
.setSelection(isLaunchInBackground(configuration));
}
/**
* Updates the encoding
*
* @param configuration
* the local configuration
*/
private void updateEncoding(ILaunchConfiguration configuration) {
String encoding = null;
try {
encoding = configuration.getAttribute(
IDebugUIConstants.ATTR_CONSOLE_ENCODING, (String) null);
} catch (CoreException e) {
}
if (encoding != null) {
fAltEncodingButton.setSelection(true);
fDefaultEncodingButton.setSelection(false);
fEncodingCombo.setText(encoding);
fEncodingCombo.setEnabled(true);
} else {
fDefaultEncodingButton.setSelection(true);
fAltEncodingButton.setSelection(false);
fEncodingCombo.setEnabled(false);
}
}
/**
* Returns whether the given configuration should be launched in the
* background.
*
* @param configuration
* the configuration
* @return whether the configuration is configured to launch in the
* background
*/
public static boolean isLaunchInBackground(
ILaunchConfiguration configuration) {
boolean launchInBackground = true;
try {
launchInBackground = configuration.getAttribute(
IDebugUIConstants.ATTR_LAUNCH_IN_BACKGROUND, true);
} catch (CoreException ce) {
DebugUIPlugin.log(ce);
}
return launchInBackground;
}
/**
* Updates the favorites selections from the local configuration
*
* @param config
* the local configuration
*/
private void updateFavoritesFromConfig(ILaunchConfiguration config) {
fFavoritesTable.setInput(config);
fFavoritesTable.setCheckedElements(new Object[] {});
try {
List groups = config.getAttribute(
IDebugUIConstants.ATTR_FAVORITE_GROUPS, new ArrayList());
if (groups.isEmpty()) {
// check old attributes for backwards compatible
if (config.getAttribute(IDebugUIConstants.ATTR_DEBUG_FAVORITE,
false)) {
groups.add(IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP);
}
if (config.getAttribute(IDebugUIConstants.ATTR_RUN_FAVORITE,
false)) {
groups.add(IDebugUIConstants.ID_RUN_LAUNCH_GROUP);
}
}
if (!groups.isEmpty()) {
List list = new ArrayList();
Iterator iterator = groups.iterator();
while (iterator.hasNext()) {
String id = (String) iterator.next();
LaunchGroupExtension extension = getLaunchConfigurationManager()
.getLaunchGroup(id);
list.add(extension);
}
fFavoritesTable.setCheckedElements(list.toArray());
}
} catch (CoreException e) {
DebugUIPlugin.log(e);
}
}
/**
* Updates the configuration form the local shared config working copy
*
* @param config
* the local shared config working copy
*/
private void updateConfigFromLocalShared(
ILaunchConfigurationWorkingCopy config) {
if (isShared()) {
String containerPathString = fSharedLocationText.getText();
IContainer container = getContainer(containerPathString);
config.setContainer(container);
} else {
config.setContainer(null);
}
}
/**
* Convenience accessor
*/
protected LaunchConfigurationManager getLaunchConfigurationManager() {
return DebugUIPlugin.getDefault().getLaunchConfigurationManager();
}
/**
* Update the favorite settings.
*
* NOTE: set to <code>null</code> instead of <code>false</code> for
* backwards compatibility when comparing if content is equal, since 'false'
* is default and will be missing for older configurations.
*/
private void updateConfigFromFavorites(
ILaunchConfigurationWorkingCopy config) {
try {
Object[] checked = fFavoritesTable.getCheckedElements();
boolean debug = config.getAttribute(
IDebugUIConstants.ATTR_DEBUG_FAVORITE, false);
boolean run = config.getAttribute(
IDebugUIConstants.ATTR_RUN_FAVORITE, false);
if (debug || run) {
// old attributes
List groups = new ArrayList();
int num = 0;
if (debug) {
groups.add(getLaunchConfigurationManager().getLaunchGroup(
IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP));
num++;
}
if (run) {
num++;
groups.add(getLaunchConfigurationManager().getLaunchGroup(
IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP));
}
// see if there are any changes
if (num == checked.length) {
boolean different = false;
for (int i = 0; i < checked.length; i++) {
if (!groups.contains(checked[i])) {
different = true;
break;
}
}
if (!different) {
return;
}
}
}
config.setAttribute(IDebugUIConstants.ATTR_DEBUG_FAVORITE,
(String) null);
config.setAttribute(IDebugUIConstants.ATTR_RUN_FAVORITE,
(String) null);
List groups = null;
for (int i = 0; i < checked.length; i++) {
LaunchGroupExtension group = (LaunchGroupExtension) checked[i];
if (groups == null) {
groups = new ArrayList();
}
groups.add(group.getIdentifier());
}
config.setAttribute(IDebugUIConstants.ATTR_FAVORITE_GROUPS, groups);
} catch (CoreException e) {
DebugUIPlugin.log(e);
}
}
/**
* Convenience method for getting the workspace root.
*/
private IWorkspaceRoot getWorkspaceRoot() {
return ResourcesPlugin.getWorkspace().getRoot();
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.debug.ui.ILaunchConfigurationTab#isValid(org.eclipse.debug
* .core.ILaunchConfiguration)
*/
public boolean isValid(ILaunchConfiguration config) {
setMessage(null);
setErrorMessage(null);
return validateLocalShared() && validateRedirectFile()
&& validateEncoding();
}
/**
* validates the encoding selection
*
* @return true if the validate encoding is allowable, false otherwise
*/
private boolean validateEncoding() {
if (fAltEncodingButton.getSelection()) {
if (fEncodingCombo.getSelectionIndex() == -1) {
setErrorMessage(DLTKLaunchConfigurationsMessages.commonTab_EncodingNotSupported);
return false;
}
}
return true;
}
/**
* Validates if the redirect file is valid
*
* @return true if the filename is not zero, false otherwise
*/
private boolean validateRedirectFile() {
if (fFileOutput.getSelection()) {
int len = fFileText.getText().trim().length();
if (len == 0) {
setErrorMessage(LaunchConfigurationsMessages.CommonTab_8);
return false;
}
}
return true;
}
/**
* validates the local shared config file location
*
* @return true if the local shared file exists, false otherwise
*/
private boolean validateLocalShared() {
if (isShared()) {
String path = fSharedLocationText.getText().trim();
IContainer container = getContainer(path);
if (container == null
|| container.equals(ResourcesPlugin.getWorkspace()
.getRoot())) {
setErrorMessage(LaunchConfigurationsMessages.CommonTab_Invalid_shared_configuration_location_14);
return false;
} else if (!container.getProject().isOpen()) {
setErrorMessage(LaunchConfigurationsMessages.CommonTab_Cannot_save_launch_configuration_in_a_closed_project__1);
return false;
}
}
return true;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.debug.ui.ILaunchConfigurationTab#setDefaults(org.eclipse.
* debug.core.ILaunchConfigurationWorkingCopy)
*/
public void setDefaults(ILaunchConfigurationWorkingCopy config) {
config.setContainer(null);
config.setAttribute(IDebugUIConstants.ATTR_LAUNCH_IN_BACKGROUND, true);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(org.eclipse
* .debug.core.ILaunchConfigurationWorkingCopy)
*/
public void performApply(ILaunchConfigurationWorkingCopy configuration) {
updateConfigFromLocalShared(configuration);
updateConfigFromFavorites(configuration);
setAttribute(IDebugUIConstants.ATTR_LAUNCH_IN_BACKGROUND,
configuration, fLaunchInBackgroundButton.getSelection(), true);
String encoding = null;
if (fAltEncodingButton.getSelection()) {
encoding = fEncodingCombo.getText();
}
configuration.setAttribute(DebugPlugin.ATTR_CONSOLE_ENCODING, encoding);
boolean captureOutput = false;
if (fConsoleOutput.getSelection()) {
captureOutput = true;
configuration.setAttribute(
IDebugUIConstants.ATTR_CAPTURE_IN_CONSOLE, (String) null);
configuration.setAttribute(
ScriptLaunchConfigurationConstants.ATTR_DLTK_CONSOLE_ID,
Long.toString(System.currentTimeMillis()));
} else {
configuration.setAttribute(
IDebugUIConstants.ATTR_CAPTURE_IN_CONSOLE, false);
}
if (fFileOutput.getSelection()) {
captureOutput = true;
String file = fFileText.getText();
configuration.setAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_FILE,
file);
if (fAppend.getSelection()) {
configuration.setAttribute(
IDebugUIConstants.ATTR_APPEND_TO_FILE, true);
} else {
configuration.setAttribute(
IDebugUIConstants.ATTR_APPEND_TO_FILE, (String) null);
}
} else {
configuration.setAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_FILE,
(String) null);
}
boolean useDltk = false;
if (fUseDltkRadio.getSelection()) {
configuration.setAttribute(DebugPlugin.ATTR_CAPTURE_OUTPUT,
(String) null);
IFileHandle proxyFile;
try {
IExecutionEnvironment exeEnv = (IExecutionEnvironment) EnvironmentManager
.getLocalEnvironment().getAdapter(
IExecutionEnvironment.class);
proxyFile = JavaScriptLaunchingPlugin.getDefault()
.getConsoleProxy(exeEnv);
if (proxyFile != null) {
configuration.setAttribute("environmentId", proxyFile
.getEnvironment().getId());
configuration.setAttribute("proxy_path",
proxyFile.toOSString());
}
} catch (IOException e) {
if (DLTKCore.DEBUG) {
e.printStackTrace();
}
}
captureOutput = false;
useDltk = true;
}
configuration
.setAttribute(
ScriptLaunchConfigurationConstants.ATTR_USE_INTERACTIVE_CONSOLE,
useDltk);
// Last option
if (captureOutput) {
configuration.setAttribute(DebugPlugin.ATTR_CAPTURE_OUTPUT,
(String) null);
} else {
configuration.setAttribute(DebugPlugin.ATTR_CAPTURE_OUTPUT, false);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#getName()
*/
public String getName() {
return LaunchConfigurationsMessages.CommonTab__Common_15;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#canSave()
*/
public boolean canSave() {
return validateLocalShared();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#getImage()
*/
public Image getImage() {
return DebugUITools
.getImage(IInternalDebugUIConstants.IMG_OBJS_COMMON_TAB);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.debug.ui.ILaunchConfigurationTab#activated(org.eclipse.debug
* .core.ILaunchConfigurationWorkingCopy)
*/
public void activated(ILaunchConfigurationWorkingCopy workingCopy) {
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.debug.ui.ILaunchConfigurationTab#deactivated(org.eclipse.
* debug.core.ILaunchConfigurationWorkingCopy)
*/
public void deactivated(ILaunchConfigurationWorkingCopy workingCopy) {
}
/**
* Content provider for the favorites table
*/
class FavoritesContentProvider implements IStructuredContentProvider {
public Object[] getElements(Object inputElement) {
ILaunchGroup[] groups = DebugUITools.getLaunchGroups();
List possibleGroups = new ArrayList();
ILaunchConfiguration configuration = (ILaunchConfiguration) inputElement;
for (int i = 0; i < groups.length; i++) {
ILaunchGroup extension = groups[i];
LaunchHistory history = getLaunchConfigurationManager()
.getLaunchHistory(extension.getIdentifier());
if (history != null && history.accepts(configuration)) {
possibleGroups.add(extension);
}
}
return possibleGroups.toArray();
}
public void dispose() {
}
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
}
/**
* Provides the labels for the favorites table
*
*/
class FavoritesLabelProvider implements ITableLabelProvider {
private Map fImages = new HashMap();
public Image getColumnImage(Object element, int columnIndex) {
Image image = (Image) fImages.get(element);
if (image == null) {
ImageDescriptor descriptor = ((LaunchGroupExtension) element)
.getImageDescriptor();
if (descriptor != null) {
image = descriptor.createImage();
fImages.put(element, image);
}
}
return image;
}
public String getColumnText(Object element, int columnIndex) {
String label = ((LaunchGroupExtension) element).getLabel();
return DebugUIPlugin.removeAccelerators(label);
}
public void addListener(ILabelProviderListener listener) {
}
public void dispose() {
Iterator images = fImages.values().iterator();
while (images.hasNext()) {
Image image = (Image) images.next();
image.dispose();
}
}
public boolean isLabelProperty(Object element, String property) {
return false;
}
public void removeListener(ILabelProviderListener listener) {
}
}
}