Attachment #132680 for bug #272416




            class="org.eclipse.cdt.make.ui.dialogs.GCCPerProjectSCDProfilePage"
            name="%MBSPerProjectProfile.name"
            profileId="org.eclipse.cdt.managedbuilder.core.GCCWinManagedMakePerProjectProfileCPP"/>
   </extension>
     <extension
           point="org.eclipse.cdt.ui.workingSetConfigurations">
        <projectConfigurationFactory
              class="org.eclipse.cdt.managedbuilder.internal.ui.workingsets.MBSProjectConfigurationFactory"
              id="org.eclipse.cdt.managedbuilder.ui.mbsProjectConfigurationFactory">
           <projectNature
                 id="org.eclipse.cdt.managedbuilder.core.managedBuildNature">
           </projectNature>
        </projectConfigurationFactory>
     </extension>  
   
 
   

Lines 6-12 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
6	Bundle-Activator: org.eclipse.cdt.managedbuilder.ui.properties.ManagedBuilderUIPlugin	6	Bundle-Activator: org.eclipse.cdt.managedbuilder.ui.properties.ManagedBuilderUIPlugin
7	Bundle-Vendor: %providerName	7	Bundle-Vendor: %providerName
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Export-Package: org.eclipse.cdt.managedbuilder.ui.actions,	9	Export-Package: org.eclipse.cdt.managedbuilder.internal.ui.workingsets,
		10	org.eclipse.cdt.managedbuilder.ui.actions,
10	org.eclipse.cdt.managedbuilder.ui.properties,	11	org.eclipse.cdt.managedbuilder.ui.properties,
11	org.eclipse.cdt.managedbuilder.ui.wizards	12	org.eclipse.cdt.managedbuilder.ui.wizards
12	Require-Bundle: org.eclipse.ui.ide;bundle-version="[3.2.0,4.0.0)",	13	Require-Bundle: org.eclipse.ui.ide;bundle-version="[3.2.0,4.0.0)",




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.managedbuilder.internal.ui.workingsets;

import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;
import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetConfiguration;
import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfiguration;
import org.eclipse.cdt.internal.ui.workingsets.WorkingSetProjectConfiguration;
import org.eclipse.cdt.internal.ui.workingsets.WorkspaceSnapshot;
import org.eclipse.cdt.managedbuilder.core.IConfiguration;
import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.osgi.util.NLS;

/**
 * A managed-build implementation of the working set project configuration. It
 * knows how to build the selected configuration without activating it.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 */
class MBSProjectConfiguration extends WorkingSetProjectConfiguration {

	/**
	 * Initializes me.
	 * 
	 * @param parent
	 *            my parent working set configuration
	 */
	public MBSProjectConfiguration(IWorkingSetConfiguration parent) {
		super(parent);
	}

	@Override
	public IStatus build(IProgressMonitor monitor) {
		return MBSProjectConfiguration.build(this, monitor);
	}

	/**
	 * Builds the MBS configuration selected by the specified working set
	 * project configuration.
	 * 
	 * @param projectConfig
	 *            a project configuration to build
	 * @param monitor
	 *            for reporting build progress
	 * 
	 * @return the result of the MBS build
	 */
	static IStatus build(IWorkingSetProjectConfiguration projectConfig,
			IProgressMonitor monitor) {
		
		IStatus result = Status.OK_STATUS;

		ICConfigurationDescription config = projectConfig
				.resolveSelectedConfiguration();
		IConfiguration mbsConfig = (config == null) ? null
				: ManagedBuildManager.getConfigurationForDescription(config);

		if (mbsConfig == null) {
			result = new Status(IStatus.WARNING, CUIPlugin.PLUGIN_ID, NLS.bind(
					"No configuration selected for project \"{0}\".",
					projectConfig.getProjectName()));
		} else {
			monitor = SubMonitor.convert(monitor);

			try {
				ManagedBuildManager.buildConfigurations(
						new IConfiguration[] { mbsConfig }, monitor);
			} catch (CoreException e) {
				result = e.getStatus();
			}
		}

		return result;
	}

	@Override
	public ISnapshot createSnapshot(
			IWorkingSetConfiguration.ISnapshot workingSetConfig,
			WorkspaceSnapshot workspace) {

		return new Snapshot(workingSetConfig, this, workspace);
	}

	//
	// Nested classes
	//

	/**
	 * A mutable working-copy snapshot for MBS projects.
	 */
	static class Snapshot extends WorkingSetProjectConfiguration.Snapshot {
		protected Snapshot(IWorkingSetConfiguration parent,
				IWorkingSetProjectConfiguration projectConfig,
				WorkspaceSnapshot workspace) {

			super(parent, projectConfig, workspace);
		}

		@Override
		public IStatus build(IProgressMonitor monitor) {
			return MBSProjectConfiguration.build(this, monitor);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.managedbuilder.internal.ui.workingsets;

import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetConfiguration;
import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfigurationFactory;
import org.eclipse.cdt.internal.ui.workingsets.WorkingSetProjectConfiguration;

/**
 * Working set project configuration factory for MBS projects.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public class MBSProjectConfigurationFactory extends
		IWorkingSetProjectConfigurationFactory.Registry.Default {

	/**
	 * Initializes me.
	 */
	public MBSProjectConfigurationFactory() {
		super();
	}

	@Override
	protected WorkingSetProjectConfiguration createProjectConfiguration(
			IWorkingSetConfiguration parent) {

		return new MBSProjectConfiguration(parent);
	}

}

Lines 1-5 Link Here

(-)plugin.properties (-2 / +5 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2003, 2008 IBM Corporation and others.	2	# Copyright (c) 2003, 2009 IBM Corporation, QNX Software Systems, 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 10-15 Link Here
10	# Markus Schorn (Wind River Systems)	10	# Markus Schorn (Wind River Systems)
11	# Anton Leherbauer (Wind River Systems)	11	# Anton Leherbauer (Wind River Systems)
12	# Sergey Prigogin (Google)	12	# Sergey Prigogin (Google)
		13	# QNX Software Systems - [272416] Rework the working set configurations
13	###############################################################################	14	###############################################################################
14	pluginName=C/C++ Development Tools UI	15	pluginName=C/C++ Development Tools UI
15	providerName=Eclipse.org	16	providerName=Eclipse.org
Lines 508-514 Link Here
508	cElementHyperlinkDetector= C/C++ Elements	509	cElementHyperlinkDetector= C/C++ Elements
509		510
510	keybinding.MSVS= Microsoft Visual Studio	511	keybinding.MSVS= Microsoft Visual Studio
511	wsselection= Configs for Working set	512	wsselection= Manage Working Sets...
		513	buildWorkingSetConfig.label=Build Working Set
		514	workingSetConfigurationsExtensionPoint=Working Set Configurations
512		515
513	# Keywords for Preferences	516	# Keywords for Preferences
514	preferenceKeywords.common=c cpp cplusplus cdt	517	preferenceKeywords.common=c cpp cplusplus cdt




   <extension-point id="quickFixProcessors" name="%quickFixProcessorExtensionPoint" schema="schema/quickFixProcessors.exsd"/>
   <extension-point id="quickAssistProcessors" name="%quickAssistProcessorExtensionPoint" schema="schema/quickAssistProcessors.exsd"/>
   <extension-point id="DocCommentOwner" name="%DocCommentOwner.name" schema="schema/DocCommentOwner.exsd"/>
   <extension-point id="workingSetConfigurations" name="%workingSetConfigurationsExtensionPoint" schema="schema/workingSetConfigurations.exsd"/>

   <extension
         point="org.eclipse.core.runtime.adapters">

            contentMergeViewerId="org.eclipse.cdt.ui.compare.AsmContentViewerCreator"/>
   </extension>
   <extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="menu:project?after=build">
         <menu
               id="org.eclipse.cdt.ui.prjmenu"
               label="%Configurations.menu">
            <separator
                  name="gm1" visible="false">
            </separator>
            <separator
                  name="s2" visible="true">
            </separator>
            <separator
                  name="gm2" visible="false">
            </separator>
            <separator
                  name="s3" visible="true">
            </separator>
            <separator
                  name="gm3" visible="false">
            </separator>
            <separator
                  name="gm4" visible="false">
            </separator>
         </menu>
      </menuContribution>
      <menuContribution
            locationURI="menu:org.eclipse.cdt.ui.prjmenu?before=gm4">
         <dynamic
               class="org.eclipse.cdt.ui.actions.BuildWorkingSetConfigsContribution"
               id="org.eclipse.cdt.ui.buildWorkingSetConfigs">
            <visibleWhen>
               <with
                     variable="activeContexts">
                  <iterate
                        ifEmpty="false"
                        operator="or">
                     <equals
                           value="org.eclipse.cdt.ui.buildConfigActionSet">
                     </equals>
                  </iterate>
               </with>
            </visibleWhen>
         </dynamic>
      </menuContribution>
   </extension>
   <extension
         point="org.eclipse.ui.actionSets">
      <actionSet
            label="%CodingActionSet.label"

           id="org.eclipse.cdt.ui.buildConfigActionSet"
           label="%BuildConfigActionSet.label"
           visible="false">
        <menu
              id="org.eclipse.cdt.ui.prjmenu"
              label="%Configurations.menu"
              path="project/build">
           <groupMarker
                 name="gm1">
           </groupMarker>
           <separator
                 name="s2">
           </separator>
           <groupMarker
                 name="gm2">
           </groupMarker>
           <separator
                 name="s3">
           </separator>
           <groupMarker
                 name="gm3">
           </groupMarker>
        </menu>
        <action
              class="org.eclipse.cdt.ui.actions.ChangeBuildConfigMenuAction"
              disabledIcon="icons/dlcl16/config-tool.gif"

              class="org.eclipse.cdt.ui.actions.WorkingSetConfigAction"
              id="org.eclipse.cdt.ui.wsselection"
              label="%wsselection"
              menubarPath="project/org.eclipse.cdt.ui.prjmenu/gm4"
              style="push"
              />
     </actionSet>

         </selection>
      </wizard>
   </extension>
   <extension
         point="org.eclipse.cdt.ui.workingSetConfigurations">
      <projectConfigurationFactory
            class="org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfigurationFactory$Registry$Default"
            id="org.eclipse.cdt.ui.defaultWorkingSetProjectConfigFactory">
         <projectNature
               id="org.eclipse.cdt.core.cnature">
         </projectNature>
         <projectNature
               id="org.eclipse.cdt.core.ccnature">
         </projectNature>
      </projectConfigurationFactory>
   </extension>

</plugin>




###############################################################################
# Copyright (c) 2000, 2009 IBM Corporation, QNX Software Systems, 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

# Contributors:
#     IBM Corporation - initial API and implementation
#     Anton Leherbauer (Wind River Systems)
#     QNX Software Systems - [272416] Rework the working set configurations
###############################################################################

CElementWorkingSetPage_title= C/C++ Working Set

CElementWorkingSetPage_warning_nameMustNotBeEmpty= The name must not be empty.
CElementWorkingSetPage_warning_workingSetExists= A working set with that name already exists.
CElementWorkingSetPage_warning_resourceMustBeChecked= At least one resource must be checked.

WSConfig_build_problems=Problems occurred in building the working set.
WSConfig_build_task=Building working set "{0}"

WSConfigDialog_activate_label=Set Active
WSConfigDialog_active_config={0} (active)
WSConfigDialog_add_label=Add...
WSConfigDialog_buildPrompt_message=Some projects have had their active configurations changed, and need to be re-built.  Build them now?
WSConfigDialog_buildPrompt_title=Build New Configuration
WSConfigDialog_implicit_config=(active)
WSConfigDialog_projTree_accessible_name=Project configuration selection tree
WSConfigDialog_projTree_label=Project configurations:
WSConfigDialog_remove_label=Remove
WSConfigDialog_rename_label=Rename...
WSConfigDialog_title=Manage Working Set Configurations
WSConfigDialog_wsTree_accessible_name=Working sets and configurations tree
WSConfigDialog_wsTree_label=Working set configurations:

WSConfigManager_closeFailed=Failed to close working set configurations file.
WSConfigManager_loadFailed=Failed to load working set configurations.
WSConfigManager_save_job=Saving working set configurations
WSConfigManager_saveFailed=Failed to save working set configurations.

WSConfigsController_addDlg_defaultName=NewConfiguration
WSConfigsController_addDlg_emptyName=The name must not be empty.
WSConfigsController_addDlg_msg=Enter a name for the new configuration.
WSConfigsController_addDlg_nameExists=A configuration with that name already exists.
WSConfigsController_addDlg_title=Add Working Set Configuration
WSConfigsController_renameDlg_msg=Enter a new name for the configuration.
WSConfigsController_renameDlg_title=Rename Working Set Configuration

WSProjConfig_activatedWarning=Set configuration "{0}" active in project "{1}".
WSProjConfig_buildProblem=Problems occurred in building project "{0}".
WSProjConfig_noConfig=No configuration selected for project "{0}".

WSProjConfigFactory_badFactory=Invalid project configuration factory in plug-in {0}.  Expected an IWorkingSetProjectConfigurationFactory.
WSProjConfigFactory_factoryFailed=Failed to create project configuration factory.
WSProjConfigFactory_noFactoryID=Missing ID in project configuration factory extension in plug-in {0}
WSProjConfigFactory_noNatureID=Missing nature ID in project configuration factory in plug-in {0}.




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation, QNX Software Systems, 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

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     QNX Software Systems - [272416] Rework the working set configurations
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.workingsets;


	public static String CElementWorkingSetPage_warning_workingSetExists;
	public static String CElementWorkingSetPage_warning_resourceMustBeChecked;

	public static String WSConfig_build_problems;
	public static String WSConfig_build_task;
	
	public static String WSConfigDialog_activate_label;
	public static String WSConfigDialog_active_config;
	public static String WSConfigDialog_add_label;
	public static String WSConfigDialog_buildPrompt_message;
	public static String WSConfigDialog_buildPrompt_title;
	public static String WSConfigDialog_implicit_config;
	public static String WSConfigDialog_projTree_accessible_name;
	public static String WSConfigDialog_projTree_label;
	public static String WSConfigDialog_remove_label;
	public static String WSConfigDialog_rename_label;
	public static String WSConfigDialog_title;
	public static String WSConfigDialog_wsTree_accessible_name;
	public static String WSConfigDialog_wsTree_label;

	public static String WSConfigManager_closeFailed;
	public static String WSConfigManager_loadFailed;
	public static String WSConfigManager_save_job;
	public static String WSConfigManager_saveFailed;
	
	public static String WSConfigsController_addDlg_defaultName;
	public static String WSConfigsController_addDlg_emptyName;
	public static String WSConfigsController_addDlg_msg;
	public static String WSConfigsController_addDlg_nameExists;
	public static String WSConfigsController_addDlg_title;
	public static String WSConfigsController_renameDlg_msg;
	public static String WSConfigsController_renameDlg_title;
	
	public static String WSProjConfig_activatedWarning;
	public static String WSProjConfig_buildProblem;
	public static String WSProjConfig_noConfig;
	
	public static String WSProjConfigFactory_badFactory;
	public static String WSProjConfigFactory_factoryFailed;
	public static String WSProjConfigFactory_noFactoryID;
	public static String WSProjConfigFactory_noNatureID;

	static {
		NLS.initializeMessages(BUNDLE_NAME, WorkingSetMessages.class);
	}

Lines 7-12 Link Here

(-)src/org/eclipse/cdt/ui/newui/CDTPrefUtil.java (+12 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Intel Corporation - initial API and implementation	9	* Intel Corporation - initial API and implementation
		10	* QNX Software Systems - [272416] Rework the working set configurations
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.ui.newui;	12	package org.eclipse.cdt.ui.newui;
12		13
Lines 22-27 Link Here
22		23
23	import org.eclipse.cdt.ui.CUIPlugin;	24	import org.eclipse.cdt.ui.CUIPlugin;
24		25
		26	import org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager;
		27
25	/**	28	/**
26	* @noextend This class is not intended to be subclassed by clients.	29	* @noextend This class is not intended to be subclassed by clients.
27	* @noinstantiate This class is not intended to be instantiated by clients.	30	* @noinstantiate This class is not intended to be instantiated by clients.
Lines 226-234 Link Here
226	return s1;	229	return s1;
227	}	230	}
228		231
		232	/**
		233	* @deprecated Use the {@link WorkingSetConfigurationManager} class, instead.
		234	*/
		235	@Deprecated
229	public static List<String> readConfigSets() {	236	public static List<String> readConfigSets() {
230	return new LinkedList<String>(Arrays.asList(getStr(KEY_CONFSET).split(CONFSETDEL)));	237	return new LinkedList<String>(Arrays.asList(getStr(KEY_CONFSET).split(CONFSETDEL)));
231	}	238	}
		239
		240	/**
		241	* @deprecated Use the {@link WorkingSetConfigurationManager} class, instead.
		242	*/
		243	@Deprecated
232	public static void saveConfigSets(List<String> out) {	244	public static void saveConfigSets(List<String> out) {
233	StringBuilder b = new StringBuilder();	245	StringBuilder b = new StringBuilder();
234	for (String s : out) {	246	for (String s : out) {




###############################################################################
# Copyright (c) 2000, 2009 IBM Corporation, QNX Software Systems, 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

#
# Contributors:
# IBM - Initial API and implementation
# QNX Software Systems - [272416] Rework the working set configurations
###############################################################################

# ----------- Configuration Selection Page -----------

CDTMainWizardPage.1=Project category is selected. Expand the category and select a concrete project type.
CProjectWizard.0=Add C Project Nature
CCProjectWizard.0=Add CC Project Nature
WorkingSetConfigAction.0=Symbols '
WorkingSetConfigAction.1=Choose active configs for Working Sets
WorkingSetConfigAction.10=-- CURRENT --
WorkingSetConfigAction.11=Config Set Name:
WorkingSetConfigAction.12=Configuration set already exists: 
WorkingSetConfigAction.13=Wrong configuration set data : 
WorkingSetConfigAction.14=' should not be in the name
WorkingSetConfigAction.15=Config Set '
WorkingSetConfigAction.16=' already exists \!
WorkingSetConfigAction.17=Configurations list
WorkingSetConfigAction.18=New...
WorkingSetConfigAction.19=Rename...
WorkingSetConfigAction.2=Working Sets
WorkingSetConfigAction.20=Save, Build and Exit
WorkingSetConfigAction.21=Building project 
WorkingSetConfigAction.22=Build error
WorkingSetConfigAction.3=- NO WORKING SETS -
WorkingSetConfigAction.4=Config Sets
WorkingSetConfigAction.5=Projects and configurations
WorkingSetConfigAction.6=Update config set
WorkingSetConfigAction.7=Create config set
WorkingSetConfigAction.8=Rename config set
WorkingSetConfigAction.9=Delete config set




/*******************************************************************************
 * Copyright (c) 2008, 2009 Intel Corporation, QNX Software Systems, 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

 *
 * Contributors:
 *     Intel Corporation - initial API and implementation
 *     QNX Software Systems - [272416] Rework the config sets dialog 
 *******************************************************************************/
/**
 * 
 */
package org.eclipse.cdt.ui.actions;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.TrayDialog;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.AccessibleAdapter;
import org.eclipse.swt.accessibility.AccessibleEvent;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.TreeEvent;
import org.eclipse.swt.events.TreeListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.List;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.PlatformUI;

import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;
import org.eclipse.cdt.core.settings.model.ICProjectDescription;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.newui.CDTHelpContextIds;
import org.eclipse.cdt.ui.newui.CDTPrefUtil;
import org.eclipse.cdt.ui.newui.UIMessages;

import org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationDialog;

/**
 */
public class WorkingSetConfigAction implements IWorkbenchWindowActionDelegate, IPropertyChangeListener {
	private static final String DELIMITER = " "; //$NON-NLS-1$
	private static final String EMPTY_STR = ""; //$NON-NLS-1$
	private static final String CURRENT = UIMessages.getString("WorkingSetConfigAction.10"); //$NON-NLS-1$
	public static final Image IMG_PROJ = CPluginImages.get(CPluginImages.IMG_OBJS_CFOLDER);
	public static final Image IMG_CONF = CPluginImages.get(CPluginImages.IMG_OBJS_CONFIG);
	private static final Shell sh = CUIPlugin.getDefault().getShell();
	private static final IWorkingSetManager wsm = CUIPlugin.getDefault().getWorkbench().getWorkingSetManager();  
	private LinkedHashMap<String, IWorkingSet> workingSetsMap;
	private LinkedHashMap<String, ConfigSet> configSetMap;
	private boolean enabled = true;
	
	private IWorkbenchWindow window;
	
	public void run(IAction action) {
		new WorkingSetConfigurationDialog(window.getShell()).open();
		dlg.open();
	}
	
	public void selectionChanged(IAction action, ISelection selection) {

		
	}
	public void init(IWorkbenchWindow window) {
		this.window = window;
		wsm.addPropertyChangeListener(this);
		checkWS();
	}

		enabled = w.length > 0;
		return w;
	}
	
	private String[] getWSnames() {
		IWorkingSet[] w = checkWS();
		workingSetsMap = new LinkedHashMap<String, IWorkingSet>(w.length); 
		for (IWorkingSet ws : w)
			workingSetsMap.put(ws.getLabel(), ws);
		return workingSetsMap.keySet().toArray(new String[w.length]);
	}

	public void propertyChange(PropertyChangeEvent event) {
		checkWS();
	}
	
	private class LocalDialog extends TrayDialog {
		private List wsets;
		private List csets;
		private Tree tree;
		private Button b1, b2, b3, b4, bb;
		
		LocalDialog(Shell parentShell) {
			super(parentShell);
			setHelpAvailable(false);
			setShellStyle(getShellStyle()|SWT.RESIZE);
		}
		@Override
		protected void buttonPressed(int buttonId) {
			if (buttonId == IDialogConstants.OK_ID) {
				saveConfigSets();
				saveActiveConfigs();
			} else {}
			super.buttonPressed(buttonId);
		}

		private void saveConfigSets() {
			ArrayList<String> out = new ArrayList<String>(configSetMap.size());
			for (ConfigSet cs : configSetMap.values()) 
				if (cs.isValid() && !cs.name.equals(CURRENT))
					out.add(cs.toString());
			CDTPrefUtil.saveConfigSets(out);
		}
		
		private void saveActiveConfigs() {
			for (TreeItem ti : tree.getItems()) {
				ICProjectDescription pd = (ICProjectDescription)ti.getData();
				for (TreeItem ti1: ti.getItems()) {
					if (!ti1.getChecked())
						continue;
					((ICConfigurationDescription)ti1.getData()).setActive();
					break;
				}
				try {
					CoreModel.getDefault().setProjectDescription(pd.getProject(), pd);
				} catch (CoreException e) {
					e.printStackTrace();
					CUIPlugin.log(e);
				}
			}
		}
		
		@Override
		protected void configureShell(Shell shell) {
			super.configureShell(shell);
			shell.setText(UIMessages.getString("WorkingSetConfigAction.1")); //$NON-NLS-1$
		}
		 
		@Override
		protected Control createDialogArea(Composite parent) {
			PlatformUI.getWorkbench().getHelpSystem().setHelp( getShell(), CDTHelpContextIds.MAN_PROJ_BUILD_PROP);

			Composite comp = new Composite(parent, SWT.NULL);
			comp.setFont(parent.getFont());
			comp.setLayout(new GridLayout(2, false));
			comp.setLayoutData(new GridData(GridData.FILL_BOTH));

			// Create the sash form
			SashForm sashForm = new SashForm(comp, SWT.NONE);
			sashForm.setOrientation(SWT.VERTICAL);
			GridData gd = new GridData(GridData.FILL_VERTICAL);
			gd.verticalSpan = 3;
			sashForm.setLayoutData(gd);

			Composite ws = new Composite(sashForm, SWT.NULL);
			ws.setLayoutData(new GridData(GridData.FILL_BOTH));
			ws.setLayout(new GridLayout(1, false));
			Label l1 = new Label(ws, SWT.NONE);
			l1.setText(UIMessages.getString("WorkingSetConfigAction.2")); //$NON-NLS-1$
			l1.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
			wsets = new List(ws, SWT.SINGLE | SWT.BORDER);
			wsets.setLayoutData(new GridData(GridData.FILL_BOTH));
			wsets.setItems(getWSnames());

			wsets.addSelectionListener(new SelectionListener() {
				public void widgetDefaultSelected(SelectionEvent e) {
					workingSetChanged();
				}
				public void widgetSelected(SelectionEvent e) {
					workingSetChanged();
				}});

			if (wsets.getItemCount() == 0) {
				wsets.add(UIMessages.getString("WorkingSetConfigAction.3")); //$NON-NLS-1$
				wsets.setEnabled(false);
			} else {
				IWorkingSet[] w = wsm.getRecentWorkingSets();
				if (w == null || w.length == 0)
					wsets.setSelection(0);
				else {
					String s = w[0].getLabel();
					String[] ss = wsets.getItems();
					for (int i=0; i<ss.length; i++) {
						if (ss[i].equals(s)) {
							wsets.setSelection(i);
							break;
						}
					}
				}
			}

			Composite cs = new Composite(sashForm, SWT.NULL);
			cs.setLayoutData(new GridData(GridData.FILL_BOTH));
			cs.setLayout(new GridLayout(1, false));
			l1 = new Label(cs, SWT.NONE);
			l1.setText(UIMessages.getString("WorkingSetConfigAction.4")); //$NON-NLS-1$
			l1.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
			csets = new List(cs, SWT.SINGLE | SWT.BORDER);
			csets.setLayoutData(new GridData(GridData.FILL_BOTH));
			csets.addSelectionListener(new SelectionListener() {
				public void widgetDefaultSelected(SelectionEvent e) {
					configSetChanged();
				}
				public void widgetSelected(SelectionEvent e) {
					configSetChanged();
				}});

			sashForm.setWeights(new int[]{50, 50});

			
			l1 = new Label(comp, SWT.NONE);
			l1.setText(UIMessages.getString("WorkingSetConfigAction.5")); //$NON-NLS-1$
			gd = new GridData(GridData.FILL_HORIZONTAL);
			gd.verticalIndent = 5;
			l1.setLayoutData(gd);
			
			tree = new Tree(comp, SWT.SINGLE | SWT.CHECK | SWT.BORDER);
			gd = new GridData(GridData.FILL_BOTH);
			gd.heightHint = 200;
			gd.widthHint  = 200;
			tree.setLayoutData(gd);
			tree.getAccessible().addAccessibleListener(
				new AccessibleAdapter() {                       
					@Override
					public void getName(AccessibleEvent e) {
						e.result = UIMessages.getString("WorkingSetConfigAction.17"); //$NON-NLS-1$
					}
				}
			);
			tree.addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					if (((e.detail & SWT.CHECK) == SWT.CHECK) && 
						 (e.item != null && (e.item instanceof TreeItem))) {
						TreeItem sel = (TreeItem)e.item;
						if (sel.getData() instanceof ICProjectDescription) {
							sel.setChecked(false); // do not check projects !
						} else {
							// If current item is checked, uncheck remaining ones.
							// If current item is unchecked, check the 1st instead.
							String txt = sel.getChecked() ? sel.getText() : EMPTY_STR;  
							for (TreeItem obj : sel.getParentItem().getItems()) {
								if (txt == null)
									obj.setChecked(false);
								else if (txt == EMPTY_STR || txt.equals(obj.getText())) {
									obj.setChecked(true);
									txt = null; // do not perform further checks.
								} else  
									obj.setChecked(false); 
							}
						}
					}
				}
			});

			tree.addTreeListener(new TreeListener() {
				public void treeCollapsed(TreeEvent e) {
				}
				public void treeExpanded(TreeEvent e) {
				}});
			
			// Buttons pane
			Composite c = new Composite(comp, SWT.NONE);
			c.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
			c.setLayout(new GridLayout(2, true));

			b2 = new Button(c, SWT.PUSH);
			b2.setText(UIMessages.getString("WorkingSetConfigAction.7")); //$NON-NLS-1$
			b2.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
			b2.addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					String newS = getString(UIMessages.getString("WorkingSetConfigAction.18"), null); //$NON-NLS-1$ 
				    if (newS == null)
				    	return;
				    String key = wsets.getSelection()[0] + DELIMITER + newS;
					if (configSetMap.containsKey(key))
						// error message
						return;
					ConfigSet cs = new ConfigSet(newS, wsets.getSelection()[0], tree);
					configSetMap.put(key, cs);
					csets.add(newS);
					csets.setSelection(csets.getItemCount() - 1);
					updateButtons();
				}});

			b1 = new Button(c, SWT.PUSH);
			b1.setText(UIMessages.getString("WorkingSetConfigAction.6")); //$NON-NLS-1$
			b1.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
			b1.addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					String oldS = csets.getItem(csets.getSelectionIndex());
					ConfigSet cs = new ConfigSet(oldS, wsets.getSelection()[0], tree);
					configSetMap.put(wsets.getSelection()[0] + DELIMITER + oldS, cs); // overwrite
				}});

			b3 = new Button(c, SWT.PUSH);
			b3.setText(UIMessages.getString("WorkingSetConfigAction.8")); //$NON-NLS-1$
			b3.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
			b3.addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					int n = csets.getSelectionIndex();
					if (n > 0) {
						String oldS = csets.getItem(n);
						String newS = getString(UIMessages.getString("WorkingSetConfigAction.19"), oldS);  //$NON-NLS-1$
					    if (newS == null)
					    	return;
						if (oldS.equals(newS)) // nothing to do
							return;
						String key = wsets.getSelection()[0] + DELIMITER + newS;
						if (configSetMap.containsKey(key)) {
							ExistsMessage(newS);
							return;
						}
						ConfigSet cs = configSetMap.get(wsets.getSelection()[0] + DELIMITER + oldS);
						configSetMap.remove(cs);
						cs.name = newS;
						configSetMap.put(key, cs);
						csets.setItem(n, newS);
					}
				}});

			b4 = new Button(c, SWT.PUSH);
			b4.setText(UIMessages.getString("WorkingSetConfigAction.9")); //$NON-NLS-1$
			b4.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
			b4.addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					String[] ss = csets.getSelection();
					if (ss != null && ss.length > 0) {
						configSetMap.remove(wsets.getSelection()[0] + DELIMITER + ss[0]);
						csets.remove(ss[0]);
						csets.setSelection(0);
						updateButtons();
					}
				}});

	        bb = new Button(c, SWT.PUSH);
	        bb.setText(UIMessages.getString("WorkingSetConfigAction.20")); //$NON-NLS-1$
	        gd = new GridData(GridData.FILL_HORIZONTAL);
	        gd.horizontalSpan = 2;
        	bb.setLayoutData(gd);
			bb.addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					build();
					LocalDialog.this.close();
				}});
			
			initData();
			return comp;
		}

		private void initData() {
			configSetMap = new LinkedHashMap<String, ConfigSet>();
			for (String s : CDTPrefUtil.readConfigSets()) {
				ConfigSet cs = new ConfigSet(s);
				if (cs.isValid())
					configSetMap.put(cs.workingSetLabel + DELIMITER + cs.name, cs);
			}
			workingSetChanged();
		}
		
		private void updateButtons() {
			Button ok =	this.getButton(IDialogConstants.OK_ID);
			boolean en = csets.getSelectionIndex() > 0;
			if (! wsets.getEnabled()) {
				b2.setEnabled(false); // new
				if (ok != null)
					ok.setEnabled(false); // OK
				en = false;
			}
			b1.setEnabled(en); // update
			b3.setEnabled(en); // rename
			b4.setEnabled(en); // delete
			bb.setEnabled(wsets.getEnabled());
		}
		private void workingSetChanged() {
//			tree.setRedraw(false);
			tree.removeAll();
			String[] ss = wsets.getSelection();
			if (ss == null || ss.length == 0)
				return;
			IWorkingSet ws = workingSetsMap.get(ss[0]);
			fillTree(ws);
			tree.setRedraw(true);
//			csets.setRedraw(false);
			csets.removeAll();
			csets.add(CURRENT);
			csets.setSelection(0);
			
			configSetMap.remove(CURRENT); // previous default object, if any
			for (Map.Entry<String, ConfigSet> me : configSetMap.entrySet()) {
				if (me.getValue().workingSetLabel.equals(ws.getLabel()))
					csets.add(me.getValue().name);
			}
			configSetMap.put(CURRENT, new ConfigSet(CURRENT, ws.getLabel(), tree));
			csets.setRedraw(true);
			updateButtons();
			
			// calls from FillTree does not work...
			for (TreeItem ti : tree.getItems())
				ti.setExpanded(true);
		}
		
		/**
		 * Update projects tree for selected working set.
		 * @param ws - working set selected.
		 */
		private void fillTree(IWorkingSet ws) {
			if (ws == null) 
				return;
			for (IAdaptable ad : ws.getElements()) {
				IProject p = (IProject)ad.getAdapter(IProject.class);
				if (p == null) 
					continue;
				ICProjectDescription prjd = CoreModel.getDefault().getProjectDescription(p, true);
				if (prjd == null)
					continue;
				ICConfigurationDescription[] cfgs = prjd.getConfigurations();
				if (cfgs == null || cfgs.length == 0)
					continue;
				TreeItem ti = new TreeItem(tree, SWT.NONE);
				ti.setText(prjd.getName());
				ti.setImage(IMG_PROJ);
				ti.setData(prjd);
				for (ICConfigurationDescription c : cfgs) {
					TreeItem ti1 = new TreeItem(ti, SWT.NONE);
					ti1.setText(c.getName());
					ti1.setImage(IMG_CONF);
					ti1.setChecked(c.isActive());
					ti1.setData(c);
				}
			}
		}
		
		private void configSetChanged() {
			int i = csets.getSelectionIndex();
			if (i >= 0) {
				String key = (i == 0) ? CURRENT : wsets.getSelection()[0] + DELIMITER + csets.getItem(i);
				ConfigSet cs = configSetMap.get(key);
				if (cs != null && cs.isValid()) {
					for (TreeItem ti : tree.getItems()) {
						ICProjectDescription prjd = (ICProjectDescription)ti.getData();
						String cid = cs.data.get(prjd.getName());
						if (cid == null)
							continue; // the project not in the list
						for (TreeItem ti1 : ti.getItems()) {
							ICConfigurationDescription cfg = (ICConfigurationDescription)ti1.getData();
							ti1.setChecked(cid.equals(cfg.getId()));
						}
					}
				}
			}
			updateButtons();
		}

		private String getString(String title, String value) { 
			InputDialog d = new InputDialog(sh, title, 
					UIMessages.getString("WorkingSetConfigAction.11"), //$NON-NLS-1$ 
					value, new IInputValidator() {
						public String isValid(String newText) {
							if (newText.indexOf(CDTPrefUtil.CONFSETDEL) >= 0)
								return UIMessages.getString("WorkingSetConfigAction.0") + CDTPrefUtil.CONFSETDEL + UIMessages.getString("WorkingSetConfigAction.14"); //$NON-NLS-1$ //$NON-NLS-2$
							if (configSetMap.containsKey(wsets.getSelection()[0] + DELIMITER + newText))
								return UIMessages.getString("WorkingSetConfigAction.15") + newText + UIMessages.getString("WorkingSetConfigAction.16"); //$NON-NLS-1$ //$NON-NLS-2$
							return null;
						}}); 
			if (d.open() == Window.OK) 
				return d.getValue().replace(' ', '_'); // space is delimiter.
			return null;
		}
		
		private void ExistsMessage(String s) {
			MessageBox box = new MessageBox(sh, SWT.ICON_ERROR);
			box.setMessage(UIMessages.getString("WorkingSetConfigAction.12") + s); //$NON-NLS-1$
			box.open();
		}
		
		private void build() {
			saveConfigSets();
			saveActiveConfigs();
			IProject[] ps = new IProject[tree.getItemCount()];
			int cnt = 0;
			for (TreeItem ti : tree.getItems()) 
				ps[cnt++] = ((ICProjectDescription)ti.getData()).getProject();
			Job buildJob = new BuildJob(ps);
			buildJob.schedule();
		}
	}

	private static final class BuildJob extends Job {
		IProject[] ps;
		
		BuildJob(IProject[] _ps) {
			super(UIMessages.getString("WorkingSetConfigAction.21")); //$NON-NLS-1$
			ps = _ps;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
		 */
		@Override
		protected IStatus run(IProgressMonitor monitor) {
			for (IProject p:ps) 
				try {
					setName(UIMessages.getString("WorkingSetConfigAction.21") + p.getName()); //$NON-NLS-1$
					p.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
			} catch (CoreException e) {
				return new Status(IStatus.ERROR, UIMessages.getString("WorkingSetConfigAction.22"), e.getLocalizedMessage()); //$NON-NLS-1$
			}
			if (monitor.isCanceled()) {
				return Status.CANCEL_STATUS;
			}
			monitor.done();
			return Status.OK_STATUS;
		}

		@Override
		public boolean belongsTo(Object family) {
			return ResourcesPlugin.FAMILY_MANUAL_BUILD == family;
		}

	}
	
	private static class ConfigSet {
		String name;
		String workingSetLabel;
		LinkedHashMap<String, String> data;
		
		private ConfigSet(String s) {
			data = new LinkedHashMap<String, String>();
			String[] ss = s.split(DELIMITER);
			if (ss == null || ss.length < 4 || ss.length %2 == 1) {
				CUIPlugin.getDefault().logErrorMessage(UIMessages.getString("WorkingSetConfigAction.13") + s); //$NON-NLS-1$
				return; // not valid
			}
			name = ss[0];
			workingSetLabel = ss[1];
			int n = (ss.length - 2) / 2;
			for (int i=0; i<n; i++) 
				data.put(ss[2 + i * 2], ss[3 + i * 2]);
		}
		
		private ConfigSet(String n, String w, Tree t) {
			data = new LinkedHashMap<String, String>();
			name = n;
			workingSetLabel = w;
			for (TreeItem ti : t.getItems()) {
				ICProjectDescription prjd = (ICProjectDescription)ti.getData();
				for (TreeItem ti1 : ti.getItems()) {
					if (ti1.getChecked()) {
						ICConfigurationDescription cfg = (ICConfigurationDescription)ti1.getData();
						data.put(prjd.getName(), cfg.getId());
						break;
					}
				}
			}

		}
		
		private boolean isValid() {
			return data.size() > 0;
		}
		
		@Override
		public String toString() {
			if (!isValid())
				return EMPTY_STR;
			StringBuilder b = new StringBuilder();
			b.append(name);
			b.append(DELIMITER);
			b.append(workingSetLabel);
			b.append(DELIMITER);
			for (Map.Entry<String, String> me : data.entrySet()) {
				b.append(me.getKey());
				b.append(DELIMITER);
				b.append(me.getValue());
				b.append(DELIMITER);
			}
			return b.toString().trim();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Map;

import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.graphics.Image;

/**
 * View controller for the project configurations pane of the working set configurations dialog. It takes care
 * of coordinating the user gestures in that pane with the working-set configuration model and vice-versa.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
class ProjectConfigsController implements ICheckStateListener, DisposeListener {
	private CheckboxTreeViewer tree;

	private IWorkingSetConfiguration.ISnapshot workingSet;
	private WorkingSetConfigsController workingSetController;

	private ControllerContext controllerContext;

	private ILabelProvider labelProvider = new DelegatingLabelProvider();
	private ITreeContentProvider contentProvider = new DelegatingContentProvider();

	/**
	 * Initializes me.
	 */
	ProjectConfigsController() {
		super();
	}

	/**
	 * Assigns the tree viewer that I control.
	 * 
	 * @param tree
	 *            my tree viewer
	 */
	void setTreeViewer(CheckboxTreeViewer tree) {
		if (this.tree != null) {
			this.tree.getTree().removeDisposeListener(this);
			this.tree.removeCheckStateListener(this);
			this.tree.setLabelProvider(null);
			this.tree.setContentProvider(null);
		}

		this.tree = tree;

		if (this.tree != null) {
			this.tree.setUseHashlookup(true);
			this.tree.setContentProvider(contentProvider);
			this.tree.setLabelProvider(labelProvider);
			this.tree.addCheckStateListener(this);
			this.tree.getTree().addDisposeListener(this);
		}
	}

	/**
	 * Injects the current selection of a working set from the Working Set Configurations pane. This changes
	 * the project configurations that I show in my own tree.
	 * 
	 * @param config
	 *            the new working set configuration selection. May be <code>null</code> if there is no
	 *            selection
	 */
	void setWorkingSetConfiguration(IWorkingSetConfiguration.ISnapshot config) {
		if ((tree != null) && (config != workingSet)) {
			this.workingSet = config;

			tree.setSelection(new StructuredSelection());
			
			if (config != null) {
				controllerContext = new ControllerContext();
				tree.setInput(config);
				tree.getTree().setEnabled(true);
				updateCheckState(config);
				tree.expandToLevel(2);
			} else {
				tree.getTree().setEnabled(false);
				tree.setInput(config);
				controllerContext.dispose();
				controllerContext = null;
			}
		}
	}

	/**
	 * Queries the current working set configuration that I show in my tree.
	 * 
	 * @return the working set configuration, or <code>null</code> if none
	 */
	IWorkingSetConfiguration.ISnapshot getWorkingSetConfiguration() {
		return workingSet;
	}

	public void checkStateChanged(CheckStateChangedEvent event) {
		Object element = event.getElement();
		IWorkingSetProjectConfigurationController controller = controllerContext
				.controllerForElement(element);

		if (controller != null) {
			controller.checkStateChanged(element, event.getChecked(), controllerContext);

		} else {
			// controller unknown? Cannot change the check-state
			tree.setChecked(element, !event.getChecked());
		}
	}

	public void widgetDisposed(DisposeEvent e) {
		dispose();
	}

	/**
	 * Computes the initial check-box settings for my tree according to the current state of the specified
	 * working set configuration.
	 * 
	 * @param config
	 *            a working set configuration that I am now showing
	 */
	private void updateCheckState(IWorkingSetConfiguration.ISnapshot config) {
		for (IWorkingSetProjectConfiguration project : config.getProjectConfigurations()) {
			IWorkingSetProjectConfigurationController controller = controllerContext
					.controllerForElement(project);

			if (controller != null) {
				controller.updateCheckState(controllerContext);
			}
		}
	}

	/**
	 * Connects me to the controller of the working set configurations pane.
	 * 
	 * @param controller
	 *            the working-set configs controller
	 */
	void setWorkingSetConfigurationsController(WorkingSetConfigsController controller) {
		workingSetController = controller;
	}

	void dispose() {
		if (controllerContext != null) {
			controllerContext.dispose();
			controllerContext = null;
		}
	}

	//
	// Nested classes
	//

	private class ControllerContext implements IWorkingSetProjectConfigurationController.IControllerContext {

		private Map<Object, IWorkingSetProjectConfigurationController> elementToControllerMap;

		private Map<IWorkingSetProjectConfigurationController, ITreeContentProvider> contentProviders;
		private Map<IWorkingSetProjectConfigurationController, ILabelProvider> labelProviders;

		ControllerContext() {
			elementToControllerMap = new java.util.IdentityHashMap<Object, IWorkingSetProjectConfigurationController>();
			contentProviders = new java.util.HashMap<IWorkingSetProjectConfigurationController, ITreeContentProvider>();
			labelProviders = new java.util.HashMap<IWorkingSetProjectConfigurationController, ILabelProvider>();

			for (IWorkingSetProjectConfiguration next : getWorkingSetConfiguration()
					.getProjectConfigurations()) {

				IWorkingSetProjectConfiguration.ISnapshot project = (IWorkingSetProjectConfiguration.ISnapshot) next;

				IWorkingSetProjectConfigurationController controller = IWorkingSetProjectConfigurationFactory.Registry.INSTANCE
						.getFactory(project.resolveProject()).createProjectConfigurationController(project);

				if (controller == null) {
					// can only supply the default behaviour, then
					controller = new ProjectConfigurationController(project);
				}

				elementToControllerMap.put(project, controller);
				contentProviders.put(controller, controller.getContentProvider());
				labelProviders.put(controller, controller.getLabelProvider());

				discoverElements(controller, project, contentProviders.get(controller));
			}
		}

		private void discoverElements(IWorkingSetProjectConfigurationController controller, Object element,
				ITreeContentProvider provider) {
			Object[] children = provider.getChildren(element);

			for (Object next : children) {
				elementToControllerMap.put(next, controller);
				discoverElements(controller, next, provider);
			}
		}

		IWorkingSetProjectConfigurationController controllerForElement(Object element) {
			return elementToControllerMap.get(element);
		}

		ITreeContentProvider contentProviderForElement(Object element) {
			return contentProviders.get(elementToControllerMap.get(element));
		}

		ILabelProvider labelProviderForElement(Object element) {
			return labelProviders.get(elementToControllerMap.get(element));
		}

		public void activationStateChanged(IWorkingSetProjectConfiguration projectConfiguration) {
			workingSetController.projectSelectionsChanged(projectConfiguration);
		}

		public boolean isReadOnly() {
			return getWorkingSetConfiguration().isReadOnly();
		}

		public void setChecked(Object element, boolean checked) {
			tree.setChecked(element, checked);
		}

		public void update(Object element) {
			if ((element instanceof IWorkingSetConfiguration) || (element instanceof IWorkingSetProxy)) {
				// TODO: Talk to the WS controller
			} else if (controllerForElement(element) != null) {
				// only need to update if we have actually accessed this
				// element, yet, in order to display it
				tree.update(element, null);
			}
		}

		public void dispose() {
			elementToControllerMap = null;

			if (contentProviders != null) {
				for (ITreeContentProvider next : contentProviders.values()) {
					next.dispose();
				}
				contentProviders = null;
			}

			if (labelProviders != null) {
				for (ILabelProvider next : labelProviders.values()) {
					next.dispose();
				}
				labelProviders = null;
			}
		}
	}

	private class DelegatingLabelProvider extends LabelProvider {
		@Override
		public String getText(Object element) {
			ILabelProvider delegate = delegateFor(element);

			return (delegate != null) ? delegate.getText(element) : super.getText(element);
		}

		@Override
		public Image getImage(Object element) {
			ILabelProvider delegate = delegateFor(element);

			return (delegate != null) ? delegate.getImage(element) : super.getImage(element);
		}

		private ILabelProvider delegateFor(Object element) {
			return (controllerContext == null) ? null : controllerContext.labelProviderForElement(element);
		}
	}

	private class DelegatingContentProvider implements ITreeContentProvider {
		private final Object[] NO_OBJECTS = new Object[0];

		public Object[] getChildren(Object parentElement) {
			ITreeContentProvider delegate = delegateFor(parentElement);

			return (delegate != null) ? delegate.getChildren(parentElement) : NO_OBJECTS;
		}

		public Object getParent(Object element) {
			ITreeContentProvider delegate = delegateFor(element);

			return (delegate != null) ? delegate.getParent(element) : null;
		}

		public boolean hasChildren(Object element) {
			ITreeContentProvider delegate = delegateFor(element);

			return (delegate != null) && delegate.hasChildren(element);
		}

		public Object[] getElements(Object inputElement) {
			return getWorkingSetConfiguration().getProjectConfigurations().toArray();
		}

		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			// nothing to do
		}

		public void dispose() {
			// nothing of my own to dispose
		}

		private ITreeContentProvider delegateFor(Object element) {
			return (controllerContext == null) ? null : controllerContext.contentProviderForElement(element);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import static org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager.ATTR_CONFIG;
import static org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager.ATTR_NAME;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.IMemento;

import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;
import org.eclipse.cdt.core.settings.model.ICProjectDescription;
import org.eclipse.cdt.ui.CUIPlugin;

/**
 * Default implementation of the {@link IWorkingSetProjectConfiguration} interface. Clients may extend this
 * class to implement additional project configuration settings.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public class WorkingSetProjectConfiguration implements IWorkingSetProjectConfiguration {
	private final IWorkingSetConfiguration workingSetConfig;
	private String projectName;
	private String selectedConfiguration;

	/**
	 * Initializes me with my parent working set configuration.
	 * 
	 * @param parent
	 *            my parent working set configuration
	 */
	protected WorkingSetProjectConfiguration(IWorkingSetConfiguration parent) {
		this.workingSetConfig = parent;
	}

	public IWorkingSetConfiguration getWorkingSetConfiguration() {
		return workingSetConfig;
	}

	public String getProjectName() {
		return projectName;
	}

	/**
	 * Sets my project name. Note that this <b>does not</b> change the name of the project that I represent.
	 * Rather, it changes <i>which</i> project I represent.
	 * 
	 * @param projectName
	 *            my new project name
	 */
	protected void setProjectName(String projectName) {
		this.projectName = projectName;
	}

	public IProject resolveProject() {
		IProject result = ResourcesPlugin.getWorkspace().getRoot().getProject(getProjectName());

		if ((result != null) && !result.isAccessible()) {
			result = null;
		}

		return result;
	}

	public String getSelectedConfigurationID() {
		return selectedConfiguration;
	}

	public void setSelectedConfigurationID(String id) {
		this.selectedConfiguration = id;
	}

	public ICConfigurationDescription resolveSelectedConfiguration() {
		ICConfigurationDescription result = null;

		IProject project = resolveProject();
		if (project != null) {
			ICProjectDescription desc = CoreModel.getDefault().getProjectDescription(project);

			if (desc != null) {
				result = desc.getConfigurationById(getSelectedConfigurationID());
			}
		}

		return result;
	}

	public Collection<ICConfigurationDescription> resolveConfigurations() {
		ICConfigurationDescription[] result = null;

		IProject project = resolveProject();
		if (project != null) {
			ICProjectDescription desc = CoreModel.getDefault().getProjectDescription(project);

			if (desc != null) {
				result = desc.getConfigurations();
			}
		}

		return (result == null) ? Collections.<ICConfigurationDescription> emptyList() : Arrays
				.asList(result);
	}

	public boolean isActive() {
		ICConfigurationDescription desc = resolveSelectedConfiguration();

		return (desc != null) && desc.isActive();
	}

	public void activate() {
		ICConfigurationDescription config = resolveSelectedConfiguration();

		if (config != null) {
			ICProjectDescription desc = config.getProjectDescription();

			if (desc.getActiveConfiguration() != config) {
				try {
					IProject project = desc.getProject();
					desc.setActiveConfiguration(config);
					CoreModel.getDefault().setProjectDescription(project, desc);
				} catch (CoreException e) {
					CUIPlugin.log(e);
				}
			}
		}
	}

	public IStatus build(IProgressMonitor monitor) {
		IStatus result = Status.OK_STATUS;

		ICConfigurationDescription config = resolveSelectedConfiguration();

		if (config == null) {
			result = new Status(IStatus.WARNING, CUIPlugin.PLUGIN_ID, NLS.bind(
					WorkingSetMessages.WSProjConfig_noConfig, getProjectName()));
		} else {
			if (!isActive()) {
				activate();
				result = new Status(IStatus.WARNING, CUIPlugin.PLUGIN_ID, NLS.bind(
						WorkingSetMessages.WSProjConfig_activatedWarning, config.getName(), getProjectName()));
			}

			monitor = SubMonitor.convert(monitor);

			try {
				resolveProject().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
			} catch (CoreException e) {
				if (result.isOK()) {
					result = e.getStatus();
				} else {
					result = new MultiStatus(CUIPlugin.PLUGIN_ID, 0, new IStatus[] { result, e.getStatus() },
							NLS.bind(WorkingSetMessages.WSProjConfig_buildProblem, getProjectName()), null);
				}
			}
		}

		return result;
	}

	public void saveState(IMemento memento) {
		memento.putString(ATTR_NAME, getProjectName());

		if (getSelectedConfigurationID() != null) {
			memento.putString(ATTR_CONFIG, getSelectedConfigurationID());
		}
	}

	public void loadState(IMemento memento) {
		projectName = memento.getString(ATTR_NAME);
		selectedConfiguration = memento.getString(ATTR_CONFIG);
	}

	public ISnapshot createSnapshot(IWorkingSetConfiguration.ISnapshot workingSetConfig,
			WorkspaceSnapshot workspace) {

		return new Snapshot(workingSetConfig, this, workspace);
	}

	//
	// Nested classes
	//

	/**
	 * Default implementation of the mutable project configuration snapshot.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @since 6.0
	 */
	public static class Snapshot extends WorkingSetProjectConfiguration implements
			IWorkingSetProjectConfiguration.ISnapshot {

		private final IProject project;
		private final WorkspaceSnapshot workspace;

		/**
		 * Initializes me with the project that I represent and the workspace snapshot. I discover the
		 * currently defined configurations for my project and initially select the one that is currently
		 * active, or the first available if none is active (which would be odd).
		 * 
		 * @param parent
		 *            my parent working set configuration
		 * @param projectConfig
		 *            the project configuration to copy
		 * @param workspace
		 *            the current workspace snapshot
		 */
		protected Snapshot(IWorkingSetConfiguration parent, IWorkingSetProjectConfiguration projectConfig,
				WorkspaceSnapshot workspace) {

			super(parent);

			this.project = projectConfig.resolveProject();
			this.workspace = workspace;

			String selected = projectConfig.getSelectedConfigurationID();
			if (selected == null) {
				selected = workspace.getOriginalActiveConfigurationID(project);
			}
			setSelectedConfigurationID(selected);
		}

		@Override
		public IWorkingSetConfiguration.ISnapshot getWorkingSetConfiguration() {
			return (IWorkingSetConfiguration.ISnapshot) super.getWorkingSetConfiguration();
		}

		@Override
		public final IProject resolveProject() {
			return project;
		}

		@Override
		public final String getProjectName() {
			return resolveProject().getName();
		}

		@Override
		public boolean isActive() {
			return workspace.isActive(this);
		}

		@Override
		public void activate() {
			workspace.activate(resolveProject(), getSelectedConfigurationID());
		}

		@Override
		public Collection<ICConfigurationDescription> resolveConfigurations() {
			return workspace.getConfigurations(resolveProject());
		}

		@Override
		public ICConfigurationDescription resolveSelectedConfiguration() {
			return workspace.getConfiguration(resolveProject(), getSelectedConfigurationID());
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import static org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager.ATTR_NAME;
import static org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager.KEY_CONFIG;

import java.util.Collection;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkingSet;

/**
 * Default implementation of the {@link IWorkingSetProxy} interface.
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 */
public class WorkingSetProxy implements IWorkingSetProxy {
	private String name;
	private Map<String, IWorkingSetConfiguration> configurations;

	/**
	 * Initializes me.
	 */
	public WorkingSetProxy() {
		super();
	}

	public String getName() {
		return name;
	}

	/**
	 * Sets my name. This <b>does not</b> change the name of the working set that I represent. Rather, it
	 * changes <i>which</i> working set I represent.
	 * 
	 * @param name
	 *            my new name
	 */
	void setName(String name) {
		this.name = name;
	}

	public IWorkingSet resolve() {
		return WorkingSetConfigurationManager.WS_MGR.getWorkingSet(name);
	}

	public Collection<IProject> resolveProjects() {
		Set<IProject> result = new java.util.HashSet<IProject>();

		IWorkingSet resolvedWS = resolve();
		if (resolvedWS != null) {
			for (IAdaptable next : resolvedWS.getElements()) {
				IProject proj = (IProject) next.getAdapter(IProject.class);

				if (proj != null) {
					result.add(proj);
				}
			}
		}

		return result;
	}

	public boolean isValid() {
		return !resolveProjects().isEmpty();
	}

	private Map<String, IWorkingSetConfiguration> getConfigurationsMap() {
		if (configurations == null) {
			configurations = new java.util.HashMap<String, IWorkingSetConfiguration>();
		}

		return configurations;
	}

	public IWorkingSetConfiguration getConfiguration(String name) {
		return getConfigurationsMap().get(name);
	}

	public Collection<IWorkingSetConfiguration> getConfigurations() {
		return getConfigurationsMap().values();
	}

	public void saveState(IMemento memento) {
		memento.putString(ATTR_NAME, getName());

		for (IWorkingSetConfiguration next : getConfigurations()) {
			if (!isTransient(next)) {
				next.saveState(memento.createChild(KEY_CONFIG));
			}
		}
	}

	/**
	 * Queries whether the specified configuration is transient, meaning that it should not be persisted in
	 * the working set configuration store. The default implementation just returns <code>false</code>;
	 * subclasses may redefine as required.
	 * 
	 * @param config
	 *            a working set configuration
	 * @return whether it should be omitted from persistence
	 */
	protected boolean isTransient(IWorkingSetConfiguration config) {
		return false;
	}

	public void loadState(IMemento memento) {
		setName(memento.getString(ATTR_NAME));

		for (IMemento next : memento.getChildren(KEY_CONFIG)) {
			IWorkingSetConfiguration config = createWorkingSetConfiguration();
			config.loadState(next);
			getConfigurationsMap().put(config.getName(), config);
		}
	}

	/**
	 * Creates a new child working set configuration element. Subclasses may override to create custom
	 * implementations.
	 * 
	 * @return the new working set configuration
	 */
	protected IWorkingSetConfiguration createWorkingSetConfiguration() {
		return new WorkingSetConfiguration(this);
	}

	/**
	 * Provides simple access to the child configurations, to remove the specified configuration.
	 * 
	 * @param config
	 *            a configuration to remove
	 */
	protected void basicRemoveConfiguration(IWorkingSetConfiguration config) {
		getConfigurationsMap().remove(config.getName());
	}

	/**
	 * Provides simple access to the child configurations, to add the specified configuration.
	 * 
	 * @param config
	 *            a configuration to add
	 */
	protected void basicAddConfiguration(IWorkingSetConfiguration config) {
		getConfigurationsMap().put(config.getName(), config);
	}

	public ISnapshot createSnapshot(WorkspaceSnapshot workspace) {
		Snapshot result = new Snapshot(this, workspace);
		
		result.updateActiveConfigurations();
		
		return result;
	}

	//
	// Nested classes
	//

	/**
	 * The default implementation of a mutable working set snapshot.
	 * 
	 * @noextend This class is not intended to be subclassed by clients.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @since 6.0
	 */
	public static class Snapshot extends WorkingSetProxy implements IWorkingSetProxy.ISnapshot {
		private final WorkspaceSnapshot workspace;
		private IWorkingSetConfiguration.ISnapshot readOnlyConfig;

		/**
		 * Initializes me with the current workspace snapshot.
		 * 
		 * @param workingSet
		 *            the original working set element to copy
		 * @param workspace
		 *            the workspace snapshot
		 */
		protected Snapshot(IWorkingSetProxy workingSet, WorkspaceSnapshot workspace) {
			super();

			this.workspace = workspace;

			setName(workingSet.getName());

			for (IWorkingSetConfiguration next : workingSet.getConfigurations()) {
				basicAddConfiguration(next.createSnapshot(this, workspace));
			}
		}

		public IWorkingSetConfiguration.ISnapshot createConfiguration(String name) {
			if ((name == null) || (name.length() == 0)) {
				throw new IllegalArgumentException("name is empty"); //$NON-NLS-1$
			}
			if (getConfiguration(name) != null) {
				throw new IllegalArgumentException("name is already in use"); //$NON-NLS-1$
			}

			IWorkingSetConfiguration.ISnapshot result = createWorkingSetConfiguration();
			result.setName(name);
			basicAddConfiguration(result);
			updateActiveConfigurations();

			return result;
		}

		/**
		 * I create working-set configuration snapshots that are mutable, as I am.
		 */
		@Override
		protected IWorkingSetConfiguration.ISnapshot createWorkingSetConfiguration() {
			return new WorkingSetConfiguration.Snapshot(this, workspace);
		}

		public void removeConfiguration(IWorkingSetConfiguration config) {
			if (WorkingSetConfiguration.isReadOnly(config)) {
				throw new IllegalArgumentException("config is read-only"); //$NON-NLS-1$
			}

			basicRemoveConfiguration(config);
		}

		public boolean updateActiveConfigurations() {
			boolean result = getConfigurations().isEmpty();

			boolean hasActiveConfig = false;
			for (IWorkingSetConfiguration next : getConfigurations()) {
				if (next.isActive() && !WorkingSetConfiguration.isReadOnly(next)) {
					hasActiveConfig = true;
					break;
				}
			}

			if (hasActiveConfig) {
				if (readOnlyConfig != null) {
					basicRemoveConfiguration(readOnlyConfig);
					result = true;
				}
				readOnlyConfig = null;
			} else {
				WorkingSetConfiguration.Snapshot ro = new WorkingSetConfiguration.Snapshot(this, workspace,
						true);
				ro.basicSetName(""); // don't want to validate this name //$NON-NLS-1$
				readOnlyConfig = ro;
				basicAddConfiguration(readOnlyConfig);
				result = true;
			}

			return result;
		}

		/**
		 * Read-only working set configuration snapshots are transient.
		 */
		@Override
		protected boolean isTransient(IWorkingSetConfiguration config) {
			return WorkingSetConfiguration.isReadOnly(config);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.dialogs.InputDialog;
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.TreeViewer;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IWorkingSet;

/**
 * The view controller for the working set configurations pane in the dialog. It takes care of coordinating
 * the user gestures in the pane with the working set configuration model, and vice-versa. It also implements
 * the handling of the action buttons.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
class WorkingSetConfigsController implements SelectionListener, ISelectionChangedListener {

	private TreeViewer tree;
	private Button addButton;
	private Button removeButton;
	private Button renameButton;
	private Button activateButton;

	private IWorkingSetProxy.ISnapshot initialWorkingSet;
	private IWorkingSetProxy.ISnapshot currentWorkingSet;
	private IWorkingSetConfiguration.ISnapshot currentConfig;

	private final WorkspaceSnapshot workspace;

	private ProjectConfigsController projectsController;

	/**
	 * Initializes me.
	 */
	WorkingSetConfigsController(WorkspaceSnapshot workspace) {
		this.workspace = workspace;

		IWorkingSet[] recent = WorkingSetConfigurationManager.WS_MGR.getRecentWorkingSets();
		if ((recent != null) && (recent.length > 0)) {
			initialWorkingSet = workspace.getWorkingSet(recent[0].getName());
		}
	}

	/**
	 * Assigns the tree viewer that I control.
	 * 
	 * @param tree
	 *            my tree viewer
	 */
	void setTreeViewer(TreeViewer tree) {
		if (this.tree != null) {
			this.tree.removeSelectionChangedListener(this);
		}

		this.tree = tree;

		if (this.tree != null) {
			this.tree.addSelectionChangedListener(this);

			this.tree.setInput(workspace.getWorkingSets());
			if (initialWorkingSet != null) {
				this.tree.setSelection(new StructuredSelection(initialWorkingSet));
				this.tree.expandToLevel(initialWorkingSet, 1);
			} else if (!workspace.getWorkingSets().isEmpty()) {
				final TreeItem initialItem = tree.getTree().getItem(0);
				tree.getTree().getDisplay().asyncExec(new Runnable() {

					public void run() {
						WorkingSetConfigsController.this.tree.setSelection(new StructuredSelection(
								initialItem.getData()));
						WorkingSetConfigsController.this.tree.expandToLevel(initialItem.getData(), 1);
					}
				});
			}
		}
	}

	private Button updateButton(Button oldButton, Button newButton) {
		if (oldButton != null) {
			oldButton.removeSelectionListener(this);
		}

		if (newButton != null) {
			newButton.addSelectionListener(this);
		}

		return newButton;
	}

	/**
	 * Assigns me my "Add..." button.
	 * 
	 * @param addButton
	 *            my add button
	 */
	void setAddButton(Button addButton) {
		this.addButton = updateButton(this.addButton, addButton);
	}

	/**
	 * Assigns me my "Remove" button.
	 * 
	 * @param removeButton
	 *            my remove button
	 */
	void setRemoveButton(Button removeButton) {
		this.removeButton = updateButton(this.removeButton, removeButton);
	}

	/**
	 * Assigns me my "Rename..." button.
	 * 
	 * @param renameButton
	 *            my rename button
	 */
	void setRenameButton(Button renameButton) {
		this.renameButton = updateButton(this.renameButton, renameButton);
	}

	/**
	 * Assigns me my "Activate" button.
	 * 
	 * @param activateButton
	 *            my activate button
	 */
	void setActivateButton(Button activateButton) {
		this.activateButton = updateButton(this.activateButton, activateButton);
	}

	/**
	 * Connects me to the controller for the project configurations pane, into which I inject the currently
	 * selected working set configuration.
	 * 
	 * @param controller
	 *            my project configurations controller
	 */
	void setProjectConfigsController(ProjectConfigsController controller) {
		this.projectsController = controller;
		
		if (controller != null) {
			controller.setWorkingSetConfiguration(currentConfig);
		}
	}

	public void widgetDefaultSelected(SelectionEvent e) {
		// not interesting
	}

	/**
	 * Handles button presses in the working set configurations pane.
	 */
	public void widgetSelected(SelectionEvent e) {
		// handle button press
		if (e.widget == addButton) {
			addConfig();
		} else if (e.widget == removeButton) {
			removeConfig();
		} else if (e.widget == renameButton) {
			renameConfig();
		} else if (e.widget == activateButton) {
			activateConfig();
		}
	}

	/**
	 * Handles selection of working sets and their configurations. Among potentially other actions, this
	 * injects the working-set configuration selection into the project configurations controller and updates
	 * the enablement of the buttons.
	 */
	public void selectionChanged(SelectionChangedEvent event) {
		currentConfig = null;
		currentWorkingSet = null;

		if (event.getSelection() instanceof IStructuredSelection) {
			IStructuredSelection sel = (IStructuredSelection) event.getSelection();

			if (!sel.isEmpty()) {
				Object first = sel.getFirstElement();

				if (first instanceof IWorkingSetConfiguration) {
					currentConfig = (IWorkingSetConfiguration.ISnapshot) first;
					currentWorkingSet = currentConfig.getWorkingSet();
				} else if (first instanceof IWorkingSetProxy) {
					currentWorkingSet = (IWorkingSetProxy.ISnapshot) first;
				}
			}
		}

		if (projectsController != null) {
			// tell the project controller
			projectsController.setWorkingSetConfiguration(currentConfig);
		}
		
		updateButtons();
	}

	/**
	 * Handler for the "Add..." button.
	 */
	private void addConfig() {
		InputDialog dlg = new InputDialog(tree.getTree().getShell(), WorkingSetMessages.WSConfigsController_addDlg_title,
				WorkingSetMessages.WSConfigsController_addDlg_msg, WorkingSetMessages.WSConfigsController_addDlg_defaultName, new IInputValidator() {

					public String isValid(String newText) {
						if (currentWorkingSet.getConfiguration(newText) != null) {
							return WorkingSetMessages.WSConfigsController_addDlg_nameExists;
						}
						if (newText.length() == 0) {
							return WorkingSetMessages.WSConfigsController_addDlg_emptyName;
						}
						return null;
					}
				});

		if (dlg.open() == IDialogConstants.OK_ID) {
			IWorkingSetConfiguration.ISnapshot newConfig = currentWorkingSet.createConfiguration(dlg.getValue());
			tree.refresh(currentWorkingSet);
			tree.setSelection(new StructuredSelection(newConfig), true);
			currentConfig = newConfig;
			currentWorkingSet = currentConfig.getWorkingSet();
			
			// this is a "recently used" working set
			IWorkingSet ws = currentWorkingSet.resolve();
			if (ws != null) {
				WorkingSetConfigurationManager.WS_MGR.addRecentWorkingSet(ws);
			}
		}
	}

	/**
	 * Handler for the "Remove" button.
	 */
	private void removeConfig() {
		currentWorkingSet.removeConfiguration(currentConfig);
		tree.refresh(currentWorkingSet);
	}

	/**
	 * Handler for the "Rename..." button.
	 */
	private void renameConfig() {
		InputDialog dlg = new InputDialog(tree.getTree().getShell(), WorkingSetMessages.WSConfigsController_renameDlg_title,
				WorkingSetMessages.WSConfigsController_renameDlg_msg, currentConfig.getName(), new IInputValidator() {

					public String isValid(String newText) {
						if (newText.equals(currentConfig.getName())) {
							return ""; //$NON-NLS-1$
						}
						if (currentWorkingSet.getConfiguration(newText) != null) {
							return WorkingSetMessages.WSConfigsController_addDlg_nameExists;
						}
						if (newText.length() == 0) {
							return WorkingSetMessages.WSConfigsController_addDlg_emptyName;
						}
						return null;
					}
				});

		if (dlg.open() == IDialogConstants.OK_ID) {
			currentConfig.setName(dlg.getValue());
			tree.refresh(currentWorkingSet);
		}
	}

	/**
	 * Handler for the "Activate" button.
	 */
	private void activateConfig() {
		currentConfig.activate();

		// update all working-set configs that intersect this config
		Collection<IWorkingSetProxy.ISnapshot> unaffectedWorkingSets = new java.util.HashSet<IWorkingSetProxy.ISnapshot>(workspace.getWorkingSets());

		for (IProject project : currentConfig.getWorkingSet().resolveProjects()) {
			for (IWorkingSetProxy.ISnapshot next : unaffectedWorkingSets) {
				if (next.resolveProjects().contains(project)) {
					unaffectedWorkingSets.remove(next);

					if (next.updateActiveConfigurations()) {
						// major change. Refresh it altogether
						tree.refresh(next);
					} else {
						// lighter-weight updates of its configs
						for (IWorkingSetConfiguration config : next.getConfigurations()) {
							tree.update(config, null);
						}
					}
					break;
				}
			}
		}

		updateButtons();
	}

	/**
	 * Updates the enablement state of the action buttons according to the current selection.
	 */
	private void updateButtons() {
		if (addButton != null) {
			addButton.setEnabled(currentWorkingSet != null);
		}
		if (removeButton != null) {
			removeButton.setEnabled((currentConfig != null) && !currentConfig.isReadOnly());
		}
		if (renameButton != null) {
			renameButton.setEnabled((currentConfig != null) && !currentConfig.isReadOnly());
		}
		if (activateButton != null) {
			activateButton.setEnabled((currentConfig != null) && !currentConfig.isActive());
		}
	}

	/**
	 * Notification that the selection of configuration(s) in some project in the current working set
	 * configuration has changed. I accordingly update the visuals of the working-set configuration to
	 * indicate whether it is active or not.
	 * 
	 * @param project
	 *            the project configuration whose active configuration selections have changed
	 */
	void projectSelectionsChanged(IWorkingSetProjectConfiguration project) {
		tree.update(currentConfig, null);
		updateButtons(); // depends on whether the ws config is active
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;

import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;

/**
 * <p>
 * The protocol for project configurations in a working set configuration. At a minimum, the project
 * configuration specifies which build configuration is {@linkplain #getSelectedConfigurationID() selected} to
 * be set as the project's active configuration. Implementations are free to add more configuration
 * information than the selected build configuration.
 * </p>
 * <p>
 * Note that project configurations are owned by working set configurations. Thus, different configurations of
 * the same (or different) working set may specify different settings for the same project.
 * </p>
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 */
public interface IWorkingSetProjectConfiguration extends IWorkingSetConfigurationElement {
	/**
	 * Obtains the working set configuration element that owns me.
	 * 
	 * @return my working set configuration
	 */
	IWorkingSetConfiguration getWorkingSetConfiguration();

	/**
	 * Queries the name of the project that I configure.
	 * 
	 * @return my project name
	 */
	String getProjectName();

	/**
	 * Resolves my project name to the actual project resource in the workspace.
	 * 
	 * @return my referenced project, or <code>null</code> if the project is not
	 *         {@linkplain IResource#isAccessible() accessible} in the workspace
	 */
	IProject resolveProject();

	/**
	 * Queries the ID of the build configuration that is currently selected for my project.
	 * 
	 * @return my selected build configuration ID
	 */
	String getSelectedConfigurationID();

	/**
	 * Sets the ID of the build configuration that is currently selected for my project.
	 * 
	 * @param id
	 *            my selected build configuration ID
	 */
	void setSelectedConfigurationID(String id);

	/**
	 * <p>
	 * Resolves my selected configuration reference to the C model's description handle for it.
	 * </p>
	 * <p>
	 * <b>Note</b> that, in the general case, it is possible for the configuration to resolve to a different
	 * object from one call to the next, but always representing the same configuration. However, in the case
	 * of a working-copy {@linkplain IWorkingSetProjectConfiguration.ISnapshot snapshot} of me, the result
	 * will always be the same object.
	 * </p>
	 * 
	 * @return the C model representation of my selected build configuration
	 * 
	 * @see #resolveConfigurations()
	 */
	ICConfigurationDescription resolveSelectedConfiguration();

	/**
	 * <p>
	 * Resolves the set of available configurations of my project.
	 * </p>
	 * <p>
	 * <b>Note</b> that, in the general case, it is possible for these configurations to resolve to different
	 * objects from one call to the next, but always representing the same configurations. However, in the
	 * case of a working-copy {@linkplain IWorkingSetProjectConfiguration.ISnapshot snapshot} of me, the
	 * results will always be the same objects.
	 * </p>
	 * 
	 * @return the C model representation of my selected available build configurations
	 * 
	 * @see #resolveSelectedConfiguration()
	 */
	Collection<ICConfigurationDescription> resolveConfigurations();

	/**
	 * Queries whether my project currently has my selected configuration active in the workspace.
	 * 
	 * @return whether I am my project's active configuration
	 * 
	 * @see #getSelectedConfigurationID()
	 * @see #activate()
	 */
	boolean isActive();

	/**
	 * Activates my selected configuration in the workspace, for my project.
	 * 
	 * @see #getSelectedConfigurationID()
	 * @see #setSelectedConfigurationID(String)
	 * @see #isActive()
	 */
	void activate();

	/**
	 * Builds my selected configuration in the workspace, for my project. If building the configuration
	 * actually requires activating it, and it was not already active, then it would be a good idea to return
	 * a warning status indicating that the active configuration had to be changed in order to effect the
	 * build.
	 * 
	 * @param monitor
	 *            a progress monitor to report build progress
	 * @return a status indicating any error or warning conditions in the invocation of the build
	 */
	IStatus build(IProgressMonitor monitor);

	/**
	 * Creates a <i>snapshot</i> (also known as a "working copy") of myself, providing a mutable view suitable
	 * for editing.
	 * 
	 * @param workingSetConfig
	 *            my parent working set configuration snapshot
	 * @param workspace
	 *            a workspace snapshot that captures the baseline state of the workspace and the working set
	 *            configurations that are to be edited
	 * 
	 * @return a working-copy snapshot of myself
	 */
	ISnapshot createSnapshot(IWorkingSetConfiguration.ISnapshot workingSetConfig, WorkspaceSnapshot workspace);

	//
	// Nested types
	//

	/**
	 * The snapshot ("working copy") view of a working set project configuration.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @since 6.0
	 */
	interface ISnapshot extends IWorkingSetProjectConfiguration {
		IWorkingSetConfiguration.ISnapshot getWorkingSetConfiguration();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.ui.IWorkingSet;

import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;
import org.eclipse.cdt.core.settings.model.ICProjectDescription;
import org.eclipse.cdt.ui.CUIPlugin;

/**
 * <p>
 * A snapshot of the working set configurations and project configurations across the workspace at the time
 * when it was created. The snapshot maintains a delta from that original state to the current state, for such
 * comparison operations as determining which projects need to be re-built because their active configurations
 * have changed. The snapshot provides mutable working-copy views of the working set configurations at the
 * time of snapshot creation.
 * </p>
 * <p>
 * To make changes to working set configurations, first
 * {@linkplain WorkingSetConfigurationManager#createWorkspaceSnapshot() obtain a snapshot} from the
 * {@link WorkingSetConfigurationManager}. Then make edits to the various snapshots of the configuration
 * elements and {@linkplain #save() save} the snapshot
 * </p>
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public class WorkspaceSnapshot {
	private Map<String, IWorkingSetProxy.ISnapshot> workingSets = new java.util.HashMap<String, IWorkingSetProxy.ISnapshot>();
	private Map<IProject, ProjectState> projectStates = new java.util.HashMap<IProject, ProjectState>();

	/**
	 * Initializes me. I capture the current C/C++ active configuration state of the projects in the
	 * workspace.
	 */
	WorkspaceSnapshot() {
		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

		for (IProject next : root.getProjects()) {
			ICProjectDescription desc = CoreModel.getDefault().getProjectDescription(next);

			if (desc != null) {
				projectStates.put(next, createProjectState(next, desc));
			}
		}
	}

	/**
	 * Creates a project state using the registered factory, if possible.
	 * 
	 * @param project
	 *            a workspace project
	 * @param desc
	 *            its CDT project description
	 * 
	 * @return its state capture (will never be <code>null</code>)
	 */
	private static ProjectState createProjectState(IProject project, ICProjectDescription desc) {
		ProjectState result = null;
		IWorkingSetProjectConfigurationFactory factory = IWorkingSetProjectConfigurationFactory.Registry.INSTANCE
				.getFactory(project);

		if (factory != null) {
			result = factory.createProjectState(project, desc);
		}

		if (result == null) {
			// the default-default
			result = new ProjectState(project, desc);
		}

		return result;
	}

	/**
	 * Initializes me with the specified working sets to copy for editing.
	 * 
	 * @param workingSets
	 *            the working sets to copy
	 * @return myself
	 */
	WorkspaceSnapshot initialize(Map<String, IWorkingSetProxy> workingSets) {
		for (IWorkingSet next : WorkingSetConfigurationManager.WS_MGR.getWorkingSets()) {
			IWorkingSetProxy workingSet = workingSets.get(next.getName());

			if (workingSet == null) {
				workingSet = new WorkingSetProxy();
				((WorkingSetProxy) workingSet).setName(next.getName());
			}

			if (workingSet.isValid()) {
				this.workingSets.put(workingSet.getName(), workingSet.createSnapshot(this));
			}
		}

		return this;
	}

	/**
	 * Obtains a mutable snapshot of the named working set.
	 * 
	 * @param name
	 *            the working set to retrieve
	 * 
	 * @return the working set snapshot, or <code>null</code> if there is no working set by this name
	 * 
	 * @see #getWorkingSets()
	 */
	public IWorkingSetProxy.ISnapshot getWorkingSet(String name) {
		return workingSets.get(name);
	}

	/**
	 * Obtains snapshots of all of the working sets currently defined by the workbench.
	 * 
	 * @return the working set snapshots
	 * 
	 * @see #getWorkingSet(String)
	 */
	public Collection<IWorkingSetProxy.ISnapshot> getWorkingSets() {
		return workingSets.values();
	}

	/**
	 * Obtains the project state recording the initial configuration of the specified <tt>project</tt> at the
	 * time that this snapshot was taken.
	 * 
	 * @param project
	 *            a project
	 * @return its snapshot/delta state
	 */
	public ProjectState getState(IProject project) {
		return projectStates.get(project);
	}

	/**
	 * Queries the ID of the configuration of the specified project that was active when the workspace
	 * snapshot was taken.
	 * 
	 * @param project
	 *            a project
	 * @return its active configuration ID at the time of the snapshot
	 */
	String getOriginalActiveConfigurationID(IProject project) {
		String result = null;
		ProjectState state = getState(project);

		if (state != null) {
			result = state.getOriginalActiveConfigurationID();
		}

		return result;
	}

	/**
	 * Queries whether the configuration selected by the given project in a working set configuration is
	 * currently active in the workspace.
	 * 
	 * @param project
	 *            a project configuration element in a working set configuration
	 * 
	 * @return whether the project's selected configuration is active
	 * 
	 * @see #activate(IProject, String)
	 */
	boolean isActive(IWorkingSetProjectConfiguration project) {
		boolean result = false;
		ProjectState state = getState(project.resolveProject());

		if (state != null) {
			result = state.isActive(project.getSelectedConfigurationID());
		}

		return result;
	}

	/**
	 * Activates, in the workspace, the specified configuration of a project. This method has no effect if the
	 * given configuration is already active.
	 * 
	 * @param project
	 *            the project for which to set the active configuration
	 * @param configID
	 *            the ID of the configuration to activate
	 * 
	 * @see #isActive(IWorkingSetProjectConfiguration)
	 */
	void activate(IProject project, String configID) {
		ProjectState state = getState(project);

		if (state != null) {
			state.activate(configID);
		}
	}

	/**
	 * Obtains the configurations of the specified project, as known at the time that this snapshot was taken.
	 * 
	 * @param project
	 *            a project
	 * 
	 * @return its configurations, which may be an empty collection if the project is not a C/C++ project
	 */
	public Collection<ICConfigurationDescription> getConfigurations(IProject project) {
		Collection<ICConfigurationDescription> result;
		ProjectState state = getState(project);

		if (state == null) {
			result = Collections.emptyList();
		} else {
			result = state.getConfigurations();
		}

		return result;
	}

	/**
	 * Obtains the specified configuration of a project, as known at the time that this snapshot was taken.
	 * 
	 * @param project
	 *            a project
	 * @param id
	 *            the ID of a configuration
	 * 
	 * @return the configuration, or <code>null</code> if there is none such by this ID
	 */
	public ICConfigurationDescription getConfiguration(IProject project, String id) {
		ProjectState state = getState(project);
		return (state == null) ? null : state.getConfiguration(id);
	}

	/**
	 * Queries the projects that need to be built because their active configurations have been changed since
	 * this snapshot was taken.
	 * 
	 * @return the projects needing to be re-built
	 */
	public Collection<IProject> getProjectsToBuild() {
		Collection<IProject> result = new java.util.ArrayList<IProject>();

		for (ProjectState next : projectStates.values()) {
			if (next.needsBuild()) {
				result.add(next.getProject());
			}
		}

		return result;
	}

	/**
	 * Saves my working set configuration settings.
	 */
	public void save() {
		WorkingSetConfigurationManager.getDefault().save(this);
	}

	//
	// Nested classes
	//

	/**
	 * Capture of the current state of a project at the time when a {@linkplain WorkspaceSnapshot workspace
	 * snapshot} was taken, and its delta from that original state. This tracks at least the C/C++ project
	 * description (if any) and the original active configuration. Subclasses may track additional
	 * configuration details.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @since 6.0
	 */
	public static class ProjectState {
		private final IProject project;
		private final ICProjectDescription projectDescription;
		private final String originalConfigID;
		private String currentConfigID;

		/**
		 * Initializes me with a project and its description.
		 * 
		 * @param project
		 *            the project whose state I track
		 * @param desc
		 *            the project's description, from which I capture the initial state snapshot
		 */
		protected ProjectState(IProject project, ICProjectDescription desc) {
			this.project = project;
			this.projectDescription = desc;

			if (desc != null) {
				ICConfigurationDescription config = desc.getActiveConfiguration();
				this.originalConfigID = (config == null) ? "" : config.getId(); //$NON-NLS-1$
			} else {
				this.originalConfigID = ""; //$NON-NLS-1$
			}

			this.currentConfigID = this.originalConfigID;
		}

		/**
		 * Obtains the project that I track.
		 * 
		 * @return my project
		 */
		public final IProject getProject() {
			return project;
		}

		/**
		 * Obtains the project description that was current when the snapshot was taken.
		 * 
		 * @return my project description
		 */
		protected final ICProjectDescription getProjectDescription() {
			return projectDescription;
		}

		/**
		 * Queries whether my project needs to be re-built because its active configuration has been changed
		 * since the snapshot was taken.
		 * 
		 * @return whether I need to be re-built
		 */
		public boolean needsBuild() {
			return !currentConfigID.equals(originalConfigID);
		}

		/**
		 * Queries whether the specified configuration is currently active in the workspace for my project.
		 * 
		 * @param configID
		 *            the ID of a project build configuration
		 * @return whether it is my project's active configuration
		 */
		public boolean isActive(String configID) {
			return currentConfigID.equals(configID);
		}

		/**
		 * Queries the ID of the configuration of my project that was active when the workspace snapshot was
		 * taken.
		 * 
		 * @return its active configuration ID at the time of the snapshot
		 */
		protected String getOriginalActiveConfigurationID() {
			return originalConfigID;
		}

		/**
		 * Sets my project's active configuration to the specified configuration. This method has no effect if
		 * this configuration is already active.
		 * 
		 * @param configID
		 *            the ID of the configuration to activate
		 */
		protected void activate(String configID) {
			if (!currentConfigID.equals(configID) && (projectDescription != null)) {
				try {
					ICConfigurationDescription realConfig = projectDescription.getConfigurationById(configID);
					realConfig.setActive();
					CoreModel.getDefault().setProjectDescription(project, projectDescription);
					currentConfigID = configID;
				} catch (CoreException e) {
					CUIPlugin.log(e);
				}
			}
		}

		/**
		 * Obtains the configurations of my project that were defined at the time that the snapshot was taken.
		 * 
		 * @return my project's configurations, which may be empty if it is not a C/C++ project
		 */
		protected Collection<ICConfigurationDescription> getConfigurations() {
			Collection<ICConfigurationDescription> result;

			if (projectDescription == null) {
				result = Collections.emptyList();
			} else {
				result = Arrays.asList(projectDescription.getConfigurations());
			}

			return result;
		}

		/**
		 * Obtains the specified configuration of my project as it was defined at the time that the snapshot
		 * was taken.
		 * 
		 * @param id
		 *            a configuration ID
		 * @return the matching configuration, or <code>null</code> if it did not exist
		 */
		protected ICConfigurationDescription getConfiguration(String id) {
			return (projectDescription == null) ? null : projectDescription.getConfigurationById(id);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.XMLMemento;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.newui.CDTPrefUtil;

/**
 * The purveyor of working set configurations. It provides a current view of the {@linkplain IWorkingSetProxy
 * working set configurations} defined in the workspace, as well as a working-copy
 * {@linkplain WorkspaceSnapshot snapshot} of the same for making modifications.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public class WorkingSetConfigurationManager {

	static final String TYPE_WORKING_SET_CONFIGS = "org.eclipse.cdt.ui.workingSetConfigurations"; //$NON-NLS-1$
	static final String KEY_WORKING_SET = "workingSet"; //$NON-NLS-1$
	static final String ATTR_NAME = "name"; //$NON-NLS-1$
	static final String KEY_CONFIG = "config"; //$NON-NLS-1$
	static final String KEY_PROJECT = "project"; //$NON-NLS-1$
	static final String ATTR_CONFIG = "config"; //$NON-NLS-1$
	static final String ATTR_FACTORY = "factory"; //$NON-NLS-1$

	static IWorkingSetManager WS_MGR = CUIPlugin.getDefault().getWorkbench().getWorkingSetManager();

	private static final WorkingSetConfigurationManager INSTANCE = new WorkingSetConfigurationManager();

	private Map<String, IWorkingSetProxy> workingSets;

	private final Object storeLock = new Object();
	private IMemento store;

	private final ISchedulingRule saveRule = new ISchedulingRule() {

		public boolean isConflicting(ISchedulingRule rule) {
			return rule == this;
		}

		public boolean contains(ISchedulingRule rule) {
			return rule == this;
		}
	};

	/**
	 * Not instantiable by clients.
	 */
	private WorkingSetConfigurationManager() {
		store = loadMemento();
		new WorkingSetChangeTracker();
	}

	/**
	 * Obtains the default working set configuration manager.
	 * 
	 * @return the working set configuration manager
	 */
	public static WorkingSetConfigurationManager getDefault() {
		return INSTANCE;
	}

	private Map<String, IWorkingSetProxy> getWorkingSetMap() {
		Map<String, IWorkingSetProxy> result;

		synchronized (storeLock) {
			if (workingSets == null) {
				load();
			}
			result = workingSets;
		}

		return result;
	}

	/**
	 * Obtains the current immutable view of the specified working set's configurations. These configurations
	 * may be {@linkplain IWorkingSetConfiguration#activate() activated} to apply their settings to the
	 * workspace, but they cannot be modified.
	 * 
	 * @param name
	 *            the name of the working set to retrieve
	 * @return the named working set, or <code>null</code> if there is none available by that name
	 */
	public IWorkingSetProxy getWorkingSet(String name) {
		return getWorkingSetMap().get(name);
	}

	/**
	 * Obtains the current immutable view of all available working set configurations. These configurations
	 * may be {@linkplain IWorkingSetConfiguration#activate() activated} to apply their settings to the
	 * workspace, but they cannot be modified.
	 * 
	 * @return the working set configurations
	 */
	public Collection<IWorkingSetProxy> getWorkingSets() {
		return getWorkingSetMap().values();
	}

	/**
	 * Creates a new mutable snapshot of the current working set configurations. This snapshot accepts
	 * modifications and can be {@linkplain WorkspaceSnapshot#save() saved} to persist the changes.
	 * 
	 * @return a working-copy of the working set configurations
	 */
	public WorkspaceSnapshot createWorkspaceSnapshot() {
		return new WorkspaceSnapshot().initialize(getWorkingSetMap());
	}

	/**
	 * <p>
	 * Loads the working set configurations from storage.
	 * </p>
	 * <p>
	 * <b>Note</b> that this method must only be called within the <tt>storeLock</tt> monitor.
	 * </p>
	 */
	private void load() {
		workingSets = new java.util.HashMap<String, IWorkingSetProxy>();

		for (IMemento next : store.getChildren(KEY_WORKING_SET)) {
			WorkingSetProxy ws = new WorkingSetProxy();
			
			ws.loadState(next);
			
			if (ws.isValid()) {
				workingSets.put(ws.getName(), ws);
			}
		}
	}

	/**
	 * <p>
	 * Forgets the current view of the working set configurations.
	 * </p>
	 * <p>
	 * <b>Note</b> that this method must only be called within the <tt>storeLock</tt> monitor.
	 * </p>
	 */
	private void clear() {
		workingSets = null;
	}

	/**
	 * Saves the working set configurations to storage.
	 * 
	 * @param snapshot
	 *            the snapshot to save
	 */
	void save(WorkspaceSnapshot snapshot) {
		final XMLMemento memento = XMLMemento.createWriteRoot(TYPE_WORKING_SET_CONFIGS);

		for (IWorkingSetConfigurationElement next : snapshot.getWorkingSets()) {
			next.saveState(memento.createChild(KEY_WORKING_SET));
		}

		save(memento);
	}

	/**
	 * Records the specified memento as our new store and asynchronously saves it in a job.
	 * 
	 * @param memento
	 *            the new store
	 */
	private void save(final XMLMemento memento) {
		synchronized (storeLock) {
			store = memento;
			clear();
		}

		new Job(WorkingSetMessages.WSConfigManager_save_job) {
			{
				setRule(saveRule);
				setSystem(true);
			}

			@Override
			protected IStatus run(IProgressMonitor monitor) {

				File file = getStorage();
				FileWriter writer = null;
				try {
					writer = new FileWriter(file);
					memento.save(writer);
					writer.close();
				} catch (IOException e) {
					if (writer != null) {
						try {
							writer.close();
						} catch (IOException e2) {
							// no recovery
							CUIPlugin.log(WorkingSetMessages.WSConfigManager_closeFailed, e);
						}
					}

					file.delete(); // it is corrupt; we won't be able to load it, later

					CUIPlugin.log(WorkingSetMessages.WSConfigManager_saveFailed, e);
				}
				return Status.OK_STATUS;
			}
		}.schedule();
	}

	/**
	 * Gets the file in which we persist the working set configurations.
	 * 
	 * @return the file store
	 */
	private File getStorage() {
		IPath path = CUIPlugin.getDefault().getStateLocation().append("workingSetConfigs.xml"); //$NON-NLS-1$
		return path.toFile();
	}

	/**
	 * Loads the working set configurations from storage. For compatibility, if the XML file is not available,
	 * we load from the old preference setting format.
	 * 
	 * @return the working set configuration store
	 */
	private IMemento loadMemento() {
		IMemento result = null;

		File file = getStorage();

		if (file.exists()) {
			FileReader reader = null;
			try {
				reader = new FileReader(file);
				result = XMLMemento.createReadRoot(reader);
				reader.close();
			} catch (Exception e) {
				result = null;

				if (reader != null) {
					try {
						reader.close();
					} catch (IOException e2) {
						// no recovery
						CUIPlugin.log(WorkingSetMessages.WSConfigManager_closeFailed, e);
					}
				}

				CUIPlugin.log(WorkingSetMessages.WSConfigManager_loadFailed, e);
			}
		}

		if (result == null) {
			// fake one from the old preference storage format. This also
			// handles the case of no working set configurations ever being made
			@SuppressWarnings("deprecation")
			List<String> configSetStrings = CDTPrefUtil.readConfigSets();
			result = XMLMemento.createWriteRoot(TYPE_WORKING_SET_CONFIGS);

			// collect the unordered entries by working set
			Map<String, IMemento> configMap = new HashMap<String, IMemento>();
			for (String next : configSetStrings) {
				String[] bits = next.split(" "); //$NON-NLS-1$

				if (bits.length >= 2) {
					String configName = bits[0];
					String wsName = bits[1];

					IMemento workingSet = configMap.get(wsName);
					if (workingSet == null) {
						workingSet = result.createChild(KEY_WORKING_SET);
						configMap.put(wsName, workingSet);
					}

					workingSet.putString(ATTR_NAME, wsName);

					IMemento config = workingSet.createChild(KEY_CONFIG);
					config.putString(ATTR_NAME, configName);

					int limit = bits.length - (bits.length % 2);
					for (int i = 2; i < limit; i += 2) {
						IMemento project = config.createChild(KEY_PROJECT);
						project.putString(ATTR_NAME, bits[i]);
						project.putString(ATTR_CONFIG, bits[i + 1]);
					}
				}
			}
		}

		return result;
	}

	//
	// Nested classes
	//

	/**
	 * A working set manager listener that tracks name changes and removals of working sets to keep our
	 * configurations in synch as much as possible. It updates the memento store directly in response to
	 * changes in the working sets.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @since 6.0
	 */
	private class WorkingSetChangeTracker extends java.util.IdentityHashMap<IWorkingSet, String> implements
			IPropertyChangeListener {

		WorkingSetChangeTracker() {
			for (IWorkingSet next : WS_MGR.getWorkingSets()) {
				put(next, next.getName());
			}

			WS_MGR.addPropertyChangeListener(this);
		}

		public void propertyChange(PropertyChangeEvent event) {
			String property = event.getProperty();

			if (IWorkingSetManager.CHANGE_WORKING_SET_NAME_CHANGE.equals(property)) {
				handleNameChange((IWorkingSet) event.getNewValue());
			} else if (IWorkingSetManager.CHANGE_WORKING_SET_REMOVE.equals(property)) {
				handleRemove((IWorkingSet) event.getOldValue());
			} else if (IWorkingSetManager.CHANGE_WORKING_SET_ADD.equals(property)) {
				handleAdd((IWorkingSet) event.getNewValue());
			}
		}

		private void handleNameChange(IWorkingSet workingSet) {
			synchronized (storeLock) {
				String oldName = get(workingSet);
				IMemento wsMemento = null;
				if (oldName != null) {
					for (IMemento next : store.getChildren(KEY_WORKING_SET)) {
						if (oldName.equals(next.getString(ATTR_NAME))) {
							wsMemento = next;
							break;
						}
					}
				}

				if (wsMemento != null) {
					// update the memento with the new name
					wsMemento.putString(ATTR_NAME, workingSet.getName());

					// clone it
					XMLMemento newStore = XMLMemento.createWriteRoot(TYPE_WORKING_SET_CONFIGS);
					newStore.putMemento(store);

					// save it asynchronously
					save(newStore);
				}

				// and update our mapping
				put(workingSet, workingSet.getName());
			}
		}

		private void handleRemove(IWorkingSet workingSet) {
			synchronized (storeLock) {
				String name = get(workingSet);
				if (name != null) {
					// remove the memento from the store
					XMLMemento newStore = XMLMemento.createWriteRoot(TYPE_WORKING_SET_CONFIGS);
					for (IMemento next : store.getChildren(KEY_WORKING_SET)) {
						if (!name.equals(next.getString(ATTR_NAME))) {
							newStore.createChild(KEY_WORKING_SET).putMemento(next);
						}
					}

					// save asynchronously
					save(newStore);
				}

				// and update our mapping
				remove(workingSet);
			}
		}

		private void handleAdd(IWorkingSet workingSet) {
			synchronized (storeLock) {
				put(workingSet, workingSet.getName());
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;

/**
 * Protocol for the view controller for the project configurations pane of the working set configurations
 * dialog. It takes care of coordinating the user gestures in that pane with the working-set configuration
 * model and vice-versa.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public interface IWorkingSetProjectConfigurationController {
	/**
	 * Queries the project configuration in the Working Set Configurations pane that I control.
	 * 
	 * @return the new working set configuration selection. May be <code>null</code> if there is no selection
	 */
	IWorkingSetProjectConfiguration.ISnapshot getProjectConfiguration();

	/**
	 * Notifies me that the check state of some element that I control in the sub-tree of my
	 * {@linkplain #getProjectConfiguration() project configuration} has changed its check-state. The
	 * controller context can be used to pass back reactions such as to veto the check-state change or to
	 * signal that some level of UI refresh is required.
	 * 
	 * @param element
	 *            an element that has been checked or unchecked
	 * @param checked
	 *            whether the <tt>element</tt> is now checked
	 * @param context
	 *            the controller context, used to communicate vetos, refreshes, etc.
	 */
	void checkStateChanged(Object element, boolean checked, IControllerContext context);

	/**
	 * Computes the initial check-box settings for my tree according to the current state of my
	 * {@linkplain #getProjectConfiguration() project configuration}.
	 * 
	 * @param context
	 *            context in which I can set initial check-states of my elements
	 */
	void updateCheckState(IControllerContext context);

	/**
	 * Obtains a content provider for the structure rooted at my {@linkplain #getProjectConfiguration()
	 * project configuration}. Note that this method will only be called once, and that the caller takes
	 * responsibility for {@linkplain IContentProvider#dispose() disposing} the content provider.
	 * 
	 * @return my content provider
	 */
	ITreeContentProvider getContentProvider();

	/**
	 * Obtains a label provider for the structure rooted at my {@linkplain #getProjectConfiguration() project
	 * configuration}. Note that this method will only be called once, and that the caller takes
	 * responsibility for {@linkplain IBaseLabelProvider#dispose() disposing} the label provider.
	 * 
	 * @return my label provider
	 */
	ILabelProvider getLabelProvider();

	//
	// Nested types
	//

	/**
	 * An interface provided by the Manage Working Set Configurations dialog infrastructure to
	 * {@link IWorkingSetProjectConfigurationController}s for communication of state changes
	 * back to the UI.
	 * 
	 * @noimplement This interface is not intended to be implemented by clients.
	 * @noextend This interface is not intended to be extended by clients.
	 * 
	 * @author Christian W. Damus (damus)
	 * 
	 * @since 6.0
	 */
	interface IControllerContext {
		/**
		 * Queries whether the current working set configuration context is a read-only one. In such cases, I
		 * should probably disallow check-state changes and other editing.
		 * 
		 * @return whether the current working set configuration is read-only
		 * 
		 * @see IWorkingSetConfiguration.ISnapshot#isReadOnly()
		 */
		boolean isReadOnly();

		/**
		 * Sets the check state of an element in the Project Configurations pane under the authority of the
		 * controller. This is particularly useful for setting the
		 * {@linkplain IWorkingSetProjectConfigurationController#updateCheckState(IControllerContext) initial
		 * check state} of a controller and for
		 * {@linkplain IWorkingSetProjectConfigurationController#checkStateChanged(Object, boolean, IControllerContext)
		 * vetoing check state changes}.
		 * 
		 * @param element
		 *            the element to update checked
		 * @param checked
		 *            whether the element should be checked
		 * 
		 * @see IWorkingSetProjectConfigurationController#checkStateChanged(Object, boolean,
		 *      IControllerContext)
		 * @see IWorkingSetProjectConfigurationController#updateCheckState(IControllerContext)
		 */
		void setChecked(Object element, boolean checked);

		/**
		 * Requests an update of the visual appearance of the specified element. The element may be any
		 * element under my control, or even the {@link IWorkingSetConfiguration} or {@link IWorkingSetProxy}
		 * that owns my project configuration.
		 * 
		 * @param element
		 *            an element to update
		 */
		void update(Object element);

		/**
		 * Notifies that the specified project configuration's activation state has changed. That is, that it
		 * is now activated when previously it was not, or vice-versa.
		 * 
		 * @param project
		 *            configuration the project configuration that changed
		 */
		void activationStateChanged(IWorkingSetProjectConfiguration projectConfiguration);
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import static org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager.ATTR_NAME;
import static org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager.KEY_PROJECT;

import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkingSet;

import org.eclipse.cdt.ui.CUIPlugin;

/**
 * Default implementation of the {@link IWorkingSetConfiguration} interface.
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public class WorkingSetConfiguration implements IWorkingSetConfiguration {
	private final IWorkingSetProxy workingSet;
	private String name;

	private Map<String, IWorkingSetProjectConfiguration> projects;

	/**
	 * Initializes me with my parent working set.
	 * 
	 * @param workingSet
	 *            my parent working set
	 */
	protected WorkingSetConfiguration(IWorkingSetProxy workingSet) {
		this.workingSet = workingSet;
	}

	/**
	 * Obtains my parent working set.
	 * 
	 * @return my parent
	 */
	public IWorkingSetProxy getWorkingSet() {
		return workingSet;
	}

	/**
	 * Obtains my name.
	 * 
	 * @return my name
	 */
	public String getName() {
		return name;
	}

	/**
	 * Sets my name.
	 * 
	 * @param name
	 *            my new name
	 * 
	 * @throws IllegalArgumentException
	 *             if the specified name is <code>null</code> or empty, or if it is already used by another
	 *             configuration in my warking set
	 */
	void setName(String name) {
		if ((name == null) || (name.length() == 0)) {
			throw new IllegalArgumentException("name is empty"); //$NON-NLS-1$
		}

		if (!name.equals(getName())) {
			if (getWorkingSet().getConfiguration(name) != null) {
				throw new IllegalArgumentException("name is already in use"); //$NON-NLS-1$
			}

			basicSetName(name);
		}
	}

	/**
	 * Provides simple access to the name for setting it.
	 * 
	 * @param name
	 *            my new name
	 */
	protected void basicSetName(String name) {
		this.name = name;
	}

	private Map<String, IWorkingSetProjectConfiguration> getProjects() {
		if (projects == null) {
			projects = new java.util.HashMap<String, IWorkingSetProjectConfiguration>();

			for (IProject next : workingSet.resolveProjects()) {
				IWorkingSetProjectConfiguration child = createProjectConfiguration(next);

				// the project may not be a C/C++ project
				if (child != null) {
					basicAddProjectConfiguration(child);
				}
			}
		}

		return projects;
	}

	protected void basicAddProjectConfiguration(IWorkingSetProjectConfiguration projectConfig) {
		if (projects == null) {
			projects = new java.util.HashMap<String, IWorkingSetProjectConfiguration>();
		}
		
		projects.put(projectConfig.getProjectName(), projectConfig);
	}

	public IWorkingSetProjectConfiguration getProjectConfiguration(String projectName) {
		return getProjects().get(projectName);
	}

	public java.util.Collection<IWorkingSetProjectConfiguration> getProjectConfigurations() {
		return getProjects().values();
	}

	public boolean isActive() {
		boolean result = !getProjects().isEmpty();

		if (result) {
			for (IWorkingSetProjectConfiguration next : getProjectConfigurations()) {
				if (!next.isActive()) {
					result = false;
					break;
				}
			}
		}

		return result;
	}

	public void activate() {
		if (!isActive()) {
			for (IWorkingSetProjectConfiguration next : getProjectConfigurations()) {
				next.activate();
			}
		}

		// this is a "recently used" working set
		IWorkingSet ws = getWorkingSet().resolve();
		if (ws != null) {
			WorkingSetConfigurationManager.WS_MGR.addRecentWorkingSet(ws);
		}
	}

	public IStatus build(IProgressMonitor monitor) {
		MultiStatus result = new MultiStatus(CUIPlugin.PLUGIN_ID, 0,
				WorkingSetMessages.WSConfig_build_problems, null);

		List<IWorkingSetProjectConfiguration> toBuild = new java.util.ArrayList<IWorkingSetProjectConfiguration>(
				getProjectConfigurations().size());
		for (IWorkingSetProjectConfiguration next : getProjectConfigurations()) {
			IProject project = next.resolveProject();

			if ((project != null) && (project.isAccessible())) {
				toBuild.add(next);
			}
		}

		SubMonitor progress = SubMonitor.convert(monitor, NLS.bind(WorkingSetMessages.WSConfig_build_task,
				getWorkingSet().getName()), toBuild.size());

		try {
			for (IWorkingSetProjectConfiguration next : toBuild) {
				if (progress.isCanceled()) {
					result.add(Status.CANCEL_STATUS);
					break;
				}

				IStatus status = next.build(progress.newChild(1));

				if ((status != null && !status.isOK())) {
					result.add(status);
				}
			}
		} finally {
			if (monitor != null) {
				monitor.done();
			}
		}

		return result.isOK() ? Status.OK_STATUS : result;
	}

	public void saveState(IMemento memento) {
		memento.putString(ATTR_NAME, getName());

		for (IWorkingSetProjectConfiguration next : getProjectConfigurations()) {
			next.saveState(memento.createChild(KEY_PROJECT));
		}
	}

	public void loadState(IMemento memento) {
		setName(memento.getString(ATTR_NAME));

		Map<String, IMemento> projectMementos = new java.util.HashMap<String, IMemento>();
		for (IMemento next : memento.getChildren(KEY_PROJECT)) {
			projectMementos.put(next.getString(ATTR_NAME), next);
		}

		for (IWorkingSetProjectConfiguration next : getProjectConfigurations()) {
			IMemento state = projectMementos.get(next.getProjectName());
			if (state != null) {
				next.loadState(state);
			}
		}
	}

	/**
	 * Creates a new project configuration for the specified project. May be overridden by subclasses to
	 * create a different implementation.
	 * 
	 * @param project
	 *            a workspace project
	 * @return a new project configuration element for it
	 */
	protected IWorkingSetProjectConfiguration createProjectConfiguration(IProject project) {
		IWorkingSetProjectConfiguration result = null;

		IWorkingSetProjectConfigurationFactory factory = IWorkingSetProjectConfigurationFactory.Registry.INSTANCE
				.getFactory(project);
		if (factory != null) {
			result = factory.createProjectConfiguration(this, project);
		}

		return result;
	}

	public ISnapshot createSnapshot(IWorkingSetProxy.ISnapshot workingSet, WorkspaceSnapshot workspace) {

		return new Snapshot(workingSet, this, workspace);
	}

	/**
	 * Utility method to query whether the specified configuration is a read-only snapshot.
	 * 
	 * @param config
	 *            a working set configuration
	 * @return whether it is a read-only snapshot
	 * 
	 * @see IWorkingSetConfiguration.ISnapshot#isReadOnly()
	 */
	static boolean isReadOnly(IWorkingSetConfiguration config) {
		return (config instanceof WorkingSetConfiguration.Snapshot)
				&& ((WorkingSetConfiguration.Snapshot) config).isReadOnly();
	}

	//
	// Nested classes
	//

	/**
	 * Default implementation of the mutable working set configuration snapshot.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @noextend This class is not intended to be subclassed by clients.
	 * 
	 * @since 6.0
	 */
	public static class Snapshot extends WorkingSetConfiguration implements
			IWorkingSetConfiguration.ISnapshot {

		private final boolean readOnly;
		private final WorkspaceSnapshot workspace;

		/**
		 * Initializes me with the current workspace snapshot.
		 * 
		 * @param workingSet
		 *            my parent working set
		 * @param workspace
		 *            the current workspace snapshot
		 */
		protected Snapshot(IWorkingSetProxy workingSet, WorkspaceSnapshot workspace) {
			this(workingSet, workspace, false);
		}

		/**
		 * Initializes me as a special read-only configuration that shows what is the current active
		 * configuration of the projects in a working set when none of its named configurations is active.
		 * 
		 * @param workingSet
		 *            my parent working set
		 * @param workspace
		 *            the current workspace snapshot
		 * @param readOnly
		 *            whether I am read-only. A read-only configuration cannot be modified in the dialog
		 */
		protected Snapshot(IWorkingSetProxy workingSet, WorkspaceSnapshot workspace, boolean readOnly) {
			super(workingSet);

			this.readOnly = readOnly;
			this.workspace = workspace;
		}

		/**
		 * Initializes me with the current workspace snapshot.
		 * 
		 * @param workingSet
		 *            my parent working set
		 * @param config
		 *            the working set configuration that I copy
		 * @param workspace
		 *            the current workspace snapshot
		 */
		protected Snapshot(IWorkingSetProxy workingSet, IWorkingSetConfiguration config,
				WorkspaceSnapshot workspace) {
			this(workingSet, workspace);

			setName(config.getName());

			for (IWorkingSetProjectConfiguration next : config.getProjectConfigurations()) {
				basicAddProjectConfiguration(next.createSnapshot(this, workspace));
			}
		}

		@Override
		public final IWorkingSetProxy.ISnapshot getWorkingSet() {
			return (IWorkingSetProxy.ISnapshot) super.getWorkingSet();
		}

		/**
		 * Queries whether I am a read-only view of the current active configurations of my working set's
		 * projects.
		 * 
		 * @return whether I am read-only
		 */
		public final boolean isReadOnly() {
			return readOnly;
		}

		@Override
		public void setName(String name) {
			super.setName(name);
		}

		/**
		 * I create project configurations that are mutable, as I am.
		 */
		@Override
		protected IWorkingSetProjectConfiguration createProjectConfiguration(IProject project) {
			IWorkingSetProjectConfiguration result = null;

			IWorkingSetProjectConfigurationFactory factory = IWorkingSetProjectConfigurationFactory.Registry.INSTANCE
					.getFactory(project);
			if (factory != null) {
				result = factory.createProjectConfiguration(this, project).createSnapshot(this, workspace);
			}

			return result;
		}
	}
}




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.cdt.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.cdt.ui" id="workingSetConfigurations" name="Working Set Configurations"/>
      </appInfo>
      <documentation>
         &lt;p&gt;
&lt;b&gt;This extension point is internal to the CDT plug-in family.&lt;/b&gt;
&lt;/p&gt;&lt;p&gt;
Extension point for registration of project configuration factories for handling extended configuration options for custom project natures, in working set configurations.  These factories are responsible for creating the project configuration elements and the UI controllers for the Manage Working Set Configurations dialog.
&lt;/p&gt;
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="projectConfigurationFactory"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="projectConfigurationFactory">
      <annotation>
         <documentation>
            Registration of a factory for project configuration elements in working set configurations.  Factories are registered against project natures via nested &lt;tt&gt;&amp;lt;nature&amp;gt;&lt;/tt&gt; elements.
         </documentation>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="projectNature"/>
         </sequence>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  A unique identifier for the project configuration factory.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  Fully qualified name of the factory class.  It must implement the &lt;tt&gt;IWorkingSetProjectConfigurationFactory&lt;/tt&gt; interface.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfigurationFactory"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="projectNature">
      <annotation>
         <documentation>
            A reference to a project nature.
         </documentation>
      </annotation>
      <complexType>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  The referenced project nature ID.
               </documentation>
               <appInfo>
                  <meta.attribute kind="identifier" basedOn="org.eclipse.core.resources.natures/@id"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         6.0
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         &lt;pre&gt;
&lt;extension point=&quot;org.eclipse.cdt.ui.workingSetConfigurations&quot;&gt;
  &lt;projectConfigurationFactory
        id=&quot;org.example.myProject&quot;
        class=&quot;org.example.MyProjectConfigurationFactory&quot;&gt;
    &lt;nature id=&quot;org.example.myProjectNature&quot;/&gt;
  &lt;/projectConfigurationFactory&gt;
&lt;/extension&gt;
&lt;/pre&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiinfo"/>
      </appInfo>
      <documentation>
         Registered project configuration factories are required to implement the &lt;tt&gt;org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfigurationFactory&lt;/tt&gt; interface.
      </documentation>
   </annotation>


   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2009 QNX Software Systems and others.  All rights reserved.
      </documentation>
   </annotation>

</schema>




/*******************************************************************************
 * Copyright (c) 2008, 2009 Intel Corporation, QNX Software Systems, 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:
 *     Intel Corporation - initial API and implementation
 *     QNX Software Systems - [272416] Rework the working set configurations
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.newui.UIMessages;

/**
 * A job that builds a bunch of workspace projects or a working set configuration.
 */
public final class BuildJob extends Job {
	private Collection<IProject> projects;
	private IWorkingSetConfiguration workingSetConfig;

	/**
	 * Initializes me with a bunch projects to build in their active configurations.
	 * 
	 * @param projects
	 *            the projects to build
	 */
	public BuildJob(Collection<IProject> projects) {
		super(UIMessages.getString("WorkingSetConfigAction.21")); //$NON-NLS-1$
		this.projects = new java.util.ArrayList<IProject>(projects);
	}

	/**
	 * Initializes me with a working set configuration to build.
	 * 
	 * @param workingSetConfig
	 *            the working set configuration to build
	 */
	public BuildJob(IWorkingSetConfiguration workingSetConfig) {
		super(UIMessages.getString("WorkingSetConfigAction.21")); //$NON-NLS-1$
		this.workingSetConfig = workingSetConfig;
	}

	@Override
	protected IStatus run(IProgressMonitor monitor) {
		if (projects != null) {
			return buildProjects(monitor);
		} else {
			return buildWorkingSetConfig(monitor);
		}
	}

	private IStatus buildProjects(IProgressMonitor monitor) {
		try {
			for (IProject p : projects) {
				try {
					setName(UIMessages.getString("WorkingSetConfigAction.21") + p.getName()); //$NON-NLS-1$
					p.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
				} catch (CoreException e) {
					return new MultiStatus(CUIPlugin.PLUGIN_ID, 0, new IStatus[] { e.getStatus() },
							UIMessages.getString("WorkingSetConfigAction.22"), //$NON-NLS-1$
							null);
				}
				if (monitor.isCanceled()) {
					return Status.CANCEL_STATUS;
				}
			}
		} finally {
			monitor.done();
		}
		return Status.OK_STATUS;
	}

	private IStatus buildWorkingSetConfig(IProgressMonitor monitor) {
		try {
			return workingSetConfig.build(monitor);
		} finally {
			monitor.done();
		}
	}

	@Override
	public boolean belongsTo(Object family) {
		return ResourcesPlugin.FAMILY_MANUAL_BUILD == family;
	}

}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.TrayDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.resource.FontDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;
import org.eclipse.jface.resource.ResourceManager;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.IFontProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.window.IShellProvider;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.AccessibleAdapter;
import org.eclipse.swt.accessibility.AccessibleEvent;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.model.WorkbenchLabelProvider;

import org.eclipse.cdt.internal.ui.CPluginImages;
import org.eclipse.cdt.internal.ui.dialogs.OptionalMessageDialog;

/**
 * A dialog for management of working set configurations. These collect the selection of project
 * configurations for the member projects of the working sets into named presets.
 * 
 * @author Christian W. Damus (cdamus)
 */
public class WorkingSetConfigurationDialog extends TrayDialog {

	private static final String BUILD_PROMPT_DIALOG_ID = "workingsets.build.prompt"; //$NON-NLS-1$
	private static final int BUILD_PROMPT_DIALOG_NO = 0;
	private static final int BUILD_PROMPT_DIALOG_CANCEL = 1;
	private static final int BUILD_PROMPT_DIALOG_YES = 2;

	private WorkspaceSnapshot workspace;
	private WorkingSetConfigsController controller;

	/**
	 * Initializes me with my shell.
	 * 
	 * @param shell
	 */
	public WorkingSetConfigurationDialog(Shell shell) {
		super(shell);
	}

	/**
	 * Initializes me with my shell provider.
	 * 
	 * @param parentShell
	 */
	public WorkingSetConfigurationDialog(IShellProvider parentShell) {
		super(parentShell);
	}

	@Override
	protected boolean isResizable() {
		return true;
	}

	@Override
	protected void configureShell(Shell newShell) {
		setHelpAvailable(false);

		super.configureShell(newShell);

		newShell.setText(WorkingSetMessages.WSConfigDialog_title);
	}

	@Override
	protected Control createDialogArea(Composite parent) {
		Composite result = (Composite) super.createDialogArea(parent);

		SashForm sashForm = new SashForm(result, SWT.VERTICAL | SWT.SMOOTH);
		sashForm.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

		GridLayoutFactory layoutFactory = GridLayoutFactory.fillDefaults();
		createWorkingSetConfigsArea(sashForm, layoutFactory.extendedMargins(0, 0, 0,
				convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN)));
		createProjectConfigsArea(sashForm, layoutFactory.extendedMargins(0, 0,
				convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN), 0));

		sashForm.setWeights(new int[] { 1, 1 });

		return result;
	}

	/**
	 * Creates the "working set configurations" pane in the upper part of the sash form.
	 * 
	 * @param parent
	 *            the parent composite
	 * @param layoutFactory
	 *            a layout-factory to use to lay out the composite in a grid, possibly pre-configured. Its use
	 *            is optional
	 * 
	 * @return the working set configurations pane
	 */
	protected Composite createWorkingSetConfigsArea(Composite parent, GridLayoutFactory layoutFactory) {
		Composite result = new Composite(parent, SWT.NONE);
		layoutFactory.numColumns(2).applyTo(result);

		GridDataFactory layoutDataFactory = GridDataFactory.fillDefaults();

		Label label = new Label(result, SWT.NONE);
		label.setText(WorkingSetMessages.WSConfigDialog_wsTree_label);
		layoutDataFactory.span(2, 1).applyTo(label);

		workspace = WorkingSetConfigurationManager.getDefault().createWorkspaceSnapshot();
		controller = new WorkingSetConfigsController(workspace);

		TreeViewer tree = new TreeViewer(result);
		layoutDataFactory.span(1, 1).align(SWT.FILL, SWT.FILL).grab(true, true).hint(250, SWT.DEFAULT)
				.applyTo(tree.getControl());

		tree.setContentProvider(new WSConfigsContentProvider());
		tree.setLabelProvider(new WSConfigsLabelProvider(tree));
		controller.setTreeViewer(tree);

		tree.setComparator(new ViewerComparator() {
			@Override
			public int category(Object element) {
				if (element instanceof IWorkingSetConfiguration.ISnapshot) {
					IWorkingSetConfiguration.ISnapshot config = (IWorkingSetConfiguration.ISnapshot) element;
					if (config.isReadOnly()) {
						return 0;
					}
				}
				return 1;
			}
		});

		tree.getTree().getAccessible().addAccessibleListener(new AccessibleAdapter() {
			@Override
			public void getName(AccessibleEvent e) {
				e.result = WorkingSetMessages.WSConfigDialog_wsTree_accessible_name;
			}
		});

		Composite buttons = new Composite(result, SWT.NONE);
		layoutDataFactory.grab(false, false).hint(SWT.DEFAULT, SWT.DEFAULT).applyTo(buttons);
		layoutFactory.numColumns(1).extendedMargins(0, 0, 0, 0).applyTo(buttons);

		Button button = new Button(buttons, SWT.PUSH);
		layoutDataFactory.align(SWT.FILL, SWT.BEGINNING).applyTo(button);
		button.setText(WorkingSetMessages.WSConfigDialog_add_label);
		controller.setAddButton(button);

		button = new Button(buttons, SWT.PUSH);
		layoutDataFactory.applyTo(button);
		button.setText(WorkingSetMessages.WSConfigDialog_remove_label);
		controller.setRemoveButton(button);

		button = new Button(buttons, SWT.PUSH);
		layoutDataFactory.applyTo(button);
		button.setText(WorkingSetMessages.WSConfigDialog_rename_label);
		controller.setRenameButton(button);

		button = new Button(buttons, SWT.PUSH);
		layoutDataFactory.applyTo(button);
		button.setText(WorkingSetMessages.WSConfigDialog_activate_label);
		controller.setActivateButton(button);

		return result;
	}

	/**
	 * Creates the "project configurations" pane in the lower part of the sash form.
	 * 
	 * @param parent
	 *            the parent composite
	 * @param layoutFactory
	 *            a layout-factory to use to lay out the composite in a grid, possibly pre-configured. Its use
	 *            is optional
	 * 
	 * @return the project configurations pane
	 */
	protected Composite createProjectConfigsArea(Composite parent, GridLayoutFactory layoutFactory) {
		Composite result = new Composite(parent, SWT.NONE);
		layoutFactory.numColumns(1).applyTo(result);

		GridDataFactory layoutDataFactory = GridDataFactory.fillDefaults();

		Label label = new Label(result, SWT.NONE);
		label.setText(WorkingSetMessages.WSConfigDialog_projTree_label);
		layoutDataFactory.applyTo(label);

		ProjectConfigsController projectsController = new ProjectConfigsController();
		CheckboxTreeViewer tree = new CheckboxTreeViewer(result);
		layoutDataFactory.span(1, 1).align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(tree.getControl());

		controller.setProjectConfigsController(projectsController);
		projectsController.setWorkingSetConfigurationsController(controller);

		projectsController.setTreeViewer(tree);

		tree.setComparator(new ViewerComparator());

		tree.getTree().getAccessible().addAccessibleListener(new AccessibleAdapter() {
			@Override
			public void getName(AccessibleEvent e) {
				e.result = WorkingSetMessages.WSConfigDialog_projTree_accessible_name;
			}
		});

		return result;
	}

	@Override
	protected void buttonPressed(int buttonId) {
		if (buttonId == IDialogConstants.OK_ID) {
			if (!build()) {
				// user cancelled: don't save, and don't close the dialog
				return;
			}

			save();
		}

		super.buttonPressed(buttonId);
	}

	/**
	 * Saves the working set configurations to storage.
	 */
	protected void save() {
		workspace.save();
	}

	/**
	 * Builds the projects that were reconfigured by the dialog, if any. The user is prompted (if prompting is
	 * not disabled via the preference) before building. The user has the options to build, not build, or
	 * cancel. The result indicates cancellation.
	 * 
	 * @return <code>true</code> if the user opted to save changes and exit the dialog (with or without
	 *         build); <code>false</code> if the user cancelled and the dialog should remain open and unsaved
	 */
	protected boolean build() {
		boolean result = true;
		Collection<IProject> projects = workspace.getProjectsToBuild();

		if (!projects.isEmpty()) {
			int defaultButton = OptionalMessageDialog.getDialogDetail(BUILD_PROMPT_DIALOG_ID);
			if (defaultButton == OptionalMessageDialog.NO_DETAIL) {
				defaultButton = BUILD_PROMPT_DIALOG_YES; // yes button is the default-default
			}

			int button = OptionalMessageDialog.open(BUILD_PROMPT_DIALOG_ID, getShell(),
					WorkingSetMessages.WSConfigDialog_buildPrompt_title, null,
					WorkingSetMessages.WSConfigDialog_buildPrompt_message, MessageDialog.QUESTION,
					new String[] { IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL,
							IDialogConstants.YES_LABEL }, defaultButton);

			if (button == OptionalMessageDialog.NOT_SHOWN) {
				// handle the case where the dialog was suppressed. Get the current default
				button = defaultButton;
			} else if (button != BUILD_PROMPT_DIALOG_CANCEL) {
				// store non-cancel selection as the new default answer
				OptionalMessageDialog.setDialogDetail(BUILD_PROMPT_DIALOG_ID, button);
			}

			switch (button) {
			case BUILD_PROMPT_DIALOG_YES:
				// do the build
				new BuildJob(projects).schedule();
				break;
			case BUILD_PROMPT_DIALOG_NO:
				// just don't build
				break;
			default: // BUILD_PROMPT_DIALOG_CANCEL
				result = false;
				break;
			}
		}

		return result;
	}

	//
	// Nested classes
	//

	/**
	 * Simple content provider for the working set configurations tree.
	 * 
	 * @author Christian W. Damus (cdamus)
	 */
	private static class WSConfigsContentProvider implements ITreeContentProvider {
		private Collection<IWorkingSetProxy> workingSets;

		public Object[] getChildren(Object parentElement) {
			if (parentElement == workingSets) {
				return workingSets.toArray();
			} else if (parentElement instanceof IWorkingSetProxy) {
				return ((IWorkingSetProxy) parentElement).getConfigurations().toArray();
			} else {
				return new Object[0];
			}
		}

		public Object getParent(Object element) {
			return (element instanceof IWorkingSetConfiguration) ? ((IWorkingSetConfiguration) element)
					.getWorkingSet() : null;
		}

		public boolean hasChildren(Object element) {
			return (element != null) && !(element instanceof IWorkingSetConfiguration);
		}

		public Object[] getElements(Object inputElement) {
			return getChildren(inputElement);
		}

		public void dispose() {
			// nothing to dispose
		}

		@SuppressWarnings("unchecked")
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			workingSets = (Collection<IWorkingSetProxy>) newInput;
		}

	}

	/**
	 * Label provider for working sets and their configurations. The active configuration is highlighted in
	 * bold and affixed with an "(active)" decoration. The special read-only configuration is further
	 * differentiated with an italic font.
	 * 
	 * @author Christian W. Damus (cdamus)
	 */
	private static class WSConfigsLabelProvider extends LabelProvider implements IFontProvider {
		private WorkbenchLabelProvider wbLabels = new WorkbenchLabelProvider();
		private Image configImage = CPluginImages.get(CPluginImages.IMG_OBJS_CONFIG);
		private Font defaultFont;

		private ResourceManager fonts = new LocalResourceManager(JFaceResources.getResources());

		WSConfigsLabelProvider(Viewer viewer) {
			defaultFont = viewer.getControl().getFont();
		}

		@Override
		public String getText(Object element) {
			if (element instanceof IWorkingSetConfiguration) {
				IWorkingSetConfiguration config = (IWorkingSetConfiguration) element;

				if (config.isActive()) {
					return WorkingSetConfiguration.isReadOnly(config)
							? WorkingSetMessages.WSConfigDialog_implicit_config : NLS.bind(
									WorkingSetMessages.WSConfigDialog_active_config, config.getName());
				}
				return config.getName();
			} else if (element instanceof IWorkingSetProxy) {
				return ((IWorkingSetProxy) element).resolve().getLabel();
			}

			return wbLabels.getText(element);
		}

		@Override
		public Image getImage(Object element) {
			if (element instanceof IWorkingSetConfiguration) {
				return configImage;
			} else if (element instanceof IWorkingSetProxy) {
				return wbLabels.getImage(((IWorkingSetProxy) element).resolve());
			}

			return wbLabels.getImage(element);
		}

		@Override
		public void dispose() {
			wbLabels.dispose();
			fonts.dispose();
			super.dispose();
		}

		public Font getFont(Object element) {
			if (element instanceof IWorkingSetConfiguration) {
				IWorkingSetConfiguration config = (IWorkingSetConfiguration) element;
				if (config.isActive()) {
					FontDescriptor desc = FontDescriptor.createFrom(defaultFont);

					desc = WorkingSetConfiguration.isReadOnly(config) ? desc.withStyle(SWT.BOLD | SWT.ITALIC)
							: desc.withStyle(SWT.BOLD);
					return (Font) fonts.get(desc);
				}
			}

			return wbLabels.getFont(element);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.ui.IWorkingSet;

/**
 * The protocol for elements representing working sets, providing proxies for the workbench's actual
 * {@link IWorkingSet}s. A working set may have zero or more {@linkplain IWorkingSetConfiguration
 * configurations} that aggregate configuration settings for the C/C++ projects in the working set.
 * 
 * @noimplement This interface is not intended to be implemented by clients.
 * @noextend This interface is not intended to be extended by clients.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public interface IWorkingSetProxy extends IWorkingSetConfigurationElement {
	/**
	 * Queries my name. This is the {@link IWorkingSet#getName() name} of my referenced working set, not its
	 * {@link IWorkingSet#getLabel() label}. As my referenced working set's name changes, so does my name.
	 * 
	 * @return my working set's name
	 */
	String getName();

	/**
	 * Resolves me to the actual working set as maintained by the workbench.
	 * 
	 * @return my referenced working set, or <code>null</code> if it no longer exists
	 */
	IWorkingSet resolve();

	/**
	 * Resolves the actual existing projects in my working set, that are currently
	 * {@linkplain IResource#isAccessible() accessible} in the workspace.
	 * 
	 * @return my projects
	 */
	Collection<IProject> resolveProjects();

	/**
	 * Queries whether I am a valid working set proxy, to be displayed to and manipulated by the user. This
	 * should at least check that the proxy {@linkplain #resolve() resolves} to an existing working set and
	 * that it includes at least one {@linkplain #resolveProjects() project}.
	 * 
	 * @return whether I am a valid working set proxy
	 */
	boolean isValid();

	/**
	 * Obtains the named configuration of my working set.
	 * 
	 * @param name
	 *            a configuration name
	 * 
	 * @return the matching configuration, or <code>null</code> if there is none such
	 */
	IWorkingSetConfiguration getConfiguration(String name);

	/**
	 * Obtains all of the configurations currently defined for my working set. If I am a working-copy
	 * {@linkplain IWorkingSetProxy.ISnapshot snapshot}, then these may include a special
	 * {@linkplain IWorkingSetConfiguration.ISnapshot#isReadOnly() read-only} configuration indicating the
	 * active configurations of my projects, if none of my named configurations is
	 * {@linkplain IWorkingSetConfiguration#isActive() active}.
	 * 
	 * @return my configurations
	 */
	Collection<IWorkingSetConfiguration> getConfigurations();

	/**
	 * Creates a <i>snapshot</i> (also known as a "working copy") of myself, providing a mutable view suitable
	 * for editing.
	 * 
	 * @param workspace
	 *            a workspace snapshot that captures the baseline state of the workspace and the working set
	 *            configurations that are to be edited
	 * 
	 * @return a working-copy snapshot of myself
	 */
	ISnapshot createSnapshot(WorkspaceSnapshot workspace);

	//
	// Nested types
	//

	/**
	 * The snapshot ("working copy") view of a working set proxy. It has additional API for modifying
	 * configurations, which can then be {@linkplain WorkspaceSnapshot#save() saved} for posterity.
	 * 
	 * @noimplement This interface is not intended to be implemented by clients.
	 * @noextend This interface is not intended to be extended by clients.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @since 6.0
	 */
	interface ISnapshot extends IWorkingSetProxy {
		/**
		 * Creates a new configuration with the specified name.
		 * 
		 * @param name
		 *            a new configuration name
		 * 
		 * @return the new configuration
		 * 
		 * @throws IllegalArgumentException
		 *             if the new name is <code>null</code> or empty, or if it is already used by another
		 *             configuration of the same working set
		 */
		IWorkingSetConfiguration.ISnapshot createConfiguration(String name);

		/**
		 * Removes the specified configuration from me.
		 * 
		 * @param config
		 *            a configuration to remove
		 * 
		 * @throws IllegalArgumentException
		 *             if the configuration to be removed is
		 *             {@linkplain IWorkingSetConfiguration.ISnapshot#isReadOnly() read-only}
		 */
		void removeConfiguration(IWorkingSetConfiguration config);

		/**
		 * <p>
		 * Updates me according to the (assumed to have changed) activation state of my configurations. If any
		 * named configurations are active and I currently have a "fake"
		 * {@linkplain IWorkingSetConfiguration.ISnapshot#isReadOnly() read-only} configuration, then it is
		 * removed and I signal a "major change."
		 * </p>
		 * <p>
		 * If I have no named configurations that are active, and currently have not got a read-only
		 * configuration to show the active configuration, then I create it and signal a "major change."
		 * </p>
		 * <p>
		 * It is assumed that the UI will refresh the tree structure rooted in me when I signal a major
		 * change.
		 * </p>
		 * 
		 * @return whether this update results in a "major change" to my child configuration structure
		 */
		boolean updateActiveConfigurations();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPersistable;

/**
 * The protocol for elements of the working-set configuration model, which can
 * be persisted via {@linkplain IMemento mementos}.
 *
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public interface IWorkingSetConfigurationElement extends IPersistable {
	/**
	 * Loads me from the specified memento.
	 * 
	 * @param memento
	 *            a memento in which I am persisted
	 */
	void loadState(IMemento memento);
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.ui.actions;

import java.util.Collection;
import java.util.List;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.actions.CompoundContributionItem;

import org.eclipse.cdt.ui.CUIPlugin;

import org.eclipse.cdt.internal.ui.workingsets.BuildJob;
import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetConfiguration;
import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProxy;
import org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager;

/**
 * A dynamic contribution of sub-menus to build configurations of working sets.
 *
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 */
public class BuildWorkingSetConfigsContribution extends CompoundContributionItem {

	private IWorkingSetManager workingSetManager;

	/**
	 * Initializes me.
	 */
	public BuildWorkingSetConfigsContribution() {
		super();
	}

	/**
	 * Initializes me with my identifier.
	 *
	 * @param id my identifier
	 */
	public BuildWorkingSetConfigsContribution(String id) {
		super(id);
	}

	@Override
	protected IContributionItem[] getContributionItems() {
		// at most 5 recent working sets
		List<IContributionItem> result = new java.util.ArrayList<IContributionItem>(5);
		
		for (IWorkingSet recent : getWorkingsetManager().getRecentWorkingSets()) {
			IWorkingSetProxy proxy = WorkingSetConfigurationManager.getDefault().getWorkingSet(recent.getName());
			
			if (proxy != null) {
				result.add(createMenu(proxy));
			}
		}
		
		return result.toArray(new IContributionItem[result.size()]);
	}
	
	private IWorkingSetManager getWorkingsetManager() {
		if (workingSetManager == null) {
			workingSetManager = CUIPlugin.getDefault().getWorkbench().getWorkingSetManager();
		}
		
		return workingSetManager;
	}
	
	private IContributionItem createMenu(IWorkingSetProxy workingSet) {
		IContributionItem result;
		Collection<IWorkingSetConfiguration> configs = workingSet.getConfigurations();
		
		if (configs.isEmpty()) {
			result = new ActionContributionItem(new BuildWorkingSetAction(workingSet));
		} else {
			MenuManager submenu = new MenuManager(workingSet.resolve().getLabel());
			result = submenu;
			
			for (IWorkingSetConfiguration next : configs) {
				submenu.add(new BuildConfigAction(next));
			}
		}
		
		return result;
	}

	//
	// Nested classes
	//

	private static class BuildWorkingSetAction extends Action {
		private IWorkingSetProxy workingSet;

		BuildWorkingSetAction(IWorkingSetProxy workingSet) {
			super(workingSet.resolve().getLabel());
			
			this.workingSet = workingSet;
		}

		@Override
		public void run() {
			new BuildJob(workingSet.resolveProjects()).schedule();
		}
	}

	private static class BuildConfigAction extends Action {
		private IWorkingSetConfiguration workingSetConfig;

		BuildConfigAction(IWorkingSetConfiguration workingSetConfig) {
			super(workingSetConfig.getName());
			
			this.workingSetConfig = workingSetConfig;
		}

		@Override
		public void run() {
			new BuildJob(workingSetConfig).schedule();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Collection;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;

import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;

/**
 * <p>
 * The protocol for working set configurations. A working set configuration specifies, at a minimum, a
 * {@linkplain ICConfigurationDescription build configuration} for each C/C++ project in the working set.
 * {@linkplain #activate() activating} the configuration applies these build configurations to the respective
 * projects as their active build configurations.
 * </p>
 * <p>
 * Implementations of this interface may choose to manage more configuration settings than are captured by the
 * active build configuration. They are, then, responsible for persistence, editing, and application of these
 * settings.
 * </p>
 * <p>
 * A working set configuration is considered to be {@linkplain #isActive() active} if all of the projects in
 * the working set are configured to build according to the configuration specified by the working set
 * configuration. It is an implementation detail (i.e., unspecified) what it means for a working set that has
 * recorded settings for projects that are not currently {@linkplain IResource#isAccessible() accessible} in
 * the workspace. However, for projects that are accessible and are included in the working set, but for which
 * the working set configuration has no settings, such projects are implicitly in the working set
 * configuration and it specifies their current configuration settings. Thus, in the extreme case, a
 * working-set configuration that includes none of the projects that currently are members of the working set,
 * is active.
 * </p>
 * 
 * @noimplement This interface is not intended to be implemented by clients.
 * @noextend This interface is not intended to be extended by clients.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 */
public interface IWorkingSetConfiguration extends IWorkingSetConfigurationElement {
	/**
	 * Obtains the working set element that contains me.
	 * 
	 * @return my working set
	 */
	IWorkingSetProxy getWorkingSet();

	/**
	 * Queries my name.
	 * 
	 * @return my name
	 */
	String getName();

	/**
	 * Obtains the project configuration element for the specified project.
	 * 
	 * @param projectName
	 *            a project name
	 * 
	 * @return that project's configuration element
	 * 
	 * @throws IllegalArgumentException
	 *             if the specified project is not a member of my working set
	 * 
	 * @see #getProjectConfigurations()
	 */
	IWorkingSetProjectConfiguration getProjectConfiguration(String projectName);

	/**
	 * Obtains the configuration elements for all of the projects in my working set. These include any
	 * projects that were not in my working set when I was last updated, and does not include any projects
	 * that were in my working set when I was last updated but that no longer are.
	 * 
	 * @return my project configuration elements
	 */
	Collection<IWorkingSetProjectConfiguration> getProjectConfigurations();

	/**
	 * Queries whether I am currently active in the workspace. I am active if and only if for every the
	 * projects in my working set, its active configuration is the one that I specify for it. As a special
	 * case, the configurations of an empty working set can never be active.
	 * 
	 * @return whether I am currently active in the workspace
	 * 
	 * @see #activate()
	 */
	boolean isActive();

	/**
	 * Updates the workspace to set, for each project in my working set, the active configuration that I
	 * specify for it. This method has no effect if I am already active.
	 * 
	 * @see #isActive()
	 */
	void activate();

	/**
	 * Builds my project configurations in the workspace.
	 * 
	 * @param monitor
	 *            for reporting progress of the working-set build
	 * @return the aggregate status of the individual
	 *         {@linkplain IWorkingSetProjectConfiguration#build(IProgressMonitor) project builds}
	 */
	IStatus build(IProgressMonitor monitor);

	/**
	 * Creates a <i>snapshot</i> (also known as a "working copy") of myself, providing a mutable view suitable
	 * for editing.
	 * 
	 * @param workingSet
	 *            my parent working set snapshot
	 * @param workspace
	 *            a workspace snapshot that captures the baseline state of the workspace and the working set
	 *            configurations that are to be edited
	 * 
	 * @return a working-copy snapshot of myself
	 */
	ISnapshot createSnapshot(IWorkingSetProxy.ISnapshot workingSet, WorkspaceSnapshot workspace);

	//
	// Nested types
	//

	/**
	 * The snapshot ("working copy") view of a working set configuration. It defines additional API for the
	 * manipulation of working set configurations.
	 * 
	 * @noimplement This interface is not intended to be implemented by clients.
	 * @noextend This interface is not intended to be extended by clients.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @since 6.0
	 */
	interface ISnapshot extends IWorkingSetConfiguration {
		IWorkingSetProxy.ISnapshot getWorkingSet();

		/**
		 * <p>
		 * Queries whether I am read-only. Read-only working set configurations are used for the special case
		 * of showing what is the active configuration of the projects in a working set when none of the named
		 * working set configurations is active. Thus, a working set that has no user-defined named
		 * configurations does, at least, have its read-only active configuration.
		 * </p>
		 * <p>
		 * A working set only ever has at most one read-only configuration, though it may have multiple active
		 * configurations if some of its configurations are equivalent.
		 * </p>
		 * 
		 * @return whether I am the read-only active configuration of my working set
		 */
		boolean isReadOnly();

		/**
		 * Sets my name, which must be unique amongst the configurations in my working set.
		 * 
		 * @param name
		 *            my new, unique name
		 * 
		 * @throws IllegalArgumentException
		 *             if the new name is <code>null</code> or empty, or if it is already used by another
		 *             configuration of the same working set
		 */
		void setName(String name);
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.ui.actions;

import java.util.Collection;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MenuAdapter;
import org.eclipse.swt.events.MenuEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowPulldownDelegate2;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.actions.ActionDelegate;

import org.eclipse.cdt.internal.ui.workingsets.BuildJob;
import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetConfiguration;
import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProxy;
import org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager;

/**
 * A dynamic sub-menu action that provides access to working-set configurations
 * to build them.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public class BuildWorkingSetConfigAction extends ActionDelegate implements IWorkbenchWindowPulldownDelegate2,
		IMenuCreator {
	
	private IWorkingSetManager workingSetManager;

	private IAction action;

	private Menu menu;

	private IPropertyChangeListener wsmListener;

	/**
	 * Initializes me.
	 */
	public BuildWorkingSetConfigAction() {
		super();
	}

	public Menu getMenu(Menu parent) {
		return initMenu(new Menu(parent));
	}

	public Menu getMenu(Control parent) {
		return initMenu(new Menu(parent));
	}

	@Override
	public void init(IAction action) {
		this.action = action;

		if (workingSetManager != null) {
			updateEnablement();
		}

		action.setMenuCreator(this);
	}

	public void init(IWorkbenchWindow window) {
		workingSetManager = window.getWorkbench().getWorkingSetManager();

		wsmListener = new IPropertyChangeListener() {

			public void propertyChange(PropertyChangeEvent event) {
				updateEnablement();
			}
		};
		workingSetManager.addPropertyChangeListener(wsmListener);
		updateEnablement();
	}
	
	@Override
	public void selectionChanged(IAction action, ISelection selection) {
		updateEnablement();
	}

	private void updateEnablement() {
		if (action != null) {
			action.setEnabled(workingSetManager.getRecentWorkingSets().length > 0);
		}
	}
	
	private Menu initMenu(final Menu menu) {
		this.menu = menu;
		
		menu.addMenuListener(new MenuAdapter(){
			@Override
			public void menuShown(MenuEvent e) {
				fillMenu(menu);
			}
		});
		
		return menu;
	}

	private Menu fillMenu(Menu menu) {
		clearMenu(menu);

		for (IWorkingSet next : workingSetManager.getRecentWorkingSets()) {
			createWorkingSetSubMenu(menu, next);
		}

		return this.menu;
	}

	private MenuItem createWorkingSetSubMenu(Menu parentMenu, IWorkingSet workingSet) {
		MenuItem result = null;
		IWorkingSetProxy configHolder = WorkingSetConfigurationManager.getDefault().getWorkingSet(
				workingSet.getName());

		if (configHolder != null) {
			Collection<IWorkingSetConfiguration> configs = configHolder.getConfigurations();

			if (configs.isEmpty()) {
				// just build whatever projects are in the set, at their current configuration
				result = new MenuItem(parentMenu, SWT.PUSH);
				result.addSelectionListener(new BuildWorkingSetAction(configHolder));
			} else {
				// sub-menu for specific configurations
				result = new MenuItem(parentMenu, SWT.CASCADE);
				Menu submenu = new Menu(result);
				result.setMenu(submenu);

				for (IWorkingSetConfiguration config : configs) {
					createWorkingSetConfigItem(submenu, config);
				}
			}
			
			result.setText(workingSet.getLabel());
		}

		return result;
	}
	
	private MenuItem createWorkingSetConfigItem(Menu parentMenu, IWorkingSetConfiguration config) {
		MenuItem result = new MenuItem(parentMenu, SWT.PUSH);
		result.setText(config.getName());
		result.addSelectionListener(new BuildConfigAction(config));
		return result;
	}

	private void clearMenu(Menu menu) {
		MenuItem[] items = menu.getItems();
		for (MenuItem next : items) {
			next.dispose();
		}
	}

	@Override
	public void dispose() {
		if (menu != null) {
			menu.dispose();
			menu = null;
		}

		if (wsmListener != null) {
			workingSetManager.removePropertyChangeListener(wsmListener);
			wsmListener = null;
		}

		super.dispose();
	}

	//
	// Nested classes
	//

	private static class BuildWorkingSetAction extends SelectionAdapter {
		private IWorkingSetProxy workingSet;

		BuildWorkingSetAction(IWorkingSetProxy workingSet) {
			this.workingSet = workingSet;
		}

		@Override
		public void widgetSelected(SelectionEvent e) {
			new BuildJob(workingSet.resolveProjects()).schedule();
		}
	}

	private static class BuildConfigAction extends SelectionAdapter {
		private IWorkingSetConfiguration workingSetConfig;

		BuildConfigAction(IWorkingSetConfiguration workingSetConfig) {
			this.workingSetConfig = workingSetConfig;
		}

		@Override
		public void widgetSelected(SelectionEvent e) {
			new BuildJob(workingSetConfig).schedule();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectNatureDescriptor;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExecutableExtension;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.util.NLS;

import org.eclipse.cdt.core.settings.model.ICProjectDescription;
import org.eclipse.cdt.ui.CUIPlugin;

import org.eclipse.cdt.internal.ui.workingsets.WorkspaceSnapshot.ProjectState;

/**
 * Protocol for a factory of {@link IWorkingSetProjectConfiguration}s. Factories are {@linkplain Registry
 * registered} against project natures.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 */
public interface IWorkingSetProjectConfigurationFactory {
	/**
	 * Queries my factory ID. The ID is persisted in the working set configuration data so that the same
	 * factory can be used to reconstruct project configurations when loading the working set configurations.
	 * 
	 * @return my unique identifier
	 */
	String getID();

	/**
	 * Creates a new project configuration element.
	 * 
	 * @param parent
	 *            the working set configuration that owns the new project configuration
	 * @param project
	 *            the workspace project for which to create the configuration
	 * 
	 * @return the new project configuration
	 */
	IWorkingSetProjectConfiguration createProjectConfiguration(IWorkingSetConfiguration parent,
			IProject project);

	/**
	 * Creates a UI controller to support editing the specified project configuration snapshot, which should
	 * have been obtained from a configuration that I previously
	 * {@linkplain #createProjectConfiguration(org.eclipse.cdt.internal.ui.workingsets.IWorkingSetConfiguration, IProject)
	 * created}, myself.
	 * 
	 * @param config
	 *            a project configuration snapshot that I created
	 * 
	 * @return a suitable controller for it. Must not be <code>null</code>
	 */
	IWorkingSetProjectConfigurationController createProjectConfigurationController(
			IWorkingSetProjectConfiguration.ISnapshot config);

	/**
	 * Creates a snapshot of the configuration state of a project in the workspace. This may capture
	 * additional build meta-data beyond just the "active configuration."
	 * 
	 * @param project
	 *            a project to capture in a {@link WorkspaceSnapshot}
	 * @param desc
	 *            the project description, from which to capture the initial configuration data
	 * 
	 * @return the project state capture. Must not be <code>null</code>
	 */
	WorkspaceSnapshot.ProjectState createProjectState(IProject project, ICProjectDescription desc);

	//
	// Nested types
	//

	/**
	 * A registry of {@linkplain IWorkingSetProjectConfigurationFactory project configuration factories}
	 * contributed on the <tt>org.eclipse.cdt.ui.workingSetConfigurations</tt> extension point.
	 * 
	 * @author Christian W. Damus (cdamus)
	 * 
	 * @since 6.0
	 */
	class Registry {
		private static final String EXT_PT_ID = "workingSetConfigurations"; //$NON-NLS-1$
		private static final String E_FACTORY = "projectConfigurationFactory"; //$NON-NLS-1$
		private static final String E_NATURE = "projectNature"; //$NON-NLS-1$
		private static final String A_ID = "id"; //$NON-NLS-1$
		private static final String A_CLASS = "class"; //$NON-NLS-1$

		/**
		 * The shared project configuration factory registry.
		 */
		public static Registry INSTANCE = new Registry();

		private final IWorkingSetProjectConfigurationFactory defaultFactory = new Default();
		private final Map<String, IWorkingSetProjectConfigurationFactory> factoriesByID = new java.util.HashMap<String, IWorkingSetProjectConfigurationFactory>();
		private final Map<String, IWorkingSetProjectConfigurationFactory> factoriesByNature = new java.util.HashMap<String, IWorkingSetProjectConfigurationFactory>();

		private Map<String, Set<String>> projectNaturePartOrdering;

		private Registry() {
			super();

			projectNaturePartOrdering = computeProjectNaturePartOrdering();

			loadExtensions();
		}

		public IWorkingSetProjectConfigurationFactory getFactory(String id) {
			IWorkingSetProjectConfigurationFactory result = get(factoriesByID, id);

			if (result == null) {
				result = defaultFactory;
			}

			return result;
		}

		public IWorkingSetProjectConfigurationFactory getFactory(IProject project) {
			IWorkingSetProjectConfigurationFactory result = null;

			for (String nature : getPartOrderedNatureIDs(project)) {
				result = get(factoriesByNature, nature);

				if (result != null) {
					break;
				}
			}

			return result;
		}

		private IWorkingSetProjectConfigurationFactory get(
				Map<?, IWorkingSetProjectConfigurationFactory> map, Object key) {
			return map.get(key);
		}

		private String[] getPartOrderedNatureIDs(IProject project) {
			String[] result;

			try {
				result = project.getDescription().getNatureIds();
			} catch (CoreException e) {
				CUIPlugin.log(e.getStatus());
				result = new String[0];
			}

			if (result.length > 0) {
				Arrays.sort(result, new Comparator<String>() {
					public int compare(String nature1, String nature2) {
						Set<String> required1 = projectNaturePartOrdering.get(nature1);
						Set<String> required2 = projectNaturePartOrdering.get(nature2);

						if (required1.contains(nature2)) {
							return -1; // required1 precedes required2
						} else if (required2.contains(nature1)) {
							return +1; // required2 precedes required1
						} else if (nature1.startsWith("org.eclipse.cdt.") //$NON-NLS-1$
								&& !nature2.startsWith("org.eclipse.cdt.")) { //$NON-NLS-1$
							return +1; // lower priority to CDT natures
						} else if (nature2.startsWith("org.eclipse.cdt.") //$NON-NLS-1$
								&& !nature1.startsWith("org.eclipse.cdt.")) { //$NON-NLS-1$
							return -1; // lower priority to CDT natures
						}

						return 0; // not partially comparable
					}
				});
			}

			return result;
		}

		private Map<String, Set<String>> computeProjectNaturePartOrdering() {
			Map<String, Set<String>> result = new java.util.HashMap<String, Set<String>>();

			// first pass to populate the map with immediate requireds
			IWorkspace ws = ResourcesPlugin.getWorkspace();
			for (IProjectNatureDescriptor next : ws.getNatureDescriptors()) {
				result.put(next.getNatureId(), new java.util.HashSet<String>(Arrays.asList(next
						.getRequiredNatureIds())));
			}

			// now, iterate to add transitive requireds
			boolean loopAgain;
			do {
				loopAgain = false;

				for (Map.Entry<String, Set<String>> next : result.entrySet()) {
					Set<String> requireds = next.getValue();
					Set<String> newRequireds = new java.util.HashSet<String>(requireds);

					boolean changed = false;

					for (String required : requireds) {
						changed |= newRequireds.addAll(result.get(required));
					}

					if (changed) {
						loopAgain = true;
						next.setValue(newRequireds);
					}
				}
			} while (loopAgain);

			return result;
		}

		private void loadExtensions() {
			IExtensionRegistry registry = Platform.getExtensionRegistry();
			for (IExtension ext : registry.getExtensionPoint(CUIPlugin.PLUGIN_ID, EXT_PT_ID).getExtensions()) {
				for (IConfigurationElement element : ext.getConfigurationElements()) {
					if (E_FACTORY.equals(element.getName())) {
						try {
							Descriptor desc = new Descriptor(element);

							synchronized (factoriesByID) {
								factoriesByID.put(desc.getID(), desc);
							}

							synchronized (factoriesByNature) {
								for (IConfigurationElement nature : element.getChildren(E_NATURE)) {
									String natureID = nature.getAttribute(A_ID);

									if (natureID != null) {
										factoriesByNature.put(natureID, desc);
									} else {
										CUIPlugin.log(NLS.bind(
												WorkingSetMessages.WSProjConfigFactory_noNatureID, ext
														.getContributor().getName()), null);
									}
								}
							}
						} catch (CoreException e) {
							CUIPlugin.log(e.getStatus());
						}
					}
				}
			}
		}

		//
		// Nested classes
		//

		/**
		 * A self-resolving descriptor for lazy instantiation of a factory.
		 */
		private class Descriptor implements IWorkingSetProjectConfigurationFactory {
			private final IConfigurationElement extension;
			private final String id;

			Descriptor(IConfigurationElement extension) throws CoreException {
				this.extension = extension;
				id = extension.getAttribute(A_ID);

				if (id == null) {
					throw new CoreException(new Status(IStatus.ERROR, CUIPlugin.PLUGIN_ID, NLS.bind(
							WorkingSetMessages.WSProjConfigFactory_noFactoryID, extension.getContributor()
									.getName())));
				}
			}

			public String getID() {
				return id;
			}

			public IWorkingSetProjectConfiguration createProjectConfiguration(
					IWorkingSetConfiguration parent, IProject project) {
				return resolve().createProjectConfiguration(parent, project);
			}

			public IWorkingSetProjectConfigurationController createProjectConfigurationController(
					IWorkingSetProjectConfiguration.ISnapshot config) {

				return resolve().createProjectConfigurationController(config);
			}

			public ProjectState createProjectState(IProject project, ICProjectDescription desc) {
				return resolve().createProjectState(project, desc);
			}

			private IWorkingSetProjectConfigurationFactory resolve() {
				IWorkingSetProjectConfigurationFactory result = null;

				try {
					result = (IWorkingSetProjectConfigurationFactory) extension
							.createExecutableExtension(A_CLASS);
				} catch (ClassCastException e) {
					CUIPlugin.log(NLS.bind(WorkingSetMessages.WSProjConfigFactory_badFactory, extension
							.getContributor().getName()), e);
				} catch (CoreException e) {
					CUIPlugin.log(new MultiStatus(CUIPlugin.PLUGIN_ID, 0, new IStatus[] { e.getStatus() },
							WorkingSetMessages.WSProjConfigFactory_factoryFailed, null));
				}

				if (result == null) {
					result = defaultFactory;
				}

				// replace the descriptor in the maps
				synchronized (factoriesByID) {
					factoriesByID.put(getID(), result);
				}
				synchronized (factoriesByNature) {
					for (Map.Entry<String, IWorkingSetProjectConfigurationFactory> next : factoriesByNature
							.entrySet()) {
						if (next.getValue().getID().equals(getID())) {
							next.setValue(result);
						}
					}
				}

				return result;
			}
		}

		/**
		 * The default project configuration factory. Clients may extend this class to implement custom
		 * factories for their project natures.
		 * 
		 * @author Christian W. Damus (cdamus)
		 * 
		 * @since 6.0
		 */
		public static class Default implements IWorkingSetProjectConfigurationFactory, IExecutableExtension {

			private String id;

			public Default() {
				super();
			}

			public IWorkingSetProjectConfiguration createProjectConfiguration(
					IWorkingSetConfiguration parent, IProject project) {

				WorkingSetProjectConfiguration result = createProjectConfiguration(parent);
				result.setProjectName(project.getName());
				return result;
			}

			protected WorkingSetProjectConfiguration createProjectConfiguration(
					IWorkingSetConfiguration parent) {
				return new WorkingSetProjectConfiguration(parent);
			}

			public IWorkingSetProjectConfigurationController createProjectConfigurationController(
					IWorkingSetProjectConfiguration.ISnapshot config) {

				return new ProjectConfigurationController(config);
			}

			public ProjectState createProjectState(IProject project, ICProjectDescription desc) {
				return new WorkspaceSnapshot.ProjectState(project, desc);
			}

			public String getID() {
				return id;
			}

			public void setInitializationData(IConfigurationElement config, String propertyName, Object data)
					throws CoreException {

				this.id = config.getAttribute(A_ID);
			}

		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 QNX Software Systems 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:
 *     QNX Software Systems - initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.internal.ui.workingsets;

import java.util.Set;

import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.model.WorkbenchLabelProvider;

import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;

import org.eclipse.cdt.internal.ui.CPluginImages;
import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfiguration.ISnapshot;

/**
 * Default implementation of the working set project configuration controller protocol.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 6.0
 * 
 */
public class ProjectConfigurationController implements IWorkingSetProjectConfigurationController {
	
	private IWorkingSetProjectConfiguration.ISnapshot config;

	/**
	 * Initializes me with my project configuration.
	 * 
	 * @param config
	 *            my project configuration
	 */
	public ProjectConfigurationController(IWorkingSetProjectConfiguration.ISnapshot config) {
		this.config = config;
	}

	public ISnapshot getProjectConfiguration() {
		return config;
	}

	public void checkStateChanged(Object element, boolean checked, IControllerContext context) {
		if (!context.isReadOnly() && (element instanceof ICConfigurationDescription)) {

			ICConfigurationDescription newSel = (ICConfigurationDescription) element;
			ICConfigurationDescription oldSel = getProjectConfiguration().resolveSelectedConfiguration();

			boolean oldActive = getProjectConfiguration().isActive();

			if (checked) {
				if (newSel != oldSel) {
					getProjectConfiguration().setSelectedConfigurationID(newSel.getId());

					if (oldSel != null) {
						context.setChecked(oldSel, false);
					}
				}
			} else if (newSel == oldSel) {
				// cannot just uncheck the current selection
				context.setChecked(oldSel, true);
			}

			boolean newActive = getProjectConfiguration().isActive();
			if (oldActive != newActive) {
				context.activationStateChanged(getProjectConfiguration());
			}
		} else {
			// cannot change the check-state of these nodes
			context.setChecked(element, !checked);
		}
	}

	public void updateCheckState(IControllerContext context) {
		ICConfigurationDescription sel = getProjectConfiguration().resolveSelectedConfiguration();

		if (sel != null) {
			context.setChecked(sel, true);
		}
	}

	public ITreeContentProvider getContentProvider() {
		return new ContentProvider(getProjectConfiguration());
	}

	public ILabelProvider getLabelProvider() {
		return new LabelProvider();
	}

	//
	// Nested classes
	//

	private static class ContentProvider implements ITreeContentProvider {
		private static final Object[] NO_OBJECTS = new Object[0];

		private IWorkingSetProjectConfiguration project;
		private Set<ICConfigurationDescription> configs;

		ContentProvider(IWorkingSetProjectConfiguration project) {
			this.project = project;
			this.configs = new java.util.HashSet<ICConfigurationDescription>(project.resolveConfigurations());
		}

		public Object[] getChildren(Object parentElement) {
			return (parentElement == project) ? project.resolveConfigurations().toArray() : NO_OBJECTS;
		}

		public Object getParent(Object element) {
			return (element == project) ? null : configs.contains(element) ? project : null;
		}

		public boolean hasChildren(Object element) {
			return element == project;
		}

		public Object[] getElements(Object inputElement) {
			return new Object[] { project };
		}

		public void dispose() {
			// nothing to dispose
		}

		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			// nothing to do
		}

	}
	
	private static class LabelProvider extends org.eclipse.jface.viewers.LabelProvider {
		private WorkbenchLabelProvider wbLabels = new WorkbenchLabelProvider();
		private Image configImage = CPluginImages.get(CPluginImages.IMG_OBJS_CONFIG);

		@Override
		public String getText(Object element) {
			if (element instanceof ICConfigurationDescription) {
				return ((ICConfigurationDescription) element).getName();
			} else if (element instanceof IWorkingSetProjectConfiguration) {
				return wbLabels.getText(((IWorkingSetProjectConfiguration) element).resolveProject());
			}

			return wbLabels.getText(element);
		}

		@Override
		public Image getImage(Object element) {
			if (element instanceof ICConfigurationDescription) {
				return configImage;
			} else if (element instanceof IWorkingSetProjectConfiguration) {
				return wbLabels.getImage(((IWorkingSetProjectConfiguration) element).resolveProject());
			}

			return wbLabels.getImage(element);
		}

		@Override
		public void dispose() {
			wbLabels.dispose();
			super.dispose();
		}
	}

}

Return to bug 272416

Lines 675-681 Link Here

(-)plugin.xml (-1 / +11 lines)
675	class="org.eclipse.cdt.make.ui.dialogs.GCCPerProjectSCDProfilePage"	675	class="org.eclipse.cdt.make.ui.dialogs.GCCPerProjectSCDProfilePage"
676	name="%MBSPerProjectProfile.name"	676	name="%MBSPerProjectProfile.name"
677	profileId="org.eclipse.cdt.managedbuilder.core.GCCWinManagedMakePerProjectProfileCPP"/>	677	profileId="org.eclipse.cdt.managedbuilder.core.GCCWinManagedMakePerProjectProfileCPP"/>
678	</extension>	678	</extension>
		679	<extension
		680	point="org.eclipse.cdt.ui.workingSetConfigurations">
		681	<projectConfigurationFactory
		682	class="org.eclipse.cdt.managedbuilder.internal.ui.workingsets.MBSProjectConfigurationFactory"
		683	id="org.eclipse.cdt.managedbuilder.ui.mbsProjectConfigurationFactory">
		684	<projectNature
		685	id="org.eclipse.cdt.managedbuilder.core.managedBuildNature">
		686	</projectNature>
		687	</projectConfigurationFactory>
		688	</extension>
679		689
680		690
681		691

Added Link Here

(-)src/org/eclipse/cdt/managedbuilder/internal/ui/workingsets/MBSProjectConfiguration.java (+121 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 QNX Software Systems 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	* QNX Software Systems - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.cdt.managedbuilder.internal.ui.workingsets;
13
14	import org.eclipse.cdt.core.settings.model.ICConfigurationDescription;
15	import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetConfiguration;
16	import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfiguration;
17	import org.eclipse.cdt.internal.ui.workingsets.WorkingSetProjectConfiguration;
18	import org.eclipse.cdt.internal.ui.workingsets.WorkspaceSnapshot;
19	import org.eclipse.cdt.managedbuilder.core.IConfiguration;
20	import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager;
21	import org.eclipse.cdt.ui.CUIPlugin;
22	import org.eclipse.core.runtime.CoreException;
23	import org.eclipse.core.runtime.IProgressMonitor;
24	import org.eclipse.core.runtime.IStatus;
25	import org.eclipse.core.runtime.Status;
26	import org.eclipse.core.runtime.SubMonitor;
27	import org.eclipse.osgi.util.NLS;
28
29	/**
30	* A managed-build implementation of the working set project configuration. It
31	* knows how to build the selected configuration without activating it.
32	*
33	* @author Christian W. Damus (cdamus)
34	*
35	* @since 6.0
36	*/
37	class MBSProjectConfiguration extends WorkingSetProjectConfiguration {
38
39	/**
40	* Initializes me.
41	*
42	* @param parent
43	* my parent working set configuration
44	*/
45	public MBSProjectConfiguration(IWorkingSetConfiguration parent) {
46	super(parent);
47	}
48
49	@Override
50	public IStatus build(IProgressMonitor monitor) {
51	return MBSProjectConfiguration.build(this, monitor);
52	}
53
54	/**
55	* Builds the MBS configuration selected by the specified working set
56	* project configuration.
57	*
58	* @param projectConfig
59	* a project configuration to build
60	* @param monitor
61	* for reporting build progress
62	*
63	* @return the result of the MBS build
64	*/
65	static IStatus build(IWorkingSetProjectConfiguration projectConfig,
66	IProgressMonitor monitor) {
67
68	IStatus result = Status.OK_STATUS;
69
70	ICConfigurationDescription config = projectConfig
71	.resolveSelectedConfiguration();
72	IConfiguration mbsConfig = (config == null) ? null
73	: ManagedBuildManager.getConfigurationForDescription(config);
74
75	if (mbsConfig == null) {
76	result = new Status(IStatus.WARNING, CUIPlugin.PLUGIN_ID, NLS.bind(
77	"No configuration selected for project \"{0}\".",
78	projectConfig.getProjectName()));
79	} else {
80	monitor = SubMonitor.convert(monitor);
81
82	try {
83	ManagedBuildManager.buildConfigurations(
84	new IConfiguration[] { mbsConfig }, monitor);
85	} catch (CoreException e) {
86	result = e.getStatus();
87	}
88	}
89
90	return result;
91	}
92
93	@Override
94	public ISnapshot createSnapshot(
95	IWorkingSetConfiguration.ISnapshot workingSetConfig,
96	WorkspaceSnapshot workspace) {
97
98	return new Snapshot(workingSetConfig, this, workspace);
99	}
100
101	//
102	// Nested classes
103	//
104
105	/**
106	* A mutable working-copy snapshot for MBS projects.
107	*/
108	static class Snapshot extends WorkingSetProjectConfiguration.Snapshot {
109	protected Snapshot(IWorkingSetConfiguration parent,
110	IWorkingSetProjectConfiguration projectConfig,
111	WorkspaceSnapshot workspace) {
112
113	super(parent, projectConfig, workspace);
114	}
115
116	@Override
117	public IStatus build(IProgressMonitor monitor) {
118	return MBSProjectConfiguration.build(this, monitor);
119	}
120	}
121	}

Lines 24-29 Link Here

(-)plugin.xml (-21 / +62 lines)
24	<extension-point id="quickFixProcessors" name="%quickFixProcessorExtensionPoint" schema="schema/quickFixProcessors.exsd"/>	24	<extension-point id="quickFixProcessors" name="%quickFixProcessorExtensionPoint" schema="schema/quickFixProcessors.exsd"/>
25	<extension-point id="quickAssistProcessors" name="%quickAssistProcessorExtensionPoint" schema="schema/quickAssistProcessors.exsd"/>	25	<extension-point id="quickAssistProcessors" name="%quickAssistProcessorExtensionPoint" schema="schema/quickAssistProcessors.exsd"/>
26	<extension-point id="DocCommentOwner" name="%DocCommentOwner.name" schema="schema/DocCommentOwner.exsd"/>	26	<extension-point id="DocCommentOwner" name="%DocCommentOwner.name" schema="schema/DocCommentOwner.exsd"/>
		27	<extension-point id="workingSetConfigurations" name="%workingSetConfigurationsExtensionPoint" schema="schema/workingSetConfigurations.exsd"/>
27		28
28	<extension	29	<extension
29	point="org.eclipse.core.runtime.adapters">	30	point="org.eclipse.core.runtime.adapters">
Lines 1116-1121 Link Here
1116	contentMergeViewerId="org.eclipse.cdt.ui.compare.AsmContentViewerCreator"/>	1117	contentMergeViewerId="org.eclipse.cdt.ui.compare.AsmContentViewerCreator"/>
1117	</extension>	1118	</extension>
1118	<extension	1119	<extension
		1120	point="org.eclipse.ui.menus">
		1121	<menuContribution
		1122	locationURI="menu:project?after=build">
		1123	<menu
		1124	id="org.eclipse.cdt.ui.prjmenu"
		1125	label="%Configurations.menu">
		1126	<separator
		1127	name="gm1" visible="false">
		1128	</separator>
		1129	<separator
		1130	name="s2" visible="true">
		1131	</separator>
		1132	<separator
		1133	name="gm2" visible="false">
		1134	</separator>
		1135	<separator
		1136	name="s3" visible="true">
		1137	</separator>
		1138	<separator
		1139	name="gm3" visible="false">
		1140	</separator>
		1141	<separator
		1142	name="gm4" visible="false">
		1143	</separator>
		1144	</menu>
		1145	</menuContribution>
		1146	<menuContribution
		1147	locationURI="menu:org.eclipse.cdt.ui.prjmenu?before=gm4">
		1148	<dynamic
		1149	class="org.eclipse.cdt.ui.actions.BuildWorkingSetConfigsContribution"
		1150	id="org.eclipse.cdt.ui.buildWorkingSetConfigs">
		1151	<visibleWhen>
		1152	<with
		1153	variable="activeContexts">
		1154	<iterate
		1155	ifEmpty="false"
		1156	operator="or">
		1157	<equals
		1158	value="org.eclipse.cdt.ui.buildConfigActionSet">
		1159	</equals>
		1160	</iterate>
		1161	</with>
		1162	</visibleWhen>
		1163	</dynamic>
		1164	</menuContribution>
		1165	</extension>
		1166	<extension
1119	point="org.eclipse.ui.actionSets">	1167	point="org.eclipse.ui.actionSets">
1120	<actionSet	1168	<actionSet
1121	label="%CodingActionSet.label"	1169	label="%CodingActionSet.label"
Lines 1287-1312 Link Here
1287	id="org.eclipse.cdt.ui.buildConfigActionSet"	1335	id="org.eclipse.cdt.ui.buildConfigActionSet"
1288	label="%BuildConfigActionSet.label"	1336	label="%BuildConfigActionSet.label"
1289	visible="false">	1337	visible="false">
1290	<menu
1291	id="org.eclipse.cdt.ui.prjmenu"
1292	label="%Configurations.menu"
1293	path="project/build">
1294	<groupMarker
1295	name="gm1">
1296	</groupMarker>
1297	<separator
1298	name="s2">
1299	</separator>
1300	<groupMarker
1301	name="gm2">
1302	</groupMarker>
1303	<separator
1304	name="s3">
1305	</separator>
1306	<groupMarker
1307	name="gm3">
1308	</groupMarker>
1309	</menu>
1310	<action	1338	<action
1311	class="org.eclipse.cdt.ui.actions.ChangeBuildConfigMenuAction"	1339	class="org.eclipse.cdt.ui.actions.ChangeBuildConfigMenuAction"
1312	disabledIcon="icons/dlcl16/config-tool.gif"	1340	disabledIcon="icons/dlcl16/config-tool.gif"
Lines 1353-1359 Link Here
1353	class="org.eclipse.cdt.ui.actions.WorkingSetConfigAction"	1381	class="org.eclipse.cdt.ui.actions.WorkingSetConfigAction"
1354	id="org.eclipse.cdt.ui.wsselection"	1382	id="org.eclipse.cdt.ui.wsselection"
1355	label="%wsselection"	1383	label="%wsselection"
1356	menubarPath="project/org.eclipse.cdt.ui.prjmenu/gm3"	1384	menubarPath="project/org.eclipse.cdt.ui.prjmenu/gm4"
1357	style="push"	1385	style="push"
1358	/>	1386	/>
1359	</actionSet>	1387	</actionSet>
Lines 3018-3022 Link Here
3018	</selection>	3046	</selection>
3019	</wizard>	3047	</wizard>
3020	</extension>	3048	</extension>
		3049	<extension
		3050	point="org.eclipse.cdt.ui.workingSetConfigurations">
		3051	<projectConfigurationFactory
		3052	class="org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfigurationFactory$Registry$Default"
		3053	id="org.eclipse.cdt.ui.defaultWorkingSetProjectConfigFactory">
		3054	<projectNature
		3055	id="org.eclipse.cdt.core.cnature">
		3056	</projectNature>
		3057	<projectNature
		3058	id="org.eclipse.cdt.core.ccnature">
		3059	</projectNature>
		3060	</projectConfigurationFactory>
		3061	</extension>
3021		3062
3022	</plugin>	3063	</plugin>

Lines 1-5 Link Here

(-)src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetMessages.properties (-1 / +41 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2000, 2008 IBM Corporation and others.	2	# Copyright (c) 2000, 2009 IBM Corporation, QNX Software Systems, 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 8-13 Link Here
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	# Anton Leherbauer (Wind River Systems)	10	# Anton Leherbauer (Wind River Systems)
		11	# QNX Software Systems - [272416] Rework the working set configurations
11	###############################################################################	12	###############################################################################
12		13
13	CElementWorkingSetPage_title= C/C++ Working Set	14	CElementWorkingSetPage_title= C/C++ Working Set
Lines 18-20 Link Here
18	CElementWorkingSetPage_warning_nameMustNotBeEmpty= The name must not be empty.	19	CElementWorkingSetPage_warning_nameMustNotBeEmpty= The name must not be empty.
19	CElementWorkingSetPage_warning_workingSetExists= A working set with that name already exists.	20	CElementWorkingSetPage_warning_workingSetExists= A working set with that name already exists.
20	CElementWorkingSetPage_warning_resourceMustBeChecked= At least one resource must be checked.	21	CElementWorkingSetPage_warning_resourceMustBeChecked= At least one resource must be checked.
		22
		23	WSConfig_build_problems=Problems occurred in building the working set.
		24	WSConfig_build_task=Building working set "{0}"
		25
		26	WSConfigDialog_activate_label=Set Active
		27	WSConfigDialog_active_config={0} (active)
		28	WSConfigDialog_add_label=Add...
		29	WSConfigDialog_buildPrompt_message=Some projects have had their active configurations changed, and need to be re-built. Build them now?
		30	WSConfigDialog_buildPrompt_title=Build New Configuration
		31	WSConfigDialog_implicit_config=(active)
		32	WSConfigDialog_projTree_accessible_name=Project configuration selection tree
		33	WSConfigDialog_projTree_label=Project configurations:
		34	WSConfigDialog_remove_label=Remove
		35	WSConfigDialog_rename_label=Rename...
		36	WSConfigDialog_title=Manage Working Set Configurations
		37	WSConfigDialog_wsTree_accessible_name=Working sets and configurations tree
		38	WSConfigDialog_wsTree_label=Working set configurations:
		39
		40	WSConfigManager_closeFailed=Failed to close working set configurations file.
		41	WSConfigManager_loadFailed=Failed to load working set configurations.
		42	WSConfigManager_save_job=Saving working set configurations
		43	WSConfigManager_saveFailed=Failed to save working set configurations.
		44
		45	WSConfigsController_addDlg_defaultName=NewConfiguration
		46	WSConfigsController_addDlg_emptyName=The name must not be empty.
		47	WSConfigsController_addDlg_msg=Enter a name for the new configuration.
		48	WSConfigsController_addDlg_nameExists=A configuration with that name already exists.
		49	WSConfigsController_addDlg_title=Add Working Set Configuration
		50	WSConfigsController_renameDlg_msg=Enter a new name for the configuration.
		51	WSConfigsController_renameDlg_title=Rename Working Set Configuration
		52
		53	WSProjConfig_activatedWarning=Set configuration "{0}" active in project "{1}".
		54	WSProjConfig_buildProblem=Problems occurred in building project "{0}".
		55	WSProjConfig_noConfig=No configuration selected for project "{0}".
		56
		57	WSProjConfigFactory_badFactory=Invalid project configuration factory in plug-in {0}. Expected an IWorkingSetProjectConfigurationFactory.
		58	WSProjConfigFactory_factoryFailed=Failed to create project configuration factory.
		59	WSProjConfigFactory_noFactoryID=Missing ID in project configuration factory extension in plug-in {0}
		60	WSProjConfigFactory_noNatureID=Missing nature ID in project configuration factory in plug-in {0}.

Lines 1-5 Link Here

(-)src/org/eclipse/cdt/ui/newui/PluginResources.properties (-22 / +2 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2000, 2008 IBM Corporation and others.	2	# Copyright (c) 2000, 2009 IBM Corporation, QNX Software Systems, 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 7-12 Link Here
7	#	7	#
8	# Contributors:	8	# Contributors:
9	# IBM - Initial API and implementation	9	# IBM - Initial API and implementation
		10	# QNX Software Systems - [272416] Rework the working set configurations
10	###############################################################################	11	###############################################################################
11		12
12	# ----------- Configuration Selection Page -----------	13	# ----------- Configuration Selection Page -----------
Lines 530-555 Link Here
530	CDTMainWizardPage.1=Project category is selected. Expand the category and select a concrete project type.	531	CDTMainWizardPage.1=Project category is selected. Expand the category and select a concrete project type.
531	CProjectWizard.0=Add C Project Nature	532	CProjectWizard.0=Add C Project Nature
532	CCProjectWizard.0=Add CC Project Nature	533	CCProjectWizard.0=Add CC Project Nature
533	WorkingSetConfigAction.0=Symbols '
534	WorkingSetConfigAction.1=Choose active configs for Working Sets
535	WorkingSetConfigAction.10=-- CURRENT --
536	WorkingSetConfigAction.11=Config Set Name:
537	WorkingSetConfigAction.12=Configuration set already exists:
538	WorkingSetConfigAction.13=Wrong configuration set data :
539	WorkingSetConfigAction.14=' should not be in the name
540	WorkingSetConfigAction.15=Config Set '
541	WorkingSetConfigAction.16=' already exists \!
542	WorkingSetConfigAction.17=Configurations list
543	WorkingSetConfigAction.18=New...
544	WorkingSetConfigAction.19=Rename...
545	WorkingSetConfigAction.2=Working Sets
546	WorkingSetConfigAction.20=Save, Build and Exit
547	WorkingSetConfigAction.21=Building project	534	WorkingSetConfigAction.21=Building project
548	WorkingSetConfigAction.22=Build error	535	WorkingSetConfigAction.22=Build error
549	WorkingSetConfigAction.3=- NO WORKING SETS -
550	WorkingSetConfigAction.4=Config Sets
551	WorkingSetConfigAction.5=Projects and configurations
552	WorkingSetConfigAction.6=Update config set
553	WorkingSetConfigAction.7=Create config set
554	WorkingSetConfigAction.8=Rename config set
555	WorkingSetConfigAction.9=Delete config set

Added Link Here

(-)schema/workingSetConfigurations.exsd (+149 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.cdt.ui" xmlns="http://www.w3.org/2001/XMLSchema">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.cdt.ui" id="workingSetConfigurations" name="Working Set Configurations"/>
7	</appInfo>
8	<documentation>
9	<p>
10	<b>This extension point is internal to the CDT plug-in family.</b>
11	</p><p>
12	Extension point for registration of project configuration factories for handling extended configuration options for custom project natures, in working set configurations. These factories are responsible for creating the project configuration elements and the UI controllers for the Manage Working Set Configurations dialog.
13	</p>
14	</documentation>
15	</annotation>
16
17	<element name="extension">
18	<annotation>
19	<appInfo>
20	<meta.element />
21	</appInfo>
22	</annotation>
23	<complexType>
24	<sequence minOccurs="1" maxOccurs="unbounded">
25	<element ref="projectConfigurationFactory"/>
26	</sequence>
27	<attribute name="point" type="string" use="required">
28	<annotation>
29	<documentation>
30
31	</documentation>
32	</annotation>
33	</attribute>
34	<attribute name="id" type="string">
35	<annotation>
36	<documentation>
37
38	</documentation>
39	</annotation>
40	</attribute>
41	<attribute name="name" type="string">
42	<annotation>
43	<documentation>
44
45	</documentation>
46	<appInfo>
47	<meta.attribute translatable="true"/>
48	</appInfo>
49	</annotation>
50	</attribute>
51	</complexType>
52	</element>
53
54	<element name="projectConfigurationFactory">
55	<annotation>
56	<documentation>
57	Registration of a factory for project configuration elements in working set configurations. Factories are registered against project natures via nested <tt>&lt;nature&gt;</tt> elements.
58	</documentation>
59	</annotation>
60	<complexType>
61	<sequence minOccurs="1" maxOccurs="unbounded">
62	<element ref="projectNature"/>
63	</sequence>
64	<attribute name="id" type="string" use="required">
65	<annotation>
66	<documentation>
67	A unique identifier for the project configuration factory.
68	</documentation>
69	</annotation>
70	</attribute>
71	<attribute name="class" type="string" use="required">
72	<annotation>
73	<documentation>
74	Fully qualified name of the factory class. It must implement the <tt>IWorkingSetProjectConfigurationFactory</tt> interface.
75	</documentation>
76	<appInfo>
77	<meta.attribute kind="java" basedOn=":org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfigurationFactory"/>
78	</appInfo>
79	</annotation>
80	</attribute>
81	</complexType>
82	</element>
83
84	<element name="projectNature">
85	<annotation>
86	<documentation>
87	A reference to a project nature.
88	</documentation>
89	</annotation>
90	<complexType>
91	<attribute name="id" type="string" use="required">
92	<annotation>
93	<documentation>
94	The referenced project nature ID.
95	</documentation>
96	<appInfo>
97	<meta.attribute kind="identifier" basedOn="org.eclipse.core.resources.natures/@id"/>
98	</appInfo>
99	</annotation>
100	</attribute>
101	</complexType>
102	</element>
103
104	<annotation>
105	<appInfo>
106	<meta.section type="since"/>
107	</appInfo>
108	<documentation>
109	6.0
110	</documentation>
111	</annotation>
112
113	<annotation>
114	<appInfo>
115	<meta.section type="examples"/>
116	</appInfo>
117	<documentation>
118	<pre>
119	<extension point="org.eclipse.cdt.ui.workingSetConfigurations">
120	<projectConfigurationFactory
121	id="org.example.myProject"
122	class="org.example.MyProjectConfigurationFactory">
123	<nature id="org.example.myProjectNature"/>
124	</projectConfigurationFactory>
125	</extension>
126	</pre>
127	</documentation>
128	</annotation>
129
130	<annotation>
131	<appInfo>
132	<meta.section type="apiinfo"/>
133	</appInfo>
134	<documentation>
135	Registered project configuration factories are required to implement the <tt>org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProjectConfigurationFactory</tt> interface.
136	</documentation>
137	</annotation>
138
139
140	<annotation>
141	<appInfo>
142	<meta.section type="copyright"/>
143	</appInfo>
144	<documentation>
145	Copyright (c) 2009 QNX Software Systems and others. All rights reserved.
146	</documentation>
147	</annotation>
148
149	</schema>

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/workingsets/BuildJob.java (+102 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 Intel Corporation, QNX Software Systems, 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	* Intel Corporation - initial API and implementation
10	* QNX Software Systems - [272416] Rework the working set configurations
11	*******************************************************************************/
12
13	package org.eclipse.cdt.internal.ui.workingsets;
14
15	import java.util.Collection;
16
17	import org.eclipse.core.resources.IProject;
18	import org.eclipse.core.resources.IncrementalProjectBuilder;
19	import org.eclipse.core.resources.ResourcesPlugin;
20	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.core.runtime.IProgressMonitor;
22	import org.eclipse.core.runtime.IStatus;
23	import org.eclipse.core.runtime.MultiStatus;
24	import org.eclipse.core.runtime.Status;
25	import org.eclipse.core.runtime.jobs.Job;
26
27	import org.eclipse.cdt.ui.CUIPlugin;
28	import org.eclipse.cdt.ui.newui.UIMessages;
29
30	/**
31	* A job that builds a bunch of workspace projects or a working set configuration.
32	*/
33	public final class BuildJob extends Job {
34	private Collection<IProject> projects;
35	private IWorkingSetConfiguration workingSetConfig;
36
37	/**
38	* Initializes me with a bunch projects to build in their active configurations.
39	*
40	* @param projects
41	* the projects to build
42	*/
43	public BuildJob(Collection<IProject> projects) {
44	super(UIMessages.getString("WorkingSetConfigAction.21")); //$NON-NLS-1$
45	this.projects = new java.util.ArrayList<IProject>(projects);
46	}
47
48	/**
49	* Initializes me with a working set configuration to build.
50	*
51	* @param workingSetConfig
52	* the working set configuration to build
53	*/
54	public BuildJob(IWorkingSetConfiguration workingSetConfig) {
55	super(UIMessages.getString("WorkingSetConfigAction.21")); //$NON-NLS-1$
56	this.workingSetConfig = workingSetConfig;
57	}
58
59	@Override
60	protected IStatus run(IProgressMonitor monitor) {
61	if (projects != null) {
62	return buildProjects(monitor);
63	} else {
64	return buildWorkingSetConfig(monitor);
65	}
66	}
67
68	private IStatus buildProjects(IProgressMonitor monitor) {
69	try {
70	for (IProject p : projects) {
71	try {
72	setName(UIMessages.getString("WorkingSetConfigAction.21") + p.getName()); //$NON-NLS-1$
73	p.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
74	} catch (CoreException e) {
75	return new MultiStatus(CUIPlugin.PLUGIN_ID, 0, new IStatus[] { e.getStatus() },
76	UIMessages.getString("WorkingSetConfigAction.22"), //$NON-NLS-1$
77	null);
78	}
79	if (monitor.isCanceled()) {
80	return Status.CANCEL_STATUS;
81	}
82	}
83	} finally {
84	monitor.done();
85	}
86	return Status.OK_STATUS;
87	}
88
89	private IStatus buildWorkingSetConfig(IProgressMonitor monitor) {
90	try {
91	return workingSetConfig.build(monitor);
92	} finally {
93	monitor.done();
94	}
95	}
96
97	@Override
98	public boolean belongsTo(Object family) {
99	return ResourcesPlugin.FAMILY_MANUAL_BUILD == family;
100	}
101
102	}

Added Link Here

(-)src/org/eclipse/cdt/ui/actions/BuildWorkingSetConfigsContribution.java (+134 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 QNX Software Systems 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	* QNX Software Systems - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.cdt.ui.actions;
13
14	import java.util.Collection;
15	import java.util.List;
16
17	import org.eclipse.jface.action.Action;
18	import org.eclipse.jface.action.ActionContributionItem;
19	import org.eclipse.jface.action.IContributionItem;
20	import org.eclipse.jface.action.MenuManager;
21	import org.eclipse.ui.IWorkingSet;
22	import org.eclipse.ui.IWorkingSetManager;
23	import org.eclipse.ui.actions.CompoundContributionItem;
24
25	import org.eclipse.cdt.ui.CUIPlugin;
26
27	import org.eclipse.cdt.internal.ui.workingsets.BuildJob;
28	import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetConfiguration;
29	import org.eclipse.cdt.internal.ui.workingsets.IWorkingSetProxy;
30	import org.eclipse.cdt.internal.ui.workingsets.WorkingSetConfigurationManager;
31
32	/**
33	* A dynamic contribution of sub-menus to build configurations of working sets.
34	*
35	* @author Christian W. Damus (cdamus)
36	*
37	* @since 6.0
38	*/
39	public class BuildWorkingSetConfigsContribution extends CompoundContributionItem {
40
41	private IWorkingSetManager workingSetManager;
42
43	/**
44	* Initializes me.
45	*/
46	public BuildWorkingSetConfigsContribution() {
47	super();
48	}
49
50	/**
51	* Initializes me with my identifier.
52	*
53	* @param id my identifier
54	*/
55	public BuildWorkingSetConfigsContribution(String id) {
56	super(id);
57	}
58
59	@Override
60	protected IContributionItem[] getContributionItems() {
61	// at most 5 recent working sets
62	List<IContributionItem> result = new java.util.ArrayList<IContributionItem>(5);
63
64	for (IWorkingSet recent : getWorkingsetManager().getRecentWorkingSets()) {
65	IWorkingSetProxy proxy = WorkingSetConfigurationManager.getDefault().getWorkingSet(recent.getName());
66
67	if (proxy != null) {
68	result.add(createMenu(proxy));
69	}
70	}
71
72	return result.toArray(new IContributionItem[result.size()]);
73	}
74
75	private IWorkingSetManager getWorkingsetManager() {
76	if (workingSetManager == null) {
77	workingSetManager = CUIPlugin.getDefault().getWorkbench().getWorkingSetManager();
78	}
79
80	return workingSetManager;
81	}
82
83	private IContributionItem createMenu(IWorkingSetProxy workingSet) {
84	IContributionItem result;
85	Collection<IWorkingSetConfiguration> configs = workingSet.getConfigurations();
86
87	if (configs.isEmpty()) {
88	result = new ActionContributionItem(new BuildWorkingSetAction(workingSet));
89	} else {
90	MenuManager submenu = new MenuManager(workingSet.resolve().getLabel());
91	result = submenu;
92
93	for (IWorkingSetConfiguration next : configs) {
94	submenu.add(new BuildConfigAction(next));
95	}
96	}
97
98	return result;
99	}
100
101	//
102	// Nested classes
103	//
104
105	private static class BuildWorkingSetAction extends Action {
106	private IWorkingSetProxy workingSet;
107
108	BuildWorkingSetAction(IWorkingSetProxy workingSet) {
109	super(workingSet.resolve().getLabel());
110
111	this.workingSet = workingSet;
112	}
113
114	@Override
115	public void run() {
116	new BuildJob(workingSet.resolveProjects()).schedule();
117	}
118	}
119
120	private static class BuildConfigAction extends Action {
121	private IWorkingSetConfiguration workingSetConfig;
122
123	BuildConfigAction(IWorkingSetConfiguration workingSetConfig) {
124	super(workingSetConfig.getName());
125
126	this.workingSetConfig = workingSetConfig;
127	}
128
129	@Override
130	public void run() {
131	new BuildJob(workingSetConfig).schedule();
132	}
133	}
134	}