<change id="BaseActionProvider-mainClass">

            <api name="java-api-common"/>

            <summary>Possibility to override main class check and main class selection</summary>

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

            <date day="4" month="11" year="2013"/>

            <author login="tzezula"/>

            <compatibility addition="yes"/>

            <description>

                <p>

                   Added possibility to override main class check and main class selection.

                </p>

            </description>

            <class package="org.netbeans.modules.java.api.common.project" name="BaseActionProvider"/>

        </change>

     * Returns the project's {@link JavaPlatform}.

     * @return the project's {@link JavaPlatform} or null when project's

     * {@link JavaPlatform} is broken.

     * @since 1.66

     */

    @CheckForNull

    protected JavaPlatform getProjectPlatform() {

        return CommonProjectUtils.getActivePlatform(evaluator.getProperty(ProjectProperties.PLATFORM_ACTIVE));

    }

    /**

    /**

     * Gets the project main class to be executed.

     * @param verify if true the java checks should be performed

     * and the main class should be returned only if it's valid

     * @return the main class

     * @since 1.66

     */

    @CheckForNull

    protected String getProjectMainClass(final boolean verify) {

        final String mainClass = evaluator.getProperty(ProjectProperties.MAIN_CLASS);

        // support for unit testing

        if (MainClassChooser.unitTestingSupport_hasMainMethodResult != null) {

            return MainClassChooser.unitTestingSupport_hasMainMethodResult ?

                mainClass :

                null;

        }

        if (mainClass == null || mainClass.length () == 0) {

            LOG.fine("Main class is not set");    //NOI18N

            return null;

        }

        if (!verify) {

            return mainClass;

        }

        final FileObject[] sourcesRoots = projectSourceRoots.getRoots();

        if (sourcesRoots.length > 0) {

            LOG.log(Level.FINE, "Searching main class {0} for root: {1}",   //NOI18N

                    new Object[] {

                        mainClass,

                        FileUtil.getFileDisplayName(sourcesRoots[0])

            });

            ClassPath bootPath = null, compilePath = null;

            try {

                bootPath = ClassPath.getClassPath (sourcesRoots[0], ClassPath.BOOT);        //Single compilation unit

                assert bootPath != null : assertPath (

                        sourcesRoots[0],

                        sourcesRoots,

                        projectSourceRoots,

                        ClassPath.BOOT);

            } catch (AssertionError e) {

                //Log the assertion when -ea

                Exceptions.printStackTrace(e);

            }

            try {

                compilePath = ClassPath.getClassPath (sourcesRoots[0], ClassPath.EXECUTE);

                assert compilePath != null : assertPath (

                        sourcesRoots[0],

                        sourcesRoots,

                        projectSourceRoots,

                        ClassPath.EXECUTE);

            } catch (AssertionError e) {

                //Log the assertion when -ea

                Exceptions.printStackTrace(e);

            }

            //todo: The J2SEActionProvider does not require the sourceRoots, it can take the classpath

            //from ClassPathProvider everytime. But the assertions above are important, it seems that

            //the SimpleFileOwnerQueryImplementation is broken in some cases. When assertions are enabled

            //log the data.

            if (bootPath == null) {

                LOG.fine("Source root has no boot classpath, using project boot classpath.");   //NOI18N

                bootPath = callback.getProjectSourcesClassPath(ClassPath.BOOT);

            }

            if (compilePath == null) {

                LOG.fine("Source root has no execute classpath, using project execute classpath.");   //NOI18N

                compilePath = callback.getProjectSourcesClassPath(ClassPath.EXECUTE);

            }

            ClassPath sourcePath = ClassPath.getClassPath(sourcesRoots[0], ClassPath.SOURCE);

            LOG.log(Level.FINE, "Classpaths used to resolve main boot: {0}, exec: {1}, src: {2}",   //NOI18N

                    new Object[]{

                        bootPath,

                        compilePath,

                        sourcePath

            });

            if (CommonProjectUtils.isMainClass (mainClass, bootPath, compilePath, sourcePath)) {

                return mainClass;

            }

        } else {

            LOG.log(Level.FINE, "Searching main class {0} without source root", mainClass);  //NOI18N

            ClassPath bootPath = callback.getProjectSourcesClassPath(ClassPath.BOOT);

            ClassPath compilePath = callback.getProjectSourcesClassPath(ClassPath.EXECUTE);

            ClassPath sourcePath = callback.getProjectSourcesClassPath(ClassPath.SOURCE);   //Empty ClassPath

            LOG.log(Level.FINE, "Classpaths used to resolve main boot: {0}, exec: {1}, src: {2}",   //NOI18N

                    new Object[]{

                        bootPath,

                        compilePath,

                        sourcePath

            });

            if (CommonProjectUtils.isMainClass (mainClass, bootPath, compilePath, sourcePath)) {

                return mainClass;

            }

        }

        LOG.log(Level.FINE, "Main class {0} is invalid.", mainClass);   //NOI18N

        return null;

    }

    private String assertPath (

            FileObject          fileObject,

            FileObject[]        expectedRoots,

            SourceRoots         roots,

            String              pathType) {

        final StringBuilder sb = new StringBuilder ();

        sb.append ("File: ").append (fileObject);                                                                       //NOI18N

        sb.append ("\nPath Type: ").append (pathType);                                                                  //NOI18N

        final Project owner = FileOwnerQuery.getOwner(fileObject);

        sb.append ("\nOwner: ").append (owner == null ? "" : ProjectUtils.getInformation(owner).getDisplayName());      //NOI18N

        sb.append ("\nClassPathProviders: ");                                                                           //NOI18N

        for (ClassPathProvider impl  : Lookup.getDefault ().lookupResult (ClassPathProvider.class).allInstances ())

            sb.append ("\n  ").append (impl);                                                                           //NOI18N

        sb.append ("\nProject SourceGroups:");                                                                          //NOI18N

        final SourceGroup[] sgs =  ProjectUtils.getSources(this.project).getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);

        for (SourceGroup sg : sgs) {

            sb.append("\n  ").append(FileUtil.getFileDisplayName(sg.getRootFolder()));                                  //NOI18N

        }

        sb.append ("\nProject Source Roots(");                                                                          //NOI18N

        sb.append(System.identityHashCode(roots));

        sb.append("):");                                                                                                //NOI18N

        for (FileObject expectedRoot : expectedRoots) {

            sb.append("\n  ").append(FileUtil.getFileDisplayName(expectedRoot));                                        //NOI18N

        }

        return sb.toString ();

    }

    /**

     * Shows a selector of project main class.

     * @return true if main class was selected, false when project execution was canceled.

     * @since 1.66

     */

    @Messages({

        "LBL_MainClassWarning_ChooseMainClass_OK=OK",

        "AD_MainClassWarning_ChooseMainClass_OK=N/A",

        "# {0} - project name", "LBL_MainClassNotFound=Project {0} does not have a main class set.",

        "# {0} - name of class", "# {1} - project name", "LBL_MainClassWrong={0} class wasn''t found in {1} project.",

        "CTL_MainClassWarning_Title=Run Project"

        })

    protected boolean showMainClassSelector() {

        boolean result = false;

        final JButton okButton = new JButton(LBL_MainClassWarning_ChooseMainClass_OK());

        okButton.getAccessibleContext().setAccessibleDescription(AD_MainClassWarning_ChooseMainClass_OK());        

        // main class goes wrong => warning

        String mainClass = getProjectMainClass(false);

        String message;

        if (mainClass == null) {

            message = LBL_MainClassNotFound(ProjectUtils.getInformation(project).getDisplayName());

        } else {

            message = LBL_MainClassWrong(

                mainClass,

                ProjectUtils.getInformation(project).getDisplayName());

        }

        final MainClassWarning panel = new MainClassWarning (message, projectSourceRoots.getRoots());

        Object[] options = new Object[] {

            okButton,

            DialogDescriptor.CANCEL_OPTION

        };

        panel.addChangeListener (new ChangeListener () {

            @Override

           public void stateChanged (ChangeEvent e) {

               if (e.getSource () instanceof MouseEvent && MouseUtils.isDoubleClick (((MouseEvent)e.getSource ()))) {

                   // click button and the finish dialog with selected class

                   okButton.doClick ();

               } else {

                   okButton.setEnabled (panel.getSelectedMainClass () != null);

               }

           }

        });

        okButton.setEnabled (false);

        DialogDescriptor desc = new DialogDescriptor (panel,

            CTL_MainClassWarning_Title(),

            true, options, options[0], DialogDescriptor.BOTTOM_ALIGN, null, null);

        desc.setMessageType (DialogDescriptor.INFORMATION_MESSAGE);

        Dialog dlg = DialogDisplayer.getDefault ().createDialog (desc);

        dlg.setVisible (true);

        if (desc.getValue() == options[0]) {

            mainClass = panel.getSelectedMainClass ();

            String config = evaluator.getProperty(ProjectProperties.PROP_PROJECT_CONFIGURATION_CONFIG);

            String path;

            if (config == null || config.length() == 0) {

                path = AntProjectHelper.PROJECT_PROPERTIES_PATH;

            } else {

                // Set main class for a particular config only.

                path = "nbproject/configs/" + config + ".properties"; // NOI18N

            }

            final EditableProperties ep = updateHelper.getProperties(path);

            ep.put(ProjectProperties.MAIN_CLASS, mainClass == null ? "" : mainClass);

            try {

                if (updateHelper.requestUpdate()) {

                    updateHelper.putProperties(path, ep);

                    ProjectManager.getDefault().saveProject(project);

                    result = true;

                }

            } catch (IOException ioe) {

                ErrorManager.getDefault().log(ErrorManager.INFORMATIONAL, "Error while saving project: " + ioe);

            }

        }

        dlg.dispose();

        return result;

    }