<change id="ProjectConfigurationProvider">

            <api name="general"/>

            <summary>Added support for project configurations</summary>

            <version major="1" minor="11"/>

            <date day="22" month="6" year="2006"/>

            <author login="jglick"/>

            <compatibility addition="yes"/>

            <description>

                <p>

                    Added an interface <code>ProjectConfigurationProvider</code>

                    which can be included in a project's lookup to support

                    switchable configurations / profiles.

                </p>

            </description>

            <class package="org.netbeans.spi.project" name="ProjectConfiguration"/>

            <class package="org.netbeans.spi.project" name="ProjectConfigurationProvider"/>

            <issue number="49652"/>

        </change>

     * <li>{@link org.netbeans.spi.project.ProjectConfigurationProvider}</li>

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.spi.project;

/**

 * Represents one user-selectable configuration of a particular project.

 * For example, it might represent a choice of main class and arguments.

 * Besides the implementor, only the project UI infrastructure is expected to use this class.

 *

 * @author Adam Sotona, Jesse Glick

 * @since org.netbeans.modules.projectapi/1 1.11

 */

public interface ProjectConfiguration {

    /**

     * Provides a display name by which this configuration may be identified in the GUI.

     * @return a human-visible display name

     */

    String getDisplayName();

}

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.spi.project;

import java.beans.PropertyChangeListener;

import java.io.IOException;

import java.util.Collection;

/**

 * Provider of configurations for a project.

 * Should be registered in a project's {@link org.netbeans.api.project.Project#getLookup lookup}.

 * Besides the implementor, only the project UI infrastructure is expected to use this class.

 *

 * @author Adam Sotona, Jesse Glick

 * @since org.netbeans.modules.projectapi/1 1.11

 */

public interface ProjectConfigurationProvider {

    /**

     * Property name for the active configuration.

     * Use it when firing a change in the active configuration.

     */

    String PROP_CONFIGURATION_ACTIVE = "activeConfiguration"; // NOI18N

    /**

     * Property name of the set of configurations.

     * Use it when firing a change in the set of configurations.

     */

    String PROP_CONFIGURATIONS = "configurations"; // NOI18N

    /**

     * Gets a list of configurations.

     * Permitted to return different instances from one invocation to the next

     * but it is advisable for the "same" instances to compare as equal.

     * @return all available configurations for this project

     */

    Collection<? extends ProjectConfiguration> getConfigurations();

    /**

     * Gets the currently active configuration.

     * @return the active configuration for this project (should be a member of {@link #getConfigurations}, or null only if that is empty)

     */

    ProjectConfiguration getActiveConfiguration();

    /**

     * Sets the active configuration.

     * Should fire a change in {@link #PROP_CONFIGURATION_ACTIVE}.

     * It should be true afterwards that <code>configuration.equals(getActiveConfiguration())</code>

     * though it might not be true that <code>configuration == getActiveConfiguration()</code>.

     * @param configuration new active configuration

     * @throws IllegalArgumentException if the requested configuration is not a member of {@link #getConfigurations}

     * @throws IOException if storing the configuration change failed

     */

    void setActiveConfiguration(ProjectConfiguration configuration) throws IllegalArgumentException, IOException;

    /**

     * Checks if this project can provide a GUI customizer for its configurations.

     * @return true if {@link #customize} may be called

     */

    boolean hasCustomizer();

    /**

     * Customize this project's configurations.

     * Only permitted if {@link #hasCustomizer} is true.

     * May, for example, open the project properties dialog.

     */

    void customize();

    /**

     * Adds a listener to check for changes in {@link #PROP_CONFIGURATION_ACTIVE} or {@link #PROP_CONFIGURATIONS}.

     * @param lst a listener to add

     */

    void addPropertyChangeListener(PropertyChangeListener lst);

    /**

     * Removes a listener.

     * @param lst a listener to remove

     */

    void removePropertyChangeListener(PropertyChangeListener lst);

}

import org.openide.util.actions.SystemAction;

    }

    public Action setProjectConfigurationAction() {

        return SystemAction.get(ActiveConfigAction.class);

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.project.ui.actions;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.io.IOException;

import java.util.Collection;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListCellRenderer;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JList;

import javax.swing.JMenu;

import javax.swing.JMenuItem;

import javax.swing.JPanel;

import javax.swing.JRadioButtonMenuItem;

import org.netbeans.api.project.Project;

import org.netbeans.modules.project.ui.OpenProjectList;

import org.netbeans.spi.project.ProjectConfiguration;

import org.netbeans.spi.project.ProjectConfigurationProvider;

import org.openide.awt.DynamicMenuContent;

import org.openide.awt.Mnemonics;

import org.openide.util.ContextAwareAction;

import org.openide.util.HelpCtx;

import org.openide.util.Lookup;

import org.openide.util.NbBundle;

import org.openide.util.actions.CallableSystemAction;

import org.openide.util.actions.Presenter;

/**

 * Action permitting selection of a configuration for the main project.

 * @author Greg Crawley, Adam Sotona, Jesse Glick

 */

public class ActiveConfigAction extends CallableSystemAction implements ContextAwareAction {

    private static final DefaultComboBoxModel EMPTY_MODEL = new DefaultComboBoxModel();

    private static final Object CUSTOMIZE_ENTRY = new Object();

    private final PropertyChangeListener lst;

    private final JComboBox configListCombo;

    private boolean listeningToCombo = true;

    private Project currentProject;

    private ProjectConfigurationProvider cp;

    public ActiveConfigAction() {

        super();

        putValue("noIconInMenu", Boolean.TRUE); // NOI18N

        configListCombo = new JComboBox();

        configListCombo.setRenderer(new ConfigCellRenderer());

        configListCombo.setToolTipText(org.openide.awt.Actions.cutAmpersand(getName()));

        configurationsListChanged(null);

        configListCombo.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                if (!listeningToCombo) {

                    return;

                }

                Object o = configListCombo.getSelectedItem();

                if (o == CUSTOMIZE_ENTRY) {

                    activeConfigurationChanged(cp != null ? cp.getActiveConfiguration() : null);

                    cp.customize();

                } else if (o != null) {

                    activeConfigurationSelected((ProjectConfiguration) o);

                }

            }

        });

        lst = new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                if (ProjectConfigurationProvider.PROP_CONFIGURATIONS.equals(evt.getPropertyName())) {

                    configurationsListChanged(cp.getConfigurations());

                } else if (ProjectConfigurationProvider.PROP_CONFIGURATION_ACTIVE.equals(evt.getPropertyName())) {

                    activeConfigurationChanged(cp.getActiveConfiguration());

                }

            }

        };

        activeProjectChanged(OpenProjectList.getDefault().getMainProject());

        OpenProjectList.getDefault().addPropertyChangeListener(new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                if (OpenProjectList.PROPERTY_MAIN_PROJECT.equals(evt.getPropertyName())) {

                    activeProjectChanged(OpenProjectList.getDefault().getMainProject());

                }

            }

        });

    }

    private synchronized void configurationsListChanged(Collection<? extends ProjectConfiguration> configs) {

        if (configs == null) {

            configListCombo.setModel(EMPTY_MODEL);

            configListCombo.setEnabled(false);

        } else {

            DefaultComboBoxModel model = new DefaultComboBoxModel(configs.toArray());

            if (cp.hasCustomizer()) {

                model.addElement(CUSTOMIZE_ENTRY);

            }

            configListCombo.setModel(model);

            configListCombo.setEnabled(true);

        }

        if (cp != null) {

            activeConfigurationChanged(cp.getActiveConfiguration());

        }

    }

    private synchronized void activeConfigurationChanged(ProjectConfiguration config) {

        listeningToCombo = false;

        try {

            configListCombo.setSelectedIndex(-1);

            if (config != null) {

                ComboBoxModel m = configListCombo.getModel();

                for (int i = 0; i < m.getSize(); i++) {

                    if (config.equals(m.getElementAt(i))) {

                        configListCombo.setSelectedIndex(i);

                        break;

                    }

                }

            }

        } finally {

            listeningToCombo = true;

        }

    }

    private synchronized void activeConfigurationSelected(ProjectConfiguration cfg) {

        if (cp != null && cfg != null && !cfg.equals(cp.getActiveConfiguration())) {

            try {

                cp.setActiveConfiguration(cfg);

            } catch (IOException x) {

                Logger.getLogger(ActiveConfigAction.class.getName()).log(Level.WARNING, null, x);

            }

        }

    }

    public HelpCtx getHelpCtx() {

        return new HelpCtx(ActiveConfigAction.class);

    }

    public String getName() {

        return NbBundle.getMessage(ActiveConfigAction.class, "ActiveConfigAction.label");

    }

    public void performAction() {

        assert false;

    }

    public Component getToolbarPresenter() {

        // Do not return combo box directly; looks bad.

        JPanel panel = new JPanel(new GridBagLayout());

        panel.setOpaque(false); // don't interrupt JToolBar background

        panel.setMaximumSize(new Dimension(150, 80));

        panel.setMinimumSize(new Dimension(150, 0));

        panel.setPreferredSize(new Dimension(150, 23));

        // XXX top inset of 2 looks better w/ small toolbar, but 1 seems to look better for large toolbar (the default):

        panel.add(configListCombo, new GridBagConstraints(0, 0, 1, 1, 1.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL, new Insets(1, 6, 1, 5), 0, 0));

        return panel;

    }

    class ConfigMenu extends JMenu implements DynamicMenuContent {

        private final Lookup context;

        public ConfigMenu(Lookup context) {

            this.context = context;

            if (context != null) {

                Mnemonics.setLocalizedText(this, NbBundle.getMessage(ActiveConfigAction.class, "ActiveConfigAction.context.label"));

            } else {

                Mnemonics.setLocalizedText(this, ActiveConfigAction.this.getName());

            }

        }

        public JComponent[] getMenuPresenters() {

            removeAll();

            final ProjectConfigurationProvider pcp;

            if (context != null) {

                Collection<? extends Project> projects = context.lookupAll(Project.class);

                if (projects.size() == 1) {

                    pcp = projects.iterator().next().getLookup().lookup(ProjectConfigurationProvider.class);

                } else {

                    // No selection, or multiselection.

                    pcp = null;

                }

            } else {

                pcp = cp; // global menu item; take from main project

            }

            if (pcp != null) {

                boolean something = false;

                ProjectConfiguration activeConfig = pcp.getActiveConfiguration();

                for (final ProjectConfiguration config : pcp.getConfigurations()) {

                    JRadioButtonMenuItem jmi = new JRadioButtonMenuItem(config.getDisplayName(), config.equals(activeConfig));

                    jmi.addActionListener(new ActionListener() {

                        public void actionPerformed(ActionEvent e) {

                            activeConfigurationSelected(config);

                        }

                    });

                    add(jmi);

                    something = true;

                }

                if (pcp.hasCustomizer()) {

                    if (something) {

                        addSeparator();

                    }

                    something = true;

                    JMenuItem customize = new JMenuItem();

                    Mnemonics.setLocalizedText(customize, NbBundle.getMessage(ActiveConfigAction.class, "ActiveConfigAction.customize"));

                    customize.addActionListener(new ActionListener() {

                        public void actionPerformed(ActionEvent e) {

                            pcp.customize();

                        }

                    });

                    add(customize);

                }

                setEnabled(something);

            } else {

                // No configurations supported for this project.

                setEnabled(false);

                // to hide entirely just use: return new JComponent[0];

            }

            return new JComponent[] {this};

        }

        public JComponent[] synchMenuPresenters(JComponent[] items) {

            // Always rebuild submenu.

            // For performance, could try to reuse it if context == null and nothing has changed.

            return getMenuPresenters();

        }

    }

    public JMenuItem getMenuPresenter() {

        return new ConfigMenu(null);

    }

    private static class ConfigCellRenderer extends DefaultListCellRenderer {

        public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

            if (value instanceof ProjectConfiguration) {

                return super.getListCellRendererComponent(list, ((ProjectConfiguration) value).getDisplayName(), index, isSelected, cellHasFocus);

            } else if (value == CUSTOMIZE_ENTRY) {

                String label = org.openide.awt.Actions.cutAmpersand(NbBundle.getMessage(ActiveConfigAction.class, "ActiveConfigAction.customize"));

                return super.getListCellRendererComponent(list, label, index, isSelected, cellHasFocus);

            } else {

                assert value == null;

                return super.getListCellRendererComponent(list, null, index, isSelected, cellHasFocus);

            }

        }

    }

    private synchronized void activeProjectChanged(Project p) {

        if (currentProject != p) {

            if (cp != null) {

                cp.removePropertyChangeListener(lst);

            }

            currentProject = p;

            if (currentProject != null) {

                cp = currentProject.getLookup().lookup(ProjectConfigurationProvider.class);

                if (cp != null) {

                    cp.addPropertyChangeListener(lst);

                }

            } else {

                cp = null;

            }

            configurationsListChanged(cp == null ? null : cp.getConfigurations());

        }

    }

    public Action createContextAwareInstance(final Lookup actionContext) {

        class A extends AbstractAction implements Presenter.Popup {

            public void actionPerformed(ActionEvent e) {

                assert false;

            }

            public JMenuItem getPopupPresenter() {

                return new ConfigMenu(actionContext);

            }

        }

        return new A();

    }

}

ActiveConfigAction.label=Set Main Project Con&figuration

ActiveConfigAction.context.label=Set Configuration

ActiveConfigAction.customize=&Customize...

            <file name="org-netbeans-modules-project-ui-actions-ActiveConfigAction.instance"/>

            <file name="org-netbeans-modules-project-ui-actions-ActiveConfigAction.shadow">

                <attr name="originalFile" stringvalue="Actions/Project/org-netbeans-modules-project-ui-actions-ActiveConfigAction.instance"/>

            </file>

            <attr name="org-netbeans-modules-project-ui-actions-ActiveConfigAction.shadow/org-netbeans-modules-project-ui-BuildMainProject.shadow" boolvalue="true"/>

        <change id="CommonProjectActions.setProjectConfigurationAction">

            <api name="general"/>

            <summary>Added <code>CommonProjectActions.setProjectConfigurationAction</code></summary>

            <version major="1" minor="16"/>

            <date day="22" month="6" year="2006"/>

            <author login="jglick"/>

            <compatibility addition="yes"/>

            <description>

                <p>

                    Added method <code>CommonProjectActions.setProjectConfigurationAction()</code>

                    to permit projects supporting configurations to include a context menu

                    item in their logical view to change the active configuration.

                </p>

            </description>

            <class package="org.netbeans.spi.project.ui.support" name="CommonProjectActions"/>

            <issue number="49652"/>

        </change>

    Action setProjectConfigurationAction();

    /**

     * Creates an action that sets the configuration of the selected project.

     * It should be displayed with an action context containing

     * exactly one {@link org.netbeans.api.project.Project}.

     * The action itself should not be invoked but you may use its popup presenter.

     * <p class="nonnormative">

     * You might include this in the context menu of a logical view.

     * </p>

     * @return an action

     * @since org.netbeans.modules.projectuiapi/1 1.16

     * @see org.netbeans.spi.project.ProjectConfigurationProvider

     */

    public static Action setProjectConfigurationAction() {

        return Utilities.getActionsFactory().setProjectConfigurationAction();

    }