/*******************************************************************************
* Copyright (c) 2000, 2003 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.debug.internal.ui;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.lang.reflect.InvocationTargetException;
import java.text.MessageFormat;
import org.apache.xml.serialize.Method;
import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.Serializer;
import org.apache.xml.serialize.SerializerFactory;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdapterManager;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IPluginDescriptor;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchListener;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IDebugElement;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.PerspectiveManager;
import org.eclipse.debug.internal.ui.launchVariables.ContextVariableComponentManager;
import org.eclipse.debug.internal.ui.preferences.DebugActionGroupsManager;
import org.eclipse.debug.internal.ui.preferences.IDebugPreferenceConstants;
import org.eclipse.debug.internal.ui.views.console.ConsoleDocumentManager;
import org.eclipse.debug.internal.ui.views.variables.VariablesContentProviderManager;
import org.eclipse.debug.ui.IDebugModelPresentation;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.launchVariables.ILaunchVariableComponentManager;
import org.eclipse.debug.ui.launchVariables.LaunchVariableContextManager;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.w3c.dom.Document;
/**
* The Debug UI Plugin.
*
*/
public class DebugUIPlugin extends AbstractUIPlugin implements ILaunchListener {
/**
* The singleton debug plugin instance
*/
private static DebugUIPlugin fgDebugUIPlugin= null;
/**
* A utility presentation used to obtain labels
*/
protected static IDebugModelPresentation fgPresentation = null;
/**
* Default label provider
*/
private static DefaultLabelProvider fgDefaultLabelProvider;
/**
* Flag indicating whether the debug UI is in trace
* mode. When in trace mode, extra debug information
* is produced.
*/
private boolean fTrace = false;
/**
* Singleton console document manager
*/
private ConsoleDocumentManager fConsoleDocumentManager = null;
/**
* Perspective manager
*/
private PerspectiveManager fPerspectiveManager = null;
/**
* Launch configuration manager
*/
private LaunchConfigurationManager fLaunchConfigurationManager = null;
private VariablesContentProviderManager fVariablesContentProviderManager;
private ContextVariableComponentManager fVariableComponentManager;
/**
* Returns whether the debug UI plug-in is in trace
* mode.
*
* @return whether the debug UI plug-in is in trace
* mode
*/
public boolean isTraceMode() {
return fTrace;
}
/**
* Logs the given message if in trace mode.
*
* @param String message to log
*/
public static void logTraceMessage(String message) {
if (getDefault().isTraceMode()) {
IStatus s = new Status(IStatus.WARNING, IDebugUIConstants.PLUGIN_ID, IDebugUIConstants.INTERNAL_ERROR, message, null);
getDefault().getLog().log(s);
}
}
/**
* Constructs the debug UI plugin
*/
public DebugUIPlugin(IPluginDescriptor descriptor) {
super(descriptor);
fgDebugUIPlugin= this;
}
protected ILaunchManager getLaunchManager() {
return DebugPlugin.getDefault().getLaunchManager();
}
public VariablesContentProviderManager getVariablesContentProviderManager() {
if (fVariablesContentProviderManager == null) {
fVariablesContentProviderManager = new VariablesContentProviderManager();
}
return fVariablesContentProviderManager;
}
public ILaunchVariableComponentManager getVariableComponentManager() {
if (fVariableComponentManager == null) {
fVariableComponentManager = new ContextVariableComponentManager();
}
return fVariableComponentManager;
}
/**
* Returns the singleton instance of the debug plugin.
*/
public static DebugUIPlugin getDefault() {
return fgDebugUIPlugin;
}
/**
* 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.debug.ui"; //$NON-NLS-1$
}
return getDefault().getDescriptor().getUniqueIdentifier();
}
public static IDebugModelPresentation getModelPresentation() {
if (fgPresentation == null) {
fgPresentation = new DelegatingModelPresentation();
}
return fgPresentation;
}
public LaunchConfigurationManager getLaunchConfigurationManager() {
if (fLaunchConfigurationManager == null) {
fLaunchConfigurationManager = new LaunchConfigurationManager();
}
return fLaunchConfigurationManager;
}
public static IWorkbenchWindow getActiveWorkbenchWindow() {
return getDefault().getWorkbench().getActiveWorkbenchWindow();
}
public static Shell getShell() {
if (getActiveWorkbenchWindow() != null) {
return getActiveWorkbenchWindow().getShell();
}
return null;
}
/**
* Returns the default label provider for the debug UI.
*/
public static ILabelProvider getDefaultLabelProvider() {
if (fgDefaultLabelProvider == null) {
fgDefaultLabelProvider = new DefaultLabelProvider();
}
return fgDefaultLabelProvider;
}
/**
* Creates an extension. If the extension plugin has not
* been loaded a busy cursor will be activated during the duration of
* the load.
*
* @param element the config element defining the extension
* @param classAttribute the name of the attribute carrying the class
* @return the extension object
*/
public static Object createExtension(final IConfigurationElement element, final String classAttribute) throws CoreException {
// If plugin has been loaded create extension.
// Otherwise, show busy cursor then create extension.
IPluginDescriptor plugin = element.getDeclaringExtension().getDeclaringPluginDescriptor();
if (plugin.isPluginActivated()) {
return element.createExecutableExtension(classAttribute);
} else {
final Object [] ret = new Object[1];
final CoreException [] exc = new CoreException[1];
BusyIndicator.showWhile(null, new Runnable() {
public void run() {
try {
ret[0] = element.createExecutableExtension(classAttribute);
} catch (CoreException e) {
exc[0] = e;
}
}
});
if (exc[0] != null) {
throw exc[0];
}
else {
return ret[0];
}
}
}
protected ImageRegistry createImageRegistry() {
return DebugPluginImages.initializeImageRegistry();
}
/**
* Shuts down this plug-in and discards all plug-in state.
* If a plug-in has been started, this method is automatically
* invoked by the platform core when the workbench is closed.
* <p>
* This method is intended to perform simple termination
* of the plug-in environment. The platform may terminate invocations
* that do not complete in a timely fashion.
* </p><p>
* By default this will save the preference and dialog stores (if they are in use).
* </p><p>
* Subclasses which override this method must call super first.
* </p>
*/
public void shutdown() throws CoreException {
if (fPerspectiveManager != null) {
fPerspectiveManager.shutdown();
}
if (DebugActionGroupsManager.defaultExists()) {
DebugActionGroupsManager.getDefault().shutdown();
}
if (fLaunchConfigurationManager != null) {
fLaunchConfigurationManager.shutdown();
}
if (fConsoleDocumentManager != null) {
fConsoleDocumentManager.shutdown();
}
ColorManager.getDefault().dispose();
if (fgPresentation != null) {
fgPresentation.dispose();
}
super.shutdown();
}
/**
* @see AbstractUIPlugin#startup()
*/
public void startup() throws CoreException {
super.startup();
// Listen to launches to lazily create "launch processors"
DebugPlugin.getDefault().getLaunchManager().addLaunchListener(this);
IAdapterManager manager= Platform.getAdapterManager();
DebugUIPropertiesAdapterFactory propertiesFactory = new DebugUIPropertiesAdapterFactory();
manager.registerAdapters(propertiesFactory, IDebugElement.class);
manager.registerAdapters(propertiesFactory, IProcess.class);
DebugUIAdapterFactory uiFactory = new DebugUIAdapterFactory();
manager.registerAdapters(uiFactory, ILaunchConfiguration.class);
manager.registerAdapters(uiFactory, ILaunchConfigurationType.class);
getStandardDisplay().asyncExec(
new Runnable() {
public void run() {
//initialize the variable context manager
LaunchVariableContextManager.getDefault();
}
});
}
/**
* @see AbstractUIPlugin#initializeDefaultPreferences
*/
protected void initializeDefaultPreferences(IPreferenceStore prefs) {
//Debug PreferencePage
prefs.setDefault(IDebugUIConstants.PREF_BUILD_BEFORE_LAUNCH, true);
prefs.setDefault(IDebugUIConstants.PREF_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH_RADIO, IDebugUIConstants.PREF_PROMPT_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH);
prefs.setDefault(IDebugUIConstants.PREF_SHOW_DEBUG_PERSPECTIVE_DEFAULT, IDebugUIConstants.ID_DEBUG_PERSPECTIVE);
prefs.setDefault(IDebugUIConstants.PREF_SHOW_RUN_PERSPECTIVE_DEFAULT, IDebugUIConstants.PERSPECTIVE_NONE);
prefs.setDefault(IDebugUIConstants.PREF_AUTO_REMOVE_OLD_LAUNCHES, false);
prefs.setDefault(IDebugUIConstants.PREF_ACTIVATE_WORKBENCH, true);
prefs.setDefault(IDebugUIConstants.PREF_REUSE_EDITOR, true);
//ConsolePreferencePage
prefs.setDefault(IDebugPreferenceConstants.CONSOLE_WRAP, false);
prefs.setDefault(IDebugPreferenceConstants.CONSOLE_WIDTH, 80);
prefs.setDefault(IDebugPreferenceConstants.CONSOLE_OPEN_ON_OUT, true);
prefs.setDefault(IDebugPreferenceConstants.CONSOLE_OPEN_ON_ERR, true);
prefs.setDefault(IDebugPreferenceConstants.CONSOLE_LIMIT_CONSOLE_OUTPUT, true);
prefs.setDefault(IDebugPreferenceConstants.CONSOLE_LOW_WATER_MARK, 80000);
prefs.setDefault(IDebugPreferenceConstants.CONSOLE_HIGH_WATER_MARK, 100000);
PreferenceConverter.setDefault(prefs, IDebugPreferenceConstants.CONSOLE_SYS_OUT_RGB, new RGB(0, 0, 255));
PreferenceConverter.setDefault(prefs, IDebugPreferenceConstants.CONSOLE_SYS_IN_RGB, new RGB(0, 200, 125));
PreferenceConverter.setDefault(prefs, IDebugPreferenceConstants.CONSOLE_SYS_ERR_RGB, new RGB(255, 0, 0));
//LaunchHistoryPreferencePage
prefs.setDefault(IDebugUIConstants.PREF_MAX_HISTORY_SIZE, 10);
//VariableViewsPreferencePage
prefs.setDefault(IDebugPreferenceConstants.VARIABLES_DETAIL_PANE_ORIENTATION, IDebugPreferenceConstants.VARIABLES_DETAIL_PANE_UNDERNEATH);
PreferenceConverter.setDefault(prefs, IDebugPreferenceConstants.CHANGED_VARIABLE_RGB, new RGB(255, 0, 0));
prefs.setDefault(IDebugPreferenceConstants.PREF_DETAIL_PANE_WORD_WRAP, false);
// Variable/Expression view default settings
prefs.setDefault(IDebugUIConstants.ID_VARIABLE_VIEW + '+' + "org.eclipse.debug.ui.ShowDetailPaneAction", true); //$NON-NLS-1$
prefs.setDefault(IDebugUIConstants.ID_EXPRESSION_VIEW + '+' + "org.eclipse.debug.ui.ShowDetailPaneAction", true); //$NON-NLS-1$
prefs.setDefault(IDebugUIConstants.ID_VARIABLE_VIEW + '+' + "org.eclipse.debug.ui.ShowTypeNamesAction", false); //$NON-NLS-1$
prefs.setDefault(IDebugUIConstants.ID_EXPRESSION_VIEW + '+' + "org.eclipse.debug.ui.ShowTypeNamesAction", false); //$NON-NLS-1$
}
protected IProcess getProcessFromInput(Object input) {
IProcess processInput= null;
if (input instanceof IProcess) {
processInput= (IProcess) input;
} else
if (input instanceof ILaunch) {
IDebugTarget target= ((ILaunch) input).getDebugTarget();
if (target != null) {
processInput= target.getProcess();
} else {
IProcess[] processes= ((ILaunch) input).getProcesses();
if ((processes != null) && (processes.length > 0)) {
processInput= processes[0];
}
}
} else
if (input instanceof IDebugElement) {
processInput= ((IDebugElement) input).getDebugTarget().getProcess();
}
return processInput;
}
/**
* Utility method with conventions
*/
public static void errorDialog(Shell shell, String title, String message, IStatus s) {
log(s);
// if the 'message' resource string and the IStatus' message are the same,
// don't show both in the dialog
if (s != null && message.equals(s.getMessage())) {
message= null;
}
ErrorDialog.openError(shell, title, message, s);
}
/**
* Utility method with conventions
*/
public static void errorDialog(Shell shell, String title, String message, Throwable t) {
log(t);
IStatus status;
if (t instanceof CoreException) {
status= ((CoreException)t).getStatus();
// if the 'message' resource string and the IStatus' message are the same,
// don't show both in the dialog
if (status != null && message.equals(status.getMessage())) {
message= null;
}
} else {
status= new Status(IStatus.ERROR, getUniqueIdentifier(), IDebugUIConstants.INTERNAL_ERROR, "Error within Debug UI: ", t); //$NON-NLS-1$
}
ErrorDialog.openError(shell, title, message, status);
}
/**
* 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 the specified throwable with this plug-in's log.
*
* @param t throwable to log
*/
public static void log(Throwable t) {
log(newErrorStatus("Error logged from Debug UI: ", t)); //$NON-NLS-1$
}
/**
* Logs the given message if in debug mode.
*
* @param String message to log
*/
public static void logDebugMessage(String message) {
if (getDefault().isDebugging()) {
logErrorMessage(message);
}
}
/**
* Logs an internal error with the specified message.
*
* @param message the error message to log
*/
public static void logErrorMessage(String message) {
// this message is intentionally not internationalized, as an exception may
// be due to the resource bundle itself
log(newErrorStatus("Internal message logged from Debug UI: " + message, null)); //$NON-NLS-1$
}
/**
* Returns a new error status for this plugin with the given message
* @param message the message to be included in the status
* @param exception the exception to be included in the status or <code>null</code> if none
* @return a new error status
*/
public static IStatus newErrorStatus(String message, Throwable exception) {
return new Status(IStatus.ERROR, getUniqueIdentifier(), IDebugUIConstants.INTERNAL_ERROR, message, exception);
}
/**
* Save all dirty editors of all the workbench pages.
* Returns whether the operation succeeded.
*
* @return whether all saving was completed
*/
protected static boolean saveAllPages(boolean confirm) {
if (getActiveWorkbenchWindow() == null) {
return false;
}
IWorkbench wb = getActiveWorkbenchWindow().getWorkbench();
IWorkbenchWindow[] windows = wb.getWorkbenchWindows();
for (int i = 0; i < windows.length; i++) {
IWorkbenchPage[] pages = windows[i].getPages();
for (int j = 0; j < pages.length; j++) {
if (!pages[j].saveAllEditors(confirm)) {
return false;
};
}
}
return true;
}
/**
* Save & build the workspace according to the user-specified preferences. Return <code>false</code> if
* any problems were encountered, <code>true</code> otherwise.
*/
public static boolean saveAndBuild() {
boolean status = true;
String saveDirty = getDefault().getPreferenceStore().getString(IDebugUIConstants.PREF_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH_RADIO);
boolean buildBeforeLaunch = getDefault().getPreferenceStore().getBoolean(IDebugUIConstants.PREF_BUILD_BEFORE_LAUNCH);
boolean autobuilding = ResourcesPlugin.getWorkspace().isAutoBuilding();
// If we're ignoring dirty editors, check if we need to build
if (saveDirty.equals(IDebugUIConstants.PREF_NEVER_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH)) {
if (buildBeforeLaunch) {
return doBuild();
}
} else {
boolean prompt = false;
if (saveDirty.equals(IDebugUIConstants.PREF_PROMPT_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH)) {
prompt = true;
}
status = saveAllPages(prompt);
if (status && !autobuilding && buildBeforeLaunch) {
status = doBuild();
}
}
return status;
}
private static boolean doBuild() {
ProgressMonitorDialog dialog= new ProgressMonitorDialog(getShell());
try {
dialog.run(true, true, new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException {
try {
ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
} catch (CoreException e) {
throw new InvocationTargetException(e);
}
}
});
} catch (InterruptedException e) {
// cancelled by user
return false;
} catch (InvocationTargetException e) {
String title= DebugUIMessages.getString("DebugUIPlugin.Run/Debug_1"); //$NON-NLS-1$
String message= DebugUIMessages.getString("DebugUIPlugin.Build_error._Check_log_for_details._2"); //$NON-NLS-1$
Throwable t = e.getTargetException();
errorDialog(getShell(), title, message, t);
return false;
}
return true;
}
/**
* Returns the standard display to be used. The method first checks, if
* the thread calling this method has an associated display. If so, this
* display is returned. Otherwise the method returns the default display.
*/
public static Display getStandardDisplay() {
Display display= Display.getCurrent();
if (display == null) {
display= Display.getDefault();
}
return display;
}
/**
* Returns the a color based on the type of output.
* Valid types:
* <li>CONSOLE_SYS_OUT_RGB</li>
* <li>CONSOLE_SYS_ERR_RGB</li>
* <li>CONSOLE_SYS_IN_RGB</li>
* <li>CHANGED_VARIABLE_RGB</li>
*/
public static Color getPreferenceColor(String type) {
return ColorManager.getDefault().getColor(PreferenceConverter.getColor(getDefault().getPreferenceStore(), type));
}
/**
* Returns the console document manager. The manager will be created lazily on
* the first access.
*
* @return ConsoleDocumentManager
*/
public ConsoleDocumentManager getConsoleDocumentManager() {
if (fConsoleDocumentManager == null) {
fConsoleDocumentManager = new ConsoleDocumentManager();
}
return fConsoleDocumentManager;
}
/**
* Serializes a XML document into a string - encoded in UTF8 format,
* with platform line separators.
*
* @param doc document to serialize
* @return the document as a string
*/
public static String serializeDocument(Document doc) throws IOException {
ByteArrayOutputStream s= new ByteArrayOutputStream();
OutputFormat format = new OutputFormat();
format.setIndenting(true);
format.setLineSeparator(System.getProperty("line.separator")); //$NON-NLS-1$
Serializer serializer =
SerializerFactory.getSerializerFactory(Method.XML).makeSerializer(
new OutputStreamWriter(s, "UTF8"), //$NON-NLS-1$
format);
serializer.asDOMSerializer().serialize(doc);
return s.toString("UTF8"); //$NON-NLS-1$
}
/**
* Determines and returns the selection in the specified window. If nothing is
* actually selected, look for an active editor.
*/
public static IStructuredSelection resolveSelection(IWorkbenchWindow window) {
if (window == null) {
return null;
}
ISelection selection= window.getSelectionService().getSelection();
if (selection == null || selection.isEmpty() || !(selection instanceof IStructuredSelection)) {
// there is no obvious selection - go fishing
selection= null;
IWorkbenchPage page= window.getActivePage();
if (page == null) {
//workspace is closed
return null;
}
// first, see if there is an active editor, and try its input element
IEditorPart editor= page.getActiveEditor();
Object element= null;
if (editor != null) {
element= editor.getEditorInput();
}
if (selection == null && element != null) {
selection= new StructuredSelection(element);
}
}
return (IStructuredSelection)selection;
}
/**
* When the first launch is added, instantiate launch processors,
* and stop listening to launch notifications.
* <p>
* Launch processors are:
* <ul>
* <li>console document manager</li>
* <li>perspective manager</li>
* </ul>
* </p>
* @see org.eclipse.debug.core.ILaunchListener#launchAdded(org.eclipse.debug.core.ILaunch)
*/
public void launchAdded(ILaunch launch) {
DebugPlugin.getDefault().getLaunchManager().removeLaunchListener(this);
getConsoleDocumentManager().startup();
if (fPerspectiveManager == null) {
PerspectiveManager manager = getPerspectiveManager();
manager.launchAdded(launch);
}
getLaunchConfigurationManager().startup();
}
/**
* Returns the persepective manager - instantiating it if required.
*
* @return
*/
public PerspectiveManager getPerspectiveManager() {
if (fPerspectiveManager == null) {
fPerspectiveManager = new PerspectiveManager();
fPerspectiveManager.startup();
}
return fPerspectiveManager;
}
/**
* @see org.eclipse.debug.core.ILaunchListener#launchChanged(org.eclipse.debug.core.ILaunch)
*/
public void launchChanged(ILaunch launch) {
}
/**
* @see org.eclipse.debug.core.ILaunchListener#launchRemoved(org.eclipse.debug.core.ILaunch)
*/
public void launchRemoved(ILaunch launch) {
}
/**
* Save dirty editors before launching, according to preferences.
*
* @return whether to proceed with launch
*/
public static boolean preLaunchSave() {
String saveDirty = getDefault().getPreferenceStore().getString(IDebugUIConstants.PREF_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH_RADIO);
if (saveDirty.equals(IDebugUIConstants.PREF_NEVER_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH)) {
return true;
} else {
return saveAllPages(saveDirty.equals(IDebugUIConstants.PREF_PROMPT_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH));
}
}
/**
* Builds the workspace (according to preferences) and launches the given launch
* configuration in the specified mode.
*
* @param configuration the configuration to launch
* @param mode launch mode - run or debug
* @param monitor progress monitor
* @exception CoreException if an exception occurrs while building or launching
* @return resulting launch
*/
public static ILaunch buildAndLaunch(ILaunchConfiguration configuration, String mode, IProgressMonitor monitor) throws CoreException {
boolean buildBeforeLaunch = getDefault().getPreferenceStore().getBoolean(IDebugUIConstants.PREF_BUILD_BEFORE_LAUNCH);
boolean autobuilding = ResourcesPlugin.getWorkspace().isAutoBuilding();
IProgressMonitor subMonitor = monitor;
String message = MessageFormat.format(DebugUIMessages.getString("DebugUIPlugin.Launching_{0}..._1"), new String[]{configuration.getName()}); //$NON-NLS-1$
if (!autobuilding && buildBeforeLaunch) {
monitor.beginTask(message, 200);
subMonitor = new SubProgressMonitor(monitor, 100);
ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, subMonitor);
subMonitor = new SubProgressMonitor(monitor, 100);
} else {
subMonitor = monitor;
subMonitor.beginTask(message, 100);
}
return configuration.launch(mode, subMonitor);
}
}
