Attachment #56666 for bug #74480

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




	Copyright (c) IBM Corporation and others 2000, 2006. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page.
	
	All Platform Debug contexts, those for org.eclipse.debug.ui, are located in this file
	All contexts are grouped by their relation, with all relations grouped alphabetically.
-->
<!--
	Breakpoints View

   		<topic label="Working Sets..." href="reference/views/breakpoints/ref-workingsets_viewaction.htm"/>
   	</context>
   	<context id="delete_associated_launch_configs_dialog">
   		<description>This dialog prompts users to clean up launch configurations that are associated with, or used to launch code from, the project that is being deleted </description>
   		<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>
		<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>
   	</context>

		<topic label="Source Attachments" href="reference/ref-124.htm"/>
	</context>
	<context  id="launch_configuration_dialog_launchers_tab" >
		<description>This tab allows you to a specific launchers to use with the selected launch configuration in the event there is more than one available.</description>
		<topic label="Java application launch configuration" href=" tasks\tasks-java-local-configuration.htm"/>
	</context>


	</context> 

<!--
	Multiview Action contexts
-->
	<context id="find_element_context">
		<description>This command finds an element by name.</description>

		<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
	</context>
	<context id="contextual_launch_preference_page">
		<description>This page allows you to change settings that apply to contextual launching</description>
		<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
	</context>
	
<!-- 
	Property Pages 

	<context id="TableRenderingPropertiesPage_context" >
		<description>This page displays properties from the selected memory.</description>
	</context>
	<context id="default_launchconfiguration_property_page">
		<description>This page displays the properties for default launch configurations for the selected resource</description>
	</context>

<!--
	Run Menu




			}
		}
		
		// get preference nodes
		org.osgi.service.prefs.Preferences projectNode = getProjectNode(resource);
		projectNode.remove(DEFAULT_CONFIGURATION);
		flush(projectNode);
		org.osgi.service.prefs.Preferences instanceNode = getInstanceNode(resource);
		instanceNode.remove(DEFAULT_CONFIGURATION);
		flush(instanceNode);
		
		if (configuration != null) {
			org.osgi.service.prefs.Preferences node = null;
			String configurationValue = null;
			if (configuration.isLocal()) {
				// for local configurations, use workspace (instance) scope preferences
				node = instanceNode;
				if (!configuration.isWorkingCopy()) {
					instanceNode.put(DEFAULT_CONFIGURATION, configuration.getMemento());
					projectNode.remove(DEFAULT_CONFIGURATION);
				}
				
			} else {
				// for shared configurations, use project scope preferences
				projectNode.put(DEFAULT_CONFIGURATION, configuration.getFile().getProjectRelativePath().toPortableString());
				instanceNode.remove(DEFAULT_CONFIGURATION);
			}
			node.put(DEFAULT_CONFIGURATION, configurationValue);
			flush(node);
		}
		else {
			//remove nodes because the default has been un-set
			projectNode.remove(DEFAULT_CONFIGURATION);
			instanceNode.remove(DEFAULT_CONFIGURATION);
		}
		flush(projectNode);
		flush(instanceNode);
	}	
	
	/**




	private IContainer fContainer;
	
	/**
	 * Parent working copy.
	 * @since 3.3
	 */
	private LaunchConfigurationWorkingCopy fParent = null;
	
	/**
	 * Constructs a working copy of the specified launch 
	 * configuration.
	 * 

		super(parent.getLocation());
		setName(parent.getName());
		copyFrom(parent);
		setOriginal(parent);
		fParent = parent;
		fSuppressChange = false;
	}	
	

	 * @see ILaunchConfigurationWorkingCopy#doSave()
	 */
	public synchronized ILaunchConfiguration doSave() throws CoreException {
		if (getOriginal() instanceof ILaunchConfigurationWorkingCopy) {
			// save to parent working copy
			LaunchConfigurationWorkingCopy wc = (LaunchConfigurationWorkingCopy) getOriginal();
			wc.setName(getName());
			wc.copyFrom(this);
			return wc;
		}
		else {
			boolean useRunnable= true;
			if (isLocal()) {
				if (isMoved()) {
					// If this config was moved from a shared location, saving
					// it will delete the original from the workspace. Use runnable.
					useRunnable= !isNew() && !getOriginal().isLocal();
					IWorkspaceRunnable wr = new IWorkspaceRunnable() {
						public void run(IProgressMonitor pm) throws CoreException {
							doSave0();
						}
					};
					
					ResourcesPlugin.getWorkspace().run(wr, null, 0, null);
				} else {
					useRunnable= false;
					doSave0();
				}
	
				getLaunchManager().setMovedFromTo(null, null);
			}
			if (useRunnable) {
				IWorkspaceRunnable wr = new IWorkspaceRunnable() {
					public void run(IProgressMonitor pm) throws CoreException {
						doSave0();
					}
				};
				
				ResourcesPlugin.getWorkspace().run(wr, null, 0, null);
			} else {
				//file is persisted in the metadata not the workspace
				doSave0();
			}
			getLaunchManager().setMovedFromTo(null, null);
		}
		return new LaunchConfiguration(getLocation());
	}

	

	 * @see org.eclipse.debug.internal.core.LaunchConfiguration#getWorkingCopy()
	 */
	public ILaunchConfigurationWorkingCopy getWorkingCopy() throws CoreException {
		return getNestedWorkingCopy();
			return super.getWorkingCopy();
		} else {
			return getNestedWorkingCopy();
		}
	}

	/* (non-Javadoc)

	public ILaunchConfigurationWorkingCopy getNestedWorkingCopy() throws CoreException {
		return new LaunchConfigurationWorkingCopy(this);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#getParent()
	 */
	public ILaunchConfigurationWorkingCopy getParent() {
		return fParent;
	}
}





	 * </p>
	 */
	public ILaunchConfigurationWorkingCopy getNestedWorkingCopy() throws CoreException;	
	
	/**
	 * Returns the parent of this working copy or <code>null</code> if this working
	 * copy is not a nested copy of another working copy.
	 * 
	 * @return parent or <code>null</code>
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public ILaunchConfigurationWorkingCopy getParent();
}




 * This class is an abstract implementation of common features for a debug <code>IViewActionDelegate</code>
 *
 * This class is intended to be extended by clients
 * @see implemented interface {@link IViewActionDelegate}
 * @see implemented interface {@link IActionDelegate2}
 */
public abstract class AbstractDebugActionDelegate implements IViewActionDelegate, IActionDelegate2 {
	

	private IViewPart fViewPart;
	
	/**
	 * Cache of the most recent selection
	 */
	private IStructuredSelection fSelection = StructuredSelection.EMPTY;
	

	private boolean fInitialized = false;
	
	/**
	 * It's crucial that delegate actions have a zero-argument constructor so that
	 * they can be reflected into existence when referenced in an action set
	 * in the plugin's plugin.xml file.
	 */

	}

	/**
	 * Sets the initialized state of this action to the specified boolean value
	 * @param initialized the value to set the initialized state to
	 */
	protected void setInitialized(boolean initialized) {




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 */
public class LaunchablePropertyTester extends PropertyTester {

	/**
	 * @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)
	 */
	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
		if ("launchable".equals(property)) { //$NON-NLS-1$
			if (DebugUIPlugin.getDefault().getLaunchConfigurationManager().launchModeAvailable((String)expectedValue)) {
				return Platform.getAdapterManager().hasAdapter(receiver, ILaunchable.class.getName());
			}

Lines 86-91 Link Here

(-)ui/org/eclipse/debug/internal/ui/IDebugHelpContextIds.java (+2 lines)
86	public static final String LAUNCH_CONFIGURATION_PREFERENCE_PAGE = PREFIX + "launch_configuration_preference_page_context"; //$NON-NLS-1$	86	public static final String LAUNCH_CONFIGURATION_PREFERENCE_PAGE = PREFIX + "launch_configuration_preference_page_context"; //$NON-NLS-1$
87	public static final String VIEW_MANAGEMENT_PREFERENCE_PAGE = PREFIX + "view_management_preference_page_context"; //$NON-NLS-1$	87	public static final String VIEW_MANAGEMENT_PREFERENCE_PAGE = PREFIX + "view_management_preference_page_context"; //$NON-NLS-1$
88	public static final String LAUNCH_DELEGATES_PREFERENCE_PAGE = PREFIX + "launch_delegate_preference_page_context"; //$NON-NLS-1$	88	public static final String LAUNCH_DELEGATES_PREFERENCE_PAGE = PREFIX + "launch_delegate_preference_page_context"; //$NON-NLS-1$
		89	public static final String CONTEXTUAL_LAUNCHING_PREFERENCE_PAGE = PREFIX + "contextual_launch_preference_page"; //$NON-NLS-1$
89		90
90	// Dialogs	91	// Dialogs
91	public static final String LAUNCH_CONFIGURATION_DIALOG = PREFIX + "launch_configuration_dialog"; //$NON-NLS-1$	92	public static final String LAUNCH_CONFIGURATION_DIALOG = PREFIX + "launch_configuration_dialog"; //$NON-NLS-1$
Lines 115-120 Link Here
115	// Property pages	116	// Property pages
116	public static final String PROCESS_PROPERTY_PAGE = PREFIX + "process_property_page_context"; //$NON-NLS-1$	117	public static final String PROCESS_PROPERTY_PAGE = PREFIX + "process_property_page_context"; //$NON-NLS-1$
117	public static final String PROCESS_PAGE_RUN_AT = PREFIX + "process_page_run_at_time_widget"; //$NON-NLS-1$	118	public static final String PROCESS_PAGE_RUN_AT = PREFIX + "process_page_run_at_time_widget"; //$NON-NLS-1$
		119	public static final String DEFAULT_LAUNCHCONFIGURATION_PROPERTY_PAGE = PREFIX + "default_launchconfiguration_property_page"; //$NON-NLS-1$
118		120
119	// Launch configuration dialog pages	121	// Launch configuration dialog pages
120	public static final String LAUNCH_CONFIGURATION_DIALOG_COMMON_TAB = PREFIX + "launch_configuration_dialog_common_tab"; //$NON-NLS-1$	122	public static final String LAUNCH_CONFIGURATION_DIALOG_COMMON_TAB = PREFIX + "launch_configuration_dialog_common_tab"; //$NON-NLS-1$

Lines 202-207 Link Here

(-)ui/org/eclipse/debug/internal/ui/IInternalDebugUIConstants.java (+8 lines)
202	public static final String DETAIL_PANE_FONT= "org.eclipse.debug.ui.DetailPaneFont"; //$NON-NLS-1$	202	public static final String DETAIL_PANE_FONT= "org.eclipse.debug.ui.DetailPaneFont"; //$NON-NLS-1$
203		203
204	/**	204	/**
		205	* Boolean preference indicating if contextual launch options should be visible
		206	* to the user rather than the "run as" menu.
		207	*
		208	* @since 3.3
		209	*/
		210	public static final String PREF_USE_CONTEXTUAL_LAUNCH= IDebugUIConstants.PLUGIN_ID + ".UseContextualLaunch"; //$NON-NLS-1$
		211
		212	/**
205	* String preference controlling whether editors are saved before launching.	213	* String preference controlling whether editors are saved before launching.
206	* Valid values are either "always", "never", or "prompt".	214	* Valid values are either "always", "never", or "prompt".
207	* If "always" or "never", launching will save editors (or not) automatically.	215	* If "always" or "never", launching will save editors (or not) automatically.

Lines 155-160 Link Here

(-)plugin.xml (-3 / +106 lines)
155	id="org.eclipse.debug.ui.launchDelegatesKeywords">	155	id="org.eclipse.debug.ui.launchDelegatesKeywords">
156	</keywordReference>	156	</keywordReference>
157	</page>	157	</page>
		158	<page
		159	category="org.eclipse.debug.ui.DebugPreferencePage"
		160	class="org.eclipse.debug.internal.ui.preferences.ContextualLaunchPreferencePage"
		161	id="org.eclipse.debug.ui.contextualLaunchingPage"
		162	name="%ContextualLaunchingPrefPage.name">
		163	<keywordReference
		164	id="org.eclipse.debug.ui.contextLaunching">
		165	</keywordReference>
		166	</page>
158	</extension>	167	</extension>
159	<extension point="org.eclipse.ui.actionSets">	168	<extension point="org.eclipse.ui.actionSets">
160	<actionSet	169	<actionSet
Lines 874-880 Link Here
874	id="org.eclipse.debug.ui.contextualLaunch.profile.submenu">	883	id="org.eclipse.debug.ui.contextualLaunch.profile.submenu">
875	</action>	884	</action>
876	<enablement>	885	<enablement>
877	<test property="org.eclipse.debug.ui.launchable" value="profile"/>	886	<and>
		887	<test property="org.eclipse.debug.ui.launchable" value="profile"/>
		888	<not>
		889	<test property="org.eclipse.debug.ui.contextlaunch" />
		890	</not>
		891	</and>
878	</enablement>	892	</enablement>
879	</objectContribution>	893	</objectContribution>
880	<objectContribution	894	<objectContribution
Lines 889-895 Link Here
889	id="org.eclipse.debug.ui.contextualLaunch.debug.submenu">	903	id="org.eclipse.debug.ui.contextualLaunch.debug.submenu">
890	</action>	904	</action>
891	<enablement>	905	<enablement>
892	<test property="org.eclipse.debug.ui.launchable" value="debug"/>	906	<and>
		907	<test property="org.eclipse.debug.ui.launchable" value="debug"/>
		908	<not>
		909	<test property="org.eclipse.debug.ui.contextlaunch" />
		910	</not>
		911	</and>
893	</enablement>	912	</enablement>
894	</objectContribution>	913	</objectContribution>
895	<objectContribution	914	<objectContribution
Lines 904-913 Link Here
904	id="org.eclipse.debug.ui.contextualLaunch.run.submenu">	923	id="org.eclipse.debug.ui.contextualLaunch.run.submenu">
905	</action>	924	</action>
906	<enablement>	925	<enablement>
907	<test property="org.eclipse.debug.ui.launchable" value="run"/>	926	<and>
		927	<test property="org.eclipse.debug.ui.launchable" value="run"/>
		928	<not>
		929	<test property="org.eclipse.debug.ui.contextlaunch" />
		930	</not>
		931	</and>
908	</enablement>	932	</enablement>
909	</objectContribution>	933	</objectContribution>
		934	<objectContribution
		935	id="org.eclipse.debug.ui.contextlaunch.debugas"
		936	objectClass="org.eclipse.core.runtime.IAdaptable">
		937	<action
		938	class="org.eclipse.debug.internal.ui.actions.ContextLaunchingContributedAction"
		939	enablesFor="1"
		940	icon="icons/full/etool16/debug_exc.gif"
		941	id="org.eclipse.debug.ui.contextlaunch.debugas"
		942	label="%ContextLaunchingDebugMenu.name"
		943	menubarPath="additions"
		944	tooltip="%ContextLaunchingDebugMenu.tooltip">
		945	</action>
		946	<enablement>
		947	<and>
		948	<test property="org.eclipse.debug.ui.contextlaunch" />
		949	<test property="org.eclipse.debug.ui.launchable" value="debug"/>
		950	</and>
		951	</enablement>
		952	</objectContribution>
		953	<objectContribution
		954	id="org.eclipse.debug.ui.contextlaunch.profileas"
		955	objectClass="org.eclipse.core.runtime.IAdaptable">
		956	<action
		957	class="org.eclipse.debug.internal.ui.actions.ContextLaunchingContributedAction"
		958	enablesFor="1"
		959	icon="icons/full/etool16/profile_exc.gif"
		960	id="org.eclipse.debug.ui.contextlaunch.profileas"
		961	label="%ContextLaunchingProfileMenu.name"
		962	menubarPath="additions"
		963	tooltip="%ContextLaunchingProfileMenu.tooltip">
		964	</action>
		965	<enablement>
		966	<and>
		967	<test property="org.eclipse.debug.ui.contextlaunch" />
		968	<test property="org.eclipse.debug.ui.launchable" value="profile"/>
		969	</and>
		970	</enablement>
		971	</objectContribution>
910	<!-- console additions -->	972	<!-- console additions -->
		973	<objectContribution
		974	id="org.eclipse.debug.ui.contextlaunch.runas"
		975	objectClass="org.eclipse.core.runtime.IAdaptable">
		976	<action
		977	class="org.eclipse.debug.internal.ui.actions.ContextLaunchingContributedAction"
		978	enablesFor="1"
		979	icon="icons/full/etool16/run_exc.gif"
		980	id="org.eclipse.debug.ui.contextlaunch.runas"
		981	label="%ContextLaunchingRunMenu.name"
		982	menubarPath="additions"
		983	tooltip="%ContextLaunchingRunMenu.tooltip">
		984	</action>
		985	<enablement>
		986	<and>
		987	<test property="org.eclipse.debug.ui.contextlaunch" />
		988	<test property="org.eclipse.debug.ui.launchable" value="run"/>
		989	</and>
		990	</enablement>
		991	</objectContribution>
911	<viewerContribution	992	<viewerContribution
912	targetID="org.eclipse.debug.ui.ProcessConsoleType.#ContextMenu"	993	targetID="org.eclipse.debug.ui.ProcessConsoleType.#ContextMenu"
913	id="org.eclipse.debug.ui.processConsoleContextMenu">	994	id="org.eclipse.debug.ui.processConsoleContextMenu">
Lines 1394-1399 Link Here
1394	</or>	1475	</or>
1395	</enabledWhen>	1476	</enabledWhen>
1396	</page>	1477	</page>
		1478	<page
		1479	class="org.eclipse.debug.internal.ui.preferences.DefaultLaunchConfigurationsPropertiesPage"
		1480	id="org.eclipse.debug.ui.properties.defaultLaunchConfigurations"
		1481	name="%DefaultLaunchConfigurationsPropPage.name"
		1482	>
		1483	<enabledWhen>
		1484	<adapt
		1485	type="org.eclipse.core.resources.IResource">
		1486	</adapt>
		1487	</enabledWhen>
		1488	</page>
1397	</extension>	1489	</extension>
1398	<!-- commands and their bindings	1490	<!-- commands and their bindings
1399	NOTE:	1491	NOTE:
Lines 2050-2055 Link Here
2050	properties="getModelIdentifier,isTerminatedOrDisconnected"	2142	properties="getModelIdentifier,isTerminatedOrDisconnected"
2051	type="org.eclipse.core.runtime.IAdaptable">	2143	type="org.eclipse.core.runtime.IAdaptable">
2052	</propertyTester>	2144	</propertyTester>
		2145	<propertyTester
		2146	class="org.eclipse.debug.internal.ui.preferences.ContextLaunchingPropertyTester"
		2147	id="org.eclipse.debug.ui.contextlaunching.IAdaptableTester"
		2148	namespace="org.eclipse.debug.ui"
		2149	properties="contextlaunch"
		2150	type="org.eclipse.core.runtime.IAdaptable">
		2151	</propertyTester>
2053	</extension>	2152	</extension>
2054	<!-- Context extensions -->	2153	<!-- Context extensions -->
2055	<extension	2154	<extension
Lines 2235-2240 Link Here
2235	id="org.eclipse.debug.ui.launchDelegatesKeywords"	2334	id="org.eclipse.debug.ui.launchDelegatesKeywords"
2236	label="%preferenceKeywords.launchDelegates">	2335	label="%preferenceKeywords.launchDelegates">
2237	</keyword>	2336	</keyword>
		2337	<keyword
		2338	id="org.eclipse.debug.ui.contextLaunching"
		2339	label="%preferenceKeywords.contextLaunching">
		2340	</keyword>
2238	</extension>	2341	</extension>
2239	<extension	2342	<extension
2240	point="org.eclipse.ui.importWizards">	2343	point="org.eclipse.ui.importWizards">

Lines 27-32 Link Here

(-)plugin.properties (+15 lines)
27	BreakpointOrganizersName=Breakpoint Organizers	27	BreakpointOrganizersName=Breakpoint Organizers
28	VariableValueEditorsName=Variable Value Editors	28	VariableValueEditorsName=Variable Value Editors
29		29
		30	ContextLaunchingRunMenu.name=&Run
		31	ContextLaunchingRunMenu.tooltip=Run the selected item
		32
		33	ContextLaunchingDebugMenu.name=&Debug
		34	ContextLaunchingDebugMenu.tooltip=Debug the selected item
		35
		36	ContextLaunchingProfileMenu.name=&Profile
		37	ContextLaunchingProfileMenu.tooltip=Profile the selected item
		38
		39	ContextualLaunchingPrefPage.name=Contextual Launching
		40
		41	DefaultLaunchConfigurationsPropPage.name=Default Launch Configurations
		42
30	BreakpointActionSet.label=Breakpoints	43	BreakpointActionSet.label=Breakpoints
31	CollapseAll.label=Collapse All	44	CollapseAll.label=Collapse All
32	CollapseAll.tooltip= Collapse All	45	CollapseAll.tooltip= Collapse All
Lines 329-334 Link Here
329	preferenceKeywords.perspective=perspectives switching assign automatic run debug	342	preferenceKeywords.perspective=perspectives switching assign automatic run debug
330	preferenceKeywords.launchConfigurations=filters launch migration configurations run debug	343	preferenceKeywords.launchConfigurations=filters launch migration configurations run debug
331	preferenceKeywords.launchDelegates=launch delegate duplicate run debug profile mode configuration launchers launcher modes	344	preferenceKeywords.launchDelegates=launch delegate duplicate run debug profile mode configuration launchers launcher modes
		345	preferenceKeywords.contextLaunching=run debug profile launch contextual delegate configuration execute
		346
332		347
333	exportBreakpoints.label=E&xport Breakpoints...	348	exportBreakpoints.label=E&xport Breakpoints...
334	importBreakpoints.label=I&mport Breakpoints...	349	importBreakpoints.label=I&mport Breakpoints...

Lines 57-63 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupExtension.java (-1 / +1 lines)
57	* on the given configuration element	57	* on the given configuration element
58	*	58	*
59	* @param element the configuration element defining the	59	* @param element the configuration element defining the
60	* attribtues of this launch configuration tab extension	60	* attributes of this launch configuration tab extension
61	* @return a new launch configuration tab extension	61	* @return a new launch configuration tab extension
62	*/	62	*/
63	public LaunchConfigurationTabGroupExtension(IConfigurationElement element) {	63	public LaunchConfigurationTabGroupExtension(IConfigurationElement element) {

Lines 492-498 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupViewer.java (+10 lines)
492	ILaunchConfigurationTab[] tabs = getTabs();	492	ILaunchConfigurationTab[] tabs = getTabs();
493	if (tabs != null) {	493	if (tabs != null) {
494	// update the working copy from the active tab	494	// update the working copy from the active tab
		495	boolean newwc = !getWorkingCopy().isDirty();
495	getActiveTab().performApply(getWorkingCopy());	496	getActiveTab().performApply(getWorkingCopy());
		497	if(getOriginal() instanceof ILaunchConfigurationWorkingCopy && newwc) {
		498	try {
		499	getWorkingCopy().doSave();
		500	}
		501	catch (CoreException e) {DebugUIPlugin.log(e);}
		502	}
496	updateButtons();	503	updateButtons();
497	// update error ticks	504	// update error ticks
498	CTabItem item = null;	505	CTabItem item = null;
Lines 632-637 Link Here
632	boolean refreshtabs = !delegatesEqual(fWorkingCopy, configuration);	639	boolean refreshtabs = !delegatesEqual(fWorkingCopy, configuration);
633	fOriginal = configuration;	640	fOriginal = configuration;
634	fWorkingCopy = configuration.getWorkingCopy();	641	fWorkingCopy = configuration.getWorkingCopy();
		642	if(fOriginal instanceof ILaunchConfigurationWorkingCopy) {
		643	fWorkingCopy.doSave();
		644	}
635	displayInstanceTabs(refreshtabs);	645	displayInstanceTabs(refreshtabs);
636	} else if (fInput instanceof ILaunchConfigurationType) {	646	} else if (fInput instanceof ILaunchConfigurationType) {
637	fDescription = getDescription((ILaunchConfigurationType)fInput);	647	fDescription = getDescription((ILaunchConfigurationType)fInput);

Lines 257-263 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchShortcutExtension.java (-2 / +2 lines)
257	* expression tree is malformed.	257	* expression tree is malformed.
258	*/	258	*/
259	public Expression getContextualLaunchEnablementExpression() throws CoreException {	259	public Expression getContextualLaunchEnablementExpression() throws CoreException {
260	// all of this stuff is optional, so...tedius testing is required	260	// all of this stuff is optional, so...tedious testing is required
261	if (fContextualLaunchExpr == null) {	261	if (fContextualLaunchExpr == null) {
262	IConfigurationElement contextualLaunchElement = getContextualLaunchConfigurationElement();	262	IConfigurationElement contextualLaunchElement = getContextualLaunchConfigurationElement();
263	if (contextualLaunchElement == null) {	263	if (contextualLaunchElement == null) {
Lines 284-290 Link Here
284	* expression tree is malformed.	284	* expression tree is malformed.
285	*/	285	*/
286	public Expression getShortcutEnablementExpression() throws CoreException {	286	public Expression getShortcutEnablementExpression() throws CoreException {
287	// all of this stuff is optional, so...tedius testing is required	287	// all of this stuff is optional, so...tedious testing is required
288	if (fStandardLaunchExpr == null) {	288	if (fStandardLaunchExpr == null) {
289	IConfigurationElement[] elements = getConfigurationElement().getChildren(ExpressionTagNames.ENABLEMENT);	289	IConfigurationElement[] elements = getConfigurationElement().getChildren(ExpressionTagNames.ENABLEMENT);
290	IConfigurationElement enablement = elements.length > 0 ? elements[0] : null;	290	IConfigurationElement enablement = elements.length > 0 ? elements[0] : null;

Lines 32-37 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationManager.java (-1 / +41 lines)
32	import javax.xml.parsers.ParserConfigurationException;	32	import javax.xml.parsers.ParserConfigurationException;
33	import javax.xml.transform.TransformerException;	33	import javax.xml.transform.TransformerException;
34		34
		35	import org.eclipse.core.expressions.EvaluationContext;
		36	import org.eclipse.core.expressions.IEvaluationContext;
35	import org.eclipse.core.resources.IProject;	37	import org.eclipse.core.resources.IProject;
36	import org.eclipse.core.resources.IResource;	38	import org.eclipse.core.resources.IResource;
37	import org.eclipse.core.resources.ISaveContext;	39	import org.eclipse.core.resources.ISaveContext;
Lines 56-61 Link Here
56	import org.eclipse.debug.core.ILaunchManager;	58	import org.eclipse.debug.core.ILaunchManager;
57	import org.eclipse.debug.core.ILaunchMode;	59	import org.eclipse.debug.core.ILaunchMode;
58	import org.eclipse.debug.internal.core.IConfigurationElementConstants;	60	import org.eclipse.debug.internal.core.IConfigurationElementConstants;
		61	import org.eclipse.debug.internal.core.LaunchManager;
59	import org.eclipse.debug.internal.ui.DebugPluginImages;	62	import org.eclipse.debug.internal.ui.DebugPluginImages;
60	import org.eclipse.debug.internal.ui.DebugUIPlugin;	63	import org.eclipse.debug.internal.ui.DebugUIPlugin;
61	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	64	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
Lines 594-604 Link Here
594	}	597	}
595	return fLaunchShortcuts;	598	return fLaunchShortcuts;
596	}	599	}
		600
		601	/**
		602	* Returns a listing of all of the <code>ILaunchConfigurationType</code>s that apply to the currently
		603	* specified <code>IResource</code>.
		604	*
		605	* @param resource the resource context
		606	* @return a listing of applicable <code>ILaunchConfigurationType</code>s, or an empty list, never <code>null</code>
		607	* @since 3.3
		608	*/
		609	public List getApplicableConfigurationTypes(IResource resource) {
		610	List types = new ArrayList();
		611	try {
		612	List exts = getLaunchShortcuts();
		613	LaunchShortcutExtension ext = null;
		614	List list = new ArrayList();
		615	list.add(resource);
		616	IEvaluationContext context = new EvaluationContext(null, list);
		617	context.addVariable("selection", list); //$NON-NLS-1$
		618	HashSet set = new HashSet();
		619	for(Iterator iter = exts.iterator(); iter.hasNext();) {
		620	ext = (LaunchShortcutExtension) iter.next();
		621	if(ext.evalEnablementExpression(context, ext.getContextualLaunchEnablementExpression())) {
		622	set.addAll(ext.getAssociatedConfigurationTypes());
		623	}
		624	}
		625	LaunchManager lm = (LaunchManager) DebugPlugin.getDefault().getLaunchManager();
		626	ILaunchConfigurationType type = null;
		627	for(Iterator iter = set.iterator(); iter.hasNext();) {
		628	type = lm.getLaunchConfigurationType((String)iter.next());
		629	if(type != null && type.getCategory() == null && !types.contains(type)) {
		630	types.add(type);
		631	}
		632	}
		633	}
		634	catch(CoreException ce) {DebugUIPlugin.log(ce);}
		635	return types;
		636	}
597		637
598	/**	638	/**
599	* Returns a listing of all applicable <code>LaunchShortcutExtension</code>s for the given	639	* Returns a listing of all applicable <code>LaunchShortcutExtension</code>s for the given
600	* launch configuration type id.	640	* launch configuration type id.
601	* @param typeid the id of the launch configuraiton	641	* @param typeid the id of the launch configuration
602	* @return a listing of <code>LaunchShortcutExtension</code>s that are associated with the specified launch configuration	642	* @return a listing of <code>LaunchShortcutExtension</code>s that are associated with the specified launch configuration
603	* type id or an empty list, never <code>null</code>	643	* type id or an empty list, never <code>null</code>
604	*	644	*

Lines 16-21 Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.properties (+15 lines)
16	ConsolePreferencePage_Standard_In__4=Standard &In text color:	16	ConsolePreferencePage_Standard_In__4=Standard &In text color:
17	ConsolePreferencePage_Standard_Out__2=Standard &Out text color:	17	ConsolePreferencePage_Standard_Out__2=Standard &Out text color:
18	ConsolePreferencePage_Wrap_text_1=Fixed &width console	18	ConsolePreferencePage_Wrap_text_1=Fixed &width console
		19	ContextualLaunchPreferencePage_0=This page is used to edit contextual launching options (EXPERIMENTAL).
		20	ContextualLaunchPreferencePage_1=&Enable contextual launching.
19	ConsolePreferencePage_Console_width=&Maximum character width:	21	ConsolePreferencePage_Console_width=&Maximum character width:
20	ConsolePreferencePage_Limit_console_output_1=&Limit console output	22	ConsolePreferencePage_Limit_console_output_1=&Limit console output
21	ConsolePreferencePage_Console_buffer_size__characters___2=Console &buffer size (characters):	23	ConsolePreferencePage_Console_buffer_size__characters___2=Console &buffer size (characters):
Lines 127-129 Link Here
127	LaunchDelegatesPreferencePage_4=Launcher Description	129	LaunchDelegatesPreferencePage_4=Launcher Description
128	LaunchPerspectivePreferencePage_0=There is no perspective information available to change.	130	LaunchPerspectivePreferencePage_0=There is no perspective information available to change.
129	LaunchPerspectivePreferencePage_1=The selected types/launchers do not have any common mode sets.	131	LaunchPerspectivePreferencePage_1=The selected types/launchers do not have any common mode sets.
		132	DefaultLaunchConfigurationsPropertiesPage_0=This page allows you to select a default way to launch the currently selected resource.
		133	DefaultLaunchConfigurationsPropertiesPage_1=&Select default configuration for {0}:
		134	DefaultLaunchConfigurationsPropertiesPage_2=&New...
		135	DefaultLaunchConfigurationsPropertiesPage_3=Create new launch configuration
		136	DefaultLaunchConfigurationsPropertiesPage_4=Du&plicate
		137	DefaultLaunchConfigurationsPropertiesPage_5=Duplicate selected launch configuration
		138	DefaultLaunchConfigurationsPropertiesPage_6=&Edit...
		139	DefaultLaunchConfigurationsPropertiesPage_7=Edit selected launch configuration
		140	DefaultLaunchConfigurationsPropertiesPage_8=De&lete
		141	DefaultLaunchConfigurationsPropertiesPage_9=Delete selected launch configuration
		142	DefaultLaunchConfigurationsPropertiesPage_10=Configuration must be located in project {0}
		143	DefaultLaunchConfigurationsPropertiesPage_11=Select Configuration Type
		144	DefaultLaunchConfigurationsPropertiesPage_12=&Select the configuration type to create:

Lines 32-37 Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.java (+30 lines)
32	public static String ConsolePreferencePage_12;	32	public static String ConsolePreferencePage_12;
33	public static String ConsolePreferencePage_13;	33	public static String ConsolePreferencePage_13;
34		34
		35	public static String ContextualLaunchPreferencePage_0;
		36
		37	public static String ContextualLaunchPreferencePage_1;
		38
35	public static String DebugPreferencePage_1;	39	public static String DebugPreferencePage_1;
36	public static String DebugPreferencePage_2;	40	public static String DebugPreferencePage_2;
37		41
Lines 51-56 Link Here
51	public static String DebugPreferencePage_26;	55	public static String DebugPreferencePage_26;
52	public static String DebugPreferencePage_27;	56	public static String DebugPreferencePage_27;
53		57
		58	public static String DefaultLaunchConfigurationsPropertiesPage_0;
		59
		60	public static String DefaultLaunchConfigurationsPropertiesPage_1;
		61
		62	public static String DefaultLaunchConfigurationsPropertiesPage_10;
		63
		64	public static String DefaultLaunchConfigurationsPropertiesPage_11;
		65
		66	public static String DefaultLaunchConfigurationsPropertiesPage_12;
		67
		68	public static String DefaultLaunchConfigurationsPropertiesPage_2;
		69
		70	public static String DefaultLaunchConfigurationsPropertiesPage_3;
		71
		72	public static String DefaultLaunchConfigurationsPropertiesPage_4;
		73
		74	public static String DefaultLaunchConfigurationsPropertiesPage_5;
		75
		76	public static String DefaultLaunchConfigurationsPropertiesPage_6;
		77
		78	public static String DefaultLaunchConfigurationsPropertiesPage_7;
		79
		80	public static String DefaultLaunchConfigurationsPropertiesPage_8;
		81
		82	public static String DefaultLaunchConfigurationsPropertiesPage_9;
		83
54	public static String LaunchDelegatesPreferencePage_0;	84	public static String LaunchDelegatesPreferencePage_0;
55		85
56	public static String LaunchDelegatesPreferencePage_1;	86	public static String LaunchDelegatesPreferencePage_1;

Lines 13-18 Link Here

(-)ui/org/eclipse/debug/ui/actions/AbstractLaunchToolbarAction.java (-3 / +9 lines)
13		13
14	import org.eclipse.debug.core.ILaunchConfiguration;	14	import org.eclipse.debug.core.ILaunchConfiguration;
15	import org.eclipse.debug.internal.ui.DebugUIPlugin;	15	import org.eclipse.debug.internal.ui.DebugUIPlugin;
		16	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
		17	import org.eclipse.debug.internal.ui.launchConfigurations.ContextLaunchAction;
16	import org.eclipse.debug.internal.ui.launchConfigurations.OrganizeFavoritesAction;	18	import org.eclipse.debug.internal.ui.launchConfigurations.OrganizeFavoritesAction;
17	import org.eclipse.debug.ui.DebugUITools;	19	import org.eclipse.debug.ui.DebugUITools;
18	import org.eclipse.jface.action.IAction;	20	import org.eclipse.jface.action.IAction;
Lines 54-62 Link Here
54	if (menu.getItemCount() > 0) {	56	if (menu.getItemCount() > 0) {
55	addSeparator(menu);	57	addSeparator(menu);
56	}	58	}
57		59	if(DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH)) {
58	addToMenu(menu, new LaunchShortcutsAction(getLaunchGroupIdentifier()), -1);	60	addToMenu(menu, new ContextLaunchAction(getLaunchGroupIdentifier()), -1);
59	addToMenu(menu, getOpenDialogAction(), -1);	61	}
		62	else {
		63	addToMenu(menu, new LaunchShortcutsAction(getLaunchGroupIdentifier()), -1);
		64	addToMenu(menu, getOpenDialogAction(), -1);
		65	}
60	addToMenu(menu, new OrganizeFavoritesAction(getLaunchGroupIdentifier()), -1);	66	addToMenu(menu, new OrganizeFavoritesAction(getLaunchGroupIdentifier()), -1);
61	}	67	}
62		68




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.preferences;

import org.eclipse.core.expressions.PropertyTester;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;

/**
 * Tests properties for enabling/disabling popup menu object contributions
 * @since 3.3
 * 
 * EXPERIMENTAL
 */
public class ContextLaunchingPropertyTester extends PropertyTester {

	/**
	 * @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)
	 */
	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
		if("contextlaunch".equals(property)) { //$NON-NLS-1$
			return DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH);
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.preferences;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.internal.core.LaunchManager;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.DefaultLabelProvider;
import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.SWTUtil;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationComparator;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.ILaunchGroup;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
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.Table;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ListDialog;
import org.eclipse.ui.dialogs.PropertyPage;

import com.ibm.icu.text.MessageFormat;

/**
 * Displays default launch configuration settings for a selected resource - associated launch configurations.
 * 
 * @see parent class {@link PropertyPage}
 * @see associated interface {@link ILaunchConfiguration}
 * @see utilized dialog {@link org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsDialog}
 * @see page help context id {@link IDebugHelpContextIds#DEFAULT_LAUNCHCONFIGURATION_PROPERTY_PAGE}
 * 
 * @since 3.3
 */
public class DefaultLaunchConfigurationsPropertiesPage extends PropertyPage {
	
	/**
	 * Provides a viewer filter for the tree 
	 */
	class DefaultConfigFilter extends ViewerFilter {

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
		 */
		public boolean select(Viewer viewer, Object parentElement, Object element) {
			boolean select = true;
			if (element instanceof ILaunchConfiguration) {
				try {
					ILaunchConfiguration configuration = (ILaunchConfiguration) element;
					select &= configuration.getType().getCategory() == null;
					select &= !DebugUITools.isPrivate(configuration);
					if (!configuration.isLocal()) {
						select &= getResource().getProject().equals(configuration.getFile().getProject());
					}
				} 
				catch (CoreException e) {return false;}
			}
			return select;
		}

	}
	
	/**
	 * List of configurations to be deleted
	 */
	private Set fDeletedConfigurations = new HashSet();
	
	/**
	 * List of original default candidates for the resource
	 */
	private Set fOriginalCandidates;
	
	private Set fConfigurationTypeContext = null;
	
	//widgets
	private CheckboxTableViewer fViewer;
	private Button fNewButton = null;
	private Button fEditButton = null;
	private Button fDuplicateButton = null;
	private Button fDeleteButton = null;

	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, IDebugHelpContextIds.DEFAULT_LAUNCHCONFIGURATION_PROPERTY_PAGE);
		
		Composite topComposite = SWTUtil.createComposite(parent, 2, 1, GridData.FILL_BOTH);
		
		SWTUtil.createWrapLabel(topComposite, DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_0, 2, 300);
		SWTUtil.createVerticalSpacer(topComposite, 2);
		SWTUtil.createWrapLabel(topComposite, MessageFormat.format(DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_1, new String[]{getResource().getName()}), 2, 300);
		
		fViewer = createViewer(topComposite);
		
		Composite buttonComp = SWTUtil.createComposite(topComposite, 1, 1, GridData.FILL_VERTICAL);
		GridLayout layout = (GridLayout) buttonComp.getLayout();
		layout.marginHeight = 0;
		fNewButton = SWTUtil.createPushButton(buttonComp, DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_2, null);
		fNewButton.setToolTipText(DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_3);
		fNewButton.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				handleNew();
			}
		});
		
		fDuplicateButton = SWTUtil.createPushButton(buttonComp, DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_4, null);
		fDuplicateButton.setToolTipText(DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_5);
		fDuplicateButton.setEnabled(false);
		fDuplicateButton.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				handleCopy();
			}
		});
		fEditButton = SWTUtil.createPushButton(buttonComp, DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_6, null);
		fEditButton.setToolTipText(DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_7);
		fEditButton.setEnabled(false);
		fEditButton.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				handleEdit();
			}
		});
		fDeleteButton = SWTUtil.createPushButton(buttonComp, DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_8, null);
		fDeleteButton.setToolTipText(DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_9);
		fDeleteButton.setEnabled(false);
		fDeleteButton.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				handleDelete();
			}
		});
		
		fViewer.setSelection(new StructuredSelection());
		applyDialogFont(topComposite);
		return topComposite;
	}

	/**
	 * Creates and returns the viewer that will display the possible default configurations.
	 * 
	 * @param parent parent composite to create the viewer in
	 * @return viewer viewer that will display possible default configurations
	 */
	protected CheckboxTableViewer createViewer(Composite parent){
		CheckboxTableViewer viewer = CheckboxTableViewer.newCheckList(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
		viewer.setLabelProvider(new DefaultLabelProvider());
		viewer.setContentProvider(new ArrayContentProvider());
		viewer.setComparator(new LaunchConfigurationComparator());
		viewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				if (event.getChecked()) {
					fViewer.setCheckedElements(new Object[] {event.getElement()});
				}
				else{
					fViewer.setCheckedElements(new Object[] {});
				}
			}
		});
		// Only filter private configurations and external tools to avoid filtering a default
		viewer.addFilter(new DefaultConfigFilter());
		Table builderTable = viewer.getTable();
		GridData tableGridData = new GridData(GridData.FILL_BOTH);
		tableGridData.heightHint = 300;
		builderTable.setLayoutData(tableGridData);
		
		IResource resource = getResource();
		fOriginalCandidates = getDefaultCandidates(resource);
		viewer.setInput(fOriginalCandidates);
		try {
			ILaunchConfiguration configuration = DebugPlugin.getDefault().getLaunchManager().getDefaultConfiguration(resource);
			if (configuration != null) {
				Iterator iterator = fOriginalCandidates.iterator();
				while (iterator.hasNext()) {
					ILaunchConfigurationWorkingCopy wc = (ILaunchConfigurationWorkingCopy) iterator.next();
					if (configuration.equals(wc.getOriginal())) {
						viewer.setChecked(wc, true);
						break;
					}
				}
			}
		} catch (CoreException e) {
			setErrorMessage(e.getMessage());
		}
		viewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				boolean empty = event.getSelection().isEmpty();
				fEditButton.setEnabled(!empty);
				fDuplicateButton.setEnabled(!empty);
				fDeleteButton.setEnabled(!empty);
			}
		});
		
		return viewer;
	}

	/**
	 * Returns the viewer displaying possible default configurations.
	 * 
	 * @return viewer
	 */
	protected CheckboxTableViewer getViewer(){
		return fViewer;
	}
		
	/**
	 * Returns the resource this property page is open on.
	 * 
	 * @return resource
	 */
	protected IResource getResource() {
		Object element = getElement();
		IResource resource = null;
		if (element instanceof IResource) {
			resource = (IResource) element;
		} else if (element instanceof IAdaptable) {
			resource = (IResource) ((IAdaptable)element).getAdapter(IResource.class);
		}
		return resource;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#performOk()
	 */
	public boolean performOk() {
		Object[] checked = fViewer.getCheckedElements();
		try {
			ILaunchConfiguration def = null;
			if (checked.length == 1) {
					def = (ILaunchConfiguration) checked[0];
					def = ((ILaunchConfigurationWorkingCopy)def).doSave();
			}
			DebugPlugin.getDefault().getLaunchManager().setDefaultConfiguration(getResource(), def);
		} catch (CoreException e) {
			setErrorMessage(e.getMessage());
			return false;
		}
	//delete 
		Iterator iter = fDeletedConfigurations.iterator();
		while (iter.hasNext()) {
			ILaunchConfigurationWorkingCopy currentConfig = (ILaunchConfigurationWorkingCopy) iter.next();
			try{			
				if (currentConfig.getOriginal() != null){
					currentConfig.getOriginal().delete();
				}
			} catch (CoreException e) {
				DebugPlugin.logMessage("Problem deleting configuration " + currentConfig.getName(), e); //$NON-NLS-1$
			}
		}
	//add
		iter = fOriginalCandidates.iterator();
		while (iter.hasNext()) {
			ILaunchConfigurationWorkingCopy currentConfig = (ILaunchConfigurationWorkingCopy) iter.next();
			if (currentConfig.isDirty()){
				try{
					currentConfig.doSave();
				} catch (CoreException e) {
					DebugPlugin.logMessage("Problem saving changes to configuration " + currentConfig.getName(), e); //$NON-NLS-1$
				}
			}
		}
		
		return super.performOk();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#performDefaults()
	 */
	protected void performDefaults() {
		fViewer.setAllChecked(false);
		setErrorMessage(null);
		setValid(true);
		super.performDefaults();
	}

	/**
	 * Returns a list of potential default configurations candidates for the given
	 * resource. The configurations are working copies.
	 *  
	 * @param resource resource
	 * @return list of default candidates
	 */
	private Set getDefaultCandidates(IResource resource) {
		collectConfigurationTypeContext();
		IPath resourcePath = resource.getFullPath();
		ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
		Set set = new HashSet();
		try {
			ILaunchConfiguration[] configurations = manager.getLaunchConfigurations();
			ILaunchConfiguration configuration = null;
			IResource[] resources = null;
			for (int i = 0; i < configurations.length; i++) {
				configuration = configurations[i];
				resources = configuration.getMappedResources();
				if (resources != null) {
					for (int j = 0; j < resources.length; j++) {
						if (resource.equals(resources[j]) || resourcePath.isPrefixOf(resources[j].getFullPath())) {
							set.add(configuration.getWorkingCopy());
							break;
						}
					}
				} else {
					// 1. similar to launch dialog - if no resource mapping, display the config
					if (!"org.eclipse.ui.externaltools".equals(configuration.getType().getCategory())) { //$NON-NLS-1$
						set.add(configuration.getWorkingCopy());
						fConfigurationTypeContext.add(configuration.getType());
					}
				}
			}
		} catch (CoreException e) {
			set.clear();
			DebugUIPlugin.log(e);
		}
		return set;
	}
	
	/**
	 * Collects the default set of <code>ILaunchConfigurationType</code>s based on the mapping from launch shortcuts.
	 * We also must consider those types of launch configurations that do not support a resource mapping, as those types might
	 * apply but we can't be sure 
	 */
	private void collectConfigurationTypeContext() {
		if(fConfigurationTypeContext == null) {
			fConfigurationTypeContext = new HashSet();
			fConfigurationTypeContext.addAll(DebugUIPlugin.getDefault().getLaunchConfigurationManager().getApplicableConfigurationTypes(getResource()));
		}
	}
	
	/**
	 * Returns the names of the launch configurations passed in as original input to the tree viewer
	 * @return the names of the original launch configurations
	 */
	private Set getConfigurationNames() {
		Set names = new HashSet();
		Iterator iter = fOriginalCandidates.iterator();
		Object o = null;
		while (iter.hasNext()) {
			o = iter.next();
			if(o instanceof ILaunchConfiguration) {
				names.add(((ILaunchConfiguration)o).getName());
			}
		}
		return names;
	}
	
	/**
	 * Returns selected configurations.
	 * 
	 * @return selected configurations
	 */
	private ILaunchConfigurationWorkingCopy[] getSelectedConfigurations() {
		IStructuredSelection ss = (IStructuredSelection) fViewer.getSelection();
		return (ILaunchConfigurationWorkingCopy[]) ss.toList().toArray(new ILaunchConfigurationWorkingCopy[ss.size()]);
	}

	/**
	 * Copy the selection
	 */
	private void handleCopy() {
		ILaunchConfigurationWorkingCopy configuration = getSelectedConfigurations()[0];
		try {
			ILaunchConfigurationWorkingCopy copy = configuration.copy(
					((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).generateUniqueLaunchConfigurationNameFrom(configuration.getName(), getConfigurationNames()));
			copy.setAttributes(configuration.getAttributes());
			fOriginalCandidates.add(copy);
			fViewer.refresh();
			fViewer.setSelection(new StructuredSelection(copy));
		} catch (CoreException e) {
			setErrorMessage(e.getMessage());
		}
	}

	/**
	 * Delete the selection
	 */
	private void handleDelete() {
		Table table = fViewer.getTable();
		int[] indices = table.getSelectionIndices();
		Arrays.sort(indices);
		ILaunchConfiguration[] configurations = getSelectedConfigurations();
		for (int i = 0; i < configurations.length; i++) {
			fDeletedConfigurations.add(configurations[i]);
			fOriginalCandidates.remove(configurations[i]);
		}
		fViewer.refresh();
		if (indices[0] < table.getItemCount()) {
			fViewer.setSelection(new StructuredSelection(table.getItem(indices[0]).getData()));
		} else if (table.getItemCount() > 0) {
			fViewer.setSelection(new StructuredSelection(table.getItem(table.getItemCount() - 1).getData()));
		}
	}

	/**
	 * Edit the selection
	 */
	private void handleEdit() {
		edit(getSelectedConfigurations()[0]);
		fViewer.refresh();
	}

	/**
	 * Edits the given configuration as a nested working copy.
	 * Returns the code from the dialog used to edit the configuration.
	 * 
	 * @param configuration
	 * @return dialog return code - OK or CANCEL
	 */
	private int edit(ILaunchConfigurationWorkingCopy configuration) {
		// TODO: This will result in an NPE in non-standard groups
		ILaunchGroup group = DebugUITools.getLaunchGroup(configuration, ILaunchManager.RUN_MODE);
		if (group == null) {
			group = DebugUITools.getLaunchGroup(configuration, ILaunchManager.DEBUG_MODE);
		}
		return DebugUIPlugin.openLaunchConfigurationPropertiesDialog(getShell(), configuration, group.getIdentifier(), getConfigurationNames(), null);
	}

	/**
	 * Create a new configuration
	 */
	private void handleNew() {
		List avail = new ArrayList(fConfigurationTypeContext);
		Collections.sort(avail, new Comparator() {
				public int compare(Object o1, Object o2) {
					ILaunchConfigurationType t1 = (ILaunchConfigurationType) o1;
					ILaunchConfigurationType t2 = (ILaunchConfigurationType) o2;
					return t1.getName().compareTo(t2.getName());
				}
			
			});
		ListDialog dialog = new ListDialog(getShell());
		dialog.setTitle(DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_11);
		dialog.setContentProvider(new ArrayContentProvider());
		dialog.setLabelProvider(new DefaultLabelProvider());
		dialog.setAddCancelButton(true);
		dialog.setMessage(DebugPreferencesMessages.DefaultLaunchConfigurationsPropertiesPage_12);
		dialog.setInput(avail);
		if (dialog.open() == Window.OK) {
			Object[] result = dialog.getResult();
			if (result.length == 1) {
				ILaunchConfigurationType type = (ILaunchConfigurationType) result[0];
				try {
					ILaunchConfigurationWorkingCopy wc = type.newInstance(null, 
							((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).
							generateUniqueLaunchConfigurationNameFrom("New_configuration", getConfigurationNames())); //$NON-NLS-1$
					if (edit(wc) == Window.OK) {
						fOriginalCandidates.add(wc);
						fViewer.refresh();
						fViewer.setSelection(new StructuredSelection(wc));
					}
				} catch (CoreException e) {
					setErrorMessage(e.getMessage());
				}
			}
		}
	}
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.launchConfigurations;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.ui.model.WorkbenchViewerComparator;

/**
 * Groups configurations by type.
 * 
 * @since 3.3
 */
public class LaunchConfigurationComparator extends WorkbenchViewerComparator {

	/**
	 * the map of categories of <code>ILaunchConfigurationType</code>s to <code>Integer</code>s entries
	 */
	private static Map fgCategories;
	
	/**
	 * @see org.eclipse.jface.viewers.ViewerComparator#category(java.lang.Object)
	 */
	public int category(Object element) {
		Map map = getCategories();
		if (element instanceof ILaunchConfiguration) {
			ILaunchConfiguration configuration = (ILaunchConfiguration) element;
			try {
				Integer i = (Integer) map.get(configuration.getType());
				if (i != null) {
					return i.intValue();
				}
			} catch (CoreException e) {
			}
		}
		return map.size();
	}
	
	/**
	 * Returns the map of categories
	 * @return the map of categories
	 */
	private Map getCategories() {
		if (fgCategories == null) {
			fgCategories = new HashMap();
			List types = Arrays.asList(DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationTypes());
			Collections.sort(types, new Comparator() {
				public int compare(Object o1, Object o2) {
					ILaunchConfigurationType t1 = (ILaunchConfigurationType) o1;
					ILaunchConfigurationType t2 = (ILaunchConfigurationType) o2;
					return t1.getName().compareTo(t2.getName());
				}
			
			});
			Iterator iterator = types.iterator();
			int i = 0;
			while (iterator.hasNext()) {
				fgCategories.put(iterator.next(), new Integer(i));
				i++;
			}
		}
		return fgCategories;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.preferences;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.SWTUtil;
import org.eclipse.jface.preference.BooleanFieldEditor;
import org.eclipse.jface.preference.FieldEditor;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.PlatformUI;

/**
 * A preference page for configuring launching preferences.
 * 
 * @since 3.3
 */
public class ContextualLaunchPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
	
	/**
	 * a list of the field editors
	 * @since 3.2
	 */
	private List fFieldEditors;
	
	/**
	 * The default constructor
	 */
	public ContextualLaunchPreferencePage() {
		super();
		setPreferenceStore(DebugUIPlugin.getDefault().getPreferenceStore());
	}
	
	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		super.createControl(parent);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), IDebugHelpContextIds.CONTEXTUAL_LAUNCHING_PREFERENCE_PAGE);
	}
	
	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		fFieldEditors = new ArrayList();
		Composite comp = SWTUtil.createComposite(parent, 1, 1, GridData.FILL_BOTH);
		
		SWTUtil.createWrapLabel(comp, DebugPreferencesMessages.ContextualLaunchPreferencePage_0, 1, 300);
		SWTUtil.createVerticalSpacer(comp, 2);
		//use contextual launch
		FieldEditor edit = new BooleanFieldEditor(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH, DebugPreferencesMessages.ContextualLaunchPreferencePage_1, comp);	
		fFieldEditors.add(edit);
			
		//init the field editors
		initFieldEditors();
		return comp;
	}
	
	/**
	 * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
	 */
	public void init(IWorkbench workbench) {}
	
	/**
	 * Initializes the field editors to their values
	 * @since 3.2
	 */
	private void initFieldEditors() {
		FieldEditor editor;
		for(int i = 0; i < fFieldEditors.size(); i++) {
			editor = (FieldEditor)fFieldEditors.get(i);
			editor.setPreferenceStore(getPreferenceStore());
			editor.load();
		}
	}
	
	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performDefaults()
	 */
	protected void performDefaults() {
		for(int i = 0; i < fFieldEditors.size(); i++) {
			((FieldEditor)fFieldEditors.get(i)).loadDefault();
		}
	}
	
	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performOk()
	 */
	public boolean performOk() {
		for(int i = 0; i < fFieldEditors.size(); i++) {
			((FieldEditor)fFieldEditors.get(i)).store();
		}
		return super.performOk();
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.actions;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate2;

/**
 * A stub action
 * 
 * @since 3.3
 * EXPERIMENTAL
 */
public class ContextLaunchingContributedAction implements IActionDelegate2 {

	/**
	 * Constructor
	 */
	public ContextLaunchingContributedAction() {}

	/**
	 * @see org.eclipse.ui.IActionDelegate2#dispose()
	 */
	public void dispose() {}

	/**
	 * @see org.eclipse.ui.IActionDelegate2#init(org.eclipse.jface.action.IAction)
	 */
	public void init(IAction action) {}

	/**
	 * @see org.eclipse.ui.IActionDelegate2#runWithEvent(org.eclipse.jface.action.IAction, org.eclipse.swt.widgets.Event)
	 */
	public void runWithEvent(IAction action, Event event) {}

	/**
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {}

	/**
	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection) {}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui.launchConfigurations;

import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;

/**
 * A wrapper class for a context launching toolbar action
 * 
 *  @since 3.3
 *  EXPERIMENTAL
 */
public class ContextLaunchAction extends Action implements IWorkbenchWindowActionDelegate {

	private String fId = null;
	
	/**
	 * Constructor
	 * @param id
	 */
	public ContextLaunchAction(String id) {
		fId = id;
		LaunchGroupExtension extension = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(id);
		if (extension != null) {
			setText(extension.getLabel());
			setImageDescriptor(extension.getImageDescriptor());
		}
	}

	/**
	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
	 */
	public void dispose() {
		fId = null;
	}

	/**
	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#init(org.eclipse.ui.IWorkbenchWindow)
	 */
	public void init(IWorkbenchWindow window) {}

	/**
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {}

	/**
	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection) {}
}

Lines 53-59 Link Here

(-)ui/org/eclipse/jdt/debug/ui/launchConfigurations/JavaMainTab.java (-1 / +1 lines)
53	* A launch configuration tab that displays and edits project and	53	* A launch configuration tab that displays and edits project and
54	* main type name launch configuration attributes.	54	* main type name launch configuration attributes.
55	* <p>	55	* <p>
56	* This class may be instantiated. This class is not intended to be subclassed.	56	* This class may be instantiated. This class is not intended to be sub-classed.
57	* </p>	57	* </p>
58	* @since 3.2	58	* @since 3.2
59	*/	59	*/

Return to bug 74480

Lines 2454-2485 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchManager.java (-15 / +13 lines)
2454	}	2454	}
2455	}	2455	}
2456		2456
2457	// remove previous settings, if any	2457	// get preference nodes
2458	org.osgi.service.prefs.Preferences projectNode = getProjectNode(resource);	2458	org.osgi.service.prefs.Preferences projectNode = getProjectNode(resource);
2459	projectNode.remove(DEFAULT_CONFIGURATION);
2460	flush(projectNode);
2461	org.osgi.service.prefs.Preferences instanceNode = getInstanceNode(resource);	2459	org.osgi.service.prefs.Preferences instanceNode = getInstanceNode(resource);
2462	instanceNode.remove(DEFAULT_CONFIGURATION);
2463	flush(instanceNode);
2464
2465	if (configuration != null) {	2460	if (configuration != null) {
2466	org.osgi.service.prefs.Preferences node = null;
2467	String configurationValue = null;
2468	if (configuration.isLocal()) {	2461	if (configuration.isLocal()) {
2469	// for local configurations, use workspace (instance) scope preferences	2462	// for local configurations, use workspace (instance) scope preferences
2470	node = instanceNode;
2471	if (!configuration.isWorkingCopy()) {	2463	if (!configuration.isWorkingCopy()) {
2472	configurationValue = configuration.getMemento();	2464	instanceNode.put(DEFAULT_CONFIGURATION, configuration.getMemento());
		2465	projectNode.remove(DEFAULT_CONFIGURATION);
2473	}	2466	}
		2467
2474	} else {	2468	} else {
2475	// for shared configurations, use project scope preferences	2469	// for shared configurations, use project scope preferences
2476	node = projectNode;	2470	projectNode.put(DEFAULT_CONFIGURATION, configuration.getFile().getProjectRelativePath().toPortableString());
2477	configurationValue = configuration.getFile().getProjectRelativePath().toPortableString();	2471	instanceNode.remove(DEFAULT_CONFIGURATION);
2478	}	2472	}
2479	node.put(DEFAULT_CONFIGURATION, configurationValue);
2480	flush(node);
2481	}	2473	}
2482		2474	else {
		2475	//remove nodes because the default has been un-set
		2476	projectNode.remove(DEFAULT_CONFIGURATION);
		2477	instanceNode.remove(DEFAULT_CONFIGURATION);
		2478	}
		2479	flush(projectNode);
		2480	flush(instanceNode);
2483	}	2481	}
2484		2482
2485	/**	2483	/**

Lines 5-11 Link Here

(-)contexts_Debugger.xml (-4 / +12 lines)
5	Copyright (c) IBM Corporation and others 2000, 2006. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page.	5	Copyright (c) IBM Corporation and others 2000, 2006. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page.
6		6
7	All Platform Debug contexts, those for org.eclipse.debug.ui, are located in this file	7	All Platform Debug contexts, those for org.eclipse.debug.ui, are located in this file
8	All contexts are gouped by their relation, with all relations grouped alphabetically.	8	All contexts are grouped by their relation, with all relations grouped alphabetically.
9	-->	9	-->
10	<!--	10	<!--
11	Breakpoints View	11	Breakpoints View
Lines 558-564 Link Here
558	<topic label="Working Sets..." href="reference/views/breakpoints/ref-workingsets_viewaction.htm"/>	558	<topic label="Working Sets..." href="reference/views/breakpoints/ref-workingsets_viewaction.htm"/>
559	</context>	559	</context>
560	<context id="delete_associated_launch_configs_dialog">	560	<context id="delete_associated_launch_configs_dialog">
561	<description>This dialog prompts users to clean up launch configuraitons that are associated with, or used to launch code from, the project that is being deleted </description>	561	<description>This dialog prompts users to clean up launch configurations that are associated with, or used to launch code from, the project that is being deleted </description>
562	<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>	562	<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>
563	<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>	563	<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>
564	</context>	564	</context>
Lines 677-683 Link Here
677	<topic label="Source Attachments" href="reference/ref-124.htm"/>	677	<topic label="Source Attachments" href="reference/ref-124.htm"/>
678	</context>	678	</context>
679	<context id="launch_configuration_dialog_launchers_tab" >	679	<context id="launch_configuration_dialog_launchers_tab" >
680	<description>This tab allows you to a specific launchers to use with the selected launch configuration in the event ther is more than one available.</description>	680	<description>This tab allows you to a specific launchers to use with the selected launch configuration in the event there is more than one available.</description>
681	<topic label="Java application launch configuration" href=" tasks\tasks-java-local-configuration.htm"/>	681	<topic label="Java application launch configuration" href=" tasks\tasks-java-local-configuration.htm"/>
682	</context>	682	</context>
683		683
Lines 794-800 Link Here
794	</context>	794	</context>
795		795
796	<!--	796	<!--
797	Multiview Action conetxts	797	Multiview Action contexts
798	-->	798	-->
799	<context id="find_element_context">	799	<context id="find_element_context">
800	<description>This command finds an element by name.</description>	800	<description>This command finds an element by name.</description>
Lines 867-872 Link Here
867	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>	867	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
868	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>	868	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
869	</context>	869	</context>
		870	<context id="contextual_launch_preference_page">
		871	<description>This page allows you to change settings that apply to contextual launching</description>
		872	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		873	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
		874	</context>
870		875
871	<!--	876	<!--
872	Property Pages	877	Property Pages
Lines 880-885 Link Here
880	<context id="TableRenderingPropertiesPage_context" >	885	<context id="TableRenderingPropertiesPage_context" >
881	<description>This page displays properties from the selected memory.</description>	886	<description>This page displays properties from the selected memory.</description>
882	</context>	887	</context>
		888	<context id="default_launchconfiguration_property_page">
		889	<description>This page displays the properties for default launch configurations for the selected resource</description>
		890	</context>
883		891
884	<!--	892	<!--
885	Run Menu	893	Run Menu

Lines 87-98 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationWorkingCopy.java (-52 / +31 lines)
87	private IContainer fContainer;	87	private IContainer fContainer;
88		88
89	/**	89	/**
90	* Parent working copy.
91	* @since 3.3
92	*/
93	private LaunchConfigurationWorkingCopy fParent = null;
94
95	/**
96	* Constructs a working copy of the specified launch	90	* Constructs a working copy of the specified launch
97	* configuration.	91	* configuration.
98	*	92	*
Lines 121-128 Link Here
121	super(parent.getLocation());	115	super(parent.getLocation());
122	setName(parent.getName());	116	setName(parent.getName());
123	copyFrom(parent);	117	copyFrom(parent);
124	setOriginal((LaunchConfiguration) parent.getOriginal());	118	setOriginal(parent);
125	fParent = parent;
126	fSuppressChange = false;	119	fSuppressChange = false;
127	}	120	}
128		121
Lines 173-214 Link Here
173	* @see ILaunchConfigurationWorkingCopy#doSave()	166	* @see ILaunchConfigurationWorkingCopy#doSave()
174	*/	167	*/
175	public synchronized ILaunchConfiguration doSave() throws CoreException {	168	public synchronized ILaunchConfiguration doSave() throws CoreException {
176	if (fParent == null) {	169	if (getOriginal() instanceof ILaunchConfigurationWorkingCopy) {
177	if (isDirty()) {	170	// save to parent working copy
178	boolean useRunnable= true;	171	LaunchConfigurationWorkingCopy wc = (LaunchConfigurationWorkingCopy) getOriginal();
179	if (isLocal()) {	172	wc.setName(getName());
180	if (isMoved()) {	173	wc.copyFrom(this);
181	// If this config was moved from a shared location, saving	174	return wc;
182	// it will delete the original from the workspace. Use runnable.	175	}
183	useRunnable= !isNew() && !getOriginal().isLocal();	176	else {
184	} else {	177	boolean useRunnable= true;
185	useRunnable= false;	178	if (isLocal()) {
186	}	179	if (isMoved()) {
187	}	180	// If this config was moved from a shared location, saving
188		181	// it will delete the original from the workspace. Use runnable.
189	if (useRunnable) {	182	useRunnable= !isNew() && !getOriginal().isLocal();
190	IWorkspaceRunnable wr = new IWorkspaceRunnable() {
191	public void run(IProgressMonitor pm) throws CoreException {
192	doSave0();
193	}
194	};
195
196	ResourcesPlugin.getWorkspace().run(wr, null, 0, null);
197	} else {	183	} else {
198	//file is persisted in the metadata not the workspace	184	useRunnable= false;
199	doSave0();
200	}	185	}
201
202	getLaunchManager().setMovedFromTo(null, null);
203	}	186	}
204		187	if (useRunnable) {
205	return new LaunchConfiguration(getLocation());	188	IWorkspaceRunnable wr = new IWorkspaceRunnable() {
206	} else {	189	public void run(IProgressMonitor pm) throws CoreException {
207	// save to parent working copy	190	doSave0();
208	fParent.setName(getName());	191	}
209	fParent.copyFrom(this);	192	};
210	return fParent;	193
		194	ResourcesPlugin.getWorkspace().run(wr, null, 0, null);
		195	} else {
		196	//file is persisted in the metadata not the workspace
		197	doSave0();
		198	}
		199	getLaunchManager().setMovedFromTo(null, null);
211	}	200	}
		201	return new LaunchConfiguration(getLocation());
212	}	202	}
213		203
214		204
Lines 670-680 Link Here
670	* @see org.eclipse.debug.internal.core.LaunchConfiguration#getWorkingCopy()	660	* @see org.eclipse.debug.internal.core.LaunchConfiguration#getWorkingCopy()
671	*/	661	*/
672	public ILaunchConfigurationWorkingCopy getWorkingCopy() throws CoreException {	662	public ILaunchConfigurationWorkingCopy getWorkingCopy() throws CoreException {
673	if (fParent == null) {	663	return getNestedWorkingCopy();
674	return super.getWorkingCopy();
675	} else {
676	return getNestedWorkingCopy();
677	}
678	}	664	}
679		665
680	/* (non-Javadoc)	666	/* (non-Javadoc)
Lines 683-694 Link Here
683	public ILaunchConfigurationWorkingCopy getNestedWorkingCopy() throws CoreException {	669	public ILaunchConfigurationWorkingCopy getNestedWorkingCopy() throws CoreException {
684	return new LaunchConfigurationWorkingCopy(this);	670	return new LaunchConfigurationWorkingCopy(this);
685	}	671	}
686
687	/* (non-Javadoc)
688	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#getParent()
689	*/
690	public ILaunchConfigurationWorkingCopy getParent() {
691	return fParent;
692	}
693	}	672	}
694		673

Lines 277-294 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfigurationWorkingCopy.java (-14 lines)
277	* </p>	277	* </p>
278	*/	278	*/
279	public ILaunchConfigurationWorkingCopy getNestedWorkingCopy() throws CoreException;	279	public ILaunchConfigurationWorkingCopy getNestedWorkingCopy() throws CoreException;
280
281	/**
282	* Returns the parent of this working copy or <code>null</code> if this working
283	* copy is not a nested copy of another working copy.
284	*
285	* @return parent or <code>null</code>
286	* <p>
287	* <strong>EXPERIMENTAL</strong>. This method has been added as
288	* part of a work in progress. There is no guarantee that this API will
289	* remain unchanged during the 3.3 release cycle. Please do not use this API
290	* without consulting with the Platform/Debug team.
291	* </p>
292	*/
293	public ILaunchConfigurationWorkingCopy getParent();
294	}	280	}

Lines 32-39 Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/AbstractDebugActionDelegate.java (-5 / +5 lines)
32	* This class is an abstract implementation of common features for a debug <code>IViewActionDelegate</code>	32	* This class is an abstract implementation of common features for a debug <code>IViewActionDelegate</code>
33	*	33	*
34	* This class is intended to be extended by clients	34	* This class is intended to be extended by clients
35	* @see {@link IViewActionDelegate}	35	* @see implemented interface {@link IViewActionDelegate}
36	* @see {@link IActionDelegate2}	36	* @see implemented interface {@link IActionDelegate2}
37	*/	37	*/
38	public abstract class AbstractDebugActionDelegate implements IViewActionDelegate, IActionDelegate2 {	38	public abstract class AbstractDebugActionDelegate implements IViewActionDelegate, IActionDelegate2 {
39		39
Lines 48-54 Link Here
48	private IViewPart fViewPart;	48	private IViewPart fViewPart;
49		49
50	/**	50	/**
51	* Cache of the most recent seletion	51	* Cache of the most recent selection
52	*/	52	*/
53	private IStructuredSelection fSelection = StructuredSelection.EMPTY;	53	private IStructuredSelection fSelection = StructuredSelection.EMPTY;
54		54
Lines 58-64 Link Here
58	private boolean fInitialized = false;	58	private boolean fInitialized = false;
59		59
60	/**	60	/**
61	* It's crucial that delegate actions have a zero-arg constructor so that	61	* It's crucial that delegate actions have a zero-argument constructor so that
62	* they can be reflected into existence when referenced in an action set	62	* they can be reflected into existence when referenced in an action set
63	* in the plugin's plugin.xml file.	63	* in the plugin's plugin.xml file.
64	*/	64	*/
Lines 257-263 Link Here
257	}	257	}
258		258
259	/**	259	/**
260	* Sets the initialized state of this aciton to the specified boolean value	260	* Sets the initialized state of this action to the specified boolean value
261	* @param initialized the value to set the initialized state to	261	* @param initialized the value to set the initialized state to
262	*/	262	*/
263	protected void setInitialized(boolean initialized) {	263	protected void setInitialized(boolean initialized) {

Lines 1-5 Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/LaunchablePropertyTester.java (-3 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 20-30 Link Here
20	*/	20	*/
21	public class LaunchablePropertyTester extends PropertyTester {	21	public class LaunchablePropertyTester extends PropertyTester {
22		22
23	/* (non-Javadoc)	23	/**
24	* @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)	24	* @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)
25	*/	25	*/
26	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {	26	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
27	if (property.equals("launchable")) { //$NON-NLS-1$	27	if ("launchable".equals(property)) { //$NON-NLS-1$
28	if (DebugUIPlugin.getDefault().getLaunchConfigurationManager().launchModeAvailable((String)expectedValue)) {	28	if (DebugUIPlugin.getDefault().getLaunchConfigurationManager().launchModeAvailable((String)expectedValue)) {
29	return Platform.getAdapterManager().hasAdapter(receiver, ILaunchable.class.getName());	29	return Platform.getAdapterManager().hasAdapter(receiver, ILaunchable.class.getName());
30	}	30	}

Lines 26-34 Link Here

(-)ui/org/eclipse/debug/internal/ui/DebugUIPreferenceInitializer.java (-5 / +8 lines)
26	super();	26	super();
27	}	27	}
28		28
29	/*	29	/**
30	* (non-Javadoc)
31	*
32	* @see org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer#initializeDefaultPreferences()	30	* @see org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer#initializeDefaultPreferences()
33	*/	31	*/
34	public void initializeDefaultPreferences() {	32	public void initializeDefaultPreferences() {
Lines 51-56 Link Here
51	prefs.setDefault(IDebugPreferenceConstants.PREF_PROMPT_REMOVE_ALL_BREAKPOINTS, true);	49	prefs.setDefault(IDebugPreferenceConstants.PREF_PROMPT_REMOVE_ALL_BREAKPOINTS, true);
52	prefs.setDefault(IDebugPreferenceConstants.PREF_PROMPT_REMOVE_BREAKPOINTS_FROM_CONTAINER, true);	50	prefs.setDefault(IDebugPreferenceConstants.PREF_PROMPT_REMOVE_BREAKPOINTS_FROM_CONTAINER, true);
53		51
		52	//contextual launching preference page
		53	prefs.setDefault(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH, false);
		54
54	//View Management preference page	55	//View Management preference page
55	prefs.setDefault(IDebugUIConstants.PREF_MANAGE_VIEW_PERSPECTIVES, IDebugUIConstants.ID_DEBUG_PERSPECTIVE);	56	prefs.setDefault(IDebugUIConstants.PREF_MANAGE_VIEW_PERSPECTIVES, IDebugUIConstants.ID_DEBUG_PERSPECTIVE);
56	prefs.setDefault(IInternalDebugUIConstants.PREF_TRACK_VIEWS, true);	57	prefs.setDefault(IInternalDebugUIConstants.PREF_TRACK_VIEWS, true);
Lines 111-120 Link Here
111	prefs.setDefault(IDebugUIConstants.PREF_DEFAULT_EBCDIC_CODE_PAGE,	112	prefs.setDefault(IDebugUIConstants.PREF_DEFAULT_EBCDIC_CODE_PAGE,
112	IDebugPreferenceConstants.DEFAULT_EBCDIC_CP);	113	IDebugPreferenceConstants.DEFAULT_EBCDIC_CP);
113		114
114	if (MemoryViewUtil.isLinuxGTK())	115	if (MemoryViewUtil.isLinuxGTK()) {
115	prefs.setDefault(IDebugPreferenceConstants.PREF_DYNAMIC_LOAD_MEM, false);	116	prefs.setDefault(IDebugPreferenceConstants.PREF_DYNAMIC_LOAD_MEM, false);
116	else	117	}
		118	else {
117	prefs.setDefault(IDebugPreferenceConstants.PREF_DYNAMIC_LOAD_MEM, true);	119	prefs.setDefault(IDebugPreferenceConstants.PREF_DYNAMIC_LOAD_MEM, true);
		120	}
118		121
119	prefs.setDefault(IDebugPreferenceConstants.PREF_TABLE_RENDERING_PAGE_SIZE, IDebugPreferenceConstants.DEFAULT_PAGE_SIZE);	122	prefs.setDefault(IDebugPreferenceConstants.PREF_TABLE_RENDERING_PAGE_SIZE, IDebugPreferenceConstants.DEFAULT_PAGE_SIZE);
120	prefs.setDefault(IDebugPreferenceConstants.PREF_RESET_MEMORY_BLOCK, IDebugPreferenceConstants.RESET_VISIBLE);	123	prefs.setDefault(IDebugPreferenceConstants.PREF_RESET_MEMORY_BLOCK, IDebugPreferenceConstants.RESET_VISIBLE);

Added Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/ContextLaunchingPropertyTester.java (+34 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.internal.ui.preferences;
12
13	import org.eclipse.core.expressions.PropertyTester;
14	import org.eclipse.debug.internal.ui.DebugUIPlugin;
15	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
16
17	/**
18	* Tests properties for enabling/disabling popup menu object contributions
19	* @since 3.3
20	*
21	* EXPERIMENTAL
22	*/
23	public class ContextLaunchingPropertyTester extends PropertyTester {
24
25	/**
26	* @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)
27	*/
28	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
29	if("contextlaunch".equals(property)) { //$NON-NLS-1$
30	return DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH);
31	}
32	return false;
33	}
34	}