Attachment #116638 for bug #71515

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 71515
Collapse All | Expand All




import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;

import org.netbeans.api.java.source.ui.ScanDialog;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectInformation;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ProjectUtils;

import org.netbeans.modules.java.api.common.util.CommonProjectUtils;
import org.netbeans.spi.java.classpath.ClassPathProvider;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;
import org.netbeans.spi.project.ActionProvider2;
import org.netbeans.spi.project.ProjectConfiguration;
import org.netbeans.spi.project.SingleMethod;
import org.netbeans.spi.project.support.ant.AntProjectHelper;

 *
 * @since org.netbeans.modules.java.api.common/1 1.20
 */
public abstract class BaseActionProvider implements ActionProvider2 {
    public static final String AUTOMATIC_BUILD_TAG = ".netbeans_automatic_build";

    private static final Logger LOG = Logger.getLogger(BaseActionProvider.class.getName());

        return project;
    }

    @Override public Callable<Boolean> prepare(final String command, final Lookup context) {
        if (ProjectActions.COMMAND_DELETE.equals(command)) {
            return new Callable<Boolean>() {
                @Override public Boolean call() throws Exception {
                    DefaultProjectOperations.performDefaultDeleteOperation(project);
                    return true;
                }
            };
        }

        if (ProjectActions.COMMAND_COPY.equals(command)) {
            return new Callable<Boolean>() {
                @Override public Boolean call() throws Exception {
                    DefaultProjectOperations.performDefaultCopyOperation(project);
                    return true;
                }
            };
        }

        if (ProjectActions.COMMAND_MOVE.equals(command)) {
            return new Callable<Boolean>() {
                @Override public Boolean call() throws Exception {
                    DefaultProjectOperations.performDefaultMoveOperation(project);
                    return true;
                }
            };
        }

        if (ProjectActions.COMMAND_RENAME.equals(command)) {
            return new Callable<Boolean>() {
                @Override public Boolean call() throws Exception {
                    DefaultProjectOperations.performDefaultRenameOperation(project, null);
                    return true;
                }
            };
        }

        FileObject buildXml = findBuildXml();
        if (buildXml == null || !buildXml.isValid()) {
            return null;
        }
        if (Arrays.asList(getActionsDisabledForQuickRun()).contains(command)
            && isCompileOnSaveEnabled()
            && !allowAntBuild()) {
            return null;
        }
        if (!isActionEnabled(command, context)) {
            return null;
        }

        final boolean isCompileOnSaveEnabled = isCompileOnSaveEnabled();

                    return;
                }
                if (isCompileOnSaveEnabled) {
                    if (ProjectActions.COMMAND_BUILD.equals(command) && !allowAntBuild()) {
                        showBuildActionWarning(context);
                        return ;
                    }

                                execProperties.put("applet.url", url);
                                execProperties.put(JavaRunner.PROP_EXECUTE_FILE, file);
                                prepareSystemProperties(execProperties, false);
                                // XXX block
                                JavaRunner.execute(targetNames[0], execProperties);
                            }
                        } catch (IOException ex) {

                        }
                        return;
                    }
                    if (!isServerExecution() && (ProjectActions.COMMAND_RUN.equals(command) || ProjectActions.COMMAND_DEBUG.equals(command) || ProjectActions.COMMAND_DEBUG_STEP_INTO.equals(command))) {
                        prepareSystemProperties(execProperties, false);
                        bypassAntBuildScript(command, context, execProperties);
                        return ;

                    // for example RUN_SINGLE Java file with Servlet must be run on server and not locally
                    boolean serverExecution = p.getProperty(PROPERTY_RUN_SINGLE_ON_SERVER) != null;
                    p.remove(PROPERTY_RUN_SINGLE_ON_SERVER);
                    if (!serverExecution && (ProjectActions.COMMAND_RUN_SINGLE.equals(command) || ProjectActions.COMMAND_DEBUG_SINGLE.equals(command))) {
                        prepareSystemProperties(execProperties, false);
                        if (ProjectActions.COMMAND_RUN_SINGLE.equals(command)) {
                            execProperties.put(JavaRunner.PROP_CLASSNAME, p.getProperty("run.class"));
                        } else {
                            execProperties.put(JavaRunner.PROP_CLASSNAME, p.getProperty("debug.class"));

                        bypassAntBuildScript(command, context, execProperties);
                        return;
                    }
                    if (ProjectActions.COMMAND_TEST_SINGLE.equals(command) || ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(command)) {
                        FileObject[] files = findTestSources(context, true);
                        try {
                            prepareSystemProperties(execProperties, true);
                            execProperties.put(JavaRunner.PROP_EXECUTE_FILE, files[0]);
                            execProperties.put("tmp.dir", updateHelper.getAntProjectHelper().resolvePath(evaluator.getProperty(ProjectProperties.BUILD_DIR)));   //NOI18N
                            updateJavaRunnerClasspath(command, execProperties);
                            // XXX block
                            JavaRunner.execute(ProjectActions.COMMAND_TEST_SINGLE.equals(command) ? JavaRunner.QUICK_TEST : JavaRunner.QUICK_TEST_DEBUG, execProperties);
                        } catch (IOException ex) {
                            Exceptions.printStackTrace(ex);
                        }

                            execProperties.put(JavaRunner.PROP_EXECUTE_FILE, methodSpec.getFile());
                            execProperties.put("tmp.dir",updateHelper.getAntProjectHelper().resolvePath(evaluator.getProperty(ProjectProperties.BUILD_DIR)));   //NOI18N
                            updateJavaRunnerClasspath(command, execProperties);
                            // XXX block
                            JavaRunner.execute(command.equals(SingleMethod.COMMAND_RUN_SINGLE_METHOD) ? JavaRunner.QUICK_TEST : JavaRunner.QUICK_TEST_DEBUG,
                                                  execProperties);
                        } catch (IOException ex) {

                            cb2.antTargetInvocationStarted(command, context);
                        }
                        try {
                            // XXX block
                            ActionUtils.runTarget(buildFo, targetNames, p).addTaskListener(new TaskListener() {
                                @Override
                                public void taskFinished(Task task) {


            private List<String> runJvmargsIde() {
                StartupExtender.StartMode mode;
                if (command.equals(ProjectActions.COMMAND_RUN) || command.equals(ProjectActions.COMMAND_RUN_SINGLE)) {
                    mode = StartupExtender.StartMode.NORMAL;
                } else if (command.equals(ProjectActions.COMMAND_DEBUG) || command.equals(ProjectActions.COMMAND_DEBUG_SINGLE) || command.equals(ProjectActions.COMMAND_DEBUG_STEP_INTO)) {
                    mode = StartupExtender.StartMode.DEBUG;
                } else if (command.equals("profile")) {
                    mode = StartupExtender.StartMode.PROFILE;
                } else if (command.equals(ProjectActions.COMMAND_TEST) || command.equals(ProjectActions.COMMAND_TEST_SINGLE)) {
                    mode = StartupExtender.StartMode.TEST_NORMAL;
                } else if (command.equals(ProjectActions.COMMAND_DEBUG_TEST_SINGLE)) {
                    mode = StartupExtender.StartMode.TEST_DEBUG;
                } else if (command.equals("profile-test-single")) {
                    mode = StartupExtender.StartMode.TEST_PROFILE;

        LOG.log(Level.FINE, "COMMAND: {0}", command);       //NOI18N
        String[] targetNames = new String[0];
        Map<String,String[]> targetsFromConfig = loadTargetsFromConfig();
        if ( command.equals( ProjectActions.COMMAND_COMPILE_SINGLE) ) {
            FileObject[] sourceRoots = projectSourceRoots.getRoots();
            FileObject[] files = findSourcesAndPackages( context, sourceRoots);
            boolean recursive = (context.lookup(NonRecursiveFolder.class) == null);

                    return null;
                }
            }
        } else if ( command.equals( ProjectActions.COMMAND_TEST) ){
            p.setProperty("ignore.failing.tests", "true");  //NOI18N
            targetNames = getCommands().get(command);
        } else if ( command.equals( ProjectActions.COMMAND_TEST_SINGLE) ) {
            final FileObject[] files = findTestSources(context, true);
            if (files == null) {
                return null;
            }
            targetNames = setupTestSingle(p, files);            
        } else if ( command.equals( ProjectActions.COMMAND_DEBUG_TEST_SINGLE) ) {
            final FileObject[] files = findTestSources(context, true);
            if (files == null) {
                return null;

            }
            p.setProperty("fix.includes", path); // NOI18N
            p.setProperty("fix.classes", classes); // NOI18N
        } else if (!isServerExecution() && (command.equals (ProjectActions.COMMAND_RUN) || command.equals(ProjectActions.COMMAND_DEBUG) || command.equals(ProjectActions.COMMAND_DEBUG_STEP_INTO))) {
            String config = evaluator.getProperty(ProjectProperties.PROP_PROJECT_CONFIGURATION_CONFIG);
            String path;
            if (config == null || config.length() == 0) {

                    ErrorManager.getDefault().log(ErrorManager.INFORMATIONAL, "Error while saving project: " + ioe);
                }
            }
            if (!command.equals(ProjectActions.COMMAND_RUN) && /* XXX should ideally look up proper mainClass in evaluator x config */ mainClass != null) {
                p.setProperty("debug.class", mainClass); // NOI18N
            }
            String[] targets = targetsFromConfig.get(command);

                throw new IllegalArgumentException(command);
            }
            prepareDirtyList(p, false);
        } else if (command.equals (ProjectActions.COMMAND_RUN_SINGLE) || command.equals (ProjectActions.COMMAND_DEBUG_SINGLE)) {
            FileObject[] files = findTestSources(context, false);
            FileObject[] rootz = projectTestRoots.getRoots();
            boolean isTest = true;

                            return null;
                        }
                        p.setProperty("applet.url", url.toString()); // NOI18N
                        if (command.equals (ProjectActions.COMMAND_RUN_SINGLE)) {
                            targetNames = new String[] {"run-applet"}; // NOI18N
                        } else {
                            p.setProperty("debug.class", clazz); // NOI18N

                        List<String> alternativeTargetNames = new ArrayList<String>();
                        if (isTest) {
                            //Fallback to normal (non-main-method-based) unit test run
                            if (command.equals(ProjectActions.COMMAND_RUN_SINGLE)) {
                                targetNames = setupTestSingle(p, files);
                            } else {
                                targetNames = setupDebugTestSingle(p, files);

                            }
                        }
                    }
                    if (command.equals (ProjectActions.COMMAND_RUN_SINGLE)) {
                        p.setProperty("run.class", clazz); // NOI18N
                        String[] targets = targetsFromConfig.get(command);
                        targetNames = (targets != null) ? targets : (isTest ? new String[] { "run-test-with-main" } : getCommands().get(ProjectActions.COMMAND_RUN_SINGLE));
                    } else {
                        p.setProperty("debug.class", clazz); // NOI18N
                        String[] targets = targetsFromConfig.get(command);
                        targetNames = (targets != null) ? targets : (isTest ? new String[] {"debug-test-with-main"} : getCommands().get(ProjectActions.COMMAND_DEBUG_SINGLE));
                    }
                }
            }

                if (clazz == null) {
                    return null;
                }
                if (command.equals (ProjectActions.COMMAND_RUN_SINGLE)) {
                        p.setProperty("run.class", clazz); // NOI18N
                        String[] targets = targetsFromConfig.get(command);
                        targetNames = (targets != null) ? targets : (isTest ? new String[] { "run-test-with-main" } : getCommands().get(ProjectActions.COMMAND_RUN_SINGLE));    //NOI18N
                } else {
                    p.setProperty("debug.class", clazz); // NOI18N
                    String[] targets = targetsFromConfig.get(command);
                    targetNames = (targets != null) ? targets : (isTest ? new String[] {"debug-test-with-main"} : getCommands().get(ProjectActions.COMMAND_DEBUG_SINGLE));      //NOI18N
                }
            }
        } else {

            targetNames = (targets != null) ? targets : getCommands().get(command);
            if (targetNames == null) {
                String buildTarget = "false".equalsIgnoreCase(evaluator.getProperty(ProjectProperties.DO_JAR)) ? "compile" : "jar"; // NOI18N
                if (command.equals(ProjectActions.COMMAND_BUILD)) {
                    targetNames = new String[] {buildTarget};
                    prepareDirtyList(p, true);
                } else if (command.equals(ProjectActions.COMMAND_REBUILD)) {
                    targetNames = new String[] {"clean", buildTarget}; // NOI18N
                } else {
                    throw new IllegalArgumentException(command);
                }
            }
            if (ProjectActions.COMMAND_CLEAN.equals(command)) {
                //After clean, rebuild all
                dirty = null;
            }

        return !new File(buildClassesFile, AUTOMATIC_BUILD_TAG).exists();
    }

    private boolean isActionEnabled(String command, Lookup context) {
        if ( command.equals( ProjectActions.COMMAND_COMPILE_SINGLE) ) {
        if (COMMAND_DELETE.equals(command) 
            || COMMAND_MOVE.equals(command)
            || COMMAND_COPY.equals(command)
            || COMMAND_RENAME.equals(command)) {
            return true;
        }
        FileObject buildXml = findBuildXml();
        if (  buildXml == null || !buildXml.isValid()) {
            return false;
        }
        if (   Arrays.asList(getActionsDisabledForQuickRun()).contains(command)
            && isCompileOnSaveEnabled()
            && !allowAntBuild()) {
            return false;
        }
        if ( command.equals( COMMAND_COMPILE_SINGLE ) ) {
            return findSourcesAndPackages( context, projectSourceRoots.getRoots()) != null
                    || findSourcesAndPackages( context, projectTestRoots.getRoots()) != null;
        }
        else if ( command.equals( ProjectActions.COMMAND_TEST_SINGLE) ) {
            FileObject[] fos = findTestSources(context, true);
            return fos != null && fos.length == 1;
        }
        else if ( command.equals( ProjectActions.COMMAND_DEBUG_TEST_SINGLE) ) {
            FileObject[] fos = findTestSources(context, true);
            return fos != null && fos.length == 1;
        } else if (command.equals(ProjectActions.COMMAND_RUN_SINGLE) ||
                        command.equals(ProjectActions.COMMAND_DEBUG_SINGLE) ||
                        command.equals(JavaProjectConstants.COMMAND_DEBUG_FIX)) {
            FileObject fos[] = findSources(context);
            if (fos != null && fos.length == 1) {

        boolean run = true;
        boolean hasMainMethod = true;

        if (ProjectActions.COMMAND_RUN.equals(command) || ProjectActions.COMMAND_DEBUG.equals(command) || ProjectActions.COMMAND_DEBUG_STEP_INTO.equals(command)) {
            final String mainClass = evaluator.getProperty(ProjectProperties.MAIN_CLASS);

            p.put(JavaRunner.PROP_CLASSNAME, mainClass);
            p.put(JavaRunner.PROP_EXECUTE_CLASSPATH, callback.getProjectSourcesClassPath(ClassPath.EXECUTE));
            
            if (ProjectActions.COMMAND_DEBUG_STEP_INTO.equals(command)) {
                p.put("stopclassname", mainClass);
            }
        } else {


            p.put(JavaRunner.PROP_EXECUTE_FILE, files[0]);
        }
        boolean debug = ProjectActions.COMMAND_DEBUG.equals(command) || ProjectActions.COMMAND_DEBUG_SINGLE.equals(command) || ProjectActions.COMMAND_DEBUG_STEP_INTO.equals(command);
        try {
            updateJavaRunnerClasspath(command, p);
            // XXX block
            if (run) {
                copyMultiValue(ProjectProperties.APPLICATION_ARGS, p);
                JavaRunner.execute(debug ? JavaRunner.QUICK_DEBUG : JavaRunner.QUICK_RUN, p);

        }

        if (result == cleanAndBuild) {
            invokeAction(ProjectActions.COMMAND_REBUILD, context);
            return ;
        }





import java.util.logging.Logger;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.modules.java.api.common.ant.UpdateHelper;
import org.netbeans.modules.java.api.common.project.ProjectProperties;
import org.netbeans.modules.java.api.common.project.BaseActionProvider;


    // Commands available from J2SE project
    private static final String[] supportedActions = {
        ProjectActions.COMMAND_BUILD,
        ProjectActions.COMMAND_CLEAN,
        ProjectActions.COMMAND_REBUILD,
        ProjectActions.COMMAND_COMPILE_SINGLE,
        ProjectActions.COMMAND_RUN,
        ProjectActions.COMMAND_RUN_SINGLE,
        ProjectActions.COMMAND_DEBUG,
        ProjectActions.COMMAND_DEBUG_SINGLE,
        JavaProjectConstants.COMMAND_JAVADOC,
        ProjectActions.COMMAND_TEST,
        ProjectActions.COMMAND_TEST_SINGLE,
        ProjectActions.COMMAND_DEBUG_TEST_SINGLE,
        SingleMethod.COMMAND_RUN_SINGLE_METHOD,
        SingleMethod.COMMAND_DEBUG_SINGLE_METHOD,
        JavaProjectConstants.COMMAND_DEBUG_FIX,
        ProjectActions.COMMAND_DEBUG_STEP_INTO,
        ProjectActions.COMMAND_DELETE,
        ProjectActions.COMMAND_COPY,
        ProjectActions.COMMAND_MOVE,
        ProjectActions.COMMAND_RENAME,
    };


    private static final String[] platformSensitiveActions = {
        ProjectActions.COMMAND_BUILD,
        ProjectActions.COMMAND_REBUILD,
        ProjectActions.COMMAND_COMPILE_SINGLE,
        ProjectActions.COMMAND_RUN,
        ProjectActions.COMMAND_RUN_SINGLE,
        ProjectActions.COMMAND_DEBUG,
        ProjectActions.COMMAND_DEBUG_SINGLE,
        JavaProjectConstants.COMMAND_JAVADOC,
        ProjectActions.COMMAND_TEST,
        ProjectActions.COMMAND_TEST_SINGLE,
        ProjectActions.COMMAND_DEBUG_TEST_SINGLE,
        SingleMethod.COMMAND_RUN_SINGLE_METHOD,
        SingleMethod.COMMAND_DEBUG_SINGLE_METHOD,
        JavaProjectConstants.COMMAND_DEBUG_FIX,
        ProjectActions.COMMAND_DEBUG_STEP_INTO,
    };

    private static final String[] actionsDisabledForQuickRun = {
        ProjectActions.COMMAND_COMPILE_SINGLE,
        JavaProjectConstants.COMMAND_DEBUG_FIX,
    };


                new BaseActionProvider.CallbackImpl(project.getClassPathProvider()));
        commands = new HashMap<String,String[]>();
        // treated specially: COMMAND_{,RE}BUILD
        commands.put(ProjectActions.COMMAND_CLEAN, new String[] {"clean"}); // NOI18N
        commands.put(ProjectActions.COMMAND_COMPILE_SINGLE, new String[] {"compile-single"}); // NOI18N
        commands.put(ProjectActions.COMMAND_RUN, new String[] {"run"}); // NOI18N
        commands.put(ProjectActions.COMMAND_RUN_SINGLE, new String[] {"run-single"}); // NOI18N
        commands.put(ProjectActions.COMMAND_DEBUG, new String[] {"debug"}); // NOI18N
        commands.put(ProjectActions.COMMAND_DEBUG_SINGLE, new String[] {"debug-single"}); // NOI18N
        commands.put(JavaProjectConstants.COMMAND_JAVADOC, new String[] {"javadoc"}); // NOI18N
        commands.put(ProjectActions.COMMAND_TEST, new String[] {"test"}); // NOI18N
        commands.put(ProjectActions.COMMAND_TEST_SINGLE, new String[] {"test-single"}); // NOI18N
        commands.put(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, new String[] {"debug-test"}); // NOI18N
        commands.put(JavaProjectConstants.COMMAND_DEBUG_FIX, new String[] {"debug-fix"}); // NOI18N
        commands.put(ProjectActions.COMMAND_DEBUG_STEP_INTO, new String[] {"debug-stepinto"}); // NOI18N

        this.bkgScanSensitiveActions = new HashSet<String>(Arrays.asList(
            ProjectActions.COMMAND_RUN,
            ProjectActions.COMMAND_RUN_SINGLE,
            ProjectActions.COMMAND_DEBUG,
            ProjectActions.COMMAND_DEBUG_SINGLE,
            ProjectActions.COMMAND_DEBUG_STEP_INTO));
        ));

        this.needJavaModelActions = new HashSet<String>(Arrays.asList(
            JavaProjectConstants.COMMAND_DEBUG_FIX

Lines 59-64 Link Here

(-)a/java.j2seproject/src/org/netbeans/modules/java/j2seproject/J2SEConfigurationProvider.java (-2 / +3 lines)
59	import java.util.Set;	59	import java.util.Set;
60	import java.util.logging.Level;	60	import java.util.logging.Level;
61	import java.util.logging.Logger;	61	import java.util.logging.Logger;
		62	import org.netbeans.api.project.ProjectActions;
62	import org.netbeans.api.project.ProjectManager;	63	import org.netbeans.api.project.ProjectManager;
63	import org.netbeans.modules.java.api.common.project.ProjectProperties;	64	import org.netbeans.modules.java.api.common.project.ProjectProperties;
64	import org.netbeans.modules.java.j2seproject.ui.customizer.CustomizerProviderImpl;	65	import org.netbeans.modules.java.j2seproject.ui.customizer.CustomizerProviderImpl;
Lines 260-267 Link Here
260	}	261	}
261		262
262	public boolean configurationsAffectAction(String command) {	263	public boolean configurationsAffectAction(String command) {
263	return command.equals(ActionProvider.COMMAND_RUN) \|\|	264	return command.equals(ProjectActions.COMMAND_RUN) \|\|
264	command.equals(ActionProvider.COMMAND_DEBUG);	265	command.equals(ProjectActions.COMMAND_DEBUG);
265	}	266	}
266		267
267	public void addPropertyChangeListener(PropertyChangeListener lst) {	268	public void addPropertyChangeListener(PropertyChangeListener lst) {

Lines 393-399 Link Here

(-)a/java.j2seproject/src/org/netbeans/modules/java/j2seproject/J2SEProject.java (-1 lines)
393	LookupMergerSupport.createJFBLookupMerger(),	393	LookupMergerSupport.createJFBLookupMerger(),
394	QuerySupport.createBinaryForSourceQueryImplementation(this.sourceRoots, this.testRoots, this.helper, this.evaluator()), //Does not use APH to get/put properties/cfgdata	394	QuerySupport.createBinaryForSourceQueryImplementation(this.sourceRoots, this.testRoots, this.helper, this.evaluator()), //Does not use APH to get/put properties/cfgdata
395	QuerySupport.createAnnotationProcessingQuery(this.helper, this.evaluator(), ProjectProperties.ANNOTATION_PROCESSING_ENABLED, ProjectProperties.ANNOTATION_PROCESSING_ENABLED_IN_EDITOR, ProjectProperties.ANNOTATION_PROCESSING_RUN_ALL_PROCESSORS, ProjectProperties.ANNOTATION_PROCESSING_PROCESSORS_LIST, ProjectProperties.ANNOTATION_PROCESSING_SOURCE_OUTPUT, ProjectProperties.ANNOTATION_PROCESSING_PROCESSOR_OPTIONS),	395	QuerySupport.createAnnotationProcessingQuery(this.helper, this.evaluator(), ProjectProperties.ANNOTATION_PROCESSING_ENABLED, ProjectProperties.ANNOTATION_PROCESSING_ENABLED_IN_EDITOR, ProjectProperties.ANNOTATION_PROCESSING_RUN_ALL_PROCESSORS, ProjectProperties.ANNOTATION_PROCESSING_PROCESSORS_LIST, ProjectProperties.ANNOTATION_PROCESSING_SOURCE_OUTPUT, ProjectProperties.ANNOTATION_PROCESSING_PROCESSOR_OPTIONS),
396	LookupProviderSupport.createActionProviderMerger(),
397	WhiteListQueryMergerSupport.createWhiteListQueryMerger()	396	WhiteListQueryMergerSupport.createWhiteListQueryMerger()
398	);	397	);
399	lookup = base; // in case LookupProvider's call Project.getLookup	398	lookup = base; // in case LookupProvider's call Project.getLookup




import org.apache.tools.ant.module.api.support.ActionUtils;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectInformation;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.modules.java.api.common.project.ProjectProperties;
import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;
import org.netbeans.spi.project.ActionProvider;
import org.netbeans.spi.project.CopyOperationImplementation;
import org.netbeans.spi.project.DeleteOperationImplementation;
import org.netbeans.spi.project.MoveOrRenameOperationImplementation;

        Properties p = new Properties();
        final AntTargetsProvider ap = project.getLookup().lookup(AntTargetsProvider.class);
        assert ap != null;
        String[] targetNames = ap.getTargetNames(ProjectActions.COMMAND_CLEAN, Lookup.EMPTY, p, false);
        FileObject buildXML = J2SEProjectUtil.getBuildXml(project);

        assert targetNames != null;

Lines 78-83 Link Here

(-)a/java.j2seproject/src/org/netbeans/modules/java/j2seproject/ui/customizer/J2SEProjectProperties.java (-1 / +2 lines)
78	import javax.swing.text.Document;	78	import javax.swing.text.Document;
79	import javax.swing.text.PlainDocument;	79	import javax.swing.text.PlainDocument;
80	import org.netbeans.api.annotations.common.NonNull;	80	import org.netbeans.api.annotations.common.NonNull;
		81	import org.netbeans.api.project.ProjectActions;
81	import org.netbeans.api.queries.FileEncodingQuery;	82	import org.netbeans.api.queries.FileEncodingQuery;
82	import org.netbeans.api.project.ProjectManager;	83	import org.netbeans.api.project.ProjectManager;
83	import org.netbeans.api.project.ProjectUtils;	84	import org.netbeans.api.project.ProjectUtils;
Lines 463-469 Link Here
463	if (mark != null) {	464	if (mark != null) {
464	final ActionProvider ap = project.getLookup().lookup(ActionProvider.class);	465	final ActionProvider ap = project.getLookup().lookup(ActionProvider.class);
465	assert ap != null;	466	assert ap != null;
466	ap.invokeAction(ActionProvider.COMMAND_CLEAN, Lookups.fixed(project));	467	ap.invokeAction(ProjectActions.COMMAND_CLEAN, Lookups.fixed(project));
467	}	468	}
468	}	469	}
469	}	470	}




import org.netbeans.api.java.platform.Specification;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.java.api.common.applet.AppletSupport;


        p = new Properties();
        context = Lookups.fixed(someSource1);
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_COMPILE_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_COMPILE_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_COMPILE_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "compile-single", targets[0]);

        assertEquals("There must be be target parameter", "foo/Bar.java", p.getProperty("javac.includes"));
        p = new Properties();
        context = Lookups.fixed(someTest1,someTest2);
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_COMPILE_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_COMPILE_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_COMPILE_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "compile-test-single", targets[0]);

        assertEquals("There must be be target parameter", "foo/BarTest.java,foo/MainTest.java", p.getProperty("javac.includes"));
        p = new Properties();
        context = Lookups.fixed(sourcePkg1);
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_COMPILE_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_COMPILE_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_COMPILE_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "compile-single", targets[0]);

        assertEquals("There must be be target parameter", "foo/**", p.getProperty("javac.includes"));
        p = new Properties();
        context = Lookups.fixed(sourcePkg1, sourcePkg2);
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_COMPILE_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_COMPILE_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_COMPILE_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "compile-single", targets[0]);

        assertEquals("There must be be target parameter", "foo/**,foo2/**", p.getProperty("javac.includes"));
        p = new Properties();
        context = Lookups.fixed(DataFolder.findFolder(sources));
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_COMPILE_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_COMPILE_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_COMPILE_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "compile-single", targets[0]);

        
        p = new Properties();
        context = Lookups.fixed(sourcePkg1, new NonRecursiveFolderImpl (sourcePkg1));
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_COMPILE_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_COMPILE_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_COMPILE_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "compile-single", targets[0]);

        assertEquals("There must be be target parameter", "foo/*", p.getProperty("javac.includes"));
        p = new Properties();
        context = Lookups.fixed(sourcePkg1, sourcePkg2, new NonRecursiveFolderImpl(sourcePkg1), new NonRecursiveFolderImpl(sourcePkg2));
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_COMPILE_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_COMPILE_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_COMPILE_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "compile-single", targets[0]);

        assertEquals("There must be be target parameter", "foo/*,foo2/*", p.getProperty("javac.includes"));
        p = new Properties();
        context = Lookups.fixed(DataFolder.findFolder(sources), new NonRecursiveFolderImpl(sources));
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_COMPILE_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_COMPILE_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_COMPILE_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "compile-single", targets[0]);


        p = new Properties();
        context = Lookups.fixed(someSource1);
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_TEST_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_TEST_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_TEST_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "test-single", targets[0]);

        assertEquals("There must be be target parameter", "foo/BarTest.java", p.getProperty("test.includes"));
        p = new Properties();
        context = Lookups.fixed(someSource1,someSource2);
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_TEST_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_TEST_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_TEST_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "test-single", targets[0]);


        p = new Properties();
        context = Lookups.fixed(someSource1);
        targets = actionProvider.getTargetNames(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, context, p);
        assertNotNull("Must found some targets for COMMAND_DEBUG_TEST_SINGLE", targets);
        assertEquals("There must be one target for COMMAND_DEBUG_TEST_SINGLE", 1, targets.length);
        assertEquals("Unexpected target name", "debug-test", targets[0]);

        context = Lookups.fixed(someSource2);
        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_RUN_SINGLE, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
        }

        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.FALSE;
        AppletSupport.unitTestingSupport_isApplet = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_RUN_SINGLE, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
            AppletSupport.unitTestingSupport_isApplet = null;

        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.TRUE;
        AppletSupport.unitTestingSupport_isApplet = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_RUN_SINGLE, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
            AppletSupport.unitTestingSupport_isApplet = null;

        context = Lookups.fixed(someSource2);
        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_DEBUG_SINGLE, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
        }

        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.FALSE;
        AppletSupport.unitTestingSupport_isApplet = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_DEBUG_SINGLE, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
            AppletSupport.unitTestingSupport_isApplet = null;

        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.TRUE;
        AppletSupport.unitTestingSupport_isApplet = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_DEBUG_SINGLE, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
            AppletSupport.unitTestingSupport_isApplet = null;

        context = Lookup.EMPTY;
        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_RUN, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
        }

        context = Lookup.EMPTY;
        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_DEBUG, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
        }

        context = Lookup.EMPTY;
        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.TRUE;
        try {
            targets = actionProvider.getTargetNames(ProjectActions.COMMAND_DEBUG_STEP_INTO, context, p);
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;
        }

        MainClassChooser.unitTestingSupport_hasMainMethodResult = Boolean.TRUE;
        try {
            // test of targets defined in config
            String[] targets = ap.getTargetNames(ProjectActions.COMMAND_DEBUG, context, new Properties());
            assertEquals("There must be two Debug targets in test config", 2, targets.length);
            assertEquals("First Debug target name is debugtarget1", "debugtarget1", targets[0]);
            assertEquals("Second Debug target name is debugtarget2", "debugtarget2", targets[1]);
            targets = ap.getTargetNames(ProjectActions.COMMAND_BUILD, context, new Properties());
            assertEquals("There must be 1 Build target in test config", 1, targets.length);
            // target is not in fact from the config, config contains empty string
            assertEquals("Build target name is jar", "jar", targets[0]); 
            targets = ap.getTargetNames(ProjectActions.COMMAND_RUN, context, new Properties());
            assertEquals("There must be 1 Run target in test config", 1, targets.length);
            assertEquals("Run target name is runtarget", "runtarget", targets[0]);
            // test of targets not in config
            targets = ap.getTargetNames(ProjectActions.COMMAND_CLEAN, context, new Properties());
            assertEquals("There must be 1 Clean target", 1, targets.length);
            assertEquals("Clean target name is runtarget", "clean", targets[0]);
        } finally {

        FileObject newRoot = SourceRootsTest.addSourceRoot(helper, projdir, "src.other.dir","other");
        implTestIsActionEnabled(false);
        Lookup context = Lookups.fixed(sourcePkg1, DataFolder.findFolder(newRoot));
        boolean enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertFalse ("COMMAND_COMPILE_SINGLE must be disabled on multiple src packages from different roots", enabled);
    }


        helper.putProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH, ep);

        context = Lookups.fixed(someSource1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on one source", enabled);

        context = Lookups.fixed(someSource1, someSource2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on multiple sources", enabled);

        context = Lookups.fixed(someTest1, someTest2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on multiple tests", enabled);

        context = Lookups.fixed(someSource1, someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertFalse("COMMAND_COMPILE_SINGLE must be disabled on mixed files", enabled);

        context = Lookups.fixed(sourcePkg1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on one src package", enabled);

        context = Lookups.fixed(sourcePkg1, sourcePkg2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on multiple src packages", enabled);

        context = Lookups.fixed(sourcePkg1, someSource1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on mixed src packages/files", enabled);


        context = Lookups.fixed(testPkg1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on one test package", enabled);

        context = Lookups.fixed(testPkg1, testPkg2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on multiple test packages", enabled);

        context = Lookups.fixed(testPkg1, someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertTrue ("COMMAND_COMPILE_SINGLE must be enabled on mixed test packages/files", enabled);

        context = Lookups.fixed(DataFolder.findFolder(projdir));
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertFalse ("COMMAND_COMPILE_SINGLE must not be enabled on non source folder", enabled);


        context = Lookups.fixed(sourcePkg1, testPkg1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, context);
        assertFalse ("COMMAND_COMPILE_SINGLE must not be enabled on non mixed packages", enabled);

        // test COMMAND_TEST_SINGLE

        context = Lookups.fixed(someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_TEST_SINGLE, context);
        assertTrue("COMMAND_TEST_SINGLE must be enabled on one test", enabled);

        context = Lookups.fixed(someTest1, someTest2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_TEST_SINGLE, context);
        assertFalse("COMMAND_TEST_SINGLE must be disabled on multiple tests", enabled);

        context = Lookups.fixed(someSource3);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_TEST_SINGLE, context);
        assertFalse("COMMAND_TEST_SINGLE must be disabled on non-test file which does not have associated test", enabled);

        context = Lookups.fixed(someSource2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_TEST_SINGLE, context);
        assertTrue("COMMAND_TEST_SINGLE must be enabled on source file which has associated test", enabled);

        context = Lookups.fixed(someSource1, someSource2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_TEST_SINGLE, context);
        assertFalse("COMMAND_TEST_SINGLE must be enabled on source files which has associated tests", enabled);

        context = Lookups.fixed(someSource1, someSource3);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_TEST_SINGLE, context);
        assertFalse("COMMAND_TEST_SINGLE must be disabled on mixture of source files when some files do not have tests", enabled);

        context = Lookups.fixed(someSource1, someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_TEST_SINGLE, context);
        assertFalse("COMMAND_TEST_SINGLE must be disabled on mixture of source files and test files", enabled);

        // test COMMAND_DEBUG_TEST_SINGLE

        context = Lookups.fixed(someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, context);
        assertTrue("COMMAND_DEBUG_TEST_SINGLE must be enabled on test files", enabled);

        context = Lookups.fixed(someTest1, someTest2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, context);
        assertFalse("COMMAND_DEBUG_TEST_SINGLE must be disabled on multiple tests", enabled);

        context = Lookups.fixed(someSource3);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, context);
        assertFalse("COMMAND_DEBUG_TEST_SINGLE must be disabled on non-test file which does not have associated test", enabled);

        context = Lookups.fixed(someSource2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, context);
        assertTrue("COMMAND_DEBUG_TEST_SINGLE must be enabled on source file which has associated test", enabled);

        context = Lookups.fixed(someSource1, someSource2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, context);
        assertFalse("COMMAND_DEBUG_TEST_SINGLE must be disabled on multiple source files", enabled);

        // test COMMAND_DEBUG_FIX

        // test COMMAND_RUN_SINGLE

        context = Lookups.fixed(someSource1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_RUN_SINGLE, context);
        assertTrue("COMMAND_RUN_SINGLE must be enabled on one source", enabled);

        context = Lookups.fixed(someSource1, someSource2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_RUN_SINGLE, context);
        assertFalse("COMMAND_RUN_SINGLE must be disabled on multiple sources", enabled);

        context = Lookups.fixed(someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_RUN_SINGLE, context);
        assertTrue("COMMAND_RUN_SINGLE must be enabled on test file", enabled);

        context = Lookups.fixed(someTest1, someTest2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_RUN_SINGLE, context);
        assertFalse("COMMAND_RUN_SINGLE must be disabled on multiple test files", enabled);

        context = Lookups.fixed(someSource1, someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_RUN_SINGLE, context);
        assertFalse("COMMAND_RUN_SINGLE must be disabled on mixed multiple test files", enabled);

        // test COMMAND_DEBUG_SINGLE

        context = Lookups.fixed(someSource1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_SINGLE, context);
        assertTrue("COMMAND_DEBUG_SINGLE must be enabled on one source", enabled);

        context = Lookups.fixed(someSource1, someSource2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_SINGLE, context);
        assertFalse("COMMAND_DEBUG_SINGLE must be disabled on multiple sources", enabled);

        context = Lookups.fixed(someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_SINGLE, context);
        assertTrue("COMMAND_DEBUG_SINGLE must be enabled on test file", enabled);

        context = Lookups.fixed(someTest1, someTest2);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_SINGLE, context);
        assertFalse("COMMAND_DEBUG_SINGLE must be disabled on multiple test files", enabled);

        context = Lookups.fixed(someSource1, someTest1);
        enabled = actionProvider.isActionEnabled(ProjectActions.COMMAND_DEBUG_SINGLE, context);
        assertFalse("COMMAND_DEBUG_SINGLE must be disabled on mixed multiple test files", enabled);
    }


        ep.put(ProjectProperties.TRACK_FILE_CHANGES, "true");
        helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, ep);
        Properties p = new Properties();
        assertEquals("[jar]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{}", p.toString());
        TestFileUtils.touch(someSource1.getPrimaryFile(), null);
        assertEquals("[jar]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{}", p.toString());
        ep = helper.getProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH);
        ep.put(ProjectProperties.DO_JAR, "false");
        helper.putProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH, ep);
        assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{}", p.toString());
        ep.put(ProjectProperties.DO_DEPEND, "false");
        helper.putProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH, ep);
        assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{}", p.toString());
        TestFileUtils.touch(someSource1.getPrimaryFile(), null);
        assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{includes=foo/Bar.java}", p.toString());
        p.clear();
        TestFileUtils.touch(someSource2.getPrimaryFile(), null);
        TestFileUtils.touch(someSource1.getPrimaryFile(), null);
        assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{includes=foo/Bar.java,foo/Main.java}", p.toString());
        p.clear();
        assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{}", p.toString());
        TestFileUtils.touch(someTest1.getPrimaryFile(), null);
        assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{}", p.toString());
        sources.createData("x.properties");
        assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{includes=x.properties}", p.toString());
        p.clear();
        someSource1.setModified(true);
        assertEquals("[compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_BUILD, Lookup.EMPTY, p)));
        assertEquals("{includes=foo/Bar.java}", p.toString());
        p.clear();
        TestFileUtils.touch(someSource1.getPrimaryFile(), null);
        assertEquals("[clean, compile]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_REBUILD, Lookup.EMPTY, p)));
        assertEquals("{}", p.toString());
    }
    public void testBuildWithDirtyListFirstTime() throws Exception { // #119777

        Properties p = new Properties();
        MainClassChooser.unitTestingSupport_hasMainMethodResult = true;
        try {
            assertEquals("[run]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_RUN, Lookup.EMPTY, p)));
            assertEquals("{}", p.toString());
            assertEquals("[run]", Arrays.toString(actionProvider.getTargetNames(ProjectActions.COMMAND_RUN, Lookup.EMPTY, p)));
            assertEquals("{includes=nothing whatsoever}", p.toString());
        } finally {
            MainClassChooser.unitTestingSupport_hasMainMethodResult = null;




import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.versioning.ComparableVersion;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ui.OpenProjects;
import static org.netbeans.modules.maven.Bundle.*;
import org.netbeans.modules.maven.api.Constants;


    private final Project proj;
    private static String[] supported = new String[]{
        ProjectActions.COMMAND_BUILD,
        BUILD_WITH_DEPENDENCIES,
        ProjectActions.COMMAND_CLEAN,
        ProjectActions.COMMAND_REBUILD,
        "javadoc", //NOI18N
        ProjectActions.COMMAND_TEST,
        ProjectActions.COMMAND_TEST_SINGLE,
        ProjectActions.COMMAND_RUN,
        ProjectActions.COMMAND_RUN_SINGLE,
        ProjectActions.COMMAND_DEBUG,
        ProjectActions.COMMAND_DEBUG_SINGLE,
        ProjectActions.COMMAND_DEBUG_TEST_SINGLE,
        "debug.fix", //NOI18N

        //operations
        ProjectActions.COMMAND_DELETE,
        ProjectActions.COMMAND_RENAME,
        ProjectActions.COMMAND_MOVE,
        ProjectActions.COMMAND_COPY
    };
    
    Lookup.Result<? extends MavenActionsProvider> result;

                return;
            }
        }
        if (ProjectActions.COMMAND_DELETE.equals(action)) {
            DefaultProjectOperations.performDefaultDeleteOperation(proj);
            return;
        }
        if (ProjectActions.COMMAND_COPY.equals(action)) {
            DefaultProjectOperations.performDefaultCopyOperation(proj);
            return;
        }
        if (ProjectActions.COMMAND_MOVE.equals(action)) {
            DefaultProjectOperations.performDefaultMoveOperation(proj);
            return;
        }

        if (ProjectActions.COMMAND_RENAME.equals(action)) {
            Operations.renameProject(proj.getLookup().lookup(NbMavenProjectImpl.class));
            return;
        }

        //#118926 prevent NPE, how come the dobj is null?
        String dobjName = dobj != null ? dobj.getName() : ""; //NOI18N

        if (ProjectActions.COMMAND_RUN.equals(action)) {
            title = TXT_Run(prj.getMavenProject().getArtifactId());
        } else if (ProjectActions.COMMAND_DEBUG.equals(action)) {
            title = TXT_Debug(prj.getMavenProject().getArtifactId());
        } else if (ProjectActions.COMMAND_TEST.equals(action)) {
            title = TXT_Test(prj.getMavenProject().getArtifactId());
        } else if (action.startsWith(ProjectActions.COMMAND_RUN_SINGLE)) {
            title = TXT_Run(dobjName);
        } else if (action.startsWith(ProjectActions.COMMAND_DEBUG_SINGLE) || ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(action)) {
            title = TXT_Debug(dobjName);
        } else if (ProjectActions.COMMAND_TEST_SINGLE.equals(action)) {
            title = TXT_Test(dobjName);
        } else {
            title = TXT_Build(prj.getMavenProject().getArtifactId());


    @Override
    public boolean isActionEnabled(String action, Lookup lookup) {
        if (ProjectActions.COMMAND_DELETE.equals(action) ||
                ProjectActions.COMMAND_RENAME.equals(action) ||
                ProjectActions.COMMAND_COPY.equals(action) ||
                ProjectActions.COMMAND_MOVE.equals(action)) {
            return true;
        }
        if (action.equals(SingleMethod.COMMAND_RUN_SINGLE_METHOD) || action.equals(SingleMethod.COMMAND_DEBUG_SINGLE_METHOD)) {





package org.netbeans.modules.maven;

import org.netbeans.api.project.ProjectActions;
import org.netbeans.modules.maven.api.execute.PrerequisitesChecker;
import org.netbeans.modules.maven.api.execute.RunConfig;
import org.netbeans.modules.maven.api.execute.RunUtils;


    @Override public boolean checkRunConfig(RunConfig config) {
        String action = config.getActionName();
        if (ProjectActions.COMMAND_TEST.equals(action) ||
            ProjectActions.COMMAND_TEST_SINGLE.equals(action) ||
            ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(action) ||
            "profile-tests".equals(action)) { //NOI18N - profile-tests is not really nice but well.
            if (!RunUtils.hasTestCompileOnSaveEnabled(config)) {
                String test = config.getProperties().get("test");

Lines 55-60 Link Here

(-)a/maven/src/org/netbeans/modules/maven/configurations/M2ConfigProvider.java (-1 / +2 lines)
55	import java.util.Map;	55	import java.util.Map;
56	import java.util.SortedSet;	56	import java.util.SortedSet;
57	import java.util.TreeSet;	57	import java.util.TreeSet;
		58	import org.netbeans.api.project.ProjectActions;
58	import org.netbeans.modules.maven.NbMavenProjectImpl;	59	import org.netbeans.modules.maven.NbMavenProjectImpl;
59	import org.netbeans.modules.maven.api.NbMavenProject;	60	import org.netbeans.modules.maven.api.NbMavenProject;
60	import org.netbeans.modules.maven.api.ProjectProfileHandler;	61	import org.netbeans.modules.maven.api.ProjectProfileHandler;
Lines 236-242 Link Here
236	}	237	}
237		238
238	public @Override boolean configurationsAffectAction(String action) {	239	public @Override boolean configurationsAffectAction(String action) {
239	if (ActionProvider.COMMAND_DELETE.equals(action) \|\| ActionProvider.COMMAND_COPY.equals(action) \|\| ActionProvider.COMMAND_MOVE.equals(action)) {	240	if (ProjectActions.COMMAND_DELETE.equals(action) \|\| ProjectActions.COMMAND_COPY.equals(action) \|\| ProjectActions.COMMAND_MOVE.equals(action)) {
240	return false;	241	return false;
241	}	242	}
242	return true;	243	return true;




import org.netbeans.modules.maven.api.execute.RunConfig;
import org.netbeans.api.java.project.runner.JavaRunner;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.ui.OpenProjects;

public class CosChecker implements PrerequisitesChecker, LateBoundPrerequisitesChecker {

    static final String NB_COS = ".netbeans_automatic_build"; //NOI18N
    private static final String RUN_MAIN = ProjectActions.COMMAND_RUN_SINGLE + ".main"; //NOI18N
    private static final String DEBUG_MAIN = ProjectActions.COMMAND_DEBUG_SINGLE + ".main"; //NOI18N

    public boolean checkRunConfig(RunConfig config) {
        if (config.getProject() == null) {

        // we only can rely on Run via JavaRunner and via DeployOnSave
        // any other means of long term execution will not keep the CoS stamp around while running..
        // -->> ONLY DELETE FOR BUILD ACTION
        if (ProjectActions.COMMAND_BUILD.equals(config.getActionName())) {
            deleteCoSTimeStamp(config, true);
            deleteCoSTimeStamp(config, false);
            //do clean the generated class files everytime, that won't hurt anything

                    }
                Logger.getLogger(CosChecker.class.getName()).log(Level.INFO, "Compile on Save Clean failed", ex);
            }
        } else if (!ProjectActions.COMMAND_REBUILD.equals(config.getActionName())) {
            //now for all custom and non-build only related actions,
            //make sure we place the stamp files into all opened projects.
            Project[] opened = OpenProjects.getDefault().getOpenProjects();

        if (RunUtils.hasApplicationCompileOnSaveEnabled(config)) {
            if ((NbMavenProject.TYPE_JAR.equals(
                    config.getProject().getLookup().lookup(NbMavenProject.class).getPackagingType()) &&
                    (ProjectActions.COMMAND_RUN.equals(actionName) ||
                    ProjectActions.COMMAND_DEBUG.equals(actionName))) ||
                    RUN_MAIN.equals(actionName) ||
                    DEBUG_MAIN.equals(actionName)) {
                long stamp = getLastCoSLastTouch(config, false);

    private boolean checkRunTest(RunConfig config) {
        String actionName = config.getActionName();
        if (RunUtils.hasTestCompileOnSaveEnabled(config) &&
                (ProjectActions.COMMAND_TEST_SINGLE.equals(actionName) ||
                ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(actionName))) {
            String testng = PluginPropertyUtils.getPluginProperty(config.getMavenProject(), Constants.GROUP_APACHE_PLUGINS,
                    Constants.PLUGIN_SUREFIRE, "testNGArtifactName", "test"); //NOI18N
            if (testng == null) {

                    }
                    if (DefaultReplaceTokenProvider.METHOD_NAME.equals(entry.getKey())) {
                        params.put("methodname", entry.getValue()); // NOI18N
                        actionName = ProjectActions.COMMAND_TEST_SINGLE.equals(actionName) ? SingleMethod.COMMAND_RUN_SINGLE_METHOD : SingleMethod.COMMAND_DEBUG_SINGLE_METHOD;
                        continue;
                    }
                    //TODO do these have preference to ones defined in surefire plugin?

    }

    private String action2Quick(String actionName) {
        if (ProjectActions.COMMAND_CLEAN.equals(actionName)) {
            return JavaRunner.QUICK_CLEAN;
        } else if (ProjectActions.COMMAND_RUN.equals(actionName) || RUN_MAIN.equals(actionName)) {
            return JavaRunner.QUICK_RUN;
        } else if (ProjectActions.COMMAND_DEBUG.equals(actionName) || DEBUG_MAIN.equals(actionName)) {
            return JavaRunner.QUICK_DEBUG;
        } else if (ProjectActions.COMMAND_TEST.equals(actionName) || ProjectActions.COMMAND_TEST_SINGLE.equals(actionName) || SingleMethod.COMMAND_RUN_SINGLE_METHOD.equals(actionName)) {
            return JavaRunner.QUICK_TEST;
        } else if (ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(actionName) || SingleMethod.COMMAND_DEBUG_SINGLE_METHOD.equals(actionName)) {
            return JavaRunner.QUICK_TEST_DEBUG;
        }
        assert false : "Cannot convert " + actionName + " to quick actions.";




import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import org.netbeans.api.annotations.common.NullAllowed;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.modules.maven.spi.grammar.GoalsProvider;
import org.netbeans.modules.maven.api.customizer.ModelHandle;
import org.netbeans.modules.maven.NbMavenProjectImpl;

        this();
        project = proj;
        handle = hand;
        titles.put(ProjectActions.COMMAND_BUILD, NbBundle.getMessage(ActionMappings.class, "COM_Build_project"));
        titles.put(ProjectActions.COMMAND_CLEAN, NbBundle.getMessage(ActionMappings.class, "COM_Clean_project"));
        titles.put(ProjectActions.COMMAND_COMPILE_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Compile_file"));
        titles.put(ProjectActions.COMMAND_DEBUG, NbBundle.getMessage(ActionMappings.class, "COM_Debug_project"));
        titles.put(ProjectActions.COMMAND_DEBUG_SINGLE + ".main", NbBundle.getMessage(ActionMappings.class, "COM_Debug_file_main"));
        titles.put(ProjectActions.COMMAND_DEBUG_SINGLE + ".deploy", NbBundle.getMessage(ActionMappings.class, "COM_Debug_file_deploy"));
        titles.put(ProjectActions.COMMAND_DEBUG_STEP_INTO, null);
        titles.put(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Debug_test"));
        titles.put(ProjectActions.COMMAND_REBUILD, NbBundle.getMessage(ActionMappings.class, "COM_ReBuild_project"));
        titles.put(ProjectActions.COMMAND_RUN, NbBundle.getMessage(ActionMappings.class, "COM_Run_project"));
        titles.put(ProjectActions.COMMAND_RUN_SINGLE + ".main", NbBundle.getMessage(ActionMappings.class, "COM_Run_file_main"));
        titles.put(ProjectActions.COMMAND_RUN_SINGLE + ".deploy", NbBundle.getMessage(ActionMappings.class, "COM_Run_file_deploy"));
        titles.put(ProjectActions.COMMAND_TEST, NbBundle.getMessage(ActionMappings.class, "COM_Test_project"));
        titles.put(ProjectActions.COMMAND_TEST_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Test_file"));
        titles.put("profile", NbBundle.getMessage(ActionMappings.class, "COM_Profile_project"));
        titles.put("javadoc", NbBundle.getMessage(ActionMappings.class, "COM_Javadoc_project"));
        titles.put(ActionProviderImpl.BUILD_WITH_DEPENDENCIES, NbBundle.getMessage(ActionMappings.class, "COM_Build_WithDeps_project"));


        if (handle != null) {
            boolean isWar = NbMavenProject.TYPE_WAR.equalsIgnoreCase(project.getProjectWatcher().getPackagingType());
            addSingleAction(ProjectActions.COMMAND_BUILD, model);
            addSingleAction(ProjectActions.COMMAND_CLEAN, model);
            addSingleAction(ProjectActions.COMMAND_REBUILD, model);
            addSingleAction(ActionProviderImpl.BUILD_WITH_DEPENDENCIES, model);
            addSingleAction(ProjectActions.COMMAND_TEST, model);
            addSingleAction(ProjectActions.COMMAND_TEST_SINGLE, model);
            addSingleAction(ProjectActions.COMMAND_RUN, model);
            addSingleAction(ProjectActions.COMMAND_RUN_SINGLE + ".main", model); //NOI18N
            if (isWar) {
                addSingleAction(ProjectActions.COMMAND_RUN_SINGLE + ".deploy", model); //NOI18N
            }
            addSingleAction(ProjectActions.COMMAND_DEBUG, model);
            addSingleAction(ProjectActions.COMMAND_DEBUG_SINGLE + ".main", model); //NOI18N
            if (isWar) {
                addSingleAction(ProjectActions.COMMAND_DEBUG_SINGLE + ".deploy", model); //NOI18N
            }
            addSingleAction(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, model);
            addSingleAction("profile", model); //NOI18N
            addSingleAction("javadoc", model); //NOI18N
        }




import org.netbeans.modules.maven.classpath.MavenSourcesImpl;
import org.netbeans.modules.maven.NbMavenProjectImpl;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;

        @SuppressWarnings("unchecked")
        List<NetbeansActionMapping> lst = mapp.getActions();
        for (NetbeansActionMapping m : lst) {
            if (ProjectActions.COMMAND_RUN.equals(m.getActionName())) {
                run = m;
            }
            if (ProjectActions.COMMAND_DEBUG.equals(m.getActionName())) {
                debug = m;
            }
            if (PROFILE_CMD.equals(m.getActionName())) {

            }
        }
        if (run == null) {
            run = ModelHandle.getDefaultMapping(ProjectActions.COMMAND_RUN, project);
        }
        if (debug == null) {
            debug = ModelHandle.getDefaultMapping(ProjectActions.COMMAND_DEBUG, project);
        }
        if (profile == null) {
            profile = ModelHandle.getDefaultMapping(PROFILE_CMD, project);




import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.queries.SourceForBinaryQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.modules.maven.api.Constants;
import org.netbeans.modules.maven.api.NbMavenProject;
import org.netbeans.modules.maven.api.PluginPropertyUtils;

            return true;
        }
        boolean debug = "true".equalsIgnoreCase(config.getProperties().get(Constants.ACTION_PROPERTY_JPDALISTEN));//NOI18N
        if (debug && ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equalsIgnoreCase(config.getActionName()) && config.getGoals().contains("surefire:test")) { //NOI18N - just a safeguard
            String newArgs = config.getProperties().get(MAVENSUREFIREDEBUG); //NOI18N
            String oldArgs = config.getProperties().get(ARGLINE); //NOI18N


                LOGGER.log(Level.INFO, th.getMessage(), th);
            }
        }
        if (ProjectActions.COMMAND_DEBUG_STEP_INTO.equals(config.getActionName())) {
            //TODO - change the goal from compile to test-compile in case of file coming from
            //the test source roots..
        }




import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import org.netbeans.api.progress.ProgressHandle;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.modules.maven.api.FileUtilities;
import org.netbeans.modules.maven.api.execute.ExecutionContext;

        
        if (rc == null) {
            // for build and rebuild check the pom for default goal and run that one..
            if (ProjectActions.COMMAND_BUILD.equals(action) || ProjectActions.COMMAND_REBUILD.equals(action)) {
                Build bld = project.getOriginalMavenProject().getBuild();
                if (bld != null) {
                    String goal = bld.getDefaultGoal();

                        while (tok.hasMoreTokens()) {
                            toRet.add(tok.nextToken());
                        }
                        if (ProjectActions.COMMAND_REBUILD.equals(action)) {
                            toRet.add(0, "clean"); //NOI18N
                            }
                        brc.setGoals(toRet);

            return true;
        }

        if (ProjectActions.COMMAND_BUILD.equals(action) ||
                ProjectActions.COMMAND_REBUILD.equals(action)) {
            Build bld = project.getOriginalMavenProject().getBuild();
            if (bld != null) {
                String goal = bld.getDefaultGoal();




import org.netbeans.api.java.source.ClasspathInfo;
import org.netbeans.api.java.source.SourceUtils;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;

            replaceMap.put(CLASSPATHSCOPE,"runtime"); //NOI18N
        }
        if (tuple.group != null && MavenSourcesImpl.NAME_SOURCE.equals(tuple.group.getName()) &&
                (ProjectActions.COMMAND_TEST_SINGLE.equals(actionName) ||
                ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(actionName))) {
            String withExt = replaceMap.get(CLASSNAME_EXT);
            if (withExt != null && withExt.endsWith(".java")) {//NOI18N
                replaceMap.put(CLASSNAME_EXT, withExt.replace(".java", "Test.java"));//NOI18N


    @Override public String convert(String action, Lookup lookup) {
        if (SingleMethod.COMMAND_DEBUG_SINGLE_METHOD.equals(action)) {
            return ProjectActions.COMMAND_DEBUG_TEST_SINGLE;
        }
        if (SingleMethod.COMMAND_RUN_SINGLE_METHOD.equals(action)) {
            return ProjectActions.COMMAND_TEST_SINGLE;
        }
        if (ProjectActions.COMMAND_RUN_SINGLE.equals(action) ||
            ProjectActions.COMMAND_DEBUG_SINGLE.equals(action)) {
            FileObject[] fos = extractFileObjectsfromLookup(lookup);
            if (fos.length > 0) {
                FileObject fo = fos[0];

Lines 52-57 Link Here

(-)a/maven/src/org/netbeans/modules/maven/runjar/RunJarPrereqChecker.java (-2 / +3 lines)
52	import javax.swing.event.ChangeListener;	52	import javax.swing.event.ChangeListener;
53	import org.netbeans.api.java.project.JavaProjectConstants;	53	import org.netbeans.api.java.project.JavaProjectConstants;
54	import org.netbeans.api.project.Project;	54	import org.netbeans.api.project.Project;
		55	import org.netbeans.api.project.ProjectActions;
55	import org.netbeans.api.project.ProjectUtils;	56	import org.netbeans.api.project.ProjectUtils;
56	import org.netbeans.api.project.SourceGroup;	57	import org.netbeans.api.project.SourceGroup;
57	import org.netbeans.api.project.Sources;	58	import org.netbeans.api.project.Sources;
Lines 102-109 Link Here
102	}	103	}
103	}	104	}
104		105
105	if ((ActionProvider.COMMAND_RUN.equals(actionName) \|\|	106	if ((ProjectActions.COMMAND_RUN.equals(actionName) \|\|
106	ActionProvider.COMMAND_DEBUG.equals(actionName) \|\|	107	ProjectActions.COMMAND_DEBUG.equals(actionName) \|\|
107	"profile".equals(actionName))) {	108	"profile".equals(actionName))) {
108	String mc = null;	109	String mc = null;
109	for (Map.Entry<? extends String,? extends String> entry : config.getProperties().entrySet()) {	110	for (Map.Entry<? extends String,? extends String> entry : config.getProperties().entrySet()) {




import java.util.Map;
import org.netbeans.api.extexecution.startup.StartupExtender;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.modules.maven.api.NbMavenProject;
import org.netbeans.modules.maven.api.execute.ActiveJ2SEPlatformProvider;
import org.netbeans.modules.maven.api.execute.ExecutionContext;

public class RunJarStartupArgs implements LateBoundPrerequisitesChecker {

    // XXX introduce constant w/ CosChecker, ActionMappings, DefaultReplaceTokenProvider
    private static final String RUN_MAIN = ProjectActions.COMMAND_RUN_SINGLE + ".main";
    private static final String DEBUG_MAIN = ProjectActions.COMMAND_DEBUG_SINGLE + ".main";

    @Override public boolean checkRunConfig(RunConfig config, ExecutionContext con) {
        String actionName = config.getActionName();
        StartupExtender.StartMode mode;
        if (ProjectActions.COMMAND_RUN.equals(actionName) || RUN_MAIN.equals(actionName)) {
            mode = StartupExtender.StartMode.NORMAL;
        } else if (ProjectActions.COMMAND_DEBUG.equals(actionName) || DEBUG_MAIN.equals(actionName)) {
            mode = StartupExtender.StartMode.DEBUG;
        } else if ("profile".equals(actionName)) {
            mode = StartupExtender.StartMode.PROFILE;

Lines 50-55 Link Here

(-)a/projectapi/nbproject/project.xml (+9 lines)
50	<code-name-base>org.netbeans.modules.projectapi</code-name-base>	50	<code-name-base>org.netbeans.modules.projectapi</code-name-base>
51	<module-dependencies>	51	<module-dependencies>
52	<dependency>	52	<dependency>
		53	<code-name-base>org.netbeans.api.annotations.common</code-name-base>
		54	<build-prerequisite/>
		55	<compile-dependency/>
		56	<run-dependency>
		57	<release-version>1</release-version>
		58	<specification-version>1.13</specification-version>
		59	</run-dependency>
		60	</dependency>
		61	<dependency>
53	<code-name-base>org.netbeans.modules.queries</code-name-base>	62	<code-name-base>org.netbeans.modules.queries</code-name-base>
54	<build-prerequisite/>	63	<build-prerequisite/>
55	<compile-dependency/>	64	<compile-dependency/>




org.netbeans.spi.project.ActionProvider.COMMAND_BUILD => org.netbeans.api.project.ProjectActions.COMMAND_BUILD;;
org.netbeans.spi.project.ActionProvider.COMMAND_COMPILE_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_COMPILE_SINGLE;;
org.netbeans.spi.project.ActionProvider.COMMAND_CLEAN => org.netbeans.api.project.ProjectActions.COMMAND_CLEAN;;
org.netbeans.spi.project.ActionProvider.COMMAND_REBUILD => org.netbeans.api.project.ProjectActions.COMMAND_REBUILD;;
org.netbeans.spi.project.ActionProvider.COMMAND_RUN => org.netbeans.api.project.ProjectActions.COMMAND_RUN;;
org.netbeans.spi.project.ActionProvider.COMMAND_RUN_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_RUN_SINGLE;;
org.netbeans.spi.project.ActionProvider.COMMAND_TEST => org.netbeans.api.project.ProjectActions.COMMAND_TEST;;
org.netbeans.spi.project.ActionProvider.COMMAND_TEST_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_TEST_SINGLE;;
org.netbeans.spi.project.ActionProvider.COMMAND_DEBUG => org.netbeans.api.project.ProjectActions.COMMAND_DEBUG;;
org.netbeans.spi.project.ActionProvider.COMMAND_DEBUG_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_DEBUG_SINGLE;;
org.netbeans.spi.project.ActionProvider.COMMAND_DEBUG_TEST_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_DEBUG_TEST_SINGLE;;
org.netbeans.spi.project.ActionProvider.COMMAND_DEBUG_STEP_INTO => org.netbeans.api.project.ProjectActions.COMMAND_DEBUG_STEP_INTO;;
org.netbeans.spi.project.ActionProvider.COMMAND_DELETE => org.netbeans.api.project.ProjectActions.COMMAND_DELETE;;
org.netbeans.spi.project.ActionProvider.COMMAND_COPY => org.netbeans.api.project.ProjectActions.COMMAND_COPY;;
org.netbeans.spi.project.ActionProvider.COMMAND_MOVE => org.netbeans.api.project.ProjectActions.COMMAND_MOVE;;
org.netbeans.spi.project.ActionProvider.COMMAND_RENAME => org.netbeans.api.project.ProjectActions.COMMAND_RENAME;;

Lines 94-100 Link Here

(-)a/projectapi/src/org/netbeans/api/project/Project.java (-1 / +1 lines)
94	* <li><a href="@org-netbeans-modules-projectuiapi@/org/netbeans/spi/project/ui/LogicalViewProvider.html"><code>LogicalViewProvider</code></a></li>	94	* <li><a href="@org-netbeans-modules-projectuiapi@/org/netbeans/spi/project/ui/LogicalViewProvider.html"><code>LogicalViewProvider</code></a></li>
95	* <li><a href="@org-netbeans-modules-projectuiapi@/org/netbeans/spi/project/ui/CustomizerProvider.html"><code>CustomizerProvider</code></a></li>	95	* <li><a href="@org-netbeans-modules-projectuiapi@/org/netbeans/spi/project/ui/CustomizerProvider.html"><code>CustomizerProvider</code></a></li>
96	* <li>{@link org.netbeans.api.project.Sources}</li>	96	* <li>{@link org.netbeans.api.project.Sources}</li>
97	* <li>{@link org.netbeans.spi.project.ActionProvider}</li>	97	* <li>{@link org.netbeans.spi.project.ActionProvider2}</li>
98	* <li>{@link org.netbeans.spi.project.SubprojectProvider}</li>	98	* <li>{@link org.netbeans.spi.project.SubprojectProvider}</li>
99	* <li>{@link org.netbeans.spi.project.AuxiliaryConfiguration}</li>	99	* <li>{@link org.netbeans.spi.project.AuxiliaryConfiguration}</li>
100	* <li>{@link org.netbeans.spi.project.AuxiliaryProperties}</li>	100	* <li>{@link org.netbeans.spi.project.AuxiliaryProperties}</li>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */

package org.netbeans.api.project;

import java.util.Arrays;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.spi.project.ActionProvider2;
import org.netbeans.spi.project.SingleMethod;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.RequestProcessor;

/**
 * Defines and manages actions exported by projects.
 * Each possible action is identified by a command string;
 * this class defines some commonly used ones, such as {@link #COMMAND_BUILD}.
 * @see ActionProvider2
 * @see SingleMethod
 * @since XXX
 */
public class ProjectActions {

    private static final RequestProcessor RP = new RequestProcessor(ProjectActions.class.getName(), Integer.MAX_VALUE);

    /**
     * Prepare to run an action.
     * @param project a project to run the action on
     * @param command a predefined command string
     * @param context an action context
     * @return a callback to run the action, or null if disabled (or just not recognized by this project)
     */
    public static @CheckForNull Callable<Boolean> prepare(@NonNull Project project, final @NonNull String command, final @NonNull Lookup context) {
        for (ActionProvider2 ap2 : project.getLookup().lookupAll(ActionProvider2.class)) {
            Callable<Boolean> task = ap2.prepare(command, context);
            if (task != null) {
                return task;
            }
        }
        @SuppressWarnings("deprecation")
        final org.netbeans.spi.project.ActionProvider ap = project.getLookup().lookup(org.netbeans.spi.project.ActionProvider.class);
        if (ap != null && Arrays.asList(ap.getSupportedActions()).contains(command)) {
            try {
                if (ap.isActionEnabled(command, context)) {
                    return new Callable<Boolean>() {
                        @Override public Boolean call() throws Exception {
                            ap.invokeAction(command, context);
                            return true;
                        }
                    };
                }
            } catch (IllegalArgumentException x) {
                Exceptions.printStackTrace(x);
            }
        }
        return null;
    }

    /**
     * Convenience method to run an action if it is enabled.
     * The return value may be safely ignored if you do not depend on the result.
     * @param project a project to run the action on
     * @param command a predefined command string
     * @param context an action context
     * @return a task representing the result; will be false if the action is not defined or enabled, or was run but failed
     */
    public static @NonNull Future<Boolean> run(@NonNull Project project, @NonNull String command, @NonNull Lookup context) {
        Callable<Boolean> task = prepare(project, command, context);
        if (task == null) {
            task = new Callable<Boolean>() {
                @Override public Boolean call() throws Exception {
                    return false;
                }
            };
        }
        return RP.submit(task);
    }

    /**
     * Standard command to incrementally build the project.
     */
    public static final String COMMAND_BUILD = "build"; // NOI18N

    /**
     * Standard command for compiling set of files
     */
    public static final String COMMAND_COMPILE_SINGLE = "compile.single"; // NOI18N

    /**
     * Standard command to clean build products.
     */
    public static final String COMMAND_CLEAN = "clean"; // NOI18N

    /**
     * Standard command to do a "clean" (forced) rebuild.
     */
    public static final String COMMAND_REBUILD = "rebuild"; // NOI18N

    /**
     * Standard command for running the project
     */
    public static final String COMMAND_RUN = "run"; // NOI18N

    /**
     * Standard command for running one file
     *
     * @see  SingleMethod#COMMAND_RUN_SINGLE_METHOD
     */
    public static final String COMMAND_RUN_SINGLE = "run.single"; // NOI18N

    /**
     * Standard command for running tests on given projects
     */
    public static final String COMMAND_TEST = "test"; // NOI18N

    /**
     * Standard command for running one test file
     */
    public static final String COMMAND_TEST_SINGLE = "test.single";  // NOI18N

    /**
     * Standard command for running the project in debugger
     */
    public static final String COMMAND_DEBUG = "debug"; // NOI18N

    /**
     * Standard command for running single file in debugger
     *
     * @see  SingleMethod#COMMAND_DEBUG_SINGLE_METHOD
     */
    public static final String COMMAND_DEBUG_SINGLE = "debug.single"; // NOI18N

    /**
     * Standard command for running one test in debugger
     */
    public static final String COMMAND_DEBUG_TEST_SINGLE = "debug.test.single"; // NOI18N

    /**
     * Standard command for starting app in debugger and stopping at the
     * beginning of app whatever that means.
     */
    public static final String COMMAND_DEBUG_STEP_INTO = "debug.stepinto"; // NOI18N

    /**
     * Standard command for deleting the project.
     */
    public static final String COMMAND_DELETE = "delete"; // NOI18N

    /**
     * Standard command for deleting the project.
     */
    public static final String COMMAND_COPY = "copy"; // NOI18N

    /**
     * Standard command for moving the project.
     */
    public static final String COMMAND_MOVE = "move"; // NOI18N

    /**
     * Standard command for renaming the project.
     */
    public static final String COMMAND_RENAME = "rename"; // NOI18N

    private ProjectActions() {}

}





package org.netbeans.spi.project;

import org.netbeans.api.project.ProjectActions;
import org.openide.util.ContextAwareAction;
import org.openide.util.Lookup;


 * @see <a href="@org-netbeans-modules-projectuiapi@/org/netbeans/spi/project/ui/support/ProjectSensitiveActions.html#projectCommandAction(java.lang.String,%20java.lang.String,%20javax.swing.Icon)"><code>ProjectSensitiveActions.projectCommandAction(...)</code></a>
 * @see SingleMethod
 * @author Jesse Glick
 * @deprecated Use {@link ActionProvider2} and {@link ProjectActions} instead.
 */
@Deprecated
public interface ActionProvider {
    
    String COMMAND_BUILD = ProjectActions.COMMAND_BUILD;
    String COMMAND_COMPILE_SINGLE = ProjectActions.COMMAND_COMPILE_SINGLE;
    String COMMAND_CLEAN = ProjectActions.COMMAND_CLEAN;
    String COMMAND_REBUILD = ProjectActions.COMMAND_REBUILD;
    String COMMAND_RUN = ProjectActions.COMMAND_RUN;
    String COMMAND_RUN_SINGLE = ProjectActions.COMMAND_RUN_SINGLE;
    String COMMAND_TEST = ProjectActions.COMMAND_TEST;
    String COMMAND_TEST_SINGLE = ProjectActions.COMMAND_TEST_SINGLE;
    String COMMAND_DEBUG = ProjectActions.COMMAND_DEBUG;
    String COMMAND_DEBUG_SINGLE = ProjectActions.COMMAND_DEBUG_SINGLE;
    String COMMAND_DEBUG_TEST_SINGLE = ProjectActions.COMMAND_DEBUG_TEST_SINGLE;
    String COMMAND_DEBUG_STEP_INTO = ProjectActions.COMMAND_DEBUG_STEP_INTO;
    String COMMAND_DELETE = ProjectActions.COMMAND_DELETE;
    String COMMAND_COPY = ProjectActions.COMMAND_COPY;
    String COMMAND_MOVE = ProjectActions.COMMAND_MOVE;
    String COMMAND_RENAME = ProjectActions.COMMAND_RENAME;
     * Standard command to do a "clean" (forced) rebuild.
     */
    String COMMAND_REBUILD = "rebuild"; // NOI18N
        
    /** 
     * Standard command for running the project
     */
    String COMMAND_RUN = "run"; // NOI18N

    /** 
     * Standard command for running one file
     *
     * @see  SingleMethod#COMMAND_RUN_SINGLE_METHOD
     */
    String COMMAND_RUN_SINGLE = "run.single"; // NOI18N
    
    /** 
     * Standard command for running tests on given projects
     */
    String COMMAND_TEST = "test"; // NOI18N
    
    /** 
     * Standard command for running one test file
     */    
    String COMMAND_TEST_SINGLE = "test.single";  // NOI18N
    
    /**
     * Standard command for running the project in debugger
     */    
    String COMMAND_DEBUG = "debug"; // NOI18N
    
    /**
     * Standard command for running single file in debugger
     *
     * @see  SingleMethod#COMMAND_DEBUG_SINGLE_METHOD
     */    
    String COMMAND_DEBUG_SINGLE = "debug.single"; // NOI18N
    
    /** 
     * Standard command for running one test in debugger
     */
    String COMMAND_DEBUG_TEST_SINGLE = "debug.test.single"; // NOI18N
    
    /** 
     * Standard command for starting app in debugger and stopping at the 
     * beginning of app whatever that means.
     */
    String COMMAND_DEBUG_STEP_INTO = "debug.stepinto"; // NOI18N
    
    /**
     * Standard command for deleting the project.
     *
     * @since 1.6
     */
    String COMMAND_DELETE = "delete"; // NOI18N
    
    /**
     * Standard command for deleting the project.
     *
     * @since 1.7
     */
    String COMMAND_COPY = "copy"; // NOI18N
    
    /**
     * Standard command for moving the project.
     *
     * @since 1.7
     */
    String COMMAND_MOVE = "move"; // NOI18N

    /**
     * Standard command for renaming the project.
     *
     * @since 1.7
     */
    String COMMAND_RENAME = "rename"; // NOI18N
    
    /**
     * Get a list of all commands which this project supports.




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */

package org.netbeans.spi.project;

import java.util.concurrent.Callable;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.openide.util.ContextAwareAction;
import org.openide.util.Lookup;

/**
 * Ability for a project to have various actions (such as Build) invoked on it.
 * Should be registered in a project's lookup and will be used by UI infrastructure.
 * Do not search for this service in a project's lookup directly; use {@link ProjectActions} instead.
 * <p>
 * Implementations supporting single file commands (command constants ending with
 * {@code _SINGLE}) can also be registered in default lookup. If a provider in project
 * lookup does not enable the action for a given command on the selected file then
 * the first implementation found in default lookup that is enabled will be used.
 * </p>
 * @see Project#getLookup
 * @see ProjectActions
 * @see <a href="@org-apache-tools-ant-module@/org/apache/tools/ant/module/api/support/ActionUtils.html"><code>ActionUtils</code></a>
 * @see <a href="@org-netbeans-modules-projectuiapi@/org/netbeans/spi/project/ui/support/ProjectSensitiveActions.html#projectCommandAction(java.lang.String,%20java.lang.String,%20javax.swing.Icon)"><code>ProjectSensitiveActions.projectCommandAction(...)</code></a>
 * @since XXX
 */
public interface ActionProvider2 {

    /**
     * Prepare to run a command.
     * @param command a predefined command name, such as those given in {@link ProjectActions}
     * @param context any action context, e.g. for a node selection
     *                (as in {@link ContextAwareAction})
     * @return null if the command is unrecognized or it would be disabled in this context;
     *          else a task which should block until the action completes and return true if it succeeded,
     *          false if it failed in some way (e.g. compilation failed)
     */
    @CheckForNull Callable<Boolean> prepare(@NonNull String command, @NonNull Lookup context);

}




import javax.swing.event.ChangeListener;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.spi.project.ActionProvider2;
import org.netbeans.spi.project.LookupMerger;
import org.netbeans.spi.project.LookupProvider;
import org.openide.util.ChangeSupport;

     * enabled on it_will perform it.
     * @return instance to include in project lookup
     * @since 1.38
     * @deprecated Use {@link ActionProvider2} instead (no need for a merger).
     */
    @Deprecated
    public static LookupMerger<org.netbeans.spi.project.ActionProvider> createActionProviderMerger() {
        return new ActionProviderMerger();
    }


        }
    }

    @Deprecated
    private static final class ActionProviderMerger implements LookupMerger<org.netbeans.spi.project.ActionProvider> {
        @Override
        public Class<org.netbeans.spi.project.ActionProvider> getMergeableClass() {
            return org.netbeans.spi.project.ActionProvider.class;
        }

        @Override
        public org.netbeans.spi.project.ActionProvider merge(final Lookup lookup) {
            return new MergedActionProvider(lookup);
        }
    }

    @Deprecated
    private static final class MergedActionProvider implements org.netbeans.spi.project.ActionProvider, LookupListener {

        private final Lookup.Result<org.netbeans.spi.project.ActionProvider> lkpResult;
        @SuppressWarnings("VolatileArrayField")
        private volatile String[] actionNamesCache;

        private MergedActionProvider(final Lookup lkp) {
            this.lkpResult = lkp.lookupResult(org.netbeans.spi.project.ActionProvider.class);
            this.lkpResult.addLookupListener(this);
        }


            String[] result = actionNamesCache;
            if (result == null) {
                final Set<String> actionNames = new LinkedHashSet <String>();
                for (org.netbeans.spi.project.ActionProvider ap : lkpResult.allInstances()) {
                    actionNames.addAll(Arrays.asList(ap.getSupportedActions()));
                }
                result = actionNames.toArray(new String[actionNames.size()]);

        @Override
        public boolean isActionEnabled(String command, Lookup context) throws IllegalArgumentException {
            boolean found = false;
            for (org.netbeans.spi.project.ActionProvider ap : lkpResult.allInstances()) {
                if (Arrays.asList(ap.getSupportedActions()).contains(command)) {
                    if (ap.isActionEnabled(command, context)) {
                        return true;


        @Override
        public void invokeAction(String command, Lookup context) throws IllegalArgumentException {
            for (org.netbeans.spi.project.ActionProvider ap : lkpResult.allInstances()) {
                if (Arrays.asList(ap.getSupportedActions()).contains(command) &&
                    ap.isActionEnabled(command, context)) {
                    ap.invokeAction(command, context);




import java.util.Map;
import javax.swing.Icon;
import javax.swing.event.ChangeListener;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.junit.NbTestCase;

    public void testActionProviderMerger() throws Exception {
        final ActionProviderImpl ap1 = new ActionProviderImpl(new LinkedHashMap<String,Boolean>(){
            {
                put(ProjectActions.COMMAND_CLEAN,Boolean.TRUE);
                put(ProjectActions.COMMAND_BUILD,Boolean.TRUE);
                put(ProjectActions.COMMAND_REBUILD,Boolean.TRUE);
                put(ProjectActions.COMMAND_COMPILE_SINGLE,Boolean.FALSE);
            }
        });
        final ActionProviderImpl ap2 = new ActionProviderImpl(new LinkedHashMap<String,Boolean>(){
            {
                put(ProjectActions.COMMAND_RUN,Boolean.TRUE);
                put(ProjectActions.COMMAND_TEST,Boolean.TRUE);
                put(ProjectActions.COMMAND_DEBUG,Boolean.FALSE);
                put(ProjectActions.COMMAND_COMPILE_SINGLE,Boolean.TRUE);
            }
        });


        assertEquals(ActionProvider.class,merger.getMergeableClass());
        final ActionProvider ap = merger.merge(Lookups.fixed(ap1,ap2));
        assertEquals(Arrays.asList(new String[] {
                ProjectActions.COMMAND_CLEAN,
                ProjectActions.COMMAND_BUILD,
                ProjectActions.COMMAND_REBUILD,
                ProjectActions.COMMAND_COMPILE_SINGLE,
                ProjectActions.COMMAND_RUN,
                ProjectActions.COMMAND_TEST,
                ProjectActions.COMMAND_DEBUG,
            }),
            Arrays.asList(ap.getSupportedActions()));
        assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_CLEAN, Lookup.EMPTY));
        assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_BUILD, Lookup.EMPTY));
        assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_REBUILD, Lookup.EMPTY));
        assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, Lookup.EMPTY));
        assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_RUN, Lookup.EMPTY));
        assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_TEST, Lookup.EMPTY));
        assertFalse(ap.isActionEnabled(ProjectActions.COMMAND_DEBUG, Lookup.EMPTY));
        try {
            ap.isActionEnabled(ProjectActions.COMMAND_MOVE, Lookup.EMPTY);
            throw new AssertionError("IAE should be thrown");   //NOI18N
        } catch (IllegalArgumentException iae) {
            assertEquals(ProjectActions.COMMAND_MOVE, iae.getMessage());
        }
        ap.invokeAction(ProjectActions.COMMAND_CLEAN, Lookup.EMPTY);
        assertEquals(ProjectActions.COMMAND_CLEAN,ap1.cleanInvokedTarget());
        assertNull(ap2.cleanInvokedTarget());
        ap.invokeAction(ProjectActions.COMMAND_BUILD, Lookup.EMPTY);
        assertEquals(ProjectActions.COMMAND_BUILD,ap1.cleanInvokedTarget());
        assertNull(ap2.cleanInvokedTarget());
        ap.invokeAction(ProjectActions.COMMAND_REBUILD, Lookup.EMPTY);
        assertEquals(ProjectActions.COMMAND_REBUILD,ap1.cleanInvokedTarget());
        assertNull(ap2.cleanInvokedTarget());
        ap.invokeAction(ProjectActions.COMMAND_COMPILE_SINGLE, Lookup.EMPTY);
        assertNull(ap1.cleanInvokedTarget());
        assertEquals(ProjectActions.COMMAND_COMPILE_SINGLE,ap2.cleanInvokedTarget());
        ap.invokeAction(ProjectActions.COMMAND_RUN, Lookup.EMPTY);
        assertNull(ap1.cleanInvokedTarget());
        assertEquals(ProjectActions.COMMAND_RUN,ap2.cleanInvokedTarget());
        ap.invokeAction(ProjectActions.COMMAND_TEST, Lookup.EMPTY);
        assertNull(ap1.cleanInvokedTarget());
        assertEquals(ProjectActions.COMMAND_TEST,ap2.cleanInvokedTarget());
        try {
            ap.invokeAction(ProjectActions.COMMAND_DEBUG, Lookup.EMPTY);
            throw new AssertionError("IAE should be thrown");   //NOI18N
        } catch (IllegalArgumentException iae) {
            assertEquals(ProjectActions.COMMAND_DEBUG, iae.getMessage());
        }
        try {
            ap.invokeAction(ProjectActions.COMMAND_MOVE, Lookup.EMPTY);
            throw new AssertionError("IAE should be thrown");   //NOI18N
        } catch (IllegalArgumentException iae) {
            assertEquals(ProjectActions.COMMAND_MOVE, iae.getMessage());
        }
    }





import org.netbeans.api.annotations.common.StaticResource;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.spi.project.ProjectIconAnnotator;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.spi.project.ActionProvider;
import org.netbeans.spi.project.ui.LogicalViewProvider;
import org.openide.filesystems.FileChangeAdapter;
import org.openide.filesystems.FileChangeListener;

import org.openide.filesystems.FileStatusListener;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Children;
import org.openide.nodes.FilterNode;

            if (p == null) {
                return false;
            }
            return ProjectActions.prepare(p, ProjectActions.COMMAND_DELETE, getLookup()) != null;

            String[] sa = ap != null ? ap.getSupportedActions() : new String[0];
            int k = sa.length;

            for (int i = 0; i < k; i++) {
                if (ActionProvider.COMMAND_DELETE.equals(sa[i])) {
                    return ap.isActionEnabled(ActionProvider.COMMAND_DELETE, getLookup());
                }
            }
            return false;
        }

        @Override

            if (p == null) {
                return;
            }
            ProjectActions.run(p, ProjectActions.COMMAND_DELETE, getLookup());
            ap.invokeAction(ActionProvider.COMMAND_DELETE, getLookup());
        }
    } // end of BadgingNode
    private static final class BadgingLookup extends ProxyLookup {




import java.beans.PropertyChangeListener;
import javax.swing.Action;
import javax.swing.Icon;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.modules.project.uiapi.ActionsFactory;
import org.netbeans.spi.project.ActionProvider;
import org.netbeans.spi.project.ui.support.FileActionPerformer;
import org.netbeans.spi.project.ui.support.ProjectActionPerformer;
import org.openide.util.ContextAwareAction;
import org.openide.util.Exceptions;
import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.actions.SystemAction;


    
    public static Action testProject() {        
        Action a = new ProjectAction (
            ProjectActions.COMMAND_TEST,
            NbBundle.getMessage(Actions.class, "LBL_TestProjectAction_Name"),
            NbBundle.getMessage(Actions.class, "LBL_TestProjectAction_Name_popup"),
            ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/testProject.png", false),

    
    public static Action buildProject() {
        Action a = new ProjectAction (
            ProjectActions.COMMAND_BUILD,
            NbBundle.getMessage(Actions.class, "LBL_BuildProjectAction_Name"),
            NbBundle.getMessage(Actions.class, "LBL_BuildProjectAction_Name_popup"),
            ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/buildCurrentProject.gif", false),

    }
    
    public static Action cleanProject() {
        @SuppressWarnings("deprecation")
        Action a = new ProjectAction(
                ProjectActions.COMMAND_CLEAN,
                NbBundle.getMessage(Actions.class, "LBL_CleanProjectAction_Name"),
                NbBundle.getMessage(Actions.class, "LBL_CleanProjectAction_Name_popup"),
                ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/cleanCurrentProject.gif", false),

    
    public static Action rebuildProject() {
        Action a = new ProjectAction(
            ProjectActions.COMMAND_REBUILD,
            NbBundle.getMessage(Actions.class, "LBL_RebuildProjectAction_Name"),
            NbBundle.getMessage(Actions.class, "LBL_RebuildProjectAction_Name_popup"),
            ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/rebuildCurrentProject.gif", false),

        
    public static Action runProject() {
        Action a = new ProjectAction(
            ProjectActions.COMMAND_RUN,
            NbBundle.getMessage(Actions.class, "LBL_RunProjectAction_Name"),
            NbBundle.getMessage(Actions.class, "LBL_RunProjectAction_Name_popup"),
            ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runCurrentProject.gif", false),

    
    public static synchronized Action deleteProject() {
        final Action a = new ProjectAction(
            ProjectActions.COMMAND_DELETE,
            NbBundle.getMessage(Actions.class, "LBL_DeleteProjectAction_Name"),
            null,
            null );

    public static synchronized Action copyProject() {
        if (COPY_PROJECT == null) {
            Action a = new ProjectAction(
                    ProjectActions.COMMAND_COPY,
		    NbBundle.getMessage(Actions.class, "LBL_CopyProjectAction_Name"),
                    null, //NOI18N
                    null );

    public static synchronized Action moveProject() {
        if (MOVE_PROJECT == null) {
            Action a = new ProjectAction(
                    ProjectActions.COMMAND_MOVE,
		    NbBundle.getMessage(Actions.class, "LBL_MoveProjectAction_Name"),
                    null, //NOI18N
                    null );

    public static synchronized Action renameProject() {
        if (RENAME_PROJECT == null) {
            Action a = new ProjectAction(
                    ProjectActions.COMMAND_RENAME,
		    NbBundle.getMessage(Actions.class, "LBL_RenameProjectAction_Name"),
                    null, //NOI18N
                    null );

    
    public static Action compileSingle() {
        Action a = new FileAction(
            ProjectActions.COMMAND_COMPILE_SINGLE,
            NbBundle.getMessage(Actions.class, "LBL_CompileSingleAction_Name"),
            ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/compileSingle.png", true),
            null);

    
    public static Action runSingle() {
        Action a = new FileAction(
            ProjectActions.COMMAND_RUN_SINGLE,
            NbBundle.getMessage(Actions.class, "LBL_RunSingleAction_Name"),
            ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runSingle.png", true),
            null);

    
    public static Action testSingle() {
        Action a = new FileAction(
            ProjectActions.COMMAND_TEST_SINGLE,
            NbBundle.getMessage(Actions.class, "LBL_TestSingleAction_Name"),
            ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/testSingle.png", true),
            null);


    public static Action buildMainProject() {
        Action a = new MainProjectAction (
            ProjectActions.COMMAND_BUILD,
            NbBundle.getMessage(Actions.class, "LBL_BuildMainProjectAction_Name" ),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/buildProject.png", false));  //NOI18N
        a.putValue("iconBase","org/netbeans/modules/project/ui/resources/buildProject.png"); //NOI18N
        return a;

    
    public static Action cleanMainProject() {
        Action a = new MainProjectAction(
                ProjectActions.COMMAND_CLEAN,
                NbBundle.getMessage(Actions.class, "LBL_CleanMainProjectAction_Name" ),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/cleanProject.gif", false));  //NOI18N
        a.putValue("iconBase","org/netbeans/modules/project/ui/resources/cleanProject.gif"); //NOI18N
        return a;


    public static Action rebuildMainProject() {
        Action a = new MainProjectAction(
            ProjectActions.COMMAND_REBUILD,
            NbBundle.getMessage(Actions.class, "LBL_RebuildMainProjectAction_Name"),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/rebuildProject.png", false)); //NOI18N
        a.putValue("iconBase","org/netbeans/modules/project/ui/resources/rebuildProject.png"); //NOI18N
        return a;

        
    public static Action runMainProject() {
        Action a = new MainProjectAction(
            ProjectActions.COMMAND_RUN,
            NbBundle.getMessage(Actions.class, "LBL_RunMainProjectAction_Name"),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runProject.png", false)); //NOI18N
        a.putValue("iconBase","org/netbeans/modules/project/ui/resources/runProject.png"); //NOI18N
        return a;




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

import java.text.MessageFormat;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.swing.Action;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectUtils;
import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;
import org.openide.util.Lookup;
import org.openide.util.RequestProcessor;
import org.openide.util.WeakSet;

/** Nice utility methods to be used in ProjectBased Actions

    public static LookupResultsCache lookupResultsCache;
     */
    
    public static final RequestProcessor RP = new RequestProcessor(ActionsUtil.class.getName(), Integer.MAX_VALUE);

    public static final ShortcutsManager SHORCUTS_MANAGER = new ShortcutsManager();
    
    public static HashMap<String,MessageFormat> pattern2format = new HashMap<String,MessageFormat>(); 

     *                does not matter.
     */    
    public static boolean commandSupported( Project project, String command, Lookup context ) {
        return ProjectActions.prepare(project, command, context) != null;
        ActionProvider ap = project.getLookup().lookup(ActionProvider.class);
        if ( ap != null ) {
            List commands = Arrays.asList( ap.getSupportedActions() );
            if ( commands.contains( command ) ) {
                if (context == null || ap.isActionEnabled(command, context)) {
                    //System.err.println("cS: true project=" + project + " command=" + command + " context=" + context);
                    return true;
                }
            }
        }            
        //System.err.println("cS: false project=" + project + " command=" + command + " context=" + context);
        return false;
    }
    
    





import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.Callable;
import javax.swing.Action;
import javax.swing.Icon;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.spi.project.ActionProvider;
import org.netbeans.spi.project.ActionProvider2;
import org.netbeans.spi.project.ui.support.FileActionPerformer;
import org.openide.awt.Actions;
import org.openide.filesystems.FileObject;

import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.Mutex;
import org.openide.util.RequestProcessor;

/** An action sensitive to selected node. Used for 1-off actions
 */
public final class FileAction extends LookupSensitiveAction implements ContextAwareAction {

    private String command;
    private FileActionPerformer performer;
    private final String namePattern;

        if (command != null) {
            Project[] projects = ActionsUtil.getProjectsFromLookup( context, command );

            if ( projects.length == 1 ) {
                ProjectActions.run(projects[0], command, context);
                ap.invokeAction( command, context );
                return;
            }

            Callable<Boolean> provider = globalProvider(context);
            if (provider != null) {
                ActionsUtil.RP.submit(provider);
            }
        } else if (performer != null) {
            Collection<? extends DataObject> dobjs = context.lookupAll(DataObject.class);

        return new FileAction( command, performer, namePattern, (Icon)getValue( SMALL_ICON ), actionContext );
    }

    @SuppressWarnings("deprecation")
    private Callable<Boolean> globalProvider(final Lookup context) {
        for (ActionProvider2 ap2 : Lookup.getDefault().lookupAll(ActionProvider2.class)) {
            Callable<Boolean> c = ap2.prepare(command, context);
            if (c != null) {
                return c;
            }
        }
        for (final ActionProvider ap : Lookup.getDefault().lookupAll(ActionProvider.class)) {
            if (Arrays.asList(ap.getSupportedActions()).contains(command) && ap.isActionEnabled(command, context)) {
                return new Callable<Boolean>() {
                    @Override public Boolean call() throws Exception {
                        ap.invokeAction(command, context);
                        return true;
                    }
                };
            }
        }
        return null;




import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.text.MessageFormat;
import java.util.concurrent.Callable;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.ui.OpenProjects;
import org.netbeans.modules.project.ui.NoMainProjectWarning;
import org.netbeans.modules.project.ui.OpenProjectList;
import org.netbeans.spi.project.ActionProvider;
import org.netbeans.spi.project.ui.support.ProjectActionPerformer;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;

        }

        if ( command != null ) {
            Callable<Boolean> task = ProjectActions.prepare(p, command, Lookup.EMPTY);
            if (task != null) {
                ActionsUtil.RP.submit(task);
            } else {
                // #47160: was a supported command (e.g. on a freeform project) but was then removed.
                Toolkit.getDefaultToolkit().beep();
                refreshView(null, false);
                    refreshView(null, false);
                }
            }
        }
        else {




import javax.swing.Action;
import javax.swing.Icon;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.spi.project.ui.support.ProjectActionPerformer;
import org.openide.awt.Actions;
import org.openide.awt.DynamicMenuContent;

        
        if ( projects.length == 1 ) {
            if ( command != null ) {
                ActionProvider ap = projects[0].getLookup().lookup(ActionProvider.class);
                LogRecord r = new LogRecord(Level.FINE, "PROJECT_ACTION"); // NOI18N
                r.setResourceBundle(NbBundle.getBundle(ProjectAction.class));
                r.setParameters(new Object[] {

                });
                r.setLoggerName(UILOG.getName());
                UILOG.log(r);
                ProjectActions.run(projects[0], command, Lookup.EMPTY);
            }
            else if ( performer != null ) {
                performer.perform( projects[0] );




import javax.swing.Icon;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.annotations.common.NullAllowed;
import org.netbeans.api.project.ProjectActions;
import org.netbeans.modules.project.uiapi.Utilities;
import org.netbeans.spi.project.ActionProvider2;

/**
 * Factory for creating file-sensitive actions.


    /**
     * Creates an action sensitive to the set of currently selected files.
     * When performed the action will call the given command using {@link ProjectActions} on
     * the selected project(s) and pass the proper context to it. Enablement of the
     * action depends on the behavior of the project's action provider.
     * <p>As mentioned in {@link ProjectActions} Javadoc, the action may also be enabled
     * without the participation of any project in case some globally registered {@link ActionProvider2}
     * can provide an implementation.
     * (This since {@code org.netbeans.modules.projectuiapi/1 1.37}.)
     * <p>Shortcuts for actions are shared according to command, i.e. actions based on the same command

Return to bug 71515

Lines 68-73 Link Here

(-)a/maven/src/org/netbeans/modules/maven/customizer/RunJarPanel.java (-4 / +5 lines)
68	import org.netbeans.modules.maven.classpath.MavenSourcesImpl;	68	import org.netbeans.modules.maven.classpath.MavenSourcesImpl;
69	import org.netbeans.modules.maven.NbMavenProjectImpl;	69	import org.netbeans.modules.maven.NbMavenProjectImpl;
70	import org.netbeans.api.java.project.JavaProjectConstants;	70	import org.netbeans.api.java.project.JavaProjectConstants;
		71	import org.netbeans.api.project.ProjectActions;
71	import org.netbeans.api.project.ProjectUtils;	72	import org.netbeans.api.project.ProjectUtils;
72	import org.netbeans.api.project.SourceGroup;	73	import org.netbeans.api.project.SourceGroup;
73	import org.netbeans.api.project.Sources;	74	import org.netbeans.api.project.Sources;
Lines 197-206 Link Here
197	@SuppressWarnings("unchecked")	198	@SuppressWarnings("unchecked")
198	List<NetbeansActionMapping> lst = mapp.getActions();	199	List<NetbeansActionMapping> lst = mapp.getActions();
199	for (NetbeansActionMapping m : lst) {	200	for (NetbeansActionMapping m : lst) {
200	if (ActionProvider.COMMAND_RUN.equals(m.getActionName())) {	201	if (ProjectActions.COMMAND_RUN.equals(m.getActionName())) {
201	run = m;	202	run = m;
202	}	203	}
203	if (ActionProvider.COMMAND_DEBUG.equals(m.getActionName())) {	204	if (ProjectActions.COMMAND_DEBUG.equals(m.getActionName())) {
204	debug = m;	205	debug = m;
205	}	206	}
206	if (PROFILE_CMD.equals(m.getActionName())) {	207	if (PROFILE_CMD.equals(m.getActionName())) {
Lines 208-217 Link Here
208	}	209	}
209	}	210	}
210	if (run == null) {	211	if (run == null) {
211	run = ModelHandle.getDefaultMapping(ActionProvider.COMMAND_RUN, project);	212	run = ModelHandle.getDefaultMapping(ProjectActions.COMMAND_RUN, project);
212	}	213	}
213	if (debug == null) {	214	if (debug == null) {
214	debug = ModelHandle.getDefaultMapping(ActionProvider.COMMAND_DEBUG, project);	215	debug = ModelHandle.getDefaultMapping(ProjectActions.COMMAND_DEBUG, project);
215	}	216	}
216	if (profile == null) {	217	if (profile == null) {
217	profile = ModelHandle.getDefaultMapping(PROFILE_CMD, project);	218	profile = ModelHandle.getDefaultMapping(PROFILE_CMD, project);

Lines 55-60 Link Here

(-)a/projectapi/test/unit/src/org/netbeans/spi/project/support/LookupProviderSupportTest.java (-40 / +41 lines)
55	import java.util.Map;	55	import java.util.Map;
56	import javax.swing.Icon;	56	import javax.swing.Icon;
57	import javax.swing.event.ChangeListener;	57	import javax.swing.event.ChangeListener;
		58	import org.netbeans.api.project.ProjectActions;
58	import org.netbeans.api.project.SourceGroup;	59	import org.netbeans.api.project.SourceGroup;
59	import org.netbeans.api.project.Sources;	60	import org.netbeans.api.project.Sources;
60	import org.netbeans.junit.NbTestCase;	61	import org.netbeans.junit.NbTestCase;
Lines 149-166 Link Here
149	public void testActionProviderMerger() throws Exception {	150	public void testActionProviderMerger() throws Exception {
150	final ActionProviderImpl ap1 = new ActionProviderImpl(new LinkedHashMap<String,Boolean>(){	151	final ActionProviderImpl ap1 = new ActionProviderImpl(new LinkedHashMap<String,Boolean>(){
151	{	152	{
152	put(ActionProvider.COMMAND_CLEAN,Boolean.TRUE);	153	put(ProjectActions.COMMAND_CLEAN,Boolean.TRUE);
153	put(ActionProvider.COMMAND_BUILD,Boolean.TRUE);	154	put(ProjectActions.COMMAND_BUILD,Boolean.TRUE);
154	put(ActionProvider.COMMAND_REBUILD,Boolean.TRUE);	155	put(ProjectActions.COMMAND_REBUILD,Boolean.TRUE);
155	put(ActionProvider.COMMAND_COMPILE_SINGLE,Boolean.FALSE);	156	put(ProjectActions.COMMAND_COMPILE_SINGLE,Boolean.FALSE);
156	}	157	}
157	});	158	});
158	final ActionProviderImpl ap2 = new ActionProviderImpl(new LinkedHashMap<String,Boolean>(){	159	final ActionProviderImpl ap2 = new ActionProviderImpl(new LinkedHashMap<String,Boolean>(){
159	{	160	{
160	put(ActionProvider.COMMAND_RUN,Boolean.TRUE);	161	put(ProjectActions.COMMAND_RUN,Boolean.TRUE);
161	put(ActionProvider.COMMAND_TEST,Boolean.TRUE);	162	put(ProjectActions.COMMAND_TEST,Boolean.TRUE);
162	put(ActionProvider.COMMAND_DEBUG,Boolean.FALSE);	163	put(ProjectActions.COMMAND_DEBUG,Boolean.FALSE);
163	put(ActionProvider.COMMAND_COMPILE_SINGLE,Boolean.TRUE);	164	put(ProjectActions.COMMAND_COMPILE_SINGLE,Boolean.TRUE);
164	}	165	}
165	});	166	});
166		167
Lines 168-224 Link Here
168	assertEquals(ActionProvider.class,merger.getMergeableClass());	169	assertEquals(ActionProvider.class,merger.getMergeableClass());
169	final ActionProvider ap = merger.merge(Lookups.fixed(ap1,ap2));	170	final ActionProvider ap = merger.merge(Lookups.fixed(ap1,ap2));
170	assertEquals(Arrays.asList(new String[] {	171	assertEquals(Arrays.asList(new String[] {
171	ActionProvider.COMMAND_CLEAN,	172	ProjectActions.COMMAND_CLEAN,
172	ActionProvider.COMMAND_BUILD,	173	ProjectActions.COMMAND_BUILD,
173	ActionProvider.COMMAND_REBUILD,	174	ProjectActions.COMMAND_REBUILD,
174	ActionProvider.COMMAND_COMPILE_SINGLE,	175	ProjectActions.COMMAND_COMPILE_SINGLE,
175	ActionProvider.COMMAND_RUN,	176	ProjectActions.COMMAND_RUN,
176	ActionProvider.COMMAND_TEST,	177	ProjectActions.COMMAND_TEST,
177	ActionProvider.COMMAND_DEBUG,	178	ProjectActions.COMMAND_DEBUG,
178	}),	179	}),
179	Arrays.asList(ap.getSupportedActions()));	180	Arrays.asList(ap.getSupportedActions()));
180	assertTrue(ap.isActionEnabled(ActionProvider.COMMAND_CLEAN, Lookup.EMPTY));	181	assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_CLEAN, Lookup.EMPTY));
181	assertTrue(ap.isActionEnabled(ActionProvider.COMMAND_BUILD, Lookup.EMPTY));	182	assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_BUILD, Lookup.EMPTY));
182	assertTrue(ap.isActionEnabled(ActionProvider.COMMAND_REBUILD, Lookup.EMPTY));	183	assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_REBUILD, Lookup.EMPTY));
183	assertTrue(ap.isActionEnabled(ActionProvider.COMMAND_COMPILE_SINGLE, Lookup.EMPTY));	184	assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_COMPILE_SINGLE, Lookup.EMPTY));
184	assertTrue(ap.isActionEnabled(ActionProvider.COMMAND_RUN, Lookup.EMPTY));	185	assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_RUN, Lookup.EMPTY));
185	assertTrue(ap.isActionEnabled(ActionProvider.COMMAND_TEST, Lookup.EMPTY));	186	assertTrue(ap.isActionEnabled(ProjectActions.COMMAND_TEST, Lookup.EMPTY));
186	assertFalse(ap.isActionEnabled(ActionProvider.COMMAND_DEBUG, Lookup.EMPTY));	187	assertFalse(ap.isActionEnabled(ProjectActions.COMMAND_DEBUG, Lookup.EMPTY));
187	try {	188	try {
188	ap.isActionEnabled(ActionProvider.COMMAND_MOVE, Lookup.EMPTY);	189	ap.isActionEnabled(ProjectActions.COMMAND_MOVE, Lookup.EMPTY);
189	throw new AssertionError("IAE should be thrown"); //NOI18N	190	throw new AssertionError("IAE should be thrown"); //NOI18N
190	} catch (IllegalArgumentException iae) {	191	} catch (IllegalArgumentException iae) {
191	assertEquals(ActionProvider.COMMAND_MOVE, iae.getMessage());	192	assertEquals(ProjectActions.COMMAND_MOVE, iae.getMessage());
192	}	193	}
193	ap.invokeAction(ActionProvider.COMMAND_CLEAN, Lookup.EMPTY);	194	ap.invokeAction(ProjectActions.COMMAND_CLEAN, Lookup.EMPTY);
194	assertEquals(ActionProvider.COMMAND_CLEAN,ap1.cleanInvokedTarget());	195	assertEquals(ProjectActions.COMMAND_CLEAN,ap1.cleanInvokedTarget());
195	assertNull(ap2.cleanInvokedTarget());	196	assertNull(ap2.cleanInvokedTarget());
196	ap.invokeAction(ActionProvider.COMMAND_BUILD, Lookup.EMPTY);	197	ap.invokeAction(ProjectActions.COMMAND_BUILD, Lookup.EMPTY);
197	assertEquals(ActionProvider.COMMAND_BUILD,ap1.cleanInvokedTarget());	198	assertEquals(ProjectActions.COMMAND_BUILD,ap1.cleanInvokedTarget());
198	assertNull(ap2.cleanInvokedTarget());	199	assertNull(ap2.cleanInvokedTarget());
199	ap.invokeAction(ActionProvider.COMMAND_REBUILD, Lookup.EMPTY);	200	ap.invokeAction(ProjectActions.COMMAND_REBUILD, Lookup.EMPTY);
200	assertEquals(ActionProvider.COMMAND_REBUILD,ap1.cleanInvokedTarget());	201	assertEquals(ProjectActions.COMMAND_REBUILD,ap1.cleanInvokedTarget());
201	assertNull(ap2.cleanInvokedTarget());	202	assertNull(ap2.cleanInvokedTarget());
202	ap.invokeAction(ActionProvider.COMMAND_COMPILE_SINGLE, Lookup.EMPTY);	203	ap.invokeAction(ProjectActions.COMMAND_COMPILE_SINGLE, Lookup.EMPTY);
203	assertNull(ap1.cleanInvokedTarget());	204	assertNull(ap1.cleanInvokedTarget());
204	assertEquals(ActionProvider.COMMAND_COMPILE_SINGLE,ap2.cleanInvokedTarget());	205	assertEquals(ProjectActions.COMMAND_COMPILE_SINGLE,ap2.cleanInvokedTarget());
205	ap.invokeAction(ActionProvider.COMMAND_RUN, Lookup.EMPTY);	206	ap.invokeAction(ProjectActions.COMMAND_RUN, Lookup.EMPTY);
206	assertNull(ap1.cleanInvokedTarget());	207	assertNull(ap1.cleanInvokedTarget());
207	assertEquals(ActionProvider.COMMAND_RUN,ap2.cleanInvokedTarget());	208	assertEquals(ProjectActions.COMMAND_RUN,ap2.cleanInvokedTarget());
208	ap.invokeAction(ActionProvider.COMMAND_TEST, Lookup.EMPTY);	209	ap.invokeAction(ProjectActions.COMMAND_TEST, Lookup.EMPTY);
209	assertNull(ap1.cleanInvokedTarget());	210	assertNull(ap1.cleanInvokedTarget());
210	assertEquals(ActionProvider.COMMAND_TEST,ap2.cleanInvokedTarget());	211	assertEquals(ProjectActions.COMMAND_TEST,ap2.cleanInvokedTarget());
211	try {	212	try {
212	ap.invokeAction(ActionProvider.COMMAND_DEBUG, Lookup.EMPTY);	213	ap.invokeAction(ProjectActions.COMMAND_DEBUG, Lookup.EMPTY);
213	throw new AssertionError("IAE should be thrown"); //NOI18N	214	throw new AssertionError("IAE should be thrown"); //NOI18N
214	} catch (IllegalArgumentException iae) {	215	} catch (IllegalArgumentException iae) {
215	assertEquals(ActionProvider.COMMAND_DEBUG, iae.getMessage());	216	assertEquals(ProjectActions.COMMAND_DEBUG, iae.getMessage());
216	}	217	}
217	try {	218	try {
218	ap.invokeAction(ActionProvider.COMMAND_MOVE, Lookup.EMPTY);	219	ap.invokeAction(ProjectActions.COMMAND_MOVE, Lookup.EMPTY);
219	throw new AssertionError("IAE should be thrown"); //NOI18N	220	throw new AssertionError("IAE should be thrown"); //NOI18N
220	} catch (IllegalArgumentException iae) {	221	} catch (IllegalArgumentException iae) {
221	assertEquals(ActionProvider.COMMAND_MOVE, iae.getMessage());	222	assertEquals(ProjectActions.COMMAND_MOVE, iae.getMessage());
222	}	223	}
223	}	224	}
224		225

Lines 55-66 Link Here

(-)a/java.j2seproject/src/org/netbeans/modules/java/j2seproject/J2SEProjectOperations.java (-2 / +2 lines)
55	import org.apache.tools.ant.module.api.support.ActionUtils;	55	import org.apache.tools.ant.module.api.support.ActionUtils;
56	import org.netbeans.api.project.FileOwnerQuery;	56	import org.netbeans.api.project.FileOwnerQuery;
57	import org.netbeans.api.project.Project;	57	import org.netbeans.api.project.Project;
		58	import org.netbeans.api.project.ProjectActions;
58	import org.netbeans.api.project.ProjectInformation;	59	import org.netbeans.api.project.ProjectInformation;
59	import org.netbeans.api.project.ProjectManager;	60	import org.netbeans.api.project.ProjectManager;
60	import org.netbeans.api.project.ProjectUtils;	61	import org.netbeans.api.project.ProjectUtils;
61	import org.netbeans.modules.java.api.common.project.ProjectProperties;	62	import org.netbeans.modules.java.api.common.project.ProjectProperties;
62	import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;	63	import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;
63	import org.netbeans.spi.project.ActionProvider;
64	import org.netbeans.spi.project.CopyOperationImplementation;	64	import org.netbeans.spi.project.CopyOperationImplementation;
65	import org.netbeans.spi.project.DeleteOperationImplementation;	65	import org.netbeans.spi.project.DeleteOperationImplementation;
66	import org.netbeans.spi.project.MoveOrRenameOperationImplementation;	66	import org.netbeans.spi.project.MoveOrRenameOperationImplementation;
Lines 152-158 Link Here
152	Properties p = new Properties();	152	Properties p = new Properties();
153	final AntTargetsProvider ap = project.getLookup().lookup(AntTargetsProvider.class);	153	final AntTargetsProvider ap = project.getLookup().lookup(AntTargetsProvider.class);
154	assert ap != null;	154	assert ap != null;
155	String[] targetNames = ap.getTargetNames(ActionProvider.COMMAND_CLEAN, Lookup.EMPTY, p, false);	155	String[] targetNames = ap.getTargetNames(ProjectActions.COMMAND_CLEAN, Lookup.EMPTY, p, false);
156	FileObject buildXML = J2SEProjectUtil.getBuildXml(project);	156	FileObject buildXML = J2SEProjectUtil.getBuildXml(project);
157		157
158	assert targetNames != null;	158	assert targetNames != null;

Lines 59-64 Link Here

(-)a/maven/src/org/netbeans/modules/maven/ActionProviderImpl.java (-28 / +29 lines)
59	import org.apache.maven.artifact.Artifact;	59	import org.apache.maven.artifact.Artifact;
60	import org.apache.maven.artifact.versioning.ComparableVersion;	60	import org.apache.maven.artifact.versioning.ComparableVersion;
61	import org.netbeans.api.project.Project;	61	import org.netbeans.api.project.Project;
		62	import org.netbeans.api.project.ProjectActions;
62	import org.netbeans.api.project.ui.OpenProjects;	63	import org.netbeans.api.project.ui.OpenProjects;
63	import static org.netbeans.modules.maven.Bundle.*;	64	import static org.netbeans.modules.maven.Bundle.*;
64	import org.netbeans.modules.maven.api.Constants;	65	import org.netbeans.modules.maven.api.Constants;
Lines 115-139 Link Here
115		116
116	private final Project proj;	117	private final Project proj;
117	private static String[] supported = new String[]{	118	private static String[] supported = new String[]{
118	COMMAND_BUILD,	119	ProjectActions.COMMAND_BUILD,
119	BUILD_WITH_DEPENDENCIES,	120	BUILD_WITH_DEPENDENCIES,
120	COMMAND_CLEAN,	121	ProjectActions.COMMAND_CLEAN,
121	COMMAND_REBUILD,	122	ProjectActions.COMMAND_REBUILD,
122	"javadoc", //NOI18N	123	"javadoc", //NOI18N
123	COMMAND_TEST,	124	ProjectActions.COMMAND_TEST,
124	COMMAND_TEST_SINGLE,	125	ProjectActions.COMMAND_TEST_SINGLE,
125	COMMAND_RUN,	126	ProjectActions.COMMAND_RUN,
126	COMMAND_RUN_SINGLE,	127	ProjectActions.COMMAND_RUN_SINGLE,
127	COMMAND_DEBUG,	128	ProjectActions.COMMAND_DEBUG,
128	COMMAND_DEBUG_SINGLE,	129	ProjectActions.COMMAND_DEBUG_SINGLE,
129	COMMAND_DEBUG_TEST_SINGLE,	130	ProjectActions.COMMAND_DEBUG_TEST_SINGLE,
130	"debug.fix", //NOI18N	131	"debug.fix", //NOI18N
131		132
132	//operations	133	//operations
133	COMMAND_DELETE,	134	ProjectActions.COMMAND_DELETE,
134	COMMAND_RENAME,	135	ProjectActions.COMMAND_RENAME,
135	COMMAND_MOVE,	136	ProjectActions.COMMAND_MOVE,
136	COMMAND_COPY	137	ProjectActions.COMMAND_COPY
137	};	138	};
138		139
139	Lookup.Result<? extends MavenActionsProvider> result;	140	Lookup.Result<? extends MavenActionsProvider> result;
Lines 187-206 Link Here
187	return;	188	return;
188	}	189	}
189	}	190	}
190	if (COMMAND_DELETE.equals(action)) {	191	if (ProjectActions.COMMAND_DELETE.equals(action)) {
191	DefaultProjectOperations.performDefaultDeleteOperation(proj);	192	DefaultProjectOperations.performDefaultDeleteOperation(proj);
192	return;	193	return;
193	}	194	}
194	if (COMMAND_COPY.equals(action)) {	195	if (ProjectActions.COMMAND_COPY.equals(action)) {
195	DefaultProjectOperations.performDefaultCopyOperation(proj);	196	DefaultProjectOperations.performDefaultCopyOperation(proj);
196	return;	197	return;
197	}	198	}
198	if (COMMAND_MOVE.equals(action)) {	199	if (ProjectActions.COMMAND_MOVE.equals(action)) {
199	DefaultProjectOperations.performDefaultMoveOperation(proj);	200	DefaultProjectOperations.performDefaultMoveOperation(proj);
200	return;	201	return;
201	}	202	}
202		203
203	if (COMMAND_RENAME.equals(action)) {	204	if (ProjectActions.COMMAND_RENAME.equals(action)) {
204	Operations.renameProject(proj.getLookup().lookup(NbMavenProjectImpl.class));	205	Operations.renameProject(proj.getLookup().lookup(NbMavenProjectImpl.class));
205	return;	206	return;
206	}	207	}
Lines 263-279 Link Here
263	//#118926 prevent NPE, how come the dobj is null?	264	//#118926 prevent NPE, how come the dobj is null?
264	String dobjName = dobj != null ? dobj.getName() : ""; //NOI18N	265	String dobjName = dobj != null ? dobj.getName() : ""; //NOI18N
265		266
266	if (ActionProvider.COMMAND_RUN.equals(action)) {	267	if (ProjectActions.COMMAND_RUN.equals(action)) {
267	title = TXT_Run(prj.getMavenProject().getArtifactId());	268	title = TXT_Run(prj.getMavenProject().getArtifactId());
268	} else if (ActionProvider.COMMAND_DEBUG.equals(action)) {	269	} else if (ProjectActions.COMMAND_DEBUG.equals(action)) {
269	title = TXT_Debug(prj.getMavenProject().getArtifactId());	270	title = TXT_Debug(prj.getMavenProject().getArtifactId());
270	} else if (ActionProvider.COMMAND_TEST.equals(action)) {	271	} else if (ProjectActions.COMMAND_TEST.equals(action)) {
271	title = TXT_Test(prj.getMavenProject().getArtifactId());	272	title = TXT_Test(prj.getMavenProject().getArtifactId());
272	} else if (action.startsWith(ActionProvider.COMMAND_RUN_SINGLE)) {	273	} else if (action.startsWith(ProjectActions.COMMAND_RUN_SINGLE)) {
273	title = TXT_Run(dobjName);	274	title = TXT_Run(dobjName);
274	} else if (action.startsWith(ActionProvider.COMMAND_DEBUG_SINGLE) \|\| ActionProvider.COMMAND_DEBUG_TEST_SINGLE.equals(action)) {	275	} else if (action.startsWith(ProjectActions.COMMAND_DEBUG_SINGLE) \|\| ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(action)) {
275	title = TXT_Debug(dobjName);	276	title = TXT_Debug(dobjName);
276	} else if (ActionProvider.COMMAND_TEST_SINGLE.equals(action)) {	277	} else if (ProjectActions.COMMAND_TEST_SINGLE.equals(action)) {
277	title = TXT_Test(dobjName);	278	title = TXT_Test(dobjName);
278	} else {	279	} else {
279	title = TXT_Build(prj.getMavenProject().getArtifactId());	280	title = TXT_Build(prj.getMavenProject().getArtifactId());
Lines 283-292 Link Here
283		284
284	@Override	285	@Override
285	public boolean isActionEnabled(String action, Lookup lookup) {	286	public boolean isActionEnabled(String action, Lookup lookup) {
286	if (COMMAND_DELETE.equals(action) \|\|	287	if (ProjectActions.COMMAND_DELETE.equals(action) \|\|
287	COMMAND_RENAME.equals(action) \|\|	288	ProjectActions.COMMAND_RENAME.equals(action) \|\|
288	COMMAND_COPY.equals(action) \|\|	289	ProjectActions.COMMAND_COPY.equals(action) \|\|
289	COMMAND_MOVE.equals(action)) {	290	ProjectActions.COMMAND_MOVE.equals(action)) {
290	return true;	291	return true;
291	}	292	}
292	if (action.equals(SingleMethod.COMMAND_RUN_SINGLE_METHOD) \|\| action.equals(SingleMethod.COMMAND_DEBUG_SINGLE_METHOD)) {	293	if (action.equals(SingleMethod.COMMAND_RUN_SINGLE_METHOD) \|\| action.equals(SingleMethod.COMMAND_DEBUG_SINGLE_METHOD)) {

Lines 42-47 Link Here

(-)a/maven/src/org/netbeans/modules/maven/TestChecker.java (-3 / +4 lines)
42		42
43	package org.netbeans.modules.maven;	43	package org.netbeans.modules.maven;
44		44
		45	import org.netbeans.api.project.ProjectActions;
45	import org.netbeans.modules.maven.api.execute.PrerequisitesChecker;	46	import org.netbeans.modules.maven.api.execute.PrerequisitesChecker;
46	import org.netbeans.modules.maven.api.execute.RunConfig;	47	import org.netbeans.modules.maven.api.execute.RunConfig;
47	import org.netbeans.modules.maven.api.execute.RunUtils;	48	import org.netbeans.modules.maven.api.execute.RunUtils;
Lines 66-74 Link Here
66		67
67	@Override public boolean checkRunConfig(RunConfig config) {	68	@Override public boolean checkRunConfig(RunConfig config) {
68	String action = config.getActionName();	69	String action = config.getActionName();
69	if (ActionProvider.COMMAND_TEST.equals(action) \|\|	70	if (ProjectActions.COMMAND_TEST.equals(action) \|\|
70	ActionProvider.COMMAND_TEST_SINGLE.equals(action) \|\|	71	ProjectActions.COMMAND_TEST_SINGLE.equals(action) \|\|
71	ActionProvider.COMMAND_DEBUG_TEST_SINGLE.equals(action) \|\|	72	ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(action) \|\|
72	"profile-tests".equals(action)) { //NOI18N - profile-tests is not really nice but well.	73	"profile-tests".equals(action)) { //NOI18N - profile-tests is not really nice but well.
73	if (!RunUtils.hasTestCompileOnSaveEnabled(config)) {	74	if (!RunUtils.hasTestCompileOnSaveEnabled(config)) {
74	String test = config.getProperties().get("test");	75	String test = config.getProperties().get("test");

Lines 79-84 Link Here

(-)a/maven/src/org/netbeans/modules/maven/customizer/ActionMappings.java (-26 / +27 lines)
79	import javax.swing.event.DocumentEvent;	79	import javax.swing.event.DocumentEvent;
80	import javax.swing.event.DocumentListener;	80	import javax.swing.event.DocumentListener;
81	import org.netbeans.api.annotations.common.NullAllowed;	81	import org.netbeans.api.annotations.common.NullAllowed;
		82	import org.netbeans.api.project.ProjectActions;
82	import org.netbeans.modules.maven.spi.grammar.GoalsProvider;	83	import org.netbeans.modules.maven.spi.grammar.GoalsProvider;
83	import org.netbeans.modules.maven.api.customizer.ModelHandle;	84	import org.netbeans.modules.maven.api.customizer.ModelHandle;
84	import org.netbeans.modules.maven.NbMavenProjectImpl;	85	import org.netbeans.modules.maven.NbMavenProjectImpl;
Lines 179-198 Link Here
179	this();	180	this();
180	project = proj;	181	project = proj;
181	handle = hand;	182	handle = hand;
182	titles.put(ActionProvider.COMMAND_BUILD, NbBundle.getMessage(ActionMappings.class, "COM_Build_project"));	183	titles.put(ProjectActions.COMMAND_BUILD, NbBundle.getMessage(ActionMappings.class, "COM_Build_project"));
183	titles.put(ActionProvider.COMMAND_CLEAN, NbBundle.getMessage(ActionMappings.class, "COM_Clean_project"));	184	titles.put(ProjectActions.COMMAND_CLEAN, NbBundle.getMessage(ActionMappings.class, "COM_Clean_project"));
184	titles.put(ActionProvider.COMMAND_COMPILE_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Compile_file"));	185	titles.put(ProjectActions.COMMAND_COMPILE_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Compile_file"));
185	titles.put(ActionProvider.COMMAND_DEBUG, NbBundle.getMessage(ActionMappings.class, "COM_Debug_project"));	186	titles.put(ProjectActions.COMMAND_DEBUG, NbBundle.getMessage(ActionMappings.class, "COM_Debug_project"));
186	titles.put(ActionProvider.COMMAND_DEBUG_SINGLE + ".main", NbBundle.getMessage(ActionMappings.class, "COM_Debug_file_main"));	187	titles.put(ProjectActions.COMMAND_DEBUG_SINGLE + ".main", NbBundle.getMessage(ActionMappings.class, "COM_Debug_file_main"));
187	titles.put(ActionProvider.COMMAND_DEBUG_SINGLE + ".deploy", NbBundle.getMessage(ActionMappings.class, "COM_Debug_file_deploy"));	188	titles.put(ProjectActions.COMMAND_DEBUG_SINGLE + ".deploy", NbBundle.getMessage(ActionMappings.class, "COM_Debug_file_deploy"));
188	titles.put(ActionProvider.COMMAND_DEBUG_STEP_INTO, null);	189	titles.put(ProjectActions.COMMAND_DEBUG_STEP_INTO, null);
189	titles.put(ActionProvider.COMMAND_DEBUG_TEST_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Debug_test"));	190	titles.put(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Debug_test"));
190	titles.put(ActionProvider.COMMAND_REBUILD, NbBundle.getMessage(ActionMappings.class, "COM_ReBuild_project"));	191	titles.put(ProjectActions.COMMAND_REBUILD, NbBundle.getMessage(ActionMappings.class, "COM_ReBuild_project"));
191	titles.put(ActionProvider.COMMAND_RUN, NbBundle.getMessage(ActionMappings.class, "COM_Run_project"));	192	titles.put(ProjectActions.COMMAND_RUN, NbBundle.getMessage(ActionMappings.class, "COM_Run_project"));
192	titles.put(ActionProvider.COMMAND_RUN_SINGLE + ".main", NbBundle.getMessage(ActionMappings.class, "COM_Run_file_main"));	193	titles.put(ProjectActions.COMMAND_RUN_SINGLE + ".main", NbBundle.getMessage(ActionMappings.class, "COM_Run_file_main"));
193	titles.put(ActionProvider.COMMAND_RUN_SINGLE + ".deploy", NbBundle.getMessage(ActionMappings.class, "COM_Run_file_deploy"));	194	titles.put(ProjectActions.COMMAND_RUN_SINGLE + ".deploy", NbBundle.getMessage(ActionMappings.class, "COM_Run_file_deploy"));
194	titles.put(ActionProvider.COMMAND_TEST, NbBundle.getMessage(ActionMappings.class, "COM_Test_project"));	195	titles.put(ProjectActions.COMMAND_TEST, NbBundle.getMessage(ActionMappings.class, "COM_Test_project"));
195	titles.put(ActionProvider.COMMAND_TEST_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Test_file"));	196	titles.put(ProjectActions.COMMAND_TEST_SINGLE, NbBundle.getMessage(ActionMappings.class, "COM_Test_file"));
196	titles.put("profile", NbBundle.getMessage(ActionMappings.class, "COM_Profile_project"));	197	titles.put("profile", NbBundle.getMessage(ActionMappings.class, "COM_Profile_project"));
197	titles.put("javadoc", NbBundle.getMessage(ActionMappings.class, "COM_Javadoc_project"));	198	titles.put("javadoc", NbBundle.getMessage(ActionMappings.class, "COM_Javadoc_project"));
198	titles.put(ActionProviderImpl.BUILD_WITH_DEPENDENCIES, NbBundle.getMessage(ActionMappings.class, "COM_Build_WithDeps_project"));	199	titles.put(ActionProviderImpl.BUILD_WITH_DEPENDENCIES, NbBundle.getMessage(ActionMappings.class, "COM_Build_WithDeps_project"));
Lines 565-587 Link Here
565		566
566	if (handle != null) {	567	if (handle != null) {
567	boolean isWar = NbMavenProject.TYPE_WAR.equalsIgnoreCase(project.getProjectWatcher().getPackagingType());	568	boolean isWar = NbMavenProject.TYPE_WAR.equalsIgnoreCase(project.getProjectWatcher().getPackagingType());
568	addSingleAction(ActionProvider.COMMAND_BUILD, model);	569	addSingleAction(ProjectActions.COMMAND_BUILD, model);
569	addSingleAction(ActionProvider.COMMAND_CLEAN, model);	570	addSingleAction(ProjectActions.COMMAND_CLEAN, model);
570	addSingleAction(ActionProvider.COMMAND_REBUILD, model);	571	addSingleAction(ProjectActions.COMMAND_REBUILD, model);
571	addSingleAction(ActionProviderImpl.BUILD_WITH_DEPENDENCIES, model);	572	addSingleAction(ActionProviderImpl.BUILD_WITH_DEPENDENCIES, model);
572	addSingleAction(ActionProvider.COMMAND_TEST, model);	573	addSingleAction(ProjectActions.COMMAND_TEST, model);
573	addSingleAction(ActionProvider.COMMAND_TEST_SINGLE, model);	574	addSingleAction(ProjectActions.COMMAND_TEST_SINGLE, model);
574	addSingleAction(ActionProvider.COMMAND_RUN, model);	575	addSingleAction(ProjectActions.COMMAND_RUN, model);
575	addSingleAction(ActionProvider.COMMAND_RUN_SINGLE + ".main", model); //NOI18N	576	addSingleAction(ProjectActions.COMMAND_RUN_SINGLE + ".main", model); //NOI18N
576	if (isWar) {	577	if (isWar) {
577	addSingleAction(ActionProvider.COMMAND_RUN_SINGLE + ".deploy", model); //NOI18N	578	addSingleAction(ProjectActions.COMMAND_RUN_SINGLE + ".deploy", model); //NOI18N
578	}	579	}
579	addSingleAction(ActionProvider.COMMAND_DEBUG, model);	580	addSingleAction(ProjectActions.COMMAND_DEBUG, model);
580	addSingleAction(ActionProvider.COMMAND_DEBUG_SINGLE + ".main", model); //NOI18N	581	addSingleAction(ProjectActions.COMMAND_DEBUG_SINGLE + ".main", model); //NOI18N
581	if (isWar) {	582	if (isWar) {
582	addSingleAction(ActionProvider.COMMAND_DEBUG_SINGLE + ".deploy", model); //NOI18N	583	addSingleAction(ProjectActions.COMMAND_DEBUG_SINGLE + ".deploy", model); //NOI18N
583	}	584	}
584	addSingleAction(ActionProvider.COMMAND_DEBUG_TEST_SINGLE, model);	585	addSingleAction(ProjectActions.COMMAND_DEBUG_TEST_SINGLE, model);
585	addSingleAction("profile", model); //NOI18N	586	addSingleAction("profile", model); //NOI18N
586	addSingleAction("javadoc", model); //NOI18N	587	addSingleAction("javadoc", model); //NOI18N
587	}	588	}

Lines 54-59 Link Here

(-)a/maven/src/org/netbeans/modules/maven/debug/DebuggerChecker.java (-2 / +3 lines)
54	import org.netbeans.api.java.classpath.ClassPath;	54	import org.netbeans.api.java.classpath.ClassPath;
55	import org.netbeans.api.java.queries.SourceForBinaryQuery;	55	import org.netbeans.api.java.queries.SourceForBinaryQuery;
56	import org.netbeans.api.project.Project;	56	import org.netbeans.api.project.Project;
		57	import org.netbeans.api.project.ProjectActions;
57	import org.netbeans.modules.maven.api.Constants;	58	import org.netbeans.modules.maven.api.Constants;
58	import org.netbeans.modules.maven.api.NbMavenProject;	59	import org.netbeans.modules.maven.api.NbMavenProject;
59	import org.netbeans.modules.maven.api.PluginPropertyUtils;	60	import org.netbeans.modules.maven.api.PluginPropertyUtils;
Lines 88-94 Link Here
88	return true;	89	return true;
89	}	90	}
90	boolean debug = "true".equalsIgnoreCase(config.getProperties().get(Constants.ACTION_PROPERTY_JPDALISTEN));//NOI18N	91	boolean debug = "true".equalsIgnoreCase(config.getProperties().get(Constants.ACTION_PROPERTY_JPDALISTEN));//NOI18N
91	if (debug && ActionProvider.COMMAND_DEBUG_TEST_SINGLE.equalsIgnoreCase(config.getActionName()) && config.getGoals().contains("surefire:test")) { //NOI18N - just a safeguard	92	if (debug && ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equalsIgnoreCase(config.getActionName()) && config.getGoals().contains("surefire:test")) { //NOI18N - just a safeguard
92	String newArgs = config.getProperties().get(MAVENSUREFIREDEBUG); //NOI18N	93	String newArgs = config.getProperties().get(MAVENSUREFIREDEBUG); //NOI18N
93	String oldArgs = config.getProperties().get(ARGLINE); //NOI18N	94	String oldArgs = config.getProperties().get(ARGLINE); //NOI18N
94		95
Lines 160-166 Link Here
160	LOGGER.log(Level.INFO, th.getMessage(), th);	161	LOGGER.log(Level.INFO, th.getMessage(), th);
161	}	162	}
162	}	163	}
163	if (ActionProvider.COMMAND_DEBUG_STEP_INTO.equals(config.getActionName())) {	164	if (ProjectActions.COMMAND_DEBUG_STEP_INTO.equals(config.getActionName())) {
164	//TODO - change the goal from compile to test-compile in case of file coming from	165	//TODO - change the goal from compile to test-compile in case of file coming from
165	//the test source roots..	166	//the test source roots..
166	}	167	}

Lines 58-63 Link Here

(-)a/maven/src/org/netbeans/modules/maven/execute/ActionToGoalUtils.java (-4 / +5 lines)
58	import org.codehaus.plexus.util.xml.pull.XmlPullParserException;	58	import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
59	import org.netbeans.api.progress.ProgressHandle;	59	import org.netbeans.api.progress.ProgressHandle;
60	import org.netbeans.api.project.Project;	60	import org.netbeans.api.project.Project;
		61	import org.netbeans.api.project.ProjectActions;
61	import org.netbeans.api.project.ProjectUtils;	62	import org.netbeans.api.project.ProjectUtils;
62	import org.netbeans.modules.maven.api.FileUtilities;	63	import org.netbeans.modules.maven.api.FileUtilities;
63	import org.netbeans.modules.maven.api.execute.ExecutionContext;	64	import org.netbeans.modules.maven.api.execute.ExecutionContext;
Lines 109-115 Link Here
109		110
110	if (rc == null) {	111	if (rc == null) {
111	// for build and rebuild check the pom for default goal and run that one..	112	// for build and rebuild check the pom for default goal and run that one..
112	if (ActionProvider.COMMAND_BUILD.equals(action) \|\| ActionProvider.COMMAND_REBUILD.equals(action)) {	113	if (ProjectActions.COMMAND_BUILD.equals(action) \|\| ProjectActions.COMMAND_REBUILD.equals(action)) {
113	Build bld = project.getOriginalMavenProject().getBuild();	114	Build bld = project.getOriginalMavenProject().getBuild();
114	if (bld != null) {	115	if (bld != null) {
115	String goal = bld.getDefaultGoal();	116	String goal = bld.getDefaultGoal();
Lines 122-128 Link Here
122	while (tok.hasMoreTokens()) {	123	while (tok.hasMoreTokens()) {
123	toRet.add(tok.nextToken());	124	toRet.add(tok.nextToken());
124	}	125	}
125	if (ActionProvider.COMMAND_REBUILD.equals(action)) {	126	if (ProjectActions.COMMAND_REBUILD.equals(action)) {
126	toRet.add(0, "clean"); //NOI18N	127	toRet.add(0, "clean"); //NOI18N
127	}	128	}
128	brc.setGoals(toRet);	129	brc.setGoals(toRet);
Lines 163-170 Link Here
163	return true;	164	return true;
164	}	165	}
165		166
166	if (ActionProvider.COMMAND_BUILD.equals(action) \|\|	167	if (ProjectActions.COMMAND_BUILD.equals(action) \|\|
167	ActionProvider.COMMAND_REBUILD.equals(action)) {	168	ProjectActions.COMMAND_REBUILD.equals(action)) {
168	Build bld = project.getOriginalMavenProject().getBuild();	169	Build bld = project.getOriginalMavenProject().getBuild();
169	if (bld != null) {	170	if (bld != null) {
170	String goal = bld.getDefaultGoal();	171	String goal = bld.getDefaultGoal();

Lines 53-58 Link Here

(-)a/maven/src/org/netbeans/modules/maven/execute/DefaultReplaceTokenProvider.java (-6 / +7 lines)
53	import org.netbeans.api.java.source.ClasspathInfo;	53	import org.netbeans.api.java.source.ClasspathInfo;
54	import org.netbeans.api.java.source.SourceUtils;	54	import org.netbeans.api.java.source.SourceUtils;
55	import org.netbeans.api.project.Project;	55	import org.netbeans.api.project.Project;
		56	import org.netbeans.api.project.ProjectActions;
56	import org.netbeans.api.project.ProjectUtils;	57	import org.netbeans.api.project.ProjectUtils;
57	import org.netbeans.api.project.SourceGroup;	58	import org.netbeans.api.project.SourceGroup;
58	import org.netbeans.api.project.Sources;	59	import org.netbeans.api.project.Sources;
Lines 152-159 Link Here
152	replaceMap.put(CLASSPATHSCOPE,"runtime"); //NOI18N	153	replaceMap.put(CLASSPATHSCOPE,"runtime"); //NOI18N
153	}	154	}
154	if (tuple.group != null && MavenSourcesImpl.NAME_SOURCE.equals(tuple.group.getName()) &&	155	if (tuple.group != null && MavenSourcesImpl.NAME_SOURCE.equals(tuple.group.getName()) &&
155	(ActionProvider.COMMAND_TEST_SINGLE.equals(actionName) \|\|	156	(ProjectActions.COMMAND_TEST_SINGLE.equals(actionName) \|\|
156	ActionProvider.COMMAND_DEBUG_TEST_SINGLE.equals(actionName))) {	157	ProjectActions.COMMAND_DEBUG_TEST_SINGLE.equals(actionName))) {
157	String withExt = replaceMap.get(CLASSNAME_EXT);	158	String withExt = replaceMap.get(CLASSNAME_EXT);
158	if (withExt != null && withExt.endsWith(".java")) {//NOI18N	159	if (withExt != null && withExt.endsWith(".java")) {//NOI18N
159	replaceMap.put(CLASSNAME_EXT, withExt.replace(".java", "Test.java"));//NOI18N	160	replaceMap.put(CLASSNAME_EXT, withExt.replace(".java", "Test.java"));//NOI18N
Lines 246-258 Link Here
246		247
247	@Override public String convert(String action, Lookup lookup) {	248	@Override public String convert(String action, Lookup lookup) {
248	if (SingleMethod.COMMAND_DEBUG_SINGLE_METHOD.equals(action)) {	249	if (SingleMethod.COMMAND_DEBUG_SINGLE_METHOD.equals(action)) {
249	return ActionProvider.COMMAND_DEBUG_TEST_SINGLE;	250	return ProjectActions.COMMAND_DEBUG_TEST_SINGLE;
250	}	251	}
251	if (SingleMethod.COMMAND_RUN_SINGLE_METHOD.equals(action)) {	252	if (SingleMethod.COMMAND_RUN_SINGLE_METHOD.equals(action)) {
252	return ActionProvider.COMMAND_TEST_SINGLE;	253	return ProjectActions.COMMAND_TEST_SINGLE;
253	}	254	}
254	if (ActionProvider.COMMAND_RUN_SINGLE.equals(action) \|\|	255	if (ProjectActions.COMMAND_RUN_SINGLE.equals(action) \|\|
255	ActionProvider.COMMAND_DEBUG_SINGLE.equals(action)) {	256	ProjectActions.COMMAND_DEBUG_SINGLE.equals(action)) {
256	FileObject[] fos = extractFileObjectsfromLookup(lookup);	257	FileObject[] fos = extractFileObjectsfromLookup(lookup);
257	if (fos.length > 0) {	258	if (fos.length > 0) {
258	FileObject fo = fos[0];	259	FileObject fo = fos[0];

Line 0 Link Here

(-)a/projectapi/src/META-INF/upgrade/ActionProvider.hint (+16 lines)
	1	org.netbeans.spi.project.ActionProvider.COMMAND_BUILD => org.netbeans.api.project.ProjectActions.COMMAND_BUILD;;
	2	org.netbeans.spi.project.ActionProvider.COMMAND_COMPILE_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_COMPILE_SINGLE;;
	3	org.netbeans.spi.project.ActionProvider.COMMAND_CLEAN => org.netbeans.api.project.ProjectActions.COMMAND_CLEAN;;
	4	org.netbeans.spi.project.ActionProvider.COMMAND_REBUILD => org.netbeans.api.project.ProjectActions.COMMAND_REBUILD;;
	5	org.netbeans.spi.project.ActionProvider.COMMAND_RUN => org.netbeans.api.project.ProjectActions.COMMAND_RUN;;
	6	org.netbeans.spi.project.ActionProvider.COMMAND_RUN_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_RUN_SINGLE;;
	7	org.netbeans.spi.project.ActionProvider.COMMAND_TEST => org.netbeans.api.project.ProjectActions.COMMAND_TEST;;
	8	org.netbeans.spi.project.ActionProvider.COMMAND_TEST_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_TEST_SINGLE;;
	9	org.netbeans.spi.project.ActionProvider.COMMAND_DEBUG => org.netbeans.api.project.ProjectActions.COMMAND_DEBUG;;
	10	org.netbeans.spi.project.ActionProvider.COMMAND_DEBUG_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_DEBUG_SINGLE;;
	11	org.netbeans.spi.project.ActionProvider.COMMAND_DEBUG_TEST_SINGLE => org.netbeans.api.project.ProjectActions.COMMAND_DEBUG_TEST_SINGLE;;
	12	org.netbeans.spi.project.ActionProvider.COMMAND_DEBUG_STEP_INTO => org.netbeans.api.project.ProjectActions.COMMAND_DEBUG_STEP_INTO;;
	13	org.netbeans.spi.project.ActionProvider.COMMAND_DELETE => org.netbeans.api.project.ProjectActions.COMMAND_DELETE;;
	14	org.netbeans.spi.project.ActionProvider.COMMAND_COPY => org.netbeans.api.project.ProjectActions.COMMAND_COPY;;
	15	org.netbeans.spi.project.ActionProvider.COMMAND_MOVE => org.netbeans.api.project.ProjectActions.COMMAND_MOVE;;
	16	org.netbeans.spi.project.ActionProvider.COMMAND_RENAME => org.netbeans.api.project.ProjectActions.COMMAND_RENAME;;

Line 0 Link Here

(-)a/projectapi/src/org/netbeans/api/project/ProjectActions.java (+208 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42
		43	package org.netbeans.api.project;
		44
		45	import java.util.Arrays;
		46	import java.util.concurrent.Callable;
		47	import java.util.concurrent.Future;
		48	import org.netbeans.api.annotations.common.CheckForNull;
		49	import org.netbeans.api.annotations.common.NonNull;
		50	import org.netbeans.spi.project.ActionProvider2;
		51	import org.netbeans.spi.project.SingleMethod;
		52	import org.openide.util.Exceptions;
		53	import org.openide.util.Lookup;
		54	import org.openide.util.RequestProcessor;
		55
		56	/**
		57	* Defines and manages actions exported by projects.
		58	* Each possible action is identified by a command string;
		59	* this class defines some commonly used ones, such as {@link #COMMAND_BUILD}.
		60	* @see ActionProvider2
		61	* @see SingleMethod
		62	* @since XXX
		63	*/
		64	public class ProjectActions {
65
66	private static final RequestProcessor RP = new RequestProcessor(ProjectActions.class.getName(), Integer.MAX_VALUE);
67
68	/**
69	* Prepare to run an action.
70	* @param project a project to run the action on
71	* @param command a predefined command string
72	* @param context an action context
73	* @return a callback to run the action, or null if disabled (or just not recognized by this project)
74	*/
75	public static @CheckForNull Callable<Boolean> prepare(@NonNull Project project, final @NonNull String command, final @NonNull Lookup context) {
76	for (ActionProvider2 ap2 : project.getLookup().lookupAll(ActionProvider2.class)) {
77	Callable<Boolean> task = ap2.prepare(command, context);
78	if (task != null) {
79	return task;
80	}
81	}
82	@SuppressWarnings("deprecation")
83	final org.netbeans.spi.project.ActionProvider ap = project.getLookup().lookup(org.netbeans.spi.project.ActionProvider.class);
84	if (ap != null && Arrays.asList(ap.getSupportedActions()).contains(command)) {
85	try {
86	if (ap.isActionEnabled(command, context)) {
87	return new Callable<Boolean>() {
88	@Override public Boolean call() throws Exception {
89	ap.invokeAction(command, context);
90	return true;
91	}
92	};
93	}
94	} catch (IllegalArgumentException x) {
95	Exceptions.printStackTrace(x);
96	}
97	}
98	return null;
99	}
100
101	/**
102	* Convenience method to run an action if it is enabled.
103	* The return value may be safely ignored if you do not depend on the result.
104	* @param project a project to run the action on
105	* @param command a predefined command string
106	* @param context an action context
107	* @return a task representing the result; will be false if the action is not defined or enabled, or was run but failed
108	*/
109	public static @NonNull Future<Boolean> run(@NonNull Project project, @NonNull String command, @NonNull Lookup context) {
110	Callable<Boolean> task = prepare(project, command, context);
111	if (task == null) {
112	task = new Callable<Boolean>() {
113	@Override public Boolean call() throws Exception {
114	return false;
115	}
116	};
117	}
118	return RP.submit(task);
119	}
120
121	/**
122	* Standard command to incrementally build the project.
123	*/
124	public static final String COMMAND_BUILD = "build"; // NOI18N
125
126	/**
127	* Standard command for compiling set of files
128	*/
129	public static final String COMMAND_COMPILE_SINGLE = "compile.single"; // NOI18N
130
131	/**
132	* Standard command to clean build products.
133	*/
134	public static final String COMMAND_CLEAN = "clean"; // NOI18N
135
136	/**
137	* Standard command to do a "clean" (forced) rebuild.
138	*/
139	public static final String COMMAND_REBUILD = "rebuild"; // NOI18N
140
141	/**
142	* Standard command for running the project
143	*/
144	public static final String COMMAND_RUN = "run"; // NOI18N
145
146	/**
147	* Standard command for running one file
148	*
149	* @see SingleMethod#COMMAND_RUN_SINGLE_METHOD
150	*/
151	public static final String COMMAND_RUN_SINGLE = "run.single"; // NOI18N
152
153	/**
154	* Standard command for running tests on given projects
155	*/
156	public static final String COMMAND_TEST = "test"; // NOI18N
157
158	/**
159	* Standard command for running one test file
160	*/
161	public static final String COMMAND_TEST_SINGLE = "test.single"; // NOI18N
162
163	/**
164	* Standard command for running the project in debugger
165	*/
166	public static final String COMMAND_DEBUG = "debug"; // NOI18N
167
168	/**
169	* Standard command for running single file in debugger
170	*
171	* @see SingleMethod#COMMAND_DEBUG_SINGLE_METHOD
172	*/
173	public static final String COMMAND_DEBUG_SINGLE = "debug.single"; // NOI18N
174
175	/**
176	* Standard command for running one test in debugger
177	*/
178	public static final String COMMAND_DEBUG_TEST_SINGLE = "debug.test.single"; // NOI18N
179
180	/**
181	* Standard command for starting app in debugger and stopping at the
182	* beginning of app whatever that means.
183	*/
184	public static final String COMMAND_DEBUG_STEP_INTO = "debug.stepinto"; // NOI18N
185
186	/**
187	* Standard command for deleting the project.
188	*/
189	public static final String COMMAND_DELETE = "delete"; // NOI18N
190
191	/**
192	* Standard command for deleting the project.
193	*/
194	public static final String COMMAND_COPY = "copy"; // NOI18N
195
196	/**
197	* Standard command for moving the project.
198	*/
199	public static final String COMMAND_MOVE = "move"; // NOI18N
200
201	/**
202	* Standard command for renaming the project.
203	*/
204	public static final String COMMAND_RENAME = "rename"; // NOI18N
205
206	private ProjectActions() {}
207
208	}

Lines 44-49 Link Here

(-)a/projectapi/src/org/netbeans/spi/project/ActionProvider.java (-92 / +19 lines)
44		44
45	package org.netbeans.spi.project;	45	package org.netbeans.spi.project;
46		46
		47	import org.netbeans.api.project.ProjectActions;
47	import org.openide.util.ContextAwareAction;	48	import org.openide.util.ContextAwareAction;
48	import org.openide.util.Lookup;	49	import org.openide.util.Lookup;
49		50
Lines 61-161 Link Here
61	* @see <a href="@org-netbeans-modules-projectuiapi@/org/netbeans/spi/project/ui/support/ProjectSensitiveActions.html#projectCommandAction(java.lang.String,%20java.lang.String,%20javax.swing.Icon)"><code>ProjectSensitiveActions.projectCommandAction(...)</code></a>	62	* @see <a href="@org-netbeans-modules-projectuiapi@/org/netbeans/spi/project/ui/support/ProjectSensitiveActions.html#projectCommandAction(java.lang.String,%20java.lang.String,%20javax.swing.Icon)"><code>ProjectSensitiveActions.projectCommandAction(...)</code></a>
62	* @see SingleMethod	63	* @see SingleMethod
63	* @author Jesse Glick	64	* @author Jesse Glick
		65	* @deprecated Use {@link ActionProvider2} and {@link ProjectActions} instead.
64	*/	66	*/
		67	@Deprecated
65	public interface ActionProvider {	68	public interface ActionProvider {
66		69
67	/**	70	String COMMAND_BUILD = ProjectActions.COMMAND_BUILD;
68	* Standard command to incrementally build the project.	71	String COMMAND_COMPILE_SINGLE = ProjectActions.COMMAND_COMPILE_SINGLE;
69	*/	72	String COMMAND_CLEAN = ProjectActions.COMMAND_CLEAN;
70	String COMMAND_BUILD = "build"; // NOI18N	73	String COMMAND_REBUILD = ProjectActions.COMMAND_REBUILD;
71		74	String COMMAND_RUN = ProjectActions.COMMAND_RUN;
72	/**	75	String COMMAND_RUN_SINGLE = ProjectActions.COMMAND_RUN_SINGLE;
73	* Standard command for compiling set of files	76	String COMMAND_TEST = ProjectActions.COMMAND_TEST;
74	*/	77	String COMMAND_TEST_SINGLE = ProjectActions.COMMAND_TEST_SINGLE;
75	String COMMAND_COMPILE_SINGLE = "compile.single"; // NOI18N	78	String COMMAND_DEBUG = ProjectActions.COMMAND_DEBUG;
76		79	String COMMAND_DEBUG_SINGLE = ProjectActions.COMMAND_DEBUG_SINGLE;
77	/**	80	String COMMAND_DEBUG_TEST_SINGLE = ProjectActions.COMMAND_DEBUG_TEST_SINGLE;
78	* Standard command to clean build products.	81	String COMMAND_DEBUG_STEP_INTO = ProjectActions.COMMAND_DEBUG_STEP_INTO;
79	*/	82	String COMMAND_DELETE = ProjectActions.COMMAND_DELETE;
80	String COMMAND_CLEAN = "clean"; // NOI18N	83	String COMMAND_COPY = ProjectActions.COMMAND_COPY;
81		84	String COMMAND_MOVE = ProjectActions.COMMAND_MOVE;
82	/**	85	String COMMAND_RENAME = ProjectActions.COMMAND_RENAME;
83	* Standard command to do a "clean" (forced) rebuild.
84	*/
85	String COMMAND_REBUILD = "rebuild"; // NOI18N
86
87	/**
88	* Standard command for running the project
89	*/
90	String COMMAND_RUN = "run"; // NOI18N
91
92	/**
93	* Standard command for running one file
94	*
95	* @see SingleMethod#COMMAND_RUN_SINGLE_METHOD
96	*/
97	String COMMAND_RUN_SINGLE = "run.single"; // NOI18N
98
99	/**
100	* Standard command for running tests on given projects
101	*/
102	String COMMAND_TEST = "test"; // NOI18N
103
104	/**
105	* Standard command for running one test file
106	*/
107	String COMMAND_TEST_SINGLE = "test.single"; // NOI18N
108
109	/**
110	* Standard command for running the project in debugger
111	*/
112	String COMMAND_DEBUG = "debug"; // NOI18N
113
114	/**
115	* Standard command for running single file in debugger
116	*
117	* @see SingleMethod#COMMAND_DEBUG_SINGLE_METHOD
118	*/
119	String COMMAND_DEBUG_SINGLE = "debug.single"; // NOI18N
120
121	/**
122	* Standard command for running one test in debugger
123	*/
124	String COMMAND_DEBUG_TEST_SINGLE = "debug.test.single"; // NOI18N
125
126	/**
127	* Standard command for starting app in debugger and stopping at the
128	* beginning of app whatever that means.
129	*/
130	String COMMAND_DEBUG_STEP_INTO = "debug.stepinto"; // NOI18N
131
132	/**
133	* Standard command for deleting the project.
134	*
135	* @since 1.6
136	*/
137	String COMMAND_DELETE = "delete"; // NOI18N
138
139	/**
140	* Standard command for deleting the project.
141	*
142	* @since 1.7
143	*/
144	String COMMAND_COPY = "copy"; // NOI18N
145
146	/**
147	* Standard command for moving the project.
148	*
149	* @since 1.7
150	*/
151	String COMMAND_MOVE = "move"; // NOI18N
152
153	/**
154	* Standard command for renaming the project.
155	*
156	* @since 1.7
157	*/
158	String COMMAND_RENAME = "rename"; // NOI18N
159		86
160	/**	87	/**
161	* Get a list of all commands which this project supports.	88	* Get a list of all commands which this project supports.

Lines 70-81 Link Here

(-)a/projectui/src/org/netbeans/modules/project/ui/ProjectsRootNode.java (-15 / +3 lines)
70	import org.netbeans.api.annotations.common.StaticResource;	70	import org.netbeans.api.annotations.common.StaticResource;
71	import org.netbeans.api.project.FileOwnerQuery;	71	import org.netbeans.api.project.FileOwnerQuery;
72	import org.netbeans.api.project.Project;	72	import org.netbeans.api.project.Project;
		73	import org.netbeans.api.project.ProjectActions;
73	import org.netbeans.spi.project.ProjectIconAnnotator;	74	import org.netbeans.spi.project.ProjectIconAnnotator;
74	import org.netbeans.api.project.ProjectManager;	75	import org.netbeans.api.project.ProjectManager;
75	import org.netbeans.api.project.ProjectUtils;	76	import org.netbeans.api.project.ProjectUtils;
76	import org.netbeans.api.project.SourceGroup;	77	import org.netbeans.api.project.SourceGroup;
77	import org.netbeans.api.project.Sources;	78	import org.netbeans.api.project.Sources;
78	import org.netbeans.spi.project.ActionProvider;
79	import org.netbeans.spi.project.ui.LogicalViewProvider;	79	import org.netbeans.spi.project.ui.LogicalViewProvider;
80	import org.openide.filesystems.FileChangeAdapter;	80	import org.openide.filesystems.FileChangeAdapter;
81	import org.openide.filesystems.FileChangeListener;	81	import org.openide.filesystems.FileChangeListener;
Lines 86-92 Link Here
86	import org.openide.filesystems.FileStatusListener;	86	import org.openide.filesystems.FileStatusListener;
87	import org.openide.filesystems.FileSystem;	87	import org.openide.filesystems.FileSystem;
88	import org.openide.filesystems.FileUtil;	88	import org.openide.filesystems.FileUtil;
89	import org.openide.loaders.DataObject;
90	import org.openide.nodes.AbstractNode;	89	import org.openide.nodes.AbstractNode;
91	import org.openide.nodes.Children;	90	import org.openide.nodes.Children;
92	import org.openide.nodes.FilterNode;	91	import org.openide.nodes.FilterNode;
Lines 842-858 Link Here
842	if (p == null) {	841	if (p == null) {
843	return false;	842	return false;
844	}	843	}
845	ActionProvider ap = p.getLookup().lookup(ActionProvider.class);	844	return ProjectActions.prepare(p, ProjectActions.COMMAND_DELETE, getLookup()) != null;
846
847	String[] sa = ap != null ? ap.getSupportedActions() : new String[0];
848	int k = sa.length;
849
850	for (int i = 0; i < k; i++) {
851	if (ActionProvider.COMMAND_DELETE.equals(sa[i])) {
852	return ap.isActionEnabled(ActionProvider.COMMAND_DELETE, getLookup());
853	}
854	}
855	return false;
856	}	845	}
857		846
858	@Override	847	@Override
Lines 861-868 Link Here
861	if (p == null) {	850	if (p == null) {
862	return;	851	return;
863	}	852	}
864	ActionProvider ap = p.getLookup().lookup(ActionProvider.class);	853	ProjectActions.run(p, ProjectActions.COMMAND_DELETE, getLookup());
865	ap.invokeAction(ActionProvider.COMMAND_DELETE, getLookup());
866	}	854	}
867	} // end of BadgingNode	855	} // end of BadgingNode
868	private static final class BadgingLookup extends ProxyLookup {	856	private static final class BadgingLookup extends ProxyLookup {

Lines 48-61 Link Here

(-)a/projectui/src/org/netbeans/modules/project/ui/actions/Actions.java (-18 / +18 lines)
48	import java.beans.PropertyChangeListener;	48	import java.beans.PropertyChangeListener;
49	import javax.swing.Action;	49	import javax.swing.Action;
50	import javax.swing.Icon;	50	import javax.swing.Icon;
		51	import org.netbeans.api.project.ProjectActions;
51	import org.netbeans.modules.project.uiapi.ActionsFactory;	52	import org.netbeans.modules.project.uiapi.ActionsFactory;
52	import org.netbeans.spi.project.ActionProvider;
53	import org.netbeans.spi.project.ui.support.FileActionPerformer;	53	import org.netbeans.spi.project.ui.support.FileActionPerformer;
54	import org.netbeans.spi.project.ui.support.ProjectActionPerformer;	54	import org.netbeans.spi.project.ui.support.ProjectActionPerformer;
55	import org.openide.util.ContextAwareAction;	55	import org.openide.util.ContextAwareAction;
56	import org.openide.util.Exceptions;	56	import org.openide.util.Exceptions;
57	import org.openide.util.ImageUtilities;	57	import org.openide.util.ImageUtilities;
58	import org.openide.util.Lookup;
59	import org.openide.util.NbBundle;	58	import org.openide.util.NbBundle;
60	import org.openide.util.actions.SystemAction;	59	import org.openide.util.actions.SystemAction;
61		60
Lines 179-185 Link Here
179		178
180	public static Action testProject() {	179	public static Action testProject() {
181	Action a = new ProjectAction (	180	Action a = new ProjectAction (
182	ActionProvider.COMMAND_TEST,	181	ProjectActions.COMMAND_TEST,
183	NbBundle.getMessage(Actions.class, "LBL_TestProjectAction_Name"),	182	NbBundle.getMessage(Actions.class, "LBL_TestProjectAction_Name"),
184	NbBundle.getMessage(Actions.class, "LBL_TestProjectAction_Name_popup"),	183	NbBundle.getMessage(Actions.class, "LBL_TestProjectAction_Name_popup"),
185	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/testProject.png", false),	184	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/testProject.png", false),
Lines 192-198 Link Here
192		191
193	public static Action buildProject() {	192	public static Action buildProject() {
194	Action a = new ProjectAction (	193	Action a = new ProjectAction (
195	ActionProvider.COMMAND_BUILD,	194	ProjectActions.COMMAND_BUILD,
196	NbBundle.getMessage(Actions.class, "LBL_BuildProjectAction_Name"),	195	NbBundle.getMessage(Actions.class, "LBL_BuildProjectAction_Name"),
197	NbBundle.getMessage(Actions.class, "LBL_BuildProjectAction_Name_popup"),	196	NbBundle.getMessage(Actions.class, "LBL_BuildProjectAction_Name_popup"),
198	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/buildCurrentProject.gif", false),	197	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/buildCurrentProject.gif", false),
Lines 202-209 Link Here
202	}	201	}
203		202
204	public static Action cleanProject() {	203	public static Action cleanProject() {
		204	@SuppressWarnings("deprecation")
205	Action a = new ProjectAction(	205	Action a = new ProjectAction(
206	ActionProvider.COMMAND_CLEAN,	206	ProjectActions.COMMAND_CLEAN,
207	NbBundle.getMessage(Actions.class, "LBL_CleanProjectAction_Name"),	207	NbBundle.getMessage(Actions.class, "LBL_CleanProjectAction_Name"),
208	NbBundle.getMessage(Actions.class, "LBL_CleanProjectAction_Name_popup"),	208	NbBundle.getMessage(Actions.class, "LBL_CleanProjectAction_Name_popup"),
209	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/cleanCurrentProject.gif", false),	209	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/cleanCurrentProject.gif", false),
Lines 214-220 Link Here
214		214
215	public static Action rebuildProject() {	215	public static Action rebuildProject() {
216	Action a = new ProjectAction(	216	Action a = new ProjectAction(
217	ActionProvider.COMMAND_REBUILD,	217	ProjectActions.COMMAND_REBUILD,
218	NbBundle.getMessage(Actions.class, "LBL_RebuildProjectAction_Name"),	218	NbBundle.getMessage(Actions.class, "LBL_RebuildProjectAction_Name"),
219	NbBundle.getMessage(Actions.class, "LBL_RebuildProjectAction_Name_popup"),	219	NbBundle.getMessage(Actions.class, "LBL_RebuildProjectAction_Name_popup"),
220	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/rebuildCurrentProject.gif", false),	220	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/rebuildCurrentProject.gif", false),
Lines 225-231 Link Here
225		225
226	public static Action runProject() {	226	public static Action runProject() {
227	Action a = new ProjectAction(	227	Action a = new ProjectAction(
228	ActionProvider.COMMAND_RUN,	228	ProjectActions.COMMAND_RUN,
229	NbBundle.getMessage(Actions.class, "LBL_RunProjectAction_Name"),	229	NbBundle.getMessage(Actions.class, "LBL_RunProjectAction_Name"),
230	NbBundle.getMessage(Actions.class, "LBL_RunProjectAction_Name_popup"),	230	NbBundle.getMessage(Actions.class, "LBL_RunProjectAction_Name_popup"),
231	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runCurrentProject.gif", false),	231	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runCurrentProject.gif", false),
Lines 236-242 Link Here
236		236
237	public static synchronized Action deleteProject() {	237	public static synchronized Action deleteProject() {
238	final Action a = new ProjectAction(	238	final Action a = new ProjectAction(
239	ActionProvider.COMMAND_DELETE,	239	ProjectActions.COMMAND_DELETE,
240	NbBundle.getMessage(Actions.class, "LBL_DeleteProjectAction_Name"),	240	NbBundle.getMessage(Actions.class, "LBL_DeleteProjectAction_Name"),
241	null,	241	null,
242	null );	242	null );
Lines 259-265 Link Here
259	public static synchronized Action copyProject() {	259	public static synchronized Action copyProject() {
260	if (COPY_PROJECT == null) {	260	if (COPY_PROJECT == null) {
261	Action a = new ProjectAction(	261	Action a = new ProjectAction(
262	ActionProvider.COMMAND_COPY,	262	ProjectActions.COMMAND_COPY,
263	NbBundle.getMessage(Actions.class, "LBL_CopyProjectAction_Name"),	263	NbBundle.getMessage(Actions.class, "LBL_CopyProjectAction_Name"),
264	null, //NOI18N	264	null, //NOI18N
265	null );	265	null );
Lines 272-278 Link Here
272	public static synchronized Action moveProject() {	272	public static synchronized Action moveProject() {
273	if (MOVE_PROJECT == null) {	273	if (MOVE_PROJECT == null) {
274	Action a = new ProjectAction(	274	Action a = new ProjectAction(
275	ActionProvider.COMMAND_MOVE,	275	ProjectActions.COMMAND_MOVE,
276	NbBundle.getMessage(Actions.class, "LBL_MoveProjectAction_Name"),	276	NbBundle.getMessage(Actions.class, "LBL_MoveProjectAction_Name"),
277	null, //NOI18N	277	null, //NOI18N
278	null );	278	null );
Lines 285-291 Link Here
285	public static synchronized Action renameProject() {	285	public static synchronized Action renameProject() {
286	if (RENAME_PROJECT == null) {	286	if (RENAME_PROJECT == null) {
287	Action a = new ProjectAction(	287	Action a = new ProjectAction(
288	ActionProvider.COMMAND_RENAME,	288	ProjectActions.COMMAND_RENAME,
289	NbBundle.getMessage(Actions.class, "LBL_RenameProjectAction_Name"),	289	NbBundle.getMessage(Actions.class, "LBL_RenameProjectAction_Name"),
290	null, //NOI18N	290	null, //NOI18N
291	null );	291	null );
Lines 299-305 Link Here
299		299
300	public static Action compileSingle() {	300	public static Action compileSingle() {
301	Action a = new FileAction(	301	Action a = new FileAction(
302	ActionProvider.COMMAND_COMPILE_SINGLE,	302	ProjectActions.COMMAND_COMPILE_SINGLE,
303	NbBundle.getMessage(Actions.class, "LBL_CompileSingleAction_Name"),	303	NbBundle.getMessage(Actions.class, "LBL_CompileSingleAction_Name"),
304	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/compileSingle.png", true),	304	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/compileSingle.png", true),
305	null);	305	null);
Lines 310-316 Link Here
310		310
311	public static Action runSingle() {	311	public static Action runSingle() {
312	Action a = new FileAction(	312	Action a = new FileAction(
313	ActionProvider.COMMAND_RUN_SINGLE,	313	ProjectActions.COMMAND_RUN_SINGLE,
314	NbBundle.getMessage(Actions.class, "LBL_RunSingleAction_Name"),	314	NbBundle.getMessage(Actions.class, "LBL_RunSingleAction_Name"),
315	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runSingle.png", true),	315	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runSingle.png", true),
316	null);	316	null);
Lines 321-327 Link Here
321		321
322	public static Action testSingle() {	322	public static Action testSingle() {
323	Action a = new FileAction(	323	Action a = new FileAction(
324	ActionProvider.COMMAND_TEST_SINGLE,	324	ProjectActions.COMMAND_TEST_SINGLE,
325	NbBundle.getMessage(Actions.class, "LBL_TestSingleAction_Name"),	325	NbBundle.getMessage(Actions.class, "LBL_TestSingleAction_Name"),
326	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/testSingle.png", true),	326	ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/testSingle.png", true),
327	null);	327	null);
Lines 335-341 Link Here
335		335
336	public static Action buildMainProject() {	336	public static Action buildMainProject() {
337	Action a = new MainProjectAction (	337	Action a = new MainProjectAction (
338	ActionProvider.COMMAND_BUILD,	338	ProjectActions.COMMAND_BUILD,
339	NbBundle.getMessage(Actions.class, "LBL_BuildMainProjectAction_Name" ),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/buildProject.png", false)); //NOI18N	339	NbBundle.getMessage(Actions.class, "LBL_BuildMainProjectAction_Name" ),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/buildProject.png", false)); //NOI18N
340	a.putValue("iconBase","org/netbeans/modules/project/ui/resources/buildProject.png"); //NOI18N	340	a.putValue("iconBase","org/netbeans/modules/project/ui/resources/buildProject.png"); //NOI18N
341	return a;	341	return a;
Lines 343-349 Link Here
343		343
344	public static Action cleanMainProject() {	344	public static Action cleanMainProject() {
345	Action a = new MainProjectAction(	345	Action a = new MainProjectAction(
346	ActionProvider.COMMAND_CLEAN,	346	ProjectActions.COMMAND_CLEAN,
347	NbBundle.getMessage(Actions.class, "LBL_CleanMainProjectAction_Name" ),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/cleanProject.gif", false)); //NOI18N	347	NbBundle.getMessage(Actions.class, "LBL_CleanMainProjectAction_Name" ),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/cleanProject.gif", false)); //NOI18N
348	a.putValue("iconBase","org/netbeans/modules/project/ui/resources/cleanProject.gif"); //NOI18N	348	a.putValue("iconBase","org/netbeans/modules/project/ui/resources/cleanProject.gif"); //NOI18N
349	return a;	349	return a;
Lines 351-357 Link Here
351		351
352	public static Action rebuildMainProject() {	352	public static Action rebuildMainProject() {
353	Action a = new MainProjectAction(	353	Action a = new MainProjectAction(
354	ActionProvider.COMMAND_REBUILD,	354	ProjectActions.COMMAND_REBUILD,
355	NbBundle.getMessage(Actions.class, "LBL_RebuildMainProjectAction_Name"),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/rebuildProject.png", false)); //NOI18N	355	NbBundle.getMessage(Actions.class, "LBL_RebuildMainProjectAction_Name"),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/rebuildProject.png", false)); //NOI18N
356	a.putValue("iconBase","org/netbeans/modules/project/ui/resources/rebuildProject.png"); //NOI18N	356	a.putValue("iconBase","org/netbeans/modules/project/ui/resources/rebuildProject.png"); //NOI18N
357	return a;	357	return a;
Lines 359-365 Link Here
359		359
360	public static Action runMainProject() {	360	public static Action runMainProject() {
361	Action a = new MainProjectAction(	361	Action a = new MainProjectAction(
362	ActionProvider.COMMAND_RUN,	362	ProjectActions.COMMAND_RUN,
363	NbBundle.getMessage(Actions.class, "LBL_RunMainProjectAction_Name"),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runProject.png", false)); //NOI18N	363	NbBundle.getMessage(Actions.class, "LBL_RunMainProjectAction_Name"),ImageUtilities.loadImageIcon("org/netbeans/modules/project/ui/resources/runProject.png", false)); //NOI18N
364	a.putValue("iconBase","org/netbeans/modules/project/ui/resources/runProject.png"); //NOI18N	364	a.putValue("iconBase","org/netbeans/modules/project/ui/resources/runProject.png"); //NOI18N
365	return a;	365	return a;

Lines 45-64 Link Here

(-)a/projectui/src/org/netbeans/modules/project/ui/actions/ActionsUtil.java (-16 / +5 lines)
45	package org.netbeans.modules.project.ui.actions;	45	package org.netbeans.modules.project.ui.actions;
46		46
47	import java.text.MessageFormat;	47	import java.text.MessageFormat;
48	import java.util.Arrays;
49	import java.util.HashMap;	48	import java.util.HashMap;
50	import java.util.HashSet;	49	import java.util.HashSet;
51	import java.util.List;
52	import java.util.Map;	50	import java.util.Map;
53	import java.util.Set;	51	import java.util.Set;
54	import javax.swing.Action;	52	import javax.swing.Action;
55	import org.netbeans.api.project.FileOwnerQuery;	53	import org.netbeans.api.project.FileOwnerQuery;
56	import org.netbeans.api.project.Project;	54	import org.netbeans.api.project.Project;
57	import org.netbeans.spi.project.ActionProvider;	55	import org.netbeans.api.project.ProjectActions;
58	import org.netbeans.api.project.ProjectUtils;	56	import org.netbeans.api.project.ProjectUtils;
59	import org.openide.filesystems.FileObject;	57	import org.openide.filesystems.FileObject;
60	import org.openide.loaders.DataObject;	58	import org.openide.loaders.DataObject;
61	import org.openide.util.Lookup;	59	import org.openide.util.Lookup;
		60	import org.openide.util.RequestProcessor;
62	import org.openide.util.WeakSet;	61	import org.openide.util.WeakSet;
63		62
64	/** Nice utility methods to be used in ProjectBased Actions	63	/** Nice utility methods to be used in ProjectBased Actions
Lines 71-76 Link Here
71	public static LookupResultsCache lookupResultsCache;	70	public static LookupResultsCache lookupResultsCache;
72	*/	71	*/
73		72
		73	public static final RequestProcessor RP = new RequestProcessor(ActionsUtil.class.getName(), Integer.MAX_VALUE);
		74
74	public static final ShortcutsManager SHORCUTS_MANAGER = new ShortcutsManager();	75	public static final ShortcutsManager SHORCUTS_MANAGER = new ShortcutsManager();
75		76
76	public static HashMap<String,MessageFormat> pattern2format = new HashMap<String,MessageFormat>();	77	public static HashMap<String,MessageFormat> pattern2format = new HashMap<String,MessageFormat>();
Lines 145-163 Link Here
145	* does not matter.	146	* does not matter.
146	*/	147	*/
147	public static boolean commandSupported( Project project, String command, Lookup context ) {	148	public static boolean commandSupported( Project project, String command, Lookup context ) {
148	//We have to look whether the command is supported by the project	149	return ProjectActions.prepare(project, command, context) != null;
149	ActionProvider ap = project.getLookup().lookup(ActionProvider.class);
150	if ( ap != null ) {
151	List commands = Arrays.asList( ap.getSupportedActions() );
152	if ( commands.contains( command ) ) {
153	if (context == null \|\| ap.isActionEnabled(command, context)) {
154	//System.err.println("cS: true project=" + project + " command=" + command + " context=" + context);
155	return true;
156	}
157	}
158	}
159	//System.err.println("cS: false project=" + project + " command=" + command + " context=" + context);
160	return false;
161	}	150	}
162		151
163		152

Lines 50-66 Link Here

(-)a/projectui/src/org/netbeans/modules/project/ui/actions/MainProjectAction.java (-11 / +9 lines)
50	import java.beans.PropertyChangeEvent;	50	import java.beans.PropertyChangeEvent;
51	import java.beans.PropertyChangeListener;	51	import java.beans.PropertyChangeListener;
52	import java.text.MessageFormat;	52	import java.text.MessageFormat;
53	import java.util.Arrays;	53	import java.util.concurrent.Callable;
54	import javax.swing.Icon;	54	import javax.swing.Icon;
55	import javax.swing.JButton;	55	import javax.swing.JButton;
56	import javax.swing.event.ChangeEvent;	56	import javax.swing.event.ChangeEvent;
57	import javax.swing.event.ChangeListener;	57	import javax.swing.event.ChangeListener;
58	import org.netbeans.api.project.Project;	58	import org.netbeans.api.project.Project;
		59	import org.netbeans.api.project.ProjectActions;
59	import org.netbeans.api.project.ProjectUtils;	60	import org.netbeans.api.project.ProjectUtils;
60	import org.netbeans.api.project.ui.OpenProjects;	61	import org.netbeans.api.project.ui.OpenProjects;
61	import org.netbeans.modules.project.ui.NoMainProjectWarning;	62	import org.netbeans.modules.project.ui.NoMainProjectWarning;
62	import org.netbeans.modules.project.ui.OpenProjectList;	63	import org.netbeans.modules.project.ui.OpenProjectList;
63	import org.netbeans.spi.project.ActionProvider;
64	import org.netbeans.spi.project.ui.support.ProjectActionPerformer;	64	import org.netbeans.spi.project.ui.support.ProjectActionPerformer;
65	import org.openide.DialogDescriptor;	65	import org.openide.DialogDescriptor;
66	import org.openide.DialogDisplayer;	66	import org.openide.DialogDisplayer;
Lines 155-169 Link Here
155	}	155	}
156		156
157	if ( command != null ) {	157	if ( command != null ) {
158	ActionProvider ap = p.getLookup().lookup(ActionProvider.class);	158	Callable<Boolean> task = ProjectActions.prepare(p, command, Lookup.EMPTY);
159	if (ap != null) {	159	if (task != null) {
160	if (Arrays.asList(ap.getSupportedActions()).contains(command)) {	160	ActionsUtil.RP.submit(task);
161	ap.invokeAction(command, Lookup.EMPTY);	161	} else {
162	} else {	162	// #47160: was a supported command (e.g. on a freeform project) but was then removed.
163	// #47160: was a supported command (e.g. on a freeform project) but was then removed.	163	Toolkit.getDefaultToolkit().beep();
164	Toolkit.getDefaultToolkit().beep();	164	refreshView(null, false);
165	refreshView(null, false);
166	}
167	}	165	}
168	}	166	}
169	else {	167	else {

Lines 49-56 Link Here

(-)a/projectuiapi/src/org/netbeans/spi/project/ui/support/FileSensitiveActions.java (-4 / +5 lines)
49	import javax.swing.Icon;	49	import javax.swing.Icon;
50	import org.netbeans.api.annotations.common.NonNull;	50	import org.netbeans.api.annotations.common.NonNull;
51	import org.netbeans.api.annotations.common.NullAllowed;	51	import org.netbeans.api.annotations.common.NullAllowed;
		52	import org.netbeans.api.project.ProjectActions;
52	import org.netbeans.modules.project.uiapi.Utilities;	53	import org.netbeans.modules.project.uiapi.Utilities;
53	import org.netbeans.spi.project.ActionProvider;	54	import org.netbeans.spi.project.ActionProvider2;
54		55
55	/**	56	/**
56	* Factory for creating file-sensitive actions.	57	* Factory for creating file-sensitive actions.
Lines 62-72 Link Here
62		63
63	/**	64	/**
64	* Creates an action sensitive to the set of currently selected files.	65	* Creates an action sensitive to the set of currently selected files.
65	* When performed the action will call the given command on the {@link ActionProvider} of	66	* When performed the action will call the given command using {@link ProjectActions} on
66	* the selected project(s) and pass the proper context to it. Enablement of the	67	* the selected project(s) and pass the proper context to it. Enablement of the
67	* action depends on the behavior of the project's action provider.	68	* action depends on the behavior of the project's action provider.
68	* <p>As mentioned in {@link ActionProvider} Javadoc, the action may also be enabled	69	* <p>As mentioned in {@link ProjectActions} Javadoc, the action may also be enabled
69	* without the participation of any project in case some globally registered {@link ActionProvider}	70	* without the participation of any project in case some globally registered {@link ActionProvider2}
70	* can provide an implementation.	71	* can provide an implementation.
71	* (This since {@code org.netbeans.modules.projectuiapi/1 1.37}.)	72	* (This since {@code org.netbeans.modules.projectuiapi/1 1.37}.)
72	* <p>Shortcuts for actions are shared according to command, i.e. actions based on the same command	73	* <p>Shortcuts for actions are shared according to command, i.e. actions based on the same command