+ * A status handler may be registered for this error condition, + * and should return a Boolean indicating whether the program + * should be relaunched with the default working directory. + *
+ */ + public static final int ERR_WORKING_DIRECTORY_NOT_SUPPORTED = 115; + + /** + * Status code indicating an unexpected internal error. + */ + public static final int ERR_INTERNAL_ERROR = 150; + + /** + * Status code indicating the specified working directory + * does not exist. + */ + public static final int ERR_WORKING_DIRECTORY_DOES_NOT_EXIST = 108; + +} diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/LocalCLaunchConfigurationDelegate.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/LocalCLaunchConfigurationDelegate.java new file mode 100644 index 00000000000..8027f54322e --- /dev/null +++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/LocalCLaunchConfigurationDelegate.java @@ -0,0 +1,328 @@ +package org.eclipse.cdt.launch.internal; + +/* + * (c) Copyright QNX Software System 2002. + * All Rights Reserved. + */ + +import java.io.File; +import java.io.IOException; +import java.text.DateFormat; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import org.eclipse.cdt.core.CCorePlugin; +import org.eclipse.cdt.core.model.ICProject; +import org.eclipse.cdt.debug.core.CDebugCorePlugin; +import org.eclipse.cdt.debug.core.CDebugModel; +import org.eclipse.cdt.debug.core.ICDebugger; +import org.eclipse.cdt.debug.core.ICDebuggerManager; +import org.eclipse.cdt.debug.core.cdi.ICDIRuntimeOptions; +import org.eclipse.cdt.debug.core.cdi.ICDISession; +import org.eclipse.cdt.debug.core.cdi.model.ICDITarget; +import org.eclipse.cdt.launch.ICDTLaunchConfigurationConstants; +import org.eclipse.cdt.launch.internal.ui.LaunchUIPlugin; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.Platform; +import org.eclipse.core.runtime.Status; +import org.eclipse.debug.core.DebugPlugin; +import org.eclipse.debug.core.ILaunch; +import org.eclipse.debug.core.ILaunchConfiguration; +import org.eclipse.debug.core.ILaunchManager; +import org.eclipse.debug.core.IStatusHandler; +import org.eclipse.debug.core.model.ILaunchConfigurationDelegate; +import org.eclipse.debug.core.model.IProcess; + +/** + * Insert the type's description here. + * @see ILaunchConfigurationDelegate + */ +public class LocalCLaunchConfigurationDelegate implements ILaunchConfigurationDelegate { + + protected String renderDebugTarget(ICDISession session) { +// String format= "{0} at localhost {1}"; +// return MessageFormat.format(format, new String[] { classToRun, String.valueOf(host) }); + return "session -- TODO"; + } + + public static String renderProcessLabel(String[] commandLine) { + String format= "{0} ({1})"; + String timestamp= DateFormat.getInstance().format(new Date(System.currentTimeMillis())); + return MessageFormat.format(format, new String[] { commandLine[0], timestamp }); + } + + protected static String renderCommandLine(String[] commandLine) { + if (commandLine.length < 1) + return ""; + StringBuffer buf= new StringBuffer(commandLine[0]); + for (int i= 1; i < commandLine.length; i++) { + buf.append(' '); + buf.append(commandLine[i]); + } + return buf.toString(); + } + public void launch(ILaunchConfiguration configuration, String mode, ILaunch launch, IProgressMonitor monitor) + throws CoreException { + if (monitor == null) { + monitor = new NullProgressMonitor(); + } + + monitor.beginTask("Launching Local C Application", IProgressMonitor.UNKNOWN); + // check for cancellation + if (monitor.isCanceled()) { + return; + } + ICProject cproject = getCProject(configuration); + IPath projectPath = Platform.getLocation().append(cproject.getResource().getFullPath()); + projectPath = projectPath.append(getProgramName(configuration)); + String arguments[] = getProgramArgumentsArray(configuration); + ArrayList command = new ArrayList(1+arguments.length); + command.add(projectPath.toOSString()); + command.addAll(Arrays.asList(arguments)); + + if (mode.equals(ILaunchManager.DEBUG_MODE)) { + ICDebuggerManager dbgmanager = CDebugCorePlugin.getDefault().getDebuggerManager(); + ICDebugger cdebugger = dbgmanager.createDebugger(configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_CDT_DEBUGGER_ID, "")); + IFile exe = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(projectPath); + ICDISession dsession = cdebugger.createLaunchSession(configuration, exe); + ICDIRuntimeOptions opt = dsession.getRuntimeOptions(); + opt.setArguments(configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, "")); + File wd = getWorkingDir(configuration); + if ( wd != null ) { + opt.setWorkingDirectory(wd.toString()); + } + opt.setEnvironment(getEnvironmentProperty(configuration)); + ICDITarget dtarget = dsession.getTargets()[0]; +// Process process = dtarget.getProcess(); +// IProcess iprocess = DebugPlugin.newProcess(launch, process, renderProcessLabel((String [])command.toArray(new String[command.size()]))); +// CDebugModel.newDebugTarget(launch, dsession.getTargets()[0], renderDebugTarget(dsession), iprocess, true, false, false ); + } + else { + Process process = exec((String [])command.toArray(new String[command.size()]), getEnvironmentArray(configuration), getWorkingDir(configuration)); + DebugPlugin.getDefault().newProcess(launch, process, "label"); + } + monitor.done(); + } + + private String[] getEnvironmentArray(ILaunchConfiguration configuration) { +// Map env = configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ENVIROMENT_MAP, (Map) null); +// TODO create env array; + return null; + } + + private Properties getEnvironmentProperty(ILaunchConfiguration configuration) { +// Map env = configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ENVIROMENT_MAP, (Map) null); + return new Properties(); + } + + + protected File getWorkingDir(ILaunchConfiguration config) throws CoreException { + String path = config.getAttribute(ICDTLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, (String)null); + if (path == null) { + return null; + } + File dir = new File(path); + if (!dir.isDirectory()) { + abort("Specified working directory does not exist or is not a directory", null, ICDTLaunchConfigurationConstants.ERR_WORKING_DIRECTORY_DOES_NOT_EXIST); + } + return dir; + } + + /** + * Throws a core exception with an error status object built from + * the given message, lower level exception, and error code. + * + * @param message the status message + * @param exception lower level exception associated with the + * error, ornull if none
+ * @param code error code
+ */
+ protected void abort(String message, Throwable exception, int code) throws CoreException {
+ throw new CoreException(new Status(IStatus.ERROR, LaunchUIPlugin.getUniqueIdentifier(), code, message, exception));
+ }
+
+ /**
+ * Performs a runtime exec on the given command line in the context
+ * of the specified working directory, and returns
+ * the resulting process. If the current runtime does not support the
+ * specification of a working directory, the status handler for error code
+ * ERR_WORKING_DIRECTORY_NOT_SUPPORTED is queried to see if the
+ * exec should be re-executed without specifying a working directory.
+ *
+ * @param cmdLine the command line
+ * @param workingDirectory the working directory, or null
+ * @return the resulting process or null if the exec is
+ * cancelled
+ * @see Runtime
+ */
+ protected Process exec(String[] cmdLine, String[] envp, File workingDirectory) throws CoreException {
+ Process p = null;
+ try {
+ if (workingDirectory == null) {
+ p = Runtime.getRuntime().exec(cmdLine, envp);
+ }
+ else {
+ p = Runtime.getRuntime().exec(cmdLine, envp, workingDirectory);
+ }
+ }
+ catch (IOException e) {
+ if (p != null) {
+ p.destroy();
+ }
+ abort("Exception starting process", e, ICDTLaunchConfigurationConstants.ERR_INTERNAL_ERROR);
+ }
+ catch (NoSuchMethodError e) {
+ //attempting launches on 1.2.* - no ability to set working directory
+
+ IStatus status = new Status(IStatus.ERROR, LaunchUIPlugin.getUniqueIdentifier(), ICDTLaunchConfigurationConstants.ERR_WORKING_DIRECTORY_NOT_SUPPORTED, "Eclipse runtime does not support working directory", e);
+ IStatusHandler handler = DebugPlugin.getDefault().getStatusHandler(status);
+
+ if (handler != null) {
+ Object result = handler.handleStatus(status, this);
+ if (result instanceof Boolean && ((Boolean) result).booleanValue()) {
+ p = exec(cmdLine, envp, null);
+ }
+ }
+ }
+ return p;
+ }
+
+ public ICProject getCProject(ILaunchConfiguration configuration) throws CoreException {
+ String projectName = getCProjectName(configuration);
+ if (projectName != null) {
+ projectName = projectName.trim();
+ if (projectName.length() > 0) {
+ IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
+ ICProject cProject = CCorePlugin.getDefault().getCoreModel().create(project);
+ if (cProject != null && cProject.exists()) {
+ return cProject;
+ }
+ }
+ }
+ return null;
+ }
+
+ public String getCProjectName(ILaunchConfiguration configuration) throws CoreException {
+ return configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME, (String)null);
+ }
+
+ public String getProgramName(ILaunchConfiguration configuration) throws CoreException {
+ return configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, (String)null);
+ }
+
+ /**
+ * Returns the program arguments as an array of individual arguments.
+ *
+ * @return the program arguments as an array of individual arguments
+ */
+ public String[] getProgramArgumentsArray(ILaunchConfiguration configuration) throws CoreException {
+ String args = configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, (String)null);
+ return parseArguments(args);
+ }
+
+ private static class ArgumentParser {
+ private String fArgs;
+ private int fIndex= 0;
+ private int ch= -1;
+
+ public ArgumentParser(String args) {
+ fArgs= args;
+ }
+
+ public String[] parseArguments() {
+ List v= new ArrayList();
+
+ ch= getNext();
+ while (ch > 0) {
+ while (Character.isWhitespace((char)ch))
+ ch= getNext();
+
+ if (ch == '"') {
+ v.add(parseString());
+ } else {
+ v.add(parseToken());
+ }
+ }
+
+ String[] result= new String[v.size()];
+ v.toArray(result);
+ return result;
+ }
+
+ private int getNext() {
+ if (fIndex < fArgs.length())
+ return fArgs.charAt(fIndex++);
+ return -1;
+ }
+
+ private String parseString() {
+ StringBuffer buf= new StringBuffer();
+ ch= getNext();
+ while (ch > 0 && ch != '"') {
+ if (ch == '\\') {
+ ch= getNext();
+ if (ch != '"') { // Only escape double quotes
+ buf.append('\\');
+ }
+ }
+ if (ch > 0) {
+ buf.append((char)ch);
+ ch= getNext();
+ }
+ }
+
+ ch= getNext();
+
+ return buf.toString();
+ }
+
+ private String parseToken() {
+ StringBuffer buf= new StringBuffer();
+
+ while (ch > 0 && !Character.isWhitespace((char)ch)) {
+ if (ch == '\\') {
+ ch= getNext();
+ if (ch > 0) {
+ if (ch != '"') { // Only escape double quotes
+ buf.append('\\');
+ }
+ buf.append((char)ch);
+ ch= getNext();
+ } else if (ch == -1) { // Don't lose a trailing backslash
+ buf.append('\\');
+ }
+ } else if (ch == '"') {
+ buf.append(parseString());
+ } else {
+ buf.append((char)ch);
+ ch= getNext();
+ }
+ }
+ return buf.toString();
+ }
+ }
+
+ private static String[] parseArguments(String args) {
+ if (args == null)
+ return new String[0];
+ ArgumentParser parser= new ArgumentParser(args);
+ String[] res= parser.parseArguments();
+
+ return res;
+ }
+
+
+}
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/CLaunchConfigurationTab.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/CLaunchConfigurationTab.java
new file mode 100644
index 00000000000..ee8dbcfaaf9
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/CLaunchConfigurationTab.java
@@ -0,0 +1,88 @@
+package org.eclipse.cdt.launch.internal.ui;
+
+import org.eclipse.cdt.core.CCorePlugin;
+import org.eclipse.cdt.core.ICProjectDescriptor;
+import org.eclipse.cdt.core.model.CModelException;
+import org.eclipse.cdt.core.model.CoreModel;
+import org.eclipse.cdt.core.model.ICElement;
+import org.eclipse.cdt.core.model.ICProject;
+import org.eclipse.cdt.launch.ICDTLaunchConfigurationConstants;
+import org.eclipse.core.boot.BootLoader;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
+import org.eclipse.debug.ui.AbstractLaunchConfigurationTab;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IWorkbenchPage;
+
+/*
+ * (c) Copyright QNX Software Systems Ltd. 2002.
+ * All Rights Reserved.
+ */
+public abstract class CLaunchConfigurationTab extends AbstractLaunchConfigurationTab {
+
+ /**
+ * Returns the current C element context from which to initialize
+ * default settings, or null if none.
+ *
+ * @return C element context.
+ */
+ protected ICElement getContext(ILaunchConfigurationWorkingCopy config) throws CoreException {
+ IWorkbenchPage page = LaunchUIPlugin.getActivePage();
+ if (page != null) {
+ ISelection selection = page.getSelection();
+ if (selection instanceof IStructuredSelection) {
+ IStructuredSelection ss = (IStructuredSelection) selection;
+ if (!ss.isEmpty()) {
+ Object obj = ss.getFirstElement();
+ if (obj instanceof ICElement) {
+ ICProjectDescriptor descriptor = CCorePlugin.getDefault().getCProjectDescription(((ICElement)obj).getCProject().getProject());
+ if ( descriptor.getPlatform().equals(getPlatform(config)) )
+ return (ICElement) obj;
+ }
+ if (obj instanceof IResource) {
+ ICElement ce = CoreModel.getDefault().create((IResource) obj);
+ if (ce == null) {
+ IProject pro = ((IResource) obj).getProject();
+ ce = CoreModel.getDefault().create(pro);
+ }
+ if (ce != null) {
+ ICProjectDescriptor descriptor = CCorePlugin.getDefault().getCProjectDescription(ce.getCProject().getProject());
+ if ( descriptor.getPlatform().equals(getPlatform(config)) )
+ return ce;
+ }
+ }
+ }
+ }
+ IEditorPart part = page.getActiveEditor();
+ if (part != null) {
+ IEditorInput input = part.getEditorInput();
+ return (ICElement) input.getAdapter(ICElement.class);
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Set the C project attribute based on the ICElement.
+ */
+ protected void initializeCProject(ICElement cElement, ILaunchConfigurationWorkingCopy config) {
+ ICProject cProject = cElement.getCProject();
+ String name = null;
+ if (cProject != null && cProject.exists()) {
+ name = cProject.getElementName();
+ }
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME, name);
+
+ }
+
+ protected String getPlatform(ILaunchConfiguration config) throws CoreException {
+ String platform = BootLoader.getOS();
+ return config.getAttribute(ICDTLaunchConfigurationConstants.ATTR_CDT_PLATFORM, platform);
+ }
+}
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LaunchImages.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LaunchImages.java
new file mode 100644
index 00000000000..df3baf02d5f
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LaunchImages.java
@@ -0,0 +1,24 @@
+package org.eclipse.cdt.launch.internal.ui;
+
+import org.eclipse.swt.graphics.Image;
+
+/*
+ * (c) Copyright QN Software Systems Ltd. 2002.
+ * All Rights Reserved.
+ */
+public class LaunchImages {
+ public static String IMG_VIEW_ARGUMENTS_TAB = "";
+ public static String IMG_VIEW_ENVIRONMENT_TAB = "";
+ public static String IMG_VIEW_MAIN_TAB = "";
+ public static String IMG_VIEW_DEBUGGER_TAB = "";
+
+ /**
+ * Method get.
+ * @param string
+ * @return Image
+ */
+ public static Image get(String string) {
+ return null;
+ }
+
+}
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LaunchUIPlugin.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LaunchUIPlugin.java
new file mode 100644
index 00000000000..53c6578c0ba
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LaunchUIPlugin.java
@@ -0,0 +1,117 @@
+package org.eclipse.cdt.launch.internal.ui;
+
+import org.eclipse.core.runtime.IPluginDescriptor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.debug.internal.ui.DebugUIMessages;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+
+/*
+ * (c) Copyright QNX Software Systems Ltd. 2002.
+ * All Rights Reserved.
+ */
+public class LaunchUIPlugin extends AbstractUIPlugin {
+
+ /**
+ * Launch UI plug-in instance
+ */
+ private static LaunchUIPlugin fgPlugin;
+
+ /**
+ * Constructor for LaunchUIPlugin.
+ * @param descriptor
+ */
+ public LaunchUIPlugin(IPluginDescriptor descriptor) {
+ super(descriptor);
+ setDefault(this);
+ }
+/**
+ * Sets the Java Debug UI plug-in instance
+ *
+ * @param plugin the plugin instance
+ */
+ private static void setDefault(LaunchUIPlugin plugin) {
+ fgPlugin = plugin;
+ }
+
+ /**
+ * Returns the Java Debug UI plug-in instance
+ *
+ * @return the Java Debug UI plug-in instance
+ */
+ public static LaunchUIPlugin getDefault() {
+ return fgPlugin;
+ }
+
+ /**
+ * Convenience method which returns the unique identifier of this plugin.
+ */
+ public static String getUniqueIdentifier() {
+ if (getDefault() == null) {
+ // If the default instance is not yet initialized,
+ // return a static identifier. This identifier must
+ // match the plugin id defined in plugin.xml
+ return "org.eclipse.jdt.debug.ui"; //$NON-NLS-1$
+ }
+ return getDefault().getDescriptor().getUniqueIdentifier();
+ }
+
+ /**
+ * Logs the specified status with this plug-in's log.
+ *
+ * @param status status to log
+ */
+ public static void log(IStatus status) {
+ getDefault().getLog().log(status);
+ }
+ /**
+ * Logs an internal error with the specified message.
+ *
+ * @param message the error message to log
+ */
+ public static void logErrorMessage(String message) {
+ log(new Status(IStatus.ERROR, getUniqueIdentifier(), IStatus.ERROR, message, null));
+ }
+
+ /**
+ * Logs an internal error with the specified throwable
+ *
+ * @param e the exception to be logged
+ */
+ public static void log(Throwable e) {
+ log(new Status(IStatus.ERROR, getUniqueIdentifier(), IStatus.ERROR, e.getMessage(), e)); //$NON-NLS-1$
+ }
+ /**
+ * Returns the active workbench window
+ *
+ * @return the active workbench window
+ */
+ public static IWorkbenchWindow getActiveWorkbenchWindow() {
+ return getDefault().getWorkbench().getActiveWorkbenchWindow();
+ }
+
+ public static IWorkbenchPage getActivePage() {
+ IWorkbenchWindow w = getActiveWorkbenchWindow();
+ if (w != null) {
+ return w.getActivePage();
+ }
+ return null;
+ }
+
+
+ /**
+ * Returns the active workbench shell or null if none
+ *
+ * @return the active workbench shell or null if none
+ */
+ public static Shell getActiveWorkbenchShell() {
+ IWorkbenchWindow window = getActiveWorkbenchWindow();
+ if (window != null) {
+ return window.getShell();
+ }
+ return null;
+ }
+}
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LocalCLaunchConfigurationTabGroup.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LocalCLaunchConfigurationTabGroup.java
new file mode 100644
index 00000000000..d714e09dbe9
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LocalCLaunchConfigurationTabGroup.java
@@ -0,0 +1,41 @@
+package org.eclipse.cdt.launch.internal.ui;
+
+import java.util.ArrayList;
+
+import org.eclipse.cdt.launch.ICDTLaunchConfigurationConstants;
+import org.eclipse.cdt.launch.ui.CArgumentsTab;
+import org.eclipse.cdt.launch.ui.CDebuggerTab;
+import org.eclipse.cdt.launch.ui.CEnvironmentTab;
+import org.eclipse.cdt.launch.ui.CMainTab;
+import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
+import org.eclipse.debug.core.ILaunchManager;
+import org.eclipse.debug.ui.AbstractLaunchConfigurationTabGroup;
+import org.eclipse.debug.ui.CommonTab;
+import org.eclipse.debug.ui.ILaunchConfigurationDialog;
+import org.eclipse.debug.ui.ILaunchConfigurationTab;
+
+/**
+ * Insert the type's description here.
+ * @see AbstractLaunchConfigurationTabGroup
+ */
+public class LocalCLaunchConfigurationTabGroup extends AbstractLaunchConfigurationTabGroup {
+
+ /**
+ * Insert the method's description here.
+ * @see AbstractLaunchConfigurationTabGroup#createTabs
+ */
+ public void createTabs(ILaunchConfigurationDialog dialog, String mode) {
+ ArrayList tabs = new ArrayList(5);
+
+ tabs.add(new CMainTab());
+ tabs.add(new CArgumentsTab());
+ tabs.add(new CEnvironmentTab());
+ if ( mode.equalsIgnoreCase(ILaunchManager.DEBUG_MODE) ) {
+ tabs.add(new CDebuggerTab() );
+ }
+ tabs.add(new CommonTab());
+
+ setTabs((ILaunchConfigurationTab[])tabs.toArray(new ILaunchConfigurationTab[tabs.size()]));
+ }
+
+}
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/WorkingDirectoryBlock.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/WorkingDirectoryBlock.java
new file mode 100644
index 00000000000..07e80526edc
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/WorkingDirectoryBlock.java
@@ -0,0 +1,405 @@
+package org.eclipse.cdt.launch.internal.ui;
+import java.io.File;
+
+import org.eclipse.cdt.launch.ICDTLaunchConfigurationConstants;
+import org.eclipse.core.resources.IContainer;
+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.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
+import org.eclipse.debug.ui.AbstractLaunchConfigurationTab;
+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.DirectoryDialog;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.dialogs.ContainerSelectionDialog;
+
+/**
+ * A control for setting the working directory associated with a launch
+ * configuration.
+ */
+public class WorkingDirectoryBlock extends AbstractLaunchConfigurationTab {
+
+ // Working directory UI widgets
+ protected Label fWorkingDirLabel;
+
+ // Local directory
+ protected Button fLocalDirButton;
+ protected Text fWorkingDirText;
+ protected Button fWorkingDirBrowseButton;
+
+
+ // Workspace directory
+ protected Button fWorkspaceDirButton;
+ protected Text fWorkspaceDirText;
+ protected Button fWorkspaceDirBrowseButton;
+
+ // use default button
+ protected Button fUseDefaultWorkingDirButton;
+
+ protected static final String EMPTY_STRING = ""; //$NON-NLS-1$
+
+ /**
+ * The last launch config this tab was initialized from
+ */
+ protected ILaunchConfiguration fLaunchConfiguration;
+
+ /**
+ * @see ILaunchConfigurationTab#createControl(Composite)
+ */
+ public void createControl(Composite parent) {
+
+ Composite workingDirComp = new Composite(parent, SWT.NONE);
+// WorkbenchHelp.setHelp(workingDirComp, IJavaDebugHelpContextIds.WORKING_DIRECTORY_BLOCK);;
+ GridLayout workingDirLayout = new GridLayout();
+ workingDirLayout.numColumns = 3;
+ workingDirLayout.marginHeight = 0;
+ workingDirLayout.marginWidth = 0;
+ workingDirComp.setLayout(workingDirLayout);
+ GridData gd = new GridData(GridData.FILL_HORIZONTAL);
+ workingDirComp.setLayoutData(gd);
+ setControl(workingDirComp);
+
+ fWorkingDirLabel = new Label(workingDirComp, SWT.NONE);
+ fWorkingDirLabel.setText("Wor&king directory:");
+ gd = new GridData();
+ gd.horizontalSpan = 3;
+ fWorkingDirLabel.setLayoutData(gd);
+
+ fLocalDirButton = createRadioButton(workingDirComp, "&Local directory");
+ fLocalDirButton.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent evt) {
+ handleLocationButtonSelected();
+ }
+ });
+
+ fWorkingDirText = new Text(workingDirComp, SWT.SINGLE | SWT.BORDER);
+ gd = new GridData(GridData.FILL_HORIZONTAL);
+ fWorkingDirText.setLayoutData(gd);
+ fWorkingDirText.addModifyListener(new ModifyListener() {
+ public void modifyText(ModifyEvent evt) {
+ updateLaunchConfigurationDialog();
+ }
+ });
+
+ fWorkingDirBrowseButton = createPushButton(workingDirComp, "&Browse", null);
+ fWorkingDirBrowseButton.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent evt) {
+ handleWorkingDirBrowseButtonSelected();
+ }
+ });
+
+ fWorkspaceDirButton = createRadioButton(workingDirComp, "Works&pace");
+ fWorkspaceDirButton.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent evt) {
+ handleLocationButtonSelected();
+ }
+ });
+
+ fWorkspaceDirText = new Text(workingDirComp, SWT.SINGLE | SWT.BORDER);
+ gd = new GridData(GridData.FILL_HORIZONTAL);
+ fWorkspaceDirText.setLayoutData(gd);
+ fWorkspaceDirText.addModifyListener(new ModifyListener() {
+ public void modifyText(ModifyEvent evt) {
+ updateLaunchConfigurationDialog();
+ }
+ });
+
+ fWorkspaceDirBrowseButton = createPushButton(workingDirComp, "B&rowse...", null);
+ fWorkspaceDirBrowseButton.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent evt) {
+ handleWorkspaceDirBrowseButtonSelected();
+ }
+ });
+
+ fUseDefaultWorkingDirButton = new Button(workingDirComp,SWT.CHECK);
+ fUseDefaultWorkingDirButton.setText("Use de&fault working directory");
+ gd = new GridData();
+ gd.horizontalSpan = 3;
+ fUseDefaultWorkingDirButton.setLayoutData(gd);
+ fUseDefaultWorkingDirButton.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent evt) {
+ handleUseDefaultWorkingDirButtonSelected();
+ }
+ });
+
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#dispose()
+ */
+ public void dispose() {
+ }
+
+ /**
+ * Show a dialog that lets the user select a working directory
+ */
+ protected void handleWorkingDirBrowseButtonSelected() {
+ DirectoryDialog dialog = new DirectoryDialog(getShell());
+ dialog.setMessage("Select a &working directory for the launch configuration");
+ String currentWorkingDir = fWorkingDirText.getText();
+ if (!currentWorkingDir.trim().equals(EMPTY_STRING)) {
+ File path = new File(currentWorkingDir);
+ if (path.exists()) {
+ dialog.setFilterPath(currentWorkingDir);
+ }
+ }
+
+ String selectedDirectory = dialog.open();
+ if (selectedDirectory != null) {
+ fWorkingDirText.setText(selectedDirectory);
+ }
+ }
+
+ /**
+ * Show a dialog that lets the user select a working directory from
+ * the workspace
+ */
+ protected void handleWorkspaceDirBrowseButtonSelected() {
+ ContainerSelectionDialog dialog = new ContainerSelectionDialog(getShell(),
+ ResourcesPlugin.getWorkspace().getRoot(),
+ false,
+ "Select a &workspace relative working directory");
+
+ IContainer currentContainer = getContainer();
+ if (currentContainer != null) {
+ IPath path = currentContainer.getFullPath();
+ dialog.setInitialSelections(new Object[] {path});
+ }
+
+ 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.makeRelative().toString();
+ fWorkspaceDirText.setText(containerName);
+ }
+ }
+
+ /**
+ * Returns the selected workspace container,or null
+ */
+ protected IContainer getContainer() {
+ IResource res = getResource();
+ if (res instanceof IContainer) {
+ return (IContainer)res;
+ }
+ return null;
+ }
+
+ /**
+ * Returns the selected workspace resource, or null
+ */
+ protected IResource getResource() {
+ IPath path = new Path(fWorkspaceDirText.getText());
+ IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+ return root.findMember(path);
+ }
+
+ /**
+ * The "local directory" or "workspace directory" button has been selected.
+ */
+ protected void handleLocationButtonSelected() {
+ if (!isDefaultWorkingDirectory()) {
+ boolean local = isLocalWorkingDirectory();
+ fWorkingDirText.setEnabled(local);
+ fWorkingDirBrowseButton.setEnabled(local);
+ fWorkspaceDirText.setEnabled(!local);
+ fWorkspaceDirBrowseButton.setEnabled(!local);
+ }
+ updateLaunchConfigurationDialog();
+ }
+
+ /**
+ * The default working dir check box has been toggled.
+ */
+ protected void handleUseDefaultWorkingDirButtonSelected() {
+ if (isDefaultWorkingDirectory()) {
+ setDefaultWorkingDir();
+ fLocalDirButton.setEnabled(false);
+ fWorkingDirText.setEnabled(false);
+ fWorkingDirBrowseButton.setEnabled(false);
+ fWorkspaceDirButton.setEnabled(false);
+ fWorkspaceDirText.setEnabled(false);
+ fWorkspaceDirBrowseButton.setEnabled(false);
+ } else {
+ fLocalDirButton.setEnabled(true);
+ fWorkspaceDirButton.setEnabled(true);
+ handleLocationButtonSelected();
+ }
+ }
+
+ /**
+ * Sets the default working directory
+ */
+ protected void setDefaultWorkingDir() {
+ ILaunchConfiguration config = getLaunchConfiguration();
+ if (config != null) {
+// IJavaProject javaProject = JavaRuntime.getJavaProject(config);
+ Object cProject = null;
+ if (cProject != null) {
+// fWorkspaceDirText.setText(cProject.getPath().makeRelative().toOSString());
+ fLocalDirButton.setSelection(false);
+ fWorkspaceDirButton.setSelection(true);
+ return;
+ }
+ }
+
+ fWorkingDirText.setText(System.getProperty("user.dir"));
+ fLocalDirButton.setSelection(true);
+ fWorkspaceDirButton.setSelection(false);
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#isValid(ILaunchConfiguration)
+ */
+ public boolean isValid(ILaunchConfiguration config) {
+
+ setErrorMessage(null);
+ setMessage(null);
+
+ if (isLocalWorkingDirectory()) {
+ String workingDirPath = fWorkingDirText.getText().trim();
+ if (workingDirPath.length() > 0) {
+ File dir = new File(workingDirPath);
+ if (!dir.exists()) {
+ setErrorMessage("Working directory does not exist");
+ return false;
+ }
+ if (!dir.isDirectory()) {
+ setErrorMessage("Working directory is not a directory_11");
+ return false;
+ }
+ }
+ } else {
+ if (getContainer() == null) {
+ setErrorMessage("Specified project or folder does not exist.");
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Defaults are empty.
+ *
+ * @see ILaunchConfigurationTab#setDefaults(ILaunchConfigurationWorkingCopy)
+ */
+ public void setDefaults(ILaunchConfigurationWorkingCopy config) {
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, (String)null);
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, (String)null);
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#initializeFrom(ILaunchConfiguration)
+ */
+ public void initializeFrom(ILaunchConfiguration configuration) {
+ setLaunchConfiguration(configuration);
+ try {
+ String wd = configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, (String)null);
+ fWorkspaceDirText.setText(EMPTY_STRING);
+ fWorkingDirText.setText(EMPTY_STRING);
+ if (wd == null) {
+ fUseDefaultWorkingDirButton.setSelection(true);
+ } else {
+ IPath path = new Path(wd);
+ if (path.isAbsolute()) {
+ fWorkingDirText.setText(wd);
+ fLocalDirButton.setSelection(true);
+ fWorkspaceDirButton.setSelection(false);
+ } else {
+ fWorkspaceDirText.setText(wd);
+ fWorkspaceDirButton.setSelection(true);
+ fLocalDirButton.setSelection(false);
+ }
+ fUseDefaultWorkingDirButton.setSelection(false);
+ }
+ handleUseDefaultWorkingDirButtonSelected();
+ } catch (CoreException e) {
+ setErrorMessage("Exception occurred reading configuration " + e.getStatus().getMessage());
+ LaunchUIPlugin.log(e);
+ }
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#performApply(ILaunchConfigurationWorkingCopy)
+ */
+ public void performApply(ILaunchConfigurationWorkingCopy configuration) {
+ String wd = null;
+ if (!isDefaultWorkingDirectory()) {
+ if (isLocalWorkingDirectory()) {
+ wd = getAttributeValueFrom(fWorkingDirText);
+ } else {
+ IPath path = new Path(fWorkspaceDirText.getText());
+ path = path.makeRelative();
+ wd = path.toString();
+ }
+ }
+ configuration.setAttribute(ICDTLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, wd);
+ }
+
+ /**
+ * Retuns the string in the text widget, or null if empty.
+ *
+ * @return text or null
+ */
+ protected String getAttributeValueFrom(Text text) {
+ String content = text.getText().trim();
+ if (content.length() > 0) {
+ return content;
+ }
+ return null;
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#getName()
+ */
+ public String getName() {
+ return "Working Directory";
+ }
+
+ /**
+ * Returns whether the default working directory is to be used
+ */
+ protected boolean isDefaultWorkingDirectory() {
+ return fUseDefaultWorkingDirButton.getSelection();
+ }
+
+ /**
+ * Returns whether the working directory is local
+ */
+ protected boolean isLocalWorkingDirectory() {
+ return fLocalDirButton.getSelection();
+ }
+
+ /**
+ * Sets the java project currently specified by the
+ * given launch config, if any.
+ */
+ protected void setLaunchConfiguration(ILaunchConfiguration config) {
+ fLaunchConfiguration = config;
+ }
+
+ /**
+ * Returns the current java project context
+ */
+ protected ILaunchConfiguration getLaunchConfiguration() {
+ return fLaunchConfiguration;
+ }
+
+}
+
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CArgumentsTab.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CArgumentsTab.java
new file mode 100644
index 00000000000..e493207e6f9
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CArgumentsTab.java
@@ -0,0 +1,176 @@
+package org.eclipse.cdt.launch.ui;
+
+/*
+ * (c) Copyright QNX Software System 2002.
+ * All Rights Reserved.
+ */
+
+import org.eclipse.cdt.launch.ICDTLaunchConfigurationConstants;
+import org.eclipse.cdt.launch.internal.ui.CLaunchConfigurationTab;
+import org.eclipse.cdt.launch.internal.ui.LaunchImages;
+import org.eclipse.cdt.launch.internal.ui.LaunchUIPlugin;
+import org.eclipse.cdt.launch.internal.ui.WorkingDirectoryBlock;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
+import org.eclipse.debug.ui.ILaunchConfigurationDialog;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+
+/**
+ * A launch configuration tab that displays and edits program arguments,
+ * and working directory launch configuration attributes.
+ * + * This class may be instantiated. This class is not intended to be subclassed. + *
+ */ +public class CArgumentsTab extends CLaunchConfigurationTab { + + // Program arguments UI widgets + protected Label fPrgmArgumentsLabel; + protected Text fPrgmArgumentsText; + + // Working directory + protected WorkingDirectoryBlock fWorkingDirectoryBlock = new WorkingDirectoryBlock(); + + /** + * @see ILaunchConfigurationTab#createControl(Composite) + */ + public void createControl(Composite parent) { + + Composite comp = new Composite(parent, SWT.NONE); + setControl(comp); + GridLayout topLayout = new GridLayout(); + comp.setLayout(topLayout); + GridData gd; + + createVerticalSpacer(comp, 1); + + fPrgmArgumentsLabel = new Label(comp, SWT.NONE); + fPrgmArgumentsLabel.setText("C/C++ Program Arguments:"); + fPrgmArgumentsText = new Text(comp, SWT.MULTI | SWT.WRAP | SWT.BORDER | SWT.V_SCROLL); + gd = new GridData(GridData.FILL_HORIZONTAL); + gd.heightHint = 40; + fPrgmArgumentsText.setLayoutData(gd); + fPrgmArgumentsText.addModifyListener(new ModifyListener() { + public void modifyText(ModifyEvent evt) { + updateLaunchConfigurationDialog(); + } + }); + + createVerticalSpacer(comp, 1); + + fWorkingDirectoryBlock.createControl(comp); + } + + /** + * @see ILaunchConfigurationTab#dispose() + */ + public void dispose() { + } + + /** + * @see ILaunchConfigurationTab#isValid(ILaunchConfiguration) + */ + public boolean isValid(ILaunchConfiguration config) { + return fWorkingDirectoryBlock.isValid(config); + } + + /** + * Defaults are empty. + * + * @see ILaunchConfigurationTab#setDefaults(ILaunchConfigurationWorkingCopy) + */ + public void setDefaults(ILaunchConfigurationWorkingCopy config) { + config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, (String) null); + config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, (String) null); + } + + /** + * @see ILaunchConfigurationTab#initializeFrom(ILaunchConfiguration) + */ + public void initializeFrom(ILaunchConfiguration configuration) { + try { + fPrgmArgumentsText.setText(configuration.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, "")); //$NON-NLS-1$ + fWorkingDirectoryBlock.initializeFrom(configuration); + } + catch (CoreException e) { + setErrorMessage("Exception occurred reading configuration " + e.getStatus().getMessage()); + LaunchUIPlugin.log(e); + } + } + + /** + * @see ILaunchConfigurationTab#performApply(ILaunchConfigurationWorkingCopy) + */ + public void performApply(ILaunchConfigurationWorkingCopy configuration) { + configuration.setAttribute( + ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, + getAttributeValueFrom(fPrgmArgumentsText)); + fWorkingDirectoryBlock.performApply(configuration); + } + + /** + * Retuns the string in the text widget, ornull if empty.
+ *
+ * @return text or null
+ */
+ protected String getAttributeValueFrom(Text text) {
+ String content = text.getText().trim();
+ if (content.length() > 0) {
+ return content;
+ }
+ return null;
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#getName()
+ */
+ public String getName() {
+ return "Arguments";
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#setLaunchConfigurationDialog(ILaunchConfigurationDialog)
+ */
+ public void setLaunchConfigurationDialog(ILaunchConfigurationDialog dialog) {
+ super.setLaunchConfigurationDialog(dialog);
+ fWorkingDirectoryBlock.setLaunchConfigurationDialog(dialog);
+ }
+ /**
+ * @see ILaunchConfigurationTab#getErrorMessage()
+ */
+ public String getErrorMessage() {
+ String m = super.getErrorMessage();
+ if (m == null) {
+ return fWorkingDirectoryBlock.getErrorMessage();
+ }
+ return m;
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#getMessage()
+ */
+ public String getMessage() {
+ String m = super.getMessage();
+ if (m == null) {
+ return fWorkingDirectoryBlock.getMessage();
+ }
+ return m;
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#getImage()
+ */
+ public Image getImage() {
+ return LaunchImages.get(LaunchImages.IMG_VIEW_ARGUMENTS_TAB);
+ }
+
+}
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CDebuggerTab.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CDebuggerTab.java
new file mode 100644
index 00000000000..220de56efc6
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CDebuggerTab.java
@@ -0,0 +1,296 @@
+/*
+ * (c) Copyright QNX Software System Ltd. 2002.
+ * All Rights Reserved.
+ */
+package org.eclipse.cdt.launch.ui;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import org.eclipse.cdt.core.CCorePlugin;
+import org.eclipse.cdt.debug.core.CDebugCorePlugin;
+import org.eclipse.cdt.debug.core.ICDebuggerInfo;
+import org.eclipse.cdt.launch.ICDTLaunchConfigurationConstants;
+import org.eclipse.cdt.launch.internal.ui.CLaunchConfigurationTab;
+import org.eclipse.cdt.launch.internal.ui.LaunchImages;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
+import org.eclipse.debug.ui.ILaunchConfigurationTab;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+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.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Label;
+import sun.awt.windows.ModalityListener;
+
+public class CDebuggerTab extends CLaunchConfigurationTab {
+ ArrayList fDinfo;
+ int fDindex;
+ Combo fDlist;
+
+ // Dynamic Debugger UI widgets
+ protected ILaunchConfigurationTab fDynamicTab;
+ protected Composite fDynamicTabHolder;
+
+ protected ILaunchConfigurationWorkingCopy fWorkingCopy;
+ protected ILaunchConfiguration fLaunchConfiguration;
+
+
+
+ public void createControl(Composite parent) {
+ Composite comp= new Composite(parent, SWT.NONE);
+ setControl(comp);
+ GridLayout topLayout = new GridLayout(2, false);
+ comp.setLayout(topLayout);
+ Label dlabel = new Label(comp, SWT.NONE);
+ dlabel.setText("Debugger:");
+ fDlist = new Combo(comp, SWT.DROP_DOWN|SWT.READ_ONLY);
+ fDlist.addModifyListener(new ModifyListener() {
+ public void modifyText(ModifyEvent e) {
+ handleDebuggerComboBoxModified();
+ }
+ });
+ Group debuggerGroup = new Group(comp, SWT.SHADOW_ETCHED_IN);
+ GridData gd = new GridData(GridData.FILL_BOTH);
+ gd.horizontalSpan = 2;
+ debuggerGroup.setLayoutData(gd);
+ debuggerGroup.setText("Debugger Options");
+ setDynamicTabHolder(new Composite(debuggerGroup, SWT.NONE));
+ GridLayout tabHolderLayout = new GridLayout();
+ tabHolderLayout.marginHeight= 0;
+ tabHolderLayout.marginWidth= 0;
+ tabHolderLayout.numColumns = 1;
+ getDynamicTabHolder().setLayout(tabHolderLayout);
+ gd = new GridData(GridData.FILL_BOTH);
+ getDynamicTabHolder().setLayoutData(gd);
+
+ }
+
+ protected void setDynamicTabHolder(Composite tabHolder) {
+ this.fDynamicTabHolder = tabHolder;
+ }
+
+ protected Composite getDynamicTabHolder() {
+ return fDynamicTabHolder;
+ }
+
+ protected void setDynamicTab(ILaunchConfigurationTab tab) {
+ fDynamicTab = tab;
+ }
+
+ protected ILaunchConfigurationTab getDynamicTab() {
+ return fDynamicTab;
+ }
+
+
+ /**
+ * Notification that the user changed the selection in the JRE combo box.
+ */
+ protected void handleDebuggerComboBoxModified() {
+ loadDynamicDebugArea();
+
+ // always set the newly created area with defaults
+ ILaunchConfigurationWorkingCopy wc = getLaunchConfigurationWorkingCopy();
+ if (getDynamicTab() == null) {
+ // remove any VM specfic args from the config
+ if (wc == null) {
+ if (getLaunchConfiguration().isWorkingCopy()) {
+ wc = (ILaunchConfigurationWorkingCopy)getLaunchConfiguration();
+ }
+ }
+ if (wc != null) {
+ wc.setAttribute(ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_SPECIFIC_ATTRS_MAP, (Map)null);
+ }
+ } else {
+ if (wc == null) {
+ try {
+ if (getLaunchConfiguration().isWorkingCopy()) {
+ // get a fresh copy to work on
+ wc = ((ILaunchConfigurationWorkingCopy)getLaunchConfiguration()).getOriginal().getWorkingCopy();
+ } else {
+ wc = getLaunchConfiguration().getWorkingCopy();
+ }
+ } catch (CoreException e) {
+ return;
+ }
+ }
+ getDynamicTab().setDefaults(wc);
+ getDynamicTab().initializeFrom(wc);
+ }
+
+ updateLaunchConfigurationDialog();
+ }
+
+ protected void loadDebuggerComboBox(ILaunchConfiguration config) {
+ ICDebuggerInfo[] debuggerInfo = null;
+ if ( fDinfo != null ) {
+ fDinfo.clear();
+ }
+ fDlist.removeAll();
+ try {
+ debuggerInfo = CDebugCorePlugin.getDefault().getDebuggerManager().queryDebuggers(getPlatform(config));
+ }
+ catch (CoreException e) {
+ return;
+ }
+ fDinfo = new ArrayList(debuggerInfo.length);
+ for( int i = 0; i < debuggerInfo.length; i++ ) {
+ fDinfo.add(debuggerInfo[i]);
+ fDlist.add(debuggerInfo[i].getName());
+ }
+ }
+
+ protected void setSelection(String id) {
+ for (int i = 0; i < fDinfo.size(); i++ ) {
+ ICDebuggerInfo dinfo = (ICDebuggerInfo) fDinfo.get(i);
+ if ( dinfo != null && dinfo.getID().equals(id) ) {
+ fDlist.select(i);
+ return;
+ }
+ }
+ }
+
+ public void setDefaults(ILaunchConfigurationWorkingCopy config) {
+ setLaunchConfigurationWorkingCopy(config);
+ loadDebuggerComboBox(config);
+ if ( fDinfo.size() > 0 ) {
+ ICDebuggerInfo info = (ICDebuggerInfo) fDinfo.get(0);
+ if ( info != null ) {
+ setSelection(info.getID());
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_CDT_DEBUGGER_ID, info.getID());
+ }
+ }
+ ILaunchConfigurationTab dynamicTab = getDynamicTab();
+ if (dynamicTab != null) {
+ dynamicTab.setDefaults(config);
+ }
+ }
+
+ public void initializeFrom(ILaunchConfiguration config) {
+ String id;
+ setLaunchConfiguration(config);
+ loadDebuggerComboBox(config);
+ try {
+ id = config.getAttribute(ICDTLaunchConfigurationConstants.ATTR_CDT_DEBUGGER_ID, "");
+ }
+ catch (CoreException e) {
+ return;
+ }
+ setSelection(id);
+ ILaunchConfigurationTab dynamicTab = getDynamicTab();
+ if (dynamicTab != null) {
+ dynamicTab.initializeFrom(config);
+ }
+
+ }
+
+ public void performApply(ILaunchConfigurationWorkingCopy config) {
+ if ( isValid(config) ) {
+ ICDebuggerInfo dinfo = (ICDebuggerInfo)fDinfo.get(fDlist.getSelectionIndex());
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_CDT_DEBUGGER_ID, dinfo.getID() );
+ ILaunchConfigurationTab dynamicTab = getDynamicTab();
+ if (dynamicTab == null) {
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_SPECIFIC_ATTRS_MAP, (Map)null);
+ } else {
+ dynamicTab.performApply(config);
+ }
+ }
+ }
+
+ public boolean isValid(ILaunchConfiguration config) {
+ setErrorMessage(null);
+ setMessage(null);
+
+ if ( fDlist.getSelectionIndex() == -1 ) {
+ setErrorMessage("No debugger avalible");
+ return false;
+ }
+
+ ILaunchConfigurationTab dynamicTab = getDynamicTab();
+ if (dynamicTab != null) {
+ return dynamicTab.isValid(config);
+ }
+ return true;
+ }
+
+ /**
+ * Return the class that implements ILaunchConfigurationTab
+ * that is registered against the install type of the currently selected VM.
+ */
+ protected ILaunchConfigurationTab getTabForCurrentDebugger() {
+ int selectedIndex = fDlist.getSelectionIndex();
+ if (selectedIndex > 0) {
+ }
+ return null;
+ }
+
+ /**
+ * Show the contributed piece of UI that was registered for the install type
+ * of the currently selected VM.
+ */
+ protected void loadDynamicDebugArea() {
+ // Dispose of any current child widgets in the tab holder area
+ Control[] children = getDynamicTabHolder().getChildren();
+ for (int i = 0; i < children.length; i++) {
+ children[i].dispose();
+ }
+
+ // Retrieve the dynamic UI for the current JRE
+ setDynamicTab(getTabForCurrentDebugger());
+ if (getDynamicTab() == null) {
+ return;
+ }
+
+ // Ask the dynamic UI to create its Control
+ getDynamicTab().setLaunchConfigurationDialog(getLaunchConfigurationDialog());
+ getDynamicTab().createControl(getDynamicTabHolder());
+ getDynamicTabHolder().layout();
+ }
+
+ /**
+ * Overridden here so that any error message in the dynamic UI gets returned.
+ *
+ * @see ILaunchConfigurationTab#getErrorMessage()
+ */
+ public String getErrorMessage() {
+ ILaunchConfigurationTab tab = getDynamicTab();
+ if ((super.getErrorMessage() != null) || (tab == null)) {
+ return super.getErrorMessage();
+ } else {
+ return tab.getErrorMessage();
+ }
+ }
+
+ protected void setLaunchConfigurationWorkingCopy(ILaunchConfigurationWorkingCopy workingCopy) {
+ fWorkingCopy = workingCopy;
+ }
+
+ protected ILaunchConfiguration getLaunchConfiguration() {
+ return fLaunchConfiguration;
+ }
+
+ protected void setLaunchConfiguration(ILaunchConfiguration launchConfiguration) {
+ fLaunchConfiguration = launchConfiguration;
+ }
+
+ protected ILaunchConfigurationWorkingCopy getLaunchConfigurationWorkingCopy() {
+ return fWorkingCopy;
+ }
+
+ public String getName() {
+ return "Debugger";
+ }
+
+ public Image getImage() {
+ return LaunchImages.get(LaunchImages.IMG_VIEW_DEBUGGER_TAB);
+ }
+}
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CEnvironmentTab.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CEnvironmentTab.java
new file mode 100644
index 00000000000..ac5a5f6bd05
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CEnvironmentTab.java
@@ -0,0 +1,394 @@
+package org.eclipse.cdt.launch.ui;
+
+/*
+ * (c) Copyright QNX Software System 2002.
+ * All Rights Reserved.
+ */
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.Properties;
+
+import org.eclipse.cdt.launch.ICDTLaunchConfigurationConstants;
+import org.eclipse.cdt.launch.internal.ui.CLaunchConfigurationTab;
+import org.eclipse.cdt.launch.internal.ui.LaunchImages;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
+import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.viewers.ColumnWeightData;
+import org.eclipse.jface.viewers.DoubleClickEvent;
+import org.eclipse.jface.viewers.IDoubleClickListener;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredContentProvider;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.ITableLabelProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.TableLayout;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerSorter;
+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.graphics.FontMetrics;
+import org.eclipse.swt.graphics.GC;
+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.Shell;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.Text;
+
+public class CEnvironmentTab extends CLaunchConfigurationTab {
+
+ protected Properties fElements;
+
+ private Composite fControl;
+ protected TableViewer fVariableList;
+ protected Button fBtnNew;
+ protected Button fBtnEdit;
+ protected Button fBtnRemove;
+
+ class SimpleSorter extends ViewerSorter {
+ public boolean isSorterProperty(Object element, Object property) {
+ return true;
+ }
+ }
+
+ class ElementsContentProvider implements IStructuredContentProvider {
+ Object input = null;
+
+ public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
+ }
+
+ public void dispose() {
+ }
+
+ public Object[] getElements(Object parent) {
+ return fElements.entrySet().toArray();
+ }
+ }
+
+ class ElementsLabelProvider extends LabelProvider implements ITableLabelProvider {
+
+ public Image getColumnImage(Object element, int columnIndex) {
+ return null;
+ }
+
+ public String getColumnText(Object element, int columnIndex) {
+ if (element != null && element instanceof Map.Entry) {
+ return (columnIndex == 0) ? ((Map.Entry) element).getKey().toString() : ((Map.Entry) element).getValue().toString();
+ }
+ return null;
+ }
+ }
+
+ class EntryDialog extends Dialog {
+ private String fName;
+ private String fValue;
+ private boolean fEdit = false;
+
+ private Button fBtnOk = null;
+ private Button fBtnCancel = null;
+ private Text fTextName = null;
+ private Text fTextValue = null;
+
+ public EntryDialog(String name, String value, boolean edit) {
+ super(CEnvironmentTab.this.getControl().getShell());
+ fName = name;
+ fValue = value;
+ fEdit = edit;
+ }
+
+ protected Control createContents(Composite parent) {
+ Control result = super.createContents(parent);
+ updateButtonsState();
+ return result;
+ }
+
+ protected void configureShell(Shell shell) {
+ super.configureShell(shell);
+ String title = (fEdit) ? "Edit Variable" : "New Variable";
+ shell.setText(title);
+ }
+
+ protected Control createDialogArea(Composite parent) {
+ Composite composite = new Composite(parent, SWT.NONE);
+ GridLayout layout = new GridLayout(2, false);
+ layout.marginWidth= 5;
+ layout.numColumns= 2;
+ composite.setLayout(layout);
+
+ GC gc = new GC(composite);
+ gc.setFont(composite.getFont());
+ FontMetrics metrics= gc.getFontMetrics();
+ gc.dispose();
+ int fieldWidthHint= convertWidthInCharsToPixels(metrics, 50);
+
+ Label label = new Label(composite, SWT.NONE);
+ label.setText("Name:");
+ fTextName = new Text(composite, SWT.SINGLE | SWT.BORDER);
+ GridData gd = new GridData(GridData.FILL_BOTH);
+ gd.grabExcessHorizontalSpace = true;
+ gd.widthHint = fieldWidthHint;
+ fTextName.setLayoutData(gd);
+ label = new Label(composite, SWT.NONE);
+ label.setText("Value:");
+ fTextValue = new Text(composite, SWT.SINGLE | SWT.BORDER);
+ gd = new GridData(GridData.FILL_BOTH);
+ gd.grabExcessHorizontalSpace = true;
+ gd.widthHint = fieldWidthHint;
+ fTextValue.setLayoutData(gd);
+ fTextName.addModifyListener(new ModifyListener() {
+ public void modifyText(ModifyEvent e) {
+ updateButtonsState();
+ }
+ });
+ fTextValue.addModifyListener(new ModifyListener() {
+ public void modifyText(ModifyEvent e) {
+ updateButtonsState();
+ }
+ });
+ fTextName.setText(fName);
+ fTextValue.setText(fValue);
+
+ return composite;
+ }
+
+ protected void createButtonsForButtonBar(Composite parent) {
+ fBtnOk = createButton(parent, IDialogConstants.OK_ID, IDialogConstants.OK_LABEL, true);
+ fBtnCancel = createButton(parent, IDialogConstants.CANCEL_ID, IDialogConstants.CANCEL_LABEL, false);
+ }
+
+ private void updateButtonsState() {
+ if (fBtnOk != null)
+ fBtnOk.setEnabled(fTextName.getText().trim().length() > 0);
+ }
+
+ protected String getName() {
+ return fName;
+ }
+
+ protected String getValue() {
+ return fValue;
+ }
+
+ protected void okPressed() {
+ fName = fTextName.getText().trim();
+ fValue = fTextValue.getText().trim();
+ setReturnCode(OK);
+ close();
+ }
+ }
+
+ public void createControl(Composite parent) {
+ fElements = new Properties();
+ Composite control = new Composite(parent, SWT.NONE);
+ GridLayout gl = new GridLayout(2, false);
+
+ createVerticalSpacer(control, 2);
+
+ control.setLayout(gl);
+ createVariableList(control);
+ createButtons(control);
+ setControl(control);
+ fVariableList.setInput(fElements);
+ fVariableList.getTable().setFocus();
+ updateButtons();
+ }
+
+ public void set(String env) {
+ fElements.clear();
+ ByteArrayInputStream input = new ByteArrayInputStream(env.getBytes());
+ try {
+ fElements.load(input);
+ }
+ catch (IOException e) {
+ }
+
+ fVariableList.refresh();
+ fVariableList.getTable().setFocus();
+ if (fVariableList.getTable().getItemCount() > 0)
+ fVariableList.getTable().setSelection(0);
+ }
+
+ public String get() {
+ String result = new String();
+ Object[] entries = fElements.entrySet().toArray();
+ for (int i = 0; i < entries.length; ++i)
+ result += entries[i].toString() + '\n';
+ return result;
+ }
+
+ public Properties getProperties() {
+ return fElements;
+ }
+
+ public Object[] toArray() {
+ return fElements.entrySet().toArray();
+ }
+
+ private void createVariableList(Composite parent) {
+ fVariableList = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
+ fVariableList.setContentProvider(new ElementsContentProvider());
+ fVariableList.setLabelProvider(new ElementsLabelProvider());
+ fVariableList.setSorter(new SimpleSorter());
+
+ Table table = fVariableList.getTable();
+
+ TableLayout tableLayout = new TableLayout();
+ table.setLayout(tableLayout);
+
+ GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_FILL);
+ gd.grabExcessVerticalSpace = true;
+ gd.grabExcessHorizontalSpace = true;
+ table.setLayoutData(gd);
+
+ table.setHeaderVisible(true);
+ table.setLinesVisible(true);
+
+ TableColumn column1 = new TableColumn(table, SWT.NULL);
+ column1.setText("Name");
+ tableLayout.addColumnData(new ColumnWeightData(30));
+
+ TableColumn column2 = new TableColumn(table, SWT.NULL);
+ column2.setText("Value");
+ tableLayout.addColumnData(new ColumnWeightData(30));
+
+ fVariableList.addSelectionChangedListener(new ISelectionChangedListener() {
+ public void selectionChanged(SelectionChangedEvent e) {
+ updateButtons();
+ }
+ });
+
+ fVariableList.addDoubleClickListener(new IDoubleClickListener() {
+ public void doubleClick(DoubleClickEvent e) {
+ elementDoubleClicked((IStructuredSelection) e.getSelection());
+ }
+ });
+ }
+
+ private void createButtons(Composite parent) {
+ Composite composite = new Composite(parent, SWT.NONE);
+ composite.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING));
+ composite.setLayout(new GridLayout(1, true));
+ fBtnNew = new Button(composite, SWT.NONE);
+ fBtnNew.setText("New...");
+ fBtnNew.setLayoutData(new GridData(GridData.FILL_BOTH));
+ fBtnNew.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent e) {
+ newEntry();
+ }
+ });
+ fBtnEdit = new Button(composite, SWT.NONE);
+ fBtnEdit.setText("Edit...");
+ fBtnEdit.setLayoutData(new GridData(GridData.FILL_BOTH));
+ fBtnEdit.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent e) {
+ edit();
+ }
+ });
+ fBtnRemove = new Button(composite, SWT.NONE);
+ fBtnRemove.setText("Remove");
+ fBtnRemove.setLayoutData(new GridData(GridData.FILL_BOTH));
+ fBtnRemove.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent e) {
+ remove();
+ }
+ });
+ }
+
+ private void updateButtons() {
+ IStructuredSelection selection = (IStructuredSelection) fVariableList.getSelection();
+ fBtnEdit.setEnabled(selection.size() == 1);
+ fBtnRemove.setEnabled(selection.size() > 0);
+ }
+
+ private void elementDoubleClicked(IStructuredSelection selection) {
+ if (selection.size() != 1)
+ return;
+ doEdit((Map.Entry) selection.getFirstElement());
+ }
+
+ private void newEntry() {
+ EntryDialog dialog = new EntryDialog(new String(), new String(), false);
+ if (dialog.open() == dialog.OK) {
+ fElements.setProperty(dialog.getName(), dialog.getValue());
+ fVariableList.refresh();
+ }
+ updateButtons();
+ }
+
+ private void edit() {
+ IStructuredSelection selection = (IStructuredSelection) fVariableList.getSelection();
+ doEdit((Map.Entry) selection.getFirstElement());
+ }
+
+ private void doEdit(Map.Entry entry) {
+ EntryDialog dialog = new EntryDialog(entry.getKey().toString(), entry.getValue().toString(), true);
+ if (dialog.open() == dialog.OK) {
+ fElements.remove(entry.getKey());
+ fElements.setProperty(dialog.getName(), dialog.getValue());
+ fVariableList.refresh();
+ }
+ updateButtons();
+ }
+
+ private void remove() {
+ IStructuredSelection selection = (IStructuredSelection) fVariableList.getSelection();
+ Object[] elements = selection.toArray();
+ for (int i = 0; i < elements.length; ++i)
+ fElements.remove(((Map.Entry) elements[i]).getKey());
+ fVariableList.refresh();
+ updateButtons();
+ }
+
+ public void setDefaults(ILaunchConfigurationWorkingCopy config) {
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ENVIROMENT_MAP, (Map) null);
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ENVIROMENT_INHERIT, true);
+ }
+
+ public void initializeFrom(ILaunchConfiguration config) {
+ try {
+ Map env = config.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ENVIROMENT_MAP, (Map)null);
+ if ( env != null ) {
+ fElements.putAll(env);
+ fVariableList.refresh();
+ updateButtons();
+ }
+// config.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ENVIROMENT_INHERIT, true);
+ } catch ( CoreException e ) {
+ }
+ }
+
+ public void performApply(ILaunchConfigurationWorkingCopy config) {
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ENVIROMENT_MAP, fElements);
+ config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_ENVIROMENT_INHERIT, true);
+ }
+
+ /**
+ * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getName()
+ */
+ public String getName() {
+ return "Enviroment";
+ }
+
+ /**
+ * @see ILaunchConfigurationTab#getImage()
+ */
+ public Image getImage() {
+ return LaunchImages.get(LaunchImages.IMG_VIEW_ENVIRONMENT_TAB);
+ }
+
+}
diff --git a/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CMainTab.java b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CMainTab.java
new file mode 100644
index 00000000000..c7b3ad4c124
--- /dev/null
+++ b/launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CMainTab.java
@@ -0,0 +1,372 @@
+package org.eclipse.cdt.launch.ui;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+
+import java.io.FileReader;
+import java.util.ArrayList;
+
+import org.eclipse.cdt.core.CCorePlugin;
+import org.eclipse.cdt.core.ICProjectDescriptor;
+import org.eclipse.cdt.core.model.CModelException;
+import org.eclipse.cdt.core.model.CoreModel;
+import org.eclipse.cdt.core.model.IBinary;
+import org.eclipse.cdt.core.model.IBinaryContainer;
+import org.eclipse.cdt.core.model.ICElement;
+import org.eclipse.cdt.core.model.ICProject;
+import org.eclipse.cdt.core.model.ICRoot;
+import org.eclipse.cdt.internal.ui.CElementLabelProvider;
+import org.eclipse.cdt.launch.ICDTLaunchConfigurationConstants;
+import org.eclipse.cdt.launch.internal.ui.CLaunchConfigurationTab;
+import org.eclipse.cdt.launch.internal.ui.LaunchImages;
+import org.eclipse.cdt.launch.internal.ui.LaunchUIPlugin;
+import org.eclipse.core.resources.IProject;
+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.runtime.Platform;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
+import org.eclipse.jface.viewers.ILabelProvider;
+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.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.Label;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.dialogs.ElementListSelectionDialog;
+import org.eclipse.ui.dialogs.FilteredList;
+
+/**
+ * A launch configuration tab that displays and edits project and
+ * main type name launch configuration attributes.
+ * + * This class may be instantiated. This class is not intended to be subclassed. + *
+ * @since 2.0 + */ + +public class CMainTab extends CLaunchConfigurationTab { + + // Project UI widgets + protected Label fProjLabel; + protected Text fProjText; + protected Button fProjButton; + + // Main class UI widgets + protected Label fProgLabel; + protected Text fProgText; + protected Button fSearchButton; + + protected static final String EMPTY_STRING = ""; //$NON-NLS-1$ + + private String filterPlatform = EMPTY_STRING; + + /** + * @see ILaunchConfigurationTab#createControl(Composite) + */ + public void createControl(Composite parent) { + + Composite comp = new Composite(parent, SWT.NONE); + setControl(comp); + // WorkbenchHelp.setHelp(getControl(), IJavaDebugHelpContextIds.LAUNCH_CONFIGURATION_DIALOG_MAIN_TAB); + GridLayout topLayout = new GridLayout(); + comp.setLayout(topLayout); + + createVerticalSpacer(comp, 1); + + Composite projComp = new Composite(comp, SWT.NONE); + GridLayout projLayout = new GridLayout(); + projLayout.numColumns = 2; + projLayout.marginHeight = 0; + projLayout.marginWidth = 0; + projComp.setLayout(projLayout); + GridData gd = new GridData(GridData.FILL_HORIZONTAL); + projComp.setLayoutData(gd); + + fProjLabel = new Label(projComp, SWT.NONE); + fProjLabel.setText("&Project:"); + gd = new GridData(); + gd.horizontalSpan = 2; + fProjLabel.setLayoutData(gd); + + fProjText = new Text(projComp, SWT.SINGLE | SWT.BORDER); + gd = new GridData(GridData.FILL_HORIZONTAL); + fProjText.setLayoutData(gd); + fProjText.addModifyListener(new ModifyListener() { + public void modifyText(ModifyEvent evt) { + updateLaunchConfigurationDialog(); + } + }); + + fProjButton = createPushButton(projComp, "&Browse...", null); + fProjButton.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent evt) { + handleProjectButtonSelected(); + } + }); + + createVerticalSpacer(comp, 1); + + Composite mainComp = new Composite(comp, SWT.NONE); + GridLayout mainLayout = new GridLayout(); + mainLayout.numColumns = 2; + mainLayout.marginHeight = 0; + mainLayout.marginWidth = 0; + mainComp.setLayout(mainLayout); + gd = new GridData(GridData.FILL_HORIZONTAL); + mainComp.setLayoutData(gd); + fProgLabel = new Label(mainComp, SWT.NONE); + fProgLabel.setText("C/C++ Application:"); + gd = new GridData(); + gd.horizontalSpan = 2; + fProgLabel.setLayoutData(gd); + fProgText = new Text(mainComp, SWT.SINGLE | SWT.BORDER); + gd = new GridData(GridData.FILL_HORIZONTAL); + fProgText.setLayoutData(gd); + fProgText.addModifyListener(new ModifyListener() { + public void modifyText(ModifyEvent evt) { + updateLaunchConfigurationDialog(); + } + }); + fSearchButton = createPushButton(mainComp, "Searc&h...", null); + fSearchButton.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent evt) { + handleSearchButtonSelected(); + } + }); + } + + /** + * @see ILaunchConfigurationTab#initializeFrom(ILaunchConfiguration) + */ + public void initializeFrom(ILaunchConfiguration config) { + try { + filterPlatform = getPlatform(config); + } + catch (CoreException e) { + } + updateProjectFromConfig(config); + updateProgramFromConfig(config); + } + + protected void updateProjectFromConfig(ILaunchConfiguration config) { + String projectName = EMPTY_STRING; + try { + projectName = config.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME, EMPTY_STRING); + } + catch (CoreException ce) { + LaunchUIPlugin.log(ce); + } + fProjText.setText(projectName); + } + + protected void updateProgramFromConfig(ILaunchConfiguration config) { + String programName = EMPTY_STRING; + try { + programName = config.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, EMPTY_STRING); + } + catch (CoreException ce) { + LaunchUIPlugin.log(ce); + } + fProgText.setText(programName); + } + + /** + * @see ILaunchConfigurationTab#performApply(ILaunchConfigurationWorkingCopy) + */ + public void performApply(ILaunchConfigurationWorkingCopy config) { + config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME, (String) fProjText.getText()); + config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, (String) fProgText.getText()); + } + + /** + * @see ILaunchConfigurationTab#dispose() + */ + public void dispose() { + } + + /** + * Show a dialog that lists all main types + */ + protected void handleSearchButtonSelected() { + } + + /** + * Show a dialog that lets the user select a project. This in turn provides + * context for the main type, allowing the user to key a main type name, or + * constraining the search for main types to the specified project. + */ + protected void handleProjectButtonSelected() { + ICProject project = chooseCProject(); + if (project == null) { + return; + } + + String projectName = project.getElementName(); + fProjText.setText(projectName); + } + + /** + * Realize a C Project selection dialog and return the first selected project, + * or null if there was none. + */ + protected ICProject chooseCProject() { + ICProject[] projects; + projects = getCProjects(); + + ILabelProvider labelProvider = new CElementLabelProvider(); + ElementListSelectionDialog dialog = new ElementListSelectionDialog(getShell(), labelProvider); + dialog.setTitle("Project Selection"); + dialog.setMessage("Choose a &project to constrain the search for a program"); + dialog.setElements(projects); + + ICProject cProject = getCProject(); + if (cProject != null) { + dialog.setInitialSelections(new Object[] { cProject }); + } + if (dialog.open() == dialog.OK) { + return (ICProject) dialog.getFirstResult(); + } + return null; + } + + /** + * Return an array a ICProject whose platform match that of the runtime env. + **/ + + protected ICProject[] getCProjects() { + ICProject cproject[] = CoreModel.getDefault().getCRoot().getCProjects(); + ArrayList list = new ArrayList(cproject.length); + for (int i = 0; i < cproject.length; i++) { + ICProjectDescriptor cdesciptor = null; + try { + cdesciptor = CCorePlugin.getDefault().getCProjectDescription((IProject) cproject[i].getResource()); + if (cdesciptor.getPlatform().equals("*") || filterPlatform.equalsIgnoreCase(cdesciptor.getPlatform()) == true) { + list.add(cproject[i]); + } + } + catch (CoreException e) { + } + } + return (ICProject[]) list.toArray(new ICProject[list.size()]); + } + /** + * Return the ICProject corresponding to the project name in the project name + * text field, or null if the text does not match a project name. + */ + protected ICProject getCProject() { + String projectName = fProjText.getText().trim(); + if (projectName.length() < 1) { + return null; + } + return CoreModel.getDefault().getCRoot().getCProject(projectName); + } + + /** + * @see ILaunchConfigurationTab#isValid(ILaunchConfiguration) + */ + public boolean isValid(ILaunchConfiguration config) { + + setErrorMessage(null); + setMessage(null); + + String name = fProjText.getText().trim(); + if (name.length() > 0) { + if (!ResourcesPlugin.getWorkspace().getRoot().getProject(name).exists()) { + setErrorMessage("Project does not exist"); + return false; + } + } + IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(name); + + name = fProgText.getText().trim(); + if (name.length() == 0) { + setErrorMessage("Program not specified"); + return false; + } + IPath path = Platform.getLocation().append(project.getFullPath()); + path = path.append(name); + + if (!ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(path).exists()) { + setErrorMessage("Program does not exist"); + return false; + } + return true; + } + + /** + * @see ILaunchConfigurationTab#setDefaults(ILaunchConfigurationWorkingCopy) + */ + public void setDefaults(ILaunchConfigurationWorkingCopy config) { + ICElement cElement = null; + try { + cElement = getContext(config); + } + catch (CoreException e) { + } + if (cElement != null) { + initializeCProject(cElement, config); + } + else { + // We set empty attributes for project & program so that when one config is + // compared to another, the existence of empty attributes doesn't cause an + // incorrect result (the performApply() method can result in empty values + // for these attributes being set on a config if there is nothing in the + // corresponding text boxes) + config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME, EMPTY_STRING); + } + initializeProgramName(cElement, config); + } + + /** + * Set the program name attributes on the working copy based on the ICElement + */ + protected void initializeProgramName(ICElement cElement, ILaunchConfigurationWorkingCopy config) { + String name = null; + if (cElement instanceof ICProject) { + IBinaryContainer bc = ((ICProject) cElement).getBinaryContainer(); + IBinary[] bins = bc.getBinaries(); + if (bins.length == 1) { + name = bins[0].getElementName(); + } + } + if (name == null) { + name = EMPTY_STRING; + } + config.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, name); + if (name.length() > 0) { + int index = name.lastIndexOf('.'); + if (index > 0) { + name = name.substring(index + 1); + } + name = getLaunchConfigurationDialog().generateName(name); + config.rename(name); + } + } + + /** + * @see ILaunchConfigurationTab#getName() + */ + public String getName() { + return "Main"; + } + + /** + * @see ILaunchConfigurationTab#getImage() + */ + public Image getImage() { + return LaunchImages.get(LaunchImages.IMG_VIEW_MAIN_TAB); + } + +}