mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-09-08 11:03:28 +02:00
Code Issues Wiki Activity

new CDT launcher plugin with local launch delegate

Browse source
This commit is contained in:
David Inglis 2002-08-13 04:05:02 +00:00
parent a4f0fa4e7e
commit e55f659950
18 changed files with 2459 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
launch/org.eclipse.cdt.launch/.classpath Normal file
View file

@ -0,0 +1,15 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src/"/>
<classpathentry kind="src" path="/org.eclipse.core.resources"/>
<classpathentry kind="src" path="/org.eclipse.debug.core"/>
<classpathentry kind="src" path="/org.eclipse.debug.ui"/>
<classpathentry kind="src" path="/org.eclipse.ui"/>
<classpathentry kind="src" path="/org.eclipse.cdt.core"/>
<classpathentry kind="src" path="/org.eclipse.cdt.ui"/>
<classpathentry kind="src" path="/org.eclipse.cdt.debug.core"/>
<classpathentry kind="src" path="/org.eclipse.core.runtime"/>
<classpathentry kind="src" path="/org.eclipse.core.boot"/>
<classpathentry kind="var" path="JRE_LIB" rootpath="JRE_SRCROOT" sourcepath="JRE_SRC"/>
<classpathentry kind="output" path="bin"/>
</classpath>

1
launch/org.eclipse.cdt.launch/.cvsignore Normal file
View file

@ -0,0 +1 @@
bin

37
launch/org.eclipse.cdt.launch/.project Normal file
View file

@ -0,0 +1,37 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>org.eclipse.cdt.launch</name>
<comment></comment>
<projects>
<project>org.eclipse.cdt.core</project>
<project>org.eclipse.cdt.debug.core</project>
<project>org.eclipse.cdt.ui</project>
<project>org.eclipse.core.boot</project>
<project>org.eclipse.core.resources</project>
<project>org.eclipse.core.runtime</project>
<project>org.eclipse.debug.core</project>
<project>org.eclipse.debug.ui</project>
<project>org.eclipse.ui</project>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.pde.ManifestBuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.pde.SchemaBuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
<nature>org.eclipse.pde.PluginNature</nature>
</natures>
</projectDescription>

1
launch/org.eclipse.cdt.launch/build.properties Normal file
View file

@ -0,0 +1 @@
source.launch.jar = src/

BIN
launch/org.eclipse.cdt.launch/icons/arguments_tab.gif Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 108 B

12
launch/org.eclipse.cdt.launch/plugin.properties Normal file
View file

@ -0,0 +1,12 @@
######################################################################
# Copyright (c) 2002 QNX Software Systems Ltd. and others.
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Common Public License v0.5
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/cpl-v05.html
#
# Contributors:
# QNX Software Systems Ltd. - Initial implementation
######################################################################
LocalCDTLaunch.name= Local C/C++ Application

60
launch/org.eclipse.cdt.launch/plugin.xml Normal file
View file

@ -0,0 +1,60 @@
<?xml version="1.0" encoding="UTF-8"?>
<plugin
id="org.eclipse.cdt.launch"
name="CDT Launch Plug-in"
version="0.0.1"
provider-name="QNX Software Systems Ltd."
class="org.eclipse.cdt.launch.internal.ui.LaunchUIPlugin">
<runtime>
<library name="cdtlaunch.jar"/>
</runtime>
<requires>
<import plugin="org.eclipse.core.resources"/>
<import plugin="org.eclipse.debug.core"/>
<import plugin="org.eclipse.debug.ui"/>
<import plugin="org.eclipse.ui"/>
<import plugin="org.eclipse.cdt.core"/>
<import plugin="org.eclipse.cdt.ui"/>
<import plugin="org.eclipse.cdt.debug.core"/>
</requires>
<extension
point="org.eclipse.debug.core.launchConfigurationTypes">
<launchConfigurationType
name="%LocalCDTLaunch.name"
delegate="org.eclipse.cdt.launch.internal.LocalCLaunchConfigurationDelegate"
modes="run,debug"
public="true"
id="org.eclipse.cdt.launch.localCLaunch">
</launchConfigurationType>
</extension>
<extension
point="org.eclipse.debug.ui.launchConfigurationTypeImages">
<launchConfigurationTypeImage
icon="icon/localCLaunch.gif"
configTypeID="org.eclipse.cdt.launch.LocalCLaunch"
id="org.eclipse.cdt.launch.localCLaunchImage">
</launchConfigurationTypeImage>
</extension>
<extension
point="org.eclipse.debug.ui.launchConfigurationTabGroups">
<launchConfigurationTabGroup
type="org.eclipse.cdt.launch.localCLaunch"
class="org.eclipse.cdt.launch.internal.ui.LocalCLaunchConfigurationTabGroup"
id="org.eclipse.cdt.launch.localClaunchConfigurationTabGroup">
</launchConfigurationTabGroup>
</extension>
<extension
point="org.eclipse.debug.ui.launchShortcuts">
<shortcut
label="org.eclipse.cdt.launch.shortcut1"
icon="org.eclipse.cdt.launch.shortcut1"
modes="run,debug"
class="org.eclipse.cdt.launch.LaunchShortcut1"
id="org.eclipse.cdt.launch.localCShortcut">
</shortcut>
</extension>
</plugin>

92
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ICDTLaunchConfigurationConstants.java Normal file
View file

@ -0,0 +1,92 @@
package org.eclipse.cdt.launch;
/*
* (c) Copyright QNX Software System 2002.
* All Rights Reserved.
*/
import org.eclipse.cdt.launch.internal.ui.LaunchUIPlugin;
public interface ICDTLaunchConfigurationConstants {
/**
* Launch configuration attribute key. The value is a name of
* a C/C++ project associated with a C/C++ launch configuration.
*/
public static final String ATTR_PROJECT_NAME = LaunchUIPlugin.getUniqueIdentifier() + ".PROJECT_ATTR"; //$NON-NLS-1$
/**
* Launch configuration attribute key. The value is a string specifying
* application a C/C++ launch configuration.
*/
public static final String ATTR_PROGRAM_NAME = LaunchUIPlugin.getUniqueIdentifier() + ".PROGRAM_NAME"; //$NON-NLS-1$
/**
* Launch configuration attribute key. The value is a string specifying
* application arguments for a C/C++ launch configuration, as they should appear
* on the command line.
*/
public static final String ATTR_PROGRAM_ARGUMENTS = LaunchUIPlugin.getUniqueIdentifier() + ".PROGRAM_ARGUMENTS"; //$NON-NLS-1$
/**
* Launch configuration attribute key. The value is a string specifying a
* path to the working directory to use when launching a the application.
* When unspecified, the working directory is inherited from the current process.
* When specified as an absolute path, the path represents a path in the local
* file system. When specified as a full path, the path represents a workspace
* relative path.
*/
public static final String ATTR_WORKING_DIRECTORY = LaunchUIPlugin.getUniqueIdentifier() + ".WORKING_DIRECTORY"; //$NON-NLS-1$
/**
* Launch configuration attribute key. The value is a boolean specifying
* wheather the current enviroment should be inherited when the application
* is launched.
*/
public static final String ATTR_PROGRAM_ENVIROMENT_INHERIT = LaunchUIPlugin.getUniqueIdentifier() + ".ENVIRONMENT_INHERIT"; //$NON-NLS-1$
/**
* Launch configuration attribute key. The value is a Map specifying the
* enviroment to use when launching a C/C++ application.
*/
public static final String ATTR_PROGRAM_ENVIROMENT_MAP = LaunchUIPlugin.getUniqueIdentifier() + ".ENVIRONMENT_MAP"; //$NON-NLS-1$
/**
* Launch configuration attribute key. The value is the debugger id
* used when launching a C/C++ application for debug.
*/
public static final String ATTR_CDT_DEBUGGER_ID = LaunchUIPlugin.getUniqueIdentifier() + ".CDT_DEBUGGER"; //$NON-NLS-1$
/**
* Launch configuration attribute key. The value is the platform string of the launch configuration
*/
public static final String ATTR_CDT_PLATFORM = LaunchUIPlugin.getUniqueIdentifier() + ".CDT_PLATFFORM"; //$NON-NLS-1$
/**
* Launch configuration attribute key. The value is the platform string of the launch configuration
*/
public static final String ATTR_DEBUGGER_SPECIFIC_ATTRS_MAP = LaunchUIPlugin.getUniqueIdentifier() + ".CDT_DEBUGGER_SPECIFIC_ATTRS_MAP"; //$NON-NLS-1$
/**
* Status code indicating that the Eclipse runtime does not support
* launching a program with a working directory. This feature is only
* available if Eclipse is run on a 1.3 runtime or higher.
* <p>
* 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.
* </p>
*/
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;
}

328
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/LocalCLaunchConfigurationDelegate.java Normal file
View file

@ -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, or <code>null</code> 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
* <code>ERR_WORKING_DIRECTORY_NOT_SUPPORTED</code> 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 <code>null</code>
* @return the resulting process or <code>null</code> 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;
}
}

88
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/CLaunchConfigurationTab.java Normal file
View file

@ -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 <code>null</code> 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);
}
}

24
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LaunchImages.java Normal file
View file

@ -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;
}
}

117
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LaunchUIPlugin.java Normal file
View file

@ -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 <code>null</code> if none
*
* @return the active workbench shell or <code>null</code> if none
*/
public static Shell getActiveWorkbenchShell() {
IWorkbenchWindow window = getActiveWorkbenchWindow();
if (window != null) {
return window.getShell();
}
return null;
}
}

41
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/LocalCLaunchConfigurationTabGroup.java Normal file
View file

@ -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()]));
}
}

405
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/internal/ui/WorkingDirectoryBlock.java Normal file
View file

@ -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 <code>null</code>
*/
protected IContainer getContainer() {
IResource res = getResource();
if (res instanceof IContainer) {
return (IContainer)res;
}
return null;
}
/**
* Returns the selected workspace resource, or <code>null</code>
*/
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 <code>null</code> if empty.
*
* @return text or <code>null</code>
*/
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;
}
}

176
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CArgumentsTab.java Normal file
View file

@ -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.
* <p>
* This class may be instantiated. This class is not intended to be subclassed.
* </p>
*/
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, or <code>null</code> if empty.
*
* @return text or <code>null</code>
*/
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);
}
}

296
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CDebuggerTab.java Normal file
View file

@ -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 <code>ILaunchConfigurationTab</code>
* 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);
}
}

394
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CEnvironmentTab.java Normal file
View file

@ -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);
}
}

372
launch/org.eclipse.cdt.launch/src/org/eclipse/cdt/launch/ui/CMainTab.java Normal file
View file

@ -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.
* <p>
* This class may be instantiated. This class is not intended to be subclassed.
* </p>
* @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);
}
}