false;
+ * 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 final WorkspaceSnapshot getWorkspaceSnapshot() {
+ return 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);
+
+ heuristicSelectProjectConfigurations(result);
+
+ basicAddConfiguration(result);
+ updateActiveConfigurations();
+
+ return result;
+ }
+
+ /**
+ * Heuristically attempts to select reasonable default project configurations for a new working-set
+ * configuration. This implementation does a best-effort match of project configuration names against
+ * the working set configuration name.
+ *
+ * @param newConfig
+ * the new working set configuration
+ */
+ protected void heuristicSelectProjectConfigurations(IWorkingSetConfiguration.ISnapshot newConfig) {
+ String nameToSearch = getSearchKey(newConfig.getName());
+
+ for (IWorkingSetProjectConfiguration next : newConfig.getProjectConfigurations()) {
+ IWorkingSetProjectConfiguration.ISnapshot project = (IWorkingSetProjectConfiguration.ISnapshot) next;
+
+ for (ICConfigurationDescription config : project.resolveConfigurations()) {
+ if (nameToSearch.equalsIgnoreCase(getSearchKey(config.getName()))) {
+ // a match! Select this config
+ project.setSelectedConfigurationID(config.getId());
+ break;
+ }
+ }
+ }
+
+ }
+
+ private String getSearchKey(String configurationName) {
+ StringBuilder result = new StringBuilder(configurationName.length());
+
+ UCharacterIterator iter = UCharacterIterator.getInstance(configurationName);
+ for (int cp = iter.nextCodePoint(); cp != UCharacterIterator.DONE; cp = iter.nextCodePoint()) {
+ if (Character.isLetterOrDigit(cp)) {
+ result.appendCodePoint(cp);
+ }
+ }
+
+ return result.toString();
+ }
+
+ /**
+ * 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);
+ }
+ }
+}
\ No newline at end of file
Index: src/org/eclipse/cdt/internal/ui/workingsets/BuildWorkingSetConfigsContribution.java
===================================================================
RCS file: src/org/eclipse/cdt/internal/ui/workingsets/BuildWorkingSetConfigsContribution.java
diff -N src/org/eclipse/cdt/internal/ui/workingsets/BuildWorkingSetConfigsContribution.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/org/eclipse/cdt/internal/ui/workingsets/BuildWorkingSetConfigsContribution.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * 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.action.Action;
+import org.eclipse.jface.action.ActionContributionItem;
+import org.eclipse.jface.action.IContributionItem;
+import org.eclipse.osgi.util.NLS;
+
+/**
+ * A dynamic contribution of items to build configurations of a working set.
+ *
+ * @author Christian W. Damus (cdamus)
+ *
+ * @since 6.0
+ */
+public class BuildWorkingSetConfigsContribution extends AbstractWorkingSetConfigsContribution {
+
+ /**
+ * Initializes me without a working set. I figure it out, later. This is only appropriate usage for
+ * context-menu contribution, where the workbench selection is obvious.
+ */
+ public BuildWorkingSetConfigsContribution() {
+ super();
+ }
+
+ /**
+ * Initializes me with my working set.
+ *
+ * @param workingSet
+ * my working set
+ */
+ BuildWorkingSetConfigsContribution(IWorkingSetProxy workingSet) {
+ super(workingSet);
+ }
+
+ @Override
+ protected IContributionItem createContribution(IWorkingSetConfiguration config, int index) {
+ return new ActionContributionItem(new BuildConfigAction(config, index + 1));
+ }
+
+ //
+ // Nested classes
+ //
+
+ private static class BuildConfigAction extends Action {
+ private IWorkingSetConfiguration workingSetConfig;
+
+ BuildConfigAction(IWorkingSetConfiguration workingSetConfig, int ordinal) {
+ super(NLS.bind(WorkingSetMessages.WorkingSetMenus_enumPattern, ordinal, workingSetConfig
+ .getName()));
+
+ this.workingSetConfig = workingSetConfig;
+ }
+
+ @Override
+ public void run() {
+ new BuildJob(workingSetConfig).schedule();
+ }
+ }
+}
Index: src/org/eclipse/cdt/internal/ui/workingsets/IWorkingSetProjectConfigurationController.java
===================================================================
RCS file: src/org/eclipse/cdt/internal/ui/workingsets/IWorkingSetProjectConfigurationController.java
diff -N src/org/eclipse/cdt/internal/ui/workingsets/IWorkingSetProjectConfigurationController.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/org/eclipse/cdt/internal/ui/workingsets/IWorkingSetProjectConfigurationController.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,176 @@
+/*******************************************************************************
+ * 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.IColorProvider;
+import org.eclipse.jface.viewers.IContentProvider;
+import org.eclipse.jface.viewers.IFontProvider;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+
+/**
+ * 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 null 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 element 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. + *
+ *+ * The viewer argument is useful to obtain information about default font and colors, for label providers + * that implement the optional {@link IFontProvider} and/or {@link IColorProvider} interfaces. + *
+ * + * @param viewer + * the viewer for which I will provide labels + * + * @return my label provider + */ + ILabelProvider getLabelProvider(Viewer viewer); + + // + // 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) + * @see #setGrayed(Object, boolean) + */ + void setChecked(Object element, boolean checked); + + /** + * Sets the gray 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) + * responding to 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) + * @see #setChecked(Object, boolean) + */ + void setGrayed(Object element, boolean grayed); + + /** + * 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); + } +} \ No newline at end of file Index: src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfiguration.java =================================================================== RCS file: src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfiguration.java diff -N src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfiguration.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfiguration.java 1 Jan 1970 00:00:00 -0000 @@ -0,0 +1,384 @@ +/******************************************************************************* + * 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 Mapnull 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+ * 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. + *
+ *+ * 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. + *
+ *+ * 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. + *
+ * + * @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+ * 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. + *
+ *+ * 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. + *
+ * + * @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 isnull or empty, or if it is already used by another
+ * configuration of the same working set
+ */
+ void setName(String name);
+ }
+}
Index: src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfigurationsPage.java
===================================================================
RCS file: src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfigurationsPage.java
diff -N src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfigurationsPage.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfigurationsPage.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.layout.GridLayoutFactory;
+import org.eclipse.jface.viewers.IFilter;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.ui.IWorkingSet;
+import org.eclipse.ui.dialogs.PropertyPage;
+
+/**
+ * Property page for the configurations of a working set.
+ *
+ * @author Christian W. Damus (cdamus)
+ *
+ * @since 6.0
+ */
+public class WorkingSetConfigurationsPage extends PropertyPage {
+
+ private WorkingSetConfigurationBlock block;
+
+ /**
+ * Initializes me.
+ */
+ public WorkingSetConfigurationsPage() {
+ super();
+
+ noDefaultAndApplyButton();
+ }
+
+ @Override
+ protected Control createContents(Composite parent) {
+ Composite result = new Composite(parent, SWT.NONE);
+ GridLayoutFactory.fillDefaults().margins(5, 5).applyTo(result);
+
+ final WorkspaceSnapshot workspace = WorkingSetConfigurationManager.getDefault()
+ .createWorkspaceSnapshot();
+ final IWorkingSetProxy.ISnapshot workingSet = getWorkingSet(workspace);
+
+ if (workingSet == null) {
+ new Label(result, SWT.NONE).setText(WorkingSetMessages.WSetConfigsPage_noProjects);
+ } else {
+ block = new WorkingSetConfigurationBlock(workspace, workingSet);
+ block.setWorkingSetFilter(new IFilter() {
+
+ public boolean select(Object toTest) {
+ return toTest == workingSet;
+ }
+ });
+
+ Control contents = block.createContents(result);
+ contents.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+ }
+
+ return result;
+ }
+
+ private IWorkingSetProxy.ISnapshot getWorkingSet(WorkspaceSnapshot workspace) {
+ IWorkingSetProxy.ISnapshot result = null;
+ IWorkingSet realWorkingSet = (IWorkingSet) getElement().getAdapter(IWorkingSet.class);
+
+ if (realWorkingSet != null) {
+ result = workspace.getWorkingSet(realWorkingSet.getName());
+ if ((result != null) && result.resolveProjects().isEmpty()) {
+ // no C/C++ projects to configure
+ result = null;
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ public boolean performOk() {
+ if (!block.build()) {
+ // user cancelled: don't save, and don't close the property page
+ return false;
+ }
+
+ block.save();
+ return true;
+ }
+}
Index: src/org/eclipse/cdt/internal/ui/workingsets/ProjectConfigurationController.java
===================================================================
RCS file: src/org/eclipse/cdt/internal/ui/workingsets/ProjectConfigurationController.java
diff -N src/org/eclipse/cdt/internal/ui/workingsets/ProjectConfigurationController.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/org/eclipse/cdt/internal/ui/workingsets/ProjectConfigurationController.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,220 @@
+/*******************************************************************************
+ * 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.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.IFontProvider;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Font;
+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);
+ }
+
+ // gray the project node
+ context.setGrayed(getProjectConfiguration(), true);
+ }
+
+ public ITreeContentProvider getContentProvider() {
+ return new ContentProvider(getProjectConfiguration());
+ }
+
+ public ILabelProvider getLabelProvider(Viewer viewer) {
+ return new LabelProvider(viewer, getProjectConfiguration());
+ }
+
+ //
+ // Nested classes
+ //
+
+ private static class ContentProvider implements ITreeContentProvider {
+ private static final Object[] NO_OBJECTS = new Object[0];
+
+ private IWorkingSetProjectConfiguration project;
+ private Settrue if the user opted to save changes and exit the dialog (with or without
+ * build); false if the user cancelled and the dialog should remain open and unsaved
+ */
+ public boolean build() {
+ boolean result = true;
+ Collectionnull 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);
+ 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 null 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);
+ }
+ }
+ }
+
+ void update() {
+ if (tree != null) {
+ tree.refresh(true);
+ }
+ }
+
+ /**
+ * 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+ * 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. + *
+ *+ * 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. + *
+ * + * @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, ornull 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);
+
+ /**
+ * + * Resolves my selected configuration reference to the C model's description handle for it. + *
+ *+ * Note 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. + *
+ * + * @return the C model representation of my selected build configuration + * + * @see #resolveConfigurations() + */ + ICConfigurationDescription resolveSelectedConfiguration(); + + /** + *+ * Resolves the set of available configurations of my project. + *
+ *+ * Note 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. + *
+ * + * @return the C model representation of my selected available build configurations + * + * @see #resolveSelectedConfiguration() + */ + Collection+ * 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. + *
+ *+ * 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 + *
+ * + * @author Christian W. Damus (cdamus) + * + * @since 6.0 + * + */ +public class WorkspaceSnapshot { + private Mapnull)
+ */
+ 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(Mapnull 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 Collectionnull 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 Collectionnull)
+ */
+ protected void built(String configID) {
+ lastBuiltConfigID = configID;
+ }
+
+ /**
+ * 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 Collectionnull if it did not exist
+ */
+ protected ICConfigurationDescription getConfiguration(String id) {
+ return (projectDescription == null) ? null : projectDescription.getConfigurationById(id);
+ }
+ }
+}
\ No newline at end of file
Index: src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfigurationManager.java
===================================================================
RCS file: src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfigurationManager.java
diff -N src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfigurationManager.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/org/eclipse/cdt/internal/ui/workingsets/WorkingSetConfigurationManager.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,415 @@
+/*******************************************************************************
+ * 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 Mapnull 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+ * Loads the working set configurations from storage. + *
+ *+ * Note that this method must only be called within the storeLock monitor. + *
+ */ + private void load() { + workingSets = new java.util.HashMap+ * Forgets the current view of the working set configurations. + *
+ *+ * Note that this method must only be called within the storeLock monitor. + *
+ */ + 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") + Listnull 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
+ */
+ Collectionnull 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
+ */
+ Collectionnull 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);
+
+ /**
+ * + * 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." + *
+ *+ * 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." + *
+ *+ * It is assumed that the UI will refresh the tree structure rooted in me when I signal a major + * change. + *
+ * + * @return whether this update results in a "major change" to my child configuration structure + */ + boolean updateActiveConfigurations(); + } +} Index: src/org/eclipse/cdt/internal/ui/workingsets/IWorkingSetProjectConfigurationFactory.java =================================================================== RCS file: src/org/eclipse/cdt/internal/ui/workingsets/IWorkingSetProjectConfigurationFactory.java diff -N src/org/eclipse/cdt/internal/ui/workingsets/IWorkingSetProjectConfigurationFactory.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/org/eclipse/cdt/internal/ui/workingsets/IWorkingSetProjectConfigurationFactory.java 1 Jan 1970 00:00:00 -0000 @@ -0,0 +1,394 @@ +/******************************************************************************* + * 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 benull
+ */
+ 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 null
+ */
+ WorkspaceSnapshot.ProjectState createProjectState(IProject project, ICProjectDescription desc);
+
+ //
+ // Nested types
+ //
+
+ /**
+ * A registry of {@linkplain IWorkingSetProjectConfigurationFactory project configuration factories}
+ * contributed on the org.eclipse.cdt.ui.workingSetConfigurations 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